Saravanan666/pypi-org huggingface dataset:
Package: pyosmeta
pyosmetaDescriptionpyosmetaprovides the tools and scripts used to managepyOpenSci's contributor and peer
review metadata.
This repo contains a small module and several CLI scripts, including:parse-historyupdate-contributorsupdate-reviewsupdate-review-teamsSince pyOpenSci uses this tool for its website, we expect this package to have infrequent releases.InstallationUsing pip:pip install pyosmetaUsing conda:conda install pyosmetaUsageSeeCONTRIBUTING.md.Note: this section will be rewritten to be more user focused.Contributors ✨Thanks goes to these wonderful people (emoji key):Ivan Ogasawara💻👀🎨Meer (Miriam) Williamson💻👀Tiffany Xiao💻👀austinlg96💻👀🎨JAKE👀💻🎨Luiz Irber💻👀Barnabas Bulpett (He/Him)💻👀Juanita Gomez💻👀Sarah Kaiser💻👀Sultan Orazbayev💻👀Simon💻👀Carol Willing💻👀Ofek Lev💻👀This project follows theall-contributorsspecification.
Contributions of any kind welcome!ContributingCONTRIBUTING.mdDevelopmentDevelopment guideChange logCHANGELOG.mdCode of ConductEveryone interacting in the pyOpenSci project's codebases, issue trackers, chat rooms, and communication venues is
expected to follow thepyOpenSci Code of Conduct.LicenseMIT License
Package: pyosmptparser
A python wrapper forosmptparserInstallpip install pyosmptparserpypi package:https://pypi.org/project/pyosmptparser/Usageimport pyosmptparser
p = pyosmptparser.Parser('ecuador-osm.pbf')
pts = p.get_public_transports(150)
pt1 = [p for p in pts if p.id == 85965][0]
print(pt1)(seetest_pyosmptparser.pyfile for a more complete example)Developgit clone git@github.com:cualbondi/pyosmptparser.git
cd pyosmptparser
rustup override set nightly
virtualenv --python python3 .env
source .env/bin/activate

# run tests
pip3 install tox maturin
tox

# build and copy
maturin develop
cp target/debug/libpyosmptparser.so pyosmptparser.so

# build and deploy
maturin publish
Package: pyOSOAA
pyOSOAApyOSOAAis a python interface for the Ocean Successive Orders with Atmosphere - Advanced (OSOAA) radiative transfer. The OSOAA is a radiative transfer code developed in the Sorbonne Université by Pr. Malik Chami group and supported by the CNES.The coded is based in the successive orders of scattering method and the OSOA code developed by Malik Chami in 2001 that included the computation of the radiance and polarization for the ocean-atmosphere system with a flat surface.The OSOAA code simulates:Atmospheric and sea profiles: The atmosphere can be and sea profiles can be defined by the user both for the molecules and aerosol in the atmosphere and the water column, chlorophyll and mineral-like particles in the sea. Detritus and yellow substance absorption can also be modelled.Aerosol models: Aerosol models include WMO, LND, Junge mono-modal, bimodal LND and Shettle and Fenn.Hydrosol models: For phytoplankton and mineral-like particles including scattering and absorbing properties.Sea surface interface: Both for a flat surface or by a rough surface using Cox and Munk model.ThepyOSOAAinterface aims to incorporate the creation of run scripts and parsing of output results for the OSOAA model. It also incorporates helpers to perform common tasks like calculating the radiance for a certain band instead of a wavelength or running the model for multiple wavelengths.This code was inspired bypy6Sby Robin Wilson.You can find the fullpyOSOAAmanualhere.InstallationThe installation of thepyOSOAAhas two parts.First, you need to install the OSOAA software package fromhttps://github.com/CNES/RadiativeTransferCode-OSOAA.Second, install pyOSOAA. There are two ways to install pyOSOAA.Install pyOSOAA from pypipipinstallpyOSOAAInstall pyOSOAA from source codeDownload the last version of thepyOSOAAfromgithub.Once downloaded decompress it, go to the folder containing the code and runpythonsetup.pyinstallTo then check that software installed correctly# Load pyOSOAA moduleimportpyOSOAA# Run the test suitepyOSOAA.test()the following output should appear at the end of the screenOSOAA wrapper script by Francisco Nemiña
Inspired by Py6S wrapper by Robin Wilson
Using OSOAA located at /home/.../OSOAA_V1.5
Running OSOAA using a set of test parameters
The results are:
Expected result: 0.128266
Actual result: 0.128266
#### Results agree PyOSOAA is working correctly
Package: pyospackage
pyospackageWhat does pyospackage do?pyospackage is a demonstration Python package that compliments the pyOpenScibeginner tutorial series on creating a Python package.Table of ContentsInstallationLicenseHow to installYou can install this package using either pip or conda-forge. We recommend that you create a new Python
environment to work in when installing this package. Use
whatever environment manager that you wish!To install the package using pip:pip install pyospackageTo install the package using conda-forge:conda install -c conda-forge pyospackageGet started using packagenameTo use this package:frompyospackage.add_numbersimportadd_numa=add_num(1,2)print(a)You can also add any links to this section to tutorials in your documentation.CommunityInformation here about contributing to your package. links to your code of conduct and development guide.How to cite pyospackageTo cite pyospackage please follow the citation instructions on zenodo.Leah Wasser. (2024). pyOpenSci/pyosPackage: v0.1 Test release (v0.1.0). Zenodo. https://doi.org/10.5281/zenodo.10594121Licensepyospackageis distributed under the terms of theMITlicense.
Package: pyOSPParser
pyOSPParserPython modules for parsing and deploying the xml/json files used in theOpen Simulation Platform. The module
can parse the following xml/json files for the simulation.OSP model description file (XXX_OspModelDescription.xml)OSP system structure file (OspSystemStructure.xml)OSP logging configuration file (LogConfig.xml)OSP scenario configuration file (XXX.json)Getting StartedInstallationpyOSPParser requires Python 3.7 or later. Primarily, you can install pyOSPParser by pip:pipinstallpyospparser
Package: pyosreplace
Backport of os.replace()http://docs.python.org/3.3/library/os.html#os.replacehttp://bugs.python.org/issue8828Suggested usage:import sys
if sys.version_info >= (3, 3):
    from os import replace
elif sys.platform == "win32":
    from osreplace import replace
else:
    # POSIX rename() is always atomic
    from os import rename as replacePython 3.1 is not supported. Please upgrade to Python 3.2 or better.Technical detailsThereplace()function usesMoveFileEx()withMOVEFILE_REPLACE_EXISTINGflag. The flag can’t be used to rename directories so it’s not entirely equal
to rename(P) on POSIX.MoveFileEx()isNOTguaranteed to be atomic. Under certain and unknown
circumstances it may silently fall back to a non atomic call toCopyFile().MoveFileTransacted()could improve the situation but it requires Vista or
newer.http://msdn.microsoft.com/en-us/library/windows/desktop/aa365240%28v=vs.85%29.aspxhttp://msdn.microsoft.com/en-us/library/windows/desktop/aa365241%28v=vs.85%29.aspxCreditsOriginal patch by Antoine Pitrou.Changelogpyosreplace 0.1Release date: 05-Nov-2013Python 3.2 supporttox for testingpyosreplace 0.1b1Release date: 02-Jul-2013initial beta release
Package: pyosrm
pyosrmCython wrapper of osrm-backend to be used in Python.InstallationInstalling via pipYou can install using pip:pip install pyosrmThis method is available only for Linux, since there is no wheel built for MacOS or Windows.Installing from sourceFirst things first, osrm-backend needs to be installed.To install osrm-backend, follow theinstructionsin the official repository. There is also awiki tutorialfor other platforms. Don't use Mason, otherwise you will get some nasty segfault errors on your python code.Clone the repository and make sure Cython is installed. Then proceed to install locally via pip:pip install .Or, if you want to build inline:python setup.py build_ext --inplaceUsageIt is most likely you will need to install osrm-backend first to pre-process the data, since this package does not provide the cli tools to do it yet. Follow the instructions in theproject wikito pre-process the data using the desired algorithm (CH or MLD).To create a PyOSRM object, you need to pass the path to the pre-processed data, and the algorithm (default 'CH' or 'MLD').import pyosrm
router = posrm.PyOSRM("tests/data/ch/monaco-latest.osrm")RouteTo use the Route API, you just need to pass a list of coordinate pairs in format [lon, lat]. The easiest way to get the result is by using the RouteResult.json method, which formats the data in a easily serializable dictionary like the original APIresult object.from pyosrm import PyOSRM, Status
router = PyOSRM("tests/data/ch/monaco-latest.osrm", algorithm='CH')
result = router.route([[7.419758, 43.731142], [7.419505, 43.736825]])
if result.status == Status.Ok:
    print(result.json())
Package: py-osrm-client
py-osrm-clientSimple and typed Python client forOSRMapi.RequirementsrequestsaiohttpInstallationpipinstallpy-osrm-clientUsageAsync client:importasynciofromosrmimportOsrmAsyncClientasyncdefexample():asyncwithOsrmAsyncClient()asosrm:coordinates=[(0.1,0.2),(0.3,0.4)]trip=awaitosrm.trip(coordinates)print(trip)asyncio.run(example())Sync client:fromosrmimportOsrmClientwithOsrmClient()asosrm:coordinates=[(0.1,0.2),(0.3,0.4)]trip=osrm.trip(coordinates)print(trip)By default the clients will refer to the OSRM demo server athttps://router.project-osrm.org.
To use another OSRM server:asyncwithOsrmAsyncClient(base_url='https://my-custom-osrm-server.com')asosrm:# use clientRefer toOSRM api documentationfor more details
about OSRM services and options.
Package: pyosrs
pyosrs - Python Library for Old School RuneScapepyosrs is a Python library that provides a simple interface for retrieving and parsing data from the Old School RuneScape hiscores.InstallationTo install pyosrs, you can use pip:pip install pyosrsUsageRetrieving HiscoresTo retrieve the hiscore for a player, you can create a Pyosrs instance and use its get_hiscore method. Here's an example:importasynciofrompyosrs.clientimportPyosrsfrompyosrs.enumsimportGAME_MODEasyncdefmain():asyncwithPyosrs()aspyosrs:hiscore=awaitpyosrs.get_hiscore("username")# With game modehiscore=awaitpyosrs.get_hiscore("username",GAME_MODE.MAIN)print(hiscore.skills.overall.rank)print(hiscore.skills.overall.level)print(hiscore.skills.overall.experience)asyncio.run(main())This will output the overall rank, level, and experience for the player in the main game mode.Retrieving Game ModeTo retrieve the game mode for a player, you can useget_game_modemethod which returns a tuple of the game mode and the player's hiscore object. Here's an example:game_mode,hiscore=awaitpyosrs.get_game_mode("username")Handling ErrorsIf the username provided is invalid, aInvalidUserExceptionexception will be raised. If there is a new type of hiscore data response that hasn't been accounted for, aInvalidAPIResponseExceptionexception will be raised.try:hiscore=awaitpyosrs.get_hiscore("invalid username")exceptInvalidUserException:print("Invalid username")ContributingIf you would like to contribute to pyosrs, please feel free to submit a pull request or open an issue on the GitHub repository.Here's a quick start guide to setup the project:gitclonehttps://github.com/phongse/pyosrs.gitcdpyosrs# Create virtual environmentpython-mvenv.venv# Activate venv (Linux, Mac)source.venv/bin/activate# Activate venv (Windows).\venv\Scripts\Activate.ps1# Install poetry and pyosrs dependenciespython-mpipinstall--upgradepippoetry
poetryinstall--withdev# Install pre-commitpre-commitinstallWithmakeyou can run tests and format the code:makeformat
makemypy
maketests
makeprecommitLicensepyosrs is licensed under the GNU Lesser General Public License. SeeLICENSE.
Package: pyostal
PYostal: Postal API ClientThis library helps you use thePostalAPI in Python 3.9 (and above) to send Emails, get Message Details & Deliveries and Implement Events to handle Server Webhooks.It usesRequeststhe simple, yet elegant HTTP library to handle all the http sorcery.Installing Requests and Supported VersionsPYostal is available on PyPI:$python-mpipinstallpyostalPYostal officially supports Python 3.9+.UsageUsing the ClientYou will need an API Credential from your Postal Installation to use the API Client.frompyostal.clientimportClient# Create a new Postal client using the server key of your Postal Installation.client=Client('https://postal.yourdomain.com','your-api-key')# Optional: You can add any aditional Headers for your API installation# (Maybe Authorization)# You just add a dict with your headers:headers={'Authorization'=>'Basic RTYtaO54BGBtcG9yYWwyMDIw'}client=Client('https://postal.yourdomain.com','your-api-key',headers)#Or you can add them manually to a Client Instance:client.headers=headersSending an EmailSending an email is simple. You can follow the example below:# Create a dict with the message:payload={'to':['mail@example.com'],'from_address':'othermail@example.com','reply_to':'reply-to@example.com','subject':'This is a subject','plain_body':'This is a body'}#send it using the client. that's itresponse=client.send(payload)Or Create a new Email instance and add manually each of the Mail attributesfrompyostal.emailsimportEmailemail=Email({'to':['mail@example.com'],'bcc':['test1@example.com','test2@example.com],'from_address':'othermail@example.com','reply_to':'reply-to@example.com','subject':'This is a subject','plain_body':'This is a body'})email.add_cc('emailcc@example.com')email.html_body="<p>This is a HTML body</p>"# Here we get a pyostal.response.Response instanceresponse=client.send(Email)API InformationYou can get more information about the Postal API and Payloads in thePostal Project WikiAuthorRafael Nevarez
Package: pyosticket
PyOSTicketPython client for os ticketfrompyosticketimportOSTicketAPI,TicketModelosticket=OSTicketAPI(url="URL",api_key="API-KEY")# XXX Custom endpointsosticket.ticket.all("email@email.com")osticket.ticket.get("XXXXXXXXXXX","email@email.com")# create ticketticket=TicketModel(**{"name":"John Doe","email":"johndoe@lorem.com","subject":"Lorem Ipsum","topicId":"1","message":"data:text/html,Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam lobortis sagittis turpis vel bibendum. Nunc eget tincidunt leo. Suspendisse a nibh vulputate, ultrices leo mollis, maximus nisl.","attachments":[{"filename.png":"data:image/png;base64,BASE64_ENCODED_IMAGE_HERE"}]})osticket.ticket.create(ticket)
Package: pyosv
Open Satellite VisionThis library comprises a collection of functions and classes tailored to manage satellite based data.Click here to access the documentationInstallationYou need to create a virtual environmentcondacreate-nosvpython=3.10-y
condaactivateosv
condainstallpip-yThis package is stored onPyPi, you can easily install it using pippipinstall--upgradepyosvAlthough certain elements of this library draw from Mayavi, these package is not included in the library's prerequisites, and therefore, it will not be automatically installed. To install it run the following command, once your virtual environment is activepipinstallmayaviorcondainstallmayaviif there are issue with the first command.How to contributeClick here
Package: pyot
PyotPyot is an asyncIO-based high-level Python Riot Games API framework that encourages rapid development and clean, pragmatic design. It takes care of much of the hassle of the Riot Games API, so developers can focus on writing apps without needing to reinvent the wheel. It’s free and open source.IndexVersionPyPI6.0.9master6.0.9If you're migrating your project to a newer version of Pyot, please refer to theChangelogsection of thedocumentation.FeaturesFeatures that Pyot can provide for your projects.AsyncIO Based: Performing 60x faster with AsyncIO, highly configurable settings, and a wide range of tools to speed I/O tasks.Community Projects Integrations: Includes support for CDragon, MerakiCDN. DDragon for LoL is Forbidden due to incompatible APIs.Caches Integrated: A wide range of Caches Stores is available out of the box, and currently supports Omnistone(Runtime), RedisCache(RAM), DiskCache(Disk), and MongoDB(NoSQL).Multiple Models: Available models of League of Legends, Teamfight Tactics, Legends of Runeterra and VALORANT.Code Autocompletion: Access data through attributes and properties, and maximize code efficiency with code autocompletion.Perfect Rate Limiter: Pyot's Rate Limiter is production-tested in all asynchronous, multithreaded, and multiprocessed environments.User-Friendly Docs: Human readable documentation that covers guides and all the available high-level and low-level APIs in Pyot.If this framework is useful, consider giving astarto the repo.DocumentationPortal:https://pyot.iann838.comThe documentation covers:Installation.Configuration.Base Objects.Concurrency Basics.Models API.Stores.Limiters.Utilities.Integrations.Issues.Changelog.Due to the complexity of the framework, there is no quick-start guide, it is recommended to start with:Reading and understanding theCoressection of the documentation.Reading and understanding the example projects atExamplessection to get familiar.If your project requires a specific integration, check outIntegrationssection.
Package: pyotb
pyotb: Orfeo ToolBox for Pythonpyotbwraps theOrfeo Toolboxin a pythonic, developer friendly
fashion.Key featuresEasy use of Orfeo ToolBox (OTB) applications from pythonSimplify common sophisticated I/O features of OTBLazy execution of operations thanks to OTB streaming mechanismInteroperable with popular python libraries (numpyandrasterio)ExtensibleDocumentation hosted atpyotb.readthedocs.io.ExampleBuilding a simple pipeline with OTB applicationsimportpyotb# RigidTransformResample, with input parameters as dictresampled=pyotb.RigidTransformResample({"in":"https://myserver.ia/input.tif",# Note: no /vsicurl/"interpolator":"linear","transform.type.id.scaley":0.5,"transform.type.id.scalex":0.5})# OpticalCalibration, with input parameters as argscalib=pyotb.OpticalCalibration(resampled)# BandMath, with input parameters as kwargsndvi=pyotb.BandMath(calib,exp="ndvi(im1b1, im1b4)")# Pythonic slicingroi=ndvi[20:586,9:572]# Pipeline execution. The actual computation happens here!roi.write("output.tif","float")
Package: pyoti
PyOTI - Python Open Threat IntelligencePyOTI is an API framework to easily query threat intel APIs to get fast, accurate and consistent enrichment data to provide added context to your indicators of compromise. Built as a modular framework to make it easy to use any of the available APIs without needing to be an experienced coder. If a service or tool you use isn’t already in PyOTI it is simple to add a new enrichment module or you may open an issue for a feature request and we can work to get it added into the project.Currently, PyOTI only performs queries to check if an indicator of compromise has already been scanned and/or analyzed OR seen by any of the APIs included in PyOTI. However, it is on the road map to add the ability to submit (or resubmit) an indicator of compromise to be scanned and/or analyzed by PyOTI’s APIs.Indicator TypesAPIsDomainsCheckDMARC, CIRCLPDNS, IrisInvestigate, WhoisXMLEmail AddressesDisposableEmails, EmailRepIOHashesCIRCLHashLookup, MalwareBazaar, MalwareHashRegistryIP AddressesAbuseIPDB, GreyNoise, SpamhausIntelURLsGoogleSafeBrowsing, LinkPreview, Phishtank, ProofpointURLDecoderMultisCIRCLPSSL, DNSBlockList, HybridAnalysis, MaltiverseIOC, MISP, Onyphe, OTX, Pulsedive, ThreatFox, URLhaus, URLscan, VirusTotalV2, VirusTotalV3, XForceExchangeInstalling via pipIt is advised to use a virtual environment.python3-mpipinstallpyotiIf you want to also use the Jupyter Notebook please install additional dependencies.python3-mpipinstallpyoti[jupyter_notebook]Installing/Updating from sourceWindows instructions can be found in the docs directoryhere.Linux instructions can be found in the docs directoryhere.TutorialFor a quick tutorial on the ease and benefit of using PyOTI you can view the Phishing URL Triage Jupyter Notebookhere.LicenseCopyright © 2021-2022, RH-ISACThis work is free software. You may redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or
at your option, any later version.This work is distributed in the hope that it will be useful, but is made available 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.Please review the GNU General Public License athttps://www.gnu.org/licenses/for additional information.
Package: pyotify
pyotifyA fully-featured Python library for the Spotify Web APIInstallationpip install pyotifyQuick StartAn example can be found in themain.pyfile.To get started, install pyotify and create an app onhttps://developers.spotify.com/.Add your app ID and SECRET to your environment.Then, using theos.getenv()method, get the app ID and SECRET.Finally pass both parameters to the 'Spotify' class.Reporting IssuesIf you have suggestions, bugs or other issues specific to this library, file themhere. Or just send me a pull request.
Package: pyotm
OTM is a platform for simulating vehicular traffic scenarios. It offers multiple models that can be arbitrarily combined in a single simulation. You can use one of the native OTM models (CTM, 2Q, Newell), or you can create a plugin for your own model. You can similarly implement new controllers as plugins.Learn morehere.Python APIMost users will interact with OTM through its Python API, which can be installed with pip:pip install pyotmThepyotmpackage contains a single class calledOTMWrapper. Below we see how to useOTMWrapperto run a step-by-step simulation.frompyotm.OTMWrapperimportOTMWrapper# in case there is a lingering open gatewayif"otm"inlocals():delotm# load the configuration fileotm=OTMWrapper("intersection.xml")# initialize (prepare/rewind the simulation)otm.initialize(start_time=0.0)# run step-by-step using the 'advance' methodtime=0.0# in secondsadvance_time=10.0while(time<3600.0):otm.advance(advance_time)# seconds, should be a multiple of sim_dtprint(otm.get_current_time())time+=advance_time;# deleting the wrapper to shut down the gatewaydelotmUserunto run an entire simulation.frompyotm.OTMWrapperimportOTMWrapperimportnumpyasnpif"otm"inlocals():delotmotm=OTMWrapper("intersection.xml")otm.run(start_time=0,duration=2500,output_dt=10)Y=otm.get_state_trajectory()print(Y.keys())delotmHereget_state_trajectoryhas been used to retrieve the state trajectory. This is a dictionary containing various state profiles.A comprehensive API is available via theotmattribute ofOTMWrapper. This API provides access to most of the internal state of OTM and should be used with care. The javadoc can be foundhere.
Package: pyotr
PyotrPyotris a Python library for serving and consuming REST APIs based onOpenAPIspecifications. Its name is acronym of "Python OpenAPI to REST".The project consists of two separate libraries that can be used independently:pyotr.serveris aStarlette-based framework for serving OpenAPI-based services.
It is functionally very similar toconnexion, except that it aims to be fullyASGI-compliant.pyotr.clientis a HTTP client for consuming OpenAPI-based services.WARNING:This is still very much work in progress and not quite ready for production usage. Until version 1.0 is
released, any version can be expected to break backward compatibility.Quick StartServerfrom pyotr.server import Application
from some.path import endpoints

app = Application.from_file("path/to/openapi.yaml", module=endpoints)Clientfrom pyotr.client import Client

client = Client.from_file("path/to/openapi.yaml")
result = client.some_endpoint_id("path", "variables", "query_var"="example")