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()
