code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
# [QuickHTML](https://github.com/ckc-dev/QuickHTML)
A simple Markdown to HTML preprocessor that doesn't require any third-party modules.
Quickly generate HTML from Markdown, using Python.
## Technologies used
- Python
- RegEx
## Table of contents
- [QuickHTML](#quickhtml)
- [Technologies used](#technologies-use... | /quickhtml-2.0.17.tar.gz/quickhtml-2.0.17/README.md | 0.729231 | 0.938407 | README.md | pypi |
from untwisted.event import TIMEOUT, DONE, ACCEPT, CLOSE, \
CONNECT, CONNECT_ERR, LOAD, DUMPED
from untwisted.splits import Terminator, Fixed
from untwisted.network import SuperSocket
from untwisted.client import Client, lose
from untwisted.dispatcher import Dispatcher
from untwisted.sock_writer import SockWriter
from ... | /quickirc-1.2.0.tar.gz/quickirc-1.2.0/quickirc.py | 0.431584 | 0.156298 | quickirc.py | pypi |
import typing as t
cjson_loaded = False
try:
import cjson
cjson_loaded = True
except ImportError:
try:
import json
except ImportError:
try:
import simplejson as json
except ImportError:
raise ImportError('cjson, json or simplejson required')
import rando... | /quickjsonrpc-0.4.0.tar.gz/quickjsonrpc-0.4.0/fastjsonrpc/jsonrpc.py | 0.491212 | 0.159087 | jsonrpc.py | pypi |
import typing as t
from twisted.protocols import basic
from twisted.python import log
from twisted.internet.protocol import Factory
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ClientEndpoint
from twisted.internet.defer import Deferred
from fastjsonrpc import jsonrpc
class Callbac... | /quickjsonrpc-0.4.0.tar.gz/quickjsonrpc-0.4.0/fastjsonrpc/netstringclient.py | 0.605682 | 0.155784 | netstringclient.py | pypi |
import os
import shutil
import DuckDuckGoImages as ddg
import tensorflow_hub as hub
from tensorflow.nn import softmax
from tensorflow.keras import layers
from tensorflow.keras import losses
from tensorflow.keras import optimizers
from tensorflow.keras import Sequential
from tensorflow.keras.preprocessing.image import I... | /classification/image/automodel.py | 0.59514 | 0.343589 | automodel.py | pypi |
import os
from tqdm.auto import tqdm
from joblib import Parallel, delayed
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras import layers
from tensorflow.keras import losses
from tensorflow.keras import optimizers
from tensorflow.keras import Sequential
from tensorflow.keras.preprocessing.imag... | /classification/image/quick.py | 0.674265 | 0.365032 | quick.py | pypi |
import io
import os
import shutil
import logging
import requests
import numpy as np
from PIL import Image
import tensorflow as tf
from quicklearning.classification.image import create_folder
from quicklearning.classification.image import disable_tensorflow_warnings
def load_tf_lite_model(model_file="model.tflite", la... | /classification/image/lite.py | 0.465145 | 0.2227 | lite.py | pypi |
import io
import os
import shutil
import logging
import requests
import numpy as np
from PIL import Image
import DuckDuckGoImages as ddg
import tensorflow as tf
import tensorflow_hub as hub
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from quicklearning.classification.image import plot
from qui... | /classification/image/model.py | 0.682574 | 0.357091 | model.py | pypi |
The quickly DOM
===============
.. py:currentmodule:: quickly.dom
A central part of the *quickly* package is the DOM (Document Object Model) it
provides. Targeted mainly at LilyPond and Scheme, it can build a tree structure
of almost any structured textual language. The object model is simple and
builds on a tree str... | /quickly-0.7.0.tar.gz/quickly-0.7.0/docs/source/quicklydom.rst | 0.898112 | 0.658678 | quicklydom.rst | pypi |
<h6 align="center">
<img src="https://img.icons8.com/ios-glyphs/344/audio-skimming.png" alt="LyricsPy" height="250px">
<h5 align="center">Powerful Library To Search Music Lyrics</h5>
</h6>
## Installation
QuickLyrics can be installed using pip from PyPI or from GitHub
#### via PyPI using pip
... | /quicklyrics-1.0.8.tar.gz/quicklyrics-1.0.8/README.md | 0.516595 | 0.801159 | README.md | pypi |
import logging
import seamm
import pprint # noqa: F401
logger = logging.getLogger(__name__)
class QuickMinParameters(seamm.Parameters):
"""
The control parameters for QuickMin.
The developer will add a dictionary of Parameters to this class.
The keys are parameters for the current plugin, which the... | /quickmin_step-2023.1.14.tar.gz/quickmin_step-2023.1.14/quickmin_step/quickmin_parameters.py | 0.808786 | 0.488405 | quickmin_parameters.py | pypi |
metadata = {}
"""Properties that QuickMin produces.
`metadata["results"]` describes the results that this step can produce. It is a
dictionary where the keys are the internal names of the results within this step, and
the values are a dictionary describing the result. For example::
metadata["results"] = {
... | /quickmin_step-2023.1.14.tar.gz/quickmin_step-2023.1.14/quickmin_step/metadata.py | 0.891684 | 0.616936 | metadata.py | pypi |
import quickmin_step
class QuickMinStep(object):
"""Helper class needed for the stevedore integration.
This must provide a `description()` method that returns a dict containing a
description of this node, and `create_node()` and `create_tk_node()` methods
for creating the graphical and non-graphical... | /quickmin_step-2023.1.14.tar.gz/quickmin_step-2023.1.14/quickmin_step/quickmin_step.py | 0.878438 | 0.682771 | quickmin_step.py | pypi |
import tensorflow as tf
import numpy as np
import pandas as pd
from functools import partial
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from qnn_config import TF_SAVER, logdir
class QuickNN:
"""
An implementation of Feedforward Neural Networks for quick ap... | /quicknn-1.0.9.tar.gz/quicknn-1.0.9/quicknn.py | 0.912733 | 0.597021 | quicknn.py | pypi |
from __future__ import absolute_import, division, print_function
__metaclass__ = type
import codecs
from ops.utils.text.__init__ import (
PY3,
binary_type,
text_type,
)
try:
codecs.lookup_error('surrogateescape')
HAS_SURROGATEESCAPE = True
except LookupError:
HAS_SURROGATEESCAPE = False
_CO... | /quickops-1.1.2-py3-none-any.whl/ops/utils/text/converters.py | 0.638948 | 0.156588 | converters.py | pypi |
import numpy as np
FLOATS=[np.float64,np.float32,np.float16,float,np.half]
INTS=[np.int64,np.int32,np.int16,np.int8]
STRS=[str,np.object,object]
COLORS={
'CSS':(147,['black', 'dimgray', 'dimgrey', 'gray', 'grey', 'darkgray', 'darkgrey', 'silver', 'lightgray', 'lightgrey', 'gainsboro', 'whitesmoke', 'snow', 'rosybr... | /quickpanda_aidroid-0.0.1-py3-none-any.whl/hyper.py | 0.605799 | 0.264068 | hyper.py | pypi |
import sys
import argparse
import numpy as np
import nibabel as nb
import logging
try:
from due import due, BibTeX
except ImportError:
# Adapted from
# https://github.com/duecredit/duecredit/blob/2221bfd/duecredit/stub.py
class InactiveDueCreditCollector(object):
"""Just a stub at the Collector... | /quickshear-1.2.0.tar.gz/quickshear-1.2.0/quickshear.py | 0.676513 | 0.548734 | quickshear.py | pypi |
# Quick-Show
[](code_of_conduct.md)
[](https://doi.org/10.5281/zenodo.1246809)
This is a very basic but very fast window discriminator for detecting and
extracting spikes in a time series. It was developed for analyzing extracellular
neural recordings, but also works with in... | /quickspikes-2.0.1.tar.gz/quickspikes-2.0.1/README.md | 0.867724 | 0.98249 | README.md | pypi |
import numpy as nx
def spike_times(x, spike_thresh=5, dt=0.02, peak_window=1.5, **kwargs):
""" Detect spikes in a signal
Returns an array of times corresponding to the peaks in the signal that were
above spike_thresh.
- x : signal to analyze
- spike_thresh: the threshold for the detector
- d... | /quickspikes-2.0.1.tar.gz/quickspikes-2.0.1/f2py/spikes.py | 0.894427 | 0.885582 | spikes.py | pypi |
from click import style, echo
from typing import List, Dict
from terminaltables import SingleTable
from click import echo
DEFAULT_EMPTY_DATA_MESSAGE = """
No data to display.
"""
class Printer(SingleTable):
"""
Handles printing a list of json objects.
TODO:
- validate that all items in the data ha... | /quicksplit-1.4.tar.gz/quicksplit-1.4/cli/printers.py | 0.405096 | 0.251211 | printers.py | pypi |
from .. import requirePackage
Image = requirePackage("PIL", "Image")
def transport_back(
src: str, to_color: tuple, from_color: tuple = (0, 0, 0, 0)
) -> Image.Image:
"""
图片颜色替换
Image color replacement
:param src: 图片路径
:param to_color: RGBA四元组 -> 转换至目标颜色
:param from_color: RGBA四元组 -> 需要... | /quickstart_rhy-0.7.4-py3-none-any.whl/QuickStart_Rhy/ImageTools/ColorTools.py | 0.499756 | 0.45048 | ColorTools.py | pypi |
from PIL import Image
from .. import requirePackage
def is_svg(imgPath: str):
"""
判断图片是否为svg格式
check if the image is svg
:param imgPath: 图片路径 | image path
:return:
"""
return imgPath.endswith(".svg") or imgPath.endswith('.svgz')
def is_eps(imgPath: str):
"""
判断图片是否为eps格式
c... | /quickstart_rhy-0.7.4-py3-none-any.whl/QuickStart_Rhy/ImageTools/ImageTools.py | 0.447943 | 0.501282 | ImageTools.py | pypi |
from . import pre_check, user_lang
from .. import requirePackage
class QiniuOSS:
qiniu = requirePackage("qiniu")
def __init__(
self,
ac_key: str = None,
sc_key: str = None,
df_bucket: str = None,
):
"""
初始化并登陆七牛云对象存储
Initializes and logs in qiniu c... | /quickstart_rhy-0.7.4-py3-none-any.whl/QuickStart_Rhy/API/QiniuOSS.py | 0.446012 | 0.185025 | QiniuOSS.py | pypi |
import threading
from concurrent.futures import ThreadPoolExecutor, wait
class ThreadFunctionWrapper(threading.Thread):
def __init__(self, function, *args, **kwargs):
"""
开辟子线程执行任务（初始化）
Create child threads to perform tasks (initialization)
:param function: 函数
:param args... | /quickstart_rhy-0.7.4-py3-none-any.whl/QuickStart_Rhy/ThreadTools/__init__.py | 0.537284 | 0.298651 | __init__.py | pypi |
<!--
<p align="center">
<img src="https://github.com/cthoyt/quickstatements-client/raw/main/docs/source/logo.png" height="150">
</p>
-->
<h1 align="center">
QuickStatements Client
</h1>
<p align="center">
<a href="https://github.com/cthoyt/quickstatements_client/actions/workflows/tests.yml">
<img alt=... | /quickstatements_client-0.0.3.tar.gz/quickstatements_client-0.0.3/README.md | 0.412175 | 0.89077 | README.md | pypi |
import webbrowser
from typing import Optional, Sequence
import pystow
import requests
from pydantic import BaseModel, Field
from typing_extensions import Literal
from quickstatements_client.model import Line, lines_to_url, render_lines
__all__ = [
"QuickStatementsClient",
"Post",
"Response",
]
class Re... | /quickstatements_client-0.0.3.tar.gz/quickstatements_client-0.0.3/src/quickstatements_client/client.py | 0.926885 | 0.236109 | client.py | pypi |
import json
import logging
from functools import lru_cache
from pathlib import Path
from typing import Iterable, Mapping, Optional, Sequence
import requests
from quickstatements_client.model import (
CreateLine,
DateQualifier,
EntityLine,
EntityQualifier,
Line,
TextLine,
TextQualifier,
... | /quickstatements_client-0.0.3.tar.gz/quickstatements_client-0.0.3/src/quickstatements_client/sources/pypi.py | 0.771413 | 0.212436 | pypi.py | pypi |
import grpc
import pandas as pd
import proto.NetworkCli_pb2 as NetworkCli_pb2
import proto.NetworkCli_pb2_grpc as NetworkCli_pb2_grpc
def sql_to_table(query):
"""Runs an SQL query on the quickstep database.
Runs the passed SQL query on the quickstep database set in quickstepIP and quickstepPort
and returns th... | /quickstep-0.0.8.tar.gz/quickstep-0.0.8/quickstep.py | 0.724578 | 0.710663 | quickstep.py | pypi |
# QuickStruct
QuickStruct is a small library written in Python that allows you to
easily create C structs (and a bit more dynamic stuff) in Python!
It's fairly easy to use
```py
from quickstruct import *
class Person(DataStruct):
name: String
age: i8
```
Structs can also be composed
```py
class TeachingCla... | /quickstruct-0.2.1.tar.gz/quickstruct-0.2.1/README.md | 0.531453 | 0.89382 | README.md | pypi |
__version__ = '2.1'
import argparse
import subprocess
import os
import re
try:
import i3
except ImportError:
print("quickswitch requires i3-py.")
print("You can install it from the PyPI with ``pip install i3-py''.")
exit(1)
def check_dmenu():
'''Check if dmenu is available.'''
try:
... | /quickswitch-i3-2.1.tar.gz/quickswitch-i3-2.1/quickswitch.py | 0.479991 | 0.153962 | quickswitch.py | pypi |
[**NEW: v.1.4 supports starting multiple QuickUMLS matchers concurrently!**](https://giphy.com/embed/BlVnrxJgTGsUw) I've finally added support for [unqlite](https://github.com/coleifer/unqlite-python) as an alternative to leveldb for storage of CUIs and Semantic Types (see [here](https://github.com/Georgetown-IR-Lab/Qu... | /quickumls-1.4.1.tar.gz/quickumls-1.4.1/README.md | 0.480235 | 0.937726 | README.md | pypi |
from bson import ObjectId
from .quicly_mongo_client import QuiclyMongoClient
class QuiclyMongoModel(object):
def __init__(self, mongo_client, collection_name, pk_name='_id', ex_field_names=None, **kw):
assert isinstance(mongo_client, QuiclyMongoClient)
assert isinstance(collection_name, str)
... | /quicly-mongo-0.0.2.tar.gz/quicly-mongo-0.0.2/quicly_mongo/quicly_mongo_model.py | 0.731826 | 0.17485 | quicly_mongo_model.py | pypi |
from __future__ import annotations
import os.path as osp
from collections import deque
from random import randint, sample
from typing import List, Optional, Tuple, Union
import networkx as nx
import torch
from torch_geometric.data import Batch as PygBatch
from torch_geometric.data import Data as PygData
from QuICT.c... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/rl_mapping/data_def.py | 0.888402 | 0.369998 | data_def.py | pypi |
import asyncio as aio
from threading import Thread
from time import time
from torch.utils.tensorboard import SummaryWriter
from QuICT_ml.rl_mapping.data_def import TrainConfig
from QuICT_ml.rl_mapping.train.actor import Actor
from QuICT_ml.rl_mapping.train.learner import Learner
from QuICT.tools.logger import Logger... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/rl_mapping/train/train_rl.py | 0.801198 | 0.185984 | train_rl.py | pypi |
from typing import Optional
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch_geometric.nn as gnn
class GnnBlock(nn.Module):
def __init__(
self,
qubit_num: int,
max_gate_num: int,
feat_dim: int,
pool: bool,
) -> None:
super().__ini... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/rl_mapping/net/nn_mapping.py | 0.970198 | 0.416856 | nn_mapping.py | pypi |
import copy
import numpy as np
import torch
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT.tools.exception.core import *
from QuICT_ml.utils import Ansatz
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.tools.exception import *
class Hamiltonian:
"""The Hamiltonian class."""
... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/hamiltonian.py | 0.898928 | 0.507751 | hamiltonian.py | pypi |
import os
import torch
import shutil
import numpy as np
import random
from QuICT.tools.logger import *
from QuICT_ml.tools.exception import *
logger = Logger("ML_utils")
def set_seed(seed: int):
"""Set random seed.
Args:
seed (int): The random seed.
"""
torch.manual_seed(seed)
torch.cu... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/ml_utils.py | 0.835181 | 0.245973 | ml_utils.py | pypi |
import cupy as cp
import numpy as np
import torch
from QuICT.ops.utils import LinAlgLoader
from QuICT.tools.exception.core import *
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.tools.exception import *
class GpuSimulator:
"""A GPU simulator for gradient propagation."""
def __init__(self):
... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/gpu_gate_simulator.py | 0.903814 | 0.564459 | gpu_gate_simulator.py | pypi |
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT_ml.utils import Ansatz
from QuICT_ml.utils.gate_tensor import *
class Qubit:
"""Qubit encoding for encoding classical image data into quantum circuits."""
@property
def circuit(self):
return self._circuit
@property
... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/encoding.py | 0.960184 | 0.622861 | encoding.py | pypi |
import cupy as cp
import random
import numpy as np
import torch
from QuICT.core.gate import *
from QuICT.ops.utils import LinAlgLoader
from QuICT.tools.exception.core import *
from QuICT.tools.logger import *
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.utils import apply_gate
from QuICT_ml.tools.exception ... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/ansatz.py | 0.860838 | 0.434581 | ansatz.py | pypi |
import copy
import numpy as np
import torch
from typing import Union
from QuICT.core.gate import *
from QuICT.core.utils import SPECIAL_GATE_SET, GateType
class BasicGateTensor(object):
"""the abstract SuperClass of all basic tensor quantum gate
All basic quantum gate described in the framework have
som... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/utils/gate_tensor.py | 0.927855 | 0.655074 | gate_tensor.py | pypi |
import torch
import numpy as np
from QuICT.core.gate import CompositeGate, Rz, sqiSwap, X
from QuICT_ml.utils import Ansatz, Rz_tensor, sqiSwap_tensor, X_tensor
class Thouless:
""" Thouless ansatz
Reference:
https://www.sciencedirect.com/science/article/pii/0029558260900481
https://arxiv.org... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/ansatz_library/thouless_ansatz.py | 0.939123 | 0.690598 | thouless_ansatz.py | pypi |
import torch
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT_ml.utils import Ansatz
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.tools.exception import *
class QNNLayer:
"""Initialize a QNNLayer instance."""
def __init__(self, data_qubits, result_qubit, ... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/ansatz_library/QNN_layer.py | 0.894789 | 0.554169 | QNN_layer.py | pypi |
import torch
import torch.nn as nn
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT_ml.ansatz_library import QNNLayer
from QuICT_ml.utils import Ansatz
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.utils.encoding import *
from QuICT_ml.utils import GpuSimulator
from QuICT_ml.tools.exce... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/QNN/mnist_classifier_net.py | 0.935324 | 0.49109 | mnist_classifier_net.py | pypi |
import torch
import numpy as np
from QuICT_ml.ansatz_library import Thouless
from QuICT_ml.utils import GpuSimulator, Hamiltonian
class HartreeFockVQENet(torch.nn.Module):
"""The network used by restricted Hartree-Fock VQE with Thouless ansatz
Reference:
https://arxiv.org/abs/2004.04174
"""
... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQE/hartree_fock_net.py | 0.958635 | 0.577078 | hartree_fock_net.py | pypi |
from .polynomial_operator import PolynomialOperator
class FermionOperator(PolynomialOperator):
"""
A fermion operator is a polynomial of anti-commutative creation-annihilation operators,
which is a useful representation for states and Hamiltonians by second quantization.
Due to the anti-commutation r... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQE/operators/fermion_operator.py | 0.907107 | 0.835986 | fermion_operator.py | pypi |
from .qubit_operator import QubitOperator
class Encoder:
"""
Superclass of encoding methods.
Attributes:
n_orbitals(integer): the number of orbitals
"""
def __init__(self, n_orbitals):
self.n_orbitals = n_orbitals
def encode(self, fermion_operator):
"""
Encode... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQE/operators/encoder.py | 0.948137 | 0.76105 | encoder.py | pypi |
import numpy as np
from .polynomial_operator import PolynomialOperator
class QubitOperator(PolynomialOperator):
"""
A Qubit operator is a polynomial of Pauli matrices {X, Y, Z} = {sigma_1, sigma_2, sigma_3},
which is a useful representation for circuits by second quantization.
In this class, the ope... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQE/operators/qubit_operator.py | 0.889842 | 0.780098 | qubit_operator.py | pypi |
import copy
class PolynomialOperator(object):
"""
A polynomial of symbolic operators.
The superClass of FermionOperator and QubitOperator.
In this class, the operator could be represented as below.
The first parameter in a binary tuple represents the target, while the second one represents the ty... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQE/operators/polynomial_operator.py | 0.899376 | 0.773815 | polynomial_operator.py | pypi |
import torch
import torch.nn
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT_ml.utils import Ansatz, Hamiltonian
from QuICT_ml.utils.gate_tensor import *
from QuICT_ml.model.VQA import VQENet
class QAOANet(VQENet):
"""The network used by QAOA.
The QAOANet implementation directly ext... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQA/qaoa_net.py | 0.885594 | 0.503662 | qaoa_net.py | pypi |
import numpy as np
import torch
from QuICT_ml.utils import GpuSimulator
from QuICT_ml.utils import Hamiltonian
from QuICT_ml.tools.exception import *
class VQENet(torch.nn.Module):
"""Variational Quantum Eigensolver algorithm.
VQE <https://arxiv.org/abs/1304.3061> is a quantum algorithm that uses a variatio... | /quict_ml-0.9.6-py3-none-any.whl/QuICT_ml/model/VQA/vqe_net.py | 0.944196 | 0.638032 | vqe_net.py | pypi |
import cupy as cp
import numpy as np
from cupy import cuda
from cupy.cuda import nccl
from typing import Union
from .timeout import timeout
# Mapping between dtype and nccl dtype
# Modify for cupy>9.0.0
type_mapping = {
"int8": 1,
"uint8": 1,
"int32": 4,
"uint32": 4,
"int64": 8,
"uint64": 8... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/proxy/proxy.py | 0.842928 | 0.351617 | proxy.py | pypi |
from enum import Enum
import multiprocessing as mp
from concurrent.futures import ProcessPoolExecutor, as_completed
import cupy as cp
import numpy as np
from cupy.cuda import nccl
from QuICT.core import Circuit
from QuICT.ops.linalg.gpu_calculator import VectorPermutation
from QuICT_sim.proxy import Proxy
from QuICT... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/multi_nodes/controller.py | 0.750827 | 0.168788 | controller.py | pypi |
import numpy as np
import cupy as cp
from QuICT_sim.operator import DataSwitch, DataSwitchType
class DataSwitcher:
""" A class of data switch functions using by multi-GPU simulator.
Args:
proxy (Proxy): The NCCL Communicator.
qubits (int): The number of qubits.
"""
@property
def ... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/multi_nodes/data_switch.py | 0.880547 | 0.700408 | data_switch.py | pypi |
import random
import cupy as cp
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import BasicGate, GateType
from QuICT.ops.gate_kernel.gate_function import mn_measureprob_calculator
from QuICT.simulation.state_vector import StateVectorSimulator
from QuICT_sim.operator import *
from QuICT_sim.pro... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/multi_nodes/multi_nodes_simulator.py | 0.78609 | 0.498413 | multi_nodes_simulator.py | pypi |
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT_sim.operator import DataSwitch, DataSwitchType, DeviceTrigger, Multiply, SpecialGate
ALL_PENTY = 0.5
HALF_PENTY = 2
CARG_PENTY = 3
PROB_ADD = 1
class Transpile:
""" Transpile the circuit by the number of devices.
Ar... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/multi_nodes/transpile.py | 0.896501 | 0.595787 | transpile.py | pypi |
from collections import defaultdict
import numpy as np
from QuICT.core.gate import Unitary
from QuICT.ops.linalg.cpu_calculator import multiply, dot, tensor, MatrixPermutation
class Optimizer:
""" The quantum circuit optimizer, used to optimize the quantum circuit
before simulation. Currently, it only workin... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/optimization/optimizer.py | 0.886291 | 0.612889 | optimizer.py | pypi |
import warnings
import os
import importlib.util
from typing import List, Union, Iterable, Tuple
import numpy as np
from copy import deepcopy
from QuICT.core import Circuit
from QuICT.core.gate import BasicGate, Measure, GateType
from QuICT.core.operator import Trigger
cur_path = os.path.dirname(os.path.abspath(__fil... | /quict_sim-1.0.0-cp38-cp38-manylinux_2_31_x86_64.whl/QuICT_sim/cpu_simulator/cpu.py | 0.613005 | 0.338214 | cpu.py | pypi |
from QuICT.qcda.synthesis import GateTransform
from QuICT.qcda.optimization import CommutativeOptimization, CliffordRzOptimization
from QuICT.qcda.mapping import MCTSMapping, SABREMapping
from QuICT.tools import Logger
logger = Logger("QCDA")
class QCDA(object):
""" Customize the process of synthesis, optimizat... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/qcda.py | 0.946698 | 0.641142 | qcda.py | pypi |
from typing import Union
from QuICT.core import *
from QuICT.core.gate import CompositeGate
from QuICT.core.gate.gate import *
from QuICT.qcda.utility import OutputAligner
from ..common import CircuitInfo, LayoutInfo
from .mcts_tree import MCTSTree
class MCTSMapping:
def __init__(
self,
layout: ... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/mcts/mcts_mapping.py | 0.885848 | 0.24168 | mcts_mapping.py | pypi |
from __future__ import annotations
import copy
import random
from math import factorial, log, sqrt
from typing import Dict, List, Optional, Tuple
from QuICT.core import *
from QuICT.core.gate.composite_gate import CompositeGate
from ..common import CircuitInfo
from ..common.layout_info import LayoutInfo
class MCTS... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/mcts/mcts_tree_node.py | 0.865437 | 0.362391 | mcts_tree_node.py | pypi |
from typing import Tuple
from QuICT.core import *
from QuICT.core.gate import CompositeGate
from QuICT.core.gate.gate import BasicGate
from ..common import LayoutInfo
from ..common.circuit_info import CircuitInfo
from .mcts_tree_node import MCTSTreeNode
class MCTSTree:
def __init__(
self,
circui... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/mcts/mcts_tree.py | 0.861334 | 0.275416 | mcts_tree.py | pypi |
import copy
from typing import List, Optional
from QuICT.core.layout import Layout
from QuICT.core.gate import *
from QuICT.core.circuit import Circuit
class DAGNode:
"""
DAG representation of a quantum circuit that indicates the commutative
relations between gates.
"""
def __init__(self... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/sabre/sabre.py | 0.848925 | 0.483283 | sabre.py | pypi |
import copy
import random
from typing import Dict, List, Tuple, Union
import networkx as nx
import numpy as np
from QuICT.core import *
from QuICT.core.gate import BasicGate, CompositeGate
class CircuitInfo:
"""DAG Representation of a quantum circuit."""
def __init__(self, circ: Union[Circuit, CompositeGate... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/common/circuit_info.py | 0.796649 | 0.413596 | circuit_info.py | pypi |
import os
from os import path as osp
from typing import Dict, List, Tuple, Union
import networkx as nx
from numba import njit
import numpy as np
from QuICT.core import *
@njit
def _floyd(n: int, dist: np.ndarray, _inf: int) -> np.ndarray:
for i in range(n):
dist[i][i] = 0
for k in range(n):
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/mapping/common/data_factory.py | 0.708112 | 0.204978 | data_factory.py | pypi |
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT.qcda.synthesis.gate_transform.special_set import *
from QuICT.qcda.utility import OutputAligner
class GateTransform(object):
def __init__(self, instruction_set=USTCSet, keep_phase=False):
"""
Args:
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/gate_transform/gate_transform.py | 0.855399 | 0.547222 | gate_transform.py | pypi |
from QuICT.core.gate import GateType
from .transform_rule.one_qubit_gate_rules import *
from .transform_rule.two_qubit_gate_rules import *
class InstructionSet(object):
""" InstructionSet describes a set of gates(expectly to be universal set)
Instruction Set contains gates and some rules, which can be assig... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/gate_transform/instruction_set.py | 0.888302 | 0.661732 | instruction_set.py | pypi |
import numpy as np
from numpy import arccos, linalg
from QuICT.core.gate import *
def _arccos(value):
""" calculate arccos(value)
Args:
value: the cos value
Returns:
float: the corresponding angle
"""
if value < -1:
value = -1
elif value > 1:
value = 1
re... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/gate_transform/transform_rule/one_qubit_gate_rules.py | 0.860076 | 0.63612 | one_qubit_gate_rules.py | pypi |
import numpy as np
from QuICT.core.gate import *
"""
the file describe transform rules between two kinds of 2-qubit gates.
"""
"""
transform CX gate into others
"""
def cx2cy_rule(gate):
targs = gate.cargs + gate.targs
gates = CompositeGate()
with gates:
S & targs[1]
CY & targs
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/gate_transform/transform_rule/two_qubit_gate_rules.py | 0.68941 | 0.525795 | two_qubit_gate_rules.py | pypi |
from numpy import gcd
from QuICT.core import Circuit
from QuICT.core.gate import CompositeGate, X, CX, CCX, Swap
def Inverse(a, N):
""" Inversion of a in (mod N)
Args:
a(int): the parameter a
N(int): the parameter N
"""
for i in range(N):
if i * a % N == 1:
retu... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/arithmetic/vbe/vbe.py | 0.869908 | 0.541954 | vbe.py | pypi |
import numpy as np
from QuICT.core.gate import CompositeGate, CX, CCX, CSwap, X, QFT, IQFT, CU1, U1, CCRz, Phase
def ex_gcd(a, b, arr):
if b == 0:
arr[0] = 1
arr[1] = 0
return a
g = ex_gcd(b, a % b, arr)
t = arr[0]
arr[0] = arr[1]
arr[1] = t - int(a / b) * arr[1]
retur... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/arithmetic/bea/bea.py | 0.608012 | 0.430028 | bea.py | pypi |
from QuICT.core.gate import CX, CCX, CompositeGate, X
def peres_gate(gate_set, a, b, c):
"""
(a, b, c) -> (a, a xor b, a.b xor c)
Args:
a(Qubit): qubit
b(Qubit): qubit
c(Qubit): qubit
"""
with gate_set:
CCX & (a, b, c)
CX & (a, b)
def adder_overflow(gate... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/arithmetic/tmvh/tmvh.py | 0.828488 | 0.565239 | tmvh.py | pypi |
from QuICT.core import Circuit
from QuICT.core.gate import *
from QuICT.algorithm.quantum_algorithm.shor.utility import int2bitwise, mod_reverse
def var_controlled_X(gate_set, controls, target):
"""0 to 2 controlled-X
Args:
controls (list): indices of control qubits
target (int): target
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/arithmetic/hrs/hrs.py | 0.788543 | 0.472805 | hrs.py | pypi |
import copy
import random
import multiprocessing as mp
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import CompositeGate, GateType
from QuICT.qcda.utility import PauliOperator, OutputAligner
class CliffordUnidirectionalSynthesizer(object):
"""
Construct L_1,…,L_n such that C = L_1…... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/clifford/clifford_synthesizer.py | 0.909859 | 0.528351 | clifford_synthesizer.py | pypi |
import numpy as np
from QuICT.core.gate import CompositeGate, CX, Ry, Rz, Unitary
# Magic basis
B = (1.0 / np.sqrt(2)) * np.array([[1, 1j, 0, 0],
[0, 0, 1j, 1],
[0, 0, 1j, -1],
[1, -1j, 0, 0]], dtype=complex)
cl... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/unitary_decomposition/cartan_kak_decomposition.py | 0.737347 | 0.696449 | cartan_kak_decomposition.py | pypi |
import numpy as np
from QuICT.core.gate import CompositeGate, CX, Rx, Rz, Unitary
from .cartan_kak_decomposition import CartanKAKDecomposition
# Magic basis
B = (1.0 / np.sqrt(2)) * np.array([[1, 1j, 0, 0],
[0, 0, 1j, 1],
[0, 0, 1j, -1],
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/unitary_decomposition/cartan_kak_diagonal_decomposition.py | 0.897178 | 0.739352 | cartan_kak_diagonal_decomposition.py | pypi |
from typing import *
import numpy as np
from QuICT.core import *
from QuICT.core.gate import *
from QuICT.core.gate.backend import UniformlyRotation
from .utility import *
class ControlledUnitaryDecomposition(object):
def __init__(self, include_phase_gate: bool = True, recursive_basis: int = 2):
"""
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/unitary_decomposition/controlled_unitary.py | 0.957058 | 0.658706 | controlled_unitary.py | pypi |
from typing import *
import numpy as np
from scipy.linalg import cossin
from QuICT.core import *
from QuICT.core.gate import *
from QuICT.core.gate.backend import UniformlyRotation
from .cartan_kak_decomposition import CartanKAKDecomposition
from .cartan_kak_diagonal_decomposition import CartanKAKDiagonalDecompositio... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/unitary_decomposition/unitary_decomposition.py | 0.936448 | 0.576184 | unitary_decomposition.py | pypi |
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import CompositeGate, GateType, GPhase, X, CX, Ry, Rz
from QuICT.core.gate.backend import MCTWithoutAux, UniformlyRotation
from QuICT.qcda.synthesis.unitary_decomposition import UnitaryDecomposition
from QuICT.simulation.state_vector import StateVe... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/synthesis/quantum_state_preparation/quantum_state_preparation.py | 0.925961 | 0.714167 | quantum_state_preparation.py | pypi |
import copy
import random
import itertools
import numpy as np
from QuICT.core.gate import build_gate, BasicGate, CompositeGate, GateType, PAULI_GATE_SET, CX, H
class PauliOperator(object):
"""
Pauli operator is a list of (I, X, Y, Z) with length n, which operates on n qubits.
In this class, we use a li... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/utility/pauli_operator.py | 0.443118 | 0.505981 | pauli_operator.py | pypi |
from functools import wraps
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import CompositeGate
class OutputAligner(object):
"""
Decorating class that keeps the type of output aligned with that of input for QCDA execute functions
Valid type of output are restricted to be Composi... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/utility/utility.py | 0.885953 | 0.577614 | utility.py | pypi |
from itertools import combinations
from .cnot_force import CnotForceBfs
from .cnot_store_force import CnotStoreForceBfs
from QuICT.core import Circuit
from QuICT.core.gate import CX, GateType
from QuICT.qcda.utility import OutputAligner
class CnotLocalForceBfs(object):
"""
use bfs to optimize the cnot circu... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_local_force/cnot_local_force.py | 0.862062 | 0.309937 | cnot_local_force.py | pypi |
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import CX, GateType
from QuICT.qcda.utility import OutputAligner
from QuICT.qcda.optimization.cnot_local_force.utility.utility import apply_cx, path
class CnotForceBfs(object):
"""
use bfs to optimize the cnot circuit
"""
@Output... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_local_force/cnot_force.py | 0.761272 | 0.32752 | cnot_force.py | pypi |
from itertools import combinations
from .cnot_force_depth import CnotForceDepthBfs
from .cnot_store_force_depth import CnotStoreForceDepthBfs
from QuICT.core import Circuit
from QuICT.core.gate import CX, GateType
from QuICT.qcda.utility import OutputAligner
class CnotLocalForceDepthBfs(object):
"""
use bfs... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_local_force/cnot_local_force_depth.py | 0.857887 | 0.319652 | cnot_local_force_depth.py | pypi |
import numpy as np
from QuICT.core import *
from QuICT.core.gate import CX, GateType
from QuICT.qcda.utility import OutputAligner
from QuICT.qcda.optimization.cnot_local_force.utility.utility import apply_cx, generate_layer
class CnotForceDepthBfs(object):
"""
use bfs to optimize the cnot circuit
"""
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_local_force/cnot_force_depth.py | 0.746416 | 0.323915 | cnot_force_depth.py | pypi |
import itertools
import random
import numpy as np
from QuICT.core import Circuit
from QuICT.core.gate import (CX, CY, CZ, CompositeGate, GateType, H, S,
S_dagger, X, Z)
from QuICT.qcda.optimization.commutative_optimization import \
CommutativeOptimization
from QuICT.qcda.synthesis.gat... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/symbolic_clifford_optimization/symbolic_clifford_optimization.py | 0.833325 | 0.513181 | symbolic_clifford_optimization.py | pypi |
from typing import *
import numpy as np
from QuICT.core import *
from QuICT.core.gate import build_gate, BasicGate, CompositeGate, GateType
from QuICT.qcda.utility import OutputAligner
from .utility import *
from .graph import *
from .edge_coloring import EdgeColoring
from .block_ldu_decompose import BlockLDUDecompos... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_without_ancilla/cnot_without_ancilla.py | 0.893507 | 0.413181 | cnot_without_ancilla.py | pypi |
from typing import *
import numpy as np
from .utility import *
class BlockLDUDecompose:
@classmethod
def remapping_select(cls, mat_: np.ndarray) \
-> List[int]:
"""
Select some rows out of a square matrix to get a full-ranked sub-matrix.
Args:
mat_(np.ndarray)... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_without_ancilla/block_ldu_decompose.py | 0.865821 | 0.551513 | block_ldu_decompose.py | pypi |
from typing import *
import numpy as np
class Merged:
"""
Merged points in heap
Attributes:
deg(int) : degree of x
nodes(List[int]) : node indices in a bipartite
"""
def __init__(self, deg: int, nodes: List[int]):
"""
Get a merged point
Args:
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_without_ancilla/utility.py | 0.942002 | 0.810666 | utility.py | pypi |
import copy
from typing import *
class Edge:
"""
A simple container for edges in a graph
Attributes:
start(int) : start point of the edge
end(int) : end point of the edge
valid(bool) : attribute of the edge indicating whether it's valid
color(int) : color of the edge
... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_without_ancilla/graph.py | 0.934343 | 0.767537 | graph.py | pypi |
from typing import Iterable, List
from QuICT.core import Circuit
from QuICT.tools.circuit_library.circuitlib import CircuitLib
from QuICT.qcda.optimization.template_optimization.template_matching.template_matching import (
MatchingDAGCircuit, TemplateMatching)
from QuICT.qcda.optimization.template_optimization.tem... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/template_optimization/template_optimization.py | 0.945096 | 0.540621 | template_optimization.py | pypi |
import itertools
from typing import List
from .backward_match import BackwardMatch
from .forward_match import ForwardMatch
from .matching_dag_circuit import Match, MatchingDAGCircuit
class TemplateMatching:
"""
[1] Iten, R., Moyard, R., Metger, T., Sutter, D. and Woerner, S., 2020.
Exact and practical pa... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/template_optimization/template_matching/template_matching.py | 0.90511 | 0.517205 | template_matching.py | pypi |
from collections import namedtuple
from functools import cached_property
from typing import List, Set
try:
from collections.abc import Iterable
except ImportError:
from collections import Iterable
from QuICT.core import Circuit
from QuICT.core.circuit.dag_circuit import DAGCircuit, DAGNode
from QuICT.core.gat... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/template_optimization/template_matching/matching_dag_circuit.py | 0.933012 | 0.472197 | matching_dag_circuit.py | pypi |
import numpy as np
from QuICT.core.gate import *
from QuICT.qcda.utility import OutputAligner
# Categories of combination
elimination = [
GateType.h, GateType.x, GateType.y, GateType.z, GateType.cx, GateType.hy,
GateType.cy, GateType.cz, GateType.ch, GateType.ccx, GateType.swap
]
addition = [
GateType.u1,... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/commutative_optimization/commutative_optimization.py | 0.705785 | 0.795181 | commutative_optimization.py | pypi |
import numpy as np
class SymbolicPhaseVariable:
"""
Symbolic phase variable.
"""
__slots__ = ['phase', 'label']
def __init__(self, label):
self.phase = None
self.label = label
def __rmul__(self, other):
ret = SymbolicPhase()
if isinstance(other, float) or isin... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/clifford_rz_optimization/symbolic_phase.py | 0.848109 | 0.316 | symbolic_phase.py | pypi |
from typing import Dict, List, Tuple
from QuICT.core import *
from QuICT.core.gate import *
from .dag import DAG
class OptimizingTemplate:
"""
Circuit template used in AutoOptimization.
"""
def __init__(self, template: DAG, replacement: DAG = None,
anchor: int = 0, weight: int = 1, ... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/clifford_rz_optimization/template.py | 0.944944 | 0.665115 | template.py | pypi |
from itertools import chain
from math import log2
from QuICT.core import *
from QuICT.core.gate import *
class PhasePolynomial:
"""
Phase polynomial representation of a quantum circuit that only contains
X, CX and Rz gates.
"""
def __init__(self, gates):
"""
Create a phase polynom... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/clifford_rz_optimization/phase_poly.py | 0.918261 | 0.698407 | phase_poly.py | pypi |
from math import log2, ceil, floor, sqrt
from typing import Union
import numpy as np
from QuICT.core import *
from QuICT.core.gate import CX, CompositeGate, GateType
from QuICT.qcda.utility import OutputAligner
from QuICT.tools.exception.core import ValueError, CircuitAppendError
class CnotAncilla(object):
"""... | /quict-1.0.0-1-py3-none-any.whl/QuICT/qcda/optimization/cnot_ancilla/cnot_ancilla.py | 0.912558 | 0.645595 | cnot_ancilla.py | pypi |
import numpy as np
from typing import Union
from QuICT.core import Circuit
from QuICT.core.noise import NoiseModel
from QuICT.simulation.state_vector import StateVectorSimulator
from QuICT.simulation.unitary import UnitarySimulator
from QuICT.simulation.density_matrix import DensityMatrixSimulator
from QuICT.simulatio... | /quict-1.0.0-1-py3-none-any.whl/QuICT/simulation/simulator.py | 0.925365 | 0.690021 | simulator.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.