Saravanan666/pypi-org huggingface dataset:
Package: quikkly-python-sdk
# Quikkly Python SDK #Note: to use this Python SDK, you need the Quikkly core native library.
Please contactdavid@quikklycodes.comfor more information and pricing.## Install ##pip install quikkly-python-sdk## Dependencies ##Python 2.7 or 3.6.Generating SVG codes has no dependencies besides the qukklycore native library files. Generating PNG and JPEG codes requires installing the ImageMagick library with librsvg support.Scanning codes from images also requires thenumpyandPillowPython packages.## Version History ##3.4.9 - Add quikkly.get_template_info() method and command-line script to export blueprint metadata. This includes also the maximum data values which are not present in the file itself. Update to require Quikkly core libs v3.4.9.3.4.8 - Fix setup.py3.4.7 - Renamedquikkly-generate-svg.pytoquikkly-generate-code.py. Add support for PNG and JPEG output formats if ImageMagick is installed.3.4.6 - Fix compatibility with Quikkly core libs v3.4.5 for scanning.3.4.5 - Update to Quikkly core libs v3.4.5. No Python SDK changes.3.4.3 - Update to Quikkly core libs v3.4.3. No Python SDK changes.3.4.1 - Update to Quikkly core libs v3.4.1. No Python SDK changes.3.3.4 - Update to Quikkly core libs v3.3.4. No Python SDK changes.3.3.2 - Update to Quikkly core libs v3.3.2. No Python SDK changes.3.2.1 - Add support for encoding/decoding data values as alphanumeric strings.3.2.0 - Update to Quikkly core libs v3.2.0, reverting some style changes to templates. No Python SDK changes.3.1.0 - Update to Quikkly core libs v3.1.0, with more styling options and templates. No Python SDK changes.1.0.0 - Support for generating SVG codes, scanning images, plus command-line scripts for both.0.1.0 - First Release.## Making a Release ##Check that setup.py version has been updated to new version,Check that README.md version history has been updated,Check that quikklycore.py version has been updated to compatible native lib versions,Check that you are in a virtualenv with python3 as default,Run ./pypi-upload.sh
Package: quil
Quil⚠️ In DevelopmentThequilpackage provides tools for constructing, manipulating, parsing, and printingQuilprograms. Internally, it is powered byquil-rs.This package is still in early development and breaking changes should be expected between minor versions.DocumentationDocumentation for the current release ofquilis publishedhere. Every version ofquilshipswith type stubsthat provide type hints and documentation to Python tooling and editors that support theLanguage Server Protocolor similar.
Package: quilbert
IntroductionQuilbert: A Python AI Voice Assistant with State Machine DesignQuilbert is a GPT powered AI voice assistant built using Python.
This project utilizes a state machine design pattern to efficiently handle user input, process it, and provide relevant responses.
With Quilbert, you can easily access information, ask questions, and receive helpful responses using only your voice.To get started with Quilbert, follow these steps:$ pip install Quilbert
$ quilbert --debugOnce running, Quilbert will begin listening for the wakeword "porcupine". When you say "porcupine", Quilbert will become active and start listening for your questions or commands.Please note some common issues you might encounter:OpenAI API not set: Configure your OpenAI API key by runningexport OPENAI_API_KEY=<your key>.Picovoice access key not set: Set up your Picovoice access key usingexport PICOVOICE_ACCESS_KEY=<your key>.Pyaudio import fails because portaudio is not installed: Install portaudio usingbrew install portaudioon mac.Architecture OverviewQuilbert's architecture is based on a state machine with three primary states: sleeping, listening, and processing.
The state diagram for Quilbert's architecture can be visualized using Mermaid:stateDiagram
sleeping --> listening
listening --> processing
processing --> listening
processing --> sleepingBy using this state machine design, Quilbert efficiently handles user interactions, providing a seamless and responsive voice assistant experience.Sleeping stateIn the sleeping state, Quilbert processes audio chunks, listens for the wakeword, and discards the audio data.
The transitions are as follows:Sleeping to listening: Triggered when the wake word is detected.Listening stateWhen in the listening state, Quilbert processes audio chunks, listens for voice activity, and stores the chunks in a buffer. The possible transitions are:Listening to sleeping: Triggered when no processing occurs after two minutes of listening.Listening to processing: Triggered when voice activity is detected for 0.25 seconds, followed by one second of inactivity.Processing stateIn the processing state, Quilbert takes the following actions:Converts the buffered audio to text.Fetches a response from the AI model.Plays the response using text-to-speech synthesis.The transitions from processing state are:Processing to sleeping: Triggered when the user says "stop" or another stop phrase.Processing to listening: Triggered immediately after processing is complete.
Package: quill-delta
Delta (Python Port)Python port of the javascript Delta library for QuillJS:https://github.com/quilljs/deltaSome basic pythonizing has been done, but mostly it works exactly like the above library.There is no other python specific documentation at this time, sorry.  Please see the tests
for reference examples.Install withPoetryWith HTML rendering:> poetry add -E html quill-deltaWithout HTML rendering:> poetry add quill-deltaInstall with pipNote: If you're usingzsh, see below.With HTML rendering:> pip install quill-delta[html]With HTML rendering (zsh):> pip install quill-delta"[html]"Without HTML rendering:> pip install quill-deltaRendering HTML in PythonThis library includes a moduledelta.htmlthat renders html from an operation list,
allowing you to render Quill Delta operations in full from a Python server.For example:from delta import html

ops = [ 
    { "insert":"Quill\nEditor\n\n" },
    { "insert": "bold",
      "attributes": {"bold": True}},
    { "insert":" and the " },
    { "insert":"italic",
      "attributes": { "italic": True }},
    { "insert":"\n\nNormal\n" },
]

html.render(ops)Result (line formatting added for readability):<p>Quill</p>
<p>Editor</p>
<p><br></p>
<p><strong>bold</strong> and the <em>italic</em></p>
<p><br></p>
<p>Normal</p>See test_html.pyfor more examples.DevelopingSetupIf you'd to contribute to quill-delta-python, get started setting your development environment by running:Checkout the repository> git clone https://github.com/forgeworks/quill-delta-python.gitMake sure you have python 3 installed, e.g.,> python --versionFrom inside your new quill-delta-python directory:> python3 -m venv env
> source env/bin/activate
> pip install poetry
> poetry install -E htmlTestsTo run tests do:> py.test
Package: quillix
Quillix is a Python package designed for local database management using JSON as the underlying storage format. With Quillix, users can seamlessly create, manage, and query databases through a simplified interface. The package provides a convenient way to perform basic database operations, execute SQL-like queries, and manage data with ease.Usageimport quillix as qx, then just call the query() function like, qx.query("your query").Note: 1. "Alter table" has only column based operations which include "drop", "rename", "add".
      2. In "update table" syntax, "column1 = column1 + value" is written as "column1 + value".
      3. Syntax does not include semi-colon(;) in the end.
      4. Enclose conditions after "where" keyword with brackets.
            Example, "select * from table_name where ((column1 > 5) or (column2 == hello world))"
      5. while using "group by" or "order by" clause, no need to mention the grouping or sorting columns in the column details between "select" and "from" keyword.
      6. "Join" does not work, however you can use object based syntax.
            Example, "select count(b.col4) from a testTable, b testTable2 where (a.col2 == b.col5) group by a.col1"When you create a database, you will find a data.json file being created in your project directory. It will store all the data that you put in your database.Complete documentation will be available in a few days.
Package: quills.app
==========quills.app==========This package is a part of the Quills Blogging Suite. It contains codeshared between Products.Quills and Products.QuillsEnabled.For further information about Quills, see package https://github.com/collective/Products.Quills.Changelog=========1.8.1 (2016-12-27)----------------- add Plone version classifiers[tkimnguyen]- include all needed files[skurfer]1.8 (2012-12-17)----------------- Plone 4.3 compatibility[ale-rt]- Handle case when attribute parentsInThread does not exist on comment[tkimnguyen]1.8a1 (2011-03-30)------------------- Compatibility with Plone 4 [sargo] (r100977_, r100979_)- Fixed problem where blog's topics view acquired an object with the tag namefrom higher up instead of showing blogs with that tag. [jcbrand] (r232360_)For older entries, please see Products.Quills/Products.QuillsEnabled for a changes.
Package: quillsql
Quill Python SDKQuickstartFirst, install the quillsql package by running:$pipinstallquillsqlThen, add a/quillendpoint to your existing python server. For example, if
you were running a FASTAPI app, you would just add the endpoint like this:fromquillsqlimportQuillfromfastapiimportFastAPI,Requestapp=FastAPI()quill=Quill(private_key=<YOUR_PRIVATE_KEY_HERE>,database_connection_string=<YOUR_DB_CONNECTION_STRING_HERE>,)# ... your existing endpoints here ...@app.post("/quill")asyncdefquill_post(data:Request):body=awaitdata.json()returnquill.query(org_id="2",data=body)Then you can run your app like normally. Pass in this route to our react library
on the frontend and you all set!For local testing (dev purposes only)pipenv install
pipenv shell
uvicorn examples.fastapi-server.app:app --reload --port 3000You are now ready to ping your local server athttp://localhost:3000.TroubleshootingIf you run into issues withLibrary not loaded: @rpath/libpq.5.dyliborno LC_RPATH's found, try uninstalling and reinstalling postgres on your machine. For example, using homebrew:$brewuninstallpostgresql
$brewupdate
$brewinstallpostgresqlIf you're still having this issue, this resource might also be useful for you:https://www.psycopg.org/docs/install.html.
Package: quilt3distribute
quilt3distributePeople commonly work with tabular datasets, people want to share their data, this makes that easier through Quilt3.FeaturesAutomatically determines which files to upload based off CSV headers. (Explicit override available)Simple interface for attaching metadata to each file based off the manifest contents.Groups metadata for files that are referenced multiple times.Validates and runs basic cleaning operations on your dataset manifest CSV.Optionally add license details and usage instructions to your dataset README.Parses README for any referenced files and packages them up as well.Support for adding extra files not contained in the manifest.Constructs an "associates" map that is placed into each files metadata for quick navigation around the package.Enforces that the metadata attached to each file is standardized across the package for each file column.Quick StartConstruct a csv (or pandas dataframe) dataset manifest (Example):CellIdStructure2dReadPath3dReadPath1lysosome2d/1.png3d/1.tiff2laminb12d/2.png3d/2.tiff3golgi2d/3.png3d/3.tiff4myosin2d/4.png3d/4.tifffromquilt3distributeimportDataset# Create the datasetds=Dataset(dataset="single_cell_examples.csv",name="single_cell_examples",package_owner="jacksonb",readme_path="single_cell_examples.md")# Optionally add common additional requirementsds.add_usage_doc("https://docs.quiltdata.com/walkthrough/reading-from-a-package")ds.add_license("https://www.allencell.org/terms-of-use.html")# Optionally indicate column values to use for file metadatads.set_metadata_columns(["CellId","Structure"])# Optionally rename the columns on the package levelds.set_column_names_map({"2dReadPath":"images_2d","3dReadPath":"images_3d"})# Distributepkg=ds.distribute(push_uri="s3://quilt-jacksonb",message="Initial dataset example")Returns:(remote Package)
 └─README.md
 └─images_2d
   └─03cdf019_1.png
   └─148ddc09_2.png
   └─2b2cf361_3.png
   └─312a0367_4.png
 └─images_3d
   └─a0ce6e01_1.tiff
   └─c360072c_2.tiff
   └─d9b55cba_3.tiff
   └─eb29e6b3_4.tiff
 └─metadata.csv
 └─referenced_files
   └─some_file_referenced_by_the_readme.pngExample Metadata:pkg["images_2d"]["03cdf019_1.png"].meta{"CellId":1,"Structure":"lysosome","associates":{"images_2d":"images_2d/03cdf019_1.png","images_3d":"images_3d/a0ce6e01_1.tiff"}}InstallationStable Release:pip install quilt3distributeDevelopment Head:pip install git+https://github.com/AllenCellModeling/quilt3distribute.gitCreditsThis package was created with Cookiecutter.Original repositoryFree software: Allen Institute Software License
Package: quilt3-local
Quilt3 catalog: Local development modeOpen source implementation of the Quilt3 registry that works in the local
environment (not requiring AWS cloud services aside from S3 / S3 Select).This package is not intended to be installed/used directly by end users.
Instead, installquilt3[catalog]and usequilt3 catalogCLI command.DevelopingTL;DR# set up venv, assuming poetry is available in the PATHpoetryinstall# build catalog bundle(cd../catalog&&npmi&&npmrunbuild&&cp-rbuild../quilt3_local/quilt3_local/catalog_bundle)# run the app at http://localhost:3000poetryrunquilt3-localSet-upPython environment set-upFirst, you needpoetryinstalled.Then, you have to set up the virtualenv by runningpoetry installfrom the
project directory -- it will create a virtualenv and install the requirements.Catalog (node.js) environment set-upRefer to thecatalog documentation.RunningYou can either serve a static catalog bundle (produced bynpm run build) or
proxy static files from a running catalog instance.NOTE: you need valid AWS credentials available, seeboto3 docsfor details.Serving a static catalog bundleRunpoetry run quilt3-localto start the app on port 3000 serving the static
catalog bundle from the./quilt3_local/catalog_bundledirectory.
Path to the bundle can be overriden byQUILT_CATALOG_BUNDLEenv var.
Port can be configured viaPORTenv var.In order to serve the bundle, you should first build it by runningnpm run buildfrom the catalog directory and then either copying it to./quilt3_loca/catalog_bundleor overridingQUILT_CATALOG_BUNDLEto point to
your bundle.
However, this approach is not very convenient when developing catalog features,
since it requires rebuilding the bundle to pick up the changes.
To address this there's a "proxy" mode available.Proxying a running catalog instanceIn this mode the app proxies all the static files requests to a running catalog
instance. One can be started by executingPORT=3001 npm startfrom the catalog
directory (setting port to3001required to avoid conflict with thequilt3_localapp's default settings).After starting up a catalog instance, you can start thequilt3_localapp and
point it to that instance by runningQUILT_CATALOG_URL=http://localhost:3001 poetry run quilt3-local(the app will be available athttp://localhost:3000and will serve static
files from the catalog running athttp://localhost:3001, catalog URL
configurable viaQUILT_CATALOG_URLenv var).Building and publishingMake sure you set upcredentials forpoetryBump package version inpyproject.tomland updateCHANGELOG.mdUpdate catalog commit hash incatalog-commitif requiredCommit, tag, push:git c -am "release X.Y.Z" && git tag vX.Y.Z && git push && git push --tagsBuild and publish the package:make publish
Package: quiltcore
QuiltCoreQuiltCore is a library for building and runningQuiltdata packages.
It is designed to leverage standard open source technology and YAML configuration files
so that it can easily be ported to other languages and platforms.This initial implementation is in Python.Key TechnologiesApacheArrowfor reading, writing, and representing manifestsPyArrowfor Python bindings to Arrowfsspecfilesystemsfor reading and writing files from various sourcesPyYAMLfor reading and writing YAML configuration filesExamplepoetryinstall#!/usr/bin/env pythonimportosfromquiltcoreimportDomain,UDIfromtempfileimportTemporaryDirectoryfromupathimportUPathTEST_BKT="s3://quilt-example"TEST_PKG="akarve/amazon-reviews"TEST_TAG="1570503102"TEST_HASH="ffe323137d0a84a9d1d6f200cecd616f434e121b3f53a8891a5c8d70f82244c2"TEST_KEY="camera-reviews"WRITE_BKT=os.environ.get("WRITE_BUCKET")SOURCE_URI=f"quilt+{TEST_BKT}#package={TEST_PKG}:{TEST_TAG}"DEST_URI=f"quilt+{TEST_BKT}#package={TEST_PKG}:{TEST_TAG}"Get Manifestremote=UDI.FromUri(SOURCE_URI)print(f"remote:{remote}")withTemporaryDirectory()astmpdir:local=UPath(tmpdir)domain=Domain.FromLocalPath(local)print(f"domain:{domain}")folder=domain.pull(remote)print(f"folder:{folder}")ifWRITE_BKT:tag=domain.push(folder,remote=UDI.FromUri(DEST_URI))print(f"tag:{tag}")
Package: quilter
QuilterThe composer of Matplotlib plots. Python implementation of the R package patchwork.This package overloads/creates operators for the matplotlib Figure class so that you can add and divide figures together into a new figure with subplots.Adding two figures together creates a new figure with the original figures side-by-side as subplots. Dividing will stack the figured on top of each other.Currently the package converts the input figures to images before reloading the images into the axes objects of the output figure. If anyone has a better way to copy actual axes objects to a new figure I'd loved help.Here are some examples:import matplotlib.pyplot as plt
import quilter # best to put this after your matplotlib import

fig1, ax1 = plt.subplots(figsize=(5,3))
ax1.plot([1, 2], label='my leg')
ax1.set_title("test")
ax1.legend()

fig2, ax2 = plt.subplots(figsize=(5,3))
ax2.plot([2, 2])
ax2.set_title("test 2")Adding figures togetherout = fig1 + fig2Dividing figuresout = fig1 / fig2More complex examplesout = (fig1 + fig2) / fig2

out = (fig1 + fig2) / (fig1 + fig2)
Package: quilt-lang
A Python library that lets you write less code to do more things.Documentation availablehere.Getting startedInstall via pippipinstallquilt-langImportingimportquilt_langas_Example usageif_.ready:print("Quilt is ready.")For more commands, visitthis website.How you can make Quilt betterAt the moment, you can help byAdding more functions which you or someone else might find usefulAdding and maintaining the docstringsAdding and improving unit testsLicenseQuilt is licensed under theApache 2.0 License.
Package: quiltplus
QuiltPlusNext-generation API for Quilt Universal Data CollectionsQuiltPlus provides an asychronous, object-oriented wrapper around the Quilt API.
In particular, it implements a resource-based architecture using Quilt+ URIs in
order to support the Universal Data Clientudc.Installationpython3-mpipinstallquiltplusUsagefromquiltplusimportQuiltPackageimportanyioURI="quilt+s3://quilt-example#package=examples/wellplates"asyncdefprint_contents(uri:str):pkg=QuiltPackage.FromURI(URI)files=awaitpkg.list()print(files)anyio.run(print_contents,URI)
Package: quiltz-domain
quiltz-domainPython domain concepts for quiltzPurposeAtQWANwe're building some applications in Python. We collect useful stuff in
the different Quiltz projects:quiltz-domain(this package) contains domain oriented support modules like entity
ids, results, email anonymization, validators and parsersquiltz-testsupportcontains test support modules, that supports e.g. automated testing for SMTP integration, probing asynchronous results and
asserting log statementsquiltz-messagingcontains a
messaging domain concept and an engines to send messages. Currently only
sending emails over SMTP is supported.Installingpipinstallquiltz-domainSeedocumentation
Package: quiltz-messaging
quiltz-messagingpython (email) messaging packagePurposeAt QWAN, we're building some applications in python. We collect useful stuff in
quiltz packages:quiltz-domaincontains domain
level modules like, entity id's, results, an email anonymizer, validators and
parsersquiltz-testsupportcontains test support modules, that supports mainly non unit tests, like
integrating with smtp, probing asynchronous results and asserting log
statementsquiltz-messaging(this package) contains a messaging domain concept and an
engine(s) to send the messages. Currently, only smtp sending is supported.installingpipinstallquitlz-messagingseedocumentation
Package: quiltz-testsupport
quiltz-testsupportA package for test supportPurposeAtQWANwe're building some applications in python. We collect usefull stuff in quiltz packages:quiltz-domaincontains domain
level modules like, entity id's, results, an email anonymizer, validators and
parsersquiltz-testsupport(this package) contains test support modules, that supports mainly non
unit tests, like integrating with smtp,  probing asynchronous results and
asserting log statementsquiltz-messagingcontains a
messaging domain concept and an engines to send the messages. Currently only
smtp sending is supported.Modules in this packageloggingWith the logging module you can assert log statements in a test using thelog_collectorfixture:in test:fromquiltz.testsupportimportlog_collectordeftest_logs_hello(log_collector):foo()log_collector.assert_info('hello info')in productiondeffoo():logger=logging.getLogger()logger.info('hello info')probingWith the probing module you can probe for async results:fromhamcrestimportassert_that,equal_tofromquiltz.testsupportimportprobe_thatdeftest_stub_server_collects_message_for_recepient(self):message=aMessage(recipient='rob@mailinator.com',sender='no-reply@qwan.eu',subject='test',body='hello test')self.message_engine.send([message])probe_that(lambda:self.server.messages==[stringified_message(message)])# orprobe_that(lambda:assert_that(self.server.messages,equal_to([stringified_message(message)])))# orprobe_that(lambda:self.server.messages,equal_to([stringified_message(message)]))smtpWith the smtp module you can create a stub smtp server that collects smtp messagesfromhamcrestimportassert_that,equal_tofromquiltz.testsupportimportprobe_thatdefserver()server=StubSmtpServer(hostname='localhost',port=9925)server.start()yield(server)server.stop()deftest_collects_message_for_recepient(self,server):message_engine=SMTPClientForTest(host='localhost',port='9925')message=aMessage(recipient='rob@mailinator.com',sender='no-reply@qwan.eu',subject='test',body='hello test')message_engine.send([message])probe_that(lambda:assert_that(server.messages,equal_to([stringified_message(message)])))installingpipinstallquiltz-testsupport
Package: quimb
quimbis an easy but fast python library for'quantum information many-body'calculations, focusing primarily ontensor networks. The code is hosted ongithub, and docs are hosted onreadthedocs. Functionality is split in two:Thequimb.tensormodule contains tools for working withtensors and tensor networks. It has a particular focus on automatically handling arbitrary geometry, e.g. beyond 1D and 2D lattices. With this you can:construct and manipulate arbitrary (hyper) graphs of tensor networksautomaticallycontract, optimize and draw networksuse various backend array libraries such asjaxandtorchviaautorayrun specific MPS, PEPS, MERA and quantum circuit algorithms, such as DMRG & TEBDThe corequimbmodule contains tools for reference'exact'quantum calculations, where the states and operator are represented as eithernumpy.ndarrayorscipy.sparsematrices. With this you can:construct operators in complicated tensor spacesfind groundstates, excited states and do time evolutions, including withslepccompute various quantities including entanglement measurestake advantage ofnumbaaccelerationsstochastically estimate $\mathrm{Tr}f(X)$ quantitiesThefull documentationcan be found at:quimb.readthedocs.io. Contributions of any sort are very welcome - please see thecontributing guide.Issuesandpull requestsare hosted ongithub. For other questions and suggestions, please use thediscussions page.