search

dagraham / etm-tk

event and task manager
https://pypi.org/project/etmtk/
67 stars 13 forks source link

Feature Request #60

Open stef204 opened 8 years ago

stef204 commented 8 years ago

etmtk 3.2.27 on linux 4.5.4

Currently, when one schedules a group task and sets an alarm, the alarm reminder box is triggered for ALL sub-tasks; so that if one has 6 sub-tasks, each a separate job, one gets six alert reminder boxes all at once.

Request is that each @j is addressed separately so that a reminder or alarm @a can be set for each sub-task individually.

dagraham commented 8 years ago

Could you post an example of a group task that causes the problem?

stef204 commented 8 years ago

+ do top task @s 2016-06-08 10am @a 0m: m @b 1 @c whatever @t whatever @j do this first &q 1 @j do this second &q 2 @j do this third &q 3 @q 1 @z some time zone

stef204 commented 8 years ago

I did not add the @q 1 myself--it was added automatically by etm! I wondered about it and even tried to remove it but etm keeps putting it back. It behaves this way on all of my group tasks.

For the rest, I am not sure why you bring up the issue of & instead of @ since I seem to be using &.

The @t and @c @b in this particular case are there for the whole group and I did not intend to have individual ones for each sub-task, although I could (if etm accepts that.)

PS your reply looks weird, I see url's all over the place, is that what you intended? Possibly you need to use backticks around the @ otherwise I believe github starts to tag users, etc.

PPS It is not impossible that the alert reminder code which you added a few months ago does not take into account group task scenarios and may need to be modified to account for these, individually.

therden commented 8 years ago

_Stef:_ I can't reproduce the behavior of ETM auto-inserting an @q 1 into a new or edited item.

Are you certain that you don't have an @q 1 (which you probably intended to be &q 1) elsewhere in the item's text? (If so, it would sort to the end of the item when you Save.)

_Dan_: ETM presently moves at least two @ key-value pairs (@z and @q) to the end of a task group item (after the final job) upon Save.

I don't know if any other @ key-value pairs are treated similarly.

dagraham commented 8 years ago

The @q 1 is a bug - I thought you were putting it in and wondered why. The issue of @a attaching to each component task is, you could almost say, by intent - meaning that I never thought about it. In fact, @b suffers from the same issue. I suppose that the desired behavior would be to create just one alert and one beginby, both for “top task”. Yes? When &a and/or &b entries are placed within individual jobs, they should be added to any provided for the group task itself. Yes?

I’m still hoping you will give me an example of a group task with individual alerts as you would like to create it.

dagraham commented 8 years ago

I get the @q 1 added myself, but only to group tasks such as Stef’s example. For me, it only gets added when the group task is opened for editing in etm. Stranger still, if I enter a timestamp myself, such as @q now, then it gives saved, as it should, as @q 20160608T951. But if I open it for editing, it’s changed to @q 1. I’ll figure it out and fix it eventually.

On Jun 8, 2016, at 9:45 AM, therden notifications@github.com<mailto:notifications@github.com> wrote:

Stef: I can't reproduce the behavior of ETM auto-inserting an @q 1 into a new or edited item.

Are you certain that you don't have an @q 1 (which you probably intended to be &q 1) elsewhere in the item's text? (If so, it would sort to the end of the item when you Save.)

Dan: ETM presently moves at least two @ key-value pairs (@z and @q) to the end of a task group item (after the final job) upon Save.

I don't know if any other @ key-value pairs are treated similarly.

— You are receiving this because you commented. Reply to this email directly, view it on GitHubhttps://urldefense.proofpoint.com/v2/url?u=https-3Agithub.com_dagraham_etm-2Dtk_issues_60-23issuecomment-2D224593125&d=CwMCaQ&c=imBPVzF25OnBgGmVOlcsiEgHoG1i6YHLR0Sj_gZ4adc&r=cjSGCFDvj7Zy-plAeyNJjDIBRBeNSNbZaJLNyuBRtxo&m=bHwEwOLoSo0hT23YevgY7uOnL2UOmmcmX6iP6hPUktQ&s=29c9hGTDZtxOMprt47kxi4CBnbwKfBpS2_woNCAe4hA&e=, or mute the threadhttps://urldefense.proofpoint.com/v2/url?u=https-3Agithub.com_notifications_unsubscribe_AA-5FDpws0IiR5EvJc-2DqKfYAgReN7oY0lxks5qJsdcgaJpZM4Iso5K&d=CwMCaQ&c=imBPVzF25OnBgGmVOlcsiEgHoG1i6YHLR0Sj_gZ4adc&r=cjSGCFDvj7Zy-plAeyNJjDIBRBeNSNbZaJLNyuBRtxo&m=bHwEwOLoSo0hT23YevgY7uOnL2UOmmcmX6iP6hPUktQ&s=GlQwia7_GMqdUfxdqUka6MlkHXU3DbyT4KgE4oamGzA&e=.

stef204 commented 8 years ago

You replies here are very difficult to read, as they are rife with really long url's like:

https://urldefense.proofpoint.com/v2/url?u=https-3A__github.com_t&d=CwMCaQ&c=imBPVzF25OnBgGmVOlcsiEgHoG1i6YHLR0Sj_gZ4adc&r=cjSGCFDvj7Zy-plAeyNJjDIBRBeNSNbZaJLNyuBRtxo&m=HC-z1gyA5-7itkT4xNeZBpQ1IGXCbZrGeq5URC3hj38&s=9Nm2LpSUyCR4IN7ufHEVKwjCXg2ginv9g-RFgnz8vUw&e

Is that what you intended?

stef204 commented 8 years ago

Here is an simple/brief example of the feature I would like.

I used &s and &a but these do not exist (yet) as I understand.

There are other more complex scenarios, I'm sure. But this below would be an improvement, basically due time and alarms treated individually for each task/sub-task in the group.

+ do top task @s 2016-06-18 10am @a 0m: m @b 1 @c whatever @t whatever @j do this first &q 1 &s 2016-06-09 2pm &a 0m: m @j do this second &q 2 &s 2016-06-14 4pm &a 0m: m @j do this third &q 3 &s 2016-06-17 5pm &a 0m: m @z some time zone

dagraham commented 8 years ago

No, evidently it happens if I respond to an email. I only meant to indicate that I have the same problem with spurious @q 1 entries that you do.

dagraham commented 8 years ago

How about replacing this:

  • do top task @s 2016-06-18 10am @a 0m: m @b 1 @c whatever @t whatever @j do this first &q 1 &s 2016-06-09 2pm &a 0m: m @j do this second &q 2 &s 2016-06-14 4pm &a 0m: m @j do this third &q 3 &s 2016-06-17 5pm &a 0m: m @z some time zone

with this:

It expresses exacty the same task starting datetimes and alarms but relative to the group @s entry and could be turned into a repeating group task by just adding, e.g., @r m, to the top line.

stef204 commented 8 years ago

OK, sorry to mention the url problems but wasn't sure what was going on--I guess it happens only when replying via email.

OK, you confirm the @q 1; it is a bug. I do not know if it has any impact on the task group or not....

Anyway, one way to go about it could be to have all elements/values inserted on top task/ top line automatically apply to sub-tasks UNLESS a sub-task has its own elements/values defined unto itself, in which case these individually defined elements/value would take precedence over those of the top task's.

That way, if one wants to apply some elements/values to ALL tasks/sub-tasks, it if sufficient to add them for top task; BUT if one wants more granularity, one can add whatever elements to each sub-task which will then have its own....

Not sure if I am clear or not.

stef204 commented 8 years ago

Sorry our replies just crossed.

When I create the group task, I don't want to be calculating how many days and hours before top task is due to set my alarms, etc. 8 days 20 hours would be tedious.

I just would like to pick a date/time and be done with it. If this is available with some kind of fuzzy dating, etc., and it produces result above, fine. If not, I would really want to be able to state: @j do this second &q 2 &a 2016-06-15 2pm

dagraham commented 8 years ago

Well, etm will calculate those for you - tools/date and time calculator - or you could just stick to days. ;-)

I. myself, don't have much enthusiam for working on this unless repetition can be incorporated in a transparent manner. Most group tasks that I need are ones that repeat - the steps to prepare my tax returns each year, for example - otherwise I would probably use a series of separate tasks with a shared tag or keyword. Even in the absence of repetition, I might want to change the due date and would much prefer the individual jobs to adjust automatically than to require my editing.

stef204 commented 8 years ago

Individual tasks just aren't the same; IMHO task groups should really be part and parcel of a task manager.

I don't see any problems with tasks repeating or not (i.e. they should repeat only if desired.)

How do I create the sub-task in a way that I don't have to calculate how many days and hours prior to top line task my alarm trigger time is for a set day and time?

i.e. how do I write the task so alarm for sub-task 2 gets triggered on 2016-06-17 5pm? Without having to calculate that is x day and x hours before top line task is due, so without having to write it&s 0d17h &a 0m: m ?

Edit: Sorry, re-reading your reply, you are suggesting using the date/time calculator..... I guess it can be done but not convenient in this situation. Being able to directly write the day and time would be significantly better.

Also, please and vital: you've got to remove those alarms defined for top tasks triggering an alarm and alert dialog for each sub-task. Imagine you have 8 sub-tasks? I get 8 alert dialog popping up!! That is just..... wrong ;)

therden commented 8 years ago

Task groups would be most useful for multi-step processes that are performed more than once for me also -- and that in such cases, using relative datetime values for &s will maximize that re-usability. But it'd be nice to also support direct-assigned datetime values for other use cases like those stef204 apparently has in mind.

Am I missing something? Are these two approaches irreconcilable? Or hard to implement together?

Maybe when the 'root' of the Task group item contains @s and@r values, and one or more jobs have direct-assigned &s datetime values which are incompatible, then ETM could raise an error message and let the user sort it out (just as it would do for other items with an @r rule and incompatible @f or @- values.)

stef204 commented 8 years ago

Dan, you could survey your user base to see which view or use case would prevail re. group tasks. On my side, and with respect, repetition of such is not a priority at all since I view task groups as very much idiosyncratic which is the beauty of having them as a very specific tool, like a micro "project management" if you will, I think that also would go along with GTD's approach.

Here is a very simple and "practical" example:

+ Client A Presentation @s 2016-06-30 3pm @a 21d, 0m: m @j research sector "A" &q 1 @j extract essential/vital points of sector "A" to use as ppt headers &q 2 @j assign headers to team &q 3 (Note: Here I would like to split this into additional sub-tasks, taskwarrior style, like this--I use "@jj" and "&qq" to indicate additional split:) @jj Bill -> Headers 1 to 5 &qq 1 @jj Mary -> Headers 6 to 8 &qq 2 @jj Rob -> Headers 8 to 12 &qq 3 @j write executive summary, etc. &q 4 @ review presentation &q 5 @ discuss presentation with team &q 6 @ final approval &q 7 @j mail presentation to client A &q 8 @p 3 @z some time zone

I would like to be able to assign a specific date/time and alert/alarm to each sub-task so I have it all planned out and am not slacking or getting behind on schedule.

That's it.

There is no chance I will repeat this specific task group but there is 100% chance I will have similar ones in the future.

However, if you take simple issues such as painting kitchen which first needs stripping, some electrical work and whatever else, it can quickly turn into a small project (i.e. GTD definition) and have a task group for it is significantly better than having 10 separate tasks.

I think that all of this should just re-use existing features and code, adding the dependency or chain linkage--which I believe is the focus of grouping tasks. Why reinvent the wheel when almost all of the features already exist in ETM?

dagraham commented 8 years ago

Here's a slightly extended version of your example which, I note, is not just a simple sequential list of jobs anymore but has sprouted branches. For the time being, ignore the labels.

stef2

As usual, arrows point toward prerequisites so that, for example, getting input from Mary requires that she has been given a header assignment which, in turn, requires that the headers have been prepared. Your example is interesting in that it cannot be represented either as a tree or an outline since the node PPT_HEADERS has multiple parents.

How to represent this structure in etm? Using your @jj and &qq tricks might seem simple to you but would require a complete rewrite of the way etm parses data entries and isn't going to happen. There is, however, a relatively simple alternative. Note that I've attached made-up labels to the left side of each node, e.g., M for Mail, AB for Assign to Bill, RS for Research, etc. The labels don't matter as long as they are unique. Using these labels, I've next attached a list of the prerequisites to the right side of each node. Since Research has no prerequisites it gets an empty list. Summary, on the other hand, gets the list [IB, IM, IR]. You get the idea. Here would be the corresponding job entries using "&x" for the label and &q for the list of prerequisites.

@j Mail &x M &q A
...
@j Summary &x S &q IB, IM, IR
@j Input from Bill &x IB &q AB
@j Assign to Bill &x AB &q H
...
@j PPT Headers &x H &q RS
@j Research &x RS

This seems pretty simple to me - even simpler than the number pairs which, of course, would not work in this case anyway. It also allows the assignments to be made in any order and the inputs to be collected in any order, provided only that the relevant assignment has been made. Your @jj entries, on the other hand, suggest that the assignments have to be made in a particular order.

Note that you don't need to construct a graph to do this. Just write down the list of jobs, attach unique labels to each using &x and then, using these labels, add a list of the immediate prerequisites for each job using &q.

stef204 commented 8 years ago

Dan, thanks a lot for your feedback.

How to represent this structure in etm? Using your @jj and &qq tricks might seem simple to you but would require a complete rewrite of the way etm parses data entries and isn't going to happen.

Firstly, I take nothing for granted, nothing seems simple or easy to me; and I also realize this is open source software and based on your own good will and work, for which--as you already know--I (and I'm sure, all ETM users) am grateful and appreciative.

I have no "demands" or expectations; I am just trying to make suggestions or comments re. user experience and these may or may not add value.

Second, and to get back to subject at hand, I think you've got something in the way you are proposing the implementation. I don't know how simple or difficult it would be and/or how viable (meaning user friendly enough so it does get used by most ETM users) but this will only become apparent via testing it.

I believe the solution might be keeping the KISS principle, yet having the right amount of sophistication to get the job done. You're in the best position to strike that balance/know what it would entail in terms of coding.

Finally, this thread started based on the alert/alarm set for top level task getting triggered on each and all of the sub-tasks, which was/is bothersome.

My first target was to get rid of that "feature" and be able to assign individual alerts for each sub-tasks.

The additional splitting came about by posting a "real life" example. Not sure if these 2 issues have to be addressed as a whole or one after the other. But I sure would settle for the first target at the moment. if at all possible.

therden commented 8 years ago

Do I correctly understand the following as your current proposal re: task groups?

If so, this is exciting: it looks to have all the power of your earlier coordinate-based &q proposal and more, while being as easy to use and update as ETM's current approach of assign ordinal values to &q.

dagraham commented 8 years ago

Yes, what you say is exactly right and, in fact, a rather nice summary.

dagraham commented 8 years ago

What if you could enter something like &s 5p -7 meaning 5pm 7 days before the @s date? This is close to what is currently supported for entries in @s.

stef204 commented 8 years ago

What if you could enter something like &s 5p -7 meaning 5pm 7 days before the @s date? This is close to what is currently supported for entries in @s.

Sounds fine.

dagraham commented 8 years ago

The job alerts and group task structure are inseparable since both will require backward incompatible changes in the etm data structure and will thus require a major version change. I would really like to get the whole story right before rolling this out and it will take a while to do so.

Meanwhile, you seem annoyed by the current behavior of etm regarding the alerts, but logically when you set an alert and all 8 jobs are due at the same time, what behavior would you like? Just one alert for the overall task? One alert for each job that is currently available, i.e., has no unfinished prerequisites? Or what? I'm guessing that you would want one alert for the task group itself unless all jobs have been finished and then any applicable alerts set for as yet unfinished jobs without unfinished prerequisites. It would really be more helpful to me if you could think through and describe the behavior you want than just disparage the current behavior. I always appreciate constructive comments but have been a little put off by some of your recent remarks.

stef204 commented 8 years ago

You closed the issue, so I do not know if you will get alerts as to a new post/reply or not.

Not all 8 jobs are due at the same time. If the top task is due 8 days from now, then perhaps the sub-tasks are due prior to that, to keep it simple, job 1 due 1 day from now, job 2 due 2 days from now, etc. That's where I would like to be able to set individual due times and corresponding alarms/alerts for each job. I have not found a way to do that.

As far as my comments, sometimes I try to be facetious, I guess the humor is lost/only apparent to me. I can refrain. No offense intended whatsoever, quite the contrary, I have praised you for your work and even if the current situation of getting 8 alert popups does annoy me, so what? I can live with it believe me and it's very minor and since all of this is based on your hard work (and free I might add) I have nothing but positive things to say, believe me.

As far as what I would want, I find it difficult to frame it without understanding what you are willing to do or consider value-adding. I cannot make "demands" that I want this or that.

I have no idea what we are now addressing: just the multiple alerts or also considering the splitting/branching off into additional nodes, etc.?

A) If we stay with the alerts issue only, I would like to be able to set a due date/time/alert(alarm) for the top line task, as well as individually for each sub-tasks. To keep it simple, that's it.

B) The prerequisites you mention go into a more in-depth design (I believe) of additional splitting into more nodes or branches, with prerequisites, etc. And, I do not know whether this is 1) vital at this point and 2) being considered for development, I do not know how much work would be involved, etc.

Again, I would be happy if we kept things simple and just went with a simple resolution of A) above, if that is possible.

dagraham commented 8 years ago

I closed it because I thought we had reached a meeting of the minds about how to proceed and no further discussion was needed. The plan as I see it is given below. Please let me know if you see any problems with it:

  1. Soon. Correct the behavior of both @a and @b to create only one instance for the main task group. Both require an @s entry, both set instances relative to the @s entry and both are active if the task group has any unfinished tasks.
  2. Later. Add &s, &a and &b elements for @j entries. Both &a and &b require &s and both set triggers for datetimes relative to the datetime specified by &s, thus mirroring the current usage for @s, @a and @b.
    • These triggers are active whether or not the relevant job has unfinished prerequisites but are not active if the relevant job has been completed.
    • The entry for &s supports fuzzy parsing, including relative datetimes, so that, e.g., &s 5p -7 would represent "5pm 7 days before the date specified in the @s entry" if @s is provided and "7 days before today" otherwise. I.e., relative datetimes are relative to @s if it is given and relative to the current datetime otherwise.
    • Jobs without an &s entry implicitly share the @s entry, if there is one.
    • Repetition for the group task is supported using @r for the task group itself. This provides repetition for component jobs as well provided that relative datetimes are used in any &s entries.
  3. Still Later. Add &x "handles" to @j entries and change the behavior of &q to require a comma separated list of "handles" of immediate prerequisites.
dagraham commented 8 years ago

I'm reopening this because it is proving more difficult than I thought.

dagraham commented 8 years ago

After a lot more thinking about this, I'm leaning toward the following and would appreciate reactions.

Consider a simple example of three tasks to be completed sequentially in the order given. In the new setup, this could be entered as follows:

- sequential task group @s +3 12p @a 3d @b 3
@j First    &a 3d3h
@j Second   &a 3d2h
@j Third    &a 3d1h

or, equivalently, as:

- sequential task group @s +3 12p @a 3d @b 3
@j First    &i 1        &a 3d3h
@j Second   &i 2 &p 1   &a 3d2h
@j Third    &i 3 &p 2   &a 3d1h

In the absence of &i id and &p prereqs entries, etm would generate them implicitly so, internally, these would be the same to etm. Either way, there would be no prereqs for First, First would be the only prereq for Second and Second would be the only prereq for Third. For more complicated, non-sequential structures, it would be necessary, of course, to add the &i and &p elements explicitly.

Treatment of @s, @a, @b, &s, &a and &b elements

therden commented 8 years ago

I like the idea of having these two alternatives for structuring Task Groups, and am really looking forward to using both.

Everything you've described above looks great, with one exception: the limitation that a &a alerts and &b beginbys will only be active if the job they are associated with is available. I would strongly prefer the opposite behavior-- that alerts and beginbys would activate even when all the job's prerequisites have not been completed -- in fact, I think that in such circumstances they would have more-than-usual value.

-Thomas

On Tue, Jun 21, 2016 at 5:56 PM, dagraham notifications@github.com wrote:

After a lot more thinking about this, I'm leaning toward the following and would appreciate reactions.

Consider a simple example of three tasks to be completed sequentially in the order given. In the new setup, this could be entered as follows:

  • sequential task group @s +3 12p @a 3d @b 3 @j First &a 3d3h @j Second &a 3d2h @j Third &a 3d1h

or, equivalently, as:

  • sequential task group @s +3 12p @a 3d @b 3 @j First &i 1 &a 3d3h @j Second &i 2 &p 1 &a 3d2h @j Third &i 3 &p 2 &a 3d1h

In the absence of &i id and &p prereqs entries, etm would generate them implicitly so, internally, these would be the same to etm. Either way, there would be no prereqs for First, First would be the only prereq for Second and Second would be the only prereq for Third. For more complicated, non-sequential structures, it would be necessary, of course, to add the &i and &p elements explicitly.

Treatment of @s, @a, @b, &s, &a and &b elements

  • If @s were given in the group, it would become the default for each job. Fuzzy parsing including relative datetimes is allowed. In the example above, the task group is due 3 days from today at 12pm.
  • If @a and/or @b were given in the group (both require @s), the alert and/or beginby would only be active for available jobs, i.e., jobs without unfinished prerequisites. In the example above, only the first task would be available, the @a entry would set an alert for it at 12pm today and the @b entry would set a beginby for it beginning at 12am today.
  • Fuzzy parsing including relative datetimes is also allowed for &s. If &s were given as a relative datetime it would be relative to @s, if given, and otherwise relative to today.
  • if &a and/or &b were given in a task (both require either @s in the group or &s in the same task), the alert and/or beginby would be relative to &s if given and otherwise to @s and the alert and/or beginby would only be active if the job were available. In the example above, there would thus be two active alerts, both for First: one from @a for 12pm today and another from &a in First for 9am today. If First were finished then Second would become available and there would only be two active alerts, both for Second with one from @a at 12pm today and another from &a in Second for 10am today.

— You are receiving this because you commented. Reply to this email directly, view it on GitHub https://github.com/dagraham/etm-tk/issues/60#issuecomment-227584824, or mute the thread https://github.com/notifications/unsubscribe/ADBtKTrp83zbUWffzgVWa0hAceCL3ENRks5qOF4igaJpZM4Iso5K .

dagraham commented 8 years ago

Well, that’s exactly what Stef objected to in the first place - a task group with an @a entry that simultaneously triggered alerts for every job.

stef204 commented 8 years ago

@dan yes, please do not make a top level alarm trigger multiple alerts for all sub-tasks at once, that just does not work; and I cannot see the value. I think you've got the right idea as you described in your post above. more granularity = more sophistication (and conversely).

dagraham commented 8 years ago

Here's an example of the current state of the future way of processing of a group task. Starting with this entry:

+ task group @s 7/1/16 @b 3 @a 2d: e, who@what.com, where@when.org, path_to_enclosure
@j Job A &s 6/1/16 &b 7 &f 5/30/16; 6/1/16 
@j Job B &s 6/15/16 &b 5 
@j Job C

etm produces and stores this internal representation:

1 {'a': [[['2d'],
2            [['e', 'who@what.com', 'where@when.org', 'path_to_enclosure']]]],
3     'b': 3,
4     'entry': '+ task group @s 7/1/16 @b 3 @a 2d: e, who@what.com, where@when.org, '
5              'path_to_enclosure @j Job A &s 6/1/16 &b 7 &f 5/30/16; 6/1/16 @j Job '
6              'B &s 6/15/16 &b 5 @j Job C',
7     'itemtype': '+',
8     'j': [{'a': [[['2d'],
9                   [['e', 'who@what.com', 'where@when.org', 'path_to_enclosure']]]],
10            'b': 7,
11            'f': ['20160530T0000', '20160601T0000'],
12            'i': '1',
13            'j': 'Job A',
14            'p': [],
15            's': '20160601T0000',
16            'status': 'f',
17            'summary': 'task group 1/1/1: Job A'},
18           {'a': [[['2d'],
19                   [['e', 'who@what.com', 'where@when.org', 'path_to_enclosure']]]],
20            'b': 5,
21            'i': '2',
22            'j': 'Job B',
23            'p': ['1'],
24            's': '20160615T0000',
25            'status': 'a',
26            'summary': 'task group 1/1/1: Job B'},
27           {'a': [[['2d'],
28                   [['e', 'who@what.com', 'where@when.org', 'path_to_enclosure']]]],
29            'b': 3,
30            'i': '3',
31            'j': 'Job C',
32            'p': ['2'],
33            's': '20160701',
34            'status': 'w',
35            'summary': 'task group 1/1/1: Job C'}],
36     'n': ['dag', 'monthly', '2016', '06'],
37     's': '20160701',
38     'summary': 'task group'}

The group task itself appears as 'entry' on lines 4-6. Note that 'entry' establishes a group default for @a (lines 1-2), @b (line 3) and @s (line 37).

Note also that absent entries for &i (identifier) and &p (prerequisites), these are generated automatically. See lines 12, 14, 21, 23, 30 and 32: A (1) has no prereqs, B (2) has only A (1) as a prereq and C (3) has only B (2) as a prereq.

The jobs themselves appear in the 'entry' on lines 5 and 6. Note that Job A has its own entry for &s and &b. The fact that these supercede the group entries shows on lines 15 and 10, respectively. The &f entry for A is reflected on line 11 and in the status, f (finished), on line 16. Jobs A, B and C inherit the default @a from the group. Job B also sets its own &s and &b and these are reflected on lines 24 and 20, respectively. B is not finished and since its only prereq is finished its status, line 25, is a (available). Job C has an unfinished prereq, B, and its status, line 34, is w (waiting). Note that each of the summaries for the jobs contains the group summary first, then 1/1/1: and then the job summary. The 1/1/1 reflects the totals for finished/available/waiting in the task group.

Note finally, that Job C, having no entries for &s, &a or &b, inherits all these from the group.

stef204 commented 8 years ago

it sounds good. would be nice if we can test it and see how it behaves.

dagraham commented 8 years ago

Too early for that. This is a complete rewrite of the data module and I only have one sandbox file with a variety of methods I’m trying out. The good news is that all the methods have doc strings with tests.

If you're really interested, I've attached the current version using txt as the extension even though it is a py file.

validate.txt

dagraham commented 8 years ago

By the way, I'll be in Colorado without email from tomorrow until July 7.

stef204 commented 8 years ago

will be out myself for a few days. will take a look at the file when back. tx.

dagraham commented 8 years ago

Here's the latest on group tasks. The short version is that you can enter (fuzzy parsed) date-times for &s in jobs but they will be stored internally as timedeltas relative to the @s entry for the task group.

Example

- sequential task group @s 6/10 12p @a 1d @b 3
@j First  &s 6/3 9a
@j Second &s 6/5 10a
@j Third

or, equivalently, as:

- sequential task group @s 6/10 12p @a 1d @b 3
@j First  &s 6/3 9a  &i 1
@j Second &s 6/5 10a &i 2 &p 1
@j Third  &i 3 &p 2

In the absence of &i id and &p prereqs entries, etm would generate them implicitly so, internally, these would be the same to etm. Either way, there would be no prereqs for First, First would be the only prereq for Second and Second would be the only prereq for Third. For more complicated, non-sequential structures, it would be necessary, of course, to add the &i and &p elements explicitly.

Treatment of @s, @a, @b, &s, &a and &b elements

dagraham commented 8 years ago

Stef and Thomas,

I've created a new git repository for the possible new mvc version of etm at https://github.com/dagraham/etm-mvc. The doc-tests in model.py should give a pretty clear idea of the model part of mvc. The file docs/cli.md has some early thoughts on the cli view part of mvc. As always, your thoughts are much appreciated.

-Dan