Saravanan666/pypi-org huggingface dataset:
Package: hydratk-lib-network
Network library provides clients/API for many network protocols and technologies.Database: clients for databases: SQLite, Oracle, MySQL, PostgreSQL, JDBC, MSSQLclients for NoSQL databases: Redis, MongoDB, CassandraEmail: clients for protocols: SMTP, POP, IMAPFTP: clients for protocols: FTP/FTP, SFTP, TFTPINET: clients for protocols: IP, TCP, UDPJava: bridge to Java VM which enables interaction with Java codeJMS: clients for protocols: JMS, STOMP, AMQP, MQTTLDAP: client for LDAP protocolREST: client for HTTP/HTTPS protocolRPC: clients for Java RMI, XML-RPC, JSON-RPCSelenium: bridge to Selenium API for web GUI interactionSOAP: client for SOAP protocolTerm: clients for protocols: SSH, Telnet
Package: hydratokengen
HydraTokenGenORY Hydra JWT generator.InstallpipinstallhydratokengenUsagefromhydratokengenimportCachedTokenGen,HydraTokenGenhydra_token_gen=CachedTokenGen(HydraTokenGen(hydra_public_url="http://localhost:4444",hydra_admin_url="http://localhost:4445",client_id="636986d6-f505-486a-839c-57bb6a881aca",client_secret="CLIENTSECRET",redirect_uri="http://localhost/callback",))token=hydra_token_gen.generate(subject="1234",access_token={"claim1":"value1"},id_token={"claim2":"value2"},)DevelopmentFormat codepoetryrunblackhydratokengentestsTestingStart Hydra:docker-composeup-dInstall dependencies:poetryinstallRun testspoetryrunpytestHTML coverage report:poetryrunpytest--cov=hydratokengen--cov-report=html

openhtmlcov/index.htmlPublish a new versionBump the version number inhydratokengen/__init__.pyand run:poetrypublish
Package: hydrator
HydratorHydrate your development environment from a YAML configuration file.SynopsisUsage: hydrator [OPTIONS] COMMAND [ARGS]...

  Hydrate your development environment.

  Without arguments, all hydrators will be run.

Options:
  -c, --config path  The config file to load. Defaults to "hydrator.yml"
  -v, --verbose
  --dry              Do not commit changes to disk.
  --select TEXT      Select a subset of hydrators to run (comma separated).
  --help             Show this message and exit.

Commands:
  auth-status  Check the filesystem authentication status.
  login        Authenticate for a filesystem.
  logout       Revoke existing credentials for a filesystem.FeaturesYAML-configuration for Bash profile and Git config.Do not repeat yourself: Layer multiple YAML configurations for multiple environments.Execute shell commands with access to external file systems (e.g. Nextcloud).RoadmapApplication directory finders (e.g. to discover VScode application directory)ExampleIn a Git repository, create a file calledhydrator.yml. In that file you can configure files
that will be produced from the YAML configuration or from external sources. External sources are
"file systems" that can be configured in the same file.filesystems:nextcloud:{type:nextcloud,server-url:https://my-cloud.example.org}hydrators:gpg:type:commandscommands:-gpg --import [[nextcloud://dotfiles/gpgp/master.key]]ssh:type:commandscommands:-cp nextcloud://dotfiles/ssh/ida_rsa{,.pub} ~./ssh-chmod 600 ~/.ssh/id_rsa{,.pub}bash_profile:type:bash_profilealiases:ll:ls -lpath:-~/.local/binIn order to access files your Nextcloud, Hydrator first needs to authenticate.$ hydrator login nextcloudThen you simply run Hydrator to execute all steps. You can select a subset of hydrators
using the--select h1,h2,...option. Add--dryto not commit changes to disk, and-v,--verboseor more logs.$ hydratorLayeringYou can have multiple YAML configuration files, where one extends the other by adding or
overwriting keys. This is useful to customize a basic configuration for another environment.extends:./base.ymlhydrators:gpg:'{{exclude}}'gitconfig:Personal.user:'{{user}}'user:email:work@email.comsigningkey:DEADBEEFCopyright 2020 © Niklas Rosenstein
Package: hydraulic
# HydraulicA python package to compute pressure, flows and temperatures in hydraulic circuits
![alt](https://raw.githubusercontent.com/Dessia-tech/hydraulic/master/doc/source/images/circuit4.png)## Installingpip(3) install hydraulic## Documentationhttps://hydraulic.readthedocs.io/en/latest/## Contributors[DessiA team](https://github.com/orgs/Dessia-tech/people)[Clément Roch](https://www.linkedin.com/in/clément-roch-121320140)
Package: hydrazaphelper
Basic Usage*** Settings ***
Documentation     A resource file with reusable keywords and variables.
...
...               The system specific keywords created here form our own
...               domain specific language. They utilize keywords provided
...               by the imported SeleniumLibrary.
Library           SeleniumLibrary
Library           Collections
Library           OperatingSystem
Library           ZapRobotHelper

*** Variables ***
${URL}            https://www.imdb.com/
${browser}        Chrome
${DELAY}          3
${proxy}          selenium-router:9090

*** Keywords ***
Open Browser To IMDB
    ${proxy dict}=   Create Dictionary   proxyType   MANUAL   httpProxy   ${proxy}  ftpProxy    ${proxy}    sslProxy  ${proxy}
    ${default caps}=    Evaluate    sys.modules["selenium.webdriver"].DesiredCapabilities.FIREFOX    sys,selenium.webdriver
    Set To Dictionary    ${default caps}    proxy    ${proxy dict}
    Open Browser    ${URL}    FIREFOX    remote_url=http://selenium-router:4444
    Maximize Browser Window
    Set Selenium Speed    ${DELAY}
    zap test

Search Movie
    [Arguments]    ${movie}
    Input Text    id=suggestion-search    ${movie}
    Click Button  id=suggestion-search-button
    Page Should Contain  Results for "${movie}"File will be downloaded on'C://projects//HYDRA//reports//zap.html'For building wrapper write this commandThis will build all the necessary packages that Python will require.Also it will create a source distributionpython -m buildpython -m twine upload --repository pypi dist/*
Package: hydrazine
hydrazineTable of Contenthydrazine1. Why2. What3. Usage1. WhyThrough mostly client work I found it useful to have something to quickly interact with relational databases or any databases.
I preferred to use PostgreSQL which was nice pre war. Now, I am not so sure what to use best, but the package will grow accordingly.2. WhatSmall package with a collection of functions frequently used to interact with databases (making the interaction easier).3. UsagePlease refer to thetests/directory for examples of the functions and their usage
Package: hydride
Hydride - Adding hydrogen atoms to molecular modelsMany tasks in structural biology ranging from simulations and hydrogen
bond detection to mere visual analysis, require complete molecular
models.
However, most experimentally determined structures do not include
the position of hydrogen atoms, due to their small size and electron
density.Hydrideis an easy-to-use program and library written in Python that
adds missing hydrogen atoms to molecular models based on known bond
lengths and angles.
Since it does not require force-field parameters for the specific
molecule(s), it can be used for adding hydrogen atoms to almost any
organic molecule - from small ligands to large protein complexes.InstallationIn order to useHydrideyou need to have Python (at least 3.7) installed.You can installHydridevia$pipinstallhydrideUsageIn its basic invocationHydridereads an input structure file, adds hydrogen
atoms to the molecular model and writes the resulting model into an output
structure file.$hydride-iinput_structure.pdb-ooutput_structure.pdbPython APIHydridealso provides a Python API to add hydrogen atoms toAtomArrayobjects fromBiotite.atom_array,_=hydride.add_hydrogen(atom_array)atom_array.coord=hydride.relax_hydrogen(atom_array)
Package: hydrilla.builder
Hydrilla builderThis is the repository of the builder part ofHydrilla. You can find the repository of its server parthere.Hydrilla builder is a tool to create Haketilo packages in serveable form. The information below is meant to help hack on the codebase. If you're instead looking for some noob-friendly documentation, see theuser manual.DependenciesRuntimePython3 (>= 3.7)clickjsonschema (>= 3.0)reuse [optional]Buildsetuptoolswheelsetuptools_scmbabelTestpytestreuseBuilding & testingBuild and test processed are analogous to those described in theREADME of Hydrilla server part.RunningThis package provides a hydrilla-builder command. You can use it to build the supplied example with something along the lines of:mkdir /tmp/bananowarzez/
hydrilla-builder -s src/test/source-package-example/ -d /tmp/bananowarzez/
# Now, list the serveable package files we just produced.
find /tmp/bananowarzez/You might as well like to run from sources, without installation:
mkdir /tmp/bananowarzez/
./setup.py compile_catalog # generate the necessary .po files
PYTHONPATH=src python3 -m hydrilla.builder -s src/test/source-package-example/-d /tmp/bananowarzez/You can also consult the included manpage (`man` tool required):
``` shell
man ./doc/man/man1/hydrilla-builder.1CopyingHydrilla is Copyright (C) 2021-2022 Wojtek Kosior and contributors, entirely available under the GNU Affero General Public License version 3 or later. Some files might also give you broader permissions, see comments inside them.I, Wojtek Kosior, thereby promise not to sue for violation of this project's license. Although I request that you do not make use this code in a proprietary program, I am not going to enforce this in court.ContributingPlease visit our Redmine instance athttps://hydrillabugs.koszko.org.You can also write an email tokoszko@koszko.org.
Package: hydroanalysis
HydroAnalysisHydroAnalysis is a Python package to calculate indices and metrics useful in the everyday job of an hydrologist.The package is the result of the re-organization of code that I have used during my research and that I have decided to publish because of its supposed usefulness.Generic interfacePlease refer to the docstrings of the single functions for documentation.Generally all the functions have the same interfacedefcalculate_index_name(flux1,quality,flux2,fluxN,other_time_series):# codewhere:flux1,flux2,fluxNare fluxes needed to calculate the index/metricqualityis a vector that is used to signal time steps where the quality of the data is not good and, therefore, are not used to calculate the index/metric.other_time_series: are other time series needed to calculate the index/metric. Example could be the season.Files in the packagemeteo_indices.py: contains the functions to calculate the indices related to meteorological datametrics.py: contains the functions to calculate the metrics related to the hydrological datastreamflow_signatures.py: contains the functions to calculate the signatures related to the hydrological datautils.py: contains the functions used by the other filesDocumentationThe documentation is work in progress. It is not complete yet but can be found inReadTheDocs.ExamplesExamples of the usage of the package are not available yet. However, the code should be self-explanatory..just read carefully the docstrings.TestingThere is no systematic testing implemented here. However, the code has been manually tested against other available code (e.g., R code from Addor et al. (2017)) when possible.Your contributionPlease feel free to contribute to the package. If you have any suggestion or you want to contribute to the documentation, please contact the author and have a look at the documentation page explaining how to do it.
Package: hydro-analysis-toolkit
HAT - Hydrological Analysis ToolkitHAT is a suite of tools to perform data analysis on hydrological datasets.The documentation can be found athttps://hydro-analysis-toolkit.readthedocs.ioDISCLAIMERThis project isBETAand will beExperimentalfor the foreseeable future.
Interfaces and functionality are likely to change, and the project itself may be scrapped.DO NOTuse this software in any project/software that is operational.InstallationClone source code repository$ git clone https://github.com/ecmwf/hat.gitCreate conda python environment$ cd hat
$ conda env create -f environment.yml
$ pip install .UsageStart a hat environment$ conda activate hatRun a command line tool$ hat-extract-timeseries --helpContributingThe main repository is hosted onGitHub, testing, bug reports and contributions are highly welcomed and appreciated.Please reportbugreports orpull-requestsonGitHubWe want your feedback, please e-mail:user-services@ecmwf.intLicenseCopyright 2023 European Centre for Medium-Range Weather Forecasts (ECMWF)Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.In applying this licence, ECMWF does not waive the privileges and immunities
granted to it by virtue of its status as an intergovernmental organisation nor
does it submit to any jurisdiction.CitingIn publications, please use a link to this repository (https://github.com/ecmwf/hat) and its documentation (https://hydro-analysis-toolkit.readthedocs.io)
Package: hydrobot
Python Package providing a suite of processing tools and utilities for Hilltop hydrological data.Free software: GNU General Public License v3Documentation:https://hydrobot.readthedocs.io.FeaturesProcesses data downloaded from Hilltop ServerUses annalist to record all changes to dataCapable of various automated processing techniques, including:Clipping dataRemoving spikes based on FBEWMA smoothingIdentifying and removing ‘flatlining’ data, where an instrument repeats it’s last collected data pointIdentifying gaps and gap lengths and closing small gapsQuality coding data based on NEMS standardsPlotting data, including:Processed data with quality codesComparing raw data to processed dataPlotting data near checksPlotting data near gapsCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: hydrobox
# HydroBox#The HydroBox is mainly a toolbox used in the [V-FOR-WaTer](https://vforwater.de) Project. It will be expanded to
serve general hydrological data exploration with a future release.The HydroBox package is a toolbox for hydrological data analysis developed at the
[Chair of Hydrology](https://hyd.iwg.kit.edu/english/index.php) at the
[Karlsruhe Institute of Technology (KIT)](https://kit.edu/english/index.php).
HydroBox has several submodules called toolboxes, which are a collection of functions and classes for specific purposes.
As of this writing these toolboxes are:geostatfor geostatistics. Mainly implemented throughscikit-gstatandgstoolsIn development are:uncertainty_framworkfor uncertainty analysisbritgetfor evapotranspiration tools
Package: hydrobricks
hydrobricksA modular hydrological modelling framework.InstallWheels are available to install from PyPI (https://pypi.org/project/hydrobricks/)Install:pip install hydrobricksResourcesDocumentation:https://hydrobricks.readthedocs.io/en/latest/How to build:https://github.com/hydrobricks/hydrobricks/wikiCode documentation of the core:https://hydrobricks.github.io/hydrobricks-doc-core/
Package: hydrocarbon
IntroductionThis tool converts technical indicators (IOCs) and search queries into the
JSON format required for a Carbon Black alliance feed.  This can be imported
into your Carbon Black server manually or by adding a Threat Intelligence
feed, which will regularly update.It was written by David Cannings (@edeca) and
released by NCC Group under the AGPL.The latest code can be found in theGithub repository.Why would I use it?This tool is useful if:You want to synchronise watch lists across multiple Carbon Black servers.You want to share indicators (and you don't have a central threat intel platform).Quick startTo get started you will need:A configuration file (seeexamples/config.yaml)At least one data file (seeexamples/data/)First install the tool in a virtual environment:# Create a new virtual environment
$ python3 -m venv hydrocarbon_venv

# Activate the virtual environment
$ . hydrocarbon_venv/bin/activate  # On Windows run hydrocarbon_venv\Scripts\activate.ps1

# Instal the module
$ pip install hydrocarbonNow generate a JSON file with feed data:# Generate JSON from the example data 
$ hydrocarbon --config examples\config.yaml --data examples\data --output feed.jsonYou can optionally provide two logos (100x100 and 370x97) to be included in
the feed data.  These wll be displayed in the web UI, for example:# Generate JSON from the example data 
$ hydrocarbon --config examples\config.yaml --data examples\data --output feed.json \
              --icon-large examples\large.jpg --icon-small examples\small.jpgINSERT IMAGEThe tool can be used from within your own Python scripts, see the FAQ.FAQWhy integrate with git?The Carbon Black server needs a timestamp for every report.  Using git gives
an accurate timestamp (from the latest commit) which does not change.  This
ensures that 'incremental' update mode is efficient, only changed reports will
be parsed.It is possible to use without git.  However, this is not recommended for
anything other than testing.How can I delete indicators?The Carbon Black Response server prefers to do an 'incremental' sync against
feeds.  This means that deleted items will not be removed.To delete an item changeenabledtoFalseand regenerate the feed.How can I automatically update my server?Simply copy the JSON file to a web server which can be accessed by the Carbon
Black instance.  You can optionally use basic authentication and provide the
username and password in the Carbon Black web interface.You can add a new feed to the Threat Intelligence section in Carbon Black.There seem to be no restrictions on the web server other than returning valid
JSON.How can I integrate this with my workflow?The tool is a Python module which can be imported and used from your own code.fromhydrocarbonimportFeedGeneratorbuilder=FeedGenerator("/path/to/config.yaml")builder.add_data_dir("/path/to/data/")withopen("output.json","w")asfh:builder.generate_feed(fh)Seehydrocarbon/app.pyfor an example implementation.
Package: hydrocomp
# hydrocomp: Package Python for hydrological data analysis## What is it?## Main Features## Where to get it
The source code is currently hosted on GitHub at:https://github.com/clebsonpy/HydroCompBinary installers for the latest released version are available at the [Python
package index](https://pypi.org/project/hydrocomp/) and on conda.`sh pip install hydrocomp `## Dependencies
- [NumPy](https://www.numpy.org)
- [Pandas](https://pandas.pydata.org/)See the [full installation instructions](https://pypi.org/project/hydrocomp/) for minimum supported versions of required, recommended and optional dependencies.[MIT](LICENSE)## Documentation
The official documentation is hosted on :
Package: hydrocrypto
HydroCryptoCryptography Extension for HydrogramHydroCryptois a Cryptography Library written inRustas a Python extension using pyo3.It is designed to be portable, fast, easy to install and use.HydroCryptois intended forHydrogram.HydroCryptocan be also used forpyrogramHydroCryptouses theAES-IGEandAES-CTRfor theTelegram MTProto and CDNNOTE : HydroCrypto is not the official cryptography extension of Hydrogram. So it on your own risks.RequirementsPython 3.8 or higherInstallation$ pip install hydrocryptoUsageHydroCryptoconsists of functions likeige256_encrypt(data:bytes,key:bytes,iv:bytes)->bytes:ige256_decrypt(data:bytes,key:bytes,iv:bytes)->bytes:ctr256_encrypt(data:bytes,key:bytes,iv:bytes,state:bytes)->bytes:ctr256_decrypt(data:bytes,key:bytes,iv:bytes,state:bytes)->bytes:LicenseLGPLV3+©Anand-2024
Package: hydrodashboards
hydrodashboardsOpen Source Dashboards for Hydro-DataDocumentation:https://d2hydro.github.io/hydrodashboardsSource Code:https://github.com/d2hydro/hydrodashboardsInstallationWe recommend to build your bokeh environment usingAnaconda. You can build an environment ánd install hydrodashboards by conda in one go using thisenvironment.ymlfrom the command-line:conda env create -f environment.ymlAs alternative; hydrodashboards works in any environment with the following packages properly installed:aiohttpbokehfewspygeopandasnest-asynciopandasrequestsAboutHydrodashboards is developed and maintained byD2Hydroand freely available under an Open SourceMIT license.
Package: hydroengine
Hydro Engineis a small service and a command-line tool built on top of [Google Earth Engine](http://earthengine.google.com) that allows querying various hydrological variables, useful as an input for hydrological models.[![Build Status](https://travis-ci.org/openearth/hydro-engine.svg?branch=master)](https://travis-ci.org/openearth/hydro-engine)The command-line Python tool can be installed using the following commands:` > pip install hydroengine `Once the package is installed, you can use`hydroengine`command to download input data needed for your hydrological model.Upstream catchments, rivers and various raster variables can be queried using following commands:` > hydroengine region.json--get-catchmentscatchments.json > hydroengine region.json--get-riversrivers.json > hydroengine region.json--get-rasterdem dem.tif 1000 EPSG:4326 > hydroengine region.json--get-lakeslakes.json > hydroengine region.json--get-lake-variable183160 water_area area.json `See [examples/run.sh](https://github.com/Deltares/hydro-engine/blob/master/examples/run.sh), showing how different data types can be downloaded.All data types can be queried for an input area or location (GeoJSON polygon geometry). A polygon may define a flood location. For example, in the figure below, a single point near Houston is used to query upstream catchments and a drainage network, providing runoff water for that location.<img src=”https://github.com/Deltares/hydro-engine/blob/master/docs/example_query.png?raw=true” alt=”Example” width=”626” height=”485”>Supported functionality:Querying upstream catchments as a single or multiple polygons. Source: [HydroBASINS](http://www.hydrosheds.org/page/hydrobasins)Querying upstream drainage network as polylines. Source: [HydroSHEDS](http://hydrosheds.org)Querying raster variables:dem [m] - in meters, source: 30m SRTM v4hand [m] - Height Above the Nearest Drainage ([HAND](http://global-hand.appspot.com))FirstZoneCapacity [-] - ?FirstZoneKsatVer [-] - ?FirstZoneMinCapacity [-] - ?InfiltCapSoil [-] - ?M [-] - ?PathFrac [-] - ?WaterFrac [-] - ?thetaS [-] - ?soil_type [-] - soil type, based on ?landuse [-] - land use type, based on MODIS 500mLAI01…LAI12 - leaf area index monthly climatology, source: [eartH2Observe](http://www.earth2observe.eu/)History0.1.0 (2018-08-27)First release on PyPI.
Package: hydro-erosion
HydroErosionPython model of rain eroding a landscape. HydroErosion model places random 'drops' on terrain and moves the terrain based on their movementFile DescriptionsgenerateLandscape.pyCreates two matrices to describe height and bedrock, using perlin noiseviewLandscape.pyGraphs given matrix in 3DerodeLandscape.pyPerforms Naive algorithm to erode given landscape, accounting for bedrockResults (so far):Performed erosion on 300x200 terrain with 600,000 iterations (current maps)Before:After: