Saravanan666/pypi-org huggingface dataset:
Package: pygame-widgets
Pygame WidgetsA helper module for common widgets that may be required in developing applications with Pygame. It supports fully
customisable buttons, collections of buttons, textboxes, sliders and many more! If there are any widgets that you would like to see
added, please create an issue!Changes in Pygame Widgets v1.0.0In v1.0.0, there are some minor changes to the use of the module, which may affect existing projects.
This outlines the changes that will affect current users in the new version.As more widgets are added, importing is now different# Nowfrompygame_widgets.buttonimportButton# Instead offrompygame_widgetsimportButton# Will not workAll widgets are now updated (draw and listen) by the update methodimportpygameimportpygame_widgetsfrompygame_widgets.buttonimportButtonpygame.init()win=pygame.display.set_mode((600,600))button=Button(win,100,100,300,150)run=Truewhilerun:events=pygame.event.get()foreventinevents:ifevent.type==pygame.QUIT:pygame.quit()run=Falsequit()win.fill((255,255,255))# Nowpygame_widgets.update(events)# Instead ofbutton.listen(events)button.draw()pygame.display.update()PrerequisitesPython 3>= 3.10Pygame>= 2.0.0InstallationEnsure that Python 3 and pip are installed and added to your environment PATH.python -m pip install pygame-widgetsOpen a Python console and run the following command.import pygame_widgetsIf you receive no errors, the installation was successful.UsageFor full documentation, seepygamewidgets.readthedocs.io.CommonButtonButtonArrayTextBoxSliderToggleProgressBarDropdownComboBoxAnimationsHow to ContributeAny contribution to this project would be greatly appreciated.
This can include:Finding errors or bugs and creating a new issueAddressing active issuesAdding functionalityImproving documentationIf applicable, you should make any changes in a forked repository and then create a pull
request once the changes arecompleteand preferably tested if possible.Note: If writing any code, please attempt to follow theCode Style Guide
Package: pygame_wrapper
Pygame WrapperTable of ContentsIntroductionInstallationDocumentationLicenseIntroductionThis is a project that I created in order to have an easier time when creating games with pygame, its not perfect but it really helps lowering some of the annoying boilerplate of pygame.
This project has pygame-ce listed as a requirement, thus meaning that when installed from PyPI it will automatically install pygame-ce.
This is because I believe it is superior than pygame.
Normal pygameshouldwork but you will have to manually uninstall pygame-ce and install pygame.
If you have normal pygame and find issues with the code, you will not get any support (at least from me).Installationpip install pygame_wrapperDocumentationDue to me being lazy, documentation is non-existent.
PRs for docs are welcome (modify DOCS.md).
If this project gets big enough I will redo my code to allow automatic documentation to work, or just actually make docs.Licensepygame_wrapperis distributed under the terms of theMITlicense.
Package: pygamma
GAMMA is a C++ library for the simulation of magnetic resonance (NMR, MRS) experiments. It
provides a simple and intuitive means to construct simulation programs to suit researchers’
individual needs. GAMMA is an acronym for a General Approach to Magnetic resonance
Mathematical Analysis.PyGamma is a Python wrapper around GAMMA that makes almost all of GAMMA’s API available via
Python.Both GAMMA and PyGamma work on OS X, Linux, and Windows.
Package: pygamma-agreement
Pygamma-agreementpygamma-agreementis an open-source package to measure Inter/Intra-annotator[^1]
agreement for sequences of annotations with the γ measure[^2]. It is written in
Python3 and based mostly on NumPy, Numba and pyannote.core. For a full list of
available functions, please refer to thepackage documentation.DependenciesThe main dependencies of pygamma-agreement areNumPy,CVXPY,Numbaandpyannote.core.Optionally, to allowpygamma-agreementto display visual representations of
our API's objects in Jupyter Notebooks,Matplotlibis needed.pygamma-agreementis a Python 3 package and is currently tested for Python 3.7 to 3.11.pygamma-agreementdoes not work with Python 2.7.Installationpygamma-agreement can be easily installed using pip :$ pip install pygamma-agreementPygamma-agreement uses theGNU Linear Programming Kitas its default Mixed Integer
Programming solver (critical step of the gamma-agreement algorithm). Since it is quite slow, you can install theCBCsolver and its officialpython API.
To use those inpygamma-agreement, simply install them:Ubuntu/Debian :$ sudo apt install coinor-libcbc-devFedora :$ sudo yum install coin-or-Cbc-develArch Linux :$ sudo pacman -S coin-or-cbcMac OS X :$ brew tap coin-or-tools/coinor$ brew install coin-or-tools/coinor/cbc pkg-configthen:$ pip install "pygamma-agreement[CBC]"If you have trouble during the two last steps, pygamma-agreement should work anyway,
although significantly slower for larger input.WARNING: A bug in GLPK causes the standard output to be polluted by non-deactivable messages.
It is strongly advised to use the CBC solver.TestsThe package comes with a unit-tests suite. To run it, first install the CBC solver, then the testing dependencies
on your Python environment:$ sudo apt install coinor-libcbc-dev
$ pip install "pygamma-agreement[testing]"After that, tests are ready to be launched (they take ~2m on a recent laptop) :$ pytest tests/DocumentationThe documentation for this package has been written using Sphinx. To build the documentation locally, run:$ pip install "pygamma-agreement[docs]"
$ cd docs/
$ make htmlAfter that, you can view the documentation by running$ firefox build/html/index.htmlSubmitting and issue or contributingPlease readCONTRIBUTING.mdbefore submitting and issue or writing some contribution
to this package.Citing PygammaIf you're using pygamma in your work, please cite our package using the following bibtex entry:@article{Titeux2021,
  doi = {10.21105/joss.02989},
  url = {https://doi.org/10.21105/joss.02989},
  year = {2021},
  publisher = {The Open Journal},
  volume = {6},
  number = {62},
  pages = {2989},
  author = {Hadrien Titeux and Rachid Riad},
  title = {pygamma-agreement: Gamma $\gamma$ measure for inter/intra-annotator agreement in Python},
  journal = {Journal of Open Source Software}
}References[^1]:Titeux H., Riad R.
pygamma-agreement: Gamma γ measure for
inter/intra-annotator agreement in Python.[^2]:Mathet Y., Widlöcher A., Métivier, J.P.
The unified and holistic method gamma γ for
inter-annotator agreement measure and alignment.
Computational Linguistics
Package: pygammon
Backgammon engine corepygammonis the base of abackgammonengine,
written in Python. It provides the core functionality for running a game, given a source of
input (player moves) and a destination for output (game state/events).InstallationThe following Python versions are supported:CPython: 3.8, 3.9, 3.10, 3.11, 3.12PyPy: 3.8Install viapip:$pipinstallpygammonUsageTo build a complete game, you have to provide a function for getting each side’s moves (input),
and a function for informing each side about the game state and events (output):fromtypingimportOptional,Tuple,UnionfrompygammonimportGameState,InputType,InvalidMoveCode,OutputType,Side,rundefreceive_input(side:Side)->Tuple[InputType,Optional[Tuple[int,Optional[int]]]]:# Return move of given side...defsend_output(output_type:OutputType,data:Union[GameState,Tuple[int,int],InvalidMoveCode,Side],side:Optional[Side]=None,)->None:# Show output to given side...run(receive_input,send_output)The input function could send to the game, moves made in any way (calculated by AI, read from stdin,
selected from GUI, either locally or through network). Similarly, the output function could do anything
with the info it gets from the game (inform AI tactics, write to stdout, show to GUI, either locally or
through network).For more details, see theprotocol.LicenseDistributed under theMIT License.
Package: pygamp
PyGAMPGoogle Analytics Measurement Protocol for PythonPyGAMP is a simple implementation of the Google Analytics Measurement Protocol API, which provides a server-side means of passing data into GA, whether it's from a web application, mobile app or server-based application.InstallationPyGAMP can be installed via PyPi by issuing the commandpip3 install pygamp.FeaturesPyGAMP currently supports the following features of Google Analytics Measurement Protocol:App screenviewsExceptionsPageviewsEvent trackingSocial interactionsCustom dimensionsCustom metricsEcommerce trackingEnhanced ecommerce trackingInternal promotionsItem and transaction refundsCheckout optionsCheckout stepsExamplesRefunding an itemrefund_items(client_id, 'UA-123456-1', '12345', 'ABC1', 1)Refunding a transactionrefund_transaction(client_id, 'UA-123456-1', '12345')Record a promotion impressionpromotion_impression(client_id, 'UA-123456-1', 'example.com', 'about-us', 'About us', 2, 'PROMO1', 'Summer sale', 'Summer', 'Slot 1')Record a promotion clickpromotion_click(client_id, 'UA-123456-1', 2, 'PROMO1', 'Summer sale', 'Summer', 'Slot 1')Assign a value to a custom dimensioncustom_dimension(client_id, 'UA-123456-1', '2', 'Analytics')Assign a value to a custom metriccustom_metric(client_id, 'UA-123456-1', '1', '1234')Create an interactive eventevent(client_id, 'UA-123456-1',  'NI event', 'action', 'label', 10, 1)Create a non-interactive eventevent(client_id, 'UA-123456-1', 'I event', 'action', 'label', 10, 0)Record a pageviewpageview(client_id, 'UA-123456-1', '/hello', 'example.com', 'Test')Record a social interactionsocial(client_id, 'UA-123456-1', 'like', 'facebook', '/home')Record an exceptionexception(client_id, 'UA-123456-1', 'Transaction not found', 1)Record an application viewscreenview(client_id, 'UA-123456-1', 'PyGAMP', '1.0.1', 'Example')Record an enhanced ecommerce transactionTo record a transaction using enhanced ecommerce, you first need to construct a nested dictionary of items to push to Google Analytics along with the transaction data. This should use the following format:items={1:{'product_id':'ABC1','product_name':'Product 1','product_price':19.99,'product_quantity':1,'product_brand':'Apple','product_category':'Phones','product_variant':'256GB',},2:{'product_id':'ABC2','product_name':'Product 2','product_price':20.99,'product_quantity':2,'product_brand':'Apple','product_category':'Phones','product_variant':'500GB',},3:{'product_id':'ABC3','product_name':'Product 3','product_price':39.99,'product_quantity':3,'product_brand':'Apple','product_category':'Phones',},}This is then passed to GA using the following method:enhanced_transaction(client_id,'UA-123456-1','example.com','/order','Order complete','12345',199.99,40.00,0.00,'',items)
Package: pyganalytics-reporting
MIT LicenseCopyright (c) 2018 Jonas WaeberPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pyganja
pyganjaVisualisation library for geometric algebra with cefpython and ganja.jsThis is a module for visualing Geometric Algebra from scripts and also from jupyter notebooks,
it relies onganja.jsto render Geometric Algebra objects.
If you are calling its api from a script it will render them in a cefpython window or if you are in a notebook it can simply render in the notebook itself.UseThis library is not specifically tied to thecliffordlibrary
but is designed to work well with it. An example of the syntax that you would use combining these two libraries:from clifford.tools.g3c import random_line
from pyganja import *

draw([random_line() for i in range(10)])Produces:Mulitple grades of object can be drawn in the same scene with different colors and transparenciesfrom clifford.g3c import *
from clifford.tools.g3c import *
from pyganja import *

P1 = up(random_euc_mv()*0.1)
P2 = up(random_euc_mv()*0.1)
P3 = up(random_euc_mv()*0.1)
P4 = up(random_euc_mv()*0.1)

# The sphere is the outer product of all 4
S = (P1^P2^P3^P4).normal()

# A line is the outer product of 2 with ninf
L = P1^P2^einf

# The inversion of a line in a sphere is a circle
C = S*L*S

# The tangent to the circle at the intersection point is the reflected line
Ldash = (P1|C)^einf

# The tangent plane to the sphere at the intersection point can be easily found
Ppi = (P1|S)^einf

sc = GanjaScene()
sc.add_objects([P1,P2,P3,P4], color=Color.BLACK)
sc.add_objects([L], color=Color.BLUE)
sc.add_objects([Ldash], color=Color.RED)
sc.add_objects([C], color=Color.RED)
sc.add_objects([S*einf*S], color=Color.BLACK)
sc.add_objects([S])
sc.add_objects([Ppi], color=rgb2hex((0,100,0))+int('70000000',16))
draw(sc,scale=0.5)Produces:Installationgit clone git@github.com:hugohadfield/pyganja.git
cd pyganja
python3 setup.py installTODOThis is still very much a work in progress, currently it only handles PGA and CGA
Package: pygans
PyGANs (Machine Learning Framework)Python Framework for Generative Adversarial Networks. It provides an Abstraction layer to create and train GANs with an integrated monitoring module to see the evolution of the Network through time.There are incorporated examples that show the usage of the framework in 2D functions and generating Hand Written Digits.Tested Models:Trigonometric Functions (f(x)=sin(x))Polynomial Functions, for example:O f(x) = x**2O f(x) = x**5 - 3x**2 - 4HandWritten Digits (MNIST)InstallationPyGANs is available in the Python Package Index (PyPI), so it's possible to install it using the package installer for Python (pip), which install automatically the external dependencies:$pip install pygansExternal DependenciesIf you install the library usingpip, it will install automatically the dependencies.KerasTensorflowNumpyMatplotlibVersions2.0.3BugFix: Random Generation in Dataset_Generator_2D2.0.2BugFix: MNIST Animation2.0.0MNIST SupportedSimplified APIOptimizing training processBugFix: Latent points generation on Standard normal distribution1.0.02D Functions tested2D animation supported
Package: pygantt
.. image:: https://img.shields.io/pypi/v/pygantt.svg:target: https://pypi.python.org/pypi/pygantt.. image:: https://img.shields.io/travis/PyGantt/PyGantt.svg:target: https://travis-ci.org/PyGantt/PyGantt.. image:: https://readthedocs.org/projects/pygantt/badge/?version=latest:target: https://pygantt.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status=======PyGantt=======Easy Gantt and waterfall charts in python.This module uses Gantt type charts to plot event data characterized by a start and an end.It naturally applies to scheduling but it is well suited in financial applications, e.g. plotting positions/weights in a portfolio alongside the portfolio index, in medical application, e.g. the raster plot of neuron impulses, or in waterfall usage plots, e.g. the evolution of your monthly earnings and expenses.* Free software: BSD license* Documentation: https://pygantt.readthedocs.io.Installation--------The easiest way to install PyGantt is using ``pip``::pip install -U pyganttor ``conda``::conda install -c mriduls pyganttFeatures--------The canonical scheduling example:.. image:: https://github.com/PyGantt/PyGantt/blob/master/images/concert.pngDisplay portfolio positions alongside the realized index:.. image:: https://github.com/PyGantt/PyGantt/blob/master/images/strategy.pngFreelancers ups and downs:.. image:: https://github.com/PyGantt/PyGantt/blob/master/images/freelancer.pngCredits-------This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage=======History=======0.1.0 (2018-04-21)------------------* First release on PyPI.
Package: pygar
pygaR 1.0.5pygaR is a Python module (with R package wrapper) that searches the SEC EDGAR
system in a variety of methods.  It is cross platform (Linux/UNIX/Windows), and
works on either the Python 2 or 3 branches.More information on the SEC EDGAR system can be found here:https://www.sec.gov/edgar.shtmlThis project is a module on PyPI:https://bcable.net/x/pygaR/pypiThis project's source code can be found here:https://bcable.net/x/pygaRThis project's Sphinx source code can be found here:https://bcable.net/x/pygaR/sphinxExamplespygar_form(...) Examplepygar_master(...) Examplepygar_search(...) ExampleSystem RequirementsPython 2.7+, 3.3+R (not required): 3+InstallationPython ModuleLinux/UNIXpip install pygarWindowspath\to\python.exe -m pip install pygarR PackageRequires devtools package to install, and the pygar Python module in order to function.If you don't have the "devtools" package installed in R, you will need to
install that first:install.packages("devtools")To install the R package:library(devtools)
install_git("https://gitlab.com/BCable/pygaR.git", subdir="Rpkg")Backup Mirror Linkshttps://gitlab.com/BCable/pygaRhttps://bcable.gitlab.io/pygaR/sphinxhttps://bcable.gitlab.io/pygaR/pygar_form/https://bcable.gitlab.io/pygaR/pygar_master/https://bcable.gitlab.io/pygaR/pygar_search/https://pypi.python.org/pypi/pygar
Package: pygarn
pygarnForward- and backward operations on graphs with a lot of fuzzyness.Install viapip:pip install pygarnpoetry:poetry add pygarnor add in yourcondaenvironment:name:sur-your-env-namechannels:-defaultsdependencies:-python>=3.8-pip-pip:-pygarnVisualsExamplesimportnetworkxasnxfrompygarn.baseimportRandomVertexSelectorfrompygarn.growthimportAddCompleteGraphn_vertices_initial=20g_initial=nx.erdos_renyi_graph(n_vertices_initial,0.3)op_add_kcomplete=AddCompleteGraph(size=3,sources=RandomVertexSelector(min=1,max=3),targets=RandomVertexSelector(min=1,max=3),)g_new=op_add_kcomplete.forward(g_initial)g_orig=op_add_kcomplete.backward(g_new)# Should be highly likely:assertnx.is_isomorphic(g_orig,g_initial)importnetworkxasnxfrompygarn.baseimportVertexDegreeSelectorfrompygarn.growthimportAddVertexn_vertices_initial=20g_initial=nx.erdos_renyi_graph(n_vertices_initial,0.3)n_edges_initial=len(g_initial.edges)degrees_initial=[(v,d)forv,ding_initial.degree()]selector=VertexDegreeSelector()op_add=AddVertex()n_rounds=5g_current=g_initial.copy()for_inrange(n_rounds):g_current=op_add.forward(g_current)
Package: pygarrayimage
pygarrayimage allows display of Python objects supporting the array
interface as OpenGL textures without a copy. The OpenGL texture
handling is done using pyglet.In other words, this allows fast transfer of data from numpy arrays
(or any other data source supporting the array interface) to the video
card.TODO: support the buffer interface added with Python 2.6/3.0 rather
than the numpy-defined array interface.
Package: pygase
PyGaSePythonGameServerA package for Python 3.6+ that contains a game-ready client-server architecture and UDP-based network protocol.It deals with problems such as package loss or network congestion so you don't have to. Instead it gives you
a high-level API to easily connect clients and backends that share a synchronized game state and exchange events.
The async framework for this one iscurio, which I highly recommend.PyGaSe is built to be easy to use, lightweight, fast, scalable and reliable.
You can build a fast-paced real-time online game with this.
You can also build a large-scale MMO with thousands of clients if you like.I'm actively developing PyGaSe in the context of several Indie game projects and I'm happy to share it.BREAKING CHANGE: Version 0.2.0 is basically a new API and updating from 0.1.9 or lower will break you code.It is also much more stable, flexible and powerful, so make sure to use 0.2.0 or higher.Installationpip install pygaseor better yetpoetry add pygase. Seriously, usepoetry, it's a revelation.UsageAPI Reference & TutorialsFor API documentation and aGetting Startedsection gohere.ExampleThis example gameimplements an online game of tag,
in which players can move around, while one of them is the chaser who has to catch another player.
A player who has been catched becomes the next chaser and can catch other players after a 5s protection countdown.Runserver.pyfirst, then runclient.pyin additional terminal sessions to add players.
Only use the same player name once.Debugging & LoggingYou can use the standardloggingmodule. On levelINFOyou will get logging output for events such as
startups, shutdowns, new connections or disconnects. OnDEBUGlevel you get detailed output right down to the level
of sending, receiving and handling single network packages.Debug logs are also a good way to understand the inner workings of PyGaSe.Changes0.3.1improved documentationminor logging fixes0.3.0sticking to SemVer from here on outlogging added using the standardloggingmoduleimprove event handler argumentsBackendclass added to reduce server-side boilerplatevarious bugfixes0.2.0complete overhaul of pygase 0.1.x with breaking API changes
Package: pygasflow
pygasflowpygasflowis a Python package that provides a few handful functions to quickly perform:Quasi-1D ideal gasdynamic (perfect gas). The following solvers are implemented:isentropic_solver(orise).fanno_solver(orfan).rayleigh_solver(orray).shockwave_solver(orss) for normal and oblique shock waves.conical_shockwave_solver(orcss).De_Laval_solverand thenozzlessub-module, containing functions and classes to understand convergent-divergent nozzles, Rao's TOP nozzles (Thrust Optmizie Parabolic), Minimum Length nozzle with Method of Characteristics. Nozzles can be used to quickly visualize their geometric differences or to solve the isentropic expansion with theDe_Laval_Solverclass.Aerothermodynamic computations (pygasflow.atdmodule):Correlations to estimate boundary layer thickness, heat flux and wall shear stress over a flat plate or a stagnation region.Newtonian Flow Theory to estimate the pressure distribution around objects and their aerodynamic characteristics.The following charts has been generated with the functions included in this package:InstallationThe repository is avaliable on PyPi:pip install pygasflowAnd also on Conda:conda install -c davide_sd pygasflowUsageThe easiest way is to call a solver. Let's say you need to solve an isentropic flow:frompygasflowimportisentropic_solverhelp(isentropic_solver)isentropic_solver("m",2,to_dict=True)# {'m': 2.0,#  'pr': 0.12780452546295096,#  'dr': 0.2300481458333117,#  'tr': 0.5555555555555556,#  'prs': 0.24192491286747442,#  'drs': 0.36288736930121157,#  'trs': 0.6666666666666667,#  'urs': 2.3515101530718505,#  'ars': 1.6875000000000002,#  'ma': 30.000000000000004,#  'pm': 26.379760813416457}Should a solver not be sufficient for your use case, feel free to explore the code implemented inside each flow's type, maybe you'll find a function that suits your needs.Please:take a look at the notebooks contained in theexamplesfolder. You can also try this package online with Binder.visit thedocumentation page.If you find any errors, open an issue or submit a pull request!