def __new__(cls, *args, **kwargs):
        """
        When creating a new ANSIString, you may use a custom parser that has
        the same attributes as the standard one, and you may declare the
        string to be handled as already decoded. It is important not to double
        decode strings, as escapes can only be respected once.
        """
        string = args[0]
        if not isinstance(string, basestring):
            string = to_str(string, force_string=True)
        parser = kwargs.get('parser', ANSI_PARSER)
        decoded = kwargs.get('decoded', False) or hasattr(string, '_raw_string')
        if not decoded:
            # Completely new ANSI String
            clean_string = to_unicode(parser.parse_ansi(string, strip_ansi=True))
            string = parser.parse_ansi(string)
        elif hasattr(string, '_clean_string'):
            # It's already an ANSIString
            clean_string = string._clean_string
            string = string._raw_string
        else:
            # It's a string that has been pre-ansi decoded.
            clean_string = parser.strip_raw_codes(string)

        if not isinstance(string, unicode):
            string = string.decode('utf-8')
        else:
            # Do this to prevent recursive ANSIStrings.
            string = unicode(string)
        ansi_string = super(ANSIString, cls).__new__(ANSIString, to_str(clean_string), "utf-8")
        ansi_string._raw_string = string
        ansi_string._clean_string = clean_string
        return ansi_string

    def reload(self, filename=None, form=None, **kwargs):
        """
        Creates the form from a stored file name
        """
        # clean kwargs (these cannot be overridden)
        kwargs.pop("enforce_size", None)
        kwargs.pop("width", None)
        kwargs.pop("height", None)

        if form or self.input_form_dict:
            datadict = form if form else self.input_form_dict
            self.input_form_dict = datadict
        elif filename or self.filename:
            filename = filename if filename else self.filename
            datadict = all_from_module(filename)
            self.filename = filename
        else:
            datadict = {}

        cellchar = to_str(datadict.get("FORMCHAR", "x"))
        self.cellchar = to_str(cellchar[0] if len(cellchar) > 1 else cellchar)
        tablechar = datadict.get("TABLECHAR", "c")
        self.tablechar = tablechar[0] if len(tablechar) > 1 else tablechar

        # split into a list of list of lines. Form can be indexed with form[iy][ix]
        self.raw_form = to_unicode(datadict.get("FORM", "")).split("\n")
        # strip first line
        self.raw_form = self.raw_form[1:] if self.raw_form else self.raw_form

        self.options.update(kwargs)

        # parse and replace
        self.mapping = self._parse_rectangles(self.cellchar, self.tablechar, self.raw_form, **kwargs)
        self.form = self._populate_form(self.raw_form, self.mapping)

def connect_to_rss(connection):
    """
    Create the parser instance and connect to RSS feed and channel
    """
    global RSS_READERS
    key = utils.to_str(connection.external_key)
    url, interval = [utils.to_str(conf) for conf in connection.external_config.split('|')]
    # Create reader (this starts the running task and stores a reference in RSS_TASKS)
    RSSReader(key, url, int(interval))

    def msg_irc(self, msg, senders=None):
        """
        Called by evennia when sending something to mapped IRC channel.

        Note that this cannot simply be called msg() since that's the
        name of of the twisted irc hook as well, this leads to some
        initialization messages to be sent without checks, causing loops.
        """
        self.msg(utils.to_str(self.factory.channel), utils.to_str(msg))

 def forwards(self, orm):
     "Write your forwards methods here."
     for attr in orm.ScriptAttribute.objects.all():
         try:
             # repack attr into new format, and reimport
             val = pickle.loads(to_str(attr.db_value))
             attr.db_value = to_unicode(pickle.dumps(to_str(to_attr(from_attr(attr, val)))))
             attr.save()
         except TypeError, RuntimeError:
             pass

def connect_to_irc(connection):
    "Create the bot instance and connect to the IRC network and channel."
    # get config
    key = utils.to_str(connection.external_key)
    service_key = build_service_key(key)
    irc_network, irc_port, irc_channel, irc_bot_nick = [utils.to_str(conf) for conf in connection.external_config.split('|')]
    # connect
    bot = internet.TCPClient(irc_network, int(irc_port), IRCbotFactory(key, irc_channel, irc_network, irc_port, irc_bot_nick,
                                                                     connection.channel.key))
    bot.setName(service_key)
    SESSIONS.server.services.addService(bot)

    def __new__(cls, *args, **kwargs):
        """
        When creating a new ANSIString, you may use a custom parser that has
        the same attributes as the standard one, and you may declare the
        string to be handled as already decoded. It is important not to double
        decode strings, as escapes can only be respected once.

        Internally, ANSIString can also passes itself precached code/character
        indexes and clean strings to avoid doing extra work when combining
        ANSIStrings.
        """
        string = args[0]
        if not isinstance(string, basestring):
            string = to_str(string, force_string=True)
        parser = kwargs.get('parser', ANSI_PARSER)
        decoded = kwargs.get('decoded', False) or hasattr(string, '_raw_string')
        code_indexes = kwargs.pop('code_indexes', None)
        char_indexes = kwargs.pop('char_indexes', None)
        clean_string = kwargs.pop('clean_string', None)
        # All True, or All False, not just one.
        checks = map(lambda x: x is None, [code_indexes, char_indexes, clean_string])
        if not len(set(checks)) == 1:
            raise ValueError("You must specify code_indexes, char_indexes, "
                             "and clean_string together, or not at all.")
        if not all(checks):
            decoded = True
        if not decoded:
            # Completely new ANSI String
            clean_string = to_unicode(parser.parse_ansi(string, strip_ansi=True))
            string = parser.parse_ansi(string)
        elif clean_string is not None:
            # We have an explicit clean string.
            pass
        elif hasattr(string, '_clean_string'):
            # It's already an ANSIString
            clean_string = string._clean_string
            code_indexes = string._code_indexes
            char_indexes = string._char_indexes
            string = string._raw_string
        else:
            # It's a string that has been pre-ansi decoded.
            clean_string = parser.strip_raw_codes(string)

        if not isinstance(string, unicode):
            string = string.decode('utf-8')

        ansi_string = super(ANSIString, cls).__new__(ANSIString, to_str(clean_string), "utf-8")
        ansi_string._raw_string = string
        ansi_string._clean_string = clean_string
        ansi_string._code_indexes = code_indexes
        ansi_string._char_indexes = char_indexes
        return ansi_string

 def __set_obj(self, value):
     """
     Set player or obj to their right database field. If
     a dbref is given, assume ObjectDB.
     """
     try:
         value = _GA(value, "dbobj")
     except AttributeError:
         pass
     if isinstance(value, (basestring, int)):
         from src.objects.models import ObjectDB
         value = to_str(value, force_string=True)
         if (value.isdigit() or value.startswith("#")):
             dbid = dbref(value, reqhash=False)
             if dbid:
                 try:
                     value = ObjectDB.objects.get(id=dbid)
                 except ObjectDoesNotExist:
                     # maybe it is just a name that happens to look like a dbid
                     pass
     if value.__class__.__name__ == "PlayerDB":
         fname = "db_player"
         _SA(self, fname, value)
     else:
         fname = "db_obj"
         _SA(self, fname, value)
     # saving the field
     _GA(self, "save")(update_fields=[fname])

 def forwards(self, orm):
     "Write your forwards methods here."
     for attr in orm.PlayerAttribute.objects.all():
         try:
             # repack attr into new format, and reimport
             val = pickle.loads(to_str(attr.db_value))
             if hasattr(val, '__iter__'):
                 val = ("iter", val)
             elif type(val) == PackedDBobject:
                 val = ("dbobj", val)
             else:
                 val = ("simple", val)
             attr.db_value = to_unicode(pickle.dumps(to_str(to_attr(from_attr(attr, val)))))
             attr.save()
         except TypeError, RuntimeError:
             pass

    def data_out(self, string='', data=None):
        """
        Data Evennia -> Player access hook.

        data argument may be used depending on
        the client-server implementation.
        """

        if data:
            # treat data?
            pass

        # string handling is similar to telnet
        try:
            string = utils.to_str(string, encoding=self.encoding)

            nomarkup = False
            raw = False
            if type(data) == dict:
                # check if we want escape codes to go through unparsed.
                raw = data.get("raw", False)
                # check if we want to remove all markup
                nomarkup = data.get("nomarkup", False)
            if raw:
                self.client.lineSend(self.suid, string)
            else:
                self.client.lineSend(self.suid, parse_html(string, strip_ansi=nomarkup))
            return
        except Exception, e:
            logger.log_trace()

    def parse_ansi(self, string, strip_ansi=False, xterm256=False):
        """
        Parses a string, subbing color codes according to
        the stored mapping.

        strip_ansi flag instead removes all ansi markup.

        """
        if hasattr(string, 'raw_string'):
            if strip_ansi:
                return string.clean_string
            else:
                return string.raw_string
        if not string:
            return ''
        self.do_xterm256 = xterm256
        string = utils.to_str(string)

        # go through all available mappings and translate them
        parts = self.ansi_escapes.split(string) + [" "]
        string = ""
        for part, sep in zip(parts[::2], parts[1::2]):
            for sub in self.ansi_sub:
                part = sub[0].sub(sub_meth(self, sub[1]), part)
            string += "%s%s" % (part, sep[0].strip())
        if strip_ansi:
            # remove all ansi codes (including those manually
            # inserted in string)
            string = self.ansi_regex.sub("", string)
        return string

  def run_diagnostics(self):
    print('Running diagnostics...')
    # diagnostic runs on validation set
    validation_images   = self.dataHandler.validation_images
    validation_labels   = self.dataHandler.validation_labels
    y                   = self.graphHelper.y
    predict             = self.graphHelper.predict

    val_labels  = np.zeros(validation_images.shape[0])
    val_y       = np.zeros((validation_images.shape[0], 10))

    for i in range(0,validation_images.shape[0]//BATCH_SIZE):
        b1 = i*BATCH_SIZE
        b2 = (i+1)*BATCH_SIZE
        fd = self._get_eval_dict('other', dataset = validation_images[b1:b2])
        val_labels[b1:b2], val_y[b1:b2] = self.sess.run([predict, y], feed_dict=fd)

    # dump diagnostics to file
    to_file = []
    bad_img = []
    bad_lbs = []
    for i in range(0, len(val_labels)):
        val_label_dense     = np.argmax(validation_labels[i])
        if val_labels[i] != val_label_dense:
            bad_img.append(validation_images[i])
            bad_lbs.append(validation_labels[i])
            to_file.append('index: '+ str(i)+
                           ', predicted: '+str(val_labels[i])+
                           ', target: '+str(val_label_dense)+
                           ', probs: '+utils.to_str(val_y[i]))

    utils.save_diagnostics(to_file)

 def _set_foreign(cls, fname, value):
     "Setter only used on foreign key relations, allows setting with #dbref"
     try:
         value = _GA(value, "dbobj")
     except AttributeError:
         pass
     if isinstance(value, (basestring, int)):
         value = to_str(value, force_string=True)
         if (value.isdigit() or value.startswith("#")):
             # we also allow setting using dbrefs, if so we try to load the matching object.
             # (we assume the object is of the same type as the class holding the field, if
             # not a custom handler must be used for that field)
             dbid = dbref(value, reqhash=False)
             if dbid:
                 model = _GA(cls, "_meta").get_field(fname).model
                 try:
                     value = model._default_manager.get(id=dbid)
                 except ObjectDoesNotExist:
                     # maybe it is just a name that happens to look like a dbid
                     pass
     _SA(cls, fname, value)
     # only use explicit update_fields in save if we actually have a
     # primary key assigned already (won't be set when first creating object)
     update_fields = [fname] if _GA(cls, "_get_pk_val")(_GA(cls, "_meta")) is not None else None
     _GA(cls, "save")(update_fields=update_fields)

    def msg(self, text=None, from_obj=None, sessid=0, **kwargs):
        """
        Emits something to a session attached to the object.

        message (str): The message to send
        from_obj (obj): object that is sending.
        data (object): an optional data object that may or may not
                       be used by the protocol.
        sessid (int): sessid to relay to, if any.
                      If set to 0 (default), use either from_obj.sessid (if set) or self.sessid automatically
                      If None, echo to all connected sessions
        """
        global _SESSIONS
        if not _SESSIONS:
            from src.server.sessionhandler import SESSIONS as _SESSIONS

        text = to_str(text, force_string=True) if text else ""

        if "data" in kwargs:
            # deprecation warning
            logger.log_depmsg("ObjectDB.msg(): 'data'-dict keyword is deprecated. Use **kwargs instead.")
            data = kwargs.pop("data")
            if isinstance(data, dict):
                kwargs.update(data)

        if from_obj:
            # call hook
            try:
                _GA(from_obj, "at_msg_send")(text=text, to_obj=self, **kwargs)
            except Exception:
                pass

        session = _SESSIONS.session_from_sessid(sessid if sessid else _GA(self, "sessid"))
        if session:
            session.msg(text=text, **kwargs)

    def msg(self, outgoing_string, from_obj=None, data=None, sessid=None):
        """
        Evennia -> User
        This is the main route for sending data back to the user from the server.

        outgoing_string (string) - text data to send
        from_obj (Object/Player) - source object of message to send
        data (dict) - arbitrary data object containing eventual protocol-specific options
        sessid - the session id of the session to send to. If not given, return to
                 all sessions connected to this player. This is usually only
                 relevant when using msg() directly from a player-command (from
                 a command on a Character, the character automatically stores and
                 handles the sessid).
        """
        if from_obj:
            # call hook
            try:
                _GA(from_obj, "at_msg_send")(outgoing_string, to_obj=self, data=data)
            except Exception:
                pass
        outgoing_string = utils.to_str(outgoing_string, force_string=True)

        session = _MULTISESSION_MODE == 2 and sessid and _GA(self, "get_session")(sessid) or None
        if session:
            obj = session.puppet
            if obj and not obj.at_msg_receive(outgoing_string, from_obj=from_obj, data=data):
                # if hook returns false, cancel send
                return
            session.msg(outgoing_string, data)
        else:
            # if no session was specified, send to them all
            for sess in _GA(self, "get_all_sessions")():
                sess.msg(outgoing_string, data)

    def data_out(self, text=None, **kwargs):
        """
        Data Evennia -> Player.
        generic hook method for engine to call in order to send data
        through the telnet connection.

        valid telnet kwargs:
            oob=<string> - supply an Out-of-Band instruction.
            xterm256=True/False - enforce xterm256 setting. If not
                                  given, ttype result is used. If
                                  client does not suport xterm256, the
                                  ansi fallback will be used
            ansi=True/False - enforce ansi setting. If not given,
                              ttype result is used.
            nomarkup=True - strip all ansi markup (this is the same as
                            xterm256=False, ansi=False)
            raw=True - pass string through without any ansi
                       processing (i.e. include Evennia ansi markers but do
                       not convert them into ansi tokens)

        The telnet ttype negotiation flags, if any, are used if no kwargs
        are given.
        """
        try:
            text = utils.to_str(text if text else "", encoding=self.encoding)
        except Exception, e:
            self.sendLine(str(e))
            return

 def send_split_msg(self, sessid, msg, data, command):
     """
     This helper method splits the sending of a msg into multiple parts
     with a maxlength of MAXLEN. This is to avoid repetition in the two
     msg-sending commands. When calling this, the maximum length has
     already been exceeded.
     Inputs:
         msg - string
         data - data dictionary
         command - one of MsgPortal2Server or MsgServer2Portal commands
     """
     # split the strings into acceptable chunks
     datastr = dumps(data)
     nmsg, ndata = len(msg), len(datastr)
     if nmsg > MAXLEN or ndata > MAXLEN:
         msglist = [msg[i:i+MAXLEN] for i in range(0, len(msg), MAXLEN)]
         datalist = [datastr[i:i+MAXLEN] for i in range(0, len(datastr), MAXLEN)]
     nmsglist, ndatalist = len(msglist), len(datalist)
     if ndatalist < nmsglist:
         datalist.extend("" for i in range(nmsglist-ndatalist))
     if nmsglist < ndatalist:
         msglist.extend("" for i in range(ndatalist-nmsglist))
     # we have split the msg/data into right-size chunks. Now we send it in sequence
     return [self.callRemote(command,
                     sessid=sessid,
                     msg=to_str(msg),
                     ipart=icall,
                     nparts=nmsglist,
                     data=dumps(data)).addErrback(self.errback, "OOBServer2Portal")
             for icall, (msg, data) in enumerate(zip(msglist, datalist))]

 def call_remote_MsgServer2Portal(self, sessid, msg, data=""):
     """
     Access method called by the Server and executed on the Server.
     """
     #print "msg server->portal (server side):", sessid, msg, data
     return self.safe_send(MsgServer2Portal, sessid,
                           msg=to_str(msg) if msg is not None else "",
                           data=dumps(data))

 def call_remote_MsgPortal2Server(self, sessid, msg, data=""):
     """
     Access method called by the Portal and executed on the Portal.
     """
     #print "msg portal->server (portal side):", sessid, msg, data
     return self.safe_send(MsgPortal2Server, sessid,
                           msg=to_str(msg) if msg is not None else "",
                           data=dumps(data))

 def update(self, new_value, *args, **kwargs):
     "Called by cache when attribute's db_value field updates"
     try:
         new_value = new_value.dbobj
     except AttributeError:
         new_value = to_str(new_value, force_string=True)
     # this is a wrapper call for sending oob data back to session
     self.oobhandler.msg(self.sessid, "report", self.attrname, new_value, *args, **kwargs)