Saravanan666/pypi-org huggingface dataset:
Package: quackpanda
QuackPanda: SQL Capability for Pandas using DuckDB 🦆🐼quackpanda is a Python library designed to bring Spark-like SQL capabilities to Pandas DataFrames using DuckDB, allowing users to execute SQL queries and perform advanced database operations directly on DataFrames.FeaturesSeamless integration with DuckDB for executing SQL queries on Pandas DataFrames.
Efficient registration of DataFrames as temporary tables.
Supports a variety of SQL functionalities, offering flexibility in DataFrame manipulation.
Installation
To install quackpanda, use pip:pip install quackpandaQuick Start
Here's a basic example of how to use quackpanda to register a DataFrame as a table and execute a SQL query:importpandasaspdfromquackpanda.coreimportQuackPanda# Create a sample DataFramedata={'Name':['Alice','Bob'],'Age':[25,30]}df=pd.DataFrame(data)# Initialize QuackPandaqp=QuackPanda()# Register DataFrame as a temporary tableqp.register_temp_table(df,'people')# Execute SQL queryresult_df=qp.execute_query('SELECT * FROM people WHERE Age > 25')# Display the resultprint(result_df)DocumentationFor detailed information on quackpanda's features and usage, please refer to the official documentation (add the link to your documentation).ContributingWe welcome contributions to quackpanda! Please see our Contributing Guide for more details.Support & FeedbackFor support, questions, or feedback, please submit an issue on GitHub.Licensequackpanda is licensed under the MIT License.AcknowledgmentsSpecial thanks to the creators and contributors of Pandas and DuckDB for their incredible work, which made quackpanda possible.Make sure to adapt the file paths, URLs, and other specific information to match your project's actual details. Also, consistently update the README as your project evolves, adding new sections or modifying existing ones as needed.
Package: quackpass
QuackPassWorld's most secure password thingle thangle.Setuppip install quackpassYou need to be using a version greater then 3.6 for this library to work.UsageCODEfromquackpassimportquackpassmanager=quackpass.LoginManager(salt=os.environ['salt'],mode="txt",file="passwords.txt")manager.add_user("test","secretpassword")user=manager.login()print(f"Logged in as{user}")OUTPUTUsername: test
Password: secretpassword
Logged in as test
Package: quackprofile
PyPi:https://pypi.org/project/quackprofile/This Package Is To Show How A Duck Can Get A Profile In A CompanyHow To InstallOpen CMD / TerminalpipinstallquackprofileHow To UseOpen Idle And Type…..my=Profile('Quacker')my.hobby=['Youtuber','Play Games']print(my.name)my.show_email()my.show_myart()my.show_hobby()Made By LlamaIsTheBest Hope You Enjoy :D
Package: quackquack
DocumentationOverviewThis project aims to resolve problem of configuring an application, which needs to
have initialization step (for example: for gathering settings or establishing
connections) and use Python style code (context managers and decorators) with
dependency injection to get those data.For example, normally you would need to use two separate mechanism for connection
to the database (one for web, and one for celery). Mostly it uses the web framework
configuration, to use in the celery code. It is fine, until a third sub-application
arrives. Or you have many microservices, where web frameworks are different
depending on the microservice purpose.Second goal was to make synchronized code without any globals or magic. That is
why using Quack Quack you know when the application is initialized (started),
or where to look for code you are using.In order to use QQ, you don’t need to use hacks in some starting files, like
importing something from django, starting the application, and the import the
rest.Quick Using ExampleTo use Quack Quack you need to create the application class (inherited fromqq.Application) in which you need to add plugins. After configuring, you
need to “start” (initialize)
the application. After that you can use the application as context manager.
Also, you can make simple decorator, so you can use injectors (dependency
injection) in function’s arguments.fromqqimportApplicationfromqqimportApplicationInitializerfromqqimportContextfromqqimportSimpleInjectorfromqq.pluginsimportSettingsPluginfromqq.plugins.typesimportSettingsclassMyApplication(Application):defcreate_plugins(self):self.plugins["settings"]=SettingsPlugin("settings")application=MyApplication()application.start("application")withContext(application)asctx:print(ctx["settings"])app=ApplicationInitializer(application)@appdefsamplefun(settings:Settings=SimpleInjector("settings")):print(settings)samplefun()samplefun({"info":"fake settings"})# dependency injection !!context["settings"]in above example, is a variable made by the SettingsPlugin.
If you would like to know more, please go to theTutorialInstallationpipinstallquackquack
Package: quacks
If it walks like a duck and it quacks like a duck, then it must be a duckThanks toPEP544, Python now has protocols:
a way to define duck typing statically.
This library gives you some niceties to make common idioms easier.Installationpipinstallquacks⚠️ For type checking to work withmypy, you’ll need to enable the plugin in
yourmypy config file:[mypy]plugins=quacksFeaturesEasy read-only protocolsDefining read-only protocols is great for encouraging immutability and
working with frozen dataclasses. Use thereadonlydecorator:fromquacksimportreadonly@readonlyclassUser(Protocol):id:intname:stris_premium:boolWithout this decorator, we’d have to write quite a lot of cruft,
reducing readability:classUser(Protocol):@propertydefid(self)->int:...@propertydefname(self)->str:...@propertydefis_premium(self)->bool:...
Package: quad
QUAD: Quantum State DatabaseGraduate research project for CMSC 33550 (Introduction to Databases) at University of Chicago.Installation$pip3uninstallcirq# Fix possibly conflicting packages$pip3installquad# InstallUsageimportquaddimension=100store=quad.VectorStore('path/to/vector/database')# Load or create vector database# First time only: Add vectors to databaseforiinrange(10):prng=np.random.RandomState(i)base_vector=prng.normal(size=dimension)forjinrange(10):# Generate any vectorsvector=base_vector+np.random.normal(scale=0.05,size=dimension)info={'any-data':...}vid=store.add(vector,info)# Several hashes available: L2DistanceHash, MipsHash, StateVectorDistanceHashh=quad.lsh.L2DistanceHash.from_random(d=dimension,r=2.5,preproc_scale=1,)# Create locality sensitive collection of vectorscollection=quad.AsymmetricLocalCollection(vector_store=store,base_lsh=h,meta_hash_size=10,number_of_maps=10,prng=np.random.RandomState(seed=5),# Ensure consistent across runs)forvidinstore:collection.add(vid)# Query similar vectors:prng=np.random.RandomState(4)query_vector=prng.normal(size=dimension)# Some query vectorquery_vid=store.add(query_vector,{'type':'query'})norm=1#np.linalg.norm(query_vid)close_vids=set(collection.iter_local_buckets(query_vid,scale=1/norm))print('Possibly close vids:',close_vids)assertclose_vids==set(range(40,50))Benchmarks$gitclonehttps://github.com/cduck/quantum-state-database# Clone repo$cdquantum-state-database
$pipinstall-e.[dev]# Install dev requirements$pythonquad/benchmark/benchmark_generate.py# Generate test state vector data$pytestquad/benchmark/# Run all benchmarks
Package: quadax
quadax is a library for numerical quadrature and integration using JAX.vmap-able,jit-able, differentiable.Scalar or vector valued integrands.Finite or infinite domains with discontinuities or singularities within the domain of integration.Globally adaptive Gauss-Konrod and Clenshaw-Curtis quadrature for smooth integrands (similar toscipy.integrate.quad)Adaptive tanh-sinh quadrature for singular or near singular integrands.Quadrature from sampled values using trapezoidal and Simpsons methods.Coming soon:Custom JVP/VJP rules (currently AD works by differentiating the loop which isn’t the most efficient.)N-D quadrature (cubature)QMC methodsIntegration with weight functionsSparse grids (maybe, need to play with data structures and JAX)Installationquadax is installable withpip:pip install quadaxUsageimportjax.numpyasjnpimportnumpyasnpfromquadaximportquadgkf=lambdat:t*jnp.log(1+t)epsabs=epsrel=1e-14a,b=0,1y,info=quadgk(fun,[a,b],epsabs=epsabs,epsrel=epsrel)assertinfo.err<max(epsabs,epsrel*abs(y))np.testing.assert_allclose(y,1/4,rtol=1e-14,atol=1e-14)For full details of various options see theAPI documentation
Package: quadbin
quadbin-pyPython library for quadbin.InstallpipinstallquadbinUsage>>>importquadbin>>>longitude=-3.7038>>>latitude=40.4168>>>resolution=10>>>quadbin.point_to_cell(longitude,latitude,resolution)5234261499580514303APIFunctionis_valid_index(index)is_valid_cell(cell)cell_to_tile(cell)tile_to_cell(tile)cell_to_point(cell, geojson=False)point_to_cell(longitude, latitude, resolution)cell_to_boundary(cell, geojson=False)cell_to_bounding_box(cell)get_resolution(index)index_to_string(index)string_to_index(index)k_ring(origin, k)k_ring_distances(origin, k)cell_sibling(cell, direction)cell_to_parent(cell, parent_resolution)cell_to_children(cell, children_resolution)geometry_to_cells(geometry, resolution)cell_area(cell)DevelopmentMake commands:init: create the environment and install dependencieslint: run linter (flake8) + fix (black)test: run tests (pytest)publish-pypi: publish package in pypi.orgpublish-test-pypi: publish package in test.pypi.orgclean: remove the environmentNOTE: Python2 is supported to enable the usage in platforms likeAmazon Redshift.
Package: quadcelldetector
QuadCellDetectorA Python package designed to simulate the electronic response of a circular quadrant cell photodiode to the passage of a gaussian profile laser beam across its surface.OverviewThe package simulates circular quadrant cell detectors, where the quadrant cell is characterized by a radius, and a gap that separates the four active photocell quadrants. This code allows the user to specify the beam shape, the path the beam takes across the detector, and it will output the signals produced by the photodiode: the sum of all four quadrants, the top two minus the bottom two, and the left two minus the right two.InstallationYou can install this package with pip through our PyPi package with the commandpip install quadcelldetectorAlternatively, since we usepbrinsetup.py, you can install from this github repository withhttps://github.com/university-of-southern-maine-physics/QuadCellDetector.git
cd QuadCellDetector
pip install .ExamplesTo see a complete demonstration of the library features, see theDetectorDemoJupyter notebook.How To Get Help (or Help Us)If you found a bug, have a question, or otherwise need to contact us, pleaseread this.If you want to help us in the development process, or have an idea,read this.ContributorsPaul NakroshisBen Montgomery
Package: quadcube
quadcubePython library (written in rust) that currently provide one methodpix2vecfor converting between quadcube res15 pixel number to ecliptic unit vectors.The code is a reimplementation of parts of the COBE DIRBE map binning routines provided by A.J. Banday. See theCOBE Explanatory Supplementfor more information.Installpip install quadcubeExampleimportquadcubequadcube.pix2vec(98477345)# >>> array([[0.37147827],#           [0.62248052],#           [0.6888555 ]])pixels=[315879751,238749305,408302824,290970621,427780527]quadcube.pix2vec(pixels)# >>> array([[ 0.90477257, -0.51544922,  0.91755844,  0.74030402,  0.98561299],#            [-0.40535959,  0.10338045, -0.39665074, -0.00232418, -0.00949373],#            [-0.13065298,  0.85066127,  0.02747185, -0.67226822,  0.16875101]])
Package: quade
Meet Quade, the friendly QA tool for Django!Quade is a Django app that makes quality assurance testing better. It
handles repeatedly setting up the same data so you don’t have to.InstallationCheck out theQuickstart!LinksSource on GithubDocumentation at Read the DocsHistory0.2.2 (2018-02-02)Fix dependency problems when installing without Celery (#29).Improve help text when not using Celery (#22).Use transparent logo (#31).0.2.1 (2018-01-16)Coerce fixtures’ return value into text (#14).0.2.0 (2018-01-12)Moved celery dependency to an extra namedcelery(#13).0.1.1 (2018-01-05)Release on PyPI!0.1.0 (2018-01-05)Preparation for release.
Package: quadgrid
QuadgridThequadgridpackage provides a class and some convenience functions
for generating quadtree-based grids at arbitrary resolutions in pandas, geopandas and xarray formats for use in geospatial analysis and catastrophe risk modelling.OverviewQuadtree grids are a way of recursively partitioning a plane into
nested quadrants, allowing for simple but efficient geocoding of
points.Some assumptions have been made to simplify the package:all coordinates are in decimal degreesall longitudes range from -180 to +180 degreesthe centre of the grid is at 0E, 0NThe package contains a single class,QuadGrid, which is used to
generate grid objects. The class has methods to convert the grid into
tabular (pandas DataFrame), vector (geopandas GeoDataFrame) and raster
(xarray Dataset) formats which can be saved or used in further processing.Individual quadcells at a given resolution are labelled with unique
quadtreeIDs (qids). In the simplified example below, the red point is in top-level cell '2', then cell '2', then '0' then '3' giving a nominal qid of '2203'. In practice, quadtrees lend themselves to a base-4 encoding, allowing them to be stored and processed efficiently as integers.Versions0.1.2Changed email address in pyproject.toml0.1.1Bug fix to ensure user-specified bounded grid is consistent with the global grid0.1.0First release
Package: quadkey-boosted
quadkey-boostedDescriptionquadkey-boosted is a high-performance Python library that provides a powerful set of tools and functions for working with quadkeys, enabling seamless integration of tile-based mapping systems into your Python applications. Built on top of a blazing-fast C implementation, quadkey-boosted offers lightning-fast calculations, ensuring optimal performance even with large-scale datasets.Key FeaturesAvailable API'sConversionlat lng to QuadKeyQuadKey to lat lngQuadKey to BingTileBingTile to QuadKeyPolygon to quadQuadKeykeysQuadKey to MultipolygonOperationsget parentget childrensget K neighboursMetadataget average tile sizeget zoom levelget tile distance between two tilesWKT, GeoJson, WKB representation of quadkeyC based backend for fast calculationsCan handle various types of projectionsLicenseProject Status✅ Add Basic convertion API❎ Implement advance geospatial apis❎ Add support for projectionsWhat is a QuadKey?A QuadKey is a string representation of a tile's location in a quadtree hierarchy. It is used to index and address tiles at different levels of detail (zoom levels). The QuadKey system is based on dividing the Earth's surface into quadrants using a quadtree structure.For more details on the concept, please refer to
theMicrosoft Article About this.InstallationRequirementsThis library requiresPython 3.6or higher. To compile it from source, Cython is required in addition.using pippipinstallquadkey-boostedFrom sourcePrerequisites (Linux)gccFedora:dnf install @development-toolsUbuntu / Debian:apt install build-essentialpython3-develFedora:dnf install python3-develUbuntu / Debian:apt install python3-devPrerequisites (Windows)Visual C++ Build Tools 2015 (with Windows 10 SDK) (seehere)Build from source# Clone  repogitclonehttps://github.com/ls-da3m0ns/quadkey-boosted# Create Virtual Environmentpython-mvenv./venvsourcevenv/bin/activate# Install dependenciespipinstall-rrequirements.txt# Compilepythonsetup.pysdistbdist_wheel# Installpipinstalldist/quadkey-0.0.1-cp38-cp38-linux_x86_64.whlUsageBasic Usageimportquadkeylat=47.641268lng=-122.125679zoom=15# Convert lat lng to quadkeyqk=quadkey.geo_to_quadkey(lat,lng,zoom)# Convert quadkey to lat lng## get top left cornerlat,lng=quadkey.quadkey_to_geo(qk,corner=0)## get bottom right cornerlat,lng=quadkey.quadkey_to_geo(qk,corner=2)# Convert quadkey to bboxbbox=quadkey.quadkey_to_bbox(qk)# Convert quadkey to Tiletl=quadkey.quadkey_to_tile(qk)# Conver quadkey to quadintqi=quadkey.quadkey_to_quadint(qk)# Convert lat lng to quadintqi=quadkey.geo_to_quadint(lat,lng,zoom)# get parent quadkeyparent=quadkey.get_parent(qk)ReferencesI would like to acknowledge the following repositories that served as references during the development of this project:pyquadkey2
Package: quad-mesh-simplify
Quadric mesh simplificationA leightweight package for simplifying a mesh containing node features. The algorithm fromSurface Simplification Using Quadric Error Metricswas implemented using cython.Only python versions >= 3.6 are supportedInstallationwith pip$pipinstallquad_mesh_simplifyfrom source if distribution is not supportedDownload this repository and build the package by running:$pipinstall-rrequirements.txt
$pythonsetup.pybuild_ext--inplace
$pipinstall.UsageThis package provides one simple function to reduce a given mesh. This can be done for simple meshes or meshes with vertex features.simplify_mesh(positions, face, num_nodes, features=None, threshold=0., max_err=np.Infinity)positions(numpy array): array of shape [num_nodes x 3] containing the x, y, z position for each nodeface(numpy array): array of shape [num_faces x 3] containing the indices for each triangular facenum_nodes(int): number of nodes that the final mesh will have
threshold (number, optional): threshold of vertices distance to be a valid pairfeatures(numpy array): features for all nodes [num_nodes x feature_length]threshold(double): if the distance between two vertices is below this threshold, they are considered as valid pairs that can be merged.max_err(double): no vertices are merged that have an error higher than this number. IMPORTANT: if provided it is not guaranteed that the output will have less than num_nodes vertices.Returns:new_positions, new_face, (new_features)Reduce a simple meshfromquad_mesh_simplifyimportsimplify_meshnew_positions,new_face=simplify_mesh(positions,face,<final_num_nodes>)Reduce a mesh with vertex featuresfromquad_mesh_simplifyimportsimplify_meshnew_positions,new_face=simplify_mesh(positions,face,<final_num_nodes>,features=features)Reduce a mesh with a threshold for the minimal distancefromquad_mesh_simplifyimportsimplify_meshnew_positions,new_face=simplify_mesh(positions,face,<final_num_nodes>,threshold=0.5)
Package: quadmompy
QuadMomPy is a library for all sorts of fun with moments, Gaussian quadratures, orthogonal polynomials and quadrature-based moment methods for the solution of spatially homogeneous population balance equations.InstallationThe QuadMomPy package can be easily installed bypip install quadmompyor from the project repositorypip install -e .A comprehensive documentation and additional examples are only available in the project repository on GitLab/GitHub. Usegit clone https://gitlab.com/puetzm/quadmompy.gitto clone the code from the GitLab repository orgit clone https://github.com/puetzmi/quadmompy.gitto clone from the project mirror on GitHub.The repository also includes aDockerfileto run tests and use the QuadMomPy package in a docker image.UsageA simple example of a moment inversion using the quadrature method of moments with the Wheeler algorithm to compute a Gaussian quadrature rule from a set of moments is given below.importnumpyasnpfromquadmompyimportqbmmfromquadmompy.qbmm.univariateimportQmomfromquadmompy.core.inversionimportWheeler# Create Qmom object using the Wheeler# algorithm for moment inversionqmom=qbmm.new(qbmm_type=Qmom,qbmm_setup={'inv_type':Wheeler})# Nodes `x` and weights `w` of a weighted# sum of degenerate distributionsx=np.array([-0.5,0.1,1.,1.4])w=np.array([0.15,0.4,0.4,0.05])# Compute moments of the distributionn=len(x)moments=np.vander(x,2*n).T[::-1]@w# Invert moments to obtain quadrature nodes and# weights, which should, in this particular# equal the nodes and weights defined above.x_quad,w_quad=qmom.moment_inversion(moments)print(f"x ={x_quad}")print(f"w ={w_quad}")For more examples of how to use the numerous classes provided with this package, see thetestsdirectory and theexamplesdirectory in the project repository on GitLab (https://gitlab.com/puetzm/quadmompy.git) and the project mirror on GitHub(https://github.com/puetzmi/quadmompy.git).LicenseCopyright (c) 2022 Michele Puetz.This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3.This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Package: quadprog-wheel
Minimize     1/2 x^T G x - a^T xSubject to   C.T x >= bThis routine uses the the Goldfarb/Idnani dual algorithm [1].ReferencesD. Goldfarb and A. Idnani (1983). A numerically stable dual
method for solving strictly convex quadratic programs.
Mathematical Programming, 27, 1-33.
Package: quadproj
quadprojA simple library to project a point onto a quadratic surface, orquadric.How to install quadproj?It is a one-liner!python3-mpipinstallquadprojSeeinstallation pagefor further information and the requirements.DocumentationThe documentation is hosted on GitLab:https://loicvh.gitlab.io/quadprojHow does quadproj works?The projection is obtained by computing exhaustively all KKT point from the optimization problem defining the projection. The authors of[1]show that for non-cylindrical central quadrics, the solutions belong to the KKT points that consist in the intersection between:a unique root of a nonlinear function on a specific interval;a set of closed-form points.Either set can be empty but for a nonempty quadric, at least one is nonempty and contains (one of the) projections.The full explanation is provided in[1].How to use quadproj?See thequickstartpage or theAPI documentation.DependenciesSeerequirements.txt.[1](2021) L. Van Hoorebeeck, P.-A. Absil and A. Papavasiliou, “Projection onto quadratic hypersurfaces”, submitted. (preprint,abstract/BibTex)
Package: quadrantic
Determination of quadrants based on angle, coordinates and othersOverviewThis library allows you to determine quadrant(s) based onangle (360° or 400 Gon)location (latlon)SetupVia Pip:pipinstallquadranticVia Github (latest):pipinstallgit+https://github.com/earthobservations/quadranticImplementationsGet quadrant for angleDetermine quadrant based onDegree#####################
#         # 90°     #
#         #         #
# 180°    #      0° #
#####################
#         #         #
#         #         #
#         # 270°    #
#####################orGon#####################
#         # 100°    #
#         #         #
# 200°    #      0° #
#####################
#         #         #
#         #         #
#         # 300°    #
#####################fromquadranticimportQuadrantFromAngle,AngleUnit,Qquad=QuadrantFromAngle()# no args need for this method# Single quadrantquad.get(45.0,AngleUnit.DEGREE)# [Q.FIRST]# Two quadrantsquad.get(90.0,AngleUnit.DEGREE)# [Q.FIRST, Q.SECOND]# More then full circle (360°)quad.get(450.0,AngleUnit.DEGREE)# same as above + 360°# [Q.FIRST, Q.SECOND]# Negative degreequad.get(-45.0,AngleUnit.DEGREE)# [Q.FOURTH]# Degree in Gonquad.get(90.0,AngleUnit.GON)# [Q.FIRST]Get quadrant for coordinates#####################
# (-1,1)  #   (1,1) #
#         #         #
#         # (0,0)   #
#####################
#         #         #
#         #         #
#         #         #
#####################fromquadranticimportQuadrantFromCoords,AngleUnit,Qfromshapely.geometryimportPoint# Single quadrantquad=QuadrantFromCoords((0.0,0.0))quad.get((1.0,1.0))# [Q.FIRST]# Two quadrantsquad=QuadrantFromCoords((0.0,0.0))quad.get((0.0,1.0))# [Q.FIRST, Q.SECOND]# All quadrantsquad=QuadrantFromCoords((0.0,0.0))quad.get((0.0,0.0))# [Q.FIRST, Q.SECOND, Q.THIRD, Q.FOURTH]# Single quadrant with shapely Pointquad=QuadrantFromCoords(Point(0.0,0.0))quad.get(Point(1.0,1.0))# [Q.FIRST]ExamplesVisualized examples can be found in theexamplesfolder.LicenseDistributed under the MIT License. SeeLICENSE.rstfor more info.ChangelogDevelopment0.1.0 (25.09.2022)Add first version of quadrantic