Saravanan666/pypi-org huggingface dataset:
Package: quickpathstr
QuickPathStrCopyright (c) 2023 Sean Yeatts. All rights reserved.This module provides syntax for working with strings in the context of file
management. It's designed to reinforce a universal nomenclature by which files,
their types, and their directories may be referred.API ReferenceThe core of the API is captured within theFilepathclass:classFilepath:# Deconstructs a complete filepath into its constituent elementsdef__init__(self,complete:str)->None:self.complete=complete# Ex: C:\Users\myself\Desktop\MyFile.txtself.directory=str(Path(self.complete).parent)# Ex: C:\Users\myself\Desktopself.name=str(Path(self.complete).name)# Ex: MyFile.txtself.root=str(Path(self.complete).stem)# Ex: MyFileself.extension=str(Path(self.complete).suffix)# Ex: .txt
Package: quickpiggy
QuickPiggyLaunch an impromptu PostgreSQL server, hassle free.Prerequisites:postgresql-server (tested with v9.0 - v13.2), providingpostgres,initdbandcreatedbon your$PATHpostgresql libraries and clients (tested with v9.0 - v13.2), providingpsqlon your$PATHThis is mainly a library module, but you can take it for a for a demo spin by runningquickpiggy.pyas a program (python quickpiggy.py).When used as a library, an ephemeral PostgresSQL instance can be obtained quite easily:pig=quickpiggy.Piggy(volatile=True,create_db='somedb')conn=psycopg2.connect(pig.dsnstring())Many use cases can be accommodated for by supplying appropriate parameters to the constructor of Piggy.This version works with Python 2.7 and 3.1+.
Package: quick-plot
quick plotThe scripting interface of matplotlib is stateful, therefore
dangerous. The object oriented interface to the plotting library is
polluted. This tiny library combines the two interfaces into one
context manager.fundamentIf this file is somewhere in your =$PYTHONPATH=, the following code
should produce a plot.´´´python
import numpy as np
import quickwith quick.Plot() as qp:
qp.plot(np.sin(np.linspace(0, 2 * np.pi)))
´´´The =Plot= class is the only available class in the =quick= module. It
should be instantiated exactly once. Its instance can do everything
the matplotlib axis object can do. For some methods, a default
configuration is supplied. There are some methods, that are not
contained in the axis object, for example =trajectory=, =field=, =points=,
=remove_border=, =remove_xticks=. When a method is called, that is neither
a method of the =axis= object, nor one of the additional methods of this
module, then the module =matplotlib.pyplot= is searched for a function
with that name, and, if it exists, it is called. When the context
manager is left, the plot shows up.arguments=Plot= takes optional arguments.
| =filename= | given that, the plot is not shown interactively, but saved as a file, default =None= |
| =figsize=  | a tuple, representing (width, height), default =(3, 3)=                              |
| =grid=     | if =True= shows a grid, default =False                                               |
all other optional arguments are directly passed to =matplotlib.pyplot.subplot=.short formIf you just want to quickly see some of your data, and you do not want
to do any customization of the plotting result, the context manager is
a bit of a boilerplate. So there is the following shorthand for the
previous script.´´´python
import numpy as np
import quickquick.plot(np.sin(np.linspace(0, 2 * np.pi)))
´´´The context manager is called implicitly.more convenienceThe quick module additionally provides a few methods that are not
directly related to the =matplotlib= plotting facility, e.g.=colored=: takes a list of array and return an iterator with tuple,
with the data and a color, that can be past to the color argument of
plotting methods. Optional argument is the name of a colormap=landscape=, =portrait=: they return tuples that can be past to the
=figsize= argument of =Plot=, internally using the golden ratio.=tex=: surround a string by dollar signs.drawbackThere is no interactive workflow anymore with this approach. I like
that way of working, because due to script restarts you eliminate all
errors in your script, that may occur from state changes from the
past, that confuses the (fragile) python module system.
Package: quickplotter
Instant EDAInstantly generate common exploratory data plots without having to worry about cleaning your data.Note: To find the most updated documentation, visit the Githubrepo.Description: Thequickplottermodule provided here is meant to provide common exploratory data plots without having to worry about cleaning your DataFrame or preanalyzing your data. Additionally, these plots can be exported to.{png, jpeg}for use in reports and papers.1. Basic Usage:plotter=quickplotter.QuickPlotter(df:pd.DataFrame)#creates a QuickPlotter object with the given DataFrameplotter.common(subset=['correlation','percent_nan'])#plots correlation between features, and percent nan in each columnplotter.distribution(column_subset=df.columns[0:4])#plots distributions for the first four columns in the DataFrameplotter.common(column_subset=['body_mass_index','blood_type'])#plots common plots for the given columns2. FundamentalsIf the number ofNaNvalues in the DataFrame is<= 5%of the total values, the NaN rows will be dropped and the plots will be generated without them.Remember, this is meant to be a quick and dirty tool for exploration, and not for being delicate with each data entry.subset & diff listsThe quickplot module works mainly with two specifications,subsetanddiff.For anysubset-like list, the items in the list will be used. For anydiff-like list, all itemsexceptthose in the list will be used.The options are as follow:subset: Use only the plots specified in the listdiff: Use all plotsexceptthose specified in the listsubset_columns: Use all columns specified in the list. Can either bedf.columnsslicing or by namediff_columns: Use all columnsexceptthose specified in the list. Can either bedf.columnsslicing or by name.3. ContributingIf you have read this far I hope you've found this tool useful. I am always looking to learn more and develop as a collaborative programmer, so if you have any ideas or contributions, feel free to write a feature or pull request.
Package: quickpomdps
quickpomdps - pythonquickpomdpsis a package to quickly define[PO]MDPsin Python.
You can use any of the solvers inPOMDPs.jlecosystem, directly in Python.A hybrid continuous-discrete light-dark problem definition and QMDP solution (taken fromexamples/lightdark.py) looks like this:r=60light_loc=10deftransition(s,a):ifa==0:returnDeterministic(r+1)else:returnDeterministic(min(max(s+a,-r),r))defobservation(s,a,sp):returnNormal(sp,abs(sp-light_loc)+0.0001)defreward(s,a,sp):ifa==0:return100.0ifs==0else-100.0else:return-1.0m=QuickPOMDP(states=range(-r,r+2),actions=[-10,-1,0,1,10],discount=0.95,isterminal=lambdas:s<-rors>r,obstype=Float64,transition=transition,observation=observation,reward=reward,initialstate=Uniform(range(-r//2,r//2+1)))solver=QMDPSolver()policy=solve(solver,m)Installationpipinstallquickpomdpsquickpomdpsuses thepyjulia packagewhich requires julia to be installed. We recommend usingjuliaupfor this purpose.Upon invocation ofimport quickpomdsin Python, all Julia dependencies will be installed if they are not already present.
Please note that, by default, the Julia dependencies are added to theglobalenvironment.
If you want to install these dependencies to a local environment instead, export theJULIA_PROJECTwith the desired path as documentedhere.DevelopmentThis package usespython-poetryfor dependency
management. Thus, it may be installed via one of the mayways supported by poetry, for example,gitclonehttps://github.com/JuliaPOMDP/quickpomdpscdquickpomdps
poetryinstall
poetryrunpythonexamples/lightdark.pyUsageSeeexamples/andtests/. Documentation can be found at theQuickPOMDPs.jlandPOMDPs.jlpackages.HelpIf you need help, please ask on thePOMDPs.jl discussions page!
Package: quickpool
quickpoolUse ProcessPoolExecutor and ThreadPoolExecutor from concurrent.futures with a progress bar and less boilerplate.InstallationInstall with:pip install quickpoolUsage>>> import random
>>> import time
>>> import quickpool
>>> def naptime(base_duration: float, multiplier: float, return_val: int)->int:
...   time.sleep(base_duration * multiplier)
...   return return_val
...
>>> def demo():
...   iterations = 25
...   pool = quickpool.ThreadPool(
...   functions = [naptime] * iterations,
...   args_list = [(random.random() * 5, random.random()) for _ in range(iterations)],
...   kwargs_list = [{"return_val": i} for i in range(iterations)])
...   results = pool.execute()
...   print(results)
...
>>> demo()
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 3s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
Package: quick-pp
quick_ppPython package to assist in providing quick-look/ preliminary petrophysical estimation.Free software: MIT licenseDocumentation:https://quick-pp.readthedocs.io.FeaturesTODOHistory0.1.0 (2023-10-08)First release on PyPI.0.1.2 (2024-01-19)Refactor config.0.1.3 (2024-01-20)Update requirements.0.1.4 (2024-02-04)Update docstrings.
Package: quickproxy
A lightweight, asynchronous, programmable HTTP proxy for python. Built with Tornado.## Use#### A simple proxy:import quickproxy
quickproxy.run_proxy(port=8080)#### A reverse proxy:This proxy will fetch responses from an AWS s3 bucket with the same ID as the request’s hostname.def callback(request):request.host = request.host+”.s3-website-us-east-1.amazonaws.com”
request.port = 80
return requestquickproxy.run_proxy(port=8080, req_callback=callback)## ReferenceQuickproxy exposes just one function:run_proxy(port,methods=[‘GET’, ‘POST’],
req_callback=DEFAULT_CALLBACK,
resp_callback=DEFAULT_CALLBACK,
err_callback=DEFAULT_CALLBACK,
start_ioloop=True)It runs a proxy on the specified port. You can pass the following parameters to configure quickproxy:methods: the HTTP methods this proxy will supportreq_callback: a callback that is passed a RequestObj that it shouldmodify and then return. By default this is the identity function.resp_callback: a callback that is given a ResponseObj that it shouldmodify and then return. By default this is the identity function.err_callback: in the case of an error, this callback will be called.there’s no difference between how this and the resp_callback are
used. By default this is the identity function.start_ioloop: if True (default), the tornado IOLoop will be startedimmediately.### Request callback functionsThe request callback should receive a RequestObj and return a RequestObj.request_callback(requestobj)return requestobjThe RequestObj is a python object with the following attributes that can be modified before it is returned:protocol: either ‘http’ or ‘https’host: the destination hostname of the requestport: the port for the requestpath: the path of the request (‘/index.html’ for example)query: the query string (‘?key=value&other=value’)fragment: the hash fragment (‘#fragment’)method: request method (‘GET’, ‘POST’, etc)username: always passed as None, but you can set it to override the userpassword: None, but can be set to override the passwordbody: request body as a stringheaders: a dictionary of header / value pairs(for example {‘Content-Type’: ‘text/plain’, ‘Content-Length’: 200})follow_redirects: true to follow redirects before returning a response### Response callback functionsThe response and error callbacks should receive a ResponseObj and return a ResponseObj, similar to the request callback above.The ResponseObj is a python object with the following attributes that can be modified before it is returned:code: response code, such as 200 for ‘OK’headers: the response headerspass_headers: a list or set of headers to pass along in the response. Allother headers will be stripped out. By default this includes:(‘Date’, ‘Cache-Control’, ‘Server’, ‘Content-Type’, ‘Location’)body: response body as a string## CreditsMuch of this code was adopted from Senko’s tornado-proxy:https://github.com/senko/tornado-proxy…which is itself based on the code by Bill Janssen posted to:http://groups.google.com/group/python-tornado/msg/7bea08e7a049cf26
Package: quickpt
About The ProjectThis is a small Python Function that allows you to see the variance, percentage of missing values and unique values within a dataset.pip install quickptfromquickpt.quickptimportquickptquickpt(df,graph=None,encode=True,width=800,height=400)More information on the projectGitHubContributingContributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestChange Log0.0.1 (06/02/22)First Release
0.0.2 (06/02/22)Update Readme and GitHub Link
0.0.3 (06/02/22)testing until working
0.0.4 (06/02/22)testing until working
0.0.5 (06/02/22)Set encoder default to False
0.0.6 (06/02/22)added width and height parameters for graph visualization
0.0.7 (06/03/22)fixed variance calculation
Package: quickpython
Read Latest Documentation-Browse GitHub Code RepositoryQuickPYTHONA retro-futuristic educational interactive coding environment. Powered by Python and nostalgia.Key featuresMouse supportFuturistic blue color schemeAuto-formattingIntegrated Debugging SupportQuick shortcuts for creating new dataclasses, static methods, etcBuilt-in helpGames!Quick Start Instructionspipinstallquickpythonthen start withqpythonorquickpythonDisclaimer: This project is provided as-is, for fun, with no guarantee of long-term support or maintenance.
Package: quickq
# Django Quick QueueDjango Quick Queue is a fast and simple way to use async tasks in Django. This package has a limited use case. If you are looking for a more complex async task systems you should try Django Q, Celery, or Huey. Quick Queue is meant to give you the simplest method to get started executing small asynchronous tasks.# Installation### 1. Install Package`pip install quickq`### 2. Add Base URL to settings.py```pythonQQ_BASE_URL = 'https://mysite.example.com'```### 3. Setup the view in your urls.py```pythonfrom quickq import taskinatorurlpatterns = [url(r'^taskinator/(\S+)$', taskinator, name="taskinator"),...]```### 4. Add the Task decorator to any function```pythonfrom quickq import Task@Task()def send_approved (name, slug, email):send_mail('Yay E-mail!',message,settings.DEFAULT_FROM_EMAIL,[email],fail_silently=False,)# With a custom Timeout@Task(timeout=120)def another_task ():do_stuff()```### 5. Execute your task as normal```pythonsend_email('Narf', 'narf-me', 'narf@aol.com')```## How it Works1. Your task is called1. A PyJWT is generated.2. The taskinator URL is called asynchronously.2. Taskinator view executed1. Decodes the JWT.2. Excutes the original task function outside of the original request.## Limitations- Function arguments are converted to JSON so they must be JSON compatible.- Request time may be limited. If your webserver has a limitation on request time then that will also affect how long your tasks can execute since they are simply web requests. The request is also limited by the `QQ_REQUEST_TIMEOUT` setting.## Additional Settings```QQ_TOKEN_EXPIRATION: Default 60QQ_TOKEN_ALGORITHMS: Default ['HS256']QQ_URL_NAME: Default 'taskinator'QQ_REQUEST_TIMEOUT: Default 60```## ScalingWhile Quick Queue is limited it still could scaled in with a few tricks.- Run a separate web server just for Queue tasks. This would allow you scale your task queue differently and change your request timeout values.- additional?## Future Goals- add task retries- multiple queue URLs
Package: quick_qemu
installpip3 install quick_qemuexecutepython-mquick_qemu<pathtocd><pathtoimage><argument1><argument2>...
or
quick_qemu<pathtocd><pathtoimage><argument1><argument2>...environmentQUICK_QEMU_OUTPUT: set output, default spice-appQUICK_QEMU_NOGL: if set disables ql renderingQUICK_QEMU_CPU: change virtual cpuQUICK_QEMU_MACHINE: change virtual acpiexamplepython-mquick_qemu~/Downloads/archlinux.iso
Package: quickregress
quickregressPolynomial regression for the lazyquickregressis a minimalist wrapper for sklearn's polynomial and linear regression functionality, intended to reduce the amount of effort needed for simple regression operations.quickregressprovides one function:regress(x, y, degree).regressreturns aRegressionResult, which has the following methods:predict(x)returns the model's predictions for a list of x values.formula(digits=6, latex=False)returns the model's formula as a string.digitschanges the number of significant digits, andlatexoutputs a LaTeX-friendly string (for use with Jupyter and the like).
Package: quickremi
This library wraps the popular Python library "REMI" (https://github.com/rawpython/remi) to make easy UI by simply calling functions with arguments for UI placement. Quick Remi enables building building large UI in the least lines of code using pure Python. No HTML or javascript knowledge required.USAGE:pip install quickremifrom quickremi.gui import gui as GBuild Frame or Container
frame1 = G.create_container(window, H=40, W=45, L=52, T=20, bg='lightblue')Build Labels
lbl = G.create_label(frame1, H=50, W=75, L=5, T=2, bg='ivory')Build Buttons
btn= G.create_button(frame1, H=10, W=15, L=5, T=20, bg='teal', command=clicked_button)Use the function help menu to read their respective documentation.
In all functions, frame, H, W, L, T are positional (mandatory) arguments that determine their position within a container.
Other arguments like background colours, font family, size, font colour, text alignment, justifications, border width, radius, style and border colour etc. are optional and can be changed as per use.Height, Width, Left and Top are % values by default and hence scale as per the size of the device of display.
The arugment 'fs' (font size) also scales as per the display device.Other Widgets in the package:
- Drop Down
- List Items
- Slider
- Image
- File Uploader
- Table
- Progress Bar
- Entry Field
- Date Picker
- Label Checkbox (Radio Button)
- SpinboxAll the above widgets follow the same syntax.
- Frame, Height, Width, Left, Top, and other kwargs whose documentation is available in the help menu.Widgets like Drop Down, Slider, List Items, Entry Field have listeners which read the input values entered by user.Example 1:
For: Drop Down or Entry or Slider etc.lst = ['Tiger', 'Lion', 'Jaguar']
dd = G.create_dropdown(frame1, lst, 20, 50, 5, 5, command=on_selection)Listner functiondef on_selection(widget, value):
# value will now hold the value of the user selection between tiger lion and jaguar.
print(value)Example 2:
For List Items, the listener functions in a different way. Following is the example usage.lst = ['Apple', 'Mango', 'Guava']
lv = G.create_listview(frame1, lst, 20, 50, 5, 5, command=on_value_selection)Listener functiondef on_value_selection(widget, value):
# value is the index number. Hence lv[val].get_text() is used to fetch the actual text value.val = lv.children[value].get_text()print(val)All the other widget operations revolve around these two examples.
Package: quickrepo
quickrepoIt is quite boring everytime typinggit initin your local computer then go to github and initialize a new repository, take the remote url and add it to the local... I am already tired just by explaining. Thanks Godquickrepoexists.quickrepo is a command-line application that automates initializing a new repository both locally and on GitHub. The user can either initialize the repository in the directory they are currently working in, or generate a brand new folder which will come initialized as a git and github repository.RequirementsPython 3.6+Installationinstall the official package from PyPIpip install quickrepoIf you have multiple versions of Python installed in your system, usepip3 install quickrepoinstead.or install editable source codegit clone github.com/silverhairs/quickrepo.git
cd quickrepo
pip install --editable .UsageRunquickrepoto list all the available commands.Initialize a new Git & Github repositoryTo generate a brand new project both locally and on Github, open your terminal/command prompt and run:quickrepo newInitialize current working directory as Git & Github repositoryTo initialize a Git repository in the current working directory and push the content on Github, open your terminal/command prompt and runquickrepo here
Package: quick-rest
quick_restA versatile wrapper for REST APIs.DependenciesThe sole non-builtin dependency isrequests.InstallationUse pip to install.python -m pip install quick_restUsageNo full documentation at this time, maybe someday I'll get around to it...You can get and post right now, and use the auth methods listed below. You can pass anyrequestsgetorpostkwarg in on theClient.getandClient.postmethods.AuthenticationYou can currently use no authentication, key authentication and JWT authentication.No Authenticationfromquick_restimportClienturl='https://cat-fact.herokuapp.com/'client=Client(url)route='facts'response=client.get(route)Keyfromquick_restimportKeyClienturl='https://www.haloapi.com/'creds={'keyname':'somekeyhere'}client=KeyClient(url,creds)route='stats/hw2/xp?players=LamerLink'# check out my sweet Halo statsresponse=client.get(route)JWT (JSON Web Token)fromquick_restimportJWTClienturl='https://some-jwt-client.com/'creds={'username':'someusername','password':'somepassword'}# We need to specify the names for the auth_route, token_name, and jwt_key_name.client=JWTClient(url,creds,'auth','access_token','Authorization')route='v0/some/route/results.json'response=client.get(route)ResultsResults come in the form of aServerResponseobject. You can access theraw_contentattribute or use thedecode,get_value,to_txtandto_csvmethods to get the data from the object.raw_response=response.raw_responsedecoded_response=response.decode()# utf-8 by defaultdecoded_response=response.decode(encoding='utf-16')value=response.get_value(key_name)response.to_txt('some/path/file.txt')# dumps the raw response to fileresponse.to_csv('some/path/file.csv')# By default, to_csv sets \n to lineterminator and writes the header to fileresponse.to_csv('some/path/file.csv',lineterminator='\t',omit_header=True)Issues/SuggestionsPlease make any suggestions or issues on the Github page.To DoTests.Oauth client.LicenseThis project is licensed under the MIT License. Please see the LICENSE.md file for details.
Package: quickrpc
QuickRPC is a library that is designed for quick and painless setup of communication channels and Remote-call protocols.Python 3 onlyA remote interface is defined like so:from quickrpc import RemoteAPI, incoming, outgoing

class EchoAPI(RemoteAPI):
    '''Demo of how to use RemoteAPI.
    EchoAPI answers incoming `say` calls with an `echo` call.
    '''
    @incoming
    def say(self, sender="", text=""): pass

    @outgoing
    def echo(self, receivers=None, text=""): passThe interface is used over aTransport, which might e.g. be a TCP connection or Stdio:api = EchoAPI(codec='jsonrpc', transport='tcpserv::8888')
# on incoming "say", call "echo"
api.say.connect(lambda sender="", text="": api.echo(text=text))

# transport starts in a new thread.
api.transport.start()
input('Serving on :8888 - press ENTER to stop')
api.transport.stop()That’s it! You could now connect to the server e.g. via telnet:$ telnet localhost 8888
say text:"hello"(Exit via Ctrl+5 -> “quit”)INSTALLATIONRequirements: Basically none, except for Python >= 3. For theQtTransports, PyQt4 is required.Then:pip install https://github.com/loehnertj/quickrpc/archive/master.zipOr, download / clone and usepython setup.py install.LICENSEMIT License:https://github.com/loehnertj/quickrpc/blob/master/LICENSEDOCUMENTATIONPlease proceed tohttp://quickrpc.readthedocs.io/en/latest/index.htmlTODOThis is a hobby project. If you need something quick, contact me or better, send a pull request. :-)Things I might add in the future: In-process “loopback” transport; Serial interface transport;msgpackCodec.SSH support would be really cool but don’t hold your breath for that.