Saravanan666/pypi-org huggingface dataset:
Package: qwery
qweryqwery is a small and lightweight query builder based on asyncpg and pydantic.why a query builderIn my opinion query builders strike a great balance between the flexibility of raw SQL, the structure and safety of pre-crafted queries, and the comfortable data layer of an ORM.These benefits come with some downsides:You lose some flexibility when crafting queries, especially when dealing with things like partial updates.While the query builder interface does providesometyping, its dynamic nature means it can never match the safety of pre-crafted queries with hand-written or generated types.Complex queries returning non-standard data become unruly fast.model, queries, helper patternqwery works best with a model + queries + helper pattern, namely:Models describe only data and how it is storedQueries describe how models interact with the databaseHelpers describe and implement the interactionbetweenmodels and the application (creation, fetching, etc)examplefrompydanticimportBaseModelfromqweryimportQueryclassMyModel(BaseModel):classMeta:table_name="my_table"id:intname:strdesc:Optional[str]active:boolclassMyModelQueries:create=Query(MyModel).insert(body=True).execute()delete_by_id=Query(MyModel).delete().where("id = {.id}").execute()get_by_id=Query(MyModel).select().where("id = {.id}").fetch_one()get_all=Query(MyModel).select().fetch_all()asyncwithpool.acquire()asconn:model=MyModel(id=1,name="test",desc=None,active=True)awaitMyModelQueries.create(conn,model=model)model=awaitMyModelQueries.get_by_id(conn,id=1)models=awaitMyModelQueries.get_all(conn)assertmodels==[model]awaitMyModelQueries.delete(conn,id=1)
Package: qwgraph
AboutThis is the source for the python packageqwgraph.
This package's aim is to provide an efficient implementation of quantum walks on graphs.The quantum walk model implemented in this package follows the paperhttps://arxiv.org/abs/2310.10451. This model is specifically designed for searching.Most of the critical functions of this package are implemented and compiled in rust, providing an efficient simulation.An example notebook can be found athttps://github.com/mroget/qwgraph/demo.ipynbInstallation1. From pippip install qwgraphFor windows users, it might be necessary to install the rust toolchain cargo.2. From sourcegit clone git@github.com:mroget/qwgraph.git
cd qwgraph
./build.shThe scriptbuild.shwill compile everything and install it as a python package locally on your machine. It requires to install maturin viapip install maturinDependencies+ `numpy`
+ `matplotlib`
+ `networkx`
+ `pandas`
+ `tqdm`DocumentationThe documentation can be found inhttps://mroget.github.io/qwgraph/
Package: qwhale-client
qwhale-clientThis is the official python client libraryThe library is simple, all you need is a TOKEN that you can get from our websitehareand that it! you are ready to work with our service.The library works withpymongoso you can use it like you use to.code examplefromqwhale_clientimportAPIClientTOKEN="<YOUR API TOKEN>"client=APIClient(TOKEN)withclientasdatabase:print(client.activated)# -> Truedatabase["test"].insert_one({"key":"value","extra":"123456"})document=database["test"].find_one({"key":"value"})print(document)# -> {"_id": ObjectId(...), "key": "value", "extra": "123456"}print(client.activated)# -> FalseAnother code examplefromqwhale_clientimportAPIClientTOKEN="<YOUR API TOKEN>"client=APIClient(TOKEN)database=client.get_database()print(client.activated)# -> Truedatabase["test"].insert_one({"key":"value","extra":"123456"})document=database["test"].find_one({"key":"value"})print(document)# -> {"_id": ObjectId(...), "key": "value", "extra": "123456"}print(client.close())# -> {'data_saved': True}print(client.activated)# -> False
Package: qwhale-logs-client
QWhaleLogsClientQWhaleLogs client lib for saving logs in remote serviceInstall$>pipinstallqwhale-logs-clientGet tokenGo tologinAfter the login go toget_tokenLogging exampleimportloggingfromqwhale_logs_clientimportinitinit(token="<YOUR_TOKEN>",batch_site=1)# Init logs capture# The batch site is determine how many logs to send in one request# For fewer sizes more requests are made (default to 100)logging.basicConfig(level=logging.DEBUG,format='%(asctime)s-%(name)s-%(levelname)s-%(message)s')logging.info("Some log")# Normal use# Now your logs are sent to the QWhaleLogsServiceLoguru example (Recommended)fromloguruimportloggerfromqwhale_logs_clientimportinitinit(token="<YOUR_TOKEN>",batch_site=1)# Init logs capture# The batch site is determine how many logs to send in one request# For fewer sizes more requests are made (default to 100)logger.info("Some log")# normal use# Now your logs are sent to the QWhaleLogsService
Package: qwif
qwifGenerate QR codes for WIFI and more from the command line.Requirementspython 3.8+InstallingInstall and update usingpip:pip install -U qwifAlternatively, you can package and runqwifin a docker container:make imageUsageqwifsupports a number of QR code content types through subcommands.To generate a QR code for WIFI configuration:qwif wifi --ssid test --password testTo generate a QR code to configure e.g. Google Authenticator:qwif otp --secret test --issuer "Big Corp"  --account_name test@test.localA list of  subcommands can be printed by runningqwif --help.Each has its own help menu detailing the supported parameters for each QR code
type.Authorsiwaseatenbyagrue
Package: qwikcrud
qwikcrudqwikcrudis a powerful command-line tool designed to enhance your backend development experience by automating the
generation of comprehensive REST APIs and admin interfaces. Say goodbye to the tedious task of
writing repetitive CRUD (Create, Read, Update, Delete) endpoints when starting a new project, allowing developers to
concentrate on the core business logic and functionality.[!WARNING]
The generated application is not ready for production use. Additional steps are required to
set up a secure and production-ready environment.Table of ContentsInstallationQuickstartEnvironment variablesUsageGenerated Application stackRoadmapContributingAcknowledgmentsLicenseInstallationpipinstallqwikcrudQuickstartEnvironment variablesBefore running the command-line tool, ensure the following environment variables are configured:GoogleexportGOOGLE_API_KEY="your_google_api_key"OpenAIexportOPENAI_API_KEY="your_openai_api_key"exportOPENAI_MODEL="your_openai_model"# Defaults to "gpt-3.5-turbo-1106"UsageTo generate your application, open your terminal, run the following command and follow the instructions:Googleqwikcrud-ooutput_dirOpenAIqwikcrud-ooutput_dir--aiopenaiGenerated Application stackFastAPISQLAlchemy v2Pydantic v2Starlette-adminSQLAlchemy-fileExamplesTask
Management (prompt,generated app)Roadmapqwikcrudis designed to support various frameworks and AI providers. Here's an overview of what has been accomplished
and
what is planned for the future:FrameworksFastAPI + SQLAlchemyRestful APIsAdmin interfacesAuthenticationFastAPI + BeanieSpring BootAI providersGoogle (default)OpenAIAnthropicOllama (self-hosted LLMs)Pricingqwikcrudmakes one API call per prompt and add a system prompt of around 900 tokens to
your prompt.Google: Currently free.OpenAI: With the default gpt-3.5-turbo model, each app generation costs approximately $0.003. The exact cost can
vary slightly based on the model selected and the output lengthContributingContributions are welcome and greatly appreciated! If you have ideas for improvements or encounter issues, please feel
free to submit a pull request or open an issue.AcknowledgmentsThe FastAPI + SQLAlchemy template is inspired by the excellent work
infull-stack-fastapi-postgresqlby [Sebastian Ramirez (tiangolo)].Licenseqwikcrudis distributed under the terms of theApache-2.0license.
Package: qwikidata
qwikidatais a Python package with tools that allow you to interact withWikidata.The package defines a set of classes that allow you to represent Wikidata entities
in a Pythonic way.  It also provides a Pythonic way to access three data sources,linked data interfacesparql query servicejson dumpQuick InstallRequirementspython >= 3.5Install with pipYou can install the most recent version using pip,pipinstallqwikidataQuick ExamplesPlease see the,examples folderORreadthedocsLicenseLicensed under the Apache 2.0 License. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.CopyrightCopyright 2019 Kensho Technologies, LLC.Important Linksreadthedocs|PyPI|github
Package: qwikstart
qwikstart: Code generator for fun and profitDocumentation:https://qwikstart.readthedocs.ioSource:https://github.com/tonysyu/qwikstartqwikstartis a code generator for integrating code into existing projects. It’s
similar to code generators likecookiecutter,yeoman, andhygenbut with a focus on
adding code to existing projects.A simplehello-world.ymlscript in qwikstart would look something like:steps:"Askforname":name:promptinputs:-name:"name"default:"World""Displaymessage":name:echomessage:|Hello, {{ qwikstart.name }}!The first step uses thepromptoperation with a single input"name", with a default
value of"World"(which is editable when running the script). The next step just uses
theechooperation to display a message. This script can be usingqwikstart run:$qwikstartrunhello-world.ymlPleaseenterthefollowinginformation:name:WorldHello,World!InstallThe recommended way of installingqwikstartis to usepipx:pipxinstallqwikstartIf you happen to be setting uppipxfor the first time, thepipx installation instructionssuggest runningpipx ensurepathto update
the user path. Note, if you use~/.profileinstead of~/.bash_profile,
this will add~/.bash_profile, which will take precendence over~/.profile.
Either move the code from~/.bash_profileto~/.profileorlink your profiles.Basic UsageAfter installingqwikstart, you can run a simple hello-world example using the
following:$qwikstartrun--repohttps://github.com/tonysyu/qwikstartexamples/hello_world.ymlBy default, there are abbreviations for common git repos, so the above can also be
written:qwikstartrun--repogh:tonysyu/qwikstartexamples/hello_world.ymlSee AlsoThere are a lot code generators and scaffolding tools out there, and the following is
just a selection of some of the most popular ones:cookiecutter: A command-line utility that creates projects from cookiecutters
(project templates)hygen: The scalable code generator that saves you time.yeoman: The web’s scaffolding tool for modern webapps
Package: qwilfish
IntroductionQwilfish is a Python package for fuzzing various Ethernet-related protocols.
It is a work in progress and the first goal is grammar-based generation of
LLDP frames (IEEE 802.1AB).[[TOC]]InstallationPrerequisitesA Linux systemPython3.8 (higher versions will probably work too, but no guarantees)Root privileges (for changing the capabilities of Python binary)Create a virtual environmentIt is recommended to create a virtual environment first:$ python -m venv venv
$ source venv/bin/activateInstall with pipTo install Qwilfish simply type:$ pip install qwilfishInstall from sourceTo install Qwilfish from source type:$ git clone https://gitlab.com/zluudg/qwilfish.git
$ cd qwilfish
$ pip install .Qwilfish also supports an editable install:$ pip install -e .Setting capabilitiesQwilfish writes packets to raw sockets, which is prohibited for normal users.
It is not recommended to install or run Qwilfish as root, however.
Instead, change the capabilities of your Python binary:$ sudo setcap cap_net_raw=eip /path/to/python/binaryUsageBasic usageQwilfish can be invoked without any commands:$ qwilfishIt will then send one fuzzed LLDP packet on the loopback interface.To send ten packets on the loopback interface, type:$ qwilfish -c 10Set logging level to DEBUG:$ qwilfish -dAdvanced ConfigurationThere are some possibilities to configure a Qwilfish session beyond what is
offered by the CLI. Please refer tothis guidefor more info.Writing PluginsCertain components in Qwilfish can be replaced in a plugin fashion. For more
info check outthis guide.CreditThis project is more than heavily inspired byThe Fuzzing Book. Be sure to check it out!
Package: qwixtractor
qwixtractorExtract data from the Quarterly Workforce IndicatorsInstallation$pipinstallqwixtractorUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licenseqwixtractorwas created by Rodrigo Franco. It is licensed under the terms of the MIT license.Creditsqwixtractorwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: qwlist
Qwery ListQList is a small library introducing a new way to use higher order functions
with lists, withlazy evaluation. It also aims to address ugly
python list methods such as map, filter and reduce. Whoever invented this:xs=['1','2','3','4']s=reduce(lambdaacc,x:acc+x,filter(lambdax:x<3,map(int,xs)),0)must reevaluate their life choices (yes, I am being cocky and most likely dumdum) but listen
to me first and look what the world of lazy evaluation has to offer!xs=QList(['1','2','3','4'])s=xs.map(int).filter(lambdax:x<3).fold(lambdaacc,x:acc+x,0)As a bonus you getlen()method, so no longer will you be forced to wrapp your
lists in this type of codelen(xs)and simply callxs.len()(I understand it is negligibly
slower but look how much nicer it looks!)Quick tutorialLet's say we want to read numbers from a file and choose only the even ones. No problem at all!fromqwlistimportQListwithopen('path/to/file.txt','r')asfile:qlist=QList(file.readlines())even=qlist.map(int).filter(lambdax:x%2==0).collect()Why is there thiscollectat the end? Because all operations on the QList arelazy evaluated,
so in order to finally apply all the operations you need to express that.There is also an eagerly evaluatedEagerQListin case all the actions performed on the list should
be evaluated instantaneously. This object is in theqwlist.eagermodule, but it is also
possible to transformQListintoEagerQListsimply by callingeager()>>>fromqwlistimportQList>>>QList(range(3)).eager().map(str)['0','1','2']EagerQList has the same methods that QList has (filter,map,foreach, ...) but not lazy evaluated so
there is no need to callcollectat the end.ExamplesMaking QList from an iterable>>>QList([1,2,3,4])[1,2,3,4]Making QList from a generator>>>QList(range(3))[0,1,2]Making a list of pairs:intandstr>>>qlist=QList([1,2,3])>>>qlist.zip(qlist.map(str)).collect()[(1,'1'),(2,'2'),(3,'3')]Summing only the even numbers>>>QList(range(10)).filter(lambdax:x%2==0).fold(lambdaacc,x:acc+x,0)20Side noteThis syntax resemblesRustsyntax:RustPythonletxs=vec![1,2,3,4];letdouble_xs:Vec<i32>=xs.iter().map(|&x|x*2).collect();println!("{double_xs:?}");// [2, 4, 6, 8]xs=QList([1,2,3,4])double_xs=xs.map(lambdax:x*2).collect()print(double_xs)# [2, 4, 6, 8]Story behind this whole ideaPrime idea?Vicious mockery!During studying, I had to do a lot of list comprehensions in Python, alongside
methods such asmaporfilterand although they are quite powerful, using them
in Python is just annoying. Combining them makes you read the code in an unnatural order going
from right to left. That is the main reason that for a long time I preferred simple for-loops
as opposed to using mentioned methods. Until one day my teacher asked the whole class why no one is using
list comprehensions and higher order functions."Do you guys know python?" he asked tendentiously."I would use those functions if they were nicer" I thought.During that period I also learnt Rust and immediately fell for it. Especially with how convenient
it is to replace for-loops with method calls. And that's how the idea for a python packageqwlistwas born.I hereby announce that UwU, Qwery Listwu!
Package: qW-Map
qW-Map: Weight Re-Mapping for Variational Quantum CircuitsA PyTorch implementation of Quantum Weight Re-MappingIn recent years, quantum machine learning has seen a substantial increase in the use of variational quantum circuits (VQCs). VQCs are inspired by artificial neural networks, which achieve extraordinary performance in a wide range of AI tasks as massively parameterized function approximators. VQCs have already demonstrated promising results, for example, in generalization and the requirement for fewer parameters to train, by utilizing the more robust algorithmic toolbox available in quantum computing. A VQCs' trainable parameters or weights are usually used as angles in rotational gates and current gradient-based training methods do not account for that. We introduce weight re-mapping for VQCs, to unambiguously map the weights to an interval of length $2\pi$, drawing inspiration from traditional ML, where data rescaling, or normalization techniques have demonstrated tremendous benefits in many circumstances. We employ a set of five functions and evaluate them on the Iris and Wine datasets using variational classifiers as an example. Our experiments show that weight re-mapping can improve convergence in all tested settings. Additionally, we were able to demonstrate that weight re-mapping increased test accuracy for the Wine dataset by $10%$ over using unmodified weights.Link to Arxiv PaperImplemented FunctionsInstall$ pip install qw-mapExample:importpennylaneasqmlfromqw_mapimporttanhfromtorchimportTensordefcircuit(ws:Tensor,x:Tensor):qml.AngleEmbedding(x,rotation='X',wires=range(num_qubits))qml.StronglyEntanglingLayers(tanh(ws),wires=range(num_qubits))CitationTODO
Package: qwop-fast
qwop-fast: A fast implementation of QWOP simulatorSame API ashttps://web.stanford.edu/class/cs168/qwop.py, but much faster.Installpip install qwop-fastBuild From SourceInstall Rust:https://rustup.rs/Install Maturin:pip install maturinBuild and install the package:maturin develop --releaseUse it:You can just follow the API ofhttps://web.stanford.edu/class/cs168/qwop.pyand just replaceimport qwopwithimport qwop_fast.importnumpyasnpimportqwop_fastplan=np.random.uniform(-1,1,40)qwop_fast.sim(plan)# return a floatYou can also simulate in batches. Batches will be executed in parallel.importnumpyasnpimportqwop_fastplan=np.random.uniform(-1,1,(100,40))qwop_fast.sim_batch(plan)# return a list of floats
Package: qworker
QueueWorkerQueueWorker is asynchronous Task Queue implementation built to
work withasyncio.
Can you spawn distributed workers to run functions inside workers and outside of
event loop.QueueWorkerrequires Python 3.8+ and is distributed under MIT license.How do I get set up?First, you need to instal QueueWorker:.. code-block ::pip install qworkerThen, you can start several workers (even sharing the same port):.. code-block ::qw --host  --port  --workerwhere<hostname>is a hostname of the server<port-number>is a port that server will listen on<num-workers>is a number of worker processesLicenseQueueWorker is copyright of Jesus Lara (https://phenobarbital.info) and is under MIT license. I am providing code in this repository under an open source license, remember, this is my personal repository; the license that you receive is from me and not from my employeer.
Package: qworktree
qworktreeqworktreeis a simple tool to permit to manage a qt worktree without managing the main xxx.pro.It is designed to create the main pro file at the root path of the tree (where you execute it it.It have some containts that I does not arrive to remove:need to declate the MK_FEATURE elementgenerate 2 file in the root directory![Badge](https://badge.fury.io/py/qworktree.pngInstructionsThis tool is to create the main .pro file of your worktreeqworktree is under a FREE license that can be found in the LICENSE file.
Any contribution is more than welcome ;)git repositoryhttp://github.com/HeeroYui/qworktree/InstallationRequirements:Python >= 2.7andpipJust run:pip install qworktreeInstall pip on debian/ubuntu:sudo apt-get install pipInstall pip on ARCH-linux:sudo pacman -S pipInstall pip on MacOs:sudo easy_install pipUsageDownload your worktree and run the commandqworktree
export QMAKEFEATURES=`pwd`/mkfeatures
mkdir build
cd build
qmake ..the qworktree will generate local filesfolder_name.pro ==> the file of the worktree description
defines.prf ==> a file that define a list of dependency macroCreating the needed elements1: Need a mkfeature to add an include to determine the main root worktree:mkfeatures/root_directory.prfROOT_DIRETORY += $${PWD}/..
ROOT_DEFINES += $${PWD}/../defines.prf
load(../defines.prf)2: Create a file in your library/plugin/application folder:folderName/qworktree_folderName.py#!/usr/bin/python
# -*- coding: utf-8 -*-
depend_on = [
"depend_worktree_lib1_name",
"depend_worktree_lib2_name"
	]3: Create a file in your worktree with the dependency property:folderName/dependencies.priINCLUDEPATH += $$PWD
LIBS *= -llibraryName4: Import the library elements:load(root_directory.prf)
  # request include properties
  include($$ROOT_DIRETORY/$$LIB_DECLARE_DEPENDENCIES_FOLDERNAME1)
  include($$ROOT_DIRETORY/$$LIB_DECLARE_DEPENDENCIES_MYLIB2)Note that the define is generate in the filedefines.prfLicense (MPL v2.0)Copyright qworktree Edouard DUPINLicensed under the Mozilla Public License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttps://www.mozilla.org/MPL/2.0/Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: qxbranch.quantum-feature-detector
OverviewQxBranch’s Quantum Feature Detector (QxQFD) is a Python library providing a configurable class of quantum machine
learning functions. It provides a simple interface for using quantum transformations to detect features in data as part
of a machine learning application stack, on Rigetti’s QCS.RequirementsQxQFD requires the following Python packages:Python 3.6Pyquil 2.0.0numpymatplotlibscikit-learnnetworkxQxQFD officially supports Linux 18.04.UsageQxQFD can be used with a Rigetti Forest QMI, or a local machine running the Forest SDK QVM.Included with QxQFD are three demonstration notebooks providing examples of the library’s use. They can be found in the
‘demo’ folder. The CIFAR-10 data required for the third notebook can be found athttps://www.cs.toronto.edu/~kriz/cifar.html.DocumentationComplete documentation is available on QxBranch’s website athttps://www.qxbranch.com/manuals/quantum_feature_detector.At this address you can also find some demonstration iPython notebooks.About QxBranchQxBranch is a quantum computing and data analytics software company founded in 2014, based in Washington DC with offices
in London, UK, and Adelaide, Australia. QxBranch specializes in the development of quantum computing software and data
analytics services. To learn more about QxBranch, visithttps://www.qxbranch.com.LicenseCopyright 2018 QxBranch, Inc.Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttps://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: qxelarator
QX SimulatorA universal quantum computer simulator. Allows simulation of a quantum circuit written incQasm.Runs as aPython moduleor an executable binary.For detailed documentation, please visitthe ReadTheDocs page, to find e.g.:installation instructionsusage.LicensingQX-simulator is licensed under the Apache License, Version 2.0. SeeLICENSEfor the full
license text.