Saravanan666/pypi-org huggingface dataset:
Package: quartet-trail
Logs action in QuartetDocumentationThe full documentation is athttps://serial-lab.gitlab.io/quartet-trail/QuickstartInstall Quartet Trail:pip install quartet-trailAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'quartet_trail.apps.QuartetTrailConfig',...)Add Quartet Trail’s URL patterns:fromquartet_trailimporturlsasquartet_trail_urlsurlpatterns=[...url(r'^',include(quartet_trail_urls)),...]FeaturesTODORunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxHistory0.1.0 (2018-11-07)First release on PyPI.
Package: quartet_vrs
A GS1-compliant VRS interface for QU4RTET, the open-source EPCIS  platform.DocumentationThe full documentation is athttps://serial-lab.gitlab.io/quartet_vrs/QuickstartInstall quartet_vrs:pip install quartet_vrsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'quartet_vrs.apps.QuartetVrsConfig',...)Add quartet_vrs’s URL patterns:fromquartet_vrsimporturlsasquartet_vrs_urlsurlpatterns=[...url(r'^',include(quartet_vrs_urls)),...]FeaturesREST APIOpen API SchemaImplements the full Global Lightweight Messaging Standard v1.0.2Providescheckconnectivtyendpoint.Providesverifyendpoint.Running TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ tox
Package: quart-events
quart-eventsUsagequart_events.EventBroker loads a blueprint into Quart which allows clients to subscribe to events via a WebSockets. The app can then generate events that can be sent to all subscribed clients in real-time.Please seetest/app.pyfor an example app. This app is used when running testing via py.test but can also be run standalone.Change Log[0.4.2] - 2021-12-23Change build system from setuptools to poetry[0.4.0] - 2021-11-08add type hints and type validation with mypyrequires asyncio-multisubscriber-queue 0.3.0pytest plugin to facilitate capturing events while other tests are running; plugin name isquart_events_catcheradded optional callbackswebsocket auth improvementstoken is now seemlessly managed using the user's session datatoken has an expiration; user is disconnected from the socket upon expirationa callback is available to further validate user using other criteria (like Flask-Login)
Package: quart-flask-patch
Quart-Flask-Patch is a Quart extension that patches Quart to work with
Flask extensions.QuickstartQuart-Flask-Patch must be imported first in your main module, so that
the patching occurs before any other code is initialised. For example,
if you want to use Flask-Login,importquart_flask_patchfromquartimportQuartimportflask_loginapp=Quart(__name__)login_manager=flask_login.LoginManager()login_manager.init_app(app)Extensions known to workThe following flask extensions are tested and known to work with
quart,Flask-BCryptFlask-CachingFlask-KVSessionFlask-LimiterSee
alsoQuart-Rate-LimiterFlask-LoginSee
alsoQuart-LoginorQuart-AuthFlask-MailFlask-MakoFlask-SeasurfFlask-SQLAlchemySee alsoQuart-DBFlask-WTFExtensions known not to workThe following flask extensions have been tested are known not to work
with quart,Flask-CORS, as it
usesapp.make_responsewhich must be awaited. TryQuart-CORSinstead.Flask-Restfulas it subclasses the Quart (app) class with synchronous methods
overriding asynchronous methods. TryQuart-OpenApiorQuart-Schemainstead.CaveatsFlask extensions must use the global request proxy variable to access
the request, any other access e.g. via~quart.local.LocalProxy._get_current_objectwill require
asynchronous access. To enable this the request body must be fully
received before any part of the request is handled, which is a
limitation not present in vanilla flask.Trying to use Flask alongside Quart in the same runtime will likely
not work, and lead to surprising errors.The flask extension must be limited to creating routes, using the
request and rendering templates. Any other more advanced functionality
may not work.Synchronous functions will not run in a separate thread (unlike Quart
normally) and hence may block the event loop.Finally the flask_patching system also relies on patching asyncio, and
hence other implementations or event loop policies are unlikely to
work.ContributingQuart-Flask-Patch is developed onGitHub. If you come across
an issue, or have a feature request please open anissue. If you want
to contribute a fix or the feature-implementation please do (typo
fixes welcome), by proposing amerge request.TestingThe best way to test Quart-Flask-Patch is withTox,$pipinstalltox$toxthis will check the code style and run the tests.HelpThe Quart-Flask-Patchdocumentationis the best
places to start, after that try searchingstack overflowor ask for helpon gitter. If you still
can’t find an answer pleaseopen an issue.
Package: quartical
QuartiCalQuartiCal is the successor to CubiCal. It implements a suite of fast radio interferometric calibration routines exploiting complex optimisation. Unlike CubiCal, QuartiCal allows for any available Jones terms to be combined. It can also be deployed on a cluster (documentation under construction).InstallationQuartiCal can be installed using pip:pip install quartical.DocumentationDocumentation is available onreadthedocs.Public BetaQuartiCal is now in public beta! That means we want you to use (and break) it as much as possible. Any bugs and feature requests can be submitted via the issue tracker.
Package: quartic-sdk
QuarticSDKQuartic SDK is Quartic.ai's external software development kit which allows users to use assets, tags, and other intelligence outside the Quartic AI Platform. Using the Quartic SDK, third party developers who have access to the Quartic AI Platform can build custom applications.InstallationInstall usingpippip install quartic-sdkto Install complete package with all supported model libraries:pip install quartic-sdk[complete]...or follow the following steps to install it from the source:git clone https://github.com/Quarticai/QuarticSDK/
python setup.py installExampleComprehensive documentation is available athttps://quarticsdk.readthedocs.io/en/latest/Here's an example on how the Quartic SDK can be used:Getting the assets, tags, batches from the server# Assuming that the Quartic.ai server is hosted at `https://test.quartic.ai/`,# with the login credentials as username and password is "testuser" and `testpassword respectively,# then use APIClient in the following format.fromquartic_sdkimportAPIClientclient=APIClient("https://test.quartic.ai/",username="testuser",password="testpassword")user_assets=client.assets()# Get the list of all assets that the user has access toasset=user_assets.get("name","Test Asset")# Get a specific asset with the name "Test Asset"asset_tags=asset.get_tags()# Gets the list of all tagsfirst_tag=asset_tags.first()# Returns the first in the list of tagsfirst_tag_data_iterator=first_tag.data(start_time=1000000,stop_time=2000000)# Returns the data present in the first tag for the time range of 1000000 to 2000000# Assuming that the Quartic.ai server is hosted at `https://test.quartic.ai/`,# with the login credentials as username and password is "testuser" and `testpassword respectively,# then use GraphqlClient in the following format.fromquartic_sdkimportGraphqlClientclient=GraphqlClient(url='https://test.quartic.ai/',username='testuser',password='testpassword')# Executing Query by:query='''query MyQuery {Site {idname}}'''result=client.execute_query(query=query)# To execute query asynchronously use the function below.#You should see the following result:{'data':{'Site':[{'id':'1','name':'quartic'},{'id':'8','name':'ABC site 1'},{'id':'12','name':'XYZ 123'}]}asyncdefexecute_graphql_query():query='''query MyQuery {Site {idname}}'''resp=awaitclient.execute_async_query(query=query)returnresp# Note: The above function will return a coroutine object.# Example to upload a file.query='''mutation($file: Upload!, $edge_connector: Int!, $date_format: DateTime!) {uploadTelemetryCsv(file: $file,fileName: "123",edgeConnector: $edge_connector,dateFormat: $date_format){taskIdstatus}}'''variables={'file':open('<path/to/file>','rb'),'edge_connector':'edgeConnector Id','date_format':'DatTime format'}response=client.execute_query(query=query,variables=variables)DocumentationTo run the documentation locally, run the following commands in terminal:cd docs
make html

cd docs/source
sphinx-build -b html . _build
open build/html/index.htmlTest CasesTo run the behaviour test cases, run the command:aloeTo run the unit test cases, run the command:pytest
Package: quartic-solver-kapoorlabs
quartic-solver-kapoorlabsA package containing methods for solving quartic, cubic, quadratic, and depressed equations.Thiscapedpackage was generated withCookiecutterusing@caped'scookiecutter-templatetemplate.InstallationYou can installquartic-solver-kapoorlabsviapip:pip install quartic-solver-kapoorlabsTo install latest development version :pip install git+https://github.com/Kapoorlabs-CAPED/quartic-solver.gitContributingContributions are very welcome. Tests can be run withtox, please ensure
the coverage at least stays the same before you submit a pull request.LicenseDistributed under the terms of theBSD-3license,
"quartic-solver" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.
Package: quart-imp
Quart-Imppip install quart-impWhat is Quart-Imp?Quart-Imp's main purpose is to help simplify the importing of blueprints, resources, and models.
It has a few extra features built in to help with securing pages and password authentication.NoteQuart-Flask-Patch is required to use Quart-Imp.Generate a Quart appquart-impinitExampleproject/
└── app/
    ├── blueprints/
    │   └── www/...
    ├── extensions/
    │   └── __init__.py
    ├── resources/
    │   ├── static/...
    │   ├── templates/...
    │   └── routes.py
    └── __init__.py# app/extensions/__init__.pyimportquart_flask_patchfromflask_sqlalchemyimportSQLAlchemyfromquart_impimportImp_=quart_flask_patchimp=Imp()db=SQLAlchemy()# app/__init__.pyfromquartimportQuartfromapp.extensionsimportimp,dbdefcreate_app():app=Quart(__name__,static_url_path="/")imp.init_app(app)imp.import_app_resources(files_to_import=["*"],folders_to_import=["*"])imp.import_blueprints("blueprints")imp.import_models("models")db.init_app(app)@app.before_servingasyncdefcreate_tables():db.create_all()returnapp
Package: quart-injector
Quart InjectorDependency injecetion for quart apps.🛠 Installingpoetry add quart-injector🎓 Usageimporttypingimportquartimportinjectorimportquart_injectorGreeting=typing.NewType("Greeting",str)defconfigure(binder:injector.Binder)->None:binder.bind(Greeting,to="Hello")app=quart.Quart(__name__)@app.route("/<name>")@app.route("/",defaults={"name":"World"})asyncdefgreeting_view(greeting:injector.Inject[Greeting],name:str)->str:returnf"{greeting}{name}!"quart_injector.wire(app,configure)📚 HelpSee theDocumentationor ask questions on theDiscussionboard.⚖️ LicenceThis project is licensed under theMIT licence.All documentation and images are licenced under theCreative Commons Attribution-ShareAlike 4.0 International License.📝 MetaThis project usesSemantic Versioning.
Package: quart_minify
quart_minifyA Quart extension to minify quart response for html, javascript, css and less compilation as well.Install:With pippip install quart-minifyFrom the source:git clone https://github.com/AceFire6/quart_minify.gitcd quart_minifypython setup.py installSetup:Inside Quart app:fromquartimportQuartfromquart_minify.minifyimportMinifyapp=Quart(__name__)Minify(app=app)Result:Before:<html><head><script>if(true){console.log('working !')}</script><style>body{background-color:red;}</style></head><body><h1>Example !</h1></body></html>After:<html><head><script>if(true){console.log('working !')}</script><style>body{background-color:red;}</style></head><body><h1>Example !</h1></body></html>Options:def__init__(self,app=None,html=True,js=False,cssless=True,cache=True,fail_safe=True,bypass=()):"""A Quart extension to minify flask response for html,javascript, css and less.@param: app Quart app instance to be passed (default:None).@param: js To minify the css output (default:False).@param: cssless To minify spaces in css (default:True).@param: cache To cache minifed response with hash (default: True).@param: fail_safe to avoid raising error while minifying (default True).@param: bypass a list of the routes to be bypassed by the minifierNotice: bypass route should be identical to the url_rule used for example:bypass=['/user/<int:user_id>', '/users']"""Credit:Adapted fromflask_minifyhtmlmin: HTML python minifier.lesscpy: Python less compiler and css minifier.jsmin: JavaScript python minifier.
Package: quart-mongo
Quart MongoQuart-Mongo bridgesQuart,Motor, andOdmanticto create a powerful MongoDB extension to use in your Quart applications. It also provides some convenience helpers as well as being able to work withQuart-Schema.InstallationInstall the extension with the following command:$ pip3 install quart-mongoUsageTo use the extension simply import the class wrapper and pass the Quart app
object back to here. Do so like this:from quart import Quart
from quart_mongo import Mongo

app = Quart(__name__)
babel = Mongo(app)DocumentationThe documentation for Quart-Mongo and is availablehere.
Package: quarto
QuartoPython interface to Quarto, an academic, scientific, and technical publishing system built onPandoc.In addition to the core capabilities of Pandoc, Quarto includes:Support for embedding output from R and Python via integration with knitr and Jupyter.A project system for rendering groups of documents at once.Flexible ways to specify rendering options, including project-wide options and per-format options.Cross references for figures, tables, equations, sections, listings, proofs, and more.Sophisticated layout for panels of figures, tables, and other content.Automatic installation of required LaTeX packages when rendering PDF output.For more information on Quarto, see the project GitHub repositories athttps://github.com/quarto-dev/
Package: quart-oauth2-discord.py
#Quart-OAuth2-Discord.pyA library to make the discord authentication system easier for Quart Users.To install this library:$python3-mpipinstallQuart-OAuth2-Discord.pyIf you're in Windows:python-mpipinstallQuart-OAuth2-Discord.pyAn example of Quart-app-with-Discord-BotfromtypingimportListfromquartimportQuart,redirect,render_template_string,request,url_forfromquart_oauth2_discord_pyimportDiscordOauth2Client,Guildapp=Quart(__name__)app.secret_key=b"random bytes representing quart secret key"app.config['DISCORD_CLIENT_ID']="Client ID here"app.config['DISCORD_CLIENT_SECRET']='CLIENT_SECRET_HERE'app.config['SCOPES']=['identify','guilds']app.config['DISCORD_REDIRECT_URI']='http://127.0.0.1:5000/callback'app.config['DISCORD_BOT_TOKEN']=Noneclient=DiscordOauth2Client(app)@app.route('/')asyncdefindex():return"Hello!"@app.route('/login/',methods=['GET'])asyncdeflogin():returnawaitclient.create_session()@app.route('/callback')asyncdefcallback():awaitclient.callback()returnredirect(url_for('index'))defreturn_guild_names_owner(guilds_:List[Guild]):# print(list(sorted([fetch_guild.name for fetch_guild in guilds_ if fetch_guild.is_owner_of_guild()])))returnlist(sorted([fetch_guild.nameforfetch_guildinguilds_iffetch_guild.is_owner_of_guild()]))defsearch_guilds_for_name(guilds_,query):# print(list(sorted([fetch_guild.name for fetch_guild in guilds_ if fetch_guild.is_owner_of_guild() and fetch_guild.name == query])))returnlist(sorted([fetch_guild.nameforfetch_guildinguilds_iffetch_guild.is_owner_of_guild()andfetch_guild.name==query]))@app.route('/guilds')asyncdefguilds():template_string="""<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Guilds</title></head><body><h1>Your guilds: </h1><ol>{% for guild_name in guild_names %}<li>{{ guild_name }}</li>{% endfor %}</ol></body></html>"""ifrequest.args.get('guild_name'):returnawaitrender_template_string(template_string,guild_names=search_guilds_for_name(awaitclient.fetch_guilds(),request.args.get('guild_name')))returnawaitrender_template_string(template_string,guild_names=return_guild_names_owner(awaitclient.fetch_guilds()))@app.route('/me')@client.is_logged_inasyncdefme():user=awaitclient.fetch_user()image=user.avatar_url# noinspection HtmlUnknownTargetreturnawaitrender_template_string("""<html lang="en"><body><p>Login Successful</p><img src="{{ image_url }}" alt="Avatar url"></body></html>""",image_url=image)if__name__=='__main__':app.run()This is not yet documented. It will be documented soon.
Package: quarto-cli
QuartoQuarto is an open-source scientific and technical publishing system built onPandoc. Quarto documents are authored usingmarkdown, an easy to write plain text format.In addition to the core capabilities of Pandoc, Quarto includes:Embedding code and output from Python, R, Julia, and JavaScript via integration withJupyter,Knitr, andObservable.A variety of extensions to Pandoc markdown useful for technical writing including cross-references, sub-figures, layout panels, hoverable citations and footnotes, callouts, and more.A project system for rendering groups of documents at once, sharing options across documents, and producing aggregate output likewebsitesandbooks.Authoring using a wide variety of editors and notebooks includingJupyterLab,RStudio, andVS Code.Avisual markdown editorthat provides a productive writing interface for composing long-form documents.Learn more about Quarto athttps://quarto.org.InstallTo install the latest released version of Quarto, use:pipinstallquarto-cliNoteThe currentquarto-clipackage downloads required Quarto binary files from GitHub during installation. We are investigating providing pre-built wheel files to make installation more robust.UninstallTo uninstall thequarto-clipackage, use:pipuninstallquarto-cli
Package: quartodoc
Overviewquartodoclets you quickly generate Python package API reference
documentation using Markdown andQuarto. quartodoc
is designed as an alternative toSphinx.Check out the below screencast for a walkthrough of creating a
documentation site, or read on for instructions.Installationpython-mpipinstallquartodocor from GitHubpython-mpipinstallgit+https://github.com/machow/quartodoc.gitInstall QuartoIf you haven’t already, you’ll need toinstall
Quartobefore you can use
quartodoc.Basic useGetting started with quartodoc takes two steps: configuring quartodoc,
then generating documentation pages for your library.You can configure quartodoc alongside the rest of your Quarto site in
the_quarto.ymlfile you are already using for Quarto. Toconfigure
quartodoc,
you need to add aquartodocsection to the top level your_quarto.ymlfile. Below is a minimal example of a configuration that
documents thequartodocpackage:project:type:website# tell quarto to read the generated sidebarmetadata-files:-_sidebar.ymlquartodoc:# the name used to import the package you want to create reference docs forpackage:quartodoc# write sidebar data to this filesidebar:_sidebar.ymlsections:-title:Some functionsdesc:Functions to inspect docstrings.contents:# the functions being documented in the package.# you can refer to anything: class methods, modules, etc..-get_object-previewNow that you have configured quartodoc, you can generate the reference
API docs with the following command:quartodocbuildThis will create areference/directory with anindex.qmdand
documentation pages for listed functions, likeget_objectandpreview.Finally, preview your website with quarto:quartopreviewRebuilding siteYou can preview yourquartodocsite using the following commands:First, watch for changes to the library you are documenting so that your
docs will automatically re-generate:quartodocbuild--watchSecond, preview your site:quartopreviewLooking up objectsGenerating API reference docs for Python objects involves two pieces of
configuration:the package name.a list of objects for content.quartodoc can look up a wide variety of objects, including functions,
modules, classes, attributes, and methods:quartodoc:package:quartodocsections:-title:Some sectiondesc:""contents:-get_object# function: quartodoc.get_object-ast.preview# submodule func: quartodoc.ast.preview-MdRenderer# class: quartodoc.MdRenderer-MdRenderer.render# method: quartodoc.MDRenderer.render-renderers# module: quartodoc.renderersThe functions listed incontentsare assumed to be imported from the
package.Learning moreGoto the next
pageto
learn how to configure quartodoc sites, or check out these handy pages:Examples
page: sites
using quartodoc.Tutorials
page:
screencasts of building a quartodoc site.Docstring issues and
examples:
common issues when formatting docstrings.Programming, the big
picture:
the nitty gritty of how quartodoc works, and how to extend it.
Package: quart-peewee
Quart-PeeweeIntegration between theQuartweb framework and thePeewee ORMthrough thePeewee-AIOInstallationpip install quart-peeweeUsagefrompeewee_aio.fieldsimportCharFieldfromquartimportQuart,requestfromquart_peeweeimportQuartPeeweeapp=Quart(__name__)db=QuartPeewee("aiosqlite:///app.db")db.init_app(app)classUser(db.Model):name=CharField(unique=True)@app.before_servingasyncdefbefore_serving():awaitdb.create_tables()@app.route("/create_user",methods=["POST"])asyncdefcreate_user():data=awaitrequest.get_json(force=True)awaitUser.create(name=data["name"])return""@app.route("/get_users",methods=["GET"])asyncdefget_users():returnawaitUser.select().dicts()@app.route("/delete_user",methods=["DELETE"])asyncdefdelete_user():data=awaitrequest.get_json(force=True)awaitUser.delete().where(User.name==data["name"])return""if__name__=="__main__":app.run()