Saravanan666/pypi-org huggingface dataset:
Package: waste_not_the_water
waste_not_the_water========waste_not_the_water is a data science tool for urban wastewater treatment plants.It contains two different components, a predictive machine learning model anddata visualization. All the data is taken from the open source database from theUrban Waste Water Treatment Directive from the European Commission.For more information about our project, checkout out the repositoryREADME_... _README: https://github.com/parkec3/waste_not_the_water/blob/master/README.mdLicense=======``waste_not_the_water`` is licensed under the terms of the MIT license. See the file"LICENSE" for information on the history of this software, terms & conditionsfor usage, and a DISCLAIMER OF ALL WARRANTIES.
Package: waste-uploader
This is a python utility that uploads ipa/apk binary to s3 storage using API gateway.After installation just run in terminal:waste-uploaderand it shows you variables that you need to define.Otherwise, there is a list:AWS_ACCESS_KEY_IDAWS_SECRET_ACCESS_KEYPROJECTSTAGEPLATFORM (ios/android)VERSIONBUILD_NUMRELEASE_NOTESFILE_PATHBUNDLE_IDNon-nesessary variables for slack alerts:SLACK_URL (webhook url)APP_ICON_URL (public url to app icon)Non-nesessary variablesCUSTOM_NAME (true or false)
Package: wat-airflow-prometheus-exporter
Airflow Prometheus ExporterThe Airflow Prometheus Exporter exposes various metrics about the Scheduler, DAGs and Tasks which helps improve the observability of an Airflow cluster.The exporter is based on thisprometheus exporter for Airflow.RequirementsThe plugin has been tested with:Airflow >= 1.10.4Python 3.6+The scheduler metrics assume that there is a DAG namedcanary_dag. In our setup, thecanary_dagis a DAG which has a tasks which perform very simple actions such as establishing database connections. This DAG is used to test the uptime of the Airflow scheduler itself.InstallationThe exporter can be installed as an Airflow Plugin using:pip install airflow-prometheus-exporterThis should ideally be installed in your Airflow virtualenv.MetricsMetrics will be available athttp://<your_airflow_host_and_port>/admin/metrics/Task Specific Metricsairflow_task_statusNumber of tasks with a specific status.All the possible states are listedhere.airflow_task_durationDuration of successful tasks in seconds.airflow_task_fail_countNumber of times a particular task has failed.airflow_xcom_paramvalue of configurable parameter in xcom tablexcom fields is deserialized as a dictionary and if key is found for a paticular task-id, the value is reported as a guageAdd task / key combinations in config.yaml:xcom_params:-task_id:abckey:count-task_id:defkey:errorsa task_id of 'all' will match against all airflow tasks:xcom_params:
 -
    task_id: all
    key: countDag Specific Metricsairflow_dag_statusNumber of DAGs with a specific status.All the possible states are listedhereairflow_dag_run_durationDuration of successful DagRun in seconds.Scheduler Metricsairflow_dag_scheduler_delayScheduling delay for a DAG Run in seconds. This metric assumes there is acanary_dag.The scheduling delay is measured as the delay between when a DAG is marked asSCHEDULEDand when it actually startsRUNNING.airflow_task_scheduler_delayScheduling delay for a Task in seconds. This metric assumes there is acanary_dag.airflow_num_queued_tasksNumber of tasks in theQUEUEDstate at any given instance.
Package: watch-bot
Watch-BotThis python projects implements the idea of a watchbot introduced inthis medium article.QuickstartInstallationpipinstallwatch-botUsageCurrently the watchbot is built on OpenAI's GPT. You therefore need a valid OpenAI API key (Azure OpenAI works too).
Setup the credentials:importopenaiopenai.api_type=os.environ["OPENAI_API_TYPE"]openai.api_version=os.environ["OPENAI_API_VERSION"]openai.api_base=os.environ["OPENAI_API_BASE"]openai.api_key=os.environ["OPENAI_API_KEY"]You can then create a watchbot instance:fromwatch_botimportWatchBotbot=WatchBot(engine=os.environ["OPENAI_ENGINE"],chatbot_instructions="You are an AI assistant that helps people find information. ""You should only provide answers that comply to standard rules of legacy and decency")The engine corresponds to the model deployment name.Finally, you can use the watchbot to verify the validity of a dialog:fromwatch_botimportDialogdialog=Dialog(messages=("Hi chatgpt, how are you today?","I'm fine, thanks!"))response=bot.verify(dialog)print("Should the dialog be stopped?",response.should_stop)print("Why?",response.reason)
Package: watchconf
Watchconf is a simple tool to quickly audit the configurations of a collection of servers, namely:Have a list of all config files that must be present in the servers.Check these in all servers, and make sure that they are all equal, and if they are different, see why they are different and whether that’s what we want.This tool retrieves the files contents via ssh and displays, for each configuration file:Which servers have it and which don’t (servers that don’t have the file will appear in italics.)The servers that do have the file, will be grouped so that servers with identical file contents are together.For each group of servers, you’ll see a diff of the file against the same file in the previous group of servers.Files that are equal in all servers will appear in italics.The app is in a single file. To get it running either download thewatchconf.pyor install it withpip install watchconf.Here’s how to use it:watchconf -f FILES -s SERVERS [-p PORT] [-u|--username USERNAME] [-d|--debug]

Starts an HTTP server that shows the differences between the specified files in the specified servers.

options:

 -f --files     Files to compare
 -s --servers   Servers to compare
 -p --port      Port to listen to (default: 5000)
 -u --username  ssh username (default: use the current user)
 -d --debug     Debug mode
 -h --help      display helpFor example:watchconf -s server1,server2 -f file1,file2Watchconf expects a memcache daemon listening to the default port on localhost.
Package: watch-diff
watch-diffPeriodically run a command and receive nice diff styled emails on output changes.Seehttps://francisbergin.github.io/posts/watch-difffor more info.Setuppipinstallwatch-diffFeaturesSupports Python >= 3.7Uses only Python Standard LibrarySends email diff in both text and html formOutput changes to CLI and optionally to SMTPUsesMessage-IDandIn-Reply-Toto group email threadsUsage$watch-diff--helpusage: watch-diff [-h] [-v | -d] [-i SECONDS] [-r RECIPIENT] commandWatch command output and get notified on changespositional arguments:command               the command to watchoptional arguments:-h, --help            show this help message and exit-i SECONDS, --interval SECONDSnumber of seconds between executions-r RECIPIENT, --recipient RECIPIENTsend email to recipientlogging level:-v, --verbose         enable verbose output-d, --debug           show debugging statementsCredentialsexportSMTP_HOST=qwer.tyexportSMTP_PORT=1234exportSMTP_USER=qwer@qwer.tyread-s-p"SMTP_PASS: "SMTP_PASSexportSMTP_PASSDevelopment# setuppython3-mvenvvenv&&.venv/bin/activate# editable installpipinstall-e.[dev]# running testspython-munittest-v# running tests for all supported python versionstox
Package: watchdogs
watchdogsKeep an eye on the change of web world.Such aspost articles/news on the web portal/server api health/binge-watching/steam price fluctuation/github events/updates of comic and novel, and so on...Intro中文文档This is a web app based onfastapi,databases,uniparser,torequests.Smoothly deploy it by pip:pip install -U watchdogs;python3 -m watchdogsSimple to create a new crawler with the Web UI, not like old ways to write duplicate code.All the crawlers keep runing in the async environment.Almost all the elements have atitleattribute to describe the features in the Web UI, which means docs lay on the UI.Release your hands from repetitive refreshing pages on the browser.Subscribe the change events with RSS reminder extensions, such asFeedbroor RSS Feed Reader.Implement a class which inherits fromwatchdogs.callbacks.Callback.Usagepip install -U watchdogspython -m watchdogsOpen the browser:http://127.0.0.1:9901Command line argspython -m watchdogs -- -hdb_url:sqlite / mysql / postgresql(not test) url, whichdatabasessupports. Defaults to 'sqlite:///{HOME_PATH}/watchdogs/storage.sqlite'password:init password, if null can be set on the first visit on web.mute_std_log:remove stdout log for clean streammute_file_log:ignore file log located at {HOME_PATH}/watchdogs folder.md5_salt:md5_salt for custom md5(password) / md5(rss_tag)config_dir:config dir to save the logs and config files, if using sqlite include sqlite file. defaults to {HOME_PATH}/watchdogsuse_default_cdn:If Config.cdn_urls not set, and use_default_cdn is True, will use online js/css cdn links from staticfile.org.**uvicorn_kwargs:uvicorn startup kwargs, such as port, host. Which can be set like:python -m watchdogs --port=9999 --host=127.0.0.1 --access-log=FalseQuick Start to Create New TaskQuick Start ScreenshotsWeb UIScreenshotsWelcome Page (Tasks Page).Here you can see all the tasks meta, goto RSS / Mobile Lite Page, and do some operations to the tasks.New Task Page.Here based on the latestuniparserweb app, to create new rules and also tasks.Rules Page.Do some operations for the rules.API page.Based onfastapi/docswhich is generated automatically.Mobile Page (Lite View).For mobile phone to glimpse the latest result for the current 30 tasks.
Package: watched-sdk
WATCHED.com Python SDKPython SDK to create addons for WATCHED.com.You can find our overall documentation athttps://git.blvck.dev/watched/docsExample addonThere are two ways to run the example addon.Just install it# Install the watched_sdkpythonsetup.pyinstall# Start the addonpythonexample/main.pystartDocker# Build the containerdockerbuild.-twatched-sdk-example# Start itdockerrun--rm-p3000:3000watched-sdk-example# To run single commands:dockerrun--rm-p3000:3000watched-sdk-examplepythonexample/main.pycall# To develop on the addon, use this:dockerrun--rm-p3000:3000-v$PWD:/codewatched-sdk-examplepythonexample/main.pystartdebug
Package: watchedserial
Installation$pipinstallwatchedserialDescriptionWatchedReaderThreadis a subclass of pySerial’sserial.threaded.ReaderThread. Similar toReaderThread,WatchedReaderThreadimplements a serial port read loop in it’s own thread but
instead of killing the thread on a serial disconnection, it calls a callback and
waits for the port to become available again before attempting a reconnect. On
reconnect it calls a reconnect callback. This should make writing apps that need to
deal with unreliable serial connections more seamless and make it easier to write
apps that should allow the user to disconnect and reconnect a serial device safely.UsageSubclasswatchedserial.WatchedReaderThreadto implement thehandle_reconnect()andhandle_disconnect()callbacks. Both of these
functions should be non-blocking (similar to an ISR).importtimeimportserialfromwatchedserialimportWatchedReaderThreadPORT="COM3"classMyPacket(serial.threaded.FramedPacket):defhandle_packet(self,packet):print(packet)classMyWatchedReaderThread(WatchedReaderThread):defhandle_reconnect(self):print("Reconnected")defhandle_disconnect(self,error):print("Disconnected")ser=serial.Serial(PORT,baudrate=115200)withMyWatchedReaderThread(ser,MyPacket)asprotocol:whileTrue:time.sleep(1)
Package: watcher
watcheris a low-level C extension for receiving file system updates
using theReadDirectoryChangesWAPI on Windows systems.:import watcher
w = watcher.Watcher(dir, callback)
w.flags = watcher.FILE_NOTIFY_CHANGE_FILE_NAME
w.start()The package also includes a high-level interface to emulate most of the
.NETFileSystemWatcherAPI. The callback adding and removing mirrors how the same would be
done on IronPython. Additionally, enabling and disabling of the callbacks
is the same.:import FileSystemWatcher
fsw = FileSystemWatcher("somedir")
fsw.NotifyFilter = FileSystemWatcher.NotifyFilters.FileName
fsw.Created += your_callback
fsw.EnableRaisingEvents = TrueThe project is still in progress. Development occurs athttps://bitbucket.org/briancurtin/watcher.Changes0.2.12.6 compatibility fixes from Jo Jurgens.0.2Support for Python 2 (only tested with 2.7). It probably works with older
versions as well.Support for bytes paths on Python 3.0.1Initial release, Python 3 only.
Package: watcher-cli
python-watcherI've crated this project to watch over a repo dir and execute a file after modifying anything on that same dir.
Its lightweight since it only has watchdog as a dependency.Parameters for running-d or --dir (str, required): 
    Folder you want the watcher to look for changes. Defaults to "."
-f or --file (str, required): 
    Script that you want to run after a file is changed (probably you main.py or something similar)
-t or --time (int, optional):
    Time delay to run again (good when saving constantly). Defaults to 1.
--test (bool, optional):
    If the watcher should run pytest command instead of python. Defaults to False.
--lint (bool, optional):
    If the watcher should run pylint command instead of python. Defaults to False.
--lint_src (str, optional):
    where the linter should be run (so it does not run into unwanted files).
--lint_threshold (float, optional):
    Threshold for Pylint to fail. Defaults to None (no threshold).To runWatching and executing a python script:# watch changes in the directory "." and execute watcher.pywatcher-d.-fwatcher.py# watch changes only in the file watcher.pywatcher-fwatcher.py# watching and executing pytestwatcher--test# watching and executing pylint only for "src" directory with a threshold with 90%watcher--lint--lint_srcsrc--lint_threshold9For dependencies all you need to do is runInstall fromPyPipip install watcher-cliOr from source:git clone https://github.com/NathanGavenski/python-watcher
cd python-watcher
pip install -e .Use casesAlthough trivial, there are some uses cases that made me create this package:Run pytest when saving a file.Run pylint when making corrections.Run smaller scripts after every modification.Mostly I was tired off having to tab out from vim just to run pytest/pylint/python on the terminal.Todocreate a proper setupmake it executable from command linebe able to pass parametersread parameters from yaml fileonly watch a single file changesrun pytestrun pylintto run pylint there has to be a folder to run pylint overfail with some thresholdSpawn a new process to close if needed (more control over running process)Create documentationCreate testsPublishFix pytest not working on GitHub actions
Package: watcher-dashboard
OpenStack Dashboard plugin for Watcher projectThe Watcher dashboard is a Horizon plugin that will allow users to realize a
wide range of cloud optimization goals.Free software: Apache licenseDocumentation:https://docs.openstack.org/watcher-dashboard/latestSource:https://opendev.org/openstack/watcher-dashboardBugs:https://bugs.launchpad.net/watcher-dashboardRelease Notes:https://docs.openstack.org/releasenotes/watcher-dashboardBlueprints:https://blueprints.launchpad.net/watcher-dashboard
Package: watcherlab-ti-client-python
守望者实验室威胁情报平台2.0客户端守望者实验室威胁情报平台2.0数据查询和下载官方Python客户端说明本客户端旨在提供一种易于使用的威胁情报数据查询和下载方式威胁情报平台(1.0)
应使用0.0.1版本的Pytho客户端，目前我们正在切换到2.0版本因此应该使用0.0.2版本的Python客户端。在威胁情报平台2.0中包含三个子系统：情报云端系统、情报中心系统和情报采集系统，客户端目前支持前两个子系统的部分API。下载统计使用方法简体中文
Package: watchers.py
A simple script that monitors changes in the file system using
polling. Useful for small, platform independent projects that don’t need
complex libraries like greatwatchdog.Facts or why you should take a good look at watchers.py:No dependencies, only Python3.2,3.3or3.4SupportsWindowsandUnixOnly one file, less than12 KBSimple and minimalisticExampleA simple program that uses watchers.py to monitor specified directory
in 2 seconds interval. It prints the message on a change in a file
system.fromwatchersimportSimpleWatcherdeffoo():print('Something has changed in directory!')x=SimpleWatcher(2,'path/to/dir',foo)x.start()More examples available at Github.Why polling? WHY?!Because it works everywhere and has no other dependencies than pure Python.InstallationInstall from PyPI using pippipinstallwatchers.pyOr download a filewatchers.pyand use it in your project directly.PerformanceSystem:Intel(R) Core(TM)2 Duo CPU E8400 @ 3.00GHz
Debian Linux 3.13-1-686 on USB flash driveChecking 8000 files in 2000 directories took:Total:    Checking one file:
Watcher:        463 ms    0.058 ms
SimpleWatcher:  379 ms    0.047 ms
Package: watcher-tempest-plugin
DescriptionPlease fill here a long description which must be at least 3 lines wrapped on
80 cols, so that distribution package maintainers can use it in their packages.
Note that this is a hard requirement.Free software: Apache licenseDocumentation:https://docs.openstack.org/watcher/latest/plugin watcher-tempest-pluginRelease notes:https://docs.openstack.org/releasenotes/watcher/plugin watcher-tempest-pluginSource:https://opendev.org/openstack/watcher-tempest-pluginBugs:https://bugs.launchpad.net/watcherplugin watcher-tempest-pluginFeaturesTODO
Package: watcheye-collector
CollectorCollector is a Django application to collect monitoring data samples
through HTTP or SNMP GET interface. Collected data might be then
visualized using e.g.Grafana.DependenciesCollector usesInfluxDBtime series database for storing monitoring data samples anddjango
supported databasefor storing
configuration andRedis broker.Quick startAssuming InfluxDB is properly configured (setting up authenticationis recommended) and so is Redis broker just a few steps are required.Installwatcheye-collector:$pipinstallwatcheye-collectorAddcollectorapplication toINSTALLED_APPSsetting.INSTALLED_APPS=[...'collector',]Integrate Celery with your django project (seeCelery documentationfor further reference).Add InfluxDB connection and Celery configuration insettings.pyfile:INFLUXDB_HOST='my_host'INFLUXDB_USERNAME='user'INFLUXDB_PASSWORD='secret'CELERY_BEAT_SCHEDULE={'snmp-scheduler':{'task':'collector.tasks.snmp_scheduler','schedule':crontab(minute='*')}}CELERY_RESULT_BACKEND='redis://my_broker_host/0'CELERY_BROKER_URL='redis://my_broker_host/1'# to use non-default values configure also:INFLUXDB_PORT=1234INFLUXDB_DATABASE='my_database'INFLUXDB_RETENTION_POLICY='my_policy'INFLUXDB_DURATION='30d'To set InfluxDB instance up run:pythonmanage.pysetupinfluxdb--username<admin_username>To create the collector models run:pythonmanage.pymigrateInclude the collector URLconf in your project urls.py:path('collector/',include('collector.urls')),Start the development server and visithttp://127.0.0.1:8000/admin/to create a collector configuration (the Admin application must also
be enabled).Run Celery worker with:celery--beat--app<my_project>workerPOST some samples:$curl-i-XPOST\-H"Content-Type: application/json"\-d'{"host":"test", "timestamp": 1500000000,
"samples": [{"parameter":"CPU", "value": 10}]}'\http://127.0.0.1:8000/collector/
Package: watchfiles
watchfilesSimple, modern and high performance file watching and code reload in python.Documentation:watchfiles.helpmanual.ioSource Code:github.com/samuelcolvin/watchfilesUnderlying file system notifications are handled by theNotifyrust library.This package was previously named "watchgod",
seethe migration guidefor more information.Installationwatchfilesrequires Python 3.8 - 3.12.pipinstallwatchfilesBinaries are available for:Linux:x86_64,aarch64,i686,armv7l,musl-x86_64&musl-aarch64MacOS:x86_64&arm64Windows:amd64&win32Otherwise, you can install from source which requires Rust stable to be installed.UsageHere are some examples of whatwatchfilescan do:watchUsagefromwatchfilesimportwatchforchangesinwatch('./path/to/dir'):print(changes)Seewatchdocsfor more details.awatchUsageimportasynciofromwatchfilesimportawatchasyncdefmain():asyncforchangesinawatch('/path/to/dir'):print(changes)asyncio.run(main())Seeawatchdocsfor more details.run_processUsagefromwatchfilesimportrun_processdeffoobar(a,b,c):...if__name__=='__main__':run_process('./path/to/dir',target=foobar,args=(1,2,3))Seerun_processdocsfor more details.arun_processUsageimportasynciofromwatchfilesimportarun_processdeffoobar(a,b,c):...asyncdefmain():awaitarun_process('./path/to/dir',target=foobar,args=(1,2,3))if__name__=='__main__':asyncio.run(main())Seearun_processdocsfor more details.CLIwatchfilesalso comes with a CLI for running and reloading code. To runsome commandwhen files insrcchange:watchfiles "some command" srcFor more information, seethe CLI docs.Or runwatchfiles--help
Package: watch-fs
watch-fsis a command line tool to run commands when files change.Source on GitHubPackages on PyPIBuilds on Travis CIUsagewatch-fswill watch any number of directories and files, and run a command
when any of them are changed. By default,watch-fswill watch the current
directory.Usage: watch-fs [OPTIONS] COMMAND

Options:
  -d, --directory DIRECTORY  A directory to watch for file changes - can be
                             used multiple times, and defaults to the current
                             directory.
  -c, --clear                Clear the terminal before running the command
  -w, --wait FLOAT           A minium wait before running the command again,
                             in seconds
  -v, --verbose              -v prints commands before running, and -vv shows
                             debug informationInstallationI recommend you usepipsito installwatch-fsin it’s own virtualenv and link it from~/.local/bin:pipsiinstallwatch-fsAlternatively, you can install system-wide usingpip:pipinstallwatch-fsLicencewatch-fsis licensed under the MIT Licence.Authorwatch-fswas written bySam Clements.
Package: watchhub
Documentation for this package can be found athttps://watchhub.readthedocs.io.watchhubis a Python package for querying the strem.io Watchhub API. This API enables you to discover content IDs across many stream services such as netflix, disney+, nowtv, etc. from a IMDB IDInstallationpip install watchhubTo utilize the async version of this code, you must install into a Python 3.7+ environment via:pip install watchhub[async]
Package: watch-import
watch_importWatch_import useswatchfilesto observe a file or folder. When a file is saved it will re/import that file into the watch_import context.Using as a file/folder watcher>watch_importPATH/TO_PYTHON_FILESUsing as an importfromwatch_importimportwatch_meprint('hello')watch_me()Example use-case OCP CAD Viewerimportcadqueryascqfromocp_vscodeimportshowfromwatch_importimportwatch_mebody=cq.Workplane("XY").box(5,10,15)show(body)watch_me()Run this file once and it will start watching and "re-run" once saved.
Package: watching
# Repo WatchingGithub repos watching framework## Install```shellpip install watching```## Simple Usagefunction `ctx.upsert_file_and_pr` is a helper to update or create file and create pull request .```pythonwatcher = Watcher({'github_access_token': ACCESS_TOKEN,})def license_middleware(ctx: Context):branch = 'watcher_license_create'path = '/LICENSE'new_content = 'MIT\n\ncreated by joway'message = 'add MIT license'pr_title = 'Init: MIT License'pr_body = '- create MIT License'file_branch = 'master'ctx.upsert_file_and_pr(path=path, content=new_content, branch=branch,should_upsert=lambda new, old: new != old, message=message,pr_title=pr_title, pr_body=pr_body,)def other_middleware(ctx: Context):passdef filter_func(repo: Repo):if repo.name == 'repo-watching-demo':return True# task chain , it will be executed by every repowatcher.use(license_middleware, other_middleware)# filter the repos you needrepos = watcher.get_all_repos(filter_func=filter_func)# listen reposwatcher.listen(repos)# traverse all repos you listenedwatcher.run()```## Advanced Usage```python# get commit listctx.repo.commit_list()# access your github username | org namectx.repo.loginctx.repo.name# create filectx.repo.file_create()# update filectx.repo.file_update()# get filectx.repo.file_get()# create branchctx.repo.branch_create()# create prctx.repo.pr_create()```