def main_button_click(self):
     self.play_beep()
     self.tick_timer()
     Recorder.start_recording()
     self.full_file_path = "test.wav"
     self.l_selected_file_name_var.set("[Selected file name]: " + "test.wav")
     self.b_spectrogram['state'] = 'active'

def main():
    parser = OptionParser()
    parser.add_option('-v', '--verbose',
                      dest='verbose', action='store_true', default=False,
                      help='verbose output')
    (options, args) = parser.parse_args()
    verbose = options.verbose
    if verbose:
        print 'verbose output mode.'

    if len(args) == 0:
        print 'no input files.'
        exit

    filename = args[0]
    if verbose:
        print 'filename: ' + filename
    p = Player(filename)

    r = Recorder()
    r.start()

    pl = plotter(p, r)
    th = Thread(target=pl)
    th.daemon = True
    th.start()

    p.run()

 def test_SocketPair1(self):
     rec = Recorder()
     rec.createSocketPair(1,2)
     socDetails = rec._getSocketDetails(1)
     self.assertEqual(socDetails["socketPair"], 2)
     self.assertEqual(socDetails["isForwardChannel"], False)
     socDetails = rec._getSocketDetails(2)
     self.assertEqual(socDetails["socketPair"], 1)
     self.assertEqual(socDetails["isForwardChannel"], True)

    def test_record_when_title_and_command_given(self):
        recorder = Recorder(self.pty_recorder)

        asciicast = recorder.record('ls -l', 'the title')

        assert_equal('the title', asciicast.title)
        assert_equal('ls -l', asciicast.command)
        assert_equal(('ls -l',), self.pty_recorder.record_call_args())
        assert_equal(123.45, asciicast.duration)
        assert_equal(self.pty_recorder.stdout, asciicast.stdout)

def start_recording():
    try:
        config = read_config()
        r = Recorder(config.get('directories', 'sessions'))
        r._run()
    except KeyboardInterrupt:
        logger.info("KeyboardInterrupt")
    except:
        logger.error(sys.exc_info()[1])
    logger.info("Finished recording.")

    def test_record_when_no_title_nor_command_given(self):
        env = { 'SHELL': '/bin/blush' }
        recorder = Recorder(self.pty_recorder, env)

        asciicast = recorder.record(None, None)

        assert_equal(None, asciicast.title)
        assert_equal(None, asciicast.command)
        assert_equal(('/bin/blush',), self.pty_recorder.record_call_args())
        assert_equal(123.45, asciicast.duration)
        assert_equal(self.pty_recorder.stdout, asciicast.stdout)

def main():
    # start recording -> 5 sec default
    recorder = Recorder()
    frames = recorder.start(5)
    recorder.write_wav(frames, "input.wav")

    # load the hum and process
    hum = track_pitch("input.wav")
    timeseries(hum)
    process(hum)

    """

 def submit(self, table_name, form_obj, id):
     db = self.db
     r = Recorder(db, table_name)
     updated = True
     if id:
         result_msg = r.update(id, form_obj)
         form_obj['id'] = id
     else:
         result_msg = r.input(form_obj)
         updated = False
         form_obj['id'] = r.get_last_id()
     self.submitted.emit(updated, table_name, form_obj)
     return result_msg

class MyApp( wxApp ):
   def OnInit( self ):
      self.recorder=Recorder()
      self.res   = wxXmlResource( GUI_FILENAME )
      self.frame = self.res.LoadFrame( None, GUI_MAINFRAME_NAME )
      self.frame.Show()
        
      EVT_BUTTON(self.frame, XRCID("button_quit"), self.onClick)
      EVT_BUTTON(self.frame, XRCID("button_start"), self.onClick)
      EVT_BUTTON(self.frame, XRCID("button_stop"), self.onClick)

      in_src = XRCCTRL(self.frame, "choice_inputsource")
      for n in self.recorder.getDeviceNames():
         in_src.Append(n)
      in_src.SetSelection(0)
      
      self.frame.Bind(EVT_IDLE, self.onIdle)
      
      return 1

   def onIdle(self, evt):
      if self.recorder.status == RECORDING:
         self.recorder.process()
         XRCCTRL(self.frame, "main_frame_statusbar").SetStatusText("bytes written: " +str(self.recorder.bytesWritten()),0)
      evt.Skip()
        
   def onClick(self, evt):
      btn = evt.GetEventObject()
      name = evt.GetEventObject().GetName()
       
      if name == "button_start":
         self.startRecording()
         btn.Disable()
         XRCCTRL(self.frame, "button_stop").Enable()
          
      elif name == "button_stop":
         self.stopRecording()
         btn.Disable()
         XRCCTRL(self.frame, "button_start").Enable()

      else:
         self.quitApplication()
         
   def quitApplication(self):
      self.frame.Close(true)
       
   def startRecording(self):
      self.recorder.setDevice(XRCCTRL(self.frame, "choice_inputsource").GetStringSelection())
      
      file = wxFileSelector("Select file to save mp3 audio to")
      self.recorder.start(open(file,"wb"))
       
   def stopRecording(self):
      self.recorder.stop()

    def __init__(self, config_path):
        # read config file
        config = ConfigParser.RawConfigParser()
        config.read(config_path)

        # general
        self.tmp_file = config.get('general', 'tmp_file')

        # gsr api
        self.gsr_api_lang = config.get('gsr_api', 'language')

        # moses
        self.e = config.get('moses', 'e')
        self.f = config.get('moses', 'f')
        self.moses_config_orig = config.get('moses', 'config_orig')
        self.moses_config_fix = config.get('moses', 'config_fix')
        self.moses_dir = config.get('moses', 'moses_dir')
        self.model_dir = config.get('moses', 'model_dir')
        self.model_dir_jenkins = config.get('moses', 'model_dir_jenkins')
        self.threads = config.getint('moses', 'threads')

        # pyttsx
        self.tts_voice_id = config.get('pyttsx', 'voice')
        self.tts_voice_rate = config.getint('pyttsx', 'rate')

        # create recorder
        self.recorder = Recorder(language=self.gsr_api_lang)

 def __init__(self,url):
     self.url = url          # 要分析的url
     self.block_li = []      # 网页所包含的文本块列表
     self.title = ''
     #重置记录
     self.recorder = Recorder()
     self.recorder.reset()

class ButtonRecorder(object): 
    def __init__(self, filename): 
        self.filename = filename 
        gpio.setup(23, gpio.IN, pull_up_down=gpio.PUD_UP) 
        self.rec = Recorder(channels=2) 

    def start(self): 
        gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10) 

    def rising(self, channel): 
        gpio.remove_event_detect(23) 
        print 'Button up' 
        gpio.add_event_detect(23, gpio.FALLING, callback=self.falling, bouncetime=10) 
        #TODO: dim red LED
        self.recfile.stop_recording() 
        self.recfile.close() 
    
    def falling(self, channel): 
        ts = time.time()
	gpio.remove_event_detect(23) 
        print 'Button down' 
        gpio.add_event_detect(23, gpio.RISING, callback=self.rising, bouncetime=10) 
        #TODO: lit green LED        
        play = PlayFile(vloeken.keys()[random.randint(0,len(vloeken))])
        play.start()
        #TODO: dim green, lite red LED
        vloeken[self.filename + str(ts) + '.wav'] = {'inputfor':[]}
        with open('vloeken.log', 'wb') as handle:
            pickle.dump(vloeken, handle)
        self.recfile = self.rec.open(self.filename + str(ts) + '.wav', 'wb')    
        self.recfile.start_recording() 

 def __init__(self, pos = (0, 0)):
     filename = datetime.datetime.fromtimestamp(time.time())\
                .strftime('%Y-%m-%d %H.%M.%S')
     from recorder import Recorder
     self.path = Recorder.traceFileToPath(filename)
     widget_pos = snapshot.snapWidgetFromPoint(pos, self.path)
     # SmartClick does not support Orient
     self.pos = (pos[0] - widget_pos[0], pos[1] - widget_pos[1])

    def __init__(self, solve_continuous=False, **kwargs): 

        super(Control, self).__init__(**kwargs)

        self.DOF = 2 # task space dimensionality 
        self.u = None
        self.solve_continuous = solve_continuous

        if self.write_to_file is True:
            from recorder import Recorder
            # set up recorders
            self.u_recorder = Recorder('control signal', self.task, 'lqr')
            self.xy_recorder = Recorder('end-effector position', self.task, 'lqr')
            self.dist_recorder = Recorder('distance from target', self.task, 'lqr')
            self.recorders = [self.u_recorder, 
                            self.xy_recorder, 
                            self.dist_recorder]

    def sendValue():
        rec = Recorder()
        data = rec.read()
        vol = rec.rms(data) * 50
        bam = np.fft.fft(data)




        bam = rec.prepare_fft(data, CHUNK)

        result_dict = {"volume": vol, "frequency": bam}
        for client in clients:
            # client.write_message(vol.__str__())
            # client.write_message(bam.__str__())
            # client.write_message(value.__str__())
            client.write_message(tornado.escape.json_encode(result_dict))

    def __init__(self, null_control=True, **kwargs): 
        """
        null_control boolean: apply second controller in null space or not
        """

        super(Control, self).__init__(**kwargs)

        self.DOF = 2 # task space dimensionality 
        self.null_control = null_control

        if self.write_to_file is True:
            from recorder import Recorder
            # set up recorders
            self.u_recorder = Recorder('control signal', self.task, 'osc')
            self.xy_recorder = Recorder('end-effector position', self.task, 'osc')
            self.dist_recorder = Recorder('distance from target', self.task, 'osc')
            self.recorders = [self.u_recorder, 
                            self.xy_recorder, 
                            self.dist_recorder]

	def __init__(self):
		"""Initializes cameras"""
		spyral.scene.Scene.__init__(self)
		self.rootCamera = spyral.director.get_camera()
		self.screenCamera=  self.rootCamera.make_child();
		self.theaterCamera= self.rootCamera.make_child(virtual_size= geom['theater'].size,
													real_size= geom['theater'].size,
													offset= geom['theater'].topleft,
													layers=['upstage','stage','faces','downstage']);
		self.recorder= Recorder()
		self.preventEscapeLock = False

 def start_recording(self):
     """ Start recording data. """
     if self._recorder == None:
         logger.info("Starting recorder...")
         self._restarts = 0
         self._recorder = Recorder(self._path)
         self._recorder.start()
         self.menu.current_item = self._root_item
         self._toggle_item.header = "Stop\nRecording"
         self._root_item.header = "DreamCatcher\nRecording..."
         self.menu.lcd.backlight(self.menu.lcd.RED)

    def startRecorder(self):

        strftime = time.strftime('%Y%m%d%H%M%S')
        self.workdir = '/tmp/xcorder/{s}/'.format(s=strftime)

        if not os.path.isdir(self.workdir):
            os.makedirs(self.workdir)

        self.recorder = Recorder(
                self.video.screen, self.audio.device, self.workdir)

        self.recorder.start()

class CustomSimulation(Simulation): #Custom
    def __init__(self, code=None):
        self.code = code
        self.record_every_stock = False
        
    def setting(self, params, fname=None):
        """複数の株だけど、いくつかの株に絞ってシミュレーションする場合は
        _fnameにファイル名を指定
        """
        if 'from' in params:
            self.set_date_from(params['from'])
        if 'to' in params:
            self.set_date_to(params['to'])
        print 'from:', self.date_from
        print 'to:', self.date_to
        if self.code is not None:
            self.simulate_a_stock(self.code) # privateメソッドのため、親クラスのメソッドを直接呼び出す
        else:
            self.simulate_all_stocks(fname)
    
    def set_trading_system(self, params):
        self.trading_system = TradingSystem(params)
        
    def set_date_from(self, date):
        self.date_from = date
        
    def set_date_to(self, date):
        self.date_to = date
        
    def set_data_loader(self, data_loader):
        Simulation.data_loader = data_loader
        
    def set_record_dir(self, record_dir, setting_file_name, system_name, version):
        self.recorder = \
            Recorder(os.path.join(record_dir,system_name,version))
        self.recorder.create_record_folder()
        self.recorder.record_setting(setting_file_name)
        
    def set_record_every_stock(self, true_or_false):
        self.record_every_stock = true_or_false