Saravanan666/pypi-org huggingface dataset:
Package: dolomite-mae
Save and loadMultiAssayExperimentsin PythonIntroductionThedolomite-maepackage is the Python counterpart to thealabaster.maeR package,
providing methods for saving/readingMultiAssayExperimentobjects within thedolomiteframework.
All components of theMultiAssayExperiment- column_data, sample map and experiments - are saved to their respective file representations,
which can be loaded in a new R/Python environment for cross-language analyses.Quick startLet's mock up aMultiAssayExperiment:frommultiassayexperimentimportMultiAssayExperimentfromsinglecellexperimentimportSingleCellExperimentfromsummarizedexperimentimportSummarizedExperimentimportbiocframeimportnumpyx=numpy.random.rand(1000,200)x2=(numpy.random.rand(1000,200)*10).astype(numpy.int32)sce=SingleCellExperiment({"logcounts":x,"counts":x2},main_experiment_name="aaron's secret modality",row_data=biocframe.BiocFrame({"foo":numpy.random.rand(1000),"bar":numpy.random.rand(1000)},row_names=["gene_sce_"+str(i)foriinrange(1000)],),column_data=biocframe.BiocFrame({"whee":numpy.random.rand(200),"stuff":numpy.random.rand(200)},row_names=["cell_sce"+str(i)foriinrange(200)],),)se=SummarizedExperiment({"counts":numpy.random.rand(100,200)},row_data=biocframe.BiocFrame({"foo":numpy.random.rand(100),"bar":numpy.random.rand(100)},row_names=["gene_se_"+str(i)foriinrange(100)],),column_data=biocframe.BiocFrame({"whee":numpy.random.rand(200),"stuff":numpy.random.rand(200)},row_names=["cell_se"+str(i)foriinrange(200)],),)mae=MultiAssayExperiment(experiments={"jay_expt":sce,"aarons_expt":se})Now we can save it:fromdolomite_baseimportsave_objectimportdolomite_seimportosfromtempfileimportmkdtemppath=os.path.join(mkdtemp(),"test")save_object(se,path)And load it again, e,g., in a new session:fromdolomite_baseimportread_objectroundtrip=read_object(path)
Package: dolomite-matrix
Read and save matrices in PythonIntroductionThedolomite-matrixpackage is the Python counterpart to thealabaster.matrixR package,
providing methods for saving/reading arrays and matrices within thedolomiteframework.
Dense arrays are stored in the usual HDF5 dataset, while sparse matrices are saved inside a HDF5 file in compressed sparse format.Quick startLet's save a dense matrix to a HDF5 file with some accompanying metadata:importnumpyx=numpy.random.rand(1000,200)importosimporttempfiledir=os.path.join(tempfile.mkdtemp(),"whee")importdolomite_baseimportdolomite_matrixdolomite_base.save_object(x,dir)Now we can transfer the directory and reload the matrix in a new session.
This constructs a HDF5-backed dense array that can be used for block processing or realized into the usual NumPy array.importdolomite_baseobj=dolomite_base.read_object(dir)## <1000 x 200> ReloadedArray object of type 'float64'## [[0.58444226, 0.82595149, 0.7214525 , ..., 0.32493652, 0.58206044,##   0.73770346],##  [0.96398317, 0.73200292, 0.16410134, ..., 0.31626547, 0.11499628,##   0.19768697],##  [0.82350911, 0.48012452, 0.65221052, ..., 0.94989611, 0.15422992,##   0.77173718],##  ...,##  [0.71715436, 0.19266116, 0.52316388, ..., 0.23104537, 0.935654  ,##   0.51663007],##  [0.38585049, 0.26709808, 0.70358993, ..., 0.91822795, 0.66144925,##   0.42465112],##  [0.08535589, 0.00144712, 0.51411921, ..., 0.84546122, 0.35001404,##   0.53644868]]Sparse matricesWe can also save and load a sparse matrix from a HDF5 file:importscipyimportnumpyx=scipy.sparse.random(1000,200,0.2,dtype=numpy.int16,format="csc")importosimporttempfiledir=os.path.join(tempfile.mkdtemp(),"stuff")importdolomite_baseimportdolomite_matrixdolomite_base.save_object(x,dir)And again, loading it back in a new session.
This constructs a HDF5-backed sparse array that can be used for block processing or realized into the usual NumPy array.importdolomite_baseobj=dolomite_base.read_object(dir)## <1000 x 200> sparse ReloadedArray object of type 'int16'## [[     0,      0, -28638, ...,      0,      0,  26194],##  [     0,      0,      0, ...,      0, -30829,      0],##  [     0,      0,      0, ...,      0,      0,      0],##  ...,##  [ 10895,      0,      0, ...,      0,      0,      0],##  [     0,  32539,      0, ...,      0,   2780, -12106],##  [     0,      0,      0, ...,   1452,      0, -26314]]
Package: dolomite-ranges
Save and load genomic ranges objects to fileThis package implements methods for saving and loadingGenomicRangesandGenomicRangesListobjects. It provides a language-agnostic method for serializing genomic coordinates in these objects, as well as data in related objects like sequence information. To get started, install the package from PyPI:pipinstalldolomite-rangesWe can then save aGenomicRangesto a file, preserving itsmetadataandmcols:importosfromtempfileimportmkdtempfromdolomite_baseimportread_object,save_objectfromgenomicrangesimportGenomicRangesfromirangesimportIRangesimportdolomite_rangesgr=GenomicRanges(seqnames=["chrA","chrB","chrC"],ranges=IRanges([10,30,2200],[20,50,30]),strand=["*","+","-"],)dir=os.path.join(mkdtemp(),"granges")save_object(gr,dir)roundtrip=read_object(dir)Similarly save and load aGenomicRangesListto a file,importosfromtempfileimportmkdtempfromdolomite_baseimportread_object,save_objectfromgenomicrangesimportGenomicRanges,SeqInfofromirangesimportIRangesimportdolomite_rangesa=GenomicRanges(seqnames=["chr1","chr2","chr1","chr3"],ranges=IRanges([1,3,2,4],[10,30,50,60]),strand=["-","+","*","+"],mcols=BiocFrame({"score":[1,2,3,4]}),)b=GenomicRanges(seqnames=["chr2","chr4","chr5"],ranges=IRanges([3,6,4],[30,50,60]),strand=["-","+","*"],mcols=BiocFrame({"score":[2,3,4]}),)grl=GenomicRangesList(ranges=[a,b],names=["a","b"])dir=os.path.join(mkdtemp(),"granges_list")save_object(gr,dir)roundtrip=read_object(dir)NoteThis project has been set up using PyScaffold 4.5. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: dolomite-sce
Save and writeSingleCellExperimentsin PythonIntroductionThedolomite-scepackage is the Python counterpart to thealabaster.sceR package,
providing methods for saving/readingSingleCellExperimentobjects within thedolomiteframework.Quick startLet's mock up aSingleCellExperimentthat contains reduced dimensions and alternative experiments,fromsinglecellexperimentimportSingleCellExperimentimportbiocframeimportnumpysce=SingleCellExperiment(assays={"counts":numpy.random.rand(1000,200)},row_data=biocframe.BiocFrame({"foo":numpy.random.rand(1000),"bar":numpy.random.rand(1000)}),column_data=biocframe.BiocFrame({"whee":numpy.random.rand(200),"stuff":numpy.random.rand(200)}),reduced_dims={"tsnooch":numpy.random.rand(200,4)},alternative_experiments={"very_useful_modality":SummarizedExperiment({"counts":numpy.random.rand(100,200)})},)Now we can save it:fromdolomite_baseimportsave_objectimportdolomite_sceimportosfromtempfileimportmkdtemppath=os.path.join(mkdtemp(),"test")save_object(se,path)And load it again, e,g., in a new session:fromdolomite_baseimportread_objectroundtrip=read_object(path)## Class SingleCellExperiment with 1000 features and 200 cells##   assays: ['counts']##   row_data: ['foo']##   column_data: ['whee']
Package: dolomite-schemas
Bioconductor object schemas for PythonOverviewThis package vendors theBioconductor object schemasfor thedolomite-Python packages.
The idea is to ensure that downstream packages have consistent access to schemas without the need for a remote look-up.
We put this in a separate package so that schema updates are kept separate from actual programming changes.InstallationDevelopers can install the package throughpip.pipinstalldolomite-schemasUsageSchemas are vendored into theschemas/subdirectory in the installation directory.
This directory can be easily found by working back from thedolomite-schemasmodule location:importdolomite_schemasos.path.join(os.path.dirname(dolomite_schemas.__file__),"schemas")Application-specific schema-vendoring modules should use the same relative location for their schema subdirectory in the installation directory.Developer notesThe schemas are not actually committed to this repository, but are instead obtained by running:cdextern&&./fetch.shThis can be modified to point to any relevant version of the schemas.
Package: dolomite-se
Save and load SummarizedExperiments in PythonIntroductionThedolomite-sepackage is the Python counterpart to thealabaster.seR package,
providing methods for saving/readingSummarizedExperimentorRangeSummarizedExperimentobjects within thedolomiteframework.
All components of theSummarizedExperiment- assays, row data and column data - are saved to their respective file representations,
which can be loaded in a new R/Python environment for cross-language analyses.Quick startLet's mock up aSummarizedExperiment:importsummarizedexperimentimportbiocframeimportnumpyse=summarizedexperiment.SummarizedExperiment(assays={"counts":numpy.random.rand(1000,200)},row_data=biocframe.BiocFrame({"foo":numpy.random.rand(1000)},row_names=["gene"+str(i)foriinrange(1000)]),column_data=biocframe.BiocFrame({"whee":numpy.random.rand(200)},row_names=["cell"+str(i)foriinrange(200)]))Now we can save it:fromdolomite_baseimportsave_objectimportdolomite_seimportosfromtempfileimportmkdtemppath=os.path.join(mkdtemp(),"test")save_object(se,path)And load it again, e,g., in a new session:fromdolomite_baseimportread_objectroundtrip=read_object(path)## Class SummarizedExperiment with 1000 features and 200 samples##   assays: ['counts']##   row_data: ['foo']##   column_data: ['whee']This also works forRangeSummarizedExperimentobjects storingrow_rangesto the specified path.
Package: dolon
Read here for fulldocumentationDolonThe name Doloncomes from a spy in Homer’s Iliad.dolonis a library that interfaces with the mnemic service to trace real
time data; requires Python 3.6 or later and talks to themnemicservice that
must be running in an accessible host.dolon’s recommended way to install it is to usepip:pipinstalldolonMnemicMnemicrefers to the ability to retain memory.mnemicis the backend that dolon talks to and also exposes the related
front end as a web page.  The easiest way to install it is using docker.dockerrun--namemnemic-db-ePOSTGRES_PASSWORD=postgres123-p15432:5432-djpazarzis/mnemic-dbdockerrun--namemnemic-back-end--add-hosthost.docker.internal:host-gateway-p12013:12013/udp-ePOSTGRES_CONN_STR='postgresql://postgres:postgres123@172.17.0.1:15432/mnemic'-eBACK_END_PORT='12013'-djpazarzis/mnemic-backenddockerrun--namemnemic-front-end-ePOSTGRES_CONN_STR='postgresql://postgres:postgres123@172.17.0.1:15432/mnemic'-eFRONT_END_PORT='12111'-p12111:12111-djpazarzis/mnemic-front-endHigh level ViewThe following picture shows the components that are involved in mnemic:The backend consists of a service that runs as a docker container. It receives
messages from the application to profile and stores then in the database. It also exposes a UI client making the profiling data discoverable and visible by a browser session.Quick Example"""Mnemic hello_word program."""importasyncioimportrandomimporttracemalloctracemalloc.start()importdolon.trace_clientastcasyncdeftracer():"""Plain vanilla tracer."""tracer_name="hello-world"host="localhost"port=12013frequency=1awaittc.start_tracer(tracer_name,frequency,host,port,tc.mem_allocation,tc.active_tasks,tc.cpu_percent)asyncdeftime_and_memory_consuming_func():"""Allocates some memory for some time!"""_=[iforiinrange(10000)]awaitasyncio.sleep(random.uniform(0.1,3))asyncdefmain():"""The main function to profile."""while1:asyncio.ensure_future(time_and_memory_consuming_func())awaitasyncio.sleep(0.4)if__name__=='__main__':loop=asyncio.get_event_loop()asyncio.ensure_future(tracer())loop.run_until_complete(main())After running the above program for several minutes the screen that we will
see when accessing the UI from the browser usinglocalhost:12111will
be similar to the following:If we stop and restart the program then as we can see in the following picture
we will see another key in the tree control under the same trace run
name (hello-world in our example) which will acculate the new tracing info:
Package: doloop
doloopis a simple system for keeping things with unique IDs updated. It is
concurrency-safe and supports prioritization.doloop’s only dependency isMySQL; it does not require you to
install or administer a separate server.doloopworks with any DBI-compliant Python MySQL library, including:MySQL ConnectorMySQL-PythonoursqlPyMySQLSeehttp://packages.python.org/doloopfor tutorial and documentation.
Package: dolosse
Dolosse- A Kafka based Data Acquisition SystemCopyright (c) 2018 - 2020,S. V. Paulauskas,Dolosse Collaboration.Dolosse is a modern scientific data acquisition and analysis framework. We use Kafka as a messaging backend that allows
synchronization between acquisition systems. Using Kafka's messaging interface we can create a feedback loops between
analysis and acquisition systems. We're still working on developing the frameworkFeaturesDigitizer interfaces (coming soon)XIAPixie-16XIA Pixie-NetDecode digitizer data formatsXIAPixie-16 (released)Pixie-4 and Pixie-Net (coming soon)Runs on Linux and Windows Systems.Unpacks binary data formats:PLD (UTK)LDF (ORNL) - coming soonDocumentationOur documentation is sparse right now since we're still getting off the ground. You can read about
the project motivation inthis presentation.
You can also checkout thewiki.SupportCheckout thesupportpage for more information.InstallationThere are a couple of ways to use the software. They depend on the goal that you're after.For use in custom softwarepipinstalldolosseNow you'll have access to the packages and modules we use to build our components. Checkout the
modules documentation to see what you can do out of the box.NOTE:There's nothing that's ready for experiments just yet.For developmentDevelopers should read thedevelopment workflow.gitclonehttps://github.com/dolosse/dolosse.gitcddolosse
python3-mvenvvenv
pipinstall-rrequirements.txtLicensingApache License 2.0.
Package: dolpa
dolpadolpa is simple, easy to use library made for API-testing.Installationdolpa is available in PyPI.python -m pip install dolpaHow to useIn a nutshell, dolpa parses your json file which contains
information about your API tests. Your JSON file should
have the following schema:{
  "config": {
    "base_url": "http://localhost:8000",
    "headers": {
      "client-app": "SHM"
    }
  },
  "calls": [
    {
      "resource": "/login",
      "method": "POST",
      "body": {
        "currentUser": "alex.martin",
        "currentState": "healthy"
      },
      "headers": {
        "app-status": "current"
      },
      "saves": {
        "authToken": "$.auth_token"
      },
      "assertions": {
        "responseCheckAssertion": "responseSent==yes"
      }
    },
    {
      "resource": "/users",
      "method": "POST",
      "body": {
        "currentUser": "alex.martin",
        "currentState": "healthy"
      },
      "headers": {
        "app-status": "current"
      },
      "saves": {
        "current_block": "$.currentDepartment.currentBlock",
        "currentFriend": "$.currentDepartment.departmentInfo.employees[2]"
      },
      "assertions": {
        "nameCheck": "$.currentDepartment.departmentInfo.employees[2]==Tammy"
      }
    },
    {
      "resource": "/preference",
      "method": "POST",
      "body": {
        "currentUser": "alex.martin",
        "currentState": "healthy"
      },
      "headers": {
        "app-status": "current"
      },
      "saves": {
        "$.currentDepartment.currentBlock": "current_block"
      },
      "assertions": {
        "nameCheck": "$.workingBlock=={{current_block}}",
        "friendCheck": "$.friend=={{currentFriend}}"
      }
    }
  ]
}configcan be any valid JSON. Keys ofconfigwill remain as
global variable that can be accessed using{{<key>}}anywhere
in the call definition.So how to run API tests then?You should start by making folder for your API tests where JSON files
containing tests like above are stored. You can have multiple test folders inside
the root test folder. When you run your API tests, it only picks JSON files
for testing inside the root and subsequently, sub-folders.Here is how you start your tests:from dolpa import run_bulk_api_tests

run_bulk_api_tests('/User/home/test-user/test-folder-path')That's all the code you need to run your tests.But wait... my test-cases are little more complicated than that!Yeah, it's seldom that simple!However, dolpa makes it super easy to handle those kind of situations. Just write your API-tests
JSON files and treat them like each of them are unrelated when you reference them their identifier. You
can build complex API-tests relationship as follows:test_handler = get_api_test_handler('/Users/home/poweruser/test.json')
    first_call = test_handler.run(1)
    if first_call.response.status_code == 200:
        second_call = test_handler.run(2)
        ...The above code already abstracts away assertions and other details in the JSON file so you don't have
to worry about pesky if/else conditions and can focus on the core-logic of your tests.
Enjoy!
Package: dolphindb
DolphinDB Python SDKA C++ boosted API for Python, built on Pybind11.RequirementsTo use DolphinDB Python SDK, you'll need:Python:CPython: version 3.6 and newerDolphinDB ServerPackages:NumPy: version 1.18 and newerpandas: version 1.0.0 and newer, but not version 1.3.0futureExtension Packages:PyArrow: version 9.0.0 and newerInstallationTo install the DolphinDB package, use the following command:pipinstalldolphindbExample CodeHere's an example of using DolphinDB Python SDK:importdolphindbasddbconn=ddb.Session()conn.connect("localhost",8848,"admin","123456")conn.run("1+1;")-----------------------2
Package: dolphindb-notebook
DolphinDB Jupyter Notebook 扩展插件Jupyter Notebook是基于网页的用于交互计算的应用程序。用户可以直接通过浏览器编辑和交互式运行代码。DolphinDB database 提供了Jupyter Notebook的插件。DolphinDB Jupyter Notebook 扩展插件提供以下功能：为用户提供Jupyter Notebook连接DolphinDB Server的配置界面。使Jupyter Notebook支持DolphinDB脚本语言的执行。1. 下载插件并安装使用pip安装pip install dolphindb_notebook启用插件jupyter nbextension enable dolphindb/main2. 配置Jupyter Notebook工作路径Jupyter Notebook内核（kernels）是编程语言特定的进程，它们独立运行并与Jupyter应用程序及其用户界面进行交互。DolphinDB Jupyter Notebook 扩展插件提供了运行DolphinDB脚本的内核。用户需要通过以下步骤配置Jupyter Notebook的工作路径，以便在程序运行时DolphinDB内核的顺利导入。通过命令行jupyter kernelspec list查看Jupyter Notebook内核的工作路径。Linux系统>jupyterkernelspeclist
Availablekernels:dolphindb/home/admin/.local/share/jupyter/kernels/dolphindbpython3/home/admin/.local/share/jupyter/kernels/python3将/home/admin/.local/share/jupyter/kernels复制下来，方便下一步配置时粘贴。Windows系统>jupyterkernelspeclist
Availablekernels:dolphindbC:\Users\admin\appdata\local\programs\python3\python37\share\jupyter\kernels\dolphindbpython3C:\Users\admin\appdata\local\programs\python3\python37\share\jupyter\kernels\python3将 C:\Users\admin\appdata\local\programs\python3\python37\share\jupyter\kernels复制下来，方便下一步配置时粘贴。通过命令行jupyter notebook --generate-config生成一个配置文件jupyter_notebook_config.py，打开这个配置文件，找到c.NotebookApp.notebook_dir选项，设为上一步复制下来的工作路径，并去掉注释#。
注意：Windows系统需要将路径中的一个反斜杠\都替换成两个反斜杠\\，其中一个是转义字符。3. 连接DolphinDB Server在命令行输入jupyter notebook，启动Jupyter Notebook。在Jupyter Notebook的页面右侧点击新建，选择DolphinDB，新建一个DolphinDB notebook。点击notebook工具栏的Connect to DolphinDB Server按钮。选择相应的server，然后点击右下角Connect按钮，即与DolphinDB server建立连接（如果不需要该server，可以点击Delete按钮删除）。也可以通过New按钮，输入新的server信息，然后点击Save & Connect按钮即与DolphinDB server建立连接，并保存该信息以便下次使用。4. 编辑和运行DolphinDB脚本连接DolphinDB Server后，在代码块区域编写DolphinDB脚本，点击运行即可运行相应代码块。5. 展示代码块运行结果每次运行DolphinDB脚本后，运行结果都会在相应的代码块下方展示。对于DolphinDB的绘图功能，以PNG展示结果。注意：对于一些数据量较大的结果，可能会出现IOPub数据率超出限制的问题，可以启用 Jupyter Notebook配置文件中的 c.NotebookApp.iopub_data_rate_limit 这一项，按需调高数值。对于超出60行的表格，只显示前五行与后五行。
Package: dolphindb-tools
dolphindb-toolsDolphinDB Python Tool CollectionHow to Installpip install dolphindb-toolsExampleimport dolphindb as ddb
from dolphindb_tools.dataloader import DDBDataLoader

sess = ddb.session()
sess.connect("localhost", 8848, "admin", "123456")

sess.run("""
    t = table(1..10 as a, 2..11 as b, 3..12 as c)
""")

sql = 'select * from objByName("t")'
         
dataloader = DDBDataLoader(sess, sql, ["c"])

for X, y in dataloader:
    print(X, y)

--------------------------------------------------
tensor([[1, 2, 3]], dtype=torch.int32) tensor([[3]], dtype=torch.int32)
tensor([[2, 3, 4]], dtype=torch.int32) tensor([[4]], dtype=torch.int32)
tensor([[3, 4, 5]], dtype=torch.int32) tensor([[5]], dtype=torch.int32)
tensor([[4, 5, 6]], dtype=torch.int32) tensor([[6]], dtype=torch.int32)
tensor([[5, 6, 7]], dtype=torch.int32) tensor([[7]], dtype=torch.int32)
tensor([[6, 7, 8]], dtype=torch.int32) tensor([[8]], dtype=torch.int32)
tensor([[7, 8, 9]], dtype=torch.int32) tensor([[9]], dtype=torch.int32)
tensor([[ 8,  9, 10]], dtype=torch.int32) tensor([[10]], dtype=torch.int32)
tensor([[ 9, 10, 11]], dtype=torch.int32) tensor([[11]], dtype=torch.int32)
tensor([[10, 11, 12]], dtype=torch.int32) tensor([[12]], dtype=torch.int32)
Package: dolphin-memory-engine
Python Dolphin Memory EngineA python library designed to read and write the emulated memory ofthe Dolphin emulatorduring runtime.Binary wheels are available on pypi for Python 3.8 to 3.12. Usepython -m pip install dolphin-memory-engine.System requirementsAny x86_64 based system should work, however, Mac OS isnotsupported. Additionally, 32-bit x86 based systems are unsupported since Dolphin dropped their support.You need to have Dolphin runningandhave the emulation startedfor this program to be useful. As such, the system must meet Dolphin'ssystem requirements. Additionally, at least 250 MB of free memory is required.If it doesn't work, verify that you do not have thenosuidmount flag on your/etc/fstabas it can cause this command to silently fail.LicenseThis program is licensed under the MIT license which grants you the permission to do  anything you wish to with the software, as long as you preserve all copyright notices. (See the file LICENSE for the legal text.)Development HelpTo compile the extension in debug:$ python3 -m venv venv
$ source venv/bin/activate
$ python -m pip install Cython pytest
$ python setup.py build_ext -g --inplace --force
$ python -m pytest
Package: dolphin-python
DolphinGeneral python package for CUDA accelerated deep learning inference.Documentation:ReadTheDocSource code:https://github.com/MaximeDebarbat/DolphinBug reports:https://github.com/MaximeDebarbat/Dolphin/issuesGetting Starterd:It provides :A set of common image processing functionsA TensorRT wrapper for easy inferenceSpeeds up the inference with CUDA and TensorRTAn easy to use API with NumpyA fast N-Dimensional arrayTesting :In order to test the package, you will need the librarypytestwhich you can run from the root of the project :pytestInstallpip install dolphin-pythonBuildDolphin can be installed with Pypi (coming soon) or built with Docker which is the recommended way to use it :docker build  -f Dockerfile \
              --rm \
              -t dolphin:latest \
              .Docker runEnsure that you have thenvidia-dockerpackage installed and run the following command :docker run \
        -it \
        --rm \
        --gpus all \
        -v "$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )":"/app" \
        dolphin:latest \
        bashPlease note that Dolphin might not work without the--gpus allflag or--runtime nvidia.AcknowledgementsThis project could not have been possible withoutPyCuda:Andreas Klöckner, Nicolas Pinto, Yunsup Lee, Bryan Catanzaro, Paul Ivanov, Ahmed Fasih, PyCUDA and PyOpenCL: A scripting-based approach to GPU run-time code generation, > Parallel Computing, Volume 38, Issue 3, March 2012, Pages 157-174.TODOsImproveEngineclass in order to supportint8Use Cython to speed up the code