Saravanan666/pypi-org huggingface dataset:
Package: quickbase-model-maker
quickbase-model-makerA lightweight tool for creating and managing QuickBase models!Turn this👎# select relevant infoselect=[3,43,23,63,21,52,24,54]Into this👍fromreferences.order_managerimportOrderselect=[Order.RECORD_ID,Order.ORDER_TYPE,Order.ORDER_NUMBER,Order.DELIVERY_DATE...]With just a few lines of code!Installationpipinstallquickbase-model-makerUsageInitializingThe sample code below will initialize your models for use in your application.  Models are created within their respective app folders, in a new directory calledreferences.# import model makerfromquickbase_model_makerimportModelMaker# create model maker with realm and auth infoqmm=ModelMaker(realm='realm',auth='AUTH-TOKEN')# register tables you wish to create models fromqmm.register_tables([('bqs5asdf','bqs5aser'),# ('app_id', 'table_id') tuples('bqs5abzc','brzaners'),('bqs5abzc','brzanvac'),('bqs5abzc','bqs5wers'),])Generate your models, based off of the registered tables, with the.sync()method.# call sync method to create modelsqmm.sync(only_new_tables=True)Optionally, you can sync all registered tables, regardless of whether they have already been synced.
It is recommended to call.sync()only when you wish to re-generate models, aseach model sync with Quickbase costs 1 API call. You only have to generate
models once - or when you wish to update your models (i.e. new field you need to access added on quickbase).  Calling.sync()on
every script runcould result in a large number of API calls.qmm.sync()In codeOnce registered and created, models can be used in your application.The following code uses a fictional "Order" model to demonstrate
how one can access theORDER_TYPEfield.  One can also access useful metadata
through methods like.table_id()and.app_id().fromreferences.ordersimportOrderprint(Order.ORDER_TYPE)print(Order.table_id())Removing ModelsModels can easily be removed by doing the following:Remove the model from thereferences/appdirectoryRemove the related table from thereferences/__init__.pyfile.Remove the related table tuple from the.register_tables()method.
Package: quickbe
Quick back-endWhat is QuickbeQuickbe is a Python library that enables you to deliver quick back-end components.
If you are a technical founder or a developer, use this package to build everything you need to launch and grow high-quality SaaS application.
Every SaaS application needs these componentsMicro-servicesWeb-services or APIsWeb-hooks receiversCentral vaultWhy PythonIt has a strong community, it is fast to learn, it has lots of tools to process and analyze data ... and data is a major key for building a good app :-)Web serverDevelop your endpoint as functions with annotations for routing and validation.@endpoint(path='hello', validation={'name': {'type': 'string', 'required': True}})
def say_hello(session: HttpSession):
    name = session.get_parameter('name')
    if name is None:
        name = ''
    return f'Hello {name}'Run them using Flask or as AWS Lambda function without any changes to your code.Build in endpoints/health- Returns 200 if every thing is OK (e.g:{"status":"OK","timestamp":"2022-07-25 06:18:54.214674"})/<access_key>/set_log_level/<level>- Set log level/<access_key>/quickbe-server-info- Get verbose info on the server (endpoints and packages)/<access_key>/quickbe-server-status- Get server status (uptime, memory utilization, request per seconds and log info)/<access_key>/quickbe-server-environ- Get all environment variables keys and values
Package: quickbelog
Quick using loggerThis small project purpose is to add nice and clean logs to your app.
Just import thequickbelog.Logclass wherever you need and start using it.
To make debugging easier by default it will include the name of the source file and line number in order to understand what code line is responsible for the output.Usage:from quickbelog import Log

Log.info(msg='This is an info message')
Log.debug(msg='This is a debug message')
Log.warning(msg='This is a warning message')
Log.error(msg='This is an error message')
try:
    raise ValueError('Just for testing')
except ValueError:
    quickbe.Log.exception('Something failed')Output2022-03-14 15:54:03,411 > INFO  test_logger.py(17) method: test_basic_log_message        This is an info message
2022-03-14 15:54:03,411 > DEBUG        test_logger.py(21) method: test_debug_message    This is a debug message
2022-03-14 15:54:03,411 > WARNING      test_logger.py(29) method: test_warning_message          This is a warning message
2022-03-14 15:54:03,412 > ERROR        test_logger.py(33) method: test_error_message    This is an error message
2022-03-14 15:54:03,412 > ERROR        test_logger.py(13) method: test_exception_logging        Something failed
Traceback (most recent call last):
  File ".\test_logger.py", line 11, in test_exception_logging
    raise ValueError('Just for testing')
ValueError: Just for testingHave fun :-)
Package: quickboard
QuickboardA simple Python package for creating quick, modular dashboardsOverviewQuickboard is a collection of Python classes and utilities for making scalable dashboards. Built on top ofDashandPlotly, Quickboard provides
an assortment of tools and pre-made components to mix and match, achieving a balance between ease-of-use and
customizability.The following example was made using Quickboard.The Quickboard package contains three subpackages of interest for developing dashboards:base - the core components used to make the backbone of the dashboard,plugins - highly customizable add-ons to augment your other components,(EXPERIMENTAL) textboxes - components for having dynamically updated text.More details on using these can be foundbelow.Install GuideTo install, simply runpip install quickboardin your virtual environment.UsageOnce you have some datasets you'd like to visualize and present with a dashboard, you can start making
Quickboard components to achieve this purpose. Check out theComponent Galleryto see what
you can create with just a few lines of code.Once you have a few components you'd like to put together into a larger app, or to take advantage of using tab-level
plugin interactions, you can use a few of the other Quickboard classes to achieve this. The general layout of a full
Quickboard consists of:aQuickboardobject to hold everything together;a (n optional) list ofBaseTabobjects to organize visuals into tabs;aSidebarcalibrated to hold differentpluginsbased on the current tab.Within each tab, we havevariousContentGridobjects to display other components in a grid, with customizable column wrapping length;differentDynamicPanelobjects, materialized in the form of aPlotPanelorDataPanel, which house the
primary data displays, updatable via the sidebar plugins and other panel specificControlPluginobjects.Understanding how to compose and mix these components will allow for a huge variety in producible dashboards. For more
info on how to use them, check out the docstrings (e.g.help(ContentGrid)) or see theGuided Example.
Package: quickbooks-desktop
quickbooks_desktopA Python 3 library for QuickBooks Desktop API.The purpose of the project is to make QuickBooksDesktop more accessible in Python. This libraryuses QBXML instead of QBFC.Python 32 Bit vs. 64 BitUntil 2022, QuickBooks was a 32 bit program.  Becauseof this, you will need to use a 32 bit version of Python.In 2022 QuickBooks did upgrade to 64 bit so if you're usingQuickBooks version 2022 (or 22.0 for Enterprise) thena 64 bit version of Python may work.InstructionsThis package will handle all the complexities of dealing withSession Manager.Getting HelpFor a look at xml code you can go to QuickBooksOnscreen ReferenceDiscussion and DevelopmentMost development discussions take place on GitHub in this repo.
Package: quickbooks-py
Python Library for interfacing with Quickbooks Accounting API v3 found athttps://developer.intuit.com/docs/api/accountingFree software: ISC licenseHistory0.1.3 (2015-09-27)First release on PyPI.0.1.4 (2015-10-15)Updated requests library0.2.0 (2016-01-23)Added an api to disconnect from quickbooks0.2.1 (2016-01-23)Making Resource name case insensitive0.2.2 (2016-02-19)Bugfix in parsing query response when the response is empty
Package: quickbuild
Package supports sync and async syntax with same code base.fromquickbuildimportAsyncQBClient,QBClientDocumentationPackage Read the DocsOfficial REST API documentationAvailable REST API ClientsInstallationpip3installquickbuildExamplesGet server version:fromquickbuildimportQBClientclient=QBClient('https://server','user','password')version=client.system.get_version()print(version)Get server version in async way (be carefulAsyncQBClientmust be called inside async function):importasynciofromquickbuildimportAsyncQBClientasyncdefmain():client=AsyncQBClient('https://server','user','password')version=awaitclient.system.get_version()print(version)awaitclient.close()asyncio.run(main())Stop build:fromquickbuildimportQBClientclient=QBClient('https://server','user','password')client.builds.stop(123)Update credentials handler:importasyncioimportaiohttpfromquickbuildimportAsyncQBClientasyncdefget_credentials():asyncwithaiohttp.ClientSession()assession:asyncwithsession.get('...')asresp:response=awaitresp.json()returnresponse['user'],response['password']asyncdefmain():client=AsyncQBClient('http://server','user','password',auth_update_callback=get_credentials)# let's suppose credentials are valid nowprint(awaitclient.builds.get_status(12345))# now, after some time, password of user somehow changed, so our callback# will be called, new credentials will be using for retry and future here# we get also correct build info instead of QBUnauthorizedError exceptionprint(awaitclient.builds.get_status(12345))awaitclient.close()asyncio.run(main())Content typeBy default QuickBuild returns XML content, but starting from 10 version it also
has native support of JSON content, usually it’s much more convenient to use
native Python types (parsed XML) instead of pure XML string.So, that is why three types of content were indtoduced, this type and behavior
can be set globally for client instances, and can be rewritten for some methods.PARSE (using by default)GET: parse XML to native Python types.POST: pure XML string.XMLGET: return native XML without any transformations.POST: pure XML string.JSON (QuickBuild 10+)GET: parsed JSON string.POST: dumps object to JSON string.DevelopmentIt’s possible to run QuickBuild community edition locally using docker:Build locally:dockerbuild.-fdocker/QB10.Dockerfile-tquickbuild:10dockerrun--restartalways--nameqb10-d-p8810:8810quickbuild:10Or run prepared image:dockerrun--restartalways--nameqb10-d-p8810:8810pbelskiy/quickbuild:10Then openhttp://localhost:8810/TestingPrerequisites:toxThen just run tox, all dependencies and checks will run automaticallytoxContributingFeel free for any contributions.
Package: quick-cache
A quick and easy to use python caching system.You can installquick_cacheviapipinstall--userquick_cacheand import it in python using:fromquick_cacheimportQuickCacheCreate the cache object as follows:defmsg(message,*args,**kwargs):print(message.format(*args,**kwargs),file=sys.stderr)cache=QuickCache(base_file,quota=500,ram_quota=100,warnings=msg)wherebase_fileis an optional file whosecontentinvalidates the
cache (ie., when the content of the file changes the cache is
invalidated; for large files it might be desirable to use themtimein
the cache object below) andmsgis an optional formatting function
that prints warnings (by default it’sNonewhich doesn’t print
anything; warnings are emitted when the actual computation is faster
than reading the results from the cache or if other exceptional
situations occur).quotaandram_quotaare optional maximal
cache sizes, both in RAM and on disk, in MB.The caching functionality can then be used via:withcache.get_hnd({# object identifying the task to cache# can be any combination of keys and values"param_a":5,"input_file_c":os.path.getmtime(input_file_c),# for file change time...})ashnd:ifnothnd.has():res=hnd.write(do_compute())# compute your result hereelse:res=hnd.read()# your result is in resThe cache object used for creating the handle uniquely defines the task.
The object should contain all parameters of the task and the task
computation itself should be deterministic.
Package: quickcal
QUICK CALCULATIONThis library will help to calculate numbers quickly.How to install?'''
pip install quickcal
'''initializing package'''
from quickcal import QuickCalnum_1 = 16
num_2 = 8cal = QuickCal(num_1, num_2)
'''for addition'''
cal.addition()
'''for substraction'''
cal.substraction()
'''for multiplication'''
cal.multiplication()
'''for division'''
cal.division()
'''
Package: quickcalc
Quick CalcThis package will help you Calculate Numbers Quickly.How to Install it?On Windowspip install quickcalcOn Linux:sudo pip3 install quickcalcHow to use it?Initializing Packagefrom quickcalc import QuickCalc

num_1 = 8
num_2 = 1

calc = QuickCalc(num_1, num_2)Adding Numberscalc.addition()Substracting Numberscalc.substraction()Multiplying Numberscalc.multiplication()Dividing Numberscalc.division()
Package: quick-cd
Quick cdQuick cd is little tool allowing you to save any directory under a label, so you can quickly cd into it with out giving whole path.Instalationpip install quick-cdUsageTo save current location under label "my_location" useqcd -c my_locationYou can also, specify relative or absolute path, to save it instead of current directory.qcd -c my_location ../different_dirTo cd into saved location, simply give label without any additional argumentsqcd my_locationTo remove previously saved location useqcd -d labelTo list all saved locationsqcd -l
Package: quickcerts
quickcertsQuick and easy X.509 certificate generator for SSL/TLS utilizing local PKI:heart: :heart: :heart:You can say thanks to the author by donations to these wallets:ETH:0xB71250010e8beC90C5f9ddF408251eBA9dD7320eBTC:Legacy:1N89PRvG1CSsUk9sxKwBwudN6TjTPQ1N8aSegwit:bc1qc0hcyxc000qf0ketv4r44ld7dlgmmu73rtlntwFeaturesEasy to use.Genarates both client and server certificates.Produces certificates with proper attributes (Key Usage, Extended Key Usage, Authority Key Identifier, Subject Key Identifier and so on).Supports certificates with multiple domain names (SAN, SubjectAlternativeName).Supports wildcard certificates.Generates PKCS12 (.pfx, .p12) as wellRequirementsPython 3.4+cryptography 1.6+InstallationFrom sourceRun this command within source directory:pip3install.From PyPIpip3installquickcertsSnap StoresudosnapinstallquickcertsDockerFor deployment with Docker see "Docker" section below.Usage examplequickcerts-D*.example.comexample.com-Dwww.example2.comexample2.commx.example2.com-C"John Doe"-C"Jane Doe"quickcerts-Dlocalhost127.0.0.1These commands will produce following files in current directory:CA certificate and keyTwo server certificates having multiple DNS names or IP addresses in SubjectAlternativeName fields and keys for that certificates.Two client certificates for CN="John Doe" and CN="Jane Doe" (and keys for them).Consequent invokations will reuse created CA.DockerAlso you may run this application with Docker:dockerrun-it--rm-v"$(pwd)/certs:/certs"\yarmak/quickcerts-Dserver-Cclient1-Cclient2-Cclient3In this example CA and certificates will be created in./certsdirectory.Synopsis$ quickcerts --help
usage: quickcerts [-h] [-o OUTPUT_DIR] [-k KEY_SIZE] [--kdf-rounds KDF_ROUNDS]
                  [-D DOMAINS [DOMAINS ...]] [-C CLIENT] [-P PASSWORD]

Generate RSA certificates signed by common self-signed CA

options:
  -h, --help            show this help message and exit
  -o OUTPUT_DIR, --output-dir OUTPUT_DIR
                        location of certificates output (default: .)
  -k KEY_SIZE, --key-size KEY_SIZE
                        RSA key size used for all certificates (default: 2048)
  --kdf-rounds KDF_ROUNDS
                        number of KDF rounds (default: 50000)
  -D DOMAINS [DOMAINS ...], --domains DOMAINS [DOMAINS ...]
                        Generate server certificate which covers following
                        domains or IP addresses delimited by spaces. First one
                        will be set as CN. Option can be used multiple times.
                        (default: None)
  -C CLIENT, --client CLIENT
                        Generate client certificate with following name.
                        (default: None)
  -P PASSWORD, --password PASSWORD
                        password for newly generated .pfx files (default:
                        password)
Package: quick-cli
Quick CLIThe Quick CLI lets you manage your Quick instance.
For more information on how to work with it, see ouruser guide.Set upThe CLI is a Python project and you can install via pip:pipinstallquick-cliThe first step after installing the CLI is creating a new context.
Ouruser guideprovides further information.ReferenceThere is alist of all commandsas a reference.
Additionally, you can run all commands with-hor--helpto display a help message.ContributingTheCLI's developer guideprovides more information on how to setup the project and the project's layout.
For general information, check out out thecontributing guide.
Package: quickclone
QuickCloneCommand line utility for quickly cloning remote SCM repositories as succintly as possible.This project is a prime example of spending 24 hours to save 2 seconds.NotesCurrently, only git is supported. I might add mercurial and then subversion
later.InstallationFrom source:gitclonehttps://github.com/RenoirTan/QuickClone.gitcdQuickClone
pipinstall.FromPYPI:pipinstallquickcloneBoth ways should installqklnandquickcloneto PATH, meaning you don't have
to call quickclone usingpython -m quickclone.qklnandquickcloneare
both entry points to the samemainfunction, so you can call either command.ConfigurationYou can configure QuickClone by editing~/.config/quickclone.toml.ExamplesqklnRenoirTan/QuickCloneIfoptions.local.remotes_diris defined, QuickClone will clone the repo into
a folder in that directory. For example, ifoptions.local.remotes_diris
defined as~/Code/remote, the repo will be cloned to~/Code/remote/github.com/RenoirTan/QuickClone.You can also overrideoptions.local.remotes_dirby specifying the destination
path or adding the-Idflag to the command.qklnRenoirTan/QuickClone~/Desktop/destinationqklnRenoirTan/QuickClone-IdIn the latter example, QuickClone will ignoreoptions.local.remotes_dirand
clone to./QuickClone.After cloning the remote repository, QuickClone will save where the repository
was cloned to locally in a cache file. You can then use this command to see
where the last repository was cloned to:qkln-Land then cd into that directory:cd$(qkln-L)
Package: quickconf
quickconfSimple and flexible TOML-file based configurations frameworkIfTOML Kitis installed,quickconfwill use that and supports both reading and writing configuration files. Iftomlkitis not available,quickconfwill use the Python system librarytomllibbut will support only reading of configuration files.Installquickconfwith optional dependencysaveto ensuretomlkitis also installed:pip install quickconf[save]
Package: quick-config
QuickConfigDescriptionQuickConfig is a super lightweight dynamic config provider for python applications.
The config provider uses a runtime config that can be imported to any part of your
application.quick_configparses and loads your environment configs only once
based on the runtime environment, and the built configs can be imported anywhere
in your application!FeaturesBuilds modular configs which overwrite a base config based on the config required
for the application run time environment. Ex: thebaseconfig will be overwritten
by thedevelopmentconfig if the app is running in thelocalordevelopmentruntime environment.Has a built-in API for queryable environment flags likeconfig.is_dev()orconfig.is_prod()for environment specific code pathsCreates a simple logger with a console and file handler at application run time
which can be used anywhere in the application after importing thequick_configconfig.Creates callable methods on the globally loadedconfigobject which mirror the
names of the configs allowing engineers to call the methods in the app for their values
instead of doing config lookupsAllows for indexable accessors to configs which are collections. I.e., lists, tuples
or maps/dictionariesInstallation$>pipinstallquick_configDesignThe quick config provider relies on a standard structure for an application's
configurations. All configurations must be provided in aconfigdirectory.
Configs in theconfigdirectory must follow the standard deployment configuration
names likestaging.pyortest.pyorproduction.py. Once the runtime environment
is set via an environment variable calledenvironment, the config provider will read
that and populate the configs available to the entire application as callable methods
which can also be indexed if the provided congig is a collection (list,
tuple, or map).UsageCreate an application like a Django/Flask Application which has runtime configs which may
differ for each run time environment using the following nomenclature:create a directory calledconfigcreate files in the directory with the following structure# config/base.py:importosENV_VARS={"some_api_key":os.environ.get('my_api_key'),"db_name":"my_default_db","db_driver":"inmemory_sqlite","important_array":['a','b','c','d']}# config/production.py:importosENV_VARS={"db_name":os.environ.get("production_db"),# overwrites base.py"db_driver":"mysql","important_array":[1,2,3,4]# overwrites base.py}# config/development.py:ENV_VARS={"db_name":"my_dev_db",}Note the use ofENV_VARSin each environment file. That is requiredInstall thequick_configpackagepip install quick_configUse the environment vars in your application directly:# in my_app/my_module/file.pyfromquick_configimportconfigclassMyModule:def__init__(self):self.logger=config.get_logger()self.api_key=config.some_api_key()# depending on environment, this will changeself.important_index_value=config.important_array(0)db_connection_info={"db_name":config.db_name(),"driver":config.driver(),}
Package: quickcpp
quickcppquickcppis a small command-line tool to quickly build and run a single C++ file. Handy for quick experimentations.UsageThe simplest usage isquickcpp <path/to/some/cppfile>. When called like this,quickcppbuilds the file (producing aa.outfile) and runs the result.$ cat examples/helloworld.cpp 
#include <iostream>

int main(int argc, char** argv) {
    std::cout << "Hello world!\n";
    return 0;
}

$ quickcpp examples/helloworld.cpp 
- Building ---------------------
c++ examples/helloworld.cpp -Wall -fPIC -std=c++17 -g
- Running ----------------------
Hello world!Using other librariesWant to experiment something withQtWidgets? You can specify any installed pkg-config compliant packages using-p <package>:$ cat examples/qt.cpp 
#include <QApplication>
#include <QMainWindow>

int main(int argc, char** argv) {
    QApplication app(argc, argv);

    QMainWindow window;
    window.setWindowTitle("Hello World");
    window.show();

    return app.exec();
}

$ quickcpp -p Qt5Widgets examples/qt.cpp 
- Building ---------------------
c++ examples/qt.cpp -Wall -fPIC -std=c++17 -g -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -I/usr/include/x86_64-linux-gnu/qt5/QtWidgets -I/usr/include/x86_64-linux-gnu/qt5 -I/usr/include/x86_64-linux-gnu/qt5/QtGui -I/usr/include/x86_64-linux-gnu/qt5 -I/usr/include/x86_64-linux-gnu/qt5/QtCore -I/usr/include/x86_64-linux-gnu/qt5 -lQt5Widgets -lQt5Gui -lQt5Core
- Running ----------------------You should see a window like this one:Any package listed bypkg-config --list-allcan be used byquickcpp.Live reloadquickcppcan useentrto automatically rebuild and rerun your file. Just installentrand runquickcppwith the-lflag.InstallationThe recommended solution is to usepipx:pipx install quickcppBut you can also install it withpip:pip install --user quickcppLicenseApache 2.0