prompt_objects 0.6.0 → 0.7.0

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/bundle.rb

@@ -0,0 +1,46 @@
+module OSC
+  class Bundle
+    attr_accessor :timetag
+
+    def initialize(timetag=nil, *args)
+      @timetag = timetag
+      @args = args
+    end
+
+    def encode()
+      s = OSCString.new('#bundle').encode
+      s << encode_timetag(@timetag)
+      s << @args.collect do |x|
+        x2 = x.encode; [x2.size].pack('N') + x2
+      end.join
+    end
+
+    def to_a
+      @args.collect{|x| x.to_a}
+    end
+
+    private
+
+    def encode_timetag(t)
+      case t
+      when nil # immediately
+        t1 = 0
+        t2 = 1
+      when Numeric
+        t1, t2 = construct_timetag(t)
+      when Time
+        t1, t2 = construct_timetag(t.to_ntp)
+      else
+        raise(ArgumentError, 'invalid time')
+      end
+      [t1, t2].pack('N2')
+    end
+
+    def construct_timetag(time)
+      t1, fr = time.divmod(1)
+      t2 = (fr * (2**32)).to_i
+
+      [t1, t2]
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/client.rb

@@ -0,0 +1,13 @@
+module OSC
+  class Client
+
+    def initialize(host, port)
+      @so = UDPSocket.new
+      @so.connect(host, port)
+    end
+
+    def send(mesg)
+      @so.send(mesg.encode, 0)
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/core_ext/time.rb

@@ -0,0 +1,6 @@
+class Time
+
+  def to_ntp
+    self.to_f + 2208988800
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/em_server.rb

@@ -0,0 +1,63 @@
+require 'eventmachine'
+
+module OSC
+  Channel = EM::Channel.new
+
+  class Connection < EventMachine::Connection
+    def receive_data(data)
+      ip_info = get_peername[2,6].unpack("nC4")
+      Channel << OSC::OSCPacket.messages_from_network(data, ip_info)
+    end
+  end
+
+  class EMServer
+
+    def initialize(port = 3333)
+      @port = port
+      setup_dispatcher
+      @tuples = []
+    end
+
+    def run
+      EM.error_handler{ |e|
+        Thread.main.raise e
+      }
+
+      EM.run do
+        EM::open_datagram_socket "0.0.0.0",  @port, Connection
+      end
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new(address_pattern)
+
+      @tuples << [matcher, proc]
+    end
+
+    private
+    def setup_dispatcher
+      Channel.subscribe do |messages|
+        messages.each do |message|
+          diff =  (message.time || 0) - Time.now.to_ntp
+
+          if diff <= 0
+            sendmesg(message)
+          else
+            EM.defer do
+              sleep(diff)
+              sendmesg(message)
+            end
+          end
+        end
+      end
+    end
+
+    def sendmesg(mesg)
+      @tuples.each do |matcher, obj|
+        if matcher.match?(mesg.address)
+          obj.call(mesg)
+        end
+      end
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/message.rb

@@ -0,0 +1,46 @@
+module OSC
+  class Message
+    attr_accessor :address
+    attr_accessor :time
+    attr_accessor :ip_address
+    attr_accessor :ip_port
+
+    def self.new_with_time(address, time, tags=nil, *args)
+      message = new(address, tags, *args)
+      message.time = time
+      message
+    end
+
+    def initialize(address, *args)
+      @address = address
+      @args = []
+
+      args.each do |arg|
+        case arg
+        when Integer;     @args << OSCInt32.new(arg)
+        when Float;       @args << OSCFloat32.new(arg)
+        when String;      @args << OSCString.new(arg)
+        when OSCArgument; @args << arg
+        end
+      end
+    end
+
+    def tags
+      @args.collect{|x| x.tag}.join
+    end
+
+    def encode
+      s = OSCString.new(@address).encode
+      s << OSCString.new(',' + tags).encode
+      s << @args.collect{|x| x.encode}.join
+    end
+
+    def to_a
+      @args.collect{|x| x.val}
+    end
+
+    def ==(other)
+      @address == other.address && to_a == other.to_a
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/network_packet.rb

@@ -0,0 +1,42 @@
+module OSC
+  class NetworkPacket
+    def initialize(str)
+      @str = str.force_encoding("BINARY")
+      @index = 0
+    end
+
+    def to_s
+      @str
+    end
+
+    def rem
+      @str.length - @index
+    end
+
+    def eof?
+      rem <= 0
+    end
+
+    def skip(n)
+      @index += n
+    end
+
+    def skip_padding
+      skip((4 - (@index % 4)) % 4)
+    end
+
+    def getn(n)
+      raise(EOFError) if rem < n
+      s = @str[@index, n]
+      skip(n)
+      s
+    end
+
+    def getc
+      raise(EOFError) if rem < 1
+      c = @str[@index]
+      skip(1)
+      c
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/osc_argument.rb

@@ -0,0 +1,26 @@
+module OSC
+  class OSCArgument
+    def initialize(val)
+      @val = val
+    end
+
+    attr_accessor :val
+
+    def to_i()
+      @val.to_i
+    end
+
+    def to_f()
+      @val.to_f
+    end
+
+    def to_s()
+      @val.to_s
+    end
+
+    private
+    def padding(s)
+      s + ("\000" * ((4 - (s.size % 4)) % 4))
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/osc_packet.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname( __FILE__ ), 'network_packet')
+require 'ostruct'
+
+module OSC
+  class UnknownType < StandardError; end
+
+  class OSCPacket
+    def self.messages_from_network(string, ip_info=nil)
+      messages = []
+      osc = new(string)
+
+      if osc.bundle?
+        osc.get_string
+        time = osc.get_timestamp
+
+        osc.get_bundle_messages.each do |message|
+          msg = decode_simple_message(time, OSCPacket.new(message))
+          if ip_info
+            # Append info for the ip address
+            msg.ip_port = ip_info.shift
+            msg.ip_address = ip_info.join(".")
+          end
+          messages << msg
+        end
+
+      else
+        msg = decode_simple_message(time, osc)
+        if ip_info
+          # Append info for the ip address
+          msg.ip_port = ip_info.shift
+          msg.ip_address = ip_info.join(".")
+        end
+        messages << msg
+      end
+
+      return messages
+    end
+
+    def self.decode_simple_message(time, osc_packet)
+      address = osc_packet.get_string
+      args = osc_packet.get_arguments
+
+      Message.new_with_time(address, time, nil, *args)
+    end
+
+    def initialize(string)
+      @packet = NetworkPacket.new(string)
+
+      @types = {
+       "i" => lambda{OSCInt32.new(get_int32)},
+       "f" => lambda{  OSCFloat32.new(get_float32)},
+       "d" => lambda{  OSCDouble64.new(get_double64)},
+       "s" => lambda{  OSCString.new(get_string)},
+       "b" => lambda{  OSCBlob.new(get_blob)}
+     }
+    end
+
+    def get_bundle_messages
+      bundle_messages = []
+
+      until @packet.eof?
+        l = @packet.getn(4).unpack('N')[0]
+        bundle_messages << @packet.getn(l)
+      end
+      bundle_messages
+    end
+
+    def get_string
+      result = ''
+      until ((c = @packet.getc) == string_delemeter)
+        result << c
+      end
+      @packet.skip_padding
+      result
+    end
+
+    def get_timestamp
+      #TODO: refactor this so a mortal can figure it out
+      t1 = @packet.getn(4).unpack('N')[0]
+      t2 = @packet.getn(4).unpack('N')[0]
+      @packet.skip_padding
+
+      if t1 == 0 && t2 == 1
+        time = nil
+      else
+        time = t1 + t2.to_f / (2**32)
+      end
+
+      time
+    end
+
+    def get_arguments
+      if (@packet.getc == ?,)
+        tags = get_string
+        args = []
+
+        tags.scan(/./) do |tag|
+          type_handler = @types[tag]
+          raise(UnknownType, "Unknown OSC type: #{tag}") unless type_handler
+          args << type_handler.call
+        end
+        args
+      end
+    end
+
+    def get_int32
+      i = @packet.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      @packet.skip_padding
+      i
+    end
+
+    def get_float32
+      f = @packet.getn(4).unpack('g')[0]
+      @packet.skip_padding
+      f
+    end
+
+    def get_double64
+      f = @packet.getn(8).unpack('G')[0]
+      @packet.skip_padding
+      f
+    end
+
+    def get_blob
+      l = @packet.getn(4).unpack('N')[0]
+      b = @packet.getn(l)
+      @packet.skip_padding
+      b
+    end
+
+    def bundle?
+      !(@packet.to_s =~ /\A\#bundle/).nil?
+    end
+
+    def string_delemeter
+      "\x00"
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/osc_types.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), "osc_argument")
+
+module OSC
+  class OSCInt32 < OSCArgument
+    def tag
+      'i'
+    end
+
+    def encode
+      [@val].pack('N').force_encoding("BINARY")
+    end
+  end
+
+  class OSCFloat32 < OSCArgument
+    def tag
+      'f'
+    end
+
+    def encode
+      [@val].pack('g').force_encoding("BINARY")
+    end
+  end
+
+  class OSCDouble64 < OSCArgument
+    def tag
+      'd'
+    end
+
+    def encode
+      [@val].pack('G').force_encoding("BINARY")
+    end
+  end
+
+  class OSCString < OSCArgument
+    def tag
+      's'
+    end
+
+    def encode
+      padding(@val.sub(/\000.*\z/, '') + "\000").force_encoding("BINARY")
+    end
+  end
+
+  class OSCBlob < OSCArgument
+    def tag
+      'b'
+    end
+
+    def encode
+      padding([@val.size].pack('N') + @val).force_encoding("BINARY")
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby/server.rb

@@ -0,0 +1,91 @@
+module OSC
+  class Server
+    def initialize(port)
+      @socket = UDPSocket.new
+      @socket.bind('', port)
+      @matchers = []
+      @queue = Queue.new
+    end
+
+    def run
+      start_dispatcher
+
+      start_detector
+    end
+
+    def stop
+      @socket.close
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new(address_pattern)
+
+      @matchers << [matcher, proc]
+    end
+
+    private
+
+    def start_detector
+      begin
+        detector
+      rescue
+        Thread.main.raise($!)
+      end
+    end
+
+    def start_dispatcher
+      Thread.fork do
+        begin
+          dispatcher
+        rescue
+          Thread.main.raise($!)
+        end
+      end
+    end
+
+    def dispatcher
+      loop do
+        mesg = @queue.pop
+        dispatch_message(mesg)
+      end
+    end
+
+    def dispatch_message(message)
+      diff = (message.time || 0) - Time.now.to_ntp
+
+      if diff <= 0
+        sendmesg(message)
+      else # spawn a thread to wait until it's time
+        Thread.fork do
+          sleep(diff)
+          sendmesg(message)
+          Thread.exit
+        end
+      end
+    end
+
+    def sendmesg(mesg)
+      @matchers.each do |matcher, proc|
+        if matcher.match?(mesg.address)
+          proc.call(mesg)
+        end
+      end
+    end
+
+    def detector
+      loop do
+        osc_data, network = @socket.recvfrom(16384)
+        begin
+          ip_info = Array.new
+          ip_info << network[1]
+          ip_info.concat(network[2].split('.'))
+          OSCPacket.messages_from_network( osc_data, ip_info ).each do |message|
+            @queue.push(message)
+          end
+
+        rescue(EOFError)
+        end
+      end
+    end
+  end
+end

data/templates/music-beginner/vendor/osc-ruby-1.1.5/lib/osc-ruby.rb

@@ -0,0 +1,18 @@
+require 'socket'
+require 'thread'
+
+# core extensions
+require 'osc-ruby/core_ext/time'
+
+# jus the basics
+require 'osc-ruby/osc_types'
+require 'osc-ruby/osc_packet'
+
+require 'osc-ruby/message'
+require 'osc-ruby/bundle'
+require 'osc-ruby/address_pattern'
+
+# now we gettin fancy
+require 'osc-ruby/server'
+require 'osc-ruby/client'
+require 'osc-ruby/broadcast_client'

data/templates/music-pro/extras/AUDITION.md

@@ -0,0 +1,100 @@
+# Auditioning Music Pro
+
+## Start it
+
+1. Create a new environment from the `music-pro` template and open it.
+2. Open Sonic Pi. In Settings, allow incoming OSC if needed.
+3. In a Sonic Pi buffer, run one line with the environment's absolute path:
+
+   ```ruby
+   run_file "/Users/you/.prompt_objects/environments/my-music/extras/sonic_pi_boot.rb"
+   ```
+
+4. Ask the `conductor` to check Sonic Pi, then ask it to begin a flowing,
+   talk-safe composition. Add one musician at a time while listening, but keep
+   one sustained, phrase-based, or rhythmic layer connecting the ensemble.
+
+The autonomous timer stays dormant until the conductor receives a new human
+message after the server starts. Its first evolution turn happens 24 seconds
+later and uses the short evolution instruction in the conductor's frontmatter,
+not the human's initialization prompt.
+
+The Log should say `Prompt Objects Music Pro loaded`. The connection query reports engine `music-pro/1`.
+
+`connected: true` confirms only that the engine is reachable. The conductor
+must require each musician to call `set_live_pattern` and then verify an active
+voice in live engine state. A connected engine with an empty `voices` object is
+silent; prose proposals and defined-but-unused patches do not produce sound.
+
+## Pattern notation
+
+| Notation | Meaning |
+| --- | --- |
+| `C4/1` | C4 for one beat |
+| `(C4,E4,G4)/2` | chord for two beats |
+| `~/1` or `-/1` | one-beat rest |
+| `@bd_haus/0.5` | built-in Sonic Pi sample |
+| `[C4/1 E4/1 G4/1]/1` | subdivide/compress the sequence into one beat |
+| `<C4 E4 G4>/1` | choose the next alternative on each cycle |
+| `C4/0.5*4` | repeat an event four times |
+| `C4/1{amp=0.4,pan=-0.2}` | per-event raw controls |
+| `C4/1{gate=0.8}` | one-beat step with a shorter 0.8-beat synth envelope |
+
+Patterns are whitespace-separated. Durations are Sonic Pi beats and determine
+the distance to the next onset. Synth envelopes default to roughly 95% of that
+duration so sustained parts connect; an explicit `gate` may shorten the sound or
+overlap the next onset without changing the rhythm. Explicit patch `sustain`
+still takes precedence. Updates take effect at the next bar. A pattern is padded
+to the next bar boundary after completing, so every voice re-locks safely; this
+prototype does not yet preserve free-running polymetric phase across rewrites.
+
+Available cycle transforms are `transpose`, `stretch`, `rotate`, `reverse`, `probability`, deterministic `seed`, and `every`, for example:
+
+```json
+{
+  "rotate": 1,
+  "seed": 42,
+  "every": { "cycles": 4, "transform": "reverse" }
+}
+```
+
+## Raw patches
+
+The bundled quiet patches are only starting points. A voice can define any installed Sonic Pi synth or built-in sample and up to three effects:
+
+```json
+{
+  "name": "moving_blade",
+  "patch": {
+    "kind": "synth",
+    "synth": "blade",
+    "params": { "amp": 0.12, "attack": 0.4, "release": 2.5, "cutoff": 76 },
+    "effects": [
+      { "name": "reverb", "params": { "mix": 0.25, "room": 0.8 } },
+      { "name": "lpf", "params": { "cutoff": 90 } }
+    ]
+  }
+}
+```
+
+Unknown synth, sample, effect, or parameter names are reported in Sonic Pi's Log without taking down other voice loops.
+
+## Listening comparison
+
+To judge the system rather than one lucky pattern, try three five-minute runs from fresh environments. Give each the same high-level request and note:
+
+- whether a recognizable idea survives multiple autonomous changes;
+- whether musicians leave room and respond to one another;
+- harshness, muddiness, clipping, and distracting transients;
+- how often a change feels motivated rather than random;
+- whether human feedback produces an audible correction within one rewrite.
+
+Agents can query structure but cannot hear audio. Specific human feedback is part of the perception loop.
+
+For a stage rehearsal, begin with the venue output muted, start one voice at a time, set the computer/PA gain conservatively, and keep `stop_voice(voice: "all")` ready. The engine clamps generated event gain but cannot control the operating-system or venue mixer.
+
+## Prototype compatibility and limits
+
+This prototype targets Sonic Pi 4.6.0, the version used while checking the bundled synth/effect names and Ruby syntax. It uses Sonic Pi's Ruby `json` standard library and its `with_fx`/`play_chord` APIs. Verify it against the exact Sonic Pi build used for a performance.
+
+The notation is inspired by live-pattern languages but is not Strudel syntax. It intentionally does not evaluate arbitrary Ruby. Runtime patches may select any installed synth, built-in sample, and up to three effects; arbitrary sample file paths are not accepted in this first protocol. Chords are simultaneous, while the events within one voice otherwise run sequentially. Free-running polymeter, hot control of already-ringing synth nodes, audio analysis, and agent listening are future work.