liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/extra/metadata.liq

@@ -0,0 +1,75 @@
+# Store and retrieve file covers using metadata. This returns a set of
+# getter/setter methods that can be used to store and retrieve cover art.
+# Typical usage is to set cover art in a `on_metadata` handler and retrieve
+# it in a `video.add_image` operator. See `video.add_cover` for an implementation
+# example.
+# @category Metadata
+# @flag extra
+# @param ~default Default cover file when no cover is available
+# @param ~mime_types Recognized mime types and their corresponding file extensions.
+def file.cover.manager(
+  ~id=null,
+  ~mime_types=[
+    ("image/gif", "gif"),
+    ("image/jpg", "jpeg"),
+    ("image/jpeg", "jpeg"),
+    ("image/png", "png"),
+    ("image/webp", "webp")
+  ],
+  ~default
+) =
+  id = string.id.default(id, default="cover")
+  default = request.create(persistent=true, default)
+
+  current_cover_request = ref(default)
+
+  def extract_cover_from_metadata(_metadata) =
+    filename = _metadata["filename"]
+    log.info(
+      label=id,
+      "Extracting cover from #{string.quote(filename)}."
+    )
+    cover = metadata.cover(_metadata)
+
+    new_cover =
+      if
+        not null.defined(cover)
+      then
+        log.important(
+          label=id,
+          "File #{string.quote(filename)} has no cover."
+        )
+        null
+      else
+        cover = null.get(cover)
+        extension = mime_types[cover.mime]
+        if
+          extension == ""
+        then
+          log.important(
+            label=id,
+            "File #{string.quote(filename)} has unknown mime type #{
+              string.quote(cover.mime)
+            }."
+          )
+          null
+        else
+          cover_file = file.temp("#{id}_", ".#{extension}")
+          file.write(cover_file, data=cover)
+
+          log.important(
+            label=id,
+            "Cover for #{string.quote(filename)} saved to #{
+              string.quote(cover_file)
+            }."
+          )
+
+          request.create(temporary=true, cover_file)
+        end
+      end
+
+    current_cover_request := (new_cover ?? default)
+  end
+
+  current_cover_request.{set = extract_cover_from_metadata}
+end

package/tests/liq/extra/native.liq

@@ -0,0 +1,201 @@
+# Native reimplementation of track functions.
+# @category Source / Track processing
+let native = ()
+
+# Create a source that plays only one track of the input source.
+# @category Source / Track processing
+# @flag extra
+def native.once(s) =
+  # source.available(track_sensitive=true, s, predicate.first({true}))
+  a = ref(true)
+  s.on_track(synchronous=true, fun (_) -> a := false)
+  source.available(s, a)
+end
+
+# At the beginning of each track, select the first ready child.
+# @category Source / Track processing
+# @flag extra
+# @param ~id Force the value of the source ID.
+# @param ~track_sensitive Re-select only on end of tracks.
+def native.fallback(~id=null, ~track_sensitive=true, sources) =
+  fail = (source.fail() : source)
+
+  def s() =
+    list.find(default=fail, source.is_ready, getter.get(sources))
+  end
+
+  infallible =
+    getter.is_constant(sources)
+    and not (list.exists(source.fallible, getter.get(sources)))
+
+  source.dynamic(
+    id=id,
+    infallible=infallible,
+    track_sensitive=track_sensitive,
+    s
+  )
+end
+
+# Play only one track of every successive source, except for the last one which
+# is played as much as available.
+# @category Source / Track processing
+# @flag extra
+# @param ~id Force the value of the source ID.
+# @param sources List of sources to play tracks from.
+def native.sequence(~id=null, sources) =
+  len = list.length(sources)
+  n = ref(0)
+  fail = source.fail()
+
+  def rec s() =
+    sn = list.nth(default=list.last(default=fail, sources), sources, n())
+    if
+      source.is_ready(sn) or n() >= len - 1
+    then
+      sn
+    else
+      ref.incr(n)
+      s()
+    end
+  end
+
+  infallible = not source.fallible(list.last(default=fail, sources))
+  s = source.dynamic(id=id, infallible=infallible, track_sensitive=true, s)
+  first = ref(true)
+
+  def ot(_) =
+    # Drop the first track
+    if first() then first := false else ref.incr(n) end
+  end
+
+  s.on_track(synchronous=true, ot)
+  s
+end
+
+# Select the first source whose predicate is true in a list. If the second
+# argument is a getter, the source will be dynamically created.
+# @category Source / Track processing
+# @flag extra
+# @param ~id Force the value of the source ID.
+# @param ~track_sensitive Re-select only on end of tracks.
+# @param sources Sources with the predicate telling when they can be played.
+def native.switch(~id=null, ~track_sensitive=true, sources) =
+  sources = list.map(fun (ps) -> source.available(snd(ps), fst(ps)), sources)
+  native.fallback(id=id, track_sensitive=track_sensitive, sources)
+end
+
+# This allows doing `open native`
+# @category Source / Track processing
+let native.request = request
+
+# @docof request.dynamic
+def native.request.dynamic(%argsof(request.dynamic), f) =
+  ignore(available)
+  ignore(timeout)
+  ignore(native)
+  ignore(synchronous)
+
+  def f() =
+    try
+      f()
+    catch _ do
+      null
+    end
+  end
+
+  # Prepared requests
+  queue = ref([])
+
+  def get_queue() =
+    def get_request(s) =
+      s.request
+    end
+
+    list.map(get_request, queue())
+  end
+
+  def add(r) =
+    s = request.once(r)
+    if
+      s.resolve()
+    then
+      queue := [...queue(), s]
+      true
+    else
+      false
+    end
+  end
+
+  def set_queue(l) =
+    queue := []
+    list.iter(fun (r) -> ignore(add(r)), l)
+  end
+
+  current = ref(null)
+
+  def get_current() =
+    if
+      null.defined(current())
+    then
+      s = null.get(current())
+      s.request
+    else
+      null
+    end
+  end
+
+  # Prefetch thread
+  def fetch() =
+    r = f()
+    if
+      null.defined(r)
+    then
+      r = null.get(r)
+      s = request.once(r)
+      if
+        s.resolve()
+      then
+        log.info(
+          "Added request on queue: #{request.uri(r)}."
+        )
+        queue := [...queue(), s]
+        true
+      else
+        log.important(
+          "Failed to resolve request #{request.uri(r)}."
+        )
+        false
+      end
+    else
+      false
+    end
+  end
+
+  def fill() =
+    if list.length(queue()) < prefetch then ignore(fetch()) end
+  end
+
+  thread.run(every=retry_delay, fill)
+
+  # Source
+  def s() =
+    if
+      not list.is_empty(queue())
+    then
+      let [s, ...rest] = queue()
+      queue := rest
+      current := s
+      s
+    else
+      source.fail()
+    end
+  end
+
+  source.dynamic(id=id, track_sensitive=true, s).{
+    fetch = fetch,
+    queue = get_queue,
+    add = add,
+    set_queue = set_queue,
+    current = get_current
+  }
+end

package/tests/liq/extra/openai.liq

@@ -0,0 +1,150 @@
+let error.openai = error.register("openai")
+
+openai = ()
+
+# @flag hidden
+def parse_openai_error(ans, err) =
+  try
+    let json.parse (e : {error: {message: string, type: string}}) = ans
+
+    e = e.error
+
+    error.raise(
+      error.openai,
+      "#{e.type}: #{e.message}"
+    )
+  catch _ do
+    error.raise(err)
+  end
+end
+
+# Query ChatGPT API.
+# @param ~base_url Base URL for the API query
+# @param ~key OpenAI API key.
+# @param ~model Language model.
+# @param ~timeout Timeout for network operations in seconds.
+# @param messages Messages initially exchanged.
+# @category Internet
+# @flag extra
+def openai.chat(
+  ~key,
+  ~base_url="https://api.openai.com",
+  ~model="gpt-3.5-turbo",
+  ~timeout=null(30.),
+  (
+  messages:
+  [
+    {
+      role: string,
+      content: string,
+      name?: string,
+      tool_calls?: [
+        {id: string, type: string, function: {name: string, arguments: string}}
+      ],
+      tool_call_id?: string
+    }
+  ]
+  )
+) =
+  payload = {model = model, messages = messages}
+
+  ans =
+    http.post(
+      data=json.stringify(payload),
+      timeout=timeout,
+      headers=[
+        ("Content-Type", "application/json"),
+        (
+          "Authorization",
+          "Bearer #{(key : string)}"
+        )
+      ],
+      "#{base_url}/v1/chat/completions"
+    )
+
+  if
+    ans.status_code != 200
+  then
+    error.raise(
+      error.http,
+      "#{ans.status_code}: #{ans.status_message}"
+    )
+  end
+
+  try
+    let json.parse (ans :
+      {
+        choices: [
+          {
+            finish_reason: string,
+            index: int,
+            message: {content: string, role: string}
+          }
+        ],
+        created: int,
+        model: string,
+        object: string,
+        usage: {completion_tokens: int, prompt_tokens: int, total_tokens: int}
+      }
+    ) = ans
+    ans
+  catch err : [error.json] do
+    parse_openai_error(ans, err)
+  end
+end
+
+# Generate speech using openai. Returns the encoded audio data.
+# @param ~base_url Base URL for the API query
+# @param ~key OpenAI API key.
+# @param ~model Language model.
+# @param ~timeout Timeout for network operations in seconds.
+# @param ~voice The voice to use when generating the audio. Supported voices are `"alloy"`, `"echo"`, `"fable"`, `"onyx"`, `"nova"`, and `"shimmer"`
+# @param ~response_format The format to audio in. Supported formats are: `"mp3"`, `"opus"`, `"aac"`, and `"flac"`.
+# @param ~speed The speed of the generated audio. Select a value from `0.25` to `4.0`. `1.0` is the default.
+# @params ~on_data Function executed when receiving the audio data.
+# @category Internet
+# @flag extra
+def openai.speech(
+  ~key,
+  ~base_url="https://api.openai.com",
+  ~model="tts-1",
+  ~timeout=null(30.),
+  ~voice,
+  ~response_format="mp3",
+  ~speed=1.,
+  ~on_data,
+  (input:string)
+) =
+  payload =
+    {
+      model = model,
+      input = input,
+      voice = (voice : string),
+      response_format = response_format,
+      speed = speed
+    }
+
+  ans =
+    http.post.stream(
+      data=json.stringify(payload),
+      timeout=timeout,
+      headers=[
+        ("Content-Type", "application/json"),
+        (
+          "Authorization",
+          "Bearer #{(key : string)}"
+        )
+      ],
+      on_body_data=on_data,
+      "#{base_url}/v1/audio/speech"
+    )
+
+  if
+    ans.status_code != 200
+  then
+    error.raise(
+      error.http,
+      "#{ans.status_code}: #{ans.status_message}"
+    )
+  end
+end

package/tests/liq/extra/server.liq

@@ -0,0 +1,177 @@
+# Register a command that outputs the RMS of the returned source.
+# @flag extra
+# @category Source / Visualization
+# @param ~id Force the value of the source ID.
+def server.rms(~id=null, s) =
+  let s = rms(id=id, s)
+
+  def rms(_) =
+    rms = s.rms()
+    "#{rms}"
+  end
+
+  s.register_command(
+    description="Return the current RMS of the source.",
+    usage="rms",
+    "rms",
+    rms
+  )
+
+  s
+end
+
+# Register a server/telnet command to update a source's metadata. Returns a new
+# source, which will receive the updated metadata. The command has the following
+# format: insert key1="val1",key2="val2",...
+# @flag extra
+# @category Source / Track processing
+# @param ~id Force the value of the source ID.
+def server.insert_metadata(s) =
+  def insert(s) =
+    let (meta, _) = string.annotate.parse("#{s}:")
+    if
+      meta != []
+    then
+      s.insert_metadata(meta)
+      "Done"
+    else
+      "Syntax error or no metadata given. Use key1=\"val1\",key2=\"val2\",.."
+    end
+  end
+
+  s.register_command(
+    description="Insert a metadata chunk.",
+    usage="insert key1=\"val1\",key2=\"val2\",..",
+    "insert",
+    insert
+  )
+
+  s
+end
+
+# Start an interface for the "telnet" server over http.
+# @category Internet
+# @flag extra
+# @param ~port Port of the server.
+# @param ~transport Http transport. Use `http.transport.ssl` or http.transport.secure_transport`, when available, to enable HTTPS output
+# @param ~uri URI of the server.
+def server.harbor(~transport=http.transport.unix, ~port=8000, ~uri="/telnet") =
+  def webpage(_, response) =
+    response.html(
+      "
+<html>
+  <head>
+    <meta charset='utf-8'/>
+    <title>Liquidsoap telnet server</title>
+    <style>
+      body {
+          font-family: sans-serif;
+      }
+      h1 {
+          text-align: center;
+      }
+      textarea {
+          display: block;
+          margin: 0 auto;
+          color: lightgreen;
+          background-color: black;
+          padding: 1ex;
+      }
+    </style>
+    <script>
+      window.onload = function () {
+        c = document.getElementById('console');
+
+        function send() {
+          var lines = c.value.substr(0, c.selectionStart).split('\\n');
+          var line = lines[lines.length-1];
+          var data = line;
+          console.log('send ' + line);
+          var xmlHttp = new XMLHttpRequest();
+          xmlHttp.open('POST', '#{
+        uri
+      }');
+          xmlHttp.onreadystatechange = function () {
+            if(xmlHttp.readyState === XMLHttpRequest.DONE) {
+              var status = xmlHttp.status;
+              if (status === 0 || (status >= 200 && status < 400)) {
+                c.value += xmlHttp.responseText + 'END\\n';
+                c.scrollTop = c.scrollHeight;
+              } else {
+                console.log('Failed to send values.')
+              }
+            }
+          }
+          xmlHttp.send(data);
+        }
+
+        c.addEventListener('keypress', function(e) {if (e.which == 13) {send()}})
+      }
+    </script>
+  </head>
+  <body>
+    <h1>Liquidsoap telnet server</h1>
+    <textarea id='console' cols='80' rows='25'></textarea>
+    <p style='text-align: center'>Type <code>help</code> if you are lost.</p>
+  </body>
+</html>
+"
+    )
+  end
+
+  harbor.http.register(
+    transport=transport,
+    port=port,
+    method="GET",
+    uri,
+    webpage
+  )
+
+  def setter(request, response) =
+    log.info(
+      "Executing command: #{request.data}"
+    )
+    answer = server.execute(request.body())
+    answer = string.concat(separator="\n", answer) ^ "\n"
+    response.data(answer)
+  end
+
+  harbor.http.register(
+    transport=transport,
+    port=port,
+    method="POST",
+    uri,
+    setter
+  )
+
+  log.important(
+    label="server.harbor",
+    "Website should be ready at <http://localhost:#{port}#{uri}>."
+  )
+end
+
+# Add a skip telnet command to a source when it does not have one by default.
+# @category Interaction
+# @flag extra
+# @param s The source to attach the command to.
+def add_skip_command(s) =
+  # A command to skip
+  def skip(_) =
+    s.skip()
+    "Done!"
+  end
+
+  s.on_wake_up(
+    synchronous=false,
+    {
+      # Register the command:
+      server.register(
+        namespace="#{source.id(s)}",
+        usage="skip",
+        description="Skip the current song.",
+        "skip",
+        skip
+      )
+    }
+  )
+end