Saravanan666/pypi-org huggingface dataset:
Package: task-jogger
More affectionately known asjogger.joggeris a simple Python-based command line tool that isn’t quite a fully-fledged taskrunner. In addition to supporting arbitrary tasks, run either directly on the command line or as Python scripts, it ships with some common, useful, Django-aware tasks that can adapt their behaviour based on which packages are available in the system.Full documentation at:https://task-jogger.readthedocs.io/InstallationInstall the latest stable version from PyPI:pip install task-joggerQuick start1. Createjog.pyThejog.pyfile, created in the project root directory, stores the tasks defined for the project. It is a regular Python module, the only requirement being that it defines atasksvariable as a dictionary.2. DefinetasksKeys in thejog.pyfile’stasksdictionary form each task’s name, and values describe the tasks themselves. At their simplest, a task can be a string defining a command to execute on the command line:# jog.pytasks={'hello':'echo "Hello, World!"','test':'coverage run python manage.py test'}Alternatively, a task can be a Python function thatreturnsa command to execute on the command line. This can be useful if the command is more complex to construct or depends on dynamic values:# jog.pydefrun_tests(settings,stdout,stderr):"""
    Run the Django test suite, with coverage.py if installed.
    """try:importcoverageexceptImportError:stdout.write('Warning: coverage.py not installed.',style='warning')return'python manage.py test'else:return'coverage run python manage.py test'tasks={'test':run_tests}Finally, particularly complex tasks can be defined as classes. Such tasks can define their own custom arguments:# jog.pyfromjogger.tasksimportTaskclassTestTask(Task):help='Run the Django test suite, with coverage.py if installed.'defadd_arguments(self,parser):parser.add_argument('-q','--quick',action='store_true',help=('Run a "quick" variant of the task: no coverage analysis and ''running tests in parallel.'))defhandle(self,*args,**options):command='python manage.py test'ifoptions['quick']:command=f'{command}--parallel'else:try:importcoverageexceptImportError:self.stdout.write('Warning: coverage.py not installed.',style='warning')else:command=f'coverage run{command}'self.cli(command)tasks={'test':TestTask}3. RunjogThejogcommand is the interface to the tasks defined injog.py.Given the name of a task,jogwill run that task:$ jog testIf the task accepts arguments, they can also be provided:$ jog test --quickExecuted with no arguments,jogwill display a list of all available tasks. Tasks defined as functions or classes can define a description to be displayed in this listing. Tasks defined as strings simply display the command they will run. The following shows the output of ajog.pyfile containing a mixture of string-based, function-based, and class-based tasks:$ jog
Available tasks:
string: echo "Hello, World!"
function: A task defined as a function.
class: A task defined as a class.
    See "jog class --help" for usage details
Package: taskjuggler_utils
Tools to help use “taskjuggler” without its GUI and produce nice reports.This package provides tools that will provide nice reports
(taskjuggler-report), gantt charts (taskjuggler-gantt) and time shift
the whole taskjuggler project file (taskjuggler-timeshift).The best thing is that you don’t need to use Graphical User Interfaces
for that, so these can be automated from cron jobs, web servers and
makefiles.Reports are generated using LaTeX syntax since I use them in my LaTeX
files easily, but we can easily add code to generate HTML reports as
well in future.
Package: taskkill
terminating processes on Windows using the taskkill commandTested against Windows 10 / Python 3.10 / Anacondapip install taskkilltaskkill is a Python library that provides utility functions for terminating processes on Windows using the taskkill command. It allows users to easily kill processes by PID, terminate processes along with their child processes, and perform forceful termination if necessary. The library also includes a regex-based search function to find and terminate processes based on specific criteria such as window title, window text, class name, and process path.FeaturesKill processes by PIDTerminate processes along with their child processesForcefully terminate processesSearch and terminate processes using regex-based criteriaDry run option to preview processes without actually terminating themfromtaskkillimporttaskkill_pid,taskkill_pid_children,taskkill_force_pid,taskkill_force_pid_children,taskkill_regex_rearch# Kill processes by PIDresults=taskkill_pid(pids=(1234,5678))# Terminate processes along with their child processesresults=taskkill_pid_children(pids=(1234,5678))# Forcefully terminate processesresults=taskkill_force_pid(pids=(1234,5678))# Forcefully terminate processes along with their child processesresults=taskkill_force_pid_children(pids=(1234,5678))# Search and terminate processes using regex-based criteriaresults=taskkill_regex_rearch(dryrun=False,kill_children=True,force_kill=True,title=r"\bnotepad$",windowtext=".*",class_name=".*",path="notepad.exe$",)# Dry run - Preview processes without terminating themtaskkill_regex_rearch(dryrun=True,kill_children=True,force_kill=True,title=r"\bnotepad$",flags_title=re.I,windowtext=".*",flags_windowtext=re.I,class_name=".*",flags_class_name=re.I,path="notepad.exe$",flags_path=re.I,)Contribution
Contributions are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request on the GitHub repository.License
This project is licensed under the MIT License.
Package: tasklib
tasklib is a Python library for interacting withtaskwarriordatabases, using
a queryset API similar to that of Django’s ORM.RequirementsPython 3.5 or abovetaskwarriorv2.4.x or above.Older versions of taskwarrior are untested and may not work.InstallationInstall via pip:pip install tasklibUsagetasklib has a similar API to that of Django’s ORM:>>> from tasklib import TaskWarrior

>>> tw = TaskWarrior('~/.task')
>>> tasks = tw.tasks.pending()
>>> tasks
['Tidy the house', 'Learn German']
>>> tasks.filter(tags__contain='chores')
['Tidy the house']
>>> type(tasks[0])
<class 'tasklib.task.Task'>
>>> tasks[0].done()
>>> tasks = tw.tasks.pending()
>>> tasks
['Learn German']
>>> tasks[0]['tags'] = ['languages']
>>> tasks[0].save()For more advanced usage, see thedocumentation.
Package: tasklist
OverviewA simple way to ensure that a list of commands is executed successfully, or re-tried.Tasklist allows to the following:Execute lists of commands (tasks)Verify their successRe-execute commands that failed, order-preservingControl temporary and permanent command statusesDiscard tasks with temporary failures after a tryoutDiscard tasks with temporary failures after a timeoutPersist the list of tasks so it's reloaded when your program failsMain applicationsDevOps pipelines which require multiple commands to reach a desired stateServers which accept operations which may fail and are required to retry themEvent Sourcing architectures where events are executed with commandsManual processes which may be interrupted for a failure, and need to be resumed from thereExamplesEnsure complete termination of interrupted processfromtasklistimportTaskList,Task# make sure all of the following commands are executedcommands=["tar cjvf maillog.tbz /var/log/maillog","rm -f /var/log/maillog","service myservice restart"]# create a tasklisttl=TaskList()forcmdincommands:tl.add(Task(cmd=cmd.split()))iftl.run_all():# some task failed. Sleep a while and retrytl.run_all()Manage temporary and permanent failuresimporttimefromtasklistimportTaskList,Taskt=Task(cmd="false")t.run()# False (executed with failure)t.failed_retry()# False (failed with non-retriable exit status)time.sleep(10)t.age()# 10 (created 10 seconds ago)t=Task(cmd="python",args=["-c","import sys; sys.exit(2)"])t.run_all()# Falset.failed_retry()# True (failed with retriable exit status)Making the queue persistentfromtasklistimportTaskList,Task# automatically persist the tasklist at the given path in the filesystemtl=TaskList(wrkdir='/tmp/mytasklist',autosync=True)tl.add(Task(cmd="true"))tl.add(Task(cmd="false"))deltlnew_tl=TaskList(wrkdir='/tmp/mytasklist',autosync=True)len(new_tl)# 2 tasksSupportThis is open-source software contributed by theBuddyNSteam. The project is hosted athttps://gitlab.com/BuddyNS/tasklist.Please do not contact BuddyNS for support with this library. You can get general support on Python from the great people of the#pythonchannel on thefreenode IRC network.
Package: tasklit
tasklitA browser-based task scheduling app build on streamlit.How to use?Too lazy to write cronjobs? Working on a headless system and want to have a GUI?Tasklitis a simple task scheduling application that allows you to schedule different processes via browser interface.Get startedcreate an environmentconda create --name tasklit python=3.8install withpip install tasklitrun withtasklitvisit the website (default ishttp://localhost:8501or network ip)Submit a new task. Example to run a test script on your desktop on a Mac system:python \Users\username\Desktop\myscript.pyFor local development:Clone the repository locally:git clone https://github.com/straussmaximilian/tasklit.gitinstall withpip install .orpip install -e .for the editable versionfor pinned requirments install the development-requirements:pip install .[develop]LimitationsOnly task execution, no logic based on return valuesPlannedNotifications (Email, Slack, Teams)AcknowledgementsThe PyPi workflow and installation routine is largely copied form theAlphaTims- repository.TestsRun tests viacoverage run -m unittest discover testsCheck test coverage viacoverage report -m
Package: tasklocals
Task locals support for tulip/asyncio~~~~~~~~~~~~~~~~~~~~~It provides Task local storage similar to python's threading.localbut for Tasks in asyncio.Using task locals has some caveats:* Unlike thread locals, where you are always sure that at least one thread is running(namely main thread), Task locals are available only in the context of a running Task. So if you try to access a task local from outside a Task you will get a RuntimeError.* Be aware that using asyncio.async, asyncio.wait, asyncio.gather, asyncio.shield and friends launches a new task, so these coroutines will have its own local storage.For more information on using locals see the docs for threading.local in python's standard library
Package: tasklog
tasklog: a terminal based application to submit work/task logs to JIRA issues, to Slack channelsCompatible with Python versionsPython 3.7.3+Basic SetupInstall for all users, from Pypisudo bash make.sh --install-package-globally-from-pypi
tasklog -hInstall + run app (for development):source make.sh --enable-development-env
bash make.sh --install-dependencies
bash make.sh --install-package-in-development-mode
bash make.sh --show-tasklog-optionsInstall for all users, from sourcesudo bash make.sh --install-package-globally-from-source
tasklog -hSetup/Run the application:bash make.sh --show-tasklog-options
OR
bash make.sh --show-tasklog-submit-worklog-cli-sample
bash make.sh --show-tasklog-submit-daily-cli-sampleRun the test suite:Requirement: App is installed for development purposebash make.sh --install-test-dependencies
bash make.sh --run-testsSample Config file:# Slack Serverslack:# API TokenapiToken:"FOOBAR"# Channel to post to, without # prefixchannel:"daily"# JIRA Serverjira:# Server URLserverURL:"http://.example.com"# Account Usernameusername:"me"# Account Passwordpassword:"you"# HTTPS connection must be with a valid server certificate. boolean: true / falseverifyCertificate:false# JIRA Issue Preferencesissue:# Issue Creation Preferencescreation:# Prefered Issue Type when creating issues# (list of issue type name, sorted in descending order)typePreferedOrder:-Task-Improvement-Bug-New Feature-Sub-Task-Epic-Story-Technical Task-Question# New JIRA Issue prefered title as a numbered titledayX:# Starting title keywordprefixPreferedOrder:-Day-Jour# CLI Logginglogging:# Logging level. Enum: DEBUG, INFO, WARN, ERROR, CRITICALseverity:"INFO"# Log file namefile:"tasklog.cli.log"Sample tasklog file:MOCKTEST-1
23-05-2019
4.5h
This log will be created against an existing JIRA issue named "MOCKTEST-1"

WORKLOG#
MOCKTEST
22-05-2019
8h
This is log will be logged against a brand new JIRA issue in project with key MOCKTEST
- and an extra line
- and an extra line 2
-- and an extra line 3

WORKLOG#
MOCKTEST
23-05-2019
4.5h
This is a multiline description
it is cool is not it ?
Package: tasklogger
An extension to the core python logging library for logging the beginning and completion of tasks and subtasks.Installationtasklogger is available onpip. Install by running the following in a terminal:pip install --user taskloggerAlternatively, tasklogger can be installed usingConda(most easily obtained via theMiniconda Python distribution):conda install -c conda-forge taskloggerUsage examplesReceive timed updates mid-computation usingtasklogger.log_startandtasklogger.log_complete:>>> import tasklogger
>>> import time
>>> tasklogger.log_start("Supertask")
Calculating Supertask...
>>> time.sleep(1)
>>> tasklogger.log_start("Subtask")
  Calculating Subtask...
>>> time.sleep(1)
>>> tasklogger.log_complete("Subtask")
  Calculated Subtask in 1.01 seconds.
>>> time.sleep(1)
>>> tasklogger.log_complete("Supertask")
Calculated Supertask in 3.02 seconds.Simplify logging syntax withtasklogger.log_task:>>> import tasklogger
>>> import time
>>> with tasklogger.log_task("Supertask"):
...     time.sleep(1)
...     with tasklogger.log_task("Subtask"):
...        time.sleep(1)
...     time.sleep(1)
Calculating Supertask...
  Calculating Subtask...
  Calculated Subtask in 1.01 seconds.
Calculated Supertask in 3.02 seconds.Log wall time, CPU time, or any other counter function with the class API:>>> import tasklogger
>>> import time
>>> logger = tasklogger.TaskLogger(name='cpu_logger', timer='cpu', min_runtime=0)
>>> with logger.log_task("Supertask"):
...     time.sleep(1)
...     with logger.log_task("Subtask"):
...        _ = [[(i,j) for j in range(i)] for i in range(1000)]
...     time.sleep(1)
Calculating Supertask...
  Calculating Subtask...
  Calculated Subtask in 0.09 seconds.
Calculated Supertask in 0.09 seconds.
>>> logger = tasklogger.TaskLogger(name='nano_logger', timer=time.monotonic_ns)
>>> with logger.log_task("Supertask"):
...     time.sleep(1)
...     with logger.log_task("Subtask"):
...        time.sleep(1)
...     time.sleep(1)
Calculating Supertask...
  Calculating Subtask...
  Calculated Subtask in 1001083511.00 seconds.
Calculated Supertask in 3003702161.00 seconds.Usetaskloggerfor all your logging needs:>>> tasklogger.log_info("Log some stuff that doesn't need timing")
Log some stuff that doesn't need timing
>>> tasklogger.log_debug("Log some stuff that normally isn't needed")
>>> tasklogger.set_level(2)
Set TaskLogger logging to DEBUG
>>> tasklogger.log_debug("Log some stuff that normally isn't needed")
Log some stuff that normally isn't needed
Package: taskloop
TaskloopThis utility allows you to create multiple tasks for aTaskwarriorproject.Installationvia PyPipip install taskloopvia git (development)Clone this repocd taskloopAdd deps using poetrypoetry installpoetry run taskloop/loop.pyRunningAfter pip installing, you may runtaskloopThis requires you have a taskrc at ~/.config/task/taskrc.More flexibility is planned for this though.  If you have an old style
~/.taskrc, you should be able to symlink it withmkdir -p ~/.config/task/taskrc && ln -s ~/.taskrc ~/.config/task/taskrcEntering tasksYou will be prompted for a project.  This will autocomplete from your list of
projects (currently only pending, planned to optionally pull from "completed"
also)After entering a project, you will loop through adding tasks to the project.  if
you want to make your task dependent on the last task, start your task with a
period.Entry will continue to loop until you end by entering an empty lineNow sync will be attempted.   There are currently no checks in place, so if you
don't have a taskserver configured,this will fail.Screencast Demo
Package: task-manage
task-manage一个轻量级的定时任务执行系统，支持python，nodejs,以及一切命令行任务安装pip install task-manage##使用方法服务启动sudo tm runserver服务停止sudo tm stopserver查看任务列表tm ls添加任务 具体参数查看 tm add --helptm add --help

Options:
  -l, --log PATH        日志文件目录路径 如果为空 不保存日志
  -p, --path PATH       执行的文件路径
  -i, --info TEXT       任务描述信息
  -a, --args TEXT       执行命令时携带的参数 需打双引号
  -cmd, --command TEXT  cmd命令,需打双引号
  -c, --cron TEXT       cron表达式,需打双引号 [required]
  -n, --name TEXT       任务名称 [required]
  -f, --file PATH       json配置文件
  -cn --commandname TEXT 任务名称
  -ld --logbackupday TEXT 日志保存的时间
  --help                Show this message and exit.每5秒执行一次 /opt/app/src/test.pytm add -n test -c "0/5 * * * * * *" -cn python3 -p /opt/app/src/test.py或者tm add -n test -c "0/5 * * * * * *" -cmd "python3 /opt/app/src/test.py"通过配置文件执行，可同时添加多个执行任务
如 tm.json[{"name":"test","cron":"0/5 * * * * * *","commandName":"python3","path":"/opt/app/src/test.py","cmd":"","args":"","logPath":"/opt/app/logs","logBackupDay":7,"info":"this is a demo"}]tm add -f tm.json编辑任务 具体参数查看 tm edit --helptm edit --help

Options:
  -l, --log PATH        日志文件目录路径 如果为空 不保存日志
  -a, --args TEXT       执行命令时携带的参数 需打双引号
  -cmd, --command TEXT  cmd命令,需打双引号
  -p, --path PATH       执行的文件路径
  -i, --info TEXT       任务描述信息
  -c, --cron TEXT       cron表达式
  -n, --name TEXT       任务名称  [required]
  -cn --commandname TEXT 任务名称
  -ld --logbackupday TEXT 日志保存的时间
  --help                Show this message and exit.修改任务的执行时间tm edit -n test -c "0/10 * * * * * *"停止任务tm stop -n test开始任务tm start -n test暂停任务tm paused -n test恢复暂停中的任务tm resume -n test立即执行任务tm run -n test删除任务tm delete -n test查看任务日志tm log -n test
Package: task-manager
TaskManagerThe TaskManager keeps track of lists of tasks that users should perform. It
has a REST interface to access tasks and update them.DocumentationThe TaskManager is documented athttps://task-manager.readthedocs.io/DeploymentThe TaskManager deployment typically uses either Kubernetes or
docker-compose. Documentation on how to deploy the TaskManager
can be found in the deployment section in the documentation athttps://task-manager.readthedocs.io/en/latest/static/howto.html#deploymentSource CodeThe TaskManager is open-source and licensed under an Apache 2.0 License.
The source code found be found at GitLab:https://gitlab.com/radiology/infrastructure/task-manager/
Package: task-manager-todo
# todo_appStarted following a tutorial from real-python.After the end of the tutorial , I will contribute major changes to the project.I added time of creation of tasks.
Modified most of the fields and working procedures of those code.Instalation:–Usages:– At first need to apply init for initializing:$ python3 -m todo init—To add a task:
$ python3 -m todo add
or
$ python3 -m add [–description/-d] <Description> [–priority/-p] <Priority>– To see lists of Tasks:$ python3 -m todo list—To see all the tasks (Including Done tasks):
$ python3 -m todo list -a– To Update a task:$ python3 -m todo update
or
$ python3 -m todo update [–id] <Task ID> [–status/-s] <Status> [–priority/-p] <Priority>—To remove a task:
$ python3 -m todo remove <Task ID> [–force/-f]– To clear all tasks:$ python3 -m todo  clear—For Any commands , you can always type –help
Package: taskmaster
TaskmasterTaskmaster is a simple distributed queue designed for handling large numbers of one-off tasks.We built this at DISQUS to handle frequent, but uncommon tasks like “migrate this data to a new schema”.Why?You might ask, “Why not use Celery?”. Well the answer is simply that normal queueing requires (not literally,
but it’d be painful without) you to buffer all tasks into a central location. This becomes a problem when you
have a large amount of tasks, especially when they contain a large amount of data.Imagine you have 1 billion tasks, each weighing in at 5k. Thats, uncompressed, at minimum 4 terabytes of storage
required just to keep that around, and gains you very little.Taskmaster on the other hand is designed to take a resumable iterator, and only pull in a maximum number of
jobs at a time (using standard Python Queue’s). This ensures a consistent memory pattern that can scale linearly.RequirementsRequirementsshouldbe handled by setuptools, but if they are not, you will need the following Python packages:progressbarpyzmq (zeromq)geventgevent_zeromqA note on GeventBeing that Taskmaster uses gevent for both its iterator task (master) and its consumers, your application will need
to correctly implement non-blocking gevent compatible callers. In most cases this won’t be a problem, but if you’re
using the network you’ll need to look for a compatible library for your adapter. For example, there is an alternative
version ofpsycopg2designed for gevent calledgevent-psycopg2.UsageCreate an iterator, and callback:# taskmaster/example.py
def get_jobs(last=0):
    # last would be sent if state was resumed
    # from a previous run
    for i in xrange(last, 100000000):
        # jobs yielded must be serializeable with pickle
        yield i

def handle_job(i):
    # this **must** be idempotent, as resuming the process may execute a job
    # that had already been run
    print "Got %r!" % iSpawn a master:$ tm-master taskmaster.exampleYou can also pass keyword arguments for the master:$ tm-master taskmaster.example argument=valueSpawn a slave:$ tm-slave taskmaster.exampleOr spawn 8 slaves (each containing a threadpool):$ tm-spawn taskmaster.example 8Dont like the magical function discover for master/slave? Specify your own targets:$ tm-master taskmaster.example:get_jobs
$ tm-slave taskmaster.example:handle_jobMaybe you simply need to run things on the same server?$ tm-run taskmaster/example.py 8NoteAll arguments are optional, and the address will default totcp://0.0.0.0:3050.
Package: taskmessenger
TaskMessengerTool to send a designated email after task is finishedIntroductionWaiting for the termination of a long task can be tedious and unpractical. Instead, it would be useful if an email reminder can be sent automatically at the termination of a task. This package allows for such functionality.RequirementsPython >=3.6InstallationFrom PyPi:pip install taskmessengerFrom GitHub (newest version):git clone https://www.github.com/ArmaanAhmed22/taskmessenger & cd taskmessenger & pip install -e .Example:Sending a message using data from the function:fromtaskmessenger.sendimportCompleteMessage,EmailDatac=CompleteMessage("user@example.com")#Use specified email with the default optional arguments@c.send_function_specific_email(lambdax:EmailData("Output from 'a'",str(x)))#Send email message based on the second element of the tupledefa(i):#Function will return i**2 and send as an email [Subject: i, Body: i**2]return(i**2,EmailData(str(i),str(i**2)))print(a(66))#4356Sending a function value-independent message:fromtaskmessenger.sendimportCompleteMessage,EmailDatac=CompleteMessage("user@example.com")e=EmailData("SUBJECT","BODY")@c.send_email_after(e)#Send messagedeffunc():print("Doing something...")func()Sending a message inline (without a function):fromtaskmessenger.sendimportCompleteMessage,EmailDatac=CompleteMessage("user@example.com")c.send(EmailData("SUBJECT","BODY"))Citation:Bibtex:@software{armaan_ahmed_2021_5684676,
  author       = {Armaan Ahmed},
  title        = {ArmaanAhmed22/TaskMessenger: TaskMessenger v1.0.0},
  month        = nov,
  year         = 2021,
  publisher    = {Zenodo},
  version      = {v1.0.0},
  doi          = {10.5281/zenodo.5684676},
  url          = {https://doi.org/10.5281/zenodo.5684676}
}