Beispiel #1
0
class TemplateLogNode(TemplateAttribNode):

    def __init__(self):
        TemplateAttribNode.__init__(self)
        self._level = TemplateWordNode("debug")
        self._output = TemplateWordNode("logging")

    @property
    def level(self):
        return self._level

    @level.setter
    def level(self, level):
        self._level = level

    def resolve_to_string(self, client_context):
        resolved = self.resolve_children_to_string(client_context)

        output = self._output.resolve_to_string(client_context)
        level = self._level.resolve_to_string(client_context)

        if output == "logging":
            YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
            if level == "debug":
                YLogger.debug(client_context, resolved)
            elif level == "warning":
                YLogger.warning(client_context, resolved)
            elif level == "error":
                YLogger.error(client_context, resolved)
            elif level == "info":
                YLogger.info(client_context, resolved)
            else:
                YLogger.info(client_context, resolved)
        else:
            print(resolved)

        return ""

    def to_string(self):
        return "[LOG level=%s]" % (self._level.to_string())

    def set_attrib(self, attrib_name, attrib_value):
        if attrib_name != 'level' and attrib_name != 'output':
            raise ParserException("Invalid attribute name %s for this node", attrib_name)

        if attrib_name == 'level':
            if isinstance(attrib_value, TemplateWordNode):
                self._level = attrib_value
            else:
                self._level = TemplateWordNode(attrib_value)
        if attrib_name == 'output':
            if isinstance(attrib_value, TemplateWordNode):
                self._output = attrib_value
            else:
                self._output = TemplateWordNode(attrib_value)

    def to_xml(self, client_context):
        xml = "<log"
        if self._level is not None:
            xml += ' level="%s"' % self._level.to_xml(client_context)
        xml += ">"
        xml += self.children_to_xml(client_context)
        xml += "</log>"
        return xml

    #######################################################################################################
    # LOG_EXPRESSION ::== <log>Message</log>
    #                           <log level="error|warning|debug|info">Message</log>
    #

    def parse_expression(self, graph, expression):
        self._parse_node_with_attribs(graph, expression, [["level", "debug"],["output", "logging"]])
Beispiel #2
0
class TemplateDateNode(TemplateAttribNode):

    def __init__(self, date_format=None, locale=None):
        TemplateAttribNode.__init__(self)

        if date_format is None:
            self._format = TemplateWordNode("%c")
        else:
            self._format = TemplateWordNode(date_format)

        self._locale = None
        if locale is not None:
            self._locale = TemplateWordNode(locale)

    @property
    def date_format(self):
        return self._format

    @date_format.setter
    def date_format(self, fmt):
        if isinstance(fmt, TemplateNode):
            self._format = fmt
        else:
            self._format = TemplateWordNode(str(fmt))

    @property
    def locale(self):
        return self._locale

    @locale.setter
    def locale(self, lcl):
        if isinstance(lcl, TemplateNode):
            self._locale = lcl
        else:
            self._locale = TemplateWordNode(str(lcl))

    def _set_locate(self, client_context):
        local_locale = self._locale.resolve_to_string(client_context)
        locale.setlocale(locale.LC_TIME, local_locale)
        return local_locale

    def resolve_to_string(self, client_context):
        time_now = datetime.datetime.now()

        local_time = None
        if self._locale is not None:
            local_time = locale.setlocale(locale.LC_TIME)

        local_locale = ""
        resolved = ""
        try:
            if self._locale is not None:
                local_locale = self._set_locate(client_context)

            resolved_format = self._format.resolve_to_string(client_context)
            resolved = time_now.strftime(resolved_format)

        except Exception as exep:
            YLogger.exception(self, "Failed to set locale to [%s]", exep, local_locale)

        finally:
            if local_time is not None:
                locale.setlocale(locale.LC_TIME, local_time)

        YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
        return resolved

    def to_string(self):
        if self._locale is None:
            return "[DATE format=%s]" % self._format.to_string()
        else:
            return "[DATE format=%s locale=%s]" % (self._format.to_string(), self._locale.to_string())

    def set_attrib(self, attrib_name, attrib_value):

        if attrib_name == 'format':
            if isinstance(attrib_value, TemplateNode):
                self._format = attrib_value
            else:
                self._format = TemplateWordNode(attrib_value)

        elif attrib_name == 'locale':
            if isinstance(attrib_value, TemplateNode):
                self._locale = attrib_value
            else:
                self._locale = TemplateWordNode(attrib_value)

        else:
            raise ParserException("Invalid attribute name %s for this node" % (attrib_name))

    def to_xml(self, client_context):
        if self._locale is None:
            xml = '<date format="%s" >' % self._format.to_xml(client_context)
        else:
            xml = '<date format="%s" locale="%s">' % (self._format.to_xml(client_context),
                                                      self._locale.to_xml(client_context))

        xml += self.children_to_xml(client_context)
        xml += "</date>"
        return xml

    #######################################################################################################
    # DATE_ATTRIBUTES ::== (format="LISP_DATE_FORMAT") | (jformat="JAVA DATE FORMAT")
    # DATE_ATTRIBUTE_TAG ::== <format>TEMPLATE_EXPRESSION</format> | <jformat>TEMPLATE_EXPRESSION</jformat>
    # DATE_EXPRESSION ::== <date( DATE_ATTRIBUTES)*/> | <date>(DATE_ATTRIBUTE_TAG)</date>
    # Pandorabots supports three extension attributes to the date element in templates:
    #     	locale
    #       format
    #       timezone

    def parse_expression(self, graph, expression):
        self._parse_node_with_attribs(graph, expression, [["format", "%c"], ["locale", None]])
Beispiel #3
0
class TemplateIntervalNode(TemplateNode):
    def __init__(self, date_format="%c", style="days"):
        TemplateNode.__init__(self)
        self._interval_from = None
        self._interval_to = None
        if isinstance(date_format, str):
            self._format = TemplateWordNode(date_format)
        else:
            self._format = date_format
        if isinstance(style, str):
            self._style = TemplateWordNode(style)
        else:
            self._style = style

    @property
    def format(self):
        return self._format

    @format.setter
    def format(self, format):
        self._format = format

    @property
    def interval_from(self):
        return self._interval_from

    @interval_from.setter
    def interval_from(self, interval_from):
        self._interval_from = interval_from

    @property
    def interval_to(self):
        return self._interval_to

    @interval_to.setter
    def interval_to(self, interval_to):
        self._interval_to = interval_to

    @property
    def style(self):
        return self._style

    @style.setter
    def style(self, style):
        self._style = style

    def resolve(self, bot, clientid):
        try:
            format_str = self._format.resolve(bot, clientid)

            from_str = self.interval_from.resolve(bot, clientid)
            from_time = datetime.datetime.strptime(from_str, format_str)

            to_str = self.interval_to.resolve(bot, clientid)
            to_time = datetime.datetime.strptime(to_str, format_str)

            style = self._style.resolve(bot, clientid)

            diff = to_time - from_time
            difference = relativedelta(to_time, from_time)

            if style == "years":
                resolved = str(difference.years)
            elif style == "months":
                resolved = str(difference.months)
            elif style == "weeks":
                resolved = str(difference.weeks)
            elif style == "days":
                resolved = str(diff.days)
            elif style == "hours":
                resolved = str(difference.hours)
            elif style == "minutes":
                resolved = str(difference.minutes)
            elif style == "seconds":
                resolved = str(difference.seconds)
            elif style == "microseconds":
                resolved = str(difference.microseconds)
            elif style == "ymd":
                resolved = "%d years, %d months, %d days" % \
                           (difference.years, difference.months, difference.days)
            elif style == "hms":
                resolved = "%d hours, %d minutes, %d seconds" % \
                           (difference.hours, difference.minutes, difference.seconds)
            elif style == "ymdhms":
                resolved = "%d years, %d months, %d days, %d hours, %d minutes, %d seconds" % \
                           (difference.years, difference.months, difference.days,
                            difference.hours, difference.minutes, difference.seconds)
            else:
                logging.error("Unknown interval style [%s]", style)
                resolved = ""

            logging.debug("[INTERVAL] resolved to [%s]", resolved)
            return resolved

        except Exception as excep:
            logging.exception(excep)
            return ""

    def to_string(self):
        return "[INTERVAL]"

    def to_xml(self, bot, clientid):
        xml = '<interval'
        xml += ' format="%s"' % self._format.to_xml(bot, clientid)
        xml += ' style="%s"' % self._style.to_xml(bot, clientid)
        xml += '>'
        xml += '<from>'
        xml += self._interval_from.to_xml(bot, clientid)
        xml += '</from>'
        xml += '<to>'
        xml += self._interval_to.to_xml(bot, clientid)
        xml += '</to>'
        xml += '</interval>'
        return xml
Beispiel #4
0
class TemplateSystemNode(TemplateAttribNode):
    def __init__(self):
        TemplateAttribNode.__init__(self)
        self._timeout = TemplateWordNode("0")

    @property
    def timeout(self):
        return self._timeout

    @timeout.setter
    def timeout(self, timeout):
        self._timeout = TemplateWordNode(str(timeout))

    def resolve_to_string(self, client_context):
        if client_context.brain.configuration.overrides.allow_system_aiml is True:
            command = self.resolve_children_to_string(client_context)
            process = subprocess.Popen(command,
                                       shell=True,
                                       stdout=subprocess.PIPE,
                                       stderr=subprocess.STDOUT)
            result = []
            for line in process.stdout.readlines():
                byte_string = line.decode("utf-8")
                result.append(byte_string.strip())

            process.wait()
            resolved = " ".join(result)

        else:
            YLogger.warning(client_context,
                            "System command node disabled in config")
            resolved = ""

        YLogger.debug(client_context, "[%s] resolved to [%s]",
                      self.to_string(), resolved)
        return resolved

    def to_string(self):
        return "[SYSTEM timeout=%s]" % (self._timeout.to_string())

    def set_attrib(self, attrib_name, attrib_value):
        if attrib_name != 'timeout':
            raise ParserException("Invalid attribute name [%s] for this node" %
                                  attrib_name)
        YLogger.warning(self, "System node timeout attrib currently ignored")
        self._timeout = attrib_value

    def to_xml(self, client_context):
        xml = "<system"

        timeout = self._timeout.to_xml(client_context)

        if timeout != "0":
            xml += ' timeout="%s"' % timeout

        xml += ">"
        xml += self.children_to_xml(client_context)
        xml += "</system>"

        return xml

    #######################################################################################################
    # SYSTEM_EXPRESSION ::==
    # 		<system( TIMEOUT_ATTRIBUTE)>TEMPLATE_EXPRESSION</system> |
    #  		<system><timeout>TEMPLATE_EXPRESSION</timeout></system>
    # TIMEOUT_ATTRIBUTE :== timeout=”NUMBER”

    def parse_expression(self, graph, expression):
        self._parse_node_with_attrib(graph, expression, "timeout", "0")
Beispiel #5
0
class TemplateIntervalNode(TemplateNode):

    def __init__(self, date_format="%c", style="days"):
        TemplateNode.__init__(self)
        self._interval_from = None
        self._interval_to = None
        if isinstance(date_format, str):
            self._format = TemplateWordNode(date_format)
        else:
            self._format = date_format
        if isinstance(style, str):
            self._style = TemplateWordNode(style)
        else:
            self._style = style

    @property
    def format(self):
        return self._format

    @format.setter
    def format(self, format):
        self._format = format

    @property
    def interval_from(self):
        return self._interval_from

    @interval_from.setter
    def interval_from(self, interval_from):
        self._interval_from = interval_from

    @property
    def interval_to(self):
        return self._interval_to

    @interval_to.setter
    def interval_to(self, interval_to):
        self._interval_to = interval_to

    @property
    def style(self):
        return self._style

    @style.setter
    def style(self, style):
        self._style = style

    def resolve(self, bot, clientid):
        try:
            format_str = self._format.resolve(bot, clientid)

            from_str = self.interval_from.resolve(bot, clientid)
            from_time = datetime.datetime.strptime(from_str, format_str)

            to_str = self.interval_to.resolve(bot, clientid)
            to_time = datetime.datetime.strptime(to_str, format_str)

            style = self._style.resolve(bot, clientid)

            diff = to_time - from_time
            difference = relativedelta(to_time, from_time)

            if style == "years":
                resolved = str(difference.years)
            elif style == "months":
                resolved = str(difference.months)
            elif style == "weeks":
                resolved = str(difference.weeks)
            elif style == "days":
                resolved = str(diff.days)
            elif style == "hours":
                resolved = str(difference.hours)
            elif style == "minutes":
                resolved = str(difference.minutes)
            elif style == "seconds":
                resolved = str(difference.seconds)
            elif style == "microseconds":
                resolved = str(difference.microseconds)
            elif style == "ymd":
                resolved = "%d years, %d months, %d days" % \
                           (difference.years, difference.months, difference.days)
            elif style == "hms":
                resolved = "%d hours, %d minutes, %d seconds" % \
                           (difference.hours, difference.minutes, difference.seconds)
            elif style == "ymdhms":
                resolved = "%d years, %d months, %d days, %d hours, %d minutes, %d seconds" % \
                           (difference.years, difference.months, difference.days,
                            difference.hours, difference.minutes, difference.seconds)
            else:
                logging.error("Unknown interval style [%s]", style)
                resolved = ""

            logging.debug("[INTERVAL] resolved to [%s]", resolved)
            return resolved

        except Exception as excep:
            logging.exception(excep)
            return ""

    def to_string(self):
        return "[INTERVAL]"

    def to_xml(self, bot, clientid):
        xml = '<interval'
        xml += ' format="%s"' % self._format.to_xml(bot, clientid)
        xml += ' style="%s"' % self._style.to_xml(bot, clientid)
        xml += '>'
        xml += '<from>'
        xml += self._interval_from.to_xml(bot, clientid)
        xml += '</from>'
        xml += '<to>'
        xml += self._interval_to.to_xml(bot, clientid)
        xml += '</to>'
        xml += '</interval>'
        return xml