Saravanan666/pypi-org huggingface dataset:
Package: pylash-engine
Pylash EngineLatest Version: 2.0.0Pylashis a modern and cross-platform 2D game engine written inPython. With modern and practical interfaces provided bypylash, you can create games in an easy and relaxed way.LicenseMIT LicenseWhy PylashCross-platform. Leveraging compatibility of the underlying enginePySide2,pylashsupports many mainstream platforms including Ubuntu, macOS and Windows.Easy-to-use APIs.Pylashadopts ActionScript-like interface designs to raise the efficiency of game developing.Lightweight.Pylashdoes not come with piles of third-party tools and frameworks.Comprehensiveness.Pylashis a universal framework and provides various object-oriented interfaces including display of images, text and vector graphics, collision detection, tween animation, multimedia, etc.Get Started withPylashInstallation$pipinstallpylash-engineHello World ProgramCreate aPythonfile and open it with your favorite text editor. Type in the code below:frompylash.coreimportinit,addChildfrompylash.displayimportTextFielddefmain():txt=TextField()txt.text="Hello World"txt.size=40txt.x=txt.y=100addChild(txt)init(30,"Hello World",400,300,main)Run thePythonfile and you will get a window with a "Hello World" text.ContributingThis project is hostedon Github. Issue reports and pull requests are welcome. In addition, you can drop me an email if you have any question or suggestion.My email:wangyuehao1999@gmail.comExample ScreenshotsFind CharacterGet FruitsTower DefenseChangelog for 2.0.0Port base engine fromPyQt4toPySide2.Removed modules:text,system,net.Renamed modules:utils=>core.Addedloadersmodule, providing various loaders for different resource types.MovedTextFieldclass and related classes todisplaymodule.EnhancedLineEditclass: added focus-in event and focus-out event.SubstitutePhononwithQtMultimediaas multimedia engine.AddedVideoclass inmediamodule for displaying videos.Improved event system. Listener will not receive an event dispatcher as the parameter anymore.Added more demo.Added docstring forcoremodule.
Package: pylastfm
Lasty Last.FM API bindingsGitHub ProjectChangelog0.2.0Removed following methods due to LastFM API changes:track.bantrack.get_buy_linkstrack.get_fingerprint_metadatatrack.get_shoutstrack.get_top_fanstrack.sharetrack.unbanuser.get_banned_tracksuser.get_eventsuser.get_neighborsuser.get_neighboursuser.get_new_releasesuser.get_past_eventsuser.get_playlistsuser.get_recent_stationsuser.get_recommended_artistsuser.get_recommended_eventsuser.get_shoutsuser.shoutAdd album API resourceAdd chart API resourceAdd artist API resourceAdd geo API resourceAdd library API resourceAdd tag API resourceUser resource now parses responses instead of returning raw data0.1.1Initial release
Package: pylastica
AboutPylastica is a Python port ofElastica, a PHPElasticsearchclient
byNicolas Ruflin.Installation$pipinstallpylasticaTo use the thrift transport protocol, you will need to install thethrift transport plugin.To index attachments, you will need to install themapper attachments plugin.To use a RabbitMQ river, you will need to install theRabbitMQ river plugin.DocumentationDocumentation can be foundhere.CompatibilityPylastica is tested with Python 2.7 and Elasticsearch version 1.3.0.ChangesSee thechangelog.
Package: pylastic-exporter
pylastic-reportFlagDefaultDescription-h or --helpShow this help message and exit.-u or --h###Example commands to run:python__main__.py-ulocalhost-itesting-*-p9200-g2022-03-01T00:00:00-l2022-03-30T23:59:59-q"i_test:*TEST*"To build binary executable in linux:makeor run command:pyinstaller-F--clean--noconfirm-npylastic_report__main__.pyand copy the binary to the /usr/bin folder.Prerequisites:Need bz2 for installation.Ubuntu/Debian:sudoapt-getinstalllibbz2-devyuminstallbzip2-develInstall, check oudated list of packagespipinstall-rrequirements.txtpiplist--outdatedupdate the packages:pipinstallpip-upgraderremove packages:pipfreeze>unins&&pipuninstall-y-runins&&rmunins
Package: pylasu
Pylasu – Python Language SupportPylasu is an AST Library in theStarLasufamily, targeting the Python language.Documentationis on Read the Docs.Testingpython-munittestdiscovertestsLintingflake8.&&flake8testsPackaging and distributingUpdate version inpyproject.toml,setup.cfgandpylasu/__version__.py(TODO do we need all three?),
commit and check that CI completes normally. Then run:rmdist/*
python-mbuild
python-mtwineuploaddist/*Note:if we havetwo-factor authentication (2FA)enabled on PyPI,
we have touse an API token.If all goes well, tag the release:gittagExtracting DocumentationHere's how to extract the documentation into HTML using Sphinx, the most popular documentation generator for Python.First, ensure you have Sphinx and the chosen theme installed:pipinstallsphinxsphinx_rtd_themeThen, extract the documentation from the source code:sphinx-apidoc-odocspylasuFinally, change into the docs directory and launch the build process:cddocs
makehtmlIf everything goes as it should, indocs/_build/htmlyou'll find the generated documentation.We also host the documentation on ReadTheDocs. The project ispylasu.
Documentation needs to bebuilt manuallyfor each release for it to appear
online onhttps://pylasu.readthedocs.io.
Package: pylatconverter
pyLatConverterConvert your variables into latex codeFree software: MIT licenseDocumentation:https://pylatconverter.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2017-09-04)First release on PyPI.
Package: py-latent-profiles
PyLPAThis is a Python package that can be used to run Gaussian mixture models with different constraints on means, variances and covariances.
It can thus be used to run latent profile analysis, including multiple group analysis.Copyright (C) 2023  Johanna EinsiedlerThis 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; either version 2
of the License, or (at your option) any later version.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.
Package: pylateral
pylateralIntuitive multi-threaded task processing in python.Exampleimport urllib.request

@pylateral.task
def request_and_print(url):
    response = urllib.request.urlopen(url)
    print(response.read())

URLS = [
    "https://www.nytimes.com/",
    "https://www.cnn.com/",
    "https://europe.wsj.com/",
    "https://www.bbc.co.uk/",
    "https://some-made-up-domain.com/",
]

with pylateral.task_pool():
    for url in URLS:
        request_and_print(url)

print("Complete!")
Package: pylatexenc
Simple LaTeX parser providing latex-to-unicode and unicode-to-latex conversionUnicode Text to LaTeX codeThepylatexenc.latexencodemodule provides a functionunicode_to_latex()which converts a unicode string into LaTeX text and escape sequences. It should
recognize accented characters and most math symbols. A couple of switches allow
you to alter how this function behaves.You can also runlatexencodein command-line to convert plain unicode text
(from the standard input or from files given on the command line) into LaTeX
code, written on to the standard output.A third party plug-in for Vimvim-latexencodeby@Konfektprovides a corresponding command to operate on a given range.Parsing LaTeX code & converting to plain text (unicode)Thepylatexenc.latexwalkermodule provides a series of routines that parse
the LaTeX structure of given LaTeX code and returns a logical structure of
objects, which can then be used to produce output in another format such as
plain text.  This is not a replacement for a full (La)TeX engine, rather, this
module provides a way to parse a chunk of LaTeX code as mark-up code.Thepylatexenc.latex2textmodule builds up on top ofpylatexenc.latexwalkerand provides functions to convert given LaTeX code to
plain text with unicode characters.You can also runlatex2textin command-line to convert LaTeX input (either
from the standard input, or from files given on the command line) into plain
text written on the standard output.DocumentationFull documentation is available athttps://pylatexenc.readthedocs.io/.LicenseSee LICENSE.txt (MIT License).NOTE: See copyright notice and license information for filetools/unicode.xmlprovided intools/unicode.xml.LICENSE.  (The filetools/unicode.xmlwas downloaded fromhttps://www.w3.org/2003/entities/2007xml/unicode.xmlas linked fromhttps://www.w3.org/TR/xml-entity-names/#source.)
Package: pylatexparse
If you need:to turn your “non-crazy” LaTeX document into a document tree,to rewrite that document tree using a visitor pattern, andto near-exactly recreate your document (or a transformed version)
from this document tree,then this package may be for you.The packagedoesneed to know the number of arguments supplied to each macro
and environment encountered. There is a list of these in the code, but it is
not currently complete. Contributions to this for popular and common macros are
welcome. For custom macros and environments, an interface exists for this data
to be supplied.The package is Python 3-only.https://github.com/inducer/pylatexparseCopyright 2019 Andreas KloecknerReleased under the MIT License
Package: pylathedb
PyLatheDBA Python library for Relational Keyword Search with Support to Schema References.PyLatheDB is based on Lathe, an R-KwS framework that generalizes the well-known concepts of Query Matches (QMs) and Candidate Joining Networks (CJNs) to handle keywords referring to schema elements and introduces new algorithms to generate them, along with a novel approach to automatically select the CJNs that are more likely to represent the user intent when issuing a keyword query.We showcase PyLatheDB through a Jupyter Notebook. We recommend running it usingGoogle Colab. But its static version is also available in our repositoryhere.The database source files are availablehere
Package: pylatlon
Python toolbox for working with geographical positions defined by latitude and
longitude. The position is essentially a python object, which can parse different
formats from strings and output it in several typical formats. Two positions can
be subtracted to easily calculate the distance between two points.
The toolbox includes a simple gui to convert strings, to compute the distance
between two positions, plot them on a simple map and to output as a string in
a user choosable format.
Package: pylatt
PYLATTNumerical models of mechanical lattices (truss/frame structures)Easy to use interface--- define only the nodes and beams in the irreducible unit cell.Calculation of phononic band diagrams--- with utilities to define the path along the edges of the Brillouin zone.Auto-diferentiable--- allowing the optimization of discrete metamaterials.InstallationFrom PypiSimply runpipinstallpylattIf you want more numerical backends (pytorch, autograd and jax), including
auto-differentiation and GPU acceleration, install the full version:pipinstallpylatt[full]From sourceClone the repositorygitclonehttps://gitlab.com/benvial/pylatt.gitcdpylattInstall the package locallypipinstall-e.For the full version:pipinstall-e.[full]From gitlabBasic:pipinstall-egit+https://gitlab.com/benvial/pylatt.git#egg=pylattFull:pipinstall-egit+https://gitlab.com/benvial/pylatt.git#egg=pylatt[full]
Package: pylattica
pylattica - A Framework for Lattice and Cellular Automata Simulationpylattica is a Python library for prototyping and constructing cellular automaton and lattice models. The core features of these models are:There is a simulation state that evolves over time by repeatedly applying some unchanging ruleThe state of the simulation has a topology defined by a network of sites (i.e. each site has an unchanging set of neighbor sites)Each site has a state value associated with it that could change at each simulation stepThe future state of a site is determined by the state of its neighbor sitesThese rules capture many common models in chemistry and materials science. For instance, in the Ising Model, spins are updated with probabilities related to the neighboring spins. In a Lattice Gas Automaton, the velocities of particles are determined collisions with neighboring particles. In lattice Monte Carlo simulations of surface catalysis, adsorption, desorption, and surface diffusion are dependent on the occupancy of neighboring sites.pylattica aims to provide a general framework for prototyping these types of lattice simulations. It prioritizes providing a straightforward method for experimenting with different interaction rules and interaction neighborhoods. It provides some simple utilities for analyzing simulation states, and in the case of square grid systems, it provides visualization tools for the system state itself. Additionally, since this tool is focused on materials science, there is functionality for mapping system states to CIF files (for use in crystal lattice simulations).DocumentationDetailed documentation for this library can be foundhere.ExamplesExample notebooks are included indocs/examples.DevelopmentBuilding DocumentationThe docs for this project are built using mkdocs. To build the documentationpip install '.[docs]'
mkdocs buildTo run the documentation server locally:mkdocs serveLintingThis project uses theblackpackage for style and formatting, andprospectorfor type checking and other lint warnings. These packages are not listed as dependencies of this project, so you can install them manually. This is partially because this project doesn't rely on specific versions of them, and we expect developers to have their own installations already. You can run them as follows:To assess the changes that will happen if you run theblacklinter, run the following:black --check srcTo automatically make the changes, remove the--checkflag:black srcTo run all other linters with prospector, use this:prospectorIn the top of this repository.
Package: pylattice
pyLatticeA python library for advanced lattice light-sheet image analysisWelcome!Please read themanualto get started.Installationclone or download the repositorypipinstallpylattice
pipinstall-rrequirements.txtcdsource/jupyter
jupyternotebookin browser opensource/jupyter/latticeFrame_showFrame.ipynbTest dataA small test data set can be found here:https://www.dropbox.com/sh/s7q45h7wqoco5hl/AAB2Tt5lTGSkF2VhMTMM8NEWa?dl=0FAQLattice Light-Sheet MicroscopyReferencesscikithttp://scikit-image.orgChimeraXhttps://www.cgl.ucsf.edu/chimerax/llsm toolshttps://github.com/francois-a/llsmtoolsutrackhttps://www.utsouthwestern.edu/labs/danuser/software/#utrack_ancsJoh Schöneberghttp://www.schoeneberglab.orgThe Betzig Labhttps://www.janelia.org/lab/betzig-labThe Drubin/Barnes Labhttps://drubinbarneslab.berkeley.edu
Package: pylaunch
pylaunchSimple library for working with the DIAL Protocol.DIAL -- "DIscovery And Launch" is a simple protocol that second-screen devices can use to discover and launch apps on first-screen devices.Dial Protocol SpecificationInstallationpython3 -m pip install pylaunchUsageDiscover and Launch roku applicationfrompylaunch.rokuimportRokud=Roku.discover()[0]disney_plus=d.apps.get('Disney Plus')disney_plus.launch()Basic Remote Controlfrompylaunch.rokuimportRokufrompylaunchimportrokud=Roku('192.168.0.3')d.power()d.key_press(roku.RIGHT)d.key_press(roku.DOWN)d.key_press(roku.SELECT)Discover DIAL devices and launch YouTube to specific videofrompylaunch.dialimportDiald=Dial.discover()[0]d.launch_app('YouTube',v='6tNS--WetLI')LicenseThe MIT License (MIT)Copyright (c) 2020 Steffen AnderslandPermission 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: pylaunches
PyLaunchesA python packages to get information form upcoming space launches.Installpython3-mpipinstallpylaunchesExample usage"""Example usage of pylaunches."""importasynciofrompylaunchesimportPyLaunches,PyLaunchesExceptionasyncdefexample():"""Example usage of pylaunches."""asyncwithPyLaunches()asapi:try:launches=awaitapi.upcoming_launches()forlaunchinlaunches:print(launch.name)exceptPyLaunchesException:print(":(")asyncio.get_event_loop().run_until_complete(example())This package is using theLaunch Library 2 APIto get the information.
Package: pylava-pylint
Pylava_pylint is a community maintained fork ofPylama_pylint.pylava_pylint – SupportPylintinPylava.ContentsRequirementsInstallationUsageSupportContributingContributorsLicenseRequirementspython >= 2.7InstallationEnter the following command to install Pylava_pylint.pip install pylava-pylintWith Python 3, you may need to enter the following command instead.pip3 install pylava-pylintUsageHere are examples of a few commands that shows how Pylava_pylint may be
used with Pylava.pylava -l pylint
pylava -l pylint,pycodestyle,pydocstyleSupportTo report bugs, suggest improvements, or ask questions, please create a
new issue athttp://github.com/pylava/pylava_pylint/issues.ContributingDevelopment of Pylava happens at themasterbranch ofhttps://github.com/pylava/pylava_pylint.ContributorsSeeAUTHORS.LicenseThis is free software. You are permitted to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of it, under the
terms of the MIT License. SeeLICENSE.rstfor the complete license.This software is provided WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. SeeLICENSE.rstfor the complete disclaimer.The original LICENSE file with the BSD-3-Clause license text is archived
in thepylama-archivedirectory.
Package: pylawson
This package exposes a Python API to connect to Infor Lawson IOS services.Thepylawson.clientpackage contains Session objects for authenticating on the lawson server:sec_api.SecApiSessionfor Windows utilizes thesec-api.dlllibrary which is installed with
the Lawson Excel Add-Ins; andms_samlpr.SamlSessionwhich usesrequeststo robotically
authenticate through the SAML login session.Simple use:First create a json file with connection details (each value is optional and can alternatively
be passed directly to the session instantiation):{"lawson":{"lawson_server":"https://target.resource/sso/SSOServlet","ident_server":"http://identity.provider/adfs","ident_host":"identity.provider","username":"username","password":"password"}}Then write a couple of lines of code:frompylawson.clientimportSamlSessionasIoslawson=Ios(json_file='./pylawson.json')response=lawson.tokens({'systemCode':'GL'})This authenticates on the server and returns Lawson’s XML response in a string with the result
of a ListTokens action for the GL system.NOTE:The IOS URL’s and parameters are documented in Infor’s‘Doc for Developers: IOS Application
Program Interfaces–Windows’available on the Infor Xtreme support site.
Package: py-laxz
A Utility for Sys Admin or Personal Use (Intergrated with SHELL).TODOto integrate with ORM relational databases.Installation (any platform)$ python3 -m pip install --no-cache-dir --upgrade py-laxzUsage (as script)$ pylaxz --help # for options
$ pylaxz -N --help # for Network options
$ pylaxz -S --help # for System options
$ pylaxz -L --help # for SHELL optionsRare Usage (as direct)$ python3 -m pylaxz -hUsage (as python module - logxs for machine learning)>>> from pylaxz.utils.logxs import printf
>>> printf(ANYTHING)if you have time :>>> import pylaxz
>>> dir(pylaxz)
>>> help(pylaxz)printf is logger function and works well with various python's data typesand also with numpy's data shapes.
Package: pylayerize
PylayerizePylayerize simplifies the process of creating AWS Lambda Layers by leveraging Docker to compile and package Python dependencies for any targeted runtime. With support for custom packages and private GitHub repos, pylayerize optimizes the creation and deployment of Lambda Layers for improved development efficiency.General UsageTo use Pylayerize, you must first install it using pip:$pipinstallpylayerizeOnce pylayerize is installed, you can run it from the command line by invoking the pylayerize command.$pylayerize-tp<target_package>[OPTIONS]Required Options:-tp, --target-package: The target package to build a layer for.Optional Options:-h, --help: Show the help message and exit.-op, --output-path: The output path for the layer .zip file. Default is the current directory (.).-n, --output-layer-name: The name of the output .zip file. Default is lambda_layer.-ll, --log-level: The log level of logging. Default is INFO.-gu, --git-username: The git username to use for the git clone.-gp, --git-password: The git password to use for the git clone.-rt, --runtime: The runtime to use for the layer. Default is python3.8.--console-log, --no-console-log: Log to console. Default is True.--local, --no-local: Set to True if you want to use a requirments.txt file or a custom lib stored locally. Default is False.ExamplesTo build a layer for numpy using the default options, run:$pylayerize-tpmy_packageTo build a layer for numpy with a custom output path and layer name, run:$pylayerize-tpnumpy-op/path/to/output-nmy_layerTo build a layer for private GitHub repositories that require authentication, run:$pylayerize--target-packagegit+my_repo_link--git-usernamemy_username--git-passwordmy_passwordIf you have a local requirements.txt file at /path/to/requirements.txt, you can use it by running$pylayerize--target-packagemypackage--local--requirements-file/path/to/requirements.txtProgramatic UsageIt is also possible to use pylayerize and its components programatically in Python.frompylayerizeimportbuild_aws_lamda_layerContributionsContributions are welcome! Here are some guidelines for contributing to this project:Fork this repository and create a new branch for your feature or bug fix.
Make your changes and commit them with descriptive commit messages.
Create a pull request against the dev branch and describe your changes and the problem they solve.
Ensure that your code passes all tests and meets the project's code standards.
Respond to any feedback from maintainers and make any necessary changes.
If you'd like to contribute but aren't sure where to start, take a look at the project's issue tracker. Issues marked as "help wanted" or "good first issue" are a good place to start.