Saravanan666/pypi-org huggingface dataset:
Package: helium-api-wrapper
Helium Api Wrapper[][license]FeaturesLoad data from the Helium Blockchain APIGet hotspots by addressGet hotspots by locationGet a list of hotspotsGet challenges of a hotspotGet a list of challengesLoad Data from the Helium Console APIGet device information by uuidRequirementsPython 3.8+PoetryInstallationYou can installHelium Api Wrappervia [pip] from [PyPI]:$pipinstallhelium-api-wrapperUsageYou can import different modules to load data from the Helium Blockchain API or the Helium Console API.fromhelium_api_wrapperimporthotspots,deviceshotspots.get_hotspot_by_address("some_address")devices.get_device_by_uuid("some_uuid")In order to use the Device API, you need to set theAPI_KEYenvironment variable.
It is also possible to set different API endpoints for the Helium Blockchain API and the Helium Console API.```consoleYoucanrunthewrapperasapythonmodule:python -m helium_api_wrapper --help
python -m helium_api_wrapper get-hotspots
python -m helium_api_wrapper get-hotspot --address your-hotspot-addressTo personalise the settings command the file (using -, -- or CAPS to specify your settings) in a preferred terminal.
To list all possible settings run the --help command.

## Contributing

Contributions are very welcome.
To learn more, see the [Contributor Guide].

## License

Distributed under the terms of the [MIT license][license],
_Helium Api Wrapper_ is free and open source software.

## Issues

If you encounter any problems,
please [file an issue] along with a detailed description.

## Credits

This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter] template.

[@cjolowicz]: https://github.com/cjolowicz
[pypi]: https://pypi.org/
[hypermodern python cookiecutter]: https://github.com/cjolowicz/cookiecutter-hypermodern-python
[file an issue]: https://github.com/emergotechnologies/helium-api-wrapper/issues
[pip]: https://pip.pypa.io/

<!-- github-only -->

[license]: https://github.com/emergotechnologies/helium-api-wrapper/blob/main/LICENSE
[contributor guide]: https://github.com/emergotechnologies/helium-api-wrapper/blob/main/CONTRIBUTING.md
[command-line reference]: https://helium-api-wrapper.readthedocs.io/en/latest/usage.html
Package: heliumcli
Helium CLIPrerequisitesPython (>= 3.8)Getting StartedThe Helium CLI can easily be used with a compatible project by installing it withpip install heliumcli. The utility
is then available from the command line withhelium-cli.More details pertaining to project compatibility, installation, and configuration can be found in theHelium CLI Wiki.ContributingWant to contribute financially? If you've foundhelium-cliuseful,sponsorshipwould
also be greatly appreciated!
Package: heliumhelper
HeliumHelperHeliumHelper is a Python library to aid in creating Helium apps.InstallationUse the package managerpipto install HeliumHelper.pipinstallHeliumHelperUsagefromheliumhelperimporthelpers# returns current oracle pricehelpers.get_current_price()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: helium-liftoff
LiftoffLiftoff is a set of command line tools for creating local development projects and resources.Pre-ReleaseLiftoff is currently in pre-release, and does not include any official support. Use this tool with caution, and report
any error messages or bugs todevelopers@heliumservices.com.How it WorksUnder the hood, liftoff uses a selection of docker containers to run all of the services necessary to power your web
application locally. Before using liftoff, ensure that you have Docker installed on your system.Liftoff includes the following service containers:PostgreSQL (database)MySQL (database)Adminer (web-based database client tool)Mailhog (fake smtp server for local email testing, includes web-based inbox)PHP 7.4 (interpreter for NGINX)PHP 8.0 (interpreter for NGINX)NGINX (local web server)These containers are shared between all of your local development projects, rather than creating new instances for each
new project. For each project that you configure with liftoff, liftoff creates a.liftoffdirectory which includes
all of the configuration files necessary to serve your project in the shared containers.Note that the.liftoffconfiguration directory should be included in your project source control, while select files
in that directory will be automatically added to your.gitignorefile.UsageLiftoff ServicesTo start liftoff services:liftoff startTo stop liftoff services:liftoff stopTo restart liftoff services:liftoff restartConfiguring a New Liftoff ProjectTo configure liftoff for a new project:cd /your/project/directory
liftoff initThen follow the question prompts to configure your project.Note that any questions that display numbered multiple choice options, you must enter the number of your answer, not the
text.Configuring an Existing Liftoff ProjectFor projects which have been previously initialized with Liftoff, but need to be configured for your system:cd /your/project/directory
liftoff buildThis is for projects which have an existing.liftoffconfiguration directory, but are new to your system, such as
projects which were configured on another developer's system, and you are now cloning the project on your own system.Alternatively, if you have already configured a project with liftoff, but you relocate the project directory on your
system, you should run this command.
Package: helium-positioning-api
Helium Positioning APIFeaturesPrediction of the location of devices belonging to an organization in theHelium Console.
Several different methods and models are available.DockerThe easiest way to run the positioning-API is to prepare an.envfile (see below for further instructions what should be in it) and run it as docker-container:docker run -p 8000:8000 --env-file=.env ghcr.io/emergotechnologies/helium-positioning-api:mainInstallationDeveloper installThe following allows a user to create a developer install of the positioning api.pip install -r requirements.txtpoetry installpoetry shellpip install git+https://github.com/emergotechnologies/helium-api-wrapperPrerequisitesBefore use, ensure that there is an.envfile in the root directory of the repository where theAPI_KEYvariable is entered (see.env.sample). You can generate and copy theAPI_KEYathttps://console.helium.com/profile.UsageThe service allows usage viacommand line interfaceor locally hostedREST interface.CLIGet Device Positionpython -m helium_positioning_api predict --uuid 92f23793-6647-40aa-b255-fa1d4baec75dCurrently defaults to the "nearest_neighbor" model.Advanced RequestsThe location prediction command ispython -m helium_positioning_api predict --uuid 'your uuid' --model 'your model selection'See the table below for a list of currently available models.ModelPosition estimation explanationSuggested usenearest_neighborLocation of hotspot with the best signalPurchase of at most one packet from a device (seePacket Configurationsfor more details)midpointPoint of equal distance from the two hotspots with the best signalsPurchase of at least two packets from a device (seePacket Configurationsfor more details)linear_regression (experimental)Trilateration with an linear regression distance estimatorExperimental. Purchase of at least three packets from a device (seePacket Configurationsfor more details)gradient_boosting (experimental)Trilateration with a gradient boosted regression distance estimatorExperimental. Purchase of at least three packets from a device (seePacket Configurationsfor more details)REST-APIStart local REST-API (default)python -m helium_positioning_api serveOpen Browser and navigate to127.0.0.1:8000/docsClick onpredict_tfpath to drop down the endpoint detailsClick on theTry it outbutton.Fill in theuuidof your device and click on the buttonExecuteto get an estimation using thenearest_neighbormodelYou can see the location prediction response in theResponsessection below.The mapping of available models to paths can be seen in the table below.modelpathnearest_neighborpredict_tfmidpointpredict_mplinear_regressionpredict_tl_lingradient_boostingpredict_tl_gradContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Helium Positioning APIis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: helium-py
helium-pyVersioningThis project followssemantic versioning. Prior to 1.0.0 this project does not
guarantee a stable public API.ModulesapicryptocurrencyonboardingprototesttransactionsAPIThe API module classes provide client classes for interacting with the Helium APIs.For full API specification and documentation please referencedocs.helium.com.fromdatetimeimportdatetime,timedeltafromhelium_py.apiimportChainVariables,Hotspots# Example of fetching chain variableschain_vars=ChainVariables()# Create a ChainVariables clientprint(chain_vars.get_all())# Get all chain variables# Example of fetching hotspot earnings for the last five dayshotspot_address="some_valid_hotspot_address"hotspots=Hotspots()hotspots.get_hotspot_rewards_total(hotspot_address,min_time=datetime.now()-timedelta(days=5))CryptoThe Crypto module classes provide Address, Keypair, and Mnemonic classes as well as helpful utilities.fromhelium_py.crypto.keypairimportKeypair# Example of creating a random keypair, accessing the address, and signing a messagekeypair=Keypair.make_random()address=keypair.address.b58# B58 public key addresskeypair.sign(b'message')# Sign a message with keypair private key
Package: helius
Helius APIs Python SDKPython SDK for interacting with theOfficial Helius APIs - https://docs.helius.xyz/api-reference/.InstallationInstalling Using PIP (Recommended)pipinstallheliusInstalling from SourceClone the repository:git clone https://github.com/vmpyre/helius_sdk.gitChange into the project directory:cd helius_sdkInstall the dependencies:pip install -r requirements.txtUsageFirst, import the SDK's classes for the APIs you'd like to use.>>fromheliusimportNFTAPI,NameAPI,BalancesAPI,WebhooksAPI,TransactionsAPIThen, create instances of the classes to interact with the corresponding API endpoints (in this case the BalancesAPI class):>>balances_api=BalancesAPI("<API_KEY_HERE>")Generate your API Key from here:https://docs.helius.xyz/introduction/generate-an-api-keyFor example, you can use theget_balances()method of theBalancesAPIclass to retrieve native Solana balance (in lamports) and all token balances for a given address:>>balances_api.get_balances("<SOLANA_WALLET_ADDRESS_HERE>")The SDK provides functionality for interacting with the NFTAPI, NameAPI, BalancesAPI, TransactionsAPI and WebhooksAPI endpoints.
You can view the class methods below:DocumentationWebhooksAPIcreate_webhook()get_all_webhooks()get_webhook()edit_webhook()delete_webhook()NFTAPIget_nft_events()get_mintlists()get_nft_fingerprint()get_active_listings()get_nft_metadata()TransactionsAPIget_raw_transactions()get_parsed_transactions()get_parsed_transaction_history()BalancesAPIget_balances()NameAPIget_address_name()See the Official Helius documentation for additional information:https://docs.helius.xyz/api-reference/ContributionFeel free to open issues, pull requests and submit feedback. We appreciate your help!LicenseThis project is licensed under the MIT License - see the LICENSE file for details.AcknowledgementsThanks to the Helius team for providing an amazing product.DisclaimerThe developer of this SDK is not part of Helius team and this SDK was submitted for the LamportDAO Hackathon. The developer is not responsible for any errors or issues that may occur when using this SDK. Use at your own risk and feel free to report issues.
Package: helius-sdk
WIPInstallationpip install helius-sdkYou can also install the in-development version with:pip install https://github.com/mmchougule/helius-sdk-python/archive/main.zipExamples>>> export API_KEY=YOUR_API_KEYGet transaction details>>> from helius_sdk.transaction import Transaction
>>> t = Transaction(api_key="api_key", tx_address="").get()
>>> t.shapeGet nft sales>>> from helius_sdk.event import Sale
>>> sale = Sale(api_key="api_key", col_address="").get()
>>> sale.shapeDocumentationhttps://helius-sdk-python.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2023-04-09)First release on PyPI.
Package: helixbio
logo✨ Run large protein models in less than 30 seconds with Modal. Open an issue if it takes longer! ✨Running large models and code that scales for big datasets in this repository is enabled byModal(no affiliation). It allows us to run code in the cloud on thousands of containers and GPUs without having to think for a second about infrastructure.Currently implementedESMFoldProteinMPNNParallelized codon optimization withDNAChiselUp NextRFDiffusionEvoProtGradEvodiff⚙️ Getting startedCreate an account atmodal.com.Open a terminal and run (requires Python 3.10+):pip install helixbioRunmodal token new🧬 Run your first modelLet's predict a protein structure using ESMFold. This also works in parallel for multiple sequences.modalrunhelix.esm::predict_structures_from_fasta--fasta-file"my_lovely_proteins.fasta"--output-dir"my_lovely_structures"ExamplesGenerate protein variants usingEvoProtGrad.modalrunhelix.evoprotgrad::get_evoprotgrad_variants--sequence"MSGKIDKILIVGGGTAGWMAASYLGKALQGTADITLLQAPDIP"--max-mutations4--num-chains20--n-steps200--output-csv-file"my-variants.csv"--output-fasta-file"my-variants.fasta"ContributingWe welcome contributions of any size! Below are some good ways to get started.GitHub Discussions: A great way to talk about features you want added or things that are confusing/need clarification.GitHub Issues: These are an excellent way to report bugs. Additionally, you can try and solve an existing issue and submit a PR.We are actively looking for contributors, no matter your skill level or experience.LicenseHelix is open-source and licensed under theApache License 2.0.
Package: helix.events.sdk
helix.events.sdkThe helix.events.sdk package facilitates sending strongly typed events within the helix architecure. Currently one type of event, AuditEvent, is supported.How to set upmake devsetup- to build the dev setupmake tests- to run all tests under/tests/directoryExamplesThe following code snippet shows how to instantiate and send and audit event:# create the AuditEventevent=AuditEvent(Source.BWELLBACKEND,Audit(patient_id="1",user_id="1",user_role="Patient",ip_address="192.168.1.1",action=AuditAction.READ,action_type=AuditActionType.VIEW,accessed_resource=ResourceType.DIAGNOSES))kafka_brokers=["kafkabroker1:9092","kafkabroker1:9092"]withKafkaEventWriter(get_logger(),kafka_brokers=kafka_brokers,use_ssl=True)askafka_event_writer:kafka_event_writer.write_event(event=event)The above code shows how to write an event to Kafka assuming the kafka cluster has two brokers and uses TLS.
Package: helix.fhir.client.sdk
helix.fhir.client.sdkFluent API to call the FHIR server that handles:Authentication to FHIR serverRenewing access token when they expireRetry when there are transient errorsUn-bundling the resources received from FHIR serverPagingStreamingLoggingSimulating a $graph call when the server does not support itUsagepip install helix.fhir.client.sdkDocumentationhttps://icanbwell.github.io/helix.fhir.client.sdk/Test Project using thishttps://github.com/icanbwell/fhir-server-performancePython Version Support1.x supports python 3.7+
2.x supports python 3.10+
Package: helixmc
READMEHelixMCHelixMC is a software package for Monte-Carlo (MC) simulations of DNA/RNA
helices using the base-pair level model, coded with Python. HelixMC is
distributed under the GPLv3 licence.The project is authored by Fang-Chieh Chou in 2013, under the supervison of
Dr. Rhiju Das, at the Biochemistry Department of Stanford Unviersity.LinksSource code:https://github.com/fcchou/HelixMCHTML documentation:http://helixmc.readthedocs.org/Das Lab @ Stanford:http://daslab.stanford.eduDependenciesThe required dependencies to build the software are Python >= 2.7,
Numpy >= 1.6, Matplotlib >= 1.1.0, and a working C/C++ compiler.InstallThe easiest way to install is to use pip install:$ pip install helixmcAlternatively, one can download the source code from the latest GitHub
repository. And install usingsetup.py:$ python setup.py build
$ sudo python setup.py installInstead of installing using setup.py, you can just add your HelixMC folder
into the system’s$PATHand$PYTHONPATH. In bash this can be done by
adding the following lines to your~/.bashrc:export PATH=$PATH:<HelixMC Path>
export PYTHONPATH=$PYTHONPATH:<HelixMC Path>Then build the Cython extension. Under thehelixmc/folder, run:$ python _cython_build.py build_ext --inplaceNote that this requires you to have Cython installed. Otherwise you can choose
to build the c source file, then you do not need Cython:$ python _c_build.py build_ext --inplace
Package: helix-mockserver-client
mockserver_clientIt has docker based image:jamesdbloom/mockserver:mockserver-5.13.*As pip dependency could be found here:https://pypi.org/project/helix-mockserver-client/In yourrequirements.txtorPipFileaddhelix-mockserver-client>=*.*.*Basic usage:importjsonfrommockserver_client.mockserver_clientimport(MockServerFriendlyClient,mock_request,mock_response,times,)mock_server=MockServerFriendlyClient('http://127.0.0.1:1080')mock_server.expect(mock_request(path="/"+'item',method="POST",body={"json":{"client_id":"unitypoint_bwell","client_secret":"fake_client_secret","grant_type":"client_credentials",}},),mock_response(body=json.dumps({"token_type":"bearer","access_token":"fake access_token","expires_in":54000,})),timing=times(1),)How to pull the image with Docker:docker pull jamesdbloom/mockserver:mockserver-5.13.2How to start the server locally with Docker:docker run -dp 1080:1080 jamesdbloom/mockserver:mockserver-5.13.2 -logLevel DEBUG -serverPort 1080
Package: helix-p4p-cache
Helix Perforce Proxy - Cachehelix-p4pis a proxy cache for Perforce servers.FlushAs revisions are added to files within the proxy, there is no internal cache expiry performed.
Thus, a proxy server can retain excessive amounts of cached file revisions.p4p-flush allows sysadmins to periodically expire content.usage: p4p-flush [-h] [--ttl TTL] [--min-vers MIN_VERS] [--purge] path

Flush helix-p4p cache

positional arguments:
  path

options:
  -h, --help           show this help message and exit
  --ttl TTL            Expiry time (hours)
  --min-vers MIN_VERS  Number of revisions to keep
  --purge              Remove expired items from diskSystemdhelix-p4p-syncOneshot for syncing a proxy# 'example' is a given configuration name

systemctl enable helix-p4p-sync@example
systemctl start helix-p4p-sync@examplehelix-p4pService for running a Helix P4P server.# 'example' is a given configuration name

# Create a user to run the proxy and set the proxy root directory
useradd -m -d /opt/perforce/example -s /bin/sh example
su example -c "mkdir -p /opt/perforce/example/{root,cache}"

systemctl enable helix-p4p@example
systemctl start helix-p4p@exampleTODOHumanize file size outputs, such that automatic care is taken betwen bytes/MB/GB.Read in argparse config variables from the environment.Expand on test cases, expressing more edge cases.Add Systemd scripts for configuration & running.
Package: helix.personmatching
helix.personmatchingEntrypointhelix_personmatching/matchers/matcher.pyInputsThis code takes in:A source Patient/Person resource or a Bundle of Patient/Person resourcesA target Patient/Person resource or a Bundle of Patient/Person resourcesA set of rule options/weightsWhether to return only successful matches or all match results(Optional) Matching threshold (between 0 and 1).  Can also be set as an environment variable:PERSON_MATCH_THRESHOLD(Optional) Average score boost (between 0 and 1).  Can also be set as an environment variable:PERSON_MATCH_AVERAGE_SCORE_BOOSTOutputsA list of match results where id_source is id of source record and id_target is id of matched record.LogicThe code runs through each rule and calculates a uniqueness probability (between 0 and 1) if the rule matches.The code then picks the rule with the highest uniqueness probability and uses that probabilityThe code then calculates the average of all the other rule probabilities and boosts the uniqueness probability by it.The code then sees if any other boosting rules were requested and boosts the probability by thoseWeightsThere are five cases when matching fields of two records in a rule and the weights that are applied for each case:Field present in both sides and match ->exact_matchField present in both sides and partial match ->partial_matchField missing in both sides ->missingField missing in one side ->missingField present in both sides but do not match -> 0.0For boosting rules, there is an additionalboostweight.
Package: helixswarm
Package supports sync and async syntax with same code base.fromhelixswarmimportSwarmAsyncClient,SwarmClientDocumentationRead the DocsOfficial REST API PDFInstallationThere are two identical packages:helix-swarmand aliashelixswarm, alias
was created one year later due name confusion, to be import name and package name will the same.pip3 install helixswarmExamplesGet review info:fromhelixswarmimportSwarmClientclient=SwarmClient('http://server/api/v9','user','password')review=client.reviews.get_info(12345)print(review['review']['author'])Add comment to review in async way (be carefulSwarmAsyncClientmust be called inside async function):importasynciofromhelixswarmimportSwarmAsyncClientasyncdefexample():client=SwarmAsyncClient('http://server/api/v5','user','password')awaitclient.comments.add('reviews/12345','my awesome comment')asyncio.run(example())Update credentials handler:importrequestsfromhelixswarmimportSwarmClientdefget_credentials():response=requests.get(...).json()returnresponse['user'],response['password']client=SwarmClient('http://server/api/v9','user','password',auth_update_callback=get_credentials)# let's suppose credentials are valid nowreview=client.reviews.get_info(12345)print(review['review']['author'])# now, after some time, password of user somehow changed, so our callback# will be called, new credentials will be using for retry and future# here we get also correct review data instead of SwarmUnauthorizedError# exceptionreview=client.reviews.get_info(12345)print(review['review']['author'])TestingPrerequisites:toxThen just run tox, all dependencies and checks will run automaticallytoxContributingFeel free to any contributions.Mirror repositories of review board source code:2022.12016.1Latest version of code can be download from official page:https://www.perforce.com/downloads/helix-swarmOfficial REST API documentationAPIDateNotesv10October 2019Integration with CI toolsv9April 2018Review append and replace changelist, 2fa, mark comment as readv8December 2017Default reviewersv7October 2017Groups as review participants, groups as moderators of projectv6May 2017Activity dashboard, archiving reviews, cleaning reviews, for voting reviewsv5October 2016Limiting comments to a specific review versionv4October 2016Private projects, file-level and line-level inline commentsv3September 2016Comments managementv2May 2016Projects, groupsv1.2October 2015Author filter to the list reviews endpointv1.1January 201Required reviewersv1July 2014Initial