Saravanan666/pypi-org huggingface dataset:
Package: tasks
TasksProof of concept for a simple task queue, with a focus on UX and clean internal design.Tasks can be installed through pip:pip3 install tasks, run withtasks.Status for i3Follow these steps to add the output ofstatusto your i3 status bar.Set up a cron job (crontab -e) that saves the status every minute.* * * * * /path/to/tasks status > $HOME/.tasks.statusConfigure i3 to use the provided status wrapper (installed alongside thetaskscommand.)...
    status_command tasks-i3status
...Ubiquitous CaptureIt is very useful to have a quick and low-friction way to add new items from anywhere. This can be achieved by combining tasks with a generic dialog tool and your window manager keybindings.Example using zenity and i3:bindsym $mod+t exec --no-startup-id bash -c "zenity --title 'Add TODO item' --text 'What needs to be done?' --entry --width 450 | xargs tasks addt"Note that you will want to use tasks >= 2.7.0 for this since it detects external modification of the state file.Automatic standup emailThestandupcommand shows (among other things) recently completed items. One use case is to send this list to your phone to have it ready for a daily standup. The repo contains a script (underscripts) to send stdin as an email with Mailgun which you can then combine with a cron job as follows.API_KEY=...
DOMAIN=...
EMAIL=...
30 9 * * tue,wed,thu,fri /path/to/tasks standup 1 | /path/to/mailgun.sh
30 9 * * mon /path/to/tasks standup 3 | /path/to/mailgun.shDevelopmentTo get started, have a look at the todo items for this project.make dev_install  # one-time setup
make todoContributingPull requests are welcome. Please do keep in mind that the code is heavily inspired by theElm architectureand consider the following guidelines.Avoid mutation whenever possible, take advantage ofPEP 448to create updated versions of collections instead.Side effects (and only side effects) should be inmain.py; all other modules should be limited to pure code.Avoid classes unless you have a really good reason for them (the code does not have any classes at the moment.)
Package: taskscordepm
Task Score CalculatorThe Task Score Calculator is a Python package that helps you prioritize your tasks by calculating a score based on the task's importance and effort.GoalThe goal of this package is to provide a simple and effective way to prioritize tasks. By assigning a score to each task based on its importance and effort, you can easily decide which tasks to tackle first.InstallationYou can install the Task Score Calculator via pip:pipinstalltaskscordepmUsageThe Task Score Calculator can be used in a Python program by importing the package and creating aTaskobject:fromtaskscordepm.task_scoreimportcalculate_task_scoretask_score=calculate_task_score(importance=3,effort=2)TheTaskobject has ascoreattribute that can be used to prioritize tasks:print(task.score)ContributingContributions to the Task Score Calculator are welcome! If you have any ideas for improvements or new features, please open a pull request.LicenseThis project is licensed under the MIT License. See theLICENSEfile for details.
Package: taskscore
Task OptimizerTask Optimizer is a Python package designed to help prioritize tasks based on their importance and required effort. It uses a simple yet effective scoring formula to determine which tasks should be tackled first, making your decision-making process more efficient and data-driven.InstallationTo install Task Optimizer, simply use pip:pipinstalltaskscoreUsageUsing Task Optimizer is straightforward. Import the calculate_task_score function from the package and provide the task's importance and effort levels as integers between 1 and 4.Example:fromtaskscore.optimizerimportcalculate_task_score# Define your task parametersimportance=3# Scale: 1 (least important) to 4 (most important)effort=2# Scale: 1 (least effort) to 4 (most effort)# Calculate the task scorescore=calculate_task_score(importance,effort)print(f"Task Score:{score}")Functionalitycalculate_task_score(importance: int, effort: int) -> float:importance: Integer between 1 and 4, where 4 is the most important.effort: Integer between 1 and 4, where 4 requires the most effort.Returns: A float value representing the task score. Higher scores indicate tasks that should be prioritized.ContributingContributions to Task Optimizer are welcome! Please read our contribution guidelines for details on submitting pull requests.LicenseThis project is licensed under the MIT License - see the file for details.
Package: taskscore2
Task PrioritizerTask Prioritizer is a Python package designed to help you decide which task to tackle first based on a simple scoring formula. This tool is particularly useful when you're balancing tasks with varying levels of importance and effort.InstallationYou can install Task Prioritizer directly from PyPi:pipinstalltask_prioritizerUsageTo use Task Prioritizer, you need to provide two key pieces of information for each task: its importance and the effort required to complete it. Both parameters should be between 1 and 4.Here's a quick example:fromtask_prioritizer.prioritizerimportcalculate_task_score# Example taskstasks={"Cleaning the house":(3,4),# (importance, effort)"Studying programming":(4,2),"Paying the bills":(4,1)}# Calculating and printing task scoresfortask,(importance,effort)intasks.items():score=calculate_task_score(importance,effort)print(f"Task:{task}, Score:{score}")Function Documentationcalculate_task_score(importance: float, effort: float) -> floatimportance (float): The importance of the task, should be between 1 and 4.
effort (float): The effort required to complete the task, should be between 1 and 4.
Returns (float): The calculated score of the task.
Raises ValueError: If importance or effort is not within the required range.ContributingContributions to Task Prioritizer are welcome! Please feel free to submit pull requests or open issues on the GitHub repository.LicenseThis project is licensed under the MIT License.
Package: taskseq
taskseq(WARNING: This package is pre-release and does not promise to work the same way in further releases until 1.0.0)Make taskwarrior tasks sequential easilylike this:taskseq 1,2,3--4,5--6--7In  this example, task 4 and 5 will both depend on 1, 2 and 3.
task 6 will depend on 4 and 5
task 7 will depend on 6
Package: taskserver
Taskfile ServerTaskfile Server is a web application, to run and manageTaskfileautomations.View Demo·Report BugThis project is heavily inspired byTaskfile.dev, and built on top of it's functionality.FeaturesFeatures include:a web user interfacespawning and managing tasksmodify task vars before runconfigurable taskfilesshow execution path (with full drill down)Features that are not included (yet):Authentication and Authorization of users (eg: local only)Multitenancy and user based run contexts, permissionsSecurity hardening and Threat Analysis report(s)Web User Interface (with dark mode support)We support both light and dark mode (auto detects from browser settings):Spawning and managing tasksThis project would be incomplete without the ability to spawn an actual task. To achieve this, we implemented a simple REST API that can handle invocations of tasks.Currently this is limited to the running context of the web server, soshould not be used in a production environment. It works great as a local-only solution to manage tasks outside of the command line.In a future release, we do envision implementing mechanisms to allow user permissions and context, but for now this is outside of the scope of the project.Extending task variablesYou can add custom task variables, to be attached to a specific run. This enables you to supply user input to the underlying task.Configurable TaskfilesTaskfiles can be viewed and modified (to some extent), with the focus being on:Adding or modifying taskincludes's (with some validations).Setting or overriding defaultEnvironment Variables.Defining globalTaskfile Variables.Showing execution breakdownOne nice feature we have is the ability to do a task execution breakdown. We use the--dryrun feature of taskfile's, to plan out and parse the execution, before running it.This has two advantages:For oversight: Know the commands you are about to execute...Track task execution: See where exactly the task fails, and for what reason.MotivationTaskfile works well for automating all kinds of tasks. Some features include:It's declared in a simple, machine-readable file format (YAML).Task varibales make it easy to define defaults and overrides.We can useincludes, making it composable / extensible.Task caching and run metadata make it efficient and fast.Good support for debugging, dry-run of tasks (with execution plans).As your taskfile's become larger and more complicated, it becomes harder to manage and understand.We try to tackle this problem by giving more advanced tooling around managing these task automations from a web interface, with the ability to track execution steps in near real time.
Package: tasks-generator
Tasks GeneratorA task generator, created for pupils, students and teachers for education.Table of ContentsInstallation
Usage
DocumentationInstallationThe project can be install via pippip install tasks-generatorUsageHere is an example of how you would generate logarithm tasks:from tasks_generator import logarithms#generate random task:answer, task = tasks_generator.logarithm_generator()
print(task)
print(answer)Also you can use any logarythm function from the library as an example use random_logarithm()answer, task = tasks_generator.random_logarithm()
print(task)
print(answer)Investigate other functions for your own.
A list of avilable functions:random_logarithm()
logarithm_multiplication()
logarithm_division()
random_logarithm_in_degree()
random_figure_in_logarithm_degree_multiplication()
random_figure_in_logarithm_degree_addition()
random_logarithm_in_degree_subtraction()
random_logarithm_with_fractions()
random_logarithm_with_fractions_in_degree()
random_logarithm_with_fractions_in_degree_subtraction()
random_logarithm_with_fractions_in_degree_addition()
logarithms_addition()
figure_in_logaritms_degree_addition()
figures_in_logaritms_degree_addition()
logarithms_subtraction()
logarithms_subtraction_new()
figure_in_logaritms_degree_subtarction()
figures_in_logaritms_degree_subtarction()
logarithm_addition_of_divisions()
logarithm_subtraction_of_divisions()
logarithm_generator()Use [answer, task] variablesDocumentation#ToDo
Package: tasksource
tasksource600+ curated datasets and preprocessings for instant and interchangeable useHuggingface Datasets is an excellent library, but it lacks standardization, and datasets often require preprocessing work to be used interchangeably.tasksourcestreamlines interchangeable datasets usage to scale evaluation or multi-task learning.Each dataset is standardized to aMultipleChoice,Classification, orTokenClassificationtemplate with canonical fields. We focus on discriminative tasks (= with negative examples or classes) for our annotations but also provide aSequenceToSequencetemplate. All implemented preprocessings are intasks.pyortasks.md. A preprocessing is a function that accepts a dataset and returns the standardized dataset. Preprocessing code is concise and human-readable.Installation and usage:pip install tasksourcefromtasksourceimportlist_tasks,load_taskdf=list_tasks(multilingual=False)# takes some timeforidindf[df.task_type=="MultipleChoice"].id:dataset=load_task(id)# all yielded datasets can be used interchangeablyBrowse the 500+ curated tasks in tasks.md (200+ MultipleChoice tasks, 200+ Classification tasks), and feel free to request a new task. Datasets are downloaded to $HF_DATASETS_CACHE (like any Hugging Face dataset), so ensure you have more than 100GB of space available.You can now also use:load_dataset("tasksource/data","glue/rte",max_rows=30_000)Pretrained models:Text encoder pretrained on tasksource reached state-of-the-art results:🤗/deberta-v3-base-tasksource-nliTasksource pretraining is notably helpful for RLHF reward modeling or any kind of classification, including zero-shot. You can also find a large, and a multilingual version.u/conceptofmindalso trained Llama on tasksource:🤗/conceptofmind/Tasksource-Open-Llama-13btasksource-instructThe repo also contains some recasting code to convert tasksource datasets to instructions, providing one of the richest instruction-tuning datasets:🤗/tasksource-instruct-v0tasksource-label-nliWe also recast all classification tasks as natural language inference, to improve entailment-based zero-shot classification detection:🤗/zero-shot-label-nliWrite and use custom preprocessingsfromtasksourceimportMultipleChoicecodah=MultipleChoice('question_propmt',choices_list='candidate_answers',labels='correct_answer_idx',dataset_name='codah',config_name='codah')winogrande=MultipleChoice('sentence',['option1','option2'],'answer',dataset_name='winogrande',config_name='winogrande_xl',splits=['train','validation',None])# test labels are not usabletasks=[winogrande.load(),codah.load()])#  Aligned datasets (same columns) can be used interchangablyContact and citationFor help integrating tasksource into your experiments, please contactdamien.sileo@inria.fr.For more details, refer to thisarticle:@article{sileo2023tasksource,title={tasksource: Structured Dataset Preprocessing Annotations for Frictionless Extreme Multi-Task Learning and Evaluation},author={Sileo, Damien},url={https://arxiv.org/abs/2301.05948},journal={arXiv preprint arXiv:2301.05948},year={2023}}
Package: tasks-py
tasks===__tasks.py__ is a simple and fast task queue for executing multiple tasks in parallel. All you need to do is specify the task as a simple function that takes an argument and you get instant parallelism.Based on eventlet, multiprocessing and redis.It is ideal for executing multiple network bound tasks in parallel from a single node, without going through the pain of setting up a map reduce cluster. It uses both processes and green threads to extract the maximum out of a single node setup.Installation-----------1. Install redis and start the server, **tasks** uses redis for queueing jobs. If you already have a redis server setup, call `tasks.set_redis` and pass a redis connection object with a different database/namespace from what you normally use in your application.2. Install the redis-py and eventlet libraries.`pip install redis eventlet`3. Install tasks or copy this package to your source code.`pip install tasks-py`Usage-----Import `tasks` and call eventlet's monkey patch function in the first line of your module. Call `tasks.set_func` to register your function. This function will be receiving a string as an argument and its return value will be ignored. To indicate failure of the task, raise an error or exception within the function. Call `tasks.main()` to get the interactive command line options.import eventleteventlet.monkey_patch()import tasksfrom urllib2 import urlopendef fetch(url):f = open('/tmp/download', 'w')body = urlopen(url).read()f.write(body)f.close()tasks.set_func(fetch)tasks.main()Now to add jobs, create a file with one argument per line and use this command.`$ python yourfile.py add <list_of_jobs.txt>`To start (or restart) the job processing (do this in a **screen** session or close the input stream):`$ python yourfile.py run`**tasks** has resume support, so it will start where you left off the last time.To view the current status while it is running:`$ python yourfile.py status`Once you are done, you can clear the logs and the completed tasks by calling reset.`$ python yourfile.py reset`See the code or the test.py file for more information. Feel free to fork and modify this.----**Author** : Vivek Narayanan <<vivek@vivekn.com>>**License** : BSD(C) Vivek Narayanan (2014)
Package: taskstack
taskstack介绍任务集散中心、管理运行机构软件架构软件架构说明安装教程xxxxxxxxxxxx使用说明xxxxxxxxxxxx参与贡献Fork 本仓库新建 Feat_xxx 分支提交代码新建 Pull Request特技使用 Readme_XXX.md 来支持不同的语言，例如 Readme_en.md, Readme_zh.mdGitee 官方博客blog.gitee.com你可以https://gitee.com/explore这个地址来了解 Gitee 上的优秀开源项目GVP全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目Gitee 官方提供的使用手册https://gitee.com/helpGitee 封面人物是一档用来展示 Gitee 会员风采的栏目https://gitee.com/gitee-stars/
Package: taskstodo
taskstodotaskstodo is a command-line application for managing Google Tasks, allowing you to view, create, update and delete task lists and their associated tasks. taskstodo can also perform a two-way sync between Google Tasks andcalcurse.Installationpip install taskstodoConfigurationCreate new Google CloudprojectEnableTasks APICreate new OAuth 2.0 client IDcredentialsDownload JSON file of credentialsCopy file to~/.config/taskstodo/credentials.jsonConfigureOAuth consent screenas an external user typeUsageCreate task list:taskstodo list -c <list_title>Create task:taskstodo task -c <task_title> [-n <note>] <list_title>Show task lists:taskstodo show-listsShow tasks:taskstodo tasks <list_title>Sync calcurse and Google Tasks:taskstodo sync-calcurse <list_title>Show help:taskstodo -h
Package: taskthread
Python thread module to repeat an predefined task on a thread mulitple times.
A TaskThread is useful when a task needs to be repeated several times on
a separate thread. Normal usage of the threading.Thread class would call for
creation of a new thread each time the same task needs to be run. This module
allows for repetitive tasks to be run multiple times on the same thread by having
the thread wait until the task needs to be executed again.Provided Classestaskthread.TaskThread`A sub-class ofthreading.Threadthat may execute a single task
multiple times without the overhead of starting a new thread.taskthread.TaskInProcessExceptionException that is thrown if a task is started on a thread that is
already executing.Installationtaskthreadmay be installed by executingpip install taskthread.LinksdocumentationsourceChangesv1.4ADDTimerTaskclass that runs a repetitive task on a taskthread.v1.3Change task loop to support python 2.6.v1.2Refactor the module so classes are defined in __init__.py.v1.1ADDTaskThread.join_taskmethod that waits for the currently executing.
task to complete.v1.0First release
Package: tasktiger-admin
tasktiger-adminis an admin interface forTaskTigerusing flask-admin. It
comes with an overview page that shows the amount of tasks in each queue for
each state (queued, active, scheduled, error). It lets you inspect queues and
individual tasks, as well as delete and retry tasks that errored out.(Interested in working on projects like this?Close.iois looking forgreat engineersto join our team)Quick start%tasktiger-adminThis will listen on the default port (5000) and connect to the default Redis
instance. Additional settings are available (see--helpswitch for
details).For a more advanced integration,tasktiger-admincan be integrated in a Flask
app with an existing flask-admin by using the provided view intasktiger_admin.views.TaskTigerView.Integration LinksTheTaskTigerViewclass takes an optionalintegration_configparameter
that can be used to render integration links on the admin Task Detail page.
These can be used to easily navigate to external resources like logging
infrastructure or a Wiki.integration_configshould be a list of tuples
that specify the integration name and URL template.The URL template supports three variables:task_id: Current task idexecution_start: Execution start time minus a 10 second bufferexecution_failed: Execution failed time plus a 10 second bufferExample integration config that points to a logging website.integration_config=[('Logs','https://logs.example.com/search/?''task_id={{ task_id }}&''start_time={{ execution_start }}&''end_time={{ execution_failed }}')]
Package: task-timer-birdhouses
TaskTimerTaskTimeris a Python class used to schedule and keep track of upcoming actions. You can useTaskTimerto automatically calculate and execute when a given function will be executed based on a specified duration in seconds.UsageTo use the TaskTimer class, you need to initialize an instance of the class with an action name, function and the amount of seconds until the function will be executed.from task_timer_birdhouses import TaskTimerInitialize a new TaskTimerdef greet(name):
    print(f"Hello, {name}!")

task_timer = TaskTimer('greeting', 5, greet, args=["John"])Print the next action time in a human-friendly formatprint(task_timer.human_friendly())

# Output
June 21, 2023, 02:11 AMPrint the next action time as a datetime objectprint(str(task_timer))

# Output
2023-06-21 02:11:05.046499Print all upcoming actionsprint(TaskTimer.get_upcoming_actions())

# Output
{'send_email': 'June 21, 2023, 02:11 AM'}In the example above, 'send_email' is the action we're scheduling, and 3600 is the number of seconds until the action will be executed.Other use casesIf you just want to add the sleep time in seconds to the current time you can do this:task_timer = TaskTimer('test', 5)

    print(task_timer)
    # Output
    2023-06-21 13:03:53.582599

    print(task_timer.human_friendly())
    # Output
    June 21, 2023, 02:11 AMThis might be useful if you use a different setup for executing your functions, and you only want to display the time a function will be executed.InstallationThis package can be installed using pip:pipinstalltask-timer-birdhouses
Package: tasktools
Asyncio Tasks ToolsTheasynciomodule,
from standar library since 3.4, is basic for the coroutines and
tasks. You need to study first this module because it's not really easy.This module allows you to work with asyncio coroutines and schedule some
tasks.These tasks can be build in a really generic way, like an independet loop.The tools in this module can help you to manage your coroutines and succeed.The 'how to use' ondocumentationfile.How to installTo install, in your virtualenvironment, execute pip:pip install git+[url]Or, using setup:python setup.py tasktools
Package: task-tracking
task-trackerInstallCurrently, task-tracker is not available on pip or conda. It will be
accessible via the command below after release, whenever a stable
version is created.pipinstalltask_trackerHow to useExample on how to use task-tracker on alasagne recipe.NoteYou can find the notebook and the results of thelasagne recipeathttps://github.com/KonKob/task-tracker/blob/main/test_data.This is how the landing page looks like after completing a trial:Whenever the trial is started here, an audio recording is started,
that can be transcribed after completion of the trial.At the right you see the timeline of tasks over the session so far.
You can update it at any time.In the middle of the landing page, you can add a description manually
to running or finished tasks.The proband metadata can be saved at any time by clickingExport proband metadata.To pause all tasks, you can clickStart pause for allduring a
running trial.The proband metadata can be entered in the following mask:Tasks, that you want to track, are shown in different tabs.Whenever you click on a task, this task is started and another task
running in this tab is ended. You can end a task by clickingNo task runningas well.If you find, that you forgot a tasks, you can add it by entering the
name in the grey lineOtherand then clicking the grey buttonOther.To pause a task, just hitStart pause.Exporting the results creates excel files.fromtask_tracker.utilsimportload_trialtrial=load_trial("../test_data/2023-08-07_17.43.23_0000_Chef/")trial.tasks_dataframe.head()<style scoped>
    .dataframe tbody tr th:only-of-type {
        vertical-align: middle;
    }

    .dataframe tbody tr th {
        vertical-align: top;
    }

    .dataframe thead th {
        text-align: right;
    }
</style>laneduration_in_stask_numbertask_namestart_timeend_timedescription_00Kitchen appliances1.352812Pause203.6099204.9627220°C1Kitchen appliances52.89526Stove89.5415142.4367NaN2Kitchen appliances111.968712Oven142.4370255.7585220°C3Ingredients28.04700Onions10.374938.4219NaN4Ingredients19.84562Carrots39.585059.4306NaNFor visualization, several plots are created.The cumulative duration spent in certain tasks can be shown as bar and tie plots.It can also be shown, how much time was spent in tasks running in parallel to other tasks.