Saravanan666/pypi-org huggingface dataset:
Package: pyopenplantbook
OpenPlantbookOpen Plantbook is a free service to access plant data. Anyone can use information from the database for any purpose without limitations.RequrementsIn order to use this API you need to login to Open Plantbook web UI athttps://open.plantbook.ioand generate API credentials. The credentials are client_id and client_secret. API authentication implements OAuth2 standard Client Credentials Grant flow.UsageThe library is written with async functions.import asyncio

from pyopenplantbook import OpenPlantBookApi

client_id = "xxxx"
secret = "yyyy"

api = OpenPlantBookApi(client_id=client_id, secret=secret)

async def get_plant(species):
    plant = await api.get_plantbook_data(species=species)
    return plant

def main():
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    result = loop.run_until_complete(get_plant("coleus 'marble'"))
    print(result)

main()
Package: pyopenproject
PyOpenProjectPython library to interact with OpenProject API.frompyopenprojectimportOpenProjectop=OpenProject(url="http://localhost:8080",apikey="6289058256894568479567886794")user=op.get_user_services().create(login="h.wurst",email="h.wurst@openproject.com",first_name="Hans",last_name="Wurst",admin=False,language="de",status="active",# Password minimum is 10 characters)password="h.wurst1234567890")This library could be understood as a compendium of OpenProject endpoints services to use in a client project with the
purpose of interact with OpenProject instance through its API.Installing pyopenprojectPyOpenProject is available on PyPI:python-mpipinstallpyopenprojectDocumentationAPI ReferenceYou can see some code examples developed in ourtest casesContributingIf you want to contribute, please:Fork it (https://github.com/Flying-Free/pyopenproject/fork)Create your feature branch (git checkout -b feature/newEndpoint)Commit your changes (git commit -am 'Add some new Endpoint')Push to the branch (git push origin feature/newEndpoint)Create a new Pull RequestAuthorsAlan Padierna Fernández@AlanPadi95Marcelo Torrejón Manso@marcelotm23ContributorsPablo Suarez García@PabloSuaGar
Package: pyOpenRPA
Welcome to pyOpenRPA’s wikiby Ivan Maslov (Russia)DonatepyOpenRPA is a commercial project.AboutDear RPA-tors. Let me congratulate you with great change in the RPA world. Since 2019 the first enterprise level open source RPA platform is here!pyOpenRPA is absolutely open source commercial project. Hosted by LLC PYOPENRPA (RUSSIA)The pyOpenRPA - free, fast and reliable
Powerful OpenSource RPA tool for business (based on python 3). Best performance and absolutely free!The pyOpenRPA is based on Python and using well known OpenSource solutions such as Selenium, OpenCV, Win32, UI automation and others. Thanks to it we were able to create consolidated platform with all possible features.
The pyOpenRPA is distributed under the PYOPENRPA open license.
At the time of this writing the pyOpenRPA is successfully using in several big Russian companies. Companies in which it was decided to develop own RPA division with no dependencies on expensive licenses.WikiNow you can use the following docs:ENG Guide HTML|OPEN GITLAB|ENG Guide MarkDown|OPEN GITLAB|ENG Guide PDF|OPEN GITLAB|RUS Article: Less cost - no paid RPA|OPEN HABR|RUS Tutorial Desktop UI|OPEN HABR|;|OPEN GITLAB|RUS Tutorial Web UI|OPEN HABR|;|OPEN GITLAB|RUS Leaflet pyOpenRPA v5.pdf|OPEN GITLAB|Copyrights & ContactspyOpenRPA is created by Ivan Maslov (Russia). Use it for free only for non-commercial purposes. For commercial purpose please ask pyOpenRPA vendor for license.
My purpose is to create #IT4Business models.
If you need IT help feel free to contact me.Ivan Maslov contacts (CEO & FOUNDER):E-mail:Ivan.Maslov@pyOpenRPA.ruSkype: MegaFinderWeb:https://pyopenrpa.ru/Telegram:https://t.me/pyopenrpaWhatsApp | Telegram: +7 906 722 39 25 | @IvanMaslov
Package: py-opensea-sdk
Python SDK for the OpenSea APIAn unofficial Python SDK for theOpenSea API.FeaturesTypingAll endpoints supportedOptional API keyWebSocket supportInstallationpipinstallpy-opensea-sdkUpgradepipinstallpy-opensea-sdk-UUsagefrompyopenseaimportOpenSeaAPI# Create API instanceapi=OpenSeaAPI('OPTIONAL-API-KEY')# Examplesapi.assets(owner='0x20481b79a4F03b624D214d23aDf5bF5f33bEB4aA')api.contract('0x8a90cab2b38dba80c64b7734e58ee1db38b8992e')api.listings('0x8a90cab2b38dba80c64b7734e58ee1db38b8992e',tokenID=10)api.offers('0x8a90cab2b38dba80c64b7734e58ee1db38b8992e',tokenID=10,limit=5)api.orders()fromdatetimeimportdatetime# Note: datetime objects are automatically converted to the UTC timezoneapi.orders('0x8a90cab2b38dba80c64b7734e58ee1db38b8992e',listedAfter=datetime(2022,7,5))api.events(occurredAfter=1658423412,occurredBefore=1658425412,limit=1,eventType='successful')# Note: datetime objects are automatically converted to the UTC timezoneapi.events(occurredAfter=datetime(2022,7,3),occurredBefore=datetime(2022,7,5),limit=1,eventType='successful')# And more api endpoints supported...ContributingFork it (https://github.com/FastestMolasses/PyOpensea/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: pyopenset
pyopensetPyopenset is a package that implements the meyhodology described in the paper:It allows a easy and intuitive way to add novel classes to a pretrained model without requiring further optimization, New classes will always be added after the last.So for example if your model has 10 neurons each for a single class ,the new class would be associated with neuron 11.Note that current implementation only supports softmax activation functions on the last layer.
Package: py-openshowvar
py_openshowvarA Python port of KUKA VarProxy client (OpenShowVar).Python versionSupports 2.6+ / 3.3+, tested at 2.7.11 and 3.6.3.InstallOn PYPI:https://pypi.python.org/pypi/py-openshowvarpip install py_openshowvarUsageModule usage:>>>frompy_openshowvarimportopenshowvar>>>client=openshowvar('192.168.19.132',7001)>>>client.can_connectTrue>>>ov=client.read('$OV_PRO',debug=True)[DEBUG](48,6,0,3,'100','\x00\x01\x01')100>>>print(ov)100>>>client.close()Built-in shell usage:$python./py_openshowvar.pyIPAddress:192.168.19.132Port:7001ConnectedKRCName:"xxxxxxxxxx"Inputvar_name[,var_value](`q`forquit):$OV_PRO[DEBUG](66,5,0,2,'50','\x00\x01\x01')50Inputvar_name[,var_value](`q`forquit):$OV_PRO,100[DEBUG](67,6,1,3,'100','\x00\x01\x01')100Inputvar_name[,var_value](`q`forquit):qBye
Package: pyopensky
pyopenskyThepyopenskyPython library provides functions to download data from the OpenSky Network live API and historical databases. It aims at making ADS-B and Mode S data from OpenSky easily accessible in the Python programming environment.Full documentation onhttps://open-aviation.github.io/pyopenskyInstallationpipinstallpyopenskyThe library is also available on conda-forge:condainstall-cconda-forgepyopenskyDevelopment mode (with poetry):gitclonehttps://github.com/open-aviation/pyopenskycdpyopensky
poetryinstallCredentialsApply for accessImpalahttps://opensky-network.org/data/impalaTrinocontact@opensky-network.org(or specify it in the Impala form)The first time you use the library, a configuration file namedsettings.confis created, including the following content:[default]
username =
password =You will identify the folder where thesettings.confis located:frompyopensky.configimportopensky_config_dirprint(opensky_config_dir)Usagefrom theREST API:frompyopensky.restimportRESTrest=REST()rest.states()rest.tracks(icao24)rest.routes(callsign)rest.aircraft(icao24,begin,end)rest.arrival(airport,begin,end)rest.departure(airport,begin,end)from theImpalashell (requires authentication):frompyopensky.impalaimportImpalaimpala=Impala()# full description of the whole set of parameters in the documentationimpala.flightlist(start,stop,*,airport,callsign,icao24)impala.history(start,stop,*,callsign,icao24,bounds)impala.rawdata(start,stop,*,callsign,icao24,bounds)from theTrinodatabase (requires authentication):frompyopensky.trinoimportTrinotrino=Trino()# full description of the whole set of parameters in the documentationtrino.flightlist(start,stop,*,airport,callsign,icao24)trino.history(start,stop,*,callsign,icao24,bounds)trino.rawdata(start,stop,*,callsign,icao24,bounds)
Package: py-opensonic
py-opensonicA python library for interacting with an Open Subsonic API implementation.
This started its life as thepy-soniclibrary.
I have tested with Gonic (and continue to do so against each stable docker
release). Please open issues if you discover problems with other implementations.INSTALLInstallation is fairly simple.  Just do the standard install as root:tar -xvzf py-opensonic-*.tar.gz
cd py-opensonic-*
python setup.py installYou can also install directly usingpiporeasy_installpip install py-opensonicUSAGEThis library follows the REST API almost exactly (for now).  If you follow the
documentation onhttps://opensubsonic.netlify.app/docs/or you do a:pydoc libopensonic.connectionThe py-sonic original author has added documentation athttp://stuffivelearned.org/doku.php?id=programming:python:py-sonicBASIC TUTORIALThis is about as basic as it gets.  We are just going to set up the connection
and then get a couple of random songs.#!/usr/bin/env pythonimportlibopensonic# We pass in the base url, the username, password, and port number# Be sure to use https:// if this is an ssl connection!conn=libopensonic.Connection('https://music.example.com','myuser','secretpass',port=443)# Let's get 2 completely random songssongs=conn.getRandomSongs(size=2)# We'll just pretty print the results we got to the terminalprint(songs[0].to_dict())As you can see, it's really pretty simple.  If you use the documentation
provided in the library:pydoc libopensonic.connectionor the api docs on opensubsonic.netlify.app (listed above), you should be
able to make use of your server without too much trouble.Right now, only plain old dictionary structures are returned.I may choose to do any of the following things on the original author's
TODO list:Lazy access of members (the song objects aren't created until you want to
do something with them)
However, I want to try and use the presented API first.TODOIn the future, I would like to make this a little more "pythonic" and add
some classes to wrap up the data returned from the server.  Right now, the data
is just returned in the form of a dict, but I would like to have actual
Song, Album, Folder, etc. classes instead, or at least an alternative.  For
now, it works.NOTE:I've noticed a wart with the upstream Subsonic API wherein any
of the Connection methods that would normally return a list of dictionary
elements (getPlaylists() for example), will only return a dictionary if there
is a single return element.  I plan on changing this in py-sonic so that
any methods of that nature willalwaysreturn a list, even if there is
only a single dict in the list.
Package: pyopenspecy
pyopenspecyQuickly grab spectra from Open Specy through python!pyopenspecyallows you to grab specific or random Raman and FTIR spectra from the Open Specy libraries.ExampleGet a random spectrumimport pyopenspecy

 spectrum, metadata = pyopenspecy.random_raman_spectrum()Get a specific spectrumspectrum, metadata = pyopenspecy.raman_spectrum_by_id(801)Fuzzy search for a spectrum by sample material name.pyopenspecy.fuzzy_search_raman("Fe O3", limit=10)
Package: pyopenssl-psk
pyopenssl-pskAdd PSK support to pyOpenSSL.Installation$ pip install pyopenssl-pskAPIPatch Methodpatch_context()Add PSK related methods to theOpenSSL.SSL.Contextclass.fromopenssl_pskimportpatch_contextpatch_context()Server MethodsContext.use_psk_identity_hint(hint: bytes) -> NoneSet the server PSK identity hint.Context.set_psk_server_callback(callback: server_callback) -> NoneSet a callback to populate the server PSK.server_callback(connection: Connection, client_identity: bytes) -> psk: bytesUser provided callback function to populate the connection PSK.fromOpenSSL.SSLimportContext,Connection,TLSv1_2_METHODPSK_MAP={b'pre_shared_key_identity':b'pre_shared_key',}defserver_callback(conn,client_identity):returnPSK_MAP[client_identity]ctx=Context(TLSv1_2_METHOD)ctx.set_cipher_list(b'PSK')ctx.use_psk_identity_hint(b'pre_shared_key_identity_hint')ctx.set_psk_server_callback(server_callback)server=Connection(ctx)Client MethodsContext.set_psk_client_callback(callback: client_callback) -> NoneSet a callback to populate the client PSK identity and PSK.client_callback(connection: Connection, identity_hint: bytes) -> tuple(psk_identity: bytes, psk: bytes)User provided callback function to populate the connection PSK identity and PSK.fromOpenSSL.SSLimportContext,Connection,TLSv1_2_METHODdefclient_callback(conn,identity_hint):return(b'pre_shared_key_identity',b'pre_shared_key')ctx=Context(TLSv1_2_METHOD)ctx.set_cipher_list(b'PSK')ctx.set_psk_client_callback(client_callback)client=Connection(ctx)SeeOpenSSL.SSLdocumentationfor more information.
Package: pyopenstates
pyopenstatesA Python client for theOpen States API v3.Source:https://github.com/openstates/pyopenstates/Documentation:https://openstates.github.io/pyopenstates/Issues:https://github.com/openstates/pyopenstates/issuesNote: This library was recently updated to support Open States API v3, documentation & coverage is a bit behind, but we wanted to get a release out.  Feel free to contribute issues and/or fixes.FeaturesCompatible with Python 3.7+Automatic conversion of string dates and timestamps todatetimeobjects.Tested releases.Set API Key via environment variable or in code.API KeysTo use the Open States API you mustobtain an API Key.Once you have your key you can use it with this library by setting theOPENSTATES_API_KEYenvironment variable or callingpyopenstates.set_api_key.About Open StatesOpen States strives to improve civic engagement at the state level by providing data and tools regarding state legislatures. We aim to serve members of the public, activist groups, journalists, and researchers with better data on what is happening in their state capital, and to provide tools to reduce barriers to participation and increase engagement.Open States aggregates legislative information from all 50 states, Washington, D.C., and Puerto Rico. This information is then standardized, cleaned, and published to the public via OpenStates.org, a powerful API, and bulk downloads. OpenStates.org enables individuals to find out who represents them, look up information on an important bill that’s been in the news, discover how their representatives are voting, or just stay current with what is happening in their state. Additionally, our API and bulk downloads see millions of hits every month from advocacy organizations, journalists, researchers, and many others.Legislative data is collected from official sources, linked at the bottom of relevant pages. In general bill & vote data is collected multiple times a day via our scrapers while legislator data is curated by our team & volunteers like you.
Package: pyopenuv
☀️ pyopenuv: A simple Python API for data from openuv.iopyopenuvis a simple Python library for retrieving UV-related information fromopenuv.io.InstallationPython VersionsAPI KeyUsageContributingInstallationpipinstallpyopenuvPython Versionspyopenuvis currently supported on:Python 3.10Python 3.11Python 3.12API KeyYou can get an API key fromthe OpenUV console.UsageimportasynciofrompyopenuvimportClientfrompyopenuv.errorsimportOpenUvErrorasyncdefmain():client=Client("<OPENUV_API_KEY>","<LATITUDE>","<LONGITUDE>",altitude="<ALTITUDE>")try:# Get the current status of the OpenUV API:print(awaitclient.api_status())# >>> True# Get current UV info:print(awaitclient.uv_index())# >>> { "result": { ... } }# Get forecasted UV info:print(awaitclient.uv_forecast())# >>> { "result": { ... } }# Get UV protection window:print(awaitclient.uv_protection_window())# >>> { "result": { ... } }# Get API usage info/statistics:print(awaitclient.api_statistics())# >>> { "result": { ... } }exceptOpenUvErroraserr:print(f"There was an error:{err}")asyncio.run(main())Checking API Status Before RequestsIf you would prefer to not callapi_statusmanually, you can configure theClientobject
to automatically check the status of the OpenUV API before executing any of the API
methods—simply pass thecheck_status_before_requestparameter:importasynciofrompyopenuvimportClientfrompyopenuv.errorsimportApiUnavailableError,OpenUvErrorasyncdefmain():client=Client("<OPENUV_API_KEY>","<LATITUDE>","<LONGITUDE>",altitude="<ALTITUDE>",check_status_before_request=True,)try:print(awaitclient.uv_index())exceptApiUnavailableError:print("The API is unavailable")exceptOpenUvErroraserr:print(f"There was an error:{err}")asyncio.run(main())Connection PoolingBy default, the library creates a new connection to OpenUV with each coroutine. If you
are calling a large number of coroutines (or merely want to squeeze out every second of
runtime savings possible), anaiohttpClientSessioncan be used for
connection pooling:importasynciofromaiohttpimportClientSessionfrompyopenuvimportClientfrompyopenuv.errorsimportOpenUvErrorasyncdefmain():asyncwithClientSession()assession:client=Client("<OPENUV_API_KEY>","<LATITUDE>","<LONGITUDE>",altitude="<ALTITUDE>",session=session,)try:print(awaitclient.uv_index())exceptOpenUvErroraserr:print(f"There was an error:{err}")asyncio.run(main())ContributingThanks to all ofour contributorsso far!Check for open features/bugsorinitiate a discussion on one.Fork the repository.(optional, but highly recommended) Create a virtual environment:python3 -m venv .venv(optional, but highly recommended) Enter the virtual environment:source ./.venv/bin/activateInstall the dev environment:script/setupCode your new feature or bug fix on a new branch.Write tests that cover your new functionality.Run tests and ensure 100% code coverage:poetry run pytest --cov pyopenuv testsUpdateREADME.mdwith any new documentation.Submit a pull request!
Package: pyopenvdb
docker_pyopenvdbOpenVDB for python 3.7
Creates a docker container, which is used to build and package pyopenvdb.InstallationCurrently only for linux systems with x86_64 archiutecturepip install pyopenvdbFind parent directory of pyopenvdb.so withfind / | grep -P 'pyopenvdb\.soexport LD_LIBRARY_PATH=[parent directory]InstallationInstalldockerInstalldocker-machine(if running on macOS or Windows)Ensure docker-machine has at least 4 GB of memory allocated to it.cd docker_pyopenvdbchmod +x bin/pyopenvdbbin/pyopenvdb startThe service should take several minutes to start up.Runbin/pyopenvdb --helpfor more help on the command line tool.Usage>>>python3.7>>>import openvdb
Package: pyopenvdb-3.8
docker_pyopenvdbOpenVDB for python 3.7
Creates a docker container, which is used to build and package pyopenvdb.InstallationCurrently only for linux systems with x86_64 architecturepip install pyopenvdbFind parent directory of pyopenvdb.so withfind / | grep -P 'pyopenvdb\.so'export LD_LIBRARY_PATH=[parent directory]Addimport numpyandimport openvdbto ipykernel_launcher.py to get
jupyter lab to import without a pointer error.InstallationInstalldockerInstalldocker-machine(if running on macOS or Windows)Ensure docker-machine has at least 4 GB of memory allocated to it.cd docker_pyopenvdbchmod +x bin/pyopenvdbbin/pyopenvdb startThe service should take several minutes to start up.Runbin/pyopenvdb --helpfor more help on the command line tool.Usage>>>python3.7>>>import openvdb
Package: pyopenvidu
PyOpenViduPython interface to theOpenViduWebRTC videoconference framework.Free software: MIT licenseDocumentation:https://pyopenvidu.readthedocs.io.Flask extension:https://pypi.org/project/flask-openvidu/FeaturesUse OpenVidu API objects as native Python objectsSupports Python 3.7 and aboveDepends on nothing more thanrequestsandrequests-toolbeltCreditsThis implementation is inspired by the original Java implementation by the OpenVidu team.https://openvidu.io/docs/reference-docs/openvidu-java-client/This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.1 (2022-03-10)Addedcertandverifyoptions to the OpenVidu object constructor.Various fixes in the documentationIncluded Python 3.10 in the test suite0.2.0 (2020-12-30)Implemented OpenVidu REST API version 2.16.0.Removed inter-object updateChanged Base URLRemoved broken “Thread safety” approachSee the “Migrating” section of the documentation on how to update your code.0.1.4 (2020-05-24)Added timeouts.Added possibility to disable initial fetching.Fixed some mistakes in the documentation.Reached 100% code coverage.0.1.3 (2020-04-26)Implemented thread safety for the dynamic objects.Added IPCAM publishing option.Updated and restructured documentation.0.1.2 (2020-04-07)Removed publisher property of the OpenViduSubscriber object, as it was removed from the OpenVidu Server as well.0.1.1 (2020-04-04)Fixed dependencies not being automatically installed.Updated classifiers and URLs for PyPI.Added more tests and updated existing ones.0.1.0 (2020-04-03)First release on PyPI.Implemented support for most of the endpoints except recording and IPCam stuff.
Package: pyopenvpn
说明功能1. 获取登录的客户端的信息.
    commaon_name    # 客户端的登录名
    remote_ip       # 客户端的IP地址
    virtual_ip      # 分配给客户端的虚拟IP地址
    send_bytes      # 发送字节数
    recv_bytes      # 接收字节数
    login_time      # 登录时间

2. kill客户端
    依赖客户端的common_nameopenvpn启动management interface/usr/sbin/openvpn--cd/etc/openvpn/--configserver.conf--management10.0.0.11195使用示例1. 安装
pip install pyopenvpn

2. 使用
import pyopenvpn

vpn = pyopenvpn.Openvpn('10.0.0.1', 1195)

方法:
vpn.version()           # 获取vpn的版本
vpn.clients()           # 获取所有在线客户端
vpn.pid()               # 获取VPN的进程ID
vpn.kill(common_name)   # kill掉指定的客户端
vpn.close()             # 关闭socket
Package: pyOpENWatch
pyOpENWatchpip install pyOpENWatchFetch the NFTs that has been minted on the blockchain, with current tools,
NFT data is hard to reach or depends on commercial third party
APIs.This is not desirable for various reasons, PyOpENWatch offers an alternative.UsagefrompyopenwatchimportEthereumNFTWatcherwatcher=EthereumNFTWatcher(host,port,log_level)watcher.fetch_nfts_until_block(terminal_block_hash,limit,callback)Here, thepyopenwatch.EthereumNFTWatcherdoes the heavy lifting, you will have to point it
to an Ethereum node, using thehostandport. The nodecanbe a light node.log_levelrefers toPython's logging levelsif passed, you can control what sort of information is being logged.The watcher function traverses the blockchain and finds the NFTs being held inside,
theterminal_block_hashandlimitcan be provided to limit the number of blocks
the PyOpENWatch will fetch before terminating.Thecallbackfunction is the actual driving part of the package, it is a function
with the signature(pyopenwatch.NFT) => None. When theEthereumNFTWatcherfinds a new NFT,
it initialises anpyopenwatch.NFTclass and calls thiscallback.Pass a function that takes found NFTs and process them as they are found.LoggingMy understanding of the Ethereum nodes is that they can be extremely volatile,
and at numerous points significant errors may occur, thes errors are similar to
dropped packages in the TCP protocol, seem to occur when syncing issues occur,
in order to preserve functionality, instead of throwing errors, we log them instead,
the default behaviour of thepyopenwatch.EthereumNFTWatcheris to log these in theERRORlevel.If you set thelogger_leveltoINFO, newly found NFTs and mint transactions will
be logged. If thelogger_levelis set toDEBUGthe newly fetched transactions and
blocks wil be logged.Use CaseThis Python module was created as a part of a project to create a tool to find stolen
images minted as NFTs to help artists recover their stolen art. As you can probably
guess, I find NFTs and technology surrounding them less than ideal and I would
appereciate if dApp and Blockchain developers would refrain from using this library.I would also like people who use this technology to limit illegal blockchain activity
to get in touch.I understand that I cannot legally enforce this in any way, this is GPLv3 project,
solegallyyou are free to do whatever as long as you follow the License, but
still, I hope my words hold some weight for people.