Interesting 10-day schedule problem.

[gAlleb]

Hi! So

We have twice daily sessions, one in the AM around 8am and another in the afternoon about 4pm. We play the same audio for both the AM and PM sessions on that day.
There are 10 audios in our program that are played in sequence over the course of 10 days. After the last session, we start all over again on another 10-day sequence.

I've been thinking about:

playlist_10_8am = playlist(mode="normal", loop=true, "/playlists/playlist_10_8am.m3u")

playlist_10_16pm = playlist(mode="normal", loop=true, "/playlists/playlist_10_16pm.m3u")

radio = mksafe(switch(
      [(predicate.once({ 8h00m }), playlist_10_8am), 
       (predicate.once({ 16h00m }), playlist_10_16pm) 
       ]
    ))

So now we have 2 playlists, each one contains 10 identical files, they are sequential (mode='normal'), they are not watched.
We have a switch, which plays everyday 1 file from 1st playlist at 8:00 and 1 file from 2nd playlist at 16:00 and silence in between. When 10 days are gone - it all starts over).

I see how it's not ideal at all) Cause we have to start LS specifically on a day when 10-day program starts. Some thinking should be made). Maybe something with time().

How we can achieve expected behavior more elegantly?

[vitoyucepi]

Hi @gAlleb,
First of all, I'd like to discuss the possibility of implementing the required functions and scheduling in the external script. I think pushing to the queue using the API is much easier than storing the state using Liquidsoap's internal functions.

[vitoyucepi]

null.get(request.uri(current))
no default value for null.get

You should first check that current is not null, and then get the uri.
You can't get the uri from null because it's not a request.

if current != null() then
  current_uri = request.uri(null.get(current))
  # do something
end

I would probably use a null.map for that. The type of current_uri is string?, and in some cases the previous code snippet may be more desirable.

current_uri = null.map(request.uri, current)

[gAlleb]

So I've managed to make it work with some alterations.

1. I've commented out def daily_playlist() because I don't know how then to pass queue to fallback.
2. I've changed api function to 2 separate functions because it didn't want to work)
3. I've parsed progress with let json.parse ({current, elapsed} : {current: string, elapsed: float}) = progress because it doesn't parse with let json.parse parsed_json = progress so we could have parsed_json.current and parsed_json.elapsed
4. Had to embrace queue.seek(elapsed) in thread.run and add delay - thread.run(delay=0.5, {ignore(queue.seek(elapsed))}) because otherwise it refuses to seek.
5. Had to add delay and thread.run -> thread.run(restore_progress, delay=0.5). Otherwise it won't play when LS is restarted. A random track from main playlist kick's in.
6. Also I've noticed that elapsed always starts at 0 even if we restart LS, get track and seek forward 120 sec.
7. Also I was thinking about sending null when track is finished

    current = null.map(request.uri, queue.current())
    elapsed = queue.elapsed()
    
    if current != null() then
      log("#{current} #{elapsed}")
      # TODO: extract current track
      ignore(api_put.progress({current = current, elapsed = elapsed}))
    else
      ignore(api_put.progress({current = null_string(current), elapsed = null_float(elapsed)}))
    end

and adding delay to thread.run(put_progress, every=10., delay=10.) in order not get empty progress when LS restarts during playback. Because if it restarts during such playback - 1st thing it will send null progress and then fetch it instead of a real one. Why to send null after track is finished? Here is the case:

• we retrieve 3 hour long track and play it, in 2.5 hours LS restarts and retrieves progress in order to restore it.
• 3 hour long track starts playing from 2.5 hour mark and stops within 30 minutes because it has reached the end. elapsed starts counting from 0 when we seek the queue. So when track has finished playing we will have elapsed: 30 minutes stored.
• In one more hour after track has finished playing LS restarts again (who knows why, just an edge case) and retrieves progress. But now we have only 30 minute progress data (because LS has been previously restarted and seeked through queue).
• And track starts to play 30 minutes into an audio file. And will play another 2.5 hours.

---

radio = playlist("music.m3u8")
api_url = "http://api"
#def daily_playlist()
 def api_put(path, data) =

    full_url = "#{api_url}/#{path}"

    log("API #{path} - Sending POST request to '#{full_url}' with body: #{data}")
    try
        response = http.put(full_url,
            headers=[
                ("Content-Type", "application/json")
            ],
            data=json.stringify(data)
        )

        log("API #{path} - Response (#{response.status_code}): #{response}")

	response
    catch err do
        log("API #{path} - Error: #{error.kind(err)} - #{error.message(err)}")
        "false"
    end

end

def api_get(~timeout=2.0, path) =

    full_url = "#{api_url}/#{path}"

    log("API #{path} - Sending GET request to '#{full_url}'")
    try
        response = http.get(full_url,
            headers=[
                ("Content-Type", "application/json")
            ],
            timeout=timeout
        )

        log("API #{path} - Response (#{response.status_code}): #{response}")
        "#{response}"
    catch err do
        log("API #{path} - Error: #{error.kind(err)} - #{error.message(err)}")
        "false"
    end

end

 
  def api_get.next()
    response = api_get("next")
    # TODO: parse response
    response
  end

  def api_get.progress()
    response = api_get("progress")
    # TODO: parse response
    response
  end

  def api_put.progress(data)
    # TODO: reformat data
    response = api_put("progress", data)
    # TODO: parse response
    ignore(response)
  end

  queue = request.queue()

  def get_next()
    next = api_get.next()
    if next != null() then
      queue.push(request.create(null.get(next)))
    end
  end

  def restore_progress()
    progress = api_get.progress()

    if progress != "" then
    log("#{progress}")
    let json.parse ({current, elapsed} : {current: string, elapsed: float}) = progress
    log("#{current}: #{elapsed}")
      # TODO: check edge cases
     if elapsed != null() then
      queue.push(request.create(null.get("#{current}")))
      thread.run(delay=0.5, {ignore(queue.seek(elapsed))})
     end
    end
  end

  def put_progress()

    current = null.map(request.uri, queue.current())
    elapsed = queue.elapsed()
    
    if current != null() then
      log("#{current} #{elapsed}")
      # TODO: extract current track
      ignore(api_put.progress({current = current, elapsed = elapsed}))
    end
  end

  thread.run(restore_progress, delay=0.5)
  thread.run(get_next, every=60.)
  thread.run(put_progress, every=10.)
#end

radio = fallback(track_sensitive=false, [queue,radio])
 
output(mksafe(radio))

simple js. When playlist is imported - becomes an array with 2 consumed flags:

{"path":"1.mp3","consumed":false,"consumed2":false}

app.get('/next', checkDayChange, (req, res) => {

    const currentTrack = getTrackPath();
    
    // Check if the current track has been consumed

    if (!currentTrack.consumed && (new Date().getHours() >= 8 && new Date().getHours() < 9)) {

        // Mark the track as consumed
        currentTrack.consumed = true;
        // Return the path of the current track
        res.send(currentTrack.path);

    } else if (!currentTrack.consumed2 && (new Date().getHours() >= 16 && new Date().getHours() < 17)) {
        currentTrack.consumed2 = true;
        res.send(currentTrack.path);
    } else {

        return res.send("");

    };
});
let progress_data;
app.put('/progress', (req, res) => {
progress_data = req.body;
res.sendStatus(200);
});
app.get('/progress', (req, res) => {
res.send(progress_data);
});

I don't know why but when I use put endpoint - I get 100 response in LS. With post I get 200 as usual.

[gAlleb]

Regarding elapsed starts counting from 0 when we seek the queue after progress is restored and an edge case I came up with this:

restored_elapsed = ref(0.0)

  def restore_progress()
    progress = api_get("progress")

    if progress != "" then
    
    let json.parse ({current, elapsed} : {current: string, elapsed: float}) = progress

     if elapsed != null() then

      restored_elapsed := elapsed

      queue.push(request.create(null.get("#{current}")))
      thread.run(delay=0.5, {ignore(queue.seek(elapsed))})
     end
    end
  end

  def put_progress()

    current = null.map(request.uri, queue.current())
    elapsed = queue.elapsed()
    
    if current != null() then
      log("#{current} #{elapsed}")
      # TODO: extract current track
      ignore(api_put.progress({current = current, elapsed = elapsed + restored_elapsed()}))
    end
  end

We have a restored_elapsed = ref(0.0) that gets populated from restored progress and then we put elapsed with addition of restored_elapsed.

Vito, what do you think about it? Maybe you got some insights on that or on little problems I had regarding def daily_playlist() that I had to comment out because I don't know how then to pass queue to fallback)

[vitoyucepi]

Maybe you got some insights on that or on little problems I had regarding def daily_playlist() that I had to comment out because I don't know how then to pass queue to fallback

The last line of the function acts as an implicit return.

def daily_playlist()
  queue = request.queue()

  # do something

  queue
end

You may want to return some other methods

def daily_playlist()
  queue = request.queue()

  def some_function()

    # do something

  end

  # do something

  {queue = queue, f = some_function}
  # queue.{f = some_function}
end

[gAlleb]

Thank you, Vito!