Saravanan666/pypi-org huggingface dataset:
Package: notify
Notify process termination via email.
It support Python 2.4 and later (Python 2.4 and Python 2.5 was manually tested,
so it might not work).InstallationUsepiplike:$ pip install notifyAdditionally, if you would like to use a mail user agent which requires authentication, installing keyring is strongly recommended:$ pip install keyringUsageRunningnotifywith following command will start setup wizard first time.$ notifyFollow the setup wizard instructionCheck with the following command (Only for Unix system)$ notify --checkUsenotifylike$ notify really_havy_process -a -b --options
$ notify -t different@address.com really_havy_process -a -b --options
Package: notify2
This is a pure-python replacement for notify-python, using python-dbus
to communicate with the notifications server directly. It’s compatible with
Python 2 and 3, and its callbacks can work with Gtk 3 or Qt 4 applications.To use it, first callnotify2.init('appname'), then create and show notifications:n = notify2.Notification("Summary",
                         "Some body text",
                         "notification-message-im"   # Icon name
                        )
n.show()API docs areavailable on ReadTheDocs,
or you can refer to docstrings.Based on the notifications spec at:http://developer.gnome.org/notification-spec/Porting applications from pynotifyThere are a few differences from pynotify you should be aware of:If you need callbacks from notifications, notify2 must know about your event
loop. The simplest way is to pass ‘glib’ or ‘qt’ as themainloopparameter
toinit.The methodsattach_to_widgetandattach_to_status_iconare not
implemented. You can calculate the location you want the notification to
appear and callNotification.set_propertyandget_propertyare not implemented. The summary, body
and icon are accessible as attributes of aNotificationinstance.Various methods that pynotify Notification instances got from gobject do not
exist, or only implement part of the functionality.Several pynotify functions, especially getters and setters, are only supported
for compatibility. You are encouraged to use more direct, Pythonic alternatives.
Package: notify-discord
notify-discordWhat ?notify-discord is a simple python helper script to ease the post of messages on discord channels using webhooks.Requesiteyou should how a discord server and create a webhook in one of its channels. The channel token will be necessary to use this script.Usagenotify-discord -m <message> -w <webhook>Examplenotify-discord -m 'some useful message' -w '0000WEBHOOK0000/1111CHANNELTOKEN1111'caveatsUnknown.
Package: notify-events
Python client for Notify.EventsA simple Python extension that simplifies the process of integrating your project with theNotify.Eventsservice to send messages to your channels.Instruction on another languagesР СѓСЃСЃРєРёР№InstallationYou can install the Python client for Notify.Events fromPyPI:pip install notify_eventsUsageTo use this extension, you need to import the Message class into your script.fromnotify_eventsimportMessageAfter that, you can create a Message object, set the necessary parameters and send the message to the channel.Usage examplefromnotify_eventsimportMessage# Create a message object.message=Message('Some <b>important</b> message','Title',Message.PRIORITY_HIGH,Message.LEVEL_WARNING)# Attach the file to the message.message.add_file('path\to\local\file.zip','filename.zip')# Send a message to your channel in Notify.Events.message.send('XXXXXXXX')List of all available functions
Package: notify-function
Notifier Function StatusThis library uses a decorator to show a toast in your screen or send you a email, telegram message or message to discord channel or use a Telegram bot to send you a message when your function has finished.UsageThere are to methods to use this library:DecoratorAll that you need to do is use a decorator and some specific parameters, like in the following example:fromnotifierimportnotify@notify(email='enmanuelmag@cardor.dev')defyour_function():print('Hello World!')Parameterstitle: the title of toast notification, by defult is:Function finished.email: the email of user, by defult is:None.api_token: the api token of your Telegram bot, by defult is:None. You could useBotFatherto create a personal bot.chat_id: the chat id to send the message, by defult is:None. If you account is public you could use your username (@username), otherwise you could use the chat id, you'll findhere.webhook_url: the url of webhook to send message to discord channel, by defult is:None.msg: the message of toast notification, by default is:Your function has finished.duration: the time, in seconds, that the nottications will show, by default is8.urgency: the urgency of the notifcation. By defualt isnormal. The options are:low.normal.critical.Class (manual call)In this case you need to create a class and call the instance returned by the constructor, like in the following example:fromnotifierimportNotifiernotifier=Notifier()notifier()ParametersThis parameters are avaible in the class constructor and when you call the instance returned by the constructor.title: the title of notification, by defult is:Manual notify.msg: the message of notification, by default is:Check your code.email: the email of user, by defult is:None.api_token: the api token of your Telegram bot, by default is:None. You could useBotFatherto create a personal bot.chat_id: the chat id to send the message, by defult is:None. If you account is public you could use your username (@username), otherwise you could use the chat id, you'll findhere.webhook_url: the url of webhook to send message to discord channel, by defult is:None.Made with ❤️ byEnmanuel Magallanes
Package: notifyhub
NotifyHubLibrary to send you messages from your python scripts.SetupFor contributors:condacreate-nnotifyhubpython==3.6.6# works with RPicondaactivatenotifyhub
pipinstall-rrequirements.txtFor users:cd..# parent directorypipinstallnotifyhubUsagefromnotifyhubimportsend,watchCONFIG_FP='<CONFIG_FP>'# config .json filesend(message="hello there",config_fp=CONFIG_FP)# sends message 'hello there'# watch program to check if it crashes/completes@watch(config_fp=CONFIG_FP)defmain():print('do something')TelegramYour telegram configuration file should look like:{
    "bot": "telegram",
    "bot-token": "<BOT TOKEN>",
    "chat-id": <CHAT ID>
}DiscordYour discord configuration file should look like:{
    "bot": "discord",
    "bot-token": "<BOT TOKEN>",
    "chat-id": <CHANNEL ID>
}
Package: notifykit
👀 A cross-platform filesystem watcher toolkit for Pythonnotifykitis a set of components for building modern Python applications with a need for watching filesystem events efficiently.[!Warning]
notifykit is under active development right nowInstallationpipinstallnotifykit# orpoetryaddnotifykit# orpdmaddnotifykitnotifykit is available for:CPython 3.8-3.12 on the following platforms:Linux: x86_64, aarch64, x86, armv7, s390x, ppc64le, musl-x86_64, musl-aarch64MacOS: x86_64 & arm64Windows: x64 & x86PyPY 3.8-3.10 on the following platforms:Linux: x86_64 & aarch64MacOS: x86_64UsageimportasyncioimportosfrompathlibimportPathfromnotifykitimportNotifierasyncdefwatch(watched_dir:Path)->None:withNotifier(debounce_ms=200,debug=True)asnotifier:notifier.watch([watched_dir])asyncforeventinnotifier:# process your eventsprint(event)if__name__=="__main__":watched_dir=Path("./watched_dir")os.makedirs(watched_dir,exist_ok=True)asyncio.run(watch(watched_dir))FeaturesSimple Modern Pythonic API, both sync and asyncHigh PerformanceCross-platform (support not only Linux, but also MacOS)Easy to mock in testsMakes common cases easy and advance cases possibleSources of Inspirationhttps://github.com/seb-m/pyinotify/issueshttps://github.com/absperf/asyncinotify/https://docs.rs/notify/latest/notify/https://github.com/samuelcolvin/watchfileshttps://github.com/pantsbuild/pants/tree/612e891e90432e994327b6ddaf57502366a714c0/src/rust/enginehttps://github.com/pola-rs/polars/blob/d0c8de592b71d4b934b1598926536f03e10007bd/py-polars/src/file.rs#L206https://github.com/TheoBabilon/async-tail/
Package: notifyme
This module is just a neat little context manager that can notify you via email
to your email account when its body is completed. Example usage:fromnotifymeimportnotifywithnotify('Long, laborious task'):# Perform long, laborious taskOnce the long, laborious task is done, you will receive an email saying “Long,
laborious task completed.”.It also comes with a CLI. You simply runnotifyme [command...]to run the
command and get an email on completion.Installation, Configuration, and UseTo install, simply use the commandpip install notifyme. To configure this
module with your email server settings, create a file in your home directory
called.notifymewith contents like the following:[default]
email = <your-email-here>
host = <smtp-hostname-here>
port = <smtp-port-here>
username = <only-if-different-from-email>
password = <password-here>
security = <SSL or TLS or NONE>You’ll have to look up your configuration details from your email
provider. After you fill this out and save it, you’ll also want to protect it
from access by other users, which you can do with the following command:chmod 600 ~/.notifymeAnd you’re done!  You can now use the module within Python code as a context
manager, or on the command line for any program you’d like.LicenseThis project is released under the Revised BSD license.  SeeLICENSE.txtfor
details.
Package: notifyme-traveltimer
NotifyMe - Travel TimerNotifyMe - Travel Timer is a Python library consisting of functions for predicting travel times. The included functions can fetch distance and directions between two addresses and includes weather multipliers and public transit delays scraped from Twitter for both the TTC and YRT in Toronto, Ontario.Contains:Google Maps Functionsfetch distance from distance matrixfetch directions from public transit routesOpen Weather Map Functionsfetch weather from particular locationfetch weather multiplier from weather conditionsTwitter Functionsfetch public transit delays from TTCfetch public transit delays from YRT
Package: notifyourself
NotifYourselfCLINotifYourselfCLI makes sending notifications to your mobile phone easy. Just follow these simple steps:Install NotifYourselfCLI on your sending machineInstall the NotifYourself android app from Play Store or compile it yourselfFind your token in the configuration page of the appRunnotifyourself -T <token> "Hello yourself!"to send yourself a notificationYou can use this to push yourself a message when your long running simulation, nn-training or calculation is finished:$ longRunningCalculation.sh && notifyourself "Job finished :)"InstallationSimply use pip to install notifyourself:$ python -m pip install notifyourselfUsing source direcltyYou can also just use thepython script sourcedirectly; make sure you install therequestspackage:python -m pip install requestsConfigurationConfiguration is done using the file~/.config/notifyourself/config.ini(or%USERPROFILE%\.config\notifyourself\config.inion Windows).# notifYourself configuration## You can define multiple targets with different tokens and use# the -t flag to choose one. Default is the DEFAULT target.[DEFAULT]# Use your notifYourself app to find this tokentoken=# [ANOTHER_TARGET]# token=ANOTHER_TARGETS_TOKENUsageusage: notifyourself [-h] [-T TOKEN | -t TARGET] [--config CONFIG]
                     title [body]

Send a notification to your phone

positional arguments:
  title                 Notification title
  body                  Longer message in the body of the notification

optional arguments:
  -h, --help            show this help message and exit
  -T TOKEN, --token TOKEN
                        Use this token to send the message
  -t TARGET, --target TARGET
                        Send message to this target phone specified in the
                        config file
  --config CONFIG       Configfile to use instead of defaultExamplesSend a short result with the notification$ echo "42" > ./result
$ notifyourself "Job's finished :)" "Result: $(cat ./result)"Change the token$ notifyourself -T "longlong:token-foobar" "It works :)"Have multiple phones preconfigured$ cat ~/.config/notifyourself/config.ini 
# notifYourself configuration
#
# You can define multiple targets with different tokens and use
# the -t flag to choose one. Default is the DEFAULT target.

[DEFAULT]
# Use your notifYourself app to find this token
token=foobarbaz1

[ANOTHER_TARGET]
token=target2token

$ notifyourself -t ANOTHER_TARGET "This shows in the other one"
Package: notify-pipe
notify-pipeallows you to pipe the output from any command to desktop notificationsinstallingnotify-piperequires Python 2 or Python 3.installing with pippip install notify-pipeor installing with setup_toolsgit clonehttps://github.com/fasib/notify-pipecd notify_pipe
python setup.py installor using an alias inside of ‘~/.bashrc’:alias notify-pipe=’python ~/path/to/notify_pipe.py’examplesecho “test” | notify-pipe -n Testping localhost | notify-pipe -n pingtail -f /var/log/syslog | notify-pipe -n syslogping localhost | notify-pipe | notify-pipe -n double-pipe
Package: notify-push
notify-push is a CLI tool to push notifications straight to your phone.The usual sysadmin method is to send alerts via email but there are tons of services out there with mobile apps that allow us to send push notifications, why not use those for faster and cleaners alerts?InstallationSimply usepipto install it system-wide:$sudopipinstallgit+https://github.com/fopina/notify-push/Or only for your user$pipinstall--usergit+https://github.com/fopina/notify-push/Usage$notify-push-husage:notify-push[OPTIONS]message...Pushnotificationsstraighttoyourphoneusingmultipleservicespositionalarguments:messagemessageoptionalarguments:-sSERVICE,--serviceSERVICEuseonlythisservice--list-services-cCONFIG,--configCONFIGusethisconfigurationfileinsteadof~/.notifypush--versionshowprogram'sversionnumberandexitCurrently supported services are:$notify-push--list-servicesnotifcasterbotpushitbotAn example of configuration file~/.notifypush:[pushitbot]
token = 355aac1b7f0efe055b3f2f663cae16ddPushing messages is now as simple as:$notify-pushhelloworldPushedOr usingstdin(useful for shell piping):$notify-pushPressctrl-DwhendonehelloworldPushed$echohelloworld|notify-pushPressctrl-DwhendonePushedYou can also use it easily from other python scripts:>>>importnotifypush>>>printnotifypush.push('hello world')True
Package: notify-py
notify.pyCross platform desktop notifications for Python scripts and applications.DocsYou can read the docs on this Git's Wiki, orhereSupported Platforms.Windows 10/11macOS 10 >=10.10Linux (libnotify)No dependencies are required other than loguru & jeepney (Only for linux/DBUS).Installpip install notify-pyUsageSend Simple NotificationfromnotifypyimportNotifynotification=Notify()notification.title="Cool Title"notification.message="Even cooler message."notification.send()Send Notification With IconfromnotifypyimportNotifynotification=Notify()notification.title="Cool Title"notification.message="Even cooler message."notification.icon="path/to/icon.png"notification.send()Send Notification With SoundfromnotifypyimportNotifynotification=Notify()notification.title="Cool Title"notification.message="Even cooler message."notification.audio="path/to/audio/file.wav"notification.send()Sending Notifications without blockingfromnotifypyimportNotifynotification=Notify()notification.send(block=False)Sending with Default Notification Titles/Messages/IconsfromnotifypyimportNotifynotification=Notify(default_notification_title="Function Message",default_application_name="Great Application",default_notification_icon="path/to/icon.png",default_notification_audio="path/to/sound.wav")defyour_function():# stuff happening here.notification.message="Function Result"notification.send()CLIA CLI is available when you install notify-pynotifypy--title--message--applicationName--iconPath--soundPathYou may need to addpython3 -mto the beginning.Important CaveatsAs it stands (May 18, 2020), this is simply a notification service. There isnosupport for embedding custom actions (buttons, dialogs) regardless of platform. Other then telling you if the shell command was sent, there is also no confirmation on user action on the notification.macOS doesnotsupport custom icons on the fly.. You will need to bundle a customized version of the notifier embedded with your custom icon.Windows Specific.No support for balloon tips (pre Win10).. This will be changed in the future.ContributorsLeteraxjnoortheendynoboXouInspiration and Special Thankshttps://github.com/go-toast/toast- Ported their Windows 10 toast notification to Python.Vítor Galvãoforhttps://github.com/vitorgalvao/notificatorhttps://notificationsounds.com/notification-sounds/done-for-you-612example_notification_sound.wavhttps://github.com/mikaelbr/node-notifierContributingContributions are welcome!Please base your changes on the latest development branch and open a PR to that branch. PR will not be accepted to the master branch. Tests are ran against all platforms.Setting Up EnvironmentInstallPoetrypoetry installAdd patches/new features/bug fiexesRun testspoetry run pytest tests/*Run lintspoetry run pylint --errors-only notifypy/Run Black Formattingpoetry run black notifypyOpen PR todevbranch.Add your name to contributors list if you wish!
Package: notifyr
notifyr -Create observers in runtimePyPi:https://pypi.org/project/notifyr/DescriptionNotifyr is a package that enables simple class observed-observer schema at runtime. Instead of building the whole observation and notification toolchain, just use python decorators and notifyr will take care of the rest.Inspired by the Observer Design Pattern, notifyr adds the necessary methods to your classes without inheritance.DecoratorsFunction decorators:@targetIndicates that the decorated function is targeted and will trigger the observersupdate()everytime it runs.Class decorators:@observedAdds.observerslist attribute.Adds.attach(obj)method that appendsobjto the observers list.Adds.notify()method that notifies the observers everytime the targeted functions are called@observer('function_name')Addsupdate()method that executes class'sfunction_name()passing, as arguments,selfand everything that the targeted function received (including theselfargument).UsageOriginal Code:classDog(object):def__init__(self,name):self.name=namedefbark(self):print('Woof')defsleep(self):print(self.name,'is now asleep: ZZzzzzZzzZ...')classPerson(object):def__init__(self,name):self.name=namedefeducate_dog(self,dog):print(self.name+':','Sleep,',dog.name)dog.sleep()Suppose we want a person to educate a dog every time the animal barks:fromnotifyr.agentsimportobserved,observerfromnotifyr.functionsimporttarget@observedclassDog(object):def__init__(self,name):self.name=name@targetdefbark(self):print('Woof')defsleep(self):print(self.name,'is now asleep: ZZzzzzZzzZ...')@observer('educate_dog')classPerson(object):def__init__(self,name):self.name=namedefeducate_dog(self,dog):print(self.name+':','Sleep,',dog.name)dog.sleep()And now, it is possible to archieve this by magically callingbark()after attaching a person to a dog:d=Dog('Tobby')p=Person('Victor')d.attach(p)# Victor is now observing Tobbyd.bark()# Woof# Victor: Sleep, Tobby# Tobby is now asleep: ZZzzzzZzzZ...
Package: notify-run
Setupnotify-runcan be installed withpip:pip install notify-runThis will install both a Python modulenotify_runfor sending notifications
programmatically, and thenotify-runcommand for sending notifications
from the shell.ConfigurationBefore you use either the shell command or Python package to send notifications,
you must configure an endpoint. Both the command-line interface and Python
interface provide a way of creating this configuration, and the configuration is
shared by both. The configuration is stored in a file called.config/notify-runin your home directory.Command-line InterfaceRegister a channelTo register a channel:notify-run registerYou will then be presented with a link that you can open on the devices
you wish to subscribe to the channel. A QR code encoding the link is also
provided for convinience.Sending MessageOnce you have registered a channel, you can send a message to it with thesendsubcommand:notify-run send "Hi from notify-run."To open a webpage when the notification is clicked, you can pass it to
notify-run as the-aparameter:notify-run send "Click to open notify.run!" -a https://notify.runUsing an Existing EndpointIf you want to point notify-run at an existing endpoint, for example one
created through theweb interface, you can use theconfiguresubcommand instead ofregister:notify-run configure <endpoint URL>Python InterfaceThe commands above can also be used through a Python interface:from notify_run import Notify
notify = Notify()
notify.register()
notify.send('Hi there!')
notify.send('Click to open notify.run!', 'https://notify.run')To connect to a channel you have already created, pass it as theendpointparameter toNotify():notify = Notify(endpoint=”https://notify.run/<channel_id>”)Thenotify.register()andnotify.info()commands return anEndpointInfoobject.
When rendered in a terminal, this prints the QR code in a terminal-friendly way. When used
in a Jupyter notebook, it displays the QR code inline.
Package: notify-send
notify-sendUsage examplefromnotifyimportnotificationnotification('summary text',message='message body',app_name='myapp')Installationpipinstall-Unotify-sendPrerequisitesUbuntusudoaptinstalllibcairo2-devlibgirepository1.0-devArch Linuxsudopacman-Sgobject-introspectionDevelopment setupgitclonehttps://github.com/andreztz/notify-send.gitcdnotify-sendpython-mvenvvenvsourcevenv/bin/activatepipinstall-e.[dev]MetaAndré P. Santos –@ztzandre–andreztz@gmail.comDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/andreztz/notify-sendContributingFork it (https://github.com/andreztz/notify-send/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: notifySms
This program helps to send sms notification to specified mobile.Pre-Requisite :
- Twilio account, Its Account, Token And Moblile number.
OR
- way2sms account, its apikey & secret code.Usage :1. To use way2sms for sending sms set below environement variable.
     way2sms=True
     apikey=
     secret=
     
     Windows syntax : set =
     Linux syntax   : export = 
    OR
    To use Twilio account specfiy twilio detials config.json in file encoded using base64.b64encode()
2. Using Program to send sms.
   python sendSms.py [Message needs to be sent]
3. Using module in other script to nofiy via sms.
    from nofiySms import sendSms
    sendSms.send_sms("Message body",[To Number])
Package: notify-via-slack
Notify via slackInstall:pip install notify-via-slackUsageCreate an app inslack apiSave the bot tokenCopy the .env.example to .envcp .env.example .envReplace theSLACK_BOT_TOKENSend a messageslack.notifyimportSlackNotifyhandler=SlackNotify(app_name='My app name')handler.notify(message='some message',emit_log=True,is_error=True)