def __init__(self): self.volume = config.as_float('volume') self.playing = False self.exit = False self.thread = None self.processing = [] self.current_track = None self.queue = deque() if config['youtube_apikey']: self.youtube = build('youtube', 'v3', developerKey=config['youtube_apikey'], cache_discovery=False) else: logging.warning('YouTube API Key not set') self.youtube = None self.mumble = pymumble.Mumble(config['host'], config['user'], port=config.as_int('port'), password=config['password'], certfile=config['cert'], keyfile=config['privkey'], reconnect=True) self.mumble.callbacks.set_callback("text_received", self.message_received) self.mumble.set_codec_profile("audio") self.mumble.start() self.mumble.is_ready() self.mumble.set_bandwidth(200000) self.loop()
def __init__(self, nick, server="localhost", pwd="humbug"): self.playback_handlers = [] self.sound_activated = False self.mumble = pymumble.Mumble(server, nick, password=pwd, reconnect=True) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self._on_text_message_received) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_CONNECTED, self._on_connected) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_DISCONNECTED, self._on_disconnected) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_USERCREATED, self._on_user_added) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_USERUPDATED, self._on_user_changed) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_USERREMOVED, self._on_user_removed) self.mumble.set_receive_sound(1) # we want to receive sound self.mumble.start() self.mumble.is_ready() # wait for connection # Connected! self.mumble.users.myself.mute() # we don't want to send sound
def test_connectivity(self): mumble_inst = pymumble.Mumble(self.md.ip_address, port=self.md.port, user=self.md.user_id, password=self.md.password, stereo=self.md.stereo) assert mumble_inst is not None
def main(): config = Configuration() engine = create_engine(config.db_connection_url, echo=True) if not database_exists(engine.url): create_database(engine.url) Base.metadata.create_all(engine) # Create all tables if necessary Session = sessionmaker(bind=engine) session = Session() mumble_client = pymumble.Mumble( host=config.mumble_server_host, user=config.mumble_username, password=config.mumble_server_password, certfile=config.certfile_path, keyfile=config.keyfile_path, reconnect=config.reconnect) mumble_client.set_application_string(config.mumble_application_string) mumble_client.set_loop_rate(config.loop_rate) mumble_client.start() mumble_client.is_ready() mumble_client.callbacks.add_callback( pymumble.constants.PYMUMBLE_CLBK_USERCREATED, create_on_user_join_callback(mumble_client, session, config) ) mumble_client.callbacks.add_callback( pymumble.constants.PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, create_on_message_callback(mumble_client, session) ) while True: time.sleep(1)
def __init__(self, queue, app): self.queue = queue self.app = app self.mumble = pymumble.Mumble(self.app.config['MUMBLE_BOT_IP'], self.app.config['MUMBLE_BOT_USERNAME'], port=self.app.config['MUMBLE_BOT_PORT']) self.skip = False
def start_client(self): """Start or restart Mumble client""" self.mumble = pymumble_py3.Mumble(self.config.server, self.config.nickname, int(self.config.port), self.config.password) self.mumble.callbacks.set_callback(PYMUMBLE_CLBK_CONNECTED, self.connected_cb) self.mumble.start() # start the mumble thread self.mumble.is_ready() # wait for the end of the connection process # mute and deafen the user (just to make clear he don't speak or listen) if self.mumble.connected != PYMUMBLE_CONN_STATE_CONNECTED: print("Mumble bot failed to connect to server %s:%s" % (self.config.server, self.config.port)) return False self.mumble.users.myself.mute() self.mumble.users.myself.deafen() # join output channel if self.channel: try: channel = self.mumble.channels.find_by_name(self.channel) channel.move_in() except pymumble_py3.errors.UnknownChannelError: print("Mumble channel not found: %s" % self.channel) return True
def initialize_mumble(md: MumbleData): global_settings.mumble_inst = pymumble.Mumble( md.ip_address, port=md.port, user=md.user_id, reconnect=md.auto_reconnect, password=md.password, certfile=md.certificate, stereo=md.stereo) global_settings.mumble_inst.callbacks.set_callback( 'text_received', BotService.message_received) global_settings.mumble_inst.callbacks.set_callback( 'sound_received', BotService.sound_received) global_settings.mumble_inst.callbacks.set_callback( 'connected', BotService.on_connected) global_settings.mumble_inst.set_codec_profile('audio') global_settings.mumble_inst.set_receive_sound(True) global_settings.mumble_inst.start() global_settings.mumble_inst.is_ready() if global_settings.cfg.getboolean(C_CONNECTION_SETTINGS, P_SELF_REGISTER): global_settings.mumble_inst.users.myself.register() global_settings.mumble_inst.users.myself.comment( f'{runtime_utils.get_comment()}<br>[{META_NAME}({META_VERSION})] - {runtime_utils.get_bot_name()}<br>{runtime_utils.get_about()}' ) runtime_utils.mute() runtime_utils.get_channel(global_settings.cfg[C_CONNECTION_SETTINGS] [P_CHANNEL_DEF]).move_in()
def play_wav(server_args, channelname, file): mumble = pymumble_py3.Mumble(**server_args) mumble.start() mumble.is_ready() if not mumble.is_alive(): raise Exception(f'Connection to "{server_args["host"]}" failed') channel = mumble.channels.find_by_name(channelname) channel.move_in() deadline = time.monotonic() + 2 while time.monotonic() < deadline: if mumble.my_channel() == channel: break time.sleep(.1) if mumble.my_channel() != channel: raise Exception(f'Unable to move to channel "{channelname}"') try: while True: with wave.open(file, 'rb') as wf: duration = 1.0 * wf.getnframes() / wf.getframerate() chunk = int(wf.getframerate() * 0.1) # 100ms chunks start = time.perf_counter() data = wf.readframes(chunk) while len(data) > 0: mumble.sound_output.add_sound(data) data = wf.readframes(chunk) now = time.perf_counter() elapsed = now - start remaining = duration - elapsed + 1 if remaining > 0: time.sleep(remaining) except KeyboardInterrupt: mumble.control_socket.close()
def __init__(self): self.mumble = pymumble.Mumble( host=settings.MUMBLE_HOST, port=settings.MUMBLE_PORT, user=settings.MUMBLE_USER, password=settings.MUMBLE_PASSWORD, stereo=True, ) self.mumble.callbacks.set_callback("text_received", self.on_message) self.mumble.set_codec_profile("audio") self.mumble.start() self.mumble.is_ready() self.channel = cache.get_user_setting("channel") if self.channel: try: self.mumble.channels.find_by_name(self.channel).move_in() except pymumble.errors.UnknownChannelError: self.send_message("Channel `{self.channel}` not found") self.channel = None cache.set_user_setting("channel", None) self.volume = cache.get_user_setting("volume", int, default=50) self.mumble.set_bandwidth(200000) self.lock = Lock() self.interrupt_event = Event() self.cancel_event = Event() self.video_in_queue = Event() if queue.next(): self.video_in_queue.set()
def initialize_mumble(self, md: MumbleData): global_settings.mumble_inst = pymumble.Mumble(md.ip_address, port=md.port, user=md.user_id, reconnect=md.auto_reconnect, password=md.password, certfile=md.certificate, stereo=md.stereo) # Callback - message_received global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, global_settings.clbk_service.message_received) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self.message_received) # Callback - sound_received global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_SOUNDRECEIVED, global_settings.clbk_service.sound_received) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_SOUNDRECEIVED, self.sound_received) # Callback - on_connected global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CONNECTED, global_settings.clbk_service.connected) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_CONNECTED, self.on_connected) # Callback - disconnected global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_DISCONNECTED, global_settings.clbk_service.disconnected) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_DISCONNECTED, self.on_disconnected) # Callback - user_created global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERCREATED, global_settings.clbk_service.user_created) # Callback - user_updated global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERUPDATED, global_settings.clbk_service.user_updated) # Callback - user_removed global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERREMOVED, global_settings.clbk_service.user_removed) # Callback - channel_created global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELCREATED, global_settings.clbk_service.channel_created) # Callback - channel_removed global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELREMOVED, global_settings.clbk_service.channel_removed) # Callback - channel_updated global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELUPDATED, global_settings.clbk_service.channel_updated) # Callback - permission_denied global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_PERMISSIONDENIED, global_settings.clbk_service.permission_denied) global_settings.mumble_inst.set_codec_profile('audio') global_settings.mumble_inst.set_receive_sound(True) try: global_settings.mumble_inst.start() global_settings.mumble_inst.is_ready() if global_settings.cfg.getboolean(C_CONNECTION_SETTINGS, P_SELF_REGISTER, fallback=False): global_settings.mumble_inst.users.myself.register() global_settings.mumble_inst.users.myself.comment( f'{runtime_utils.get_comment()}<br>[{META_NAME}({META_VERSION})] - {runtime_utils.get_bot_name()}<br>{runtime_utils.get_about()}') runtime_utils.mute() runtime_utils.get_channel(global_settings.cfg[C_CONNECTION_SETTINGS][P_DEFAULT_CHANNEL]).move_in() except ConnectionRejectedError as e: log(CRITICAL, f"The connection to the server was rejected! {e}", origin=L_STARTUP, print_mode=PrintMode.REG_PRINT.value) return
def main(args): mumble = pymumble.Mumble(args[1], 'tf2-connect', port=int(args[2]), password=args[3]) mumble.start() mumble.is_ready() mumble.callbacks.add_callback('text_received', lambda m: recive_message(m, mumble)) while True: time.sleep(10)
def register(server_args, user, certfile, keyfile): mumble = pymumble_py3.Mumble(**server_args) mumble.start() mumble.is_ready() if not mumble.is_alive(): raise Exception(f'Connection to "{server_args["host"]}" failed') server_args['certfile'] = certfile server_args['keyfile'] = keyfile server_args['user'] = user admin = pymumble_py3.Mumble(**server_args) admin.start() admin.is_ready() if not admin.is_alive(): raise Exception( f'Connection to "{server_args["host"]}" as "{user}" failed') admin.users[mumble.users.myself_session].register() admin.channels.new_channel(0, mumble.user, False) time.sleep(1) print(f'User {mumble.user} registered')
def initialize_mumble(self, md: MumbleData): global_settings.mumble_inst = pymumble.Mumble(md.ip_address, port=md.port, user=md.user_id, reconnect=md.auto_reconnect, password=md.password, certfile=md.certificate, stereo=md.stereo) # Callback - message_received global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, global_settings.clbk_service.message_received) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self.message_received) # Callback - sound_received global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_SOUNDRECEIVED, global_settings.clbk_service.sound_received) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_SOUNDRECEIVED, self.sound_received) # Callback - on_connected global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CONNECTED, global_settings.clbk_service.connected) global_settings.core_callbacks.append_to_callback(PYMUMBLE_CLBK_CONNECTED, self.on_connected) # Callback - disconnected global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_DISCONNECTED, global_settings.clbk_service.disconnected) # Callback - user_created global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERCREATED, global_settings.clbk_service.user_created) # Callback - user_updated global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERUPDATED, global_settings.clbk_service.user_updated) # Callback - user_removed global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_USERREMOVED, global_settings.clbk_service.user_removed) # Callback - channel_created global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELCREATED, global_settings.clbk_service.channel_created) # Callback - channel_removed global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELREMOVED, global_settings.clbk_service.channel_removed) # Callback - channel_updated global_settings.mumble_inst.callbacks.set_callback(PYMUMBLE_CLBK_CHANNELUPDATED, global_settings.clbk_service.channel_updated) global_settings.mumble_inst.set_codec_profile('audio') global_settings.mumble_inst.set_receive_sound(True) global_settings.mumble_inst.start() global_settings.mumble_inst.is_ready() if global_settings.cfg.getboolean(C_CONNECTION_SETTINGS, P_SELF_REGISTER, fallback=False): global_settings.mumble_inst.users.myself.register() global_settings.mumble_inst.users.myself.comment( f'{runtime_utils.get_comment()}<br>[{META_NAME}({META_VERSION})] - {runtime_utils.get_bot_name()}<br>{runtime_utils.get_about()}') runtime_utils.mute() runtime_utils.get_channel(global_settings.cfg[C_CONNECTION_SETTINGS][P_DEFAULT_CHANNEL]).move_in()
def connect(self, host, user, password, certfile, port, reconnect): self.user_name = user self.host = host self.port = port self.mumble = mumble.Mumble(self.host, self.user_name, port=self.port, password=password, certfile=certfile, reconnect=reconnect) self.mumble.set_application_string('StrutOS') # Set callbacks self.mumble.callbacks.set_callback(mumble.constants.PYMUMBLE_CLBK_CONNECTED, self.connected) self.mumble.callbacks.set_callback(mumble.constants.PYMUMBLE_CLBK_DISCONNECTED, self.disconnected) self.mumble.start()
def __init__(self, host, nick, port=64738, password=''): self.mutex = Lock() self.chunk_queue = [] self.remote_users = [] self.connection = pymumble3.Mumble(host, nick, port=port, password=password) self.connection.callbacks.set_callback(ON_SOUND, self.onAudio) self.connection.callbacks.set_callback(ON_TEXT, self.onText) self.connection.callbacks.set_callback(ON_DISCONNECT, self.onDisconnect) self.connection.set_receive_sound(1) self.connection.start() self.connection.is_ready() self.connection.sound_output.set_audio_per_packet(0.02)
def __init__(self, host, port, name, pw): self.client = pymumble.Mumble(host, name, password=pw, port=port, debug=False) self.client.start() self.client.is_ready() self.active = True self.immune_players = [] self.lobby = self.client.channels.find_by_name(LOBBY_NAME) self.client.callbacks.set_callback(RCV, self.message_received) self.client.users.myself.comment( "commands: roll [number], add [name] (add to immunity list), rm [name] (remove from list), clearimm (fully clear list)" )
def connect(): mumble = pymumble.Mumble( os.getenv(MUMBLE_HOSTNAME), os.getenv(MUMBLE_USERNAME), password=os.getenv(MUMBLE_PASSWORD), ) mumble.set_receive_sound = False client = Client(mumble) client.start() client.set_callbacks() client.interpret_command( Greeting(os.getenv(MUMBLE_USERNAME), '/pmb play beep_boop')) client.loop() return client
def __init__(self, hostname, port, channel, user, cert, key, stream): self.stream = stream self.mumble_channel = channel self.audio_queue = queue.Queue() self.thread_comm_queue = queue.Queue() self.mumble_conn_thread = pymumble.Mumble(host=hostname, port=port, user=user, certfile=cert, keyfile=key, debug=False, reconnect=True) self.mumble_conn_thread._set_ident() self.mumble_conn_thread.set_application_string("c3lingo (%s)" % 0.1) self.mumble_conn_thread.set_codec_profile('audio')
def __init__(self, user_name, host, port, home_channel, speech_return_delay=0.1, pymumble_loop_rate=0.05): super().__init__() self.log = logging.getLogger(__name__) self.user_name = user_name self.bot_name = self.user_name + "Bot" self.tag = "@" + self.user_name self.tag_len = len(self.tag) self.host = host self.port = port self.home = home_channel self.speech_return_delay = speech_return_delay self.pymumble_loop_rate = pymumble_loop_rate self.commands = queue.Queue() self.bot = pymumble.Mumble(self.host, self.bot_name, port=self.port, debug=False) self.bot.set_receive_sound(1) self.bot.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self.get_callback_text) self.bot.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_USERUPDATED, self.get_callback_user) self.bot.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_USERCREATED, self.get_callback_user) self.bot.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_SOUNDRECEIVED, self.get_callback_sound) self.stream_frames = {} self.stream_last_frames = {} self.stream_users = {}
def __init__(self,host,username,password,channel_src,channel_dst): self.src=channel_src self.dst=channel_dst self.cursor_time = 0.0 # time for which the audio is treated self.exit = False self.users = dict() # store some local informations about the users session # Create the mumble instance and assign callbals self.mumble = pymumble_py3.Mumble(host, username, password=password, stereo=False, reconnect=True) self.mumble.set_loop_rate(0.005) self.mumble.set_application_string("GhostBot") self.mumble.callbacks.add_callback(PYMUMBLE_CLBK_CONNECTED,self.connection_cb) self.mumble.set_receive_sound(True) self.mumble.start() # start the mumble thread self.mumble.is_ready() # wait for the end of the connection process self.loop()
def __init__(self, server_args, channelname): self.server_args = server_args self.channel = channelname self.count = 0 mumble = pymumble_py3.Mumble(**server_args) self.mumble = mumble mumble.start() mumble.is_ready() if not mumble.is_alive(): raise AppError(f'Connection to "{server_args["host"]}" failed') channel = mumble.channels.find_by_name(channelname) channel.move_in() deadline = time.monotonic() + 2 while time.monotonic() < deadline: if mumble.my_channel() == channel: break time.sleep(.1) if mumble.my_channel() != channel: raise AppError(f'Unable to move to channel "{channelname}"')
async def start(self): self.instance = pymumble_py3.Mumble(self.ip, self.nick, reconnect=True, certfile="cert.pem", keyfile="key.pem") self.instance.start() self.instance.is_ready() self.instance.users.myself.register() self.instance.my_channel().send_text_message( "Bridge bot initialised and connected.") print(str(self.instance.users)) self.removeFromGroup("tempgroup", 45) while True: print("Done") await asyncio.sleep(1)
output=True, # and listen frames_per_buffer=CHUNK, input_device_index=found_device_id) # mumble client set up def sound_received_handler(user, soundchunk): """ play sound received from mumble server upon its arrival """ stream.write(soundchunk.pcm) # Spin up a client and connect to mumble server print("Connecting to " + server) mumble = pymumble_py3.Mumble(server, nick, password=pwd, port=port, stereo=CHANNELS == 2) # set up callback called when PCS event occurs mumble.callbacks.set_callback(PCS, sound_received_handler) #mumble.set_receive_sound(1) # Enable receiving sound from mumble server mumble.start() mumble.is_ready() # Wait for client is ready target_channel = mumble.channels[int(config[configname_for_server]['channel'])] if target_channel is not None: print("Moving into remembered channel '" + target_channel['name'] + "'") target_channel.move_in() else: print("Channel ID " + config[configname_for_server]['channel'] + " not found")
def __init__(self, args): self.log = logging.getLogger("bot") self.log.info("bot: botamusique version %s, starting..." % self.version) signal.signal(signal.SIGINT, self.ctrl_caught) self.cmd_handle = {} self.volume_set = var.config.getfloat('bot', 'volume') if var.db.has_option('bot', 'volume'): self.volume_set = var.db.getfloat('bot', 'volume') self.volume = self.volume_set if args.channel: self.channel = args.channel else: self.channel = var.config.get("server", "channel", fallback=None) var.user = args.user var.music_folder = util.solve_filepath( var.config.get('bot', 'music_folder')) var.tmp_folder = util.solve_filepath( var.config.get('bot', 'tmp_folder')) var.is_proxified = var.config.getboolean("webinterface", "is_web_proxified") self.exit = False self.nb_exit = 0 self.thread = None self.thread_stderr = None self.is_pause = False self.pause_at_id = "" self.playhead = -1 self.song_start_at = -1 self.last_ffmpeg_err = "" self.read_pcm_size = 0 # self.download_threads = [] self.wait_for_ready = False # flag for the loop are waiting for download to complete in the other thread self.on_killing = threading.Lock( ) # lock to acquire when killing ffmpeg thread is asked but ffmpeg is not # killed yet if args.host: host = args.host else: host = var.config.get("server", "host") if args.port: port = args.port else: port = var.config.getint("server", "port") if args.password: password = args.password else: password = var.config.get("server", "password") if args.channel: self.channel = args.channel else: self.channel = var.config.get("server", "channel") if args.certificate: certificate = args.certificate else: certificate = util.solve_filepath( var.config.get("server", "certificate")) if args.tokens: tokens = args.tokens else: tokens = var.config.get("server", "tokens") tokens = tokens.split(',') if args.user: self.username = args.user else: self.username = var.config.get("bot", "username") self.mumble = pymumble.Mumble(host, user=self.username, port=port, password=password, tokens=tokens, debug=var.config.getboolean( 'debug', 'mumbleConnection'), certfile=certificate) self.mumble.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self.message_received) self.mumble.set_codec_profile("audio") self.mumble.start() # start the mumble thread self.mumble.is_ready() # wait for the connection if self.mumble.connected >= pymumble_py3.constants.PYMUMBLE_CONN_STATE_FAILED: exit() self.set_comment() self.mumble.users.myself.unmute() # by sure the user is not muted self.join_channel() self.mumble.set_bandwidth(200000) self.is_ducking = False self.on_ducking = False self.ducking_release = time.time() self.last_volume_cycle_time = time.time() if not var.db.has_option("bot", "ducking") and var.config.getboolean("bot", "ducking", fallback=False) \ or var.config.getboolean("bot", "ducking"): self.is_ducking = True self.ducking_volume = var.config.getfloat("bot", "ducking_volume", fallback=0.05) self.ducking_volume = var.db.getfloat("bot", "ducking_volume", fallback=self.ducking_volume) self.ducking_threshold = var.config.getfloat("bot", "ducking_threshold", fallback=5000) self.ducking_threshold = var.db.getfloat( "bot", "ducking_threshold", fallback=self.ducking_threshold) self.mumble.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_SOUNDRECEIVED, self.ducking_sound_received) self.mumble.set_receive_sound(True) assert var.config.get("bot", "when_nobody_in_channel") in ['pause', 'pause_resume', 'stop', 'nothing', ''], \ "Unknown action for when_nobody_in_channel" if var.config.get("bot", "when_nobody_in_channel", fallback='') in ['pause', 'pause_resume', 'stop']: self.mumble.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_USERREMOVED, self.users_changed) self.mumble.callbacks.set_callback( pymumble.constants.PYMUMBLE_CLBK_USERUPDATED, self.users_changed) # Debug use self._loop_status = 'Idle' self._display_rms = False self._max_rms = 0 self.redirect_ffmpeg_log = var.config.getboolean('debug', 'redirect_ffmpeg_log', fallback=True) if var.config.getboolean("bot", "auto_check_update"): th = threading.Thread(target=self.check_update, name="UpdateThread") th.daemon = True th.start() last_startup_version = var.db.get("bot", "version", fallback=None) if not last_startup_version or version.parse( last_startup_version) < version.parse(self.version): var.db.set("bot", "version", self.version) changelog = util.fetch_changelog().replace("\n", "<br>") self.send_channel_msg( constants.strings("update_successful", version=self.version, changelog=changelog))
#print("Received sound from user \"" + user['name'] + "\".") # Convert sound format. Mumble uses 16 bit mono 48 kHz little-endian, which needs to be downsampled to 8 kHz: buffer, newstate = audioop.ratecv(soundchunk.pcm, 2, 1, 48000, AudioSlot1.PCMSAMPLERATE, None) if MumbleVolume != 1: buffer = audioop.mul(buffer, 2, MumbleVolume) AudioSlot1.playBuffer(buffer, DMR_CallType, DMR_DstId) print("HytMumbleBridge 0.01") signal.signal(signal.SIGINT, signal_handler) AudioSlot1 = AudioSlot("TS1", RPT_IP, RCP_PORT_TS1, RTP_PORT_TS1) AudioSlot2 = AudioSlot("TS2", RPT_IP, RCP_PORT_TS2, RTP_PORT_TS2) print("Connecting to Mumble server \"" + MumbleServer + "\" on port " + str(MumblePort) + "...") mumble = pymumble.Mumble(MumbleServer, MumbleNick, port=MumblePort, password=MumblePassword) mumble.callbacks.set_callback(PYMUMBLE_CLBK_SOUNDRECEIVED, MumbleSoundReceivedHandler) mumble.set_receive_sound(True) mumble.start() mumble.is_ready() if MumbleChannel > "": mumble.channels.find_by_name(MumbleChannel).move_in() print("Running... (press CTRL+C to exit)") while True: time.sleep(60)
CHUNK = 1024 server = "" pwd = "recorder" # password nick = "recorder" # username port = 64738 # port number outputFilename = "./output.wav" output = wave.open(outputFilename, "w") output.setnchannels(1) output.setsampwidth(2) output.setframerate(48000) def sound_receive_handler(user, soundchunk): output.writeframesraw(soundchunk.pcm) mumble = pymumble_py3.Mumble(server, nick, password=pwd, port=port) mumble.callbacks.set_callback(PCS, sound_receive_handler) mumble.set_receive_sound(1) mumble.start() mumble.is_ready() # Wait for client is ready print("server ready") for timeout in range(0, 10): sleep(1) output.close() print("done writting")
print( "Default configuration has been written to config.ini. Edit the necessary values and then run the bot again." ) sys.exit(0) except FileExistsError: with open("config.ini", "w") as config_file: config.write(config_file, space_around_delimiters=True) if config_file_regenerated: print( "Some sections were missing from config.ini and have been regenerated. If it's all good, run the bot again." ) sys.exit(0) client = pymumble.Mumble(config["connect"].get("host"), config["login"].get("username"), port=config["connect"].getint("port"), password=config["login"].get("password", None), certfile=config["login"].get("certfile", None), keyfile=config["login"].get("keyfile", None)) listened_user = None listened_user_deafen_time = timeit.default_timer() - 1 muting = False def set_muting(mute=muting): global muting muting = mute # I'm checking for muting outside of the for loop because I figured that'd # be faster if mute: for user in tracked_channel.get_users():
userlist.write(config_file) error = 0 x = x + 1 if error == 1: # если не существует получателя сообщения mumble.users[user].send_text_message( 'Какая-то ошибка, проверь формат команды или имя пользователя') else: text = 'Я передам Ваше сообщение' mumble.users[user].send_text_message(text) # говорим как подключиться боту к серверу mumble = pymumble_py3.Mumble(host=config['Server']['address'], user=config['Bot']['Bot_name'], port=int(config['Server']['port']), password=config['Server']['password'], certfile=config['Bot']['certfile'], reconnect=True, tokens=config['Server']['tokens']) # к колбэкам прикручиваем функции-обработчики mumble.callbacks.set_callback(PCTMR, message_received) mumble.callbacks.set_callback(PCUU, user_change_channel) mumble.callbacks.set_callback(PCUC, user_connect_server) # подключаем бота к серверу mumble.start() # костыль time.sleep(5) print('костыль функционирует') kostyl1 = 1 # циклим всё, чтобы бот не отключался
def __init__(self, args): self.log = logging.getLogger("bot") self.log.info(f"bot: botamusique version {self.get_version()}, starting...") signal.signal(signal.SIGINT, self.ctrl_caught) self.cmd_handle = {} self.stereo = var.config.getboolean('bot', 'stereo', fallback=True) if args.channel: self.channel = args.channel else: self.channel = var.config.get("server", "channel", fallback=None) var.user = args.user var.is_proxified = var.config.getboolean( "webinterface", "is_web_proxified") # Flags to indicate the bot is exiting (Ctrl-C, or !kill) self.exit = False self.nb_exit = 0 # Related to ffmpeg thread self.thread = None self.thread_stderr = None self.read_pcm_size = 0 self.pcm_buffer_size = 0 self.last_ffmpeg_err = "" # Play/pause status self.is_pause = False self.pause_at_id = "" self.playhead = -1 # current position in a song. self.song_start_at = -1 self.wait_for_ready = False # flag for the loop are waiting for download to complete in the other thread # self.on_interrupting = False if args.host: host = args.host else: host = var.config.get("server", "host") if args.port: port = args.port else: port = var.config.getint("server", "port") if args.password: password = args.password else: password = var.config.get("server", "password") if args.channel: self.channel = args.channel else: self.channel = var.config.get("server", "channel") if args.certificate: certificate = args.certificate else: certificate = util.solve_filepath(var.config.get("server", "certificate")) if args.tokens: tokens = args.tokens else: tokens = var.config.get("server", "tokens") tokens = tokens.split(',') if args.user: self.username = args.user else: self.username = var.config.get("bot", "username") if args.bandwidth: self.bandwidth = args.bandwidth else: self.bandwidth = var.config.getint("bot", "bandwidth") self.mumble = pymumble.Mumble(host, user=self.username, port=port, password=password, tokens=tokens, stereo=self.stereo, debug=var.config.getboolean('debug', 'mumbleConnection'), certfile=certificate) self.mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, self.message_received) self.mumble.set_codec_profile("audio") self.mumble.start() # start the mumble thread self.mumble.is_ready() # wait for the connection if self.mumble.connected >= pymumble.constants.PYMUMBLE_CONN_STATE_FAILED: exit() self.set_comment() self.mumble.users.myself.unmute() # by sure the user is not muted self.join_channel() self.mumble.set_bandwidth(self.bandwidth) # ====== Volume ====== self.volume_helper = util.VolumeHelper() _volume = var.config.getfloat('bot', 'volume', fallback=0.8) if var.db.has_option('bot', 'volume'): _volume = var.db.getfloat('bot', 'volume') self.volume_helper.set_volume(_volume) self.is_ducking = False self.on_ducking = False self.ducking_release = time.time() self.last_volume_cycle_time = time.time() self._ducking_volume = 0 _ducking_volume = var.config.getfloat("bot", "ducking_volume", fallback=0.50) _ducking_volume = var.db.getfloat("bot", "ducking_volume", fallback=_ducking_volume) self.volume_helper.set_ducking_volume(_ducking_volume) self.ducking_threshold = var.config.getfloat("bot", "ducking_threshold", fallback=5000) self.ducking_threshold = var.db.getfloat("bot", "ducking_threshold", fallback=self.ducking_threshold) if not var.db.has_option("bot", "ducking") and var.config.getboolean("bot", "ducking", fallback=False) \ or var.config.getboolean("bot", "ducking"): self.is_ducking = True self.mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_SOUNDRECEIVED, self.ducking_sound_received) self.mumble.set_receive_sound(True) assert var.config.get("bot", "when_nobody_in_channel") in ['pause', 'pause_resume', 'stop', 'nothing', ''], \ "Unknown action for when_nobody_in_channel" if var.config.get("bot", "when_nobody_in_channel", fallback='') in ['pause', 'pause_resume', 'stop']: user_change_callback = \ lambda user, action: threading.Thread(target=self.users_changed, args=(user, action), daemon=True).start() self.mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_USERREMOVED, user_change_callback) self.mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_USERUPDATED, user_change_callback) # Debug use self._loop_status = 'Idle' self._display_rms = False self._max_rms = 0 self.redirect_ffmpeg_log = var.config.getboolean('debug', 'redirect_ffmpeg_log', fallback=True) if var.config.getboolean("bot", "auto_check_update"): def check_update(): nonlocal self new_version, changelog = util.check_update(self.get_version()) if new_version: self.send_channel_msg(tr('new_version_found', new_version=new_version, changelog=changelog)) th = threading.Thread(target=check_update, name="UpdateThread") th.daemon = True th.start() last_startup_version = var.db.get("bot", "version", fallback=None) if not last_startup_version or version.parse(last_startup_version) < version.parse(self.version): var.db.set("bot", "version", self.version) if var.config.getboolean("bot", "auto_check_update"): changelog = util.fetch_changelog() self.send_channel_msg(tr("update_successful", version=self.version, changelog=changelog))
def connect_check(): print("PYMUMBLE_CLBK_CONNECTED: pass") def disconnect_check(): global running print("PYMUMBLE_CLBK_DISCONNECTED: pass") print("Client has disconnected. Exiting...") running = False def voice_check(user, sound): # a user has spoken, so reset their idle timer user_idle_data[user['session']] = sound.time mumble = pymumble.Mumble(config.get("server"), config.get("nick"), password=config.get("password"), certfile=config.get("certfile"), port=int(config.get("port"))) mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_TEXTMESSAGERECEIVED, process_message) mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_CONNECTED, connect_check) mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_DISCONNECTED, disconnect_check) mumble.callbacks.set_callback(pymumble.constants.PYMUMBLE_CLBK_SOUNDRECEIVED, voice_check) mumble.set_receive_sound(True) mumble.start() mumble.is_ready() channel_name = config.get("channel") if channel_name: channel = mumble.channels.find_by_name(channel_name) channel.move_in() while running: probe_users()