comparison test/test_process.py @ 82:a11b57e9fb0b

naming: module methods snake_case

 
 import vamp
 import numpy as np
 
-testPluginKey = "vamp-test-plugin:vamp-test-plugin"
-testPluginKeyFreq = "vamp-test-plugin:vamp-test-plugin-freq"
+plugin_key = "vamp-test-plugin:vamp-test-plugin"
+plugin_key_freq = "vamp-test-plugin:vamp-test-plugin-freq"
 
 rate = 44100
 
 # Throughout this file we have the assumption that the plugin gets run with a
 # blocksize of 1024, and with a step of 1024 for the time-domain version or 512

     # start at 1, not 0 so that all elts are non-zero
     return np.arange(n) + 1    
 
 def test_process_n():
     buf = input_data(blocksize)
-    results = list(vamp.process(buf, rate, testPluginKey, "input-summary"))
+    results = list(vamp.process(buf, rate, plugin_key, "input-summary"))
     assert len(results) == 1
 
 def test_process_freq_n():
     buf = input_data(blocksize)
-    results = list(vamp.process(buf, rate, testPluginKeyFreq, "input-summary", {}))
+    results = list(vamp.process(buf, rate, plugin_key_freq, "input-summary", {}))
     assert len(results) == 2 # one complete block starting at zero, one half-full
 
 def test_process_default_output():
     # If no output is specified, we should get the first one (instants)
     buf = input_data(blocksize)
-    results = list(vamp.process(buf, rate, testPluginKey, "", {}))
+    results = list(vamp.process(buf, rate, plugin_key, "", {}))
     assert len(results) == 10
     for i in range(len(results)):
         expectedTime = vamp.vampyhost.RealTime('seconds', i * 1.5)
         actualTime = results[i]["timestamp"]
         assert expectedTime == actualTime
 
 def test_process_summary_param():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKey, "input-summary", { "produce_output": 0 }))
+    results = list(vamp.process(buf, rate, plugin_key, "input-summary", { "produce_output": 0 }))
     assert len(results) == 0
 
 def test_process_multi_summary_param():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKey, [ "input-summary" ], { "produce_output": 0 }))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key, [ "input-summary" ], { "produce_output": 0 }))
     assert len(results) == 0
 
 def test_process_summary_param_bool():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKey, "input-summary", { "produce_output": False }))
+    results = list(vamp.process(buf, rate, plugin_key, "input-summary", { "produce_output": False }))
     assert len(results) == 0
 
 def test_process_multi_summary_param_bool():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKey, [ "input-summary" ], { "produce_output": False }))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key, [ "input-summary" ], { "produce_output": False }))
     assert len(results) == 0
 
 def test_process_summary():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKey, "input-summary", {}))
+    results = list(vamp.process(buf, rate, plugin_key, "input-summary", {}))
     assert len(results) == 10
     for i in range(len(results)):
         #
         # each feature has a single value, equal to the number of non-zero elts
         # in the input block (which is all of them, i.e. the blocksize) plus

         actual = results[i]["values"][0]
         assert actual == expected
 
 def test_process_multi_summary():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKey, [ "input-summary" ], {}))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key, [ "input-summary" ], {}))
     assert len(results) == 10
     for i in range(len(results)):
         #
         # each feature has a single value, equal to the number of non-zero elts
         # in the input block (which is all of them, i.e. the blocksize) plus

         actual = results[i]["input-summary"]["values"][0]
         assert actual == expected
 
 def test_process_freq_summary():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKeyFreq, "input-summary", {}))
+    results = list(vamp.process(buf, rate, plugin_key_freq, "input-summary", {}))
     assert len(results) == 20
     for i in range(len(results)):
         #
         # sort of as above, but much much subtler:
         #

         eps = 1e-6
         assert abs(actual - expected) < eps
 
 def test_process_multi_freq_summary():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKeyFreq, [ "input-summary" ], {}))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key_freq, [ "input-summary" ], {}))
     assert len(results) == 20
     for i in range(len(results)):
         expected = i * (blocksize/2) + blocksize/2 + 1   # "first" elt
         if (i == len(results)-1):
             expected = 0

         eps = 1e-6
         assert abs(actual - expected) < eps
 
 def test_process_timestamps():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKey, "input-timestamp", {}))
+    results = list(vamp.process(buf, rate, plugin_key, "input-timestamp", {}))
     assert len(results) == 10
     for i in range(len(results)):
         # The timestamp should be the frame number of the first frame in the
         # input buffer
         expected = i * blocksize
         actual = results[i]["values"][0]
         assert actual == expected
 
 def test_process_multi_timestamps():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKey, [ "input-timestamp" ]))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key, [ "input-timestamp" ]))
     assert len(results) == 10
     for i in range(len(results)):
         # The timestamp should be the frame number of the first frame in the
         # input buffer
         expected = i * blocksize
         actual = results[i]["input-timestamp"]["values"][0]
         assert actual == expected
 
 def test_process_freq_timestamps():
     buf = input_data(blocksize * 10)
-    results = list(vamp.process(buf, rate, testPluginKeyFreq, "input-timestamp", {}))
+    results = list(vamp.process(buf, rate, plugin_key_freq, "input-timestamp", {}))
     assert len(results) == 20
     for i in range(len(results)):
         # The timestamp should be the frame number of the frame just beyond
         # half-way through the input buffer
         expected = i * (blocksize/2) + blocksize/2
         actual = results[i]["values"][0]
         assert actual == expected
 
 def test_process_multi_freq_timestamps():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKeyFreq, [ "input-timestamp" ], {}))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key_freq, [ "input-timestamp" ], {}))
     assert len(results) == 20
     for i in range(len(results)):
         # The timestamp should be the frame number of the frame just beyond
         # half-way through the input buffer
         expected = i * (blocksize/2) + blocksize/2
         actual = results[i]["input-timestamp"]["values"][0]
         assert actual == expected
 
 def test_process_multiple_outputs():
     buf = input_data(blocksize * 10)
-    results = list(vamp.processMultipleOutputs(buf, rate, testPluginKey, [ "input-summary", "input-timestamp" ], {}))
+    results = list(vamp.process_multiple_outputs(buf, rate, plugin_key, [ "input-summary", "input-timestamp" ], {}))
     assert len(results) == 20
     si = 0
     ti = 0
     for r in results:
         assert "input-summary" in r or "input-timestamp" in r