Saravanan666/pypi-org huggingface dataset:
Package: cron-install
A simple command to install a cron table, and make it evolve over time.Use it in a deployement task to deploy a file containing your crontab.UsageCall the command using the module name.Indicate a marker, unique on the host,
with-moption,
that will help identify the start / end of your specific tasks in crontab.Indicate a file containing your crontab.
The file may reference environment variables,
that will be replaced at installation time using thepython builtin template module.For example, if we have a filecrontab.tplcontaining:MAILTO="$ADMIN_MAIL"
# recompute the model
0 0 * * * python -m project.rebuild_model >>/dev/null
# check stuff in $STUFF_DIRNAME
*/10 * * * /usr/local/bin/check_stuff $STUFF_DIRNAME >>/dev/nullLaunching:$ ADMIN_MAIL="admin@acme.info" STUFF_DIRNAME="/srv/stuff" python3 -m cron_install -m MY_PROJECT crontab.tplWill install the following table:$ crontab -l
# START MY_PROJECT
MAILTO="admin@acme.info"
# recompute the model
0 0 * * * python -m project.rebuild_model >>/dev/null
# check stuff in /srv/stuff
*/10 * * * /usr/local/bin/check_stuff /srv/stuff >>/dev/null
# END MY_PROJECTOn a new run,
all the part between# START MY_PROJECTand# END MY_PROJECT,
will be replaced by the new crontab.
Package: cronjobfilter
cronjobfilterTo filter list of cronjobs which are coming under from date and to date.Test PyPi:pip install -ihttps://test.pypi.org/simple/cronjobfiltercronjobfilter==0.0.3Example:Python 3.8.3 (tags/v3.8.3:6f8c832, May 13 2020, 22:37:02) [MSC v.1924 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.from cronjobfilter.cronjobfilter import greet_usergreet_user("Sam Peter")
Hello my friend Sam Peter ! How are you ?
Package: cronken
CronkenWhat is Cronken?Cronken is a Redis-backed distributed cron system which allows running cronjobs across a set of servers without
risking double-running them on multiple boxes at once.  To facilitate this, it uses Redis locks to ensure that
only one server at a time runs any particular job.  It also uses Redis for all of its input and output,
reading its job list from Redis, storing results to Redis, and subscribing to a Redis pub/sub channel to allow for
centralized control of all cronken instances.UsageA barebones example using a local Redis server can be found inexample_server.py, and a
slightly more sophisticated example that uses aiohttp to expose a web interface can be found inexample_web.py.Data FormatA full description of the backend Redis data format can be found incronken_specification.md.
Package: cronlikescheduler
Python job scheduling for humans.An in-process scheduler for periodic jobs that uses the builder pattern
for configuration. Schedule lets you run Python functions (or any other
callable) periodically at pre-determined intervals using a simple,
human-friendly syntax.Inspired byAdam Wiggins’article“Rethinking Cron”and theclockworkRuby module.FeaturesA simple to use API for scheduling jobs.Very lightweight and no external dependencies.Excellent test coverage.Tested on Python 2.7 and 3.5Usage$pipinstallscheduleimportscheduleimporttimedefjob():print("I'm working...")schedule.every(10).minutes.do(job)schedule.every().hour.do(job)schedule.every().day.at("10:30").do(job)schedule.every().monday.do(job)schedule.every().wednesday.at("13:15").do(job)whileTrue:schedule.run_pending()time.sleep(1)DocumentationSchedule’s documentation lives atschedule.readthedocs.io.Please also check the FAQ there with common questions.MetaDaniel Bader -@dbader_org-mail@dbader.orgDistributed under the MIT license. SeeLICENSE.txtfor more information.https://github.com/dbader/schedule
Package: cron-lite
A very light library to run python functions like cron jobs do. (support
cron expressions with timezone, decorator style, spawn running and
graceful exit. Runs in python service like Apscheduler, no effect of
system config)Examplefromcron_liteimportcron_task,start_all,stop_all,set_time_zoneimporttimeset_time_zone("Asia/Shanghai")@cron_task("* * * * * 0/2")defevent1():print("event1",time.strftime("%Y-%m-%d%H:%M:%S",time.localtime(time.time())))time.sleep(3)print("event1 done",time.strftime("%Y-%m-%d%H:%M:%S",time.localtime(time.time())))@cron_task("* * * * * 0/15")defevent2():print("event2",time.strftime("%Y-%m-%d%H:%M:%S",time.localtime(time.time())))time.sleep(10)print("event2 done",time.strftime("%Y-%m-%d%H:%M:%S",time.localtime(time.time())))th=start_all(spawn=True)# use bare `start_all()` to run forever as a serviceprint("start")time.sleep(60)print("stop")stop_all(th)print("done")
Package: cronmon
# CronMon## Usage`your-task.sharguments | cronmon--nameyour-task--location~/cronmon cronman--command"your-task.sharguments"--nameyour-task--location~/cronmon cronmon--command"script.sh"--location~/cronmon--on-fail"fail-script.sh"`## TODO~~Store how much time does a task has taken~~~~On failure do~~Configuration fileLog into a single fileLog into a database (SQL)Web server## New CLI` cronmon run ... cronmon log-nanaconda [0] cronmon server `## Authorscronmonwas written by [Marcos Vanetta](http://twitter.com/malev).
Package: crono
🔮 CronoCrono is aprogrammatictime-based job schedulerthat gives your application a sense of timing.importcronocrono.request('POST','https://your.app/').after(hours=42)Read moreInstallInstall package:pipinstallcronoRun the servers:redis-server&celeryworker--app=crono.queue:queue--hostname=worker1@%h
celerybeat--app=crono.queue:queueUsageTriggersA trigger defines when a job will be executed. There are 4 types of triggers:after,on,every, andcron.afterafterspecifies a countdown until the execution of a task. It will only occur once. It takes at least 1 keyword argument: hours, minutes, and/or seconds, of type . Those keywords arguments are cumulative (same for theeverytrigger). For example,hours=1, minutes=30equalsminutes=90.crono.after(minutes=30).…ononspecifies the execution of a task at a specific date and time. It will only occur once. It takes 1 positional argument of type<datetime.datetime>.importdatetimedate=datetime.datetime(2019,7,4)crono.on(date).…everyeveryspecifies a frequency at which to execute a task. It will occur multiple times. It takes at least 1 keyword argument: hours, minutes, and/or seconds, of type . Those keywords arguments are cumulative (similarly to theaftertrigger). For example,hours=1, minutes=30equalsminutes=90.crono.every(hours=1,minutes=30).…croncronuses an expression to specify the execution time. It will occur mutiple times. It takes exactly 1 positional argument of type<str>.crono.cron('0 6 * * 2').…TasksA task defines what a job will do. There are 4 types of tasks:log,request,message, andemail.logloguses the standardloggingPython library.crono.log('DEBUG','{text}',*args,**kwargs)requestrequestsends an HTTP request. It is powered by theRequestslibrary.crono.request('POST','{url}',**kwargs).…messagemessagesends an SMS. It is powered byTwilio. To use it, you will have to specifytwilio_account_sidandtwilio_auth_id.Not implemented, yet.emailemailsends an email. It is powered byPostmark. To use it, you will have to specifypostmark_api_keyandpostmark_sender.Not implemented, yet.Examplesimportcrono# Timercrono.request('POST','{url}').after(minutes=1)# Datetimecrono.log('DEBUG','{text}').on(<datetime>)# Intervalcrono.email(…).every(hours=1)# `email` task not implemented (yet)# Croncrono.message(…).cron('0 6 * * 2')# `message` task not implemented (yet)ConfigurationCrono comes with sensible default values that you can override:# Required
CELERY_BROKER

# Optional
CELERY_RESULT_BACKEND
REDIS_MAX_CONNECTIONS (default: 20)	
CELERY_BROKER_POOL_LIMIT (default: 0)
CELERY_TASK_IGNORE_RESULT (default: True)
CELERY_BEAT_MAX_LOOP_INTERVAL (default: 300)
CELERY_WORKER_MAX_TASKS_PER_CHILD (default: 100)Testpython -m pytestDevelopmentPackaging#Generatingdistributionarchives$pythonsetup.pysdistbdist_wheel#Uploadingthedistributionarchives$twineupload--skip-existingdist/*
Package: crono-api-client
Crono API ClientPython client for the 🔮 Crono API:https://crono.com/>>>importcrono_api_clientascrono>>>crono.request('POST',https://your.app/').after(hours=42)How toInstall package:$pipinstallcrono_api_clientConfigure.envvariables:CRONO_API_URL=… 
CRONO_API_KEY=…Get all jobs:>>>job_uuids=crono.jobs()Get a job:>>>job_json=crono.job(<string:job_uuid>)Schedule a job:>>>job_uuid=crono.<task>(<args>,<kwargs>).<trigger>(<args>,<kwargs>)>>># or>>>job_uuid=crono.<trigger>(<args>,<kwargs>).<task>(<args>,<kwargs>)Delete a job:>>>job_uuid=crono.delete(<string:job_uuid>)DevelopmentPackaging#Generatingdistributionarchives$pythonsetup.pysdistbdist_wheel#Uploadingthedistributionarchives$twineupload--skip-existingdist/*
Package: cronodump
The cronodump utility can parse most of the databases created by theCronosProdatabase software
and dump it to several output formats.The software is popular among Russian public offices, companies and police agencies.Example usage:croconvert --csv <yourdbpath>Will create a .csv dump of all records in your database.or:crodump strudump <yourdbpath>Will print details on the internal definitions of the tables present in your database.For more details see theREADME.mdfile.
Package: cronohub
CronohubArchive from anywhere to anywhere using the power of plugins.How does it work?Cronohub in it’s own is useless. It’s power comes from plugins located hereplugins_repository. These plugins are used assourceandtarget.
Examples are under thepluginssections. Once an appropriate plugin is
selected for downloading and uploading, cronohub takes care of the rest.For example to download all repositories for a user from github and then
upload all those repositories to an s3 bucket with timestamp cronohub would
be used like this:cronohub-sgithub-ts3The github plugin takes care of all of the necessary authentication and
parallel downloading of all repositories. The plugin also has the ability
to filter out repos that the user whishes to archive. It’s all based on
the plugin. For more information, locate the plugin and read it’s README.InstallInstallation is simply calling:pipinstallcronohubUsageTo see a help of cronohub simply access the help screen.cronohub-hPluginsThe plugins are the soul of cronohub. They are constantly added and can be
very specific and for a single purpose or can be for a wider audience.
Cronohub only provides a platform for all these plugins to exist and work
together. Cronohub is a mediator in this case.For more information please read the plugin’s readme section that explains
how they work and how a new one can be added and where they need to be
located in order or cronohub the pick them up.
Package: cronomaxrf
Welcome to cronomaxrfRecently my lab, the Rijkserfgoedlaboratorium in Amsterdam, acquired a
new Bruker Crono X-Ray Fluorescence spectral image (MACRO-XRF) scanner.
This instrument saves its raw data into a specific type of HDF5 file
format. Currently these files can only be read and converted by
commercially licensed Crono software. This situation restricts access to
the data to a limited number of researchers who can run the software.
Furthermore, it is likely that we will loose the ability to read the
data at some point in the future.In order to make optimal use of the Crono data in collaborative research
projects now and to make sure that we can still read the data in the
future we need to: 1) understand the Crono HDF5 file format, and 2)
develop open software tools available to all researchers for reading and
converting these data files. To support open heritage sciencecronomaxrfpackage is currently being developed under the GPLv3 open
source software license.For installation instructions, documentation and code see:https://fligt.github.io/cronomaxrf/
Package: cronotrack
CLI App for tracking timeBasic CLI application for tracking time writen in python (stdlib only)Installation and usageYou can install the package thrughpip:>pipinstallcronotrackRun the app as an executable module:>python-mcronotrackTo exit from the app pressq(orctrl+c)OverviewWhen started the first chrono will be started. From there you can:n: Finish current chrono and start a new one. A prompt to name the finished task will appear.p: Pause and resume the current chronoq: Exit the appThats all, pretty simple. At the end of the execution a summary with chrono execution details will be printed.App samples
Package: cronpar
Cronpar - a tool for parsing cron expressionRequirementsTo run this program, you need setup you local environment as followingA Python Environment with Python 3.8+ and pip (reckon use pyenv and create a virtualenv)Poetry (Dependency management)make (a dev tool)SetupBefore you can run everything, please make sure you have setup a Python environmentif you are using make, you can setup the dev environmane by simply usingmakeinitthis will install poetry and install all dependencies. If you don't want to use make, alternatively, just run the
following commandspipinstallpoetry
poetryinstallTo prepare/build the cli tool for you to play with, runmakebuildor, just runpipxinstall.Now, you should be able to run the program, for examplecronparexplain"*/15 0 1,15 * 1-5 /usr/bin/find"Yesting & ContributionThere are some test cases generated during development, to run the tests, you can either runmaketestprpoetryrunpytesttests/--cov--cov-fail-under89Please make sure you have tested all the changes you made properly, and all tests passed before you pushAlso, it will be good to keep the code formatted, you can check this by runningmakeformat
makelintorpoetryrunblack--preview--line-length120cronpar
poetryrunisort--line-length120cronpar
poetryrunflakehelllint.NoticePlease Note this program is still in development, it may be not very stable,
but we will fix and add more features in the coming future.
Package: cronparse
CronparseA simple tool for testingcrontablike syntax.Usage>>> from cronparse import Cron
>>> c = Cron('*/5 * * * 0')  # Matches only on Mondays, every 5th minute
>>> from datetime import datetime
>>> d = datetime(2020, 4, 13, 11, 5)
>>> c.matches(d)
True
>>> d = d.replace(minute=6)
>>> c.matches(d)
False
>>> d = d.replace(day=14, minute=5)
>>> c.matches(d)
False
>>> c.why(d) # Ask which fragment of the rule did not match
[True, True, True, True, False]crontab rule syntaxSupported syntax:* - match any value1 - match exact value*/5 - match every 5th value1,3,4 - match values from list1-3 - match values in a range1-3,7,*/2 - combinations!@yearly, @annually, @monthly, @weekly, @daily, @midnight, @hourlyUnsupported syntax:Day namesMonth names@rebootTimezone SupportOptionally, you can pass adatetime.tzinfoas the second argument. It
defaults todatetime.timezone.utc.Anydatetimepassed for testing will first be moved to that timezone.
Package: cronquot
cronquotcronquot is a command/library for quoting cron execution.You can create a list of cron scheduler with this tool.
Only you should do is preparing your cron data.UsagePreparationTo runcronquot, you have to make directory and put cron files exported fromcrontab -l.File names should server names like below.$ tree
crontab/
├── server1
├── server2
└── web1CUIFrom command, you can use only one command.# You can set start time and end time.
$ cronquot -s 20170201010000 -e 20170201020000 -d crontabAfter this, result file will export as 'result.csv'.Python sample source codeYou can use this with only python2.7fromcronquot.cronquotimportCronc=Cron(start='20170101000000',end='20170101101000')forccinc:print(cc)Installation$ pip install cronquotLicenceMIT
Package: cronredux
cronreduxA revisit of cron service using more modern interaction patterns.AboutCommand line friendlyDoes not use mail protocolsDoes not use syslogSlack notificationsConcurrency controlYou can schedule the number of jobs to run concurrentlyOverlap of tasks can be enabled or disabled depending on your use cases.RequirementsasyncioPython LibraryshellishPython LibrarycrontabPython LibraryInstallationpython3 ./setup.py build
python3 ./setup.py installCompatibilityPython 3.4+TODOWeb server for/healthendpoint and status info.
Package: cron-schedule
cron-scheduleInstallationpipinstallcron-scheduleUsagefromdatetimeimportdatetimeimporttimefromscheduleimportscheduledefdo_some_job():print('do_some_job...',datetime.now())schedule.add_job(do_some_job,"* * * * * 15,25")whileTrue:schedule.run_pending()time.sleep(1)do_some_job... 2022-09-23 15:35:15.152107
do_some_job... 2022-09-23 15:35:25.193932thankscroniter
Package: cron-schedule-triggers
CronScheduleTriggers: Quartz Syntax based Cron Trigger library.Cron Schedule Triggers (CSTriggers) is a Python library enabling the ability to determine the next execution of a live schedule. Its syntax is that ofQuartz Job Scheduler. This library is not a scheduling app or a task queue, there are plenty of those in the wild to choose from. When you need advanced customisation of triggers for tasks, and a common and conventional syntax for schedule notation, CSTriggers comes to your aid.This library is for those whoWant the ability to generate future task data for visualization purposes.Want to combine their own choice of solutions to build a customizable integrated task queuing/scheduling system at any scale.Do not want to run java, but want to take advantage of the richQuartz CronsyntaxDo not want to drag in many dependencies into their project (Uses standard Python3 libraries only).Example usageInitialize a schedule object with a cron notation string, a start date, and an optional end date. Call.next_trigger()for a new date. Notice that when an end_date is given, The schedule terminates at2022-10-13T00:00:00and not2030-03-01T00:00:00as it would naturally.fromcstriggers.core.triggerimportQuartzCronschedule_string="0 0 0 1 JAN-MAR ? 2010-2030"start_date="2019-10-13T00:00:00"end_date="2022-10-13T00:00:00"cron_obj=QuartzCron(schedule_string=schedule_string,start_date=start_date,end_date=end_date)print(cron_obj.next_trigger(isoformat=True))>> 2020-01-01T00:00:00For multiple sequential dates call either.next_trigger()multiple times.fromcstriggers.core.triggerimportQuartzCronschedule_string="0 0 0 1 JAN-MAR ? 2010-2030"start_date="2019-10-13T00:00:00"end_date="2022-10-13T00:00:00"cron_obj=QuartzCron(schedule_string=schedule_string,start_date=start_date,end_date=end_date)print(cron_obj.next_trigger(isoformat=True))print(cron_obj.next_trigger(isoformat=True))>> 2020-01-01T00:00:00
>> 2020-02-01T00:00:00Or call.next_triggers()with the number of triggers needed.fromcstriggers.core.triggerimportQuartzCronschedule_string="0 0 0 1 JAN-MAR ? 2010-2030"start_date="2019-10-13T00:00:00"end_date="2022-10-13T00:00:00"cron_obj=QuartzCron(schedule_string=schedule_string,start_date=start_date,end_date=end_date)print(cron_obj.next_triggers(number_of_triggers=10,isoformat=True))>> [
    '2020-01-01T00:00:00', 
    '2020-02-01T00:00:00', 
    '2020-03-01T00:00:00', 
    '2021-01-01T00:00:00', 
    '2021-02-01T00:00:00', 
    '2021-03-01T00:00:00', 
    '2022-01-01T00:00:00', 
    '2022-02-01T00:00:00', 
    '2022-03-01T00:00:00', 
    '2023-01-01T00:00:00'
]RoadmapSupport for last_trigger(s) to retroactively look at schedule dates.Support for AWS Cron Expression syntax.
Package: cron-sentry
Cron-Sentry is a python command-line wrapper that reports errors toSentry(usingraven)
if the called script exits with a status other than zero.Installpip installcron-sentryUsage$ cron-sentry --help
usage: cron-sentry [-h] [--dsn SENTRY_DSN] [-M STRING_MAX_LENGTH] [--quiet] [--report-all] [--version] cmd [arg ...]

Wraps commands and reports those that fail to Sentry.

positional arguments:
  cmd                   The command to run

optional arguments:
  -h, --help            show this help message and exit
  --dsn SENTRY_DSN      Sentry server address
  -M STRING_MAX_LENGTH, --string-max-length STRING_MAX_LENGTH, --max-message-length STRING_MAX_LENGTH
                        The maximum characters of a string that should be sent
                        to Sentry (defaults to 4096)
  -q, --quiet           Suppress all command output
  --version             show program's version number and exit
  --report-all          Report to Sentry even if the task has succeeded

The Sentry server address can also be specified through the SENTRY_DSN
environment variable (and the --dsn option can be omitted).It’s possible to send extra information to Sentry via environment
variables (prefix them withCRON_SENTRY_EXTRA_), such as:$ export CRON_SENTRY_EXTRA_env=production
$ cron-sentry my-programExample$ crontab-eSENTRY_DSN=https://<your_key>:<your_secret>@app.getsentry.com/<your_project_id>
0 4 * * * cron-sentry my-process --arg arg2NotesIf your command outputs Unicode, you may need to signal to python that stdin/stdout/stderr are UTF-8 encoded:PYTHONIOENCODING=utf-8
SENTRY_DSN=https://<your_key>:<your_secret>@app.getsentry.com/<your_project_id>
0 4 * * * cron-sentry my-process --arg arg2LicenseThis project started life asraven-cronby MediaCore Technologies.Original copyright 2013 to MediaCore Technologies (MIT license).
Copyright 2015 to Yipit Inc. (MIT license).
Package: cronshield
cronshieldcronshield filters cron output selectively to improve error reportingFree software: BSD licenseDocumentation:https://cronshield.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.0 (2019-11-05)First release on PyPI.
Package: cronster
cronsterFull DocumentationInstallationTo installcronster, type:$pipinstallcronsterGetting StartedInstall RedisTo get started withcronster, installRedison your computer
(macOS & Homebrew in this example):$brewinstallredis$brewservicesstartredisDigital Oceanhas a great tutorial on
how install Redis on Ubuntu.Run the crawlerAssumingRedisis running on your machine in default configuration
and you want to crawl from~/projects, run the following command:$cronster_crawler-r~/projectsThe full help output explains the other options of the CLI application.
It is possible to change certain parameters shouldRedison a different
host/port or should you want to adjust the interval between crawls:Usage:cronster_crawler[OPTIONS]Options:-r,--rootTEXTCrawlingroot,default:thecurrentworkingdirectory-h,--cache-hostTEXTCachehost,default:localhost-p,--cache-portINTEGERCacheport,default:6379(Redisdefault)-i,--intervalINTEGERCrawlinginterval,default:2seconds--helpShowthismessageandexit.Run the schedulerAssumingRedisis running on your machine in default configuration,
run the following command:$cronster_schedulerThe full help output explains the other options of the CLI application.
It is possible to changeRedis-related parameters shouldRedison a
different host or port:Usage:cronster_scheduler[OPTIONS]Options:-h,--cache-hostTEXTCachehost,default:localhost-p,--cache-portINTEGERCacheport,default:6379(Redisdefault)--helpShowthismessageandexit.Write acrontabfileWrite the followingYAMLfile to~/projects/crontab(or any other location
anywhere in the hierarchy under yourrootlocation):test_job:cmd:echo "Hello, World!"schedule:"*/5****"You should see the job being picked up by the crawler on the next crawl and
should see the scheduler run the job every five minutes.
Package: cront
# crontcront is a library that can make the task apps like crontab.## InstallationAutomatic installation:```bash$ pip install cront```cront is listed in [PyPI](https://pypi.python.org/pypi/cront) and can be installed with pip or easy_install.Manual installation:```bash$ git clone https://github.com/asmodius/cront.git$ cd cront$ python setup.py install```cront source code is [hosted on GitHub](https://github.com/asmodius/cront)## UsageHere is a simple Tornado app:```pythonfrom __future__ import print_functionimport tornado.webimport tornado.ioloopfrom cront import cron_task@cron_task("* * * * *")def hello_crontab(app):print("Hello, {0}".format(app))if __name__ == "__main__":app = tornado.web.Application()cron_task.start(app)tornado.ioloop.IOLoop.current().start()```## Using* [Tornado](http://www.tornadoweb.org/)## License* cront license under the [MIT license](https://github.com/gaujin/tornado-crontab/blob/master/LICENSE).* [Tornado is licensed under the Apache license](https://github.com/tornadoweb/tornado/blob/master/LICENSE).