Saravanan666/pypi-org huggingface dataset:
Package: taskflows
Task Management, Scheduling, and Alerting.Admin commands are accessed via thetaskflowscommand line tool. Seetaskflows --helpfor complete usage.SetuppipinstalltaskflowsTask execution metadata is stored in SQLite (default) or Postgresql. To use a personal database, set environment variableTASKFLOWS_DB_URLto your database URL. If using Postgresql, TASKFLOWS_DB_SCHEMA may also be set to use a custom schema (default schema istaskflows).Create TasksTurn any function (optionally async) into a task that logs metadata to the database and sends alerts, allows retries, etc..alerts=[Alerts(send_to=[Slack(bot_token=os.getenv("SLACK_BOT_TOKEN"),channel="critical_alerts"),Email(addr="sender@gmail.com",password=os.getenv("EMAIL_PWD"),receiver_addr=["someone@gmail.com","someone@yahoo.com"])],send_on=["start","error","finish"])]@task(name='some-task',required=True,retries=1,timeout=30,alerts=alerts)asyncdefhello():print("Hi.")Review Task Status/ResultsTasks can send alerts via Slack and/or Email, as shown in the above example. Internally, alerts are sent using thealert-msgspackage.Task start/finish times, status, retry count, return values can be found in thetask_runstable.Any errors that occurred during the execution of a task can be found in thetask_errorstable.Create ServicesNote: To use services, your system must have systemd (the init system on most modern Linux distributions)Services run commands on a specified schedule. SeeServicefor service configuration options.To create the service(s), use thecreatemethod (e.g.srv.create()), or use the CLIcreatecommand (e.g.taskflows create my_services.py)ExamplesfromtaskflowsimportCalendar,ServiceRun at specified calendar days/time.seeCalendarfor more options.srv=Service(name="something",command="docker start something",schedule=Calendar("Mon-Sun 14:00 America/New_York"),)Run command once at half an hour from now.run_time=datetime.now()+timedelta(minutes=30)srv=Service(name='write-message',command="bash -c 'echo hello >> hello.txt'",schedule=Calendar.from_datetime(run_time),)Run command after system boot, then again every 5 minutes after start of previous run. Skip run if CPU usage is over 80% for the last 5 minutes.seePeriodicandconstraintsfor more options.Service(name="my-periodic-task",command="docker start something",schedule=Periodic(start_on="boot",period=60*5,relative_to="start"),system_load_constraints=CPUPressure(max_percent=80,timespan="5min",silent=True))
Package: taskforce
This supports python 2.7 and python 3 on Unix derivatives.  It has specific
support for select.kqueue on MacOS and *BSD and the inotifyx bindings for
Linux inotify.  If neither of these facilities is available,taskforceoperates in polling mode which adds some latency and processing overhead but
is functionally the same.Commands to be run are defined in a configuration file in YAML format.  Let’s go
straight to a quick example:{
    "tasks": {
        "sshd": {
            "control": "wait",
            "commands": { "start": [ "/usr/sbin/sshd", "-D" ] }
        },
        "ntpd": {
            "control": "wait",
            "requires": "sshd",
            "defines": { "conf": "/etc/ntp.conf" },
            "commands": { "start": [ "/usr/sbin/ntpd", "-c", "{conf}", "-n"] },
            "events": [
                { "type": "self", "command": "stop" },
                { "type": "file_change", "path": "{conf}", "command": "stop" }
            ]
        }
    }
}In this example,taskforcestartssshdand then startsntpd.taskforceis set to wait on both programs and both programs are started so that they will
not detach themselves.  If either program exits, it will be restarted.ntpdis run with a couple of extra features.  First, it defines a tag for the
configuration file name.  This is convenient for when the element is used in
multiple places.  It also adds two events.  The first fires if the executable
file changes, and the second fires if the configuration file changes.  The event
typeselfis shorthand for the equivalentfile_changeevent.  In both cases,
the event will cause the task to be stopped.  As the task has thewaitcontrol, it will be immediately restarted.Visithttps://github.com/akfullfo/taskforce/for more information.
Package: taskforceagents
🤖 TaskForceAgents - in ALPHA 🚧 👷Domain Specific Agents - customized to work in teams to plan and solve real-world problems for real peopleDescriptionTaskForceAgents is a Python library for building domain specific agents. Agents are able to leverage domain-specific knowledge (in the form of APIs, databases, knowledge graphs) and take customized actions and execute domain-specific workflows.Agents must be able to:Understandthe context of a problemPlana solution and ancipate costs and risksCoordinatewith other agents to solve the problemExecutethe solutionLearnfrom the resultsThis library is designed for people who want to build agents that want more control overCostAccuracySpeedBuilt withTaskForceAgents is built on top ofPromptedGraphs✨ Features🚧 👷Core Functions🚧 👷RequirementsPython 3.10 or newer.📦 InstallationTo installTaskForceAgentsvia pip:pipinstalltaskforceagents# orpoetryaddtaskforceagentsUsageExample 1Example 2📚 ResourcesAgent ProtocolRelated LibrariesAutoGenAutoGPTHaystack💻 DevelopmentPoetry is used for dependency management. To install poetry, seehere.To install dependencies:poetryinstall

pre-commitinstall# For cleaner commits, install opencommitopencommithooksetContributingWe welcome contributions! Please DM me@seankruzelor create issues or pull requests.📝 LicenseThis project is licensed under the terms of theMIT license.Built usingquantreadyusing templatehttps://github.com/closedloop-technologies/quantready-api
Package: task-forest-cli
Task Forest CLITree-based task tracking for when everything is on fire (command line version).DocsN/AInstallationStandardpip3 install task-forest-cliLatestpip3 install git+https://gitlab.com/task-forest/task-forest-cliDevelopmentIt is recommended that you use a virtualenv for development:virtualenv --python python3 venvsource ./venv/bin/activatepython setup.py developRun withtf
Package: taskforge
# taskforgePowered by [taskw](https://github.com/ralphbean/taskw)# ConfigurationThe config is in YAML format, and looks like this (delete `#` prefixed lines`#`)```logging:level: DEBUGfile: ''plugins:- nickname: Emailotron# the entrypoint for your plugin needs to inherit from# `taskforge.plugins.Base`entrypoint: emailotron:Emailer# plugins are run in ascending weight order. Plugins with the same# weight may be run in any order. The default value for weight is 100.weight: 0enabled: false# plugins are initialized with the contents of this options fieldoptions:some: thing```# PluginsYes, that's right, you can build your own plugins! Just add your plugin to thelist in the plugins section and set `enabled: true`.# LicenseTaskforge is made available under the GNU Affero General Public License, seeLICENSE.txt for details.
Package: taskforge-cli
This is the command line client for Taskforge. This is the recommended client
for terminal-dwelling advanced users.Documentation is available athttps://taskforge.ioWhy Taskforge?Taskforge has many competitors and all of them are great choices for task
management. So why build yet another "todo app"?The answer is: most task management applications require that you
duplicate data into them from other sources. Whether by work, or personal
preference, our actual tasks are managed in different sources today. Whether
that be JIRA, GitHub, Trello etc. the teams and people we interact with rarely
use the same solution as we do. Furthermore, it's even less likely that you'll
be able to use the same systems at work and on projects.The downside of all this?These systems put the responsibility on youto
duplicate that information into a format that you can digest.This is the problem that Taskforge solves. It aggregates and integrates with
existing systems and provides a unified interface for all the various tasks
systems you're required to interact with.Getting StartedHead over toour documentation websitefor full
documentation. For a getting started guide and more information.ContributingFollow theCode of ConductContributions are greatly appreciated. We have a process for making a
contributions via Github that you can read in theContributing section of the
documentation websitedocument.LicenseThis code is distributed under the Affero GNU General Public LicenseCopyright (C) 2020 Mathew Robinson

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
Package: taskgen
Task Generator CoreЯдро генератора банка задач на базе MiKTeX и Jupyter Notebook.Для работы с ядром необходимо использовать панель управления, которая размещена здесь -https://github.com/artyom-zolotarevskiy/taskgenПо всем вопросам:artyom@zolotarevskiy.ru.ВозможностиЯдро в связке с панелью управления решают задачу генерации параметризованного банка задач
для методического сопровождения различных математических дисциплин в ВУЗе.В качестве языка разметки используется TeX на базе дистрибутива MiKTeX, а за параметризацию отвечает Python на базе
Jupyter Notebook, входящий в Anaconda.Результатом работы является уникальный банк задач в форматах TeX, HTML, PDF и Moodle XML. В скором времени планируется
добавить создание параметризированных интерактивных блокнотов Jupyter для учебного процесса.УстановкаВыполните следующую команду для установки актуальной версии ядра:pip install taskgenДальнейшую работу осуществляйте через панель управления -https://github.com/artyom-zolotarevskiy/taskgenЛицензияCopyright (c) 2023 Артём ЗолотаревскийСвязь с автором:artyom@zolotarevskiy.ruБлагодарностиОтдельная благодарность научному руководителю, Павлу Евгеньевичу Рябову,
за постановку задачи и постоянное внимание к работе.
Package: task-graph
Task-GraphBuild a dynamic task graph for your project with Task-Graph!IntroductionWhen facing a complex task, it's often necessary to recalculate the entire task when user wants to get one of the intermediate results, or to adjust one of the parameters or methods, but once you have Task-Graph,If you need to get a result, Task-Graph will only compute all the upstream tasks of the result, and each task will cache  for later use.If one of the task's parameters or method is adjusted, Task-Graph will automatically check all the downstream tasks and clear their cached results.In short, Task-Graph will make the computer lazy and just fulfill your needs without doing repetitive tasks, no more or less.UsageNo doc available now, here is an minimal example.# importfromtask_graphimportTaskGraph# init a TaskGraphtg=TaskGraph()# user task methodsdefadd(a,b):print("add",a,b)returna+bdefsub(a,b):print("sub",a,b)returna-b# describe the task graph(much like dask.delayed)ret1=tg.add_task(add)(1,2)ret2=tg.add_task(add)(3,ret1)ret3=tg.add_task(add)(4,ret2)ret4=tg.add_task(sub)(ret2,ret3)final=tg.add_task('to_list')(ret1,ret2,ret3,ret4)# trigger the computation and printprint(final.compute())# when I want to update a tasktg.update_task(ret3)(add)(5,ret2)# Because ret3 is change, rest3, rest4 and final will be recalculatedprint(final.compute())Or, a lazy way:fromtask_graphimportTaskGraphtg=TaskGraph()defadd(a,b):print("add",a,b)returna+bdefsub(a,b):print("sub",a,b)returna-b# omit add_taskret1=tg(add)(1,2)ret2=tg(add)(3,ret1)ret3=tg(add)(4,ret2)ret4=tg(sub)(ret2,ret3)final=tg('to_list')(ret1,ret2,ret3,ret4)# auto compute and printfinal.print()# omit update_tasktg(ret3)(add)(5,ret2)# auto compute and printfinal.print()TODOTask-Graph is at the very beginning, so many todos in the codes. Here are a few general ones:add parallel scheduleradd decorator that can auto transfer function to taskadd graphviz-based visualizationadd unit testadd docadd examplesZenI am lazy, so I build this to let computer be also lazy.One of the biggest differences in Python from other languages is that the methods (like all other objects) are mutable, Task-Graph is designed to accommodate that.Task-Graph was designed to speed up python project, and want to make it the simplest solution to avoid any recalculation.I have referred to the Dask.delayed API in many places. The difference between Task-Graph and Dask is to try to adapt to the dynamics of the python and python projects, andmake computer not only delayed but also lazy.
Package: task-grouping
task_grouping - Task GroupingThis module provides a basic class library for task grouping, includes 2 classes:TaskContainerOrganizes a batch of task groups, including the serial/parallel structures, and carries the arguments information for each task unit to run.ITaskLoaderThis is an abstract base class for implementing a concrete loader class to load a task tree from Dict/JSON toTaskContainer.For detailed usage, see the practice sample code:https://github.com/DataBooster/PyWebApi/blob/master/Sample/UserApps/ServicesGrouping/rest_grouping.pyand its product documentation:https://github.com/DataBooster/PyWebApi#services-groupingHomepage and documentation:https://github.com/DataBooster/PyWebApiCopyright (c) 2020 Abel ChengLicense: MIT
Package: taskHandler
AboutThis taskHandker package will distribute all file present in give directory in the newly create foldes according to there file extensionhow to usemd = ManageDownloads()for windosC:\Users\<userName>\Downloads\is the default path
and for Linux'home/<userName>/Downloads'is the default pathor we can chagne path like this:-download_path = r"C:\Users\<userName>\Downloads\Images"
md.set_download_path(download_path)then call organize_downloadsmd.organize_downloads()file distributed according to key valse define in whitlist varablenewWhitlist={
                'Media': {'mp3', 'mp4'},
                'Images': {'jpg', 'jpeg', 'gif', 'png'},
                'Web': {'html', 'css'},
                'MS-Office': {'docx', 'xlsx', 'ppt'},
                'Scripts': {'py', 'pyc', 'c++', 'cpp', 'c', 'java', 'js'},
                "Pdf&csv": {'pdf', 'csv'},
                'Application': {'exe', 'bat'}
                }this whitlist can be modifiednewWhitlist={
                'Media': {'mp3'},
                'Images': {'jpg','gif', 'png'},
                'Web': {'html', 'css'},
                'MS-Office': {'docx', 'xlsx', 'ppt'},
                'Scripts': {'py', 'pyc', 'c', 'java', 'js'},
                "PdfCsv": {'pdf', 'csv'}
                }

md.set_whitelist(newWhitlist)also importing pwd is necessary for Linux
Package: taskhawk
TaskHawk is a replacement for celery that works on AWS SQS/SNS and Google PubSub, while keeping things pretty simple and
straightforward. Any unbound function can be converted into a TaskHawk task.Only Python 3.6+ is supported currently.You can find the latest, most up to date, documentation atRead the Docs.Quick StartFirst, install the library:$pipinstalltaskhawkNext, set up a few configuration settings:Common required settings:TASKHAWK_QUEUE="DEV-MYAPP"When using AWS, additional required settings are:AWS_ACCESS_KEY=<YOURAWSKEY>AWS_ACCOUNT_ID=<YOURAWSACCOUNTID>AWS_REGION=<YOURAWSREGION>AWS_SECRET_KEY=<YOURAWSSECRETKEY>TASKHAWK_CONSUMER_BACKEND='taskhawk.backends.aws.AWSSQSConsumerBackend'TASKHAWK_PUBLISHER_BACKEND='taskhawk.backends.aws.AWSSNSPublisherBackend'In case of GCP, additional required settings are:TASKHAWK_CONSUMER_BACKEND='taskhawk.backends.gcp.GooglePubSubConsumerBackend'TASKHAWK_PUBLISHER_BACKEND='taskhawk.backends.gcp.GooglePubSubPublisherBackend'If running outside Google Cloud (e.g. locally), setGOOGLE_APPLICATION_CREDENTIALS.Within Google Cloud, these credentials and permissions are managed by Google using IAM.If the Pub/Sub resources lie in a different project, setGOOGLE_CLOUD_PROJECTto the project id.For Django projects, simple useDjango settingsto configure Taskhawk. For Flask projects, useFlask config.
For other frameworks, you can either declare an environment variable calledSETTINGS_MODULEthat points to a
module where settings may be found, or manually configure usingtaskhawk.conf.settings.configure_with_object.Then, simply add the decoratortaskhawk.taskto your function:@taskhawk.taskdefsend_email(to:str,subject:str,from_email:str=None)->None:# send emailAnd finally, dispatch your function asynchronously:send_email.dispatch('example@email.com','Hello!',from_email='example@spammer.com')DevelopmentGetting StartedAssuming that you have Python,pyenvandpyenv-virtualenvinstalled, set up your
environment and install the required dependencies like this instead of
thepip install taskhawkdefined above:$gitclonehttps://github.com/cloudchacho/taskhawk-python.git$cdtaskhawk-python$pyenvvirtualenv3.7.7taskhawk-python-3.7...$pyenvactivatetaskhawk-python-3.7$pipinstall-rrequirements/dev-3.7.txtRunning TestsYou can run tests in usingmake test. By default,
it will run all of the unit and functional tests, but you can also specify your ownpy.testoptions.$py.test$py.testtests/test_consumer.pyGenerating DocumentationSphinx is used for documentation. You can generate HTML locally with the
following:$pipinstall-e.[dev]$makedocsGetting HelpWe use GitHub issues for tracking bugs and feature requests.If it turns out that you may have found a bug, pleaseopen an issue
Package: taskhelm
= taskhelm =TaskHelm aims to be your primary tool for managing all of your tasks and
projects.  It helps you stop feeling overwhelmed.It builds on top of the excellent TaskWarrior command line task manager
by providing point-and-click interfaces for its functionality, and to
add functionalities common in other graphical task management programs.
We also look for novel new functionalities which enable you to better
manage an overly full plate.Key Features:Quickly set priority, wait, projects on multiple tasks.Associate notes with a task.Toggle buttons to filter tasks by priority.Easily browse tasks by project.Works concurrently with the task command line client.== Contributing ==Bug reports about defects in the software should be filed at the
taskwarrior website (you’ll need to register and log in):http://taskwarrior.org/projects/taskwarrior/issues/newMake sure to set ‘Target version’ to ‘taskhelm-1.0’.Patches to fix bugs, improve user documentation (in data/intial_tasks),
and make the code more portable are extremely welcomed - post them to
the bug tracker, or email them to me directly
(bryce@bryceharrington.org).Feature patches are ok too, but check with me before getting too deep.== Acknowledgments ==Special thanks must be given to the Getting Things GNOME! project.  I’ve
liberally borrowed design ideas and code snippets.  Taskhelm is not
directly derived from GTG but if Taskhelm is successful, it’s because it
stands on GTG’s shoulders.Much thanks also is due the Taskwarrior project; Taskhelm would not
exist without their continued encouragement and support.
Package: taskick
TaskickTaskick is an event-driven Python library that automatically executes scripts or any commands.
It not only automates tedious routine tasks and operations, but also makes it easy to developapplications.日本語版 READMEThe main features of Taskick are as followsAutomatically execute commands and scripts.Script execution timing can be managed in a configuration file (YAML).You can specify datetime and directory/file operations as task triggers.And,Execution schedules can be specified in Crontab format.Watchdogis used to detect directory and file operations.  Anyevents APIprovided by Watchdog can be specified in the configuration file.Installation$pipinstalltaskick
$python-mtaskick
Taskick0.1.6
usage:python-mtaskick[-h][--verbose][--version][--batch-loadBATCH_LOAD][--fileFILE[FILE...]][--log-configLOG_CONFIG]optionalarguments:-h,--helpshowthishelpmessageandexit--verbose,-vincreasetheverbosityofmessages:'-v'fornormaloutput,'-vv'formoreverboseoutputand'-vvv'fordebug--version,-Vdisplaythisapplicationversionandexit--batch-loadBATCH_LOAD,-bBATCH_LOADconfigurationfilescanbeloadinbatches--fileFILE[FILE...],-fFILE[FILE...]specifyconfigurationfiles(YAML)forthetasktobeexecuted--log-configLOG_CONFIG,-lLOG_CONFIGspecifyaloggingconfigurationfile
$python-mtaskick-V
Taskick0.1.6Toy ExampleHere is a toy-eample that converts a PNG image to PDF.
In this sample, the conversion script is automatically invoked when it detects that a PNG image has been saved to a specific folder.
The script converts the PNG to PDF and saves it in another folder.First, clonetaskick-example.gitclonehttps://github.com/atsuyaide/taskick-example.gitThen, execute the following command.$cdtaskick-example
$pipinstall-rrequirements.txt
$python-mtaskick-bbatch.yaml-vv
INFO:taskick:Loading:./config/welcome.yaml
INFO:taskick:Processing:Welcome_taskick
INFO:taskick:Startupoptionisselected.
INFO:taskick:Registered
INFO:taskick:Loading:./config/main.yaml
INFO:taskick:Processing:remove_files_in_input_folder
INFO:taskick:Startupoptionisselected.
INFO:taskick:Awaitoptionisselected.
INFO:taskick:Registered
INFO:taskick:Processing:png2pdf
INFO:taskick:Registered
INFO:taskick:Executing:Welcome_taskick
INFO:taskick:"remove_files_in_input_folder"iswaitingfor"Welcome_taskick"tofinish.
SunApr2423:25:43JST2022WelcometoTaskick!
waiting5seconds...
INFO:taskick:Executing:remove_files_in_input_folderYou can now launch an application that converts PNG images to PDF.When a PNG image is saved in theinputfolder, a converted PDF file is output in theoutputfolder.
Files in the input folder are automatically deleted at startup or every minute.The application consists ofwelcome.yamlandmain.yaml, and Taskick reads the two files indirectly by loadingbatch.yaml.
For details of the configuration files, see theproject page.
Package: taskin
Taskin provides simple task management. Tasks are simple callables
that will be executed using a pool of resources. The pool can be a
process or thread pool in order to achieve the required
concurrency. The suite of tasks is called aflow. A flow is defined
by defining a list of functions to run.Here is an example:import subprocess

from pprint import pprint

from taskin import IfTask, MapTask, do_flow


def foo(data):
    return 1


def check(v):
    return v == 1


def bar(data):
    return 'bar'


def baz(data):
    return 'baz'


def finish(data):
    result = {}

    for i in data:
        zone, ips = i
        result[zone] = ips

    return result


def dig_it(zone):
    cmd = 'dig +short %s' % zone
    print('running: %s' % cmd.strip())

    ips = subprocess.check_output(cmd.split()).strip().split('\n')
    return (zone, ips)


myflow = [
    foo,
    IfTask(
        check,
        [bar],
        [baz]
    ),
    MapTask(dig_it, [
        'ionrock.org',
        'google.com',
        'yahoo.com',
    ]),
    finish,
]


def main():
    results = do_flow(myflow, {})
    pprint(results)
    print('Done')

if __name__ == '__main__':
    main()Free software: BSD licenseDocumentation:https://taskin.readthedocs.org.
Package: task-indicator
A simple indicator application that helps do simple things with
TaskWarrior, like finding and adding tasks, starting and stopping them, track
current activity time, etc.  Supports task notes.Feature summary:Tray icon, red when tasks are running.Tray icon tooltip shows current activity time (near-icon label on Ubuntu).Tray menu gives quick access to 10 recently changed tasks.Tray menu item to quickly pull remote tasks (e.g., with bugwarrior).Search dialog helps find tasks by description, project, labels etc.Simple task editor to change description, priority, project and notes.For more complex operations CLI must be used.Seescreenshots.