Parsing corporate DateTime format with calendar week

General Usage
, ,
1

Hi all,

I have date time data in the following format:
2434.5 14:20
Which is for: year 2024, 34th week of the year (August), 5th day of the week (Friday), 14:20 o’clock.

I am struggeling to parse the calendar week and day of week.
Looking at the documentation of Dates, it is possible to print the dayofweek from a given date but not the other way around.

So I would like to parse “2434.5 14:20” → “2024-08-23T14:20:00”
Does anyone has suggestions?

Worst case if that is not possible, I will have to parse it the other way around with a lot of manual steps for calculating a delta time etc. which I’d like not to do.

1 Like
2

I don’t know if you can create a DateFormat for that.

You could parse the date components via a regex and then use DateTime arithmetics:

using Dates
function myparse(str)
    m = match(r"(?<year>\d\d)(?<week>\d\d)\.(?<day>\d)\s(?<hour>\d\d):(?<minute>\d\d)", str)
    year = 2000 + parse(Int, m[:year])
    week = parse(Int, m[:week])
    day = parse(Int, m[:day])
    hour = parse(Int, m[:hour])
    minute = parse(Int, m[:minute])

    return (DateTime(year) + Week(week - 1) + Day(day - 1) +
            Hour(hour) + Minute(minute))
end

Double-check Triple-check that it actually parses correctly though!

6 Likes
3

I’ve tested with a few values and it seems to work like a charm.
Thank you very much!

4

I’m worried the solution is wrong. Let me explain.

2025-01-01 started on a Wednesday, so it should be called 2501.3 right? That means we need to offset the final date with 3 days, not 1.

We can get this value with dayofweek(Date(Year(2025)), which returns 3.

(You can check your implementation is false, dayofweek(myparse("2505.1 13:30")) returns 3 instead of 1)

So I think the solution is:

using Dates
function weekdate_to_datetime(str::AbstractString)
    m = match(r"(?<year>\d\d)(?<week>\d\d)\.(?<day>\d)\s(?<hour>\d\d):(?<minute>\d\d)", str)
    if isnothing(m) || length(m.captures) != 5
        error("incorrect weekday format, expected \"yymm.dd hh:mm\"")
    end
    year = 2000 + parse(Int, m[:year])
    week = parse(Int, m[:week])
    day = parse(Int, m[:day])
    hour = parse(Int, m[:hour])
    minute = parse(Int, m[:minute])

    day_offset = dayofweek(DateTime(year))
    return (DateTime(year) + Week(week - 1) + Day(day) - Day(day_offset) +
            Hour(hour) + Minute(minute))
end

Note the following funny result due to the week date definition we use here:

julia> weekdate_to_datetime("2453.1 13:30")
2024-12-30T13:30:00

julia> weekdate_to_datetime("2501.1 13:30")
2024-12-30T13:30:00

Maybe you want to throw an error if someone inputs a week date of a year that starts in the previous year like "2501.1" ?

Also note that there may be funny ISO definitions as hinted at in this discussion: Determine date range given year and week number - General Usage - Julia Programming Language

3 Likes
5

I am not surprised! Nice catch.

There are other issues too. For example, the number of weeks per year is not constant, so one should probably validate that, and weeks also overflow to following years, so one should validate the day in a week too.

Working with date and time is always tricky, especially when parsing a custom format. That’s why I tried to emphasize that the implementation needs to be tested carefully. Dates are complicated in standard notation and even more so when stored in a special format :slight_smile:

1 Like
6

There’s lots of funny edge cases here! Under the assumption that the year, week and both hour & minutes are always specified as two numbers, your code appears to be correct. The format unfortunately doesn’t allow us to distinguish between 1970 and 2070, and so "7001.4 00:00" is an example where the result is ambiguous:

julia> using Supposition

julia> function corporate_time(dt::DateTime)
           y = lpad(year(dt) % 100, 2, '0')
           w = lpad(week(dt), 2, '0')
           dw = dayofweek(dt)
           h = lpad(hour(dt), 2, '0')
           m = lpad(minute(dt), 2, '0')
           "$y$w.$dw $h:$m"
       end
corporate_time (generic function with 5 methods)

# generate a random `DateTime` by simply offsetting from 1970-1-1
julia> datetime = map(Data.Integers(0, 100_000), Data.Integers(0, 23), Data.Integers(0,59)) do dayoffset, h, m
           DateTime(1970,1,1) + Day(dayoffset) + Hour(h) + Minute(m)
       end;

julia> example(datetime)
2171-08-31T12:26:00

julia> @check function weekdate_correct(dt=datetime)
           ct = corporate_time(dt)
           event!("Produced string", ct)
           weekdate = weekdate_to_datetime(ct)
           event!("Parsed corporate date", weekdate)
           weekdate == dt
       end
Found counterexample
  Context: weekdate_correct

  Arguments:
      dt::DateTime = DateTime("1970-01-01T00:00:00")

  Events:
    Produced string
        "7001.4 00:00"
    Parsed corporate date
        DateTime("2070-01-02T00:00:00")

I’d recommend moving away from this data format as soon as possible, to prevent weird problems in the future.

That being said, if we limit ourselves to dayofweek, your function is accurate :slight_smile:

julia> @check function weekdate_correct(dt=datetime)
           ct = corporate_time(dt)
           event!("Produced string", ct)
           weekdate = weekdate_to_datetime(ct)
           event!("Parsed corporate date", weekdate)
           dayofweek(weekdate) == dayofweek(dt)
       end
Test passed
  Context: weekdate_correct