Example #1
0
def get_message(sock, settings, state):

    """
    Read a message from the IRC connection, simulaneously making sure
    to keep the connection alive and handling the IRC statey business.
    Returns the message, perhaps with convenience information attached.

    """

    raw_message = network.read(sock)

    if raw_message:
        message = from_raw(raw_message)
        response = manage(message, settings, state)
        if response:
            send_message(sock, response)
        elif message.command == 'PRIVMSG':
            return message

        return None

    if settings.channel != state.joined:
        if state.joined:
            send_message(sock, Message.part(state.joined))
        send_message(sock, Message.join(settings.channel))
        return None
 def test_maxClusterSize(self):
     self.assertEqual(1, self.crowd.maxClusterSize)
     message2 = Message(4, 'sdf', 'A project to cluster high-dimensional streams.', test_time)
     message2.vector=Vector({2:4})
     stream2 = Stream(4, message2)
     self.cluster.addDocument(stream2)
     self.assertEqual(2, self.crowd.maxClusterSize)
Example #3
0
def show_start_wave(user_info, surface):
    global WAVE_TIME, START_WAVE, CREATE_WAVE
    start_wave = Message(surface, (0, 10), ('Start Wave ' + str(user_info.wave + 1) + '/' + str(user_info.waves)),
                         font=pg.font.SysFont('comicsansms', 24, True), bg_color=BROWN)
    start_wave.rect.right = 48*TILE_SIZE - 10
    start_wave.blit()
    user_info.start_wave = start_wave
Example #4
0
def manage(message, settings, state):

    """
    Takes a message and determines if it requires some administrative
    connection management, such as responding to a PING, or changing
    nicks, or joining channels or whatever. Returns a message to be
    sent to the server with the action taken. If None is returned, no
    action needs to be taken by the server.

    """

    if message.command == 'PING':
        return Message.pong(*message.arguments)
    elif message.command == '403':
        # Channel doesn't exist, stop trying to join
        settings.channel = None
    elif message.command == '433':
        def generate_nick(nick):
            truncated = nick[:min(len(nick), 6)]
            alphabet = string.ascii_lowercase + string.digits
            random_chars = ''.join(random.choice(alphabet) for _ in range(2))
            return '{}_{}'.format(truncated, random_chars)

        logger.warning('Nick %s is already in use', state.nick)

        state.nick = generate_nick(settings.nick)
        return Message.nick(state.nick)
    elif message.command == '001':
        state.nick = message.arguments[0]
    elif message.command == 'JOIN':
        if getattr(message, 'origin', None) == state.nick:
            state.joined = message.arguments[0]
 def convertTweetJSONToMessage(tweet, **twitter_stream_settings):
     tweetTime = getDateTimeObjectFromTweetTimestamp(tweet['created_at'])
     message = Message(tweet['user']['screen_name'], tweet['id'], tweet['text'], tweetTime)
     message.vector = Vector()
     for phrase in getPhrases(getWordsFromRawEnglishMessage(tweet['text']), twitter_stream_settings['min_phrase_length'], twitter_stream_settings['max_phrase_length']):
         if phrase not in message.vector: message.vector[phrase]=0
         message.vector[phrase]+=1
     return message
Example #6
0
 def test_maxClusterSize(self):
     self.assertEqual(1, self.crowd.maxClusterSize)
     message2 = Message(4, 'sdf',
                        'A project to cluster high-dimensional streams.',
                        test_time)
     message2.vector = Vector({2: 4})
     stream2 = Stream(4, message2)
     self.cluster.addDocument(stream2)
     self.assertEqual(2, self.crowd.maxClusterSize)
Example #7
0
 def setUp(self):
     self.m1 = Message(1, 'sdf',
                       'A project to cluster high-dimensional streams.',
                       test_time - timedelta(seconds=60))
     self.m1.vector = Vector({1: 1., 2: 3.})
     self.stream = Stream(1, self.m1)
     self.m2 = Message(1, 'sdf',
                       'A project to cluster high-dimensional streams.',
                       test_time)
     self.m2.vector = Vector({2: 3.})
Example #8
0
 def convertTweetJSONToMessage(tweet, **twitter_stream_settings):
     tweetTime = getDateTimeObjectFromTweetTimestamp(tweet['created_at'])
     message = Message(tweet['user']['screen_name'], tweet['id'],
                       tweet['text'], tweetTime)
     message.vector = Vector()
     for phrase in getPhrases(getWordsFromRawEnglishMessage(tweet['text']),
                              twitter_stream_settings['min_phrase_length'],
                              twitter_stream_settings['max_phrase_length']):
         if phrase not in message.vector: message.vector[phrase] = 0
         message.vector[phrase] += 1
     return message
 def getClusterFromMapFormat(clusterMap):
     dummyMessage = Message(1, '', '', datetime.now())
     dummyMessage.vector=Vector({})
     dummyStream=Stream(1, dummyMessage)
     cluster = StreamCluster(dummyStream)
     cluster.clusterId = clusterMap['clusterId']
     cluster.lastStreamAddedTime = getDateTimeObjectFromTweetTimestamp(clusterMap['lastStreamAddedTime'])
     cluster.mergedClustersList = clusterMap['mergedClustersList']
     cluster.documentsInCluster = clusterMap['streams']
     for k,v in clusterMap['dimensions'].iteritems(): cluster[k]=v
     return cluster
Example #10
0
 def getClusterFromMapFormat(clusterMap):
     dummyMessage = Message(1, '', '', datetime.now())
     dummyMessage.vector = Vector({})
     dummyStream = Stream(1, dummyMessage)
     cluster = StreamCluster(dummyStream)
     cluster.clusterId = clusterMap['clusterId']
     cluster.lastStreamAddedTime = getDateTimeObjectFromTweetTimestamp(
         clusterMap['lastStreamAddedTime'])
     cluster.mergedClustersList = clusterMap['mergedClustersList']
     cluster.documentsInCluster = clusterMap['streams']
     for k, v in clusterMap['dimensions'].iteritems():
         cluster[k] = v
     return cluster
Example #11
0
def from_raw(raw_message):

    """
    Deserialises an inbound message, returning a Message object.

    """

    user, command, args, last_arg = basic_parse(raw_message)
    if last_arg:
        args.append(last_arg)
    message = Message(command, arguments=args)
    message.user = user
    return message
Example #12
0
def getMessage():
    error = False
    id = request.json['id']
    new = Message()
    try:
        new.get(id)
    except (Exception) as err:
        error = True
        return handleError(err)
    finally:
        if not (error):
            result = new.json()
            return jsonify({'result': 'success', 'data': result})
Example #13
0
def hello(sock, settings, state):
    
    """
    Sends the basic identy information to the IRC server and sets some
    initial state required by the rest of the irc module procedures.

    """

    send_message(sock, Message.nick(settings.nick))
    send_message(sock, Message.user(settings.nick,
                                    'Bot {}'.format(settings.nick)))

    state.nick = settings.nick
    state.joined = ''
Example #14
0
def addMessage():
    error = False
    msg = request.json['msg']
    id_user = request.json['id_user']
    id_chat = request.json['id_chat']
    read = request.json['read']
    new = Message(msg, None, id_user, id_chat, read)
    try:
        new.add()
    except (Exception) as err:
        error = True
        return handleError(err)
    finally:
        if not (error):
            return jsonify({'result': 'success'})
Example #15
0
def cmd_help(args):
    if len(args) == 0:
        msg =\
"""
For additional help, run `!help <command name>` e.g. `!help !roll`

Available commands:
"""
        for cmd in commands.list:
            msg += "`{cmd}`: {desc}\n".format(cmd=cmd.name, desc=cmd.desc)
    else:
        msg = ""
        for name in args:
            if name in commands.map.keys():
                cmd = commands.map[name]
                if type(cmd.help) is str:
                    msg += cmd.help
                elif cmd.help is None:
                    msg += "Usage: `{cmd}`\n{desc}".format(cmd=cmd.name,
                                                           desc=cmd.desc)
                else:
                    msg += cmd.help(args[1:]).content
            else:
                msg += "`{name}` is not a valid command".format(name=name)
            msg += '\n'
    return Message(content=msg)
Example #16
0
 def setUp(self):
     self.message = Message(
         1, 'sdf', 'A project to cluster high-dimensional streams.',
         datetime.now())
     self.message.vector = Vector({1: 2., 2: 3.})
     self.s1 = Stream(1, self.message)
     self.v1 = Vector({1: 2., 3: 3.})
Example #17
0
    def send(self, user_id, message: Message):
        if isinstance(message, str):
            message = Message(content=message)

        assert (isinstance(message, Message))

        payload = {
            "recipient": {
                "id": user_id
            },
            "message": dict(),
            "notification_type": message.notification_type.value,
            "messaging_type": message.message_type.value
        }

        if message.content:
            payload["message"]["text"] = message.content

        if message.quick_replies:
            payload["message"]["quick_replies"] = [
                x.to_dict() for x in message.quick_replies
            ]

        if message.metadata:
            payload["message"]["metadata"] = message.metadata

        if message.tag:
            payload["tag"] = message.tag

        self.send_raw(payload)
Example #18
0
    def handler_custom_email(self, req: MessagingEntry):
        req.sender.send(
            Message(content="Thanks for signing up! You just got $250!"))

        self.balances[req.sender.id] = 250.0
        self.emails[req.sender.id] = req.message
        req.sender.set_state("Home")
        req.continue_processing = True
def createMockData():
    connection = sqlite3.connect(DATABASE_URI)
    c = connection.cursor()
    c.execute("DELETE FROM users")
    c.execute("DELETE FROM messages")
    connection.commit()
    connection.close()
    user = User("*****@*****.**", hash("abcde"),"John","Smith","Decidedly male","Kansas City","Murica")
    user2 = User("*****@*****.**", hash("abcdef"),"John","Wick","Surely male","Missouri","Murica")

    message = Message(user.email, user.email, "Hello World!")
    message2 = Message(user.email, user2.email, "Hej World!")

    addUser(user)
    addUser(user2)
    addMessage(message)
    addMessage(message2)
Example #20
0
def settings_changed(old_settings, new_settings):
    
    """
    What do we need to take care of when settings are reloaded?

    """

    yield Message.nick(new_settings.nick)
Example #21
0
def gg(surface):
    global RETRY_COUNTER
    draw_tint(RED, surface)
    gg1 = Message(surface, (480, 223), ' You Lost All      ', font=pg.font.SysFont('comicsansms', 56, True),
                  bg_color=BROWN)
    gg2 = Message(surface, (480, 300), '      Your Lives...', font=pg.font.SysFont('comicsansms', 56, True),
                  bg_color=BROWN)
    gg1.blit()
    gg2.blit()
    RETRY_COUNTER += DT
    if RETRY_COUNTER >= 2:
        user.try_again = Message(surface, (565, 420), 'Try Again?', font=pg.font.SysFont('comicsansms', 58, True),
                                 bg_color=GREEN)
        user.try_again.blit()
Example #22
0
def congrats(surface):
    global RETRY_COUNTER
    draw_tint(GREEN, surface)
    c1 = Message(surface, (480, 220), 'You Completed ', font=pg.font.SysFont('comicsansms', 60, True),
                 bg_color=BROWN)
    c2 = Message(surface, (480, 300), 'All the Waves! ', font=pg.font.SysFont('comicsansms', 60, True),
                 bg_color=BROWN)
    c1.blit()
    c2.blit()
    RETRY_COUNTER += DT
    if RETRY_COUNTER >= 2:
        user.try_again = Message(surface, (560, 420), 'Play Again?', font=pg.font.SysFont('comicsansms', 58, True),
                                 bg_color=GREEN)
        user.try_again.blit()
Example #23
0
 def send_signup(self, user):
     user.send(
         Message(content="Welcome to PayBot! What's your email?",
                 quick_replies=[
                     QuickReply("",
                                action=ExecuteFunction(self.save_email),
                                content_type=ContentType.email)
                 ]))
     user.set_state("WaitingEmail")
Example #24
0
def help_stats(args):
    msg =\
"""
Usage: `!stats <subcommand>`

Subcommands:
"""
    msg += commands_stats.help_commands(args)
    return Message(msg)
Example #25
0
 def send_home_options(self, user: User):
     user.send(
         Message(content="What do you want to do?",
                 quick_replies=[
                     QuickReply("Pay", ExecuteFunction(self.prompt_pay)),
                     QuickReply("Get balance",
                                ExecuteFunction(self.send_balance)),
                     QuickReply("Something else", SetState("Advanced"))
                 ]))
Example #26
0
def _command(message, arguments, state):

    match = re.fullmatch(
        r'^(.+) (in|on|at) (.+) with "(.+)"',
        arguments
    )

    if match:
        if not state.subscriptions:
            state.subscriptions = Heap()

        who = match.group(1)
        if who == 'me':
            who = message.origin

        preposition = match.group(2)
        when = match.group(3)
        try:
            if preposition == 'in':
                when = when.split(':')
                when = datetime.now() + timedelta(hours=int(when[0]),
                                                  minutes=int(when[1]))
            elif preposition == 'on':
                when = datetime.strptime('%Y-%m-%d', when)
            elif preposition == 'at':
                now = datetime.now()
                when = when.split(':')

                now.hour = int(when[0])
                now.minute = int(when[0])

                when = now
        except Exception as e:
            logger.exception(e)
            yield Message.privmsg(message.recipient, message.origin
                                  + ': Come again?')
            return

        what = match.group(4)

        state.subscriptions.push((when, who, preposition, what))

        yield Message.privmsg(message.recipient, message.origin
                              + ': You betcha')
Example #27
0
def test_parse_message():
    # (message "{channel}" "{text}")
    got = lisp.parse('(message "#chan" "toxt")')
    want = Message("#chan", "toxt")
    assert got == want, f"{got} == {want}"

    assert_throw(lambda: lisp.parse('(message "chan", "toxt")'))
    assert_throw(lambda: lisp.parse('(message "#oreqizer")'))
    assert_throw(lambda: lisp.parse('(message "#oreqizer" "oreqizer" asd)'))
    print("test_parse_message OK")
Example #28
0
 def setUp(self):
     self.m1 = Message(1, 'sdf',
                       'A project to cluster high-dimensional streams.',
                       test_time - timedelta(seconds=60))
     self.m1.vector = Vector({1: 2, 2: 4})
     self.stream1 = Stream(1, self.m1)
     self.m2 = Message(2, 'sdf',
                       'A project to cluster high-dimensional streams.',
                       test_time)
     self.m2.vector = Vector({2: 4})
     self.stream2 = Stream(2, self.m2)
     self.m3 = Message(3, 'sdf',
                       'A project to cluster high-dimensional streams.',
                       test_time + timedelta(seconds=60))
     self.m3.vector = Vector({2: 4})
     self.stream3 = Stream(3, self.m3)
     self.cluster1 = StreamCluster(self.stream1)
     self.cluster2 = StreamCluster(self.stream2)
     self.cluster3 = StreamCluster(self.stream3)
Example #29
0
def run(message, state):
    if message.text.endswith('++'):
        thing = message.text.rstrip('+')
        if thing in state:
            modattr(state, thing, succ)
        else:
            setattr(state, thing, 1)

        response = 'The value of {} is now {}'.format(thing, getattr(state, thing))
        yield Message.privmsg(message.recipient, response)
Example #30
0
    def execute(self, args):
        if len(args) == 0:
            return Message(
                content="Please provide a subcommand\nSubcommands:\n{}".format(
                    self.help_commands(args)))

        subcommand = args[0]
        try:
            if len(args) > 1 and args[1] == 'help':
                help_data = self.map[subcommand].help
                if type(help_data) is str: return Message(help_data)
                elif help_data is None:
                    return Message("Usage: `{name}`".format(name=subcommand))
                else:
                    return self.map[subcommand].help(args[1:])
            else:
                return self.map[subcommand].func(args[1:])
        except KeyError:
            return Message(
                content="{name} is not a valid subcommand".format(subcommand))
Example #31
0
def cmd_about(args):
    msg = \
"""
**Great Names Bot** v{ver}

This bot assists in performing die rolls and success calculation in the
Great Names system by Adam Franti.

Bot maintainer: Brandon Nguyen
""".format(ver=VERSION_STRING)
    return Message(msg)
Example #32
0
def handle(message, settings, state):
    try:
        to, text = split_text(message.text)
    except TypeError:
        pass
    else:
        if to == state.nick and text == 'hello':
            yield Message.privmsg(message.recipient, 
                'hello to you too, {}!'.format(message.origin))

    yield from run_plugins(message, settings.behaviour.command_prefix,
                           settings.plugins, state.plugins)
Example #33
0
 def handler_advanced(self, req: MessagingEntry):
     req.sender.send(
         Message(content="Your options are:",
                 quick_replies=[
                     QuickReply("Delete my account",
                                action=ExecuteFunction(
                                    self.delete_account)),
                     QuickReply("Send my location",
                                payload="",
                                content_type=ContentType.location),
                     QuickReply("Go back", SetState("Home"))
                 ]))
Example #34
0
 def test_addDocument(self):
     message1 = Message(3, 'sdf',
                        'A project to cluster high-dimensional streams.',
                        test_time)
     message1.vector = Vector({3: 4})
     stream1 = Stream(3, message1)
     message2 = Message(4, 'sdf',
                        'A project to cluster high-dimensional streams.',
                        test_time)
     message2.vector = Vector({2: 4})
     stream2 = Stream(4, message2)
     self.assertNotEqual(test_time, self.cluster1.lastStreamAddedTime)
     self.cluster1.addDocument(stream1)
     self.assertEqual(test_time, self.cluster1.lastStreamAddedTime)
     # Test if cluster id is set.
     self.assertEqual(self.cluster1.clusterId, stream1.clusterId)
     # Test that cluster mean is updated.
     self.assertEqual({1: 2 / 2., 2: 2., 3: 2.}, self.cluster1)
     # Test that cluster aggrefate is updated.
     self.assertEqual({1: 2, 2: 4, 3: 4}, self.cluster1.aggregateVector)
     # Test that document is added to cluster documents.
     self.assertEqual(stream1,
                      self.cluster1.documentsInCluster[stream1.docId])
     self.cluster1.addDocument(stream2)
     self.assertEqual(3, self.cluster1.vectorWeights)
     self.assertEqual({1: 2 / 3., 2: 8 / 3., 3: 4 / 3.}, self.cluster1)
     self.assertEqual({1: 2, 2: 8, 3: 4}, self.cluster1.aggregateVector)
 def test_addDocument(self):
     message1 = Message(3, 'sdf', 'A project to cluster high-dimensional streams.', test_time)
     message1.vector=Vector({3:4})
     stream1 = Stream(3, message1)
     message2 = Message(4, 'sdf', 'A project to cluster high-dimensional streams.', test_time)
     message2.vector=Vector({2:4})
     stream2 = Stream(4, message2)
     self.assertNotEqual(test_time, self.cluster1.lastStreamAddedTime)
     self.cluster1.addDocument(stream1)
     self.assertEqual(test_time, self.cluster1.lastStreamAddedTime)
     # Test if cluster id is set.
     self.assertEqual(self.cluster1.clusterId, stream1.clusterId)
     # Test that cluster mean is updated.
     self.assertEqual({1:2/2.,2:2.,3:2.}, self.cluster1)
     # Test that cluster aggrefate is updated.
     self.assertEqual({1:2,2:4,3:4}, self.cluster1.aggregateVector)
     # Test that document is added to cluster documents.
     self.assertEqual(stream1, self.cluster1.documentsInCluster[stream1.docId])
     self.cluster1.addDocument(stream2)
     self.assertEqual(3, self.cluster1.vectorWeights)
     self.assertEqual({1:2/3.,2:8/3.,3:4/3.}, self.cluster1)
     self.assertEqual({1:2,2:8,3:4}, self.cluster1.aggregateVector)
Example #36
0
def cmd_stats_sim_success_histogram(args):
    if len(args) < 2:
        return Message("Expected at least 2 arguments, found {}".format(
            len(args)))

    msg_parse = ""
    try:
        sample_size = int(args[0])
    except ValueError:
        msg_parse += "`{}` is not a valid integer for sample size".format(
            args[0])

    if sample_size > MAXIMUM_SAMPLE_SIZE:
        return Message(
            "`{num}` exceeds the number of maximum sample size (`{max}`)".
            format(num=sample_size, max=MAXIMUM_SAMPLE_SIZE))
    attr = 0
    try:
        attr = int(args[1])
    except ValueError:
        msg_parse += "`{}` is not a valid integer for sample size".format(
            args[1])

    n = attr
    if len(args) > 2:
        try:
            if args[2][0] == '+': n = attr + int(args[2][1:])
            else: n = int(args[2])
        except ValueError:
            msg_parse += "`{}` is not a valid integer for sample size".format(
                args[1])

    if n <= 0:
        return Message("Number of dice to be rolled must be greater than 0")

    if len(msg_parse) > 0: return Message(msg_parse)

    path = stats.success_histogram(sample_size, attr, n)
    return Message("Simulation results", file_path=path)
 def setUp(self):
     self.tweet = {'user':{'screen_name': 'abc'}, 'id':10, 'text':'A project to cluster high-dimensional streams.', 'created_at': 'Tue Mar 01 05:59:59 +0000 2011'}
     m1 = Message(1, '', '', datetime.now())
     m1.vector=Vector({'#tcot':2,'dsf':4})
     self.cluster1 = StreamCluster(Stream(1, m1))
     m2 = Message(2, '', '', datetime.now())
     m2.vector=Vector({'#tcot':4})
     self.cluster2 = StreamCluster(Stream(2, m2))
     m3 = Message(3, '', '', datetime.now())
     m3.vector=Vector(Vector({'#tcot':2}))
     m4 = Message(4, '', '', datetime.now())
     m4.vector=Vector(Vector({'#tcot':2}))
     self.doc1 = Stream(1, m3)
     self.doc2 = Stream(2, m4)
     self.meanVectorForAllDocuments = Vector.getMeanVector([self.cluster1, self.cluster2, self.doc1, self.doc2])
     self.cluster1.addDocument(self.doc1)
     self.cluster2.addDocument(self.doc2)
Example #38
0
def run(message, state):
    if state.subscriptions:
        try:
            when, who, preposition, what = state.subscriptions.pop()
        except IndexError:
            logger.debug("Didn't remind anybody")
            return
        else:
            if when <= datetime.now():
                yield Message.privmsg(message.recipient,
                                      '{}: Reminder: {}'.format(who, what))
            else:
                state.subscriptions.push((when, who, preposition, what))
    else:
        logger.debug("Didn't remind anybody")
Example #39
0
def send_message():

    data = request.args

    if not (('sender' in data) and ('receiver' in data) and ('text' in data)):
        return 'Message not correct. Try again.'

    now = datetime.now()
    dt_string = now.strftime("%d-%m-%Y %H:%M:%S")

    message = Message(data['sender'], data['receiver'], data['text'],
                      dt_string)
    response = db_i.send_message(message)

    return jsonify(response)
Example #40
0
def parse(command):
    tokens = command.split()
    cmd = tokens[0]
    args = tokens[1:]

    # run the command
    try:
        func = commands.map[cmd].func
        log('Running command \'{cmd}\' with args {args}'.format(cmd=cmd,
                                                                args=args))
        return func(args)
    except KeyError:
        # nothing to do if command not found
        pass
    except Exception as e:
        log('Ran into exception!')
        log(str(e))
        return Message("I ran into an error on my end, sorry :cry:")

    return None
Example #41
0
def run(message, state):
    last_message = state.last_message.get(message.origin)
    log.debug('Last message from %s: %s', message.origin, last_message)
    if last_message:
        subst_re = re.compile(r'^s/(.+)/(.+)/(\w)?$')

        match = subst_re.match(message.text)
        if match:
            del state['last_message'][message.origin]

            corrected = re.sub(match.group(1), match.group(2), last_message)
            log.debug('Corrected message: %s', corrected)

            yield Message.privmsg(
                message.recipient,
                'Corrected message: <{}> {}'.format(message.origin,
                                                    corrected)
            )
    else:
        log.debug('New last message for %s: %s', message.origin, message.text)
        state.last_message[message.origin] = message.text
Example #42
0
def parse_message(root):
    # (message "{channel}" "{text}")
    if len(root) != 3:
        raise Exception(
            f"invalid number of argumetns. want 3, got {len(root)}")

    channel = root[1]
    if type(channel) is not String:
        raise Exception(
            f"invalid argument #1. want {String}, got {type(channel)}")

    channel_value = repr(channel)
    if not is_channel(channel_value):
        raise Exception(
            f"invalid channel format. want #<alphanum>, got {channel_value}")

    text = root[2]
    if type(text) is not String:
        raise Exception(
            f"invalid argument #2. want {String}, got {type(text)}")

    return Message(channel_value, text.value)
Example #43
0
def new_message(data):
    u_name = data["nickname"]
    u_channel = int(data["channel"])
    u_name = u_name.encode("raw_unicode_escape").decode("utf-8")
    user = User(u_name, u_channel)
    print(u_name, u_channel)
    if user in users:
        join_room(u_channel)
        text = data["message"]
        text = text.encode("raw_unicode_escape").decode("utf-8")
        msg = Message(user, text)
        channels[u_channel].add_message(msg)
        print("收到消息:", text, "from", u_name)
        emit("write_message", {
            "nickname": u_name,
            "message": text
        },
             room=u_channel)

        nickname_array = json.dumps(channels[session["channel"]].users)
        emit("current_client_list", {"users": nickname_array},
             room=session["channel"])
    else:
        print('未登录!')
Example #44
0
def cmd_roll(args):
    if len(args) == 0:
        return "Please provide an attribute score\n" + help_roll

    try:
        attr = int(args[0])
        args = args[1:]
    except ValueError:
        return "`{num}` is not a valid integer".format(num=args[0])

    bonus = 0
    if len(args) > 0:
        try:
            bonus = int(args[0])
            args = args[1:]
        except ValueError:
            return "`{num}` is not a valid integer".format(num=args[0])

    n = attr
    if len(args) > 0:
        try:
            if args[0][0] == '+':
                # relative add
                n = attr + int(args[0][1:])
            else:
                # absolute count
                n = int(args[0])
            args = args[1:]
        except ValueError:
            return "`{num}` is not a valid integer".format(num=args[0])

    if n <= 0:
        return Message("Number of dice to be rolled must be greater than 0")
    if n > MAXIMUM_DICE:
        return "`{num}` exceeds the number of dice that can be rolled ({max_dice})".format(
            num=n, max_dice=MAXIMUM_DICE)

    result = roller.roll(attr, bonus, n)

    # print rolls
    msg = ""
    for roll in result.rolls[0:-1]:
        if roll <= attr: fmt = '**'
        elif roll == 10: fmt = '~~'
        else: fmt = ''
        msg += "{fmt}{val}{fmt}, ".format(fmt=fmt, val=str(roll))
    if len(result.rolls) > 0:
        roll = result.rolls[-1]
        if roll <= attr: fmt = '**'
        elif roll == 10: fmt = '~~'
        else: fmt = ''
        msg += "{fmt}{val}{fmt}".format(fmt=fmt, val=str(roll))

    # print explanation
    msg +=\
"""

Rolled {n} {n_noun} with an attribute score of {attr} and {bonus} bonus successes.
{successes} rolled {rs_noun}, {bonus} bonus {bs_noun}, and {negations} {neg_noun}

**Total successes: {total}  {emoji}**
""".format(n=n, n_noun=('die' if n==1 else 'dice'), attr=attr, bonus=result.bonus,
           successes=result.successes, negations=result.negations, total=result.total,
           rs_noun='success' if result.successes == 1 else 'successes',
           bs_noun='success' if result.bonus == 1 else 'successes',
           neg_noun='negation' if result.negations == 1 else 'negations',
           emoji=emoji_scale_absolute(result.total))

    return Message(content=msg)
Example #45
0
def cmd_red(args):
    black = np.random.randint(1, high=11)
    red = np.random.randint(1, high=11)
    msg = "Black: {black}\nRed: {red}".format(black=black, red=red)
    return Message(msg)
Example #46
0
def run(message, arguments, state):
    if 'called' in state:
        yield Message.privmsg(message.recipient, 'You have already tested')
    else:
        state.called = True
        yield Message.privmsg(message.recipient, 'Testing first time!')