Saravanan666/pypi-org huggingface dataset:
Package: watch-xfce-xfconf
watch-xfce-xfconf - Automate XFCE Configuration!IntroductionThe command-line toolwatch-xfce-xfconf, written byJames Cherti, allows displaying and watching the
xfconf-query commands of all the XFCE 4 Xfconf settings that are being changed by XFCE
programs like xfce4-settings-manager, thunar, catfish, ristretto, among others.Thewatch-xfce-xfconfcommand-line tool is especially useful for users who want to
replicate XFCE 4 settings on several computers.What is xfconf-query?The xfconf-query command-line tool allows retrieving, modifying, and creating XFCE 4
Xfconf settings, such as the desktop background, panel preferences, window decorations,
window manager settings, and more.How can xfconf-query commands help automate the configuration of XFCE 4?By displaying the xfconf-query commands,watch-xfce-xfconfallows to easily create a
Shell script that can be used to automate the configuration of XFCE 4, which provides
several benefits:It saves time and effort by eliminating the need to manually adjust settings on each
individual machine,It reduces the risk of errors and inconsistencies that may arise from manually
configuring settings on different machines,Finally, it allows focusing on other important tasks rather than spending time
configuring XFCE 4 manually.InstallationThe watch-xfce-xfconf command-line tool can be installed locally,
in~/.local/bin/watch-xfce-xfconf, using pip:pip install --user watch-xfce-xfconfUsageRun xfce4-settings-manager in the background:xfce4-settings-manager &After that, execute watch-xfce-xfconf:~/.local/bin/watch-xfce-xfconfOnce you begin modifying XFCE 4 settings using xfce4-settings-manager,watch-xfce-xfconfwill automatically display the corresponding xfconf-query commands in the terminal. These
xfconf-query commands can be easily copied and pasted into a Shell script, allowing for
quick and efficient automation of XFCE 4 configuration across multiple machines.FeaturesParses XML files that are located in the directory:~/.config/xfce4/xfconf/xfce-perchannel-xml/,Monitors changes in XFCE 4 settings / Xfconf,Displays xfconf-query commands,Supports the following Xfconf types: uint, int, string, bool, array, double.Linkswatch-xfce-xfconf @PyPIwatch-xfce-xfconf @GitHubGeneral information about Xfconf
Package: wat-cli
wat is this?It's a simple command line tool to get short answers from Wolfram Alpha.> wat is the circumference of the moon`
about 10921 kilometerswat do i need to do to run this?You need to get an AppId from Wolfram Alpha. Please visit theAPI Documentationwebsite
for further information.The AppID can be supplied via the--appidCLI option or via the configuration
file (appid="XXXXXX-YYYYYYYYYY").Runwat --helpto find the location of the configuration file.wat even is a kilometer? I want miles!Use CLI option--units=imperialor addunits=imperialto the configuration
file.wat does wat stand for?Obviously it stands for Wolfram Alpha uhh... Thing.
Package: watdarepo
Determines type and host of a repo.Free software: BSD licenseDocumentation:http://watdarepo.rtfd.org.FeaturesWorks to some degree with the following VCS:GitMercurialSVNBZRWorks to some degree with the following hosting services:GitHubBitBucketGitLabGitoriousSourceforgeUsage>>> from watdarepo import watdarepo
>>> watdarepo("https://github.com/pydanny/watdarepo")
{
    u'vcs': u'git',
    u'hosting_service': u'github',
    u'repo_url': u'https://github.com/pydanny/watdarepo'
}Related ProjectsDulwichis a Python Git API and does not have any discovery features.VCSworks with both Git and Mercurial, incorporates Dulwich, but does not appear to have any discovery features.History0.3.0 (2013-09-17)Allows for overrides of default repo_aliases and hosting services.0.2.0 (2013-09-08)Improved test coverage to 100%.Added coveralls.Better analysis of repos.0.1.0 (2013-09-08)First release on PyPI.
Package: waterbalans
Waternet Waterbalansen Model in PythonDeze repository bevat het Waternet Waterbalansen model, zoals uitgewerkt door
Maarten Ouboter in de Excel Waterbalans module.Auteurs:R.A. Collenteur, Artesia Water 2018D.A. Brakenhoff, Artesia Water 2018InstallatieDownload de data van deze repository.Open een windows command window (CMD) en cd naar de map waterbalans (waar ook het bestand setup.py staat).type het volgende en druk op enter:>>> pip install .de python-module “waterbalans” wordt nu automatisch geinstalleerd.Installatie vereistenPython 3.7 installatie (bij voorkeur Anacondahttps://www.anaconda.com/download/)Project GroepMaarten Wensing (Projectleider)Jan Willem Voort (Gebruiker)Laura Moria (Gebruiker)Maarten Ouboter (Maker Excel-balans)Davíd Brakenhoff (Python Programmeur)Ben Staring (FEWS)Stefan Fritz (GIS)Niet langer betrokken maar veel belangrijk werk verricht in de eerste fase:Pytrik Graafstra (Conceptueel overzicht)Raoul Collenteur (Python Programmeur)
Package: waterboy
Store “live” application settings in a choice of key/value data stores.This was originally a fork ofdjango-constance, but is now independent of
Django and is essentially the key/value abstraction part of the original library.Backends currently supported: Redis and MongoDB.Tested with Python 2.7 and Python 3.4.The source is ongithub.Installation$ pip install waterboyUsageIn your application, define the settings that you want to be editable:CONFIG = {
    '<KEY>': <DEFAULT>,
    ...
}For example:CONFIG = {
    'INT_VALUE': 1,
    'LONG_VALUE': 100000000,
    'BOOL_VALUE': True,
    'STRING_VALUE': 'Hello world',
    'UNICODE_VALUE': six.u('Rivière-Bonjour'),
    'DECIMAL_VALUE': Decimal('0.1'),
    'DATETIME_VALUE': datetime(2010, 8, 23, 11, 29, 24),
    'FLOAT_VALUE': 3.1415926536,
    'DATE_VALUE': date(2010, 12, 24),
    'TIME_VALUE': time(23, 59, 59),
}Then create a Config object based on these initial settings. For example, using Redis:>>> from waterboy import RedisConfig
>>> cfg = RedisConfig(initial=CONFIG)You then retrieve settings from the backend via attribute-style access:>>> cfg.INT_VALUE
1If the backend returns None then the default value is returned.Similarly, setting an attribute on the Config object will transparently “upsert”
(update or insert) that value in the backend.Attempts to get or set values on the Config object will fail with an AttributeError
if the key does not exist in the initial defaults dictionary:>>> cfg.ABCD = 'abcd'
Traceback (most recent call last):
  ...
AttributeError: 'RedisConfig' object has no attribute 'ABCD'But this behaviour may be modified by passingstrict=Falseto the Config constructor:>>> cfg = RedisConfig(initial=CONFIG, strict=False)which will cause the existence check to be bypassed:>>> cfg.ABCD = 'abcd'DevelopmentClone and run tests:$ git clone git@github.com:gmflanagan/waterboy.git
$ cd waterboy
$ make testTests are run via tox and pytest.If redis and mongo are not running on the declared ports then the tests associated
with those backends will be skipped. See the makefile for the default ports.To install redis and mongo locally, run buildout:$ make buildoutThen run redis in the foreground with:$ make redisand mongodb with:$ make mongodNow run all tests:$ make test
Package: waterch-tasker
TaskerA scalable and extendable experiment task scheduler framework.DocumentationInstallYou can install waterch-tasker usingpip.pipinstallwaterch-taskerAnd if you want a more simple and robust version of waterch-tasker, please install v0.2.10.pipinstallwaterch-tasker==0.2.10UsageWhen waterch-tasker is installed, please use--helpcommand.waterch-tasker--helportasker--help
Package: water_cli
WaterWater is a Python library that allows you to generate command-line interfaces (CLIs) for your Python project. Water is similar to theGoogle Firelibrary, with some key differences:Water is type-safe. This means that Water uses type annotations to ensure that the input values are of the correct type.Water is designed with easy integration testing in mind. This means that you can easily test your Water CLI by invoking it from your test code, making it simple to write thorough and comprehensive tests for your CLI.InstallationTo install Water, usepip:pip install water-cliGetting startedHere's a simple example of how to use Water:importwater_clidefgreet(name:str):print(f"Hello,{name}!")if__name__=='__main__':water_cli.simple_cli(greet)In this example, we define a function called greet that takes a single argument, name, with type str.When we run the script withpython script.py greet --name Alice, Water will call the greet function withname='Alice'.Advanced usagePlease followthe docs.ContributingIf you find a bug or have a feature request, please open an issue on the GitHub repository. Pull requests are also welcome!LicenseWater is licensed under the MIT License.TestingPython3.9, 3.11:docker build -f dockerfiles/3.9-Dockerfile .
docker build -f dockerfiles/3.11-Dockerfile .Developmentpoetry run pytestReleasingpoetry publish --build --username $PYPI_USERNAME --password $PYPI_PASSWORD
Package: waterdynamics
waterdynamicsLatest releaseStatusCommunityAnalysis of water dynamics in molecular dynamics trajectories and water interactions with other molecules.
Documentation for waterdynamics can be found athttps://mdanalysis.org/waterdynamics.waterdynamics is bound by aCode of Conduct.InstallationTo build waterdynamics from source,
we highly recommend using virtual environments.
If possible, we strongly recommend that you useAnacondaas your package manager.
Below we provide instructions both forcondaand
forpip.With condaEnsure that you havecondainstalled.Create a virtual environment and activate it:conda create --name waterdynamics
conda activate waterdynamicsInstall the development and documentation dependencies:conda env update --name waterdynamics --file devtools/conda-envs/test_env.yaml
conda env update --name waterdynamics --file docs/requirements.yamlBuild this package from source:pip install -e .If you want to update your dependencies (which can be risky!), run:conda update --allAnd when you are finished, you can exit the virtual environment with:conda deactivateWith pipInstall from PyPIThe latest release of waterdynamics is available onPyPIand can be installed with:pip install waterdynamicsInstall from sourceTo build the package from source, run:pip install .If you want to create a development environment, install
the dependencies required for tests and docs with:pip install ".[test,doc]"CopyrightThe waterdynamics source code is hosted athttps://github.com/MDAnalysis/waterdynamicsand is available under the GNU General Public License, version 2 (see the fileLICENSE).Copyright (c) 2023, MDAnalysisAcknowledgementsProject based on theMDAnalysis Cookiecutterversion 0.1.
Please citeMDAnalysiswhen using waterdynamics in published work.
Package: waterf
A convenience module on top of the deferred library that comes with the Google AppEngine (GAE).In a nutshell:from waterf import queue, task

queue.inorder(
    task(check_condition),
    queue.parallel(
        task(remove, id=101),
        task(remove, id=102),
        task(remove, id=103)
    ),
    task(email, to='foo@bar.com')
).enqueue()Should be pretty self-explanatory: it first runs the functioncheck_condition, then it runs the functionremovethree times in parallel, after that it runsemail.To abort execution of a series you either raisequeue.PermanentTaskFailureor as a convenience returnqueue.ABORT. If you return another task, you further defer so to speak: the original task will get resolved (or aborted) as soon as the new (returned) task gets resolved (or aborted).You usetask()exactly the same as you useddeferred.defer():task(check, id=102, _countdown=20)
task(email, to='foo@bar.com', _queue='mailer')After constructing a task youenqueue()it; the relation to the deferred.defer is roughly speaking:task(foo, 'bar').enqueue()  <==> deferred.defer(foo, 'bar')
task(foo, 'bar').run()      <==> foo('bar')Enqueue’ing takes (again) the same options defer took, overruling the ones you used in the constructor, e.g.:task(foo).enqueue(queue='mailer', countdown=60)waterf adds two options:use_id  True | False | str
        Use if you don't come up with a good name to prevent double-scheduling
        The value True means autogenerate a good id, otherwise takes your str
        Defaults to True if a name is not set, otherwise to False

release_after <seconds>
        Determines when the id will be released after your task has finished
        Defaults to 0, immediatelyTasks implement a jquery-like callback interface:task(foo).then(email_user, email_admin).always(...)The callbacks must accept as their first argument the message the task sent. But this message passing will likely be dropped in a future version, because it’s unused by the library.On top of the waterf.queue there is some experimental jet set in the waterf.snake module, which implements a ndb.tasklet like api:from waterf import snake

def A():
    raise snake.Return('A')

def B(): ...

def work():
    anA = yield snake.task(A)
    yield snake.task(B), snake.task(C) ...  # parallel yield

snake.task(work).enqueue()Note that you have to enable the deferred library in your app.yamlbuiltins:
- deferred: onThank you.
Package: waterfall-ax
Waterfall Chart in PythonThe waterfall_ax library creates flexible waterfall charts based on matplotlib.It provides flexible controls over your plot. For details please refer to thewaterfall_ax repo.A Simple ExampleSample code:from waterfall_ax import WaterfallChart

# Cumulative values
step_values = [80, 70, 90, 85, 60, 50]

# Plot
waterfall = WaterfallChart(step_values)
wf_ax = waterfall.plot_waterfall(title='A Simple Example')
Package: waterfall-logging
!Waterfall-loggingWaterfall-logging is a Python package that enables you to log column counts in a Pandas DataFrames, export it as a Markdown table and plot a Waterfall statistics figure.Documentation with examples can be foundhere.Developed by Louis de Bruijn,https://louisdebruijn.com.InstallationInstall to useInstall Waterfall-logging using PyPi:pip install waterfall-loggingInstall to contributegit clone https://github.com/LouisdeBruijn/waterfall-logging
python -m pip install -e .

pre-commit install --hook-type pre-commit --hook-type pre-pushDocumentationDocumentation can be created viamkdocs serveUsageInstructions are provided in the documentation'show-to-guides.importpandasaspdfromwaterfall_logging.logimportPandasWaterfallbicycle_rides=pd.DataFrame(data=[['Shimano','race',28,'2023-02-13',1],['Gazelle','comfort',31,'2023-02-15',1],['Shimano','race',31,'2023-02-16',2],['Batavia','comfort',30,'2023-02-17',3],],columns=['brand','ride_type','wheel_size','date','bike_id'])bicycle_rides_log=PandasWaterfall(table_name='rides',columns=['brand','ride_type','wheel_size'],distinct_columns=['bike_id'])bicycle_rides_log.log(table=bicycle_rides,reason='Logging initial column values',configuration_flag='')bicycle_rides=bicycle_rides.loc[lambdarow:row['wheel_size']>30]bicycle_rides_log.log(table=bicycle_rides,reason="Remove small wheels",configuration_flag='small_wheel=False')print(bicycle_rides_log.to_markdown())|Table|brand|Δbrand|ride_type|Δride_type|wheel_size|Δwheel_size|bike_id|Δbike_id|Rows|ΔRows|Reason|Configurationsflag||:--------|--------:|----------:|------------:|--------------:|-------------:|---------------:|----------:|------------:|-------:|---------:|:------------------------------|:----------------------||rides|4|0|4|0|4|0|3|0|4|0|Logginginitialcolumnvalues|||rides|2|-2|2|-2|2|-2|2|-1|2|-2|Removesmallwheels|small_wheel=False|
Package: waterfurnace
============waterfurnace============.. image:: https://img.shields.io/pypi/v/waterfurnace.svg:target: https://pypi.python.org/pypi/waterfurnace.. image:: https://img.shields.io/travis/sdague/waterfurnace.svg:target: https://travis-ci.org/sdague/waterfurnace.. image:: https://readthedocs.org/projects/waterfurnace/badge/?version=latest:target: https://waterfurnace.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://pyup.io/repos/github/sdague/waterfurnace/shield.svg:target: https://pyup.io/repos/github/sdague/waterfurnace/:alt: UpdatesPython interface for waterfurnace geothermal systems.This provides basic sensor readings for waterfurnace geothermal systems byusing the websocket interface that exists for the symphony website. This is nota documented or stable interface, so don't use this for criticalsystems. However, it is useful to record historical usage of your waterfurnacesystem.Usage=====.. code-block:: pythonfrom waterfurnace.waterfurnace import WaterFurnacewf = WaterFurnace(user, pass)wf.login()data = wf.read()The waterfurnace symphony service websocket monitors it's usage, so you need todo a data reading at least every 30 seconds otherwise the websocket is closedon the server side for resource constraints. The symphony website does a pollon the websocket every 5 seconds.Known Issues / limitations==========================* The python websocket code goes into a blocked state after long periods ofusage (always takes days to get to this state). I've yet to discoverwhy. Help welcome.* If you have multiple waterfurnace units on one account, this will only usethe first.License=======* Free software: Apache Software License 2.0.. * Documentation: https://waterfurnace.readthedocs.io.Credits=======This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template... _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage=======History=======1.1.0 (2019-01-07)------------------* Fix retry logic1.0.0 (2018-12-05)------------------* Detect unit automatically* Add series 7 sensors0.7.0 (2018-07-13)------------------* Add workaround timer to handle socket failures0.6.0 (2018-02-21)------------------* Add timeout on socket0.5.0 (2018-02-16)------------------* Update exception handling to be more Home Assistant friendly0.4.0 (2018-02-05)------------------* More exceptions to distinguish errors we are expecting0.3.0 (2018-01-23)------------------* Handle tid rollover0.2.0 (2018-01-19)------------------* Library specific exceptions for login failures.0.1.0 (2018-01-17)------------------* First release on PyPI.
Package: watergeo
Welcome to Watergeopython package for water spatial analysisFree software: MIT LicenseDocumentation: (https://github.com/Andyzxm/watergeo)Here is a list of features that are included in this package(Work in Progress):interactive map for US water accessibilitydifferent water use layerssplit maptime series for water use in USIntroductionBackground for water security onYoutube
Package: watergrid
WaterGrid-PythonWatergrid is a lightweight, distributed framework for data stream processing.Why WatergridWatergrid lets developers write their ETL pipelines as applications, not
scripts or jobs. This lets you re-use your existing CI/CD infrastructure and
deployment practices.Watergrid encourages you to write your ETL operations as modular "steps",
making it easy to isolate and test atomic parts of your pipelines.Watergrid lets you scale up to multi-node clusters by changing only a few
lines of Python code.Watergrid is minimalistic, and easy to use.Watergrid does not depend on complicated software setups that execute jobs.
Everything is self-contained in the library itself.Watergrid lets you use your existing Redis infrastructure for distributed
jobs instead of a proprietary data storage/transmission solution.Watergrid includes an API for interfacing with an APM of your choice out of
the box.Getting StartedCreating an ETL pipeline with Watergrid is very easy.Install Python 3.6 or later (other versions may be supported, but are not tested regularly).Runpip install watergridPaste the following code into a file namedmain.py:fromwatergrid.pipelines.standalone_pipelineimportStandalonePipelinefromwatergrid.stepsimportStepfromwatergrid.contextimportDataContextclassSampleStep(Step):def__init__(self):super().__init__(self.__class__.__name__)defrun(self,context:DataContext):print("Hello World!")defmain():pipeline=StandalonePipeline('hello_world_pipeline')pipeline.add_step(SampleStep())whileTrue:pipeline.run()if__name__=='__main__':main()Then runpython main.pyto run the pipeline. You should see Hello World!
printed to the console.Check out thegetting started section of the documentation siteto build more advanced pipelines with multiple steps and high-availability.Getting HelpThere are plenty of places to get help with Watergrid.Check the in-line documentation in the Python source.Read the online documentation onGitHub Pages.Make a post in theDiscussions Tab.Open an issue if you think the problem is with Watergrid, or if you have a
feature to suggest.Example ProjectsRSSMQ- Forwards RSS feed items to various HTTP APIs.atc-metrics-streamer- Streams metrics from Apache Traffic Control to Kafka.
Package: waterlooworks
Waterloo WorksA set of utilities used for interacting with Waterloo Works.This project contains a set of utilities for interacting with Waterloo Works
for employers.Getting startedpip3installwaterlooworks# Required for Apache Tikabrewcaskinstalljava8# Required for pdftotextbrewinstallpoppler# https://formulae.brew.sh/formula/popplerThis package depends ontika-pythonwhich requires
Java 7+.This package relies on the greatpdf-redactorlibrary created byJoshua Tauberer. The the core of thepdf-redactorlibrary is embedded inwaterlooworkssince it is not available on pypi.Usage$ waterlooworks --help
Usage: waterlooworks [OPTIONS] COMMAND [ARGS]...

  A set of utilities for analyzing and processing WaterlooWorks intern
  packages

Options:
  --help  Show this message and exit.

Commands:
  anonymize  Anonymize WaterlooWorks intern packages
  score      Analyze WaterlooWorks intern packagesDownload the full resume package for interns from Waterloo WorksWhen logged into Waterloo Works, copy and past the contents ofww.jsinto the
console. This script will trigger a dowload of the intern resume packages into
your browser'sDownloadsfolder. The script only downloads the packages visible
on the current page, and not on additional paginated application pages.pbcopy<ww.js# 1. Log onto Waterloo Works, and navigate the the page containing applications#    for your posting.# 2. Paste into the console# 3. Resumes for that page will be downloaded.Print a table of scored / ranked waterlooworks packagesThis script will output the metadata for resumes, in descending order based on
the mean of term averages.$ waterlooworks score data
1337 packages found
data/foo.pdf
data/bar.pdf
data/baz.pdf
...
| Foo | 4A | 11111111 | 4A Software Engineering |  {'OUTSTANDING': 2, 'EXCELLENT': 2} | [80.0, 80.0, 80.0, 80.0, 80.0] |
...Anonymize PackagesThis is a simple attempt to try and remove references to names, gender and other information irrelevant
to a package.$ waterlooworks anonymize ~/wwdata/ ~/anon1
1337 packages found
data/foo.pdf
data/bar.pdf
data/baz.pdf
...CaveatsThese utilities arebest effortand do not guarantee the data is accurate. If the format for packages changes,
this library will break.These scripts should not be the sole way of evaluating candidates, they should augment typical hiring workflows.ContributingIf you have any ideas, justopen an issueand tell me what you think.If you'd like to contribute, please fork the repository and make changes as
you'd like. Pull requests are warmly welcome.LicensingMIT License.
Package: watermark
An IPython magic extension for printing date and time stamps, version
numbers, and hardware information.ContactIf you have any questions or comments about watermark,
please feel free to contact me via
email:mail@sebastianraschka.comThis project is hosted athttps://github.com/rasbt/watermarkThe documentation can be found athttps://github.com/rasbt/watermark/blob/master/README.md