Exemplo n.º 1
0
def _manipulate_label(x):  # gets the label that is displayed for a symbol or name
    if isinstance(x, String):
        return x.get_string_value()
    elif isinstance(x, Symbol):
        return strip_context(x.get_name())
    else:
        return str(x)
Exemplo n.º 2
0
    def _load_spacy(self, evaluation, options):
        language_code = None
        language_name = self.get_option(options, 'Language', evaluation)
        if language_name is None:
            language_name = String('Undefined')
        if isinstance(language_name, String):
            language_code = _SpacyBuiltin._language_codes.get(language_name.get_string_value())
        if not language_code:
            evaluation.message(self.get_name(), 'lang', language_name, strip_context(self.get_name()))
            return None

        instance = _SpacyBuiltin._spacy_instances.get(language_code)
        if instance:
            return instance

        try:
            if 'SPACY_DATA' in os.environ:
                instance = spacy.load(language_code, via=os.environ['SPACY_DATA'])
            else:
                instance = spacy.load(language_code)

            _SpacyBuiltin._spacy_instances[language_code] = instance
            return instance
        except RuntimeError as e:
            evaluation.message(self.get_name(), 'runtime', str(e))
            return None
Exemplo n.º 3
0
    def clear_cache(self, name=None):
        # the definitions cache (self.definitions_cache) caches (incomplete and complete) names -> Definition(),
        # e.g. "xy" -> d and "MyContext`xy" -> d. we need to clear this cache if a Definition() changes (which
        # would happen if a Definition is combined from a builtin and a user definition and some content in the
        # user definition is updated) or if the lookup rules change and we could end up at a completely different
        # Definition.

        # the lookup cache (self.lookup_cache) caches what lookup_name() does. we only need to update this if some
        # change happens that might change the result lookup_name() calculates. we do not need to change it if a
        # Definition() changes.

        # self.proxy keeps track of all the names we cache. if we need to clear the caches for only one name, e.g.
        # 'MySymbol', then we need to be able to look up all the entries that might be related to it, e.g. 'MySymbol',
        # 'A`MySymbol', 'C`A`MySymbol', and so on. proxy identifies symbols using their stripped name and thus might
        # give us symbols in other contexts that are actually not affected. still, this is a safe solution.

        if name is None:
            self.definitions_cache = {}
            self.lookup_cache = {}
            self.proxy = defaultdict(set)
        else:
            definitions_cache = self.definitions_cache
            lookup_cache = self.lookup_cache
            tail = strip_context(name)
            for k in self.proxy.pop(tail, []):
                definitions_cache.pop(k, None)
                lookup_cache.pop(k, None)
Exemplo n.º 4
0
    def get_definition(self, name, only_if_exists=False):
        definition = self.definitions_cache.get(name, None)
        if definition is not None:
            return definition

        original_name = name
        name = self.lookup_name(name)
        user = self.user.get(name, None)
        builtin = self.builtin.get(name, None)

        if user is None and builtin is None:
            definition = None
        elif builtin is None:
            definition = user
        elif user is None:
            definition = builtin
        else:
            if user:
                attributes = user.attributes
            elif builtin:
                attributes = builtin.attributes
            else:
                attributes = set()
            if not user:
                user = Definition(name=name)
            if not builtin:
                builtin = Definition(name=name)
            options = builtin.options.copy()
            options.update(user.options)
            formatvalues = builtin.formatvalues.copy()
            for form, rules in six.iteritems(user.formatvalues):
                if form in formatvalues:
                    formatvalues[form].extend(rules)
                else:
                    formatvalues[form] = rules

            definition = Definition(name=name,
                              ownvalues=user.ownvalues + builtin.ownvalues,
                              downvalues=user.downvalues + builtin.downvalues,
                              subvalues=user.subvalues + builtin.subvalues,
                              upvalues=user.upvalues + builtin.upvalues,
                              formatvalues=formatvalues,
                              messages=user.messages + builtin.messages,
                              attributes=attributes,
                              options=options,
                              nvalues=user.nvalues + builtin.nvalues,
                              defaultvalues=user.defaultvalues +
                              builtin.defaultvalues,
                              )

        if definition is not None:
            self.proxy[strip_context(original_name)].add(original_name)
            self.definitions_cache[original_name] = definition
            self.lookup_cache[original_name] = name
        elif not only_if_exists:
            definition = Definition(name=name)

        return definition
Exemplo n.º 5
0
 def do_replace(self, vars, options, evaluation):
     # The Python function implementing this builtin expects
     # argument names corresponding to the symbol names without
     # context marks.
     vars_noctx = dict(((strip_context(s), vars[s]) for s in vars))
     if options:
         return self.function(
             evaluation=evaluation, options=options, **vars_noctx)
     else:
         return self.function(evaluation=evaluation, **vars_noctx)
Exemplo n.º 6
0
    def apply_int(self, n, prop, evaluation):
        "ElementData[n_?IntegerQ, prop_]"

        from mathics.core.parser import parse

        py_n = n.to_python()
        py_prop = prop.to_python()

        # Check element specifier n or "name"
        if isinstance(py_n, int):
            if not 1 <= py_n <= 118:
                evaluation.message("ElementData", "noent", n)
                return
        elif isinstance(py_n, six.string_types):
            pass
        else:
            evaluation.message("ElementData", "noent", n)
            return

        # Check property specifier
        if isinstance(py_prop, six.string_types):
            py_prop = str(py_prop)

        if py_prop == '"Properties"':
            result = []
            for i, p in enumerate(_ELEMENT_DATA[py_n]):
                if p not in ["NOT_AVAILABLE", "NOT_APPLICABLE", "NOT_KNOWN"]:
                    result.append(_ELEMENT_DATA[0][i])
            return from_python(sorted(result))

        if not (isinstance(py_prop, six.string_types) and
                py_prop[0] == py_prop[-1] == '"' and
                py_prop.strip('"') in _ELEMENT_DATA[0]):
            evaluation.message("ElementData", "noprop", prop)
            return

        iprop = _ELEMENT_DATA[0].index(py_prop.strip('"'))
        result = _ELEMENT_DATA[py_n][iprop]

        if result == "NOT_AVAILABLE":
            return Expression("Missing", "NotAvailable")

        if result == "NOT_APPLICABLE":
            return Expression("Missing", "NotApplicable")

        if result == "NOT_KNOWN":
            return Expression("Missing", "Unknown")

        result = parse(result, evaluation.definitions)
        if isinstance(result, Symbol):
            result = String(strip_context(result.get_name()))
        return result
Exemplo n.º 7
0
    def apply(self, pattern, evaluation):
        "Names[pattern_]"

        pattern = pattern.get_string_value()
        if pattern is None:
            return

        names = set([])
        for full_name in evaluation.definitions.get_matching_names(pattern):
            short_name = strip_context(full_name)
            names.add(short_name if short_name not in names else full_name)

        # TODO: Mathematica ignores contexts when it sorts the list of
        # names.
        return Expression("List", *[String(name) for name in sorted(names)])
Exemplo n.º 8
0
 def add(self, expression, evaluation):
     expr = Expression('System`Private`ManipulateParameter', expression).evaluate(evaluation)
     if expr.get_head_name() != 'System`List':  # if everything was parsed ok, we get a List
         return False
     # convert the rules given us by ManipulateParameter[] into a dict. note: duplicate keys
     # will be overwritten, the latest one wins.
     kwargs = {'evaluation': evaluation}
     for rule in expr.leaves:
         if rule.get_head_name() != 'System`Rule' or len(rule.leaves) != 2:
             return False
         kwargs[strip_context(rule.leaves[0].to_python()).lower()] = rule.leaves[1]
     widget = kwargs['type'].get_string_value()
     del kwargs['type']
     getattr(self, '_add_%s_widget' % widget.lower())(**kwargs)  # create the widget
     return True
Exemplo n.º 9
0
    def apply(self, expr, args, evaluation):
        'Manipulate[expr_, args__]'
        if (not _jupyter) or (not Kernel.initialized()) or (Kernel.instance() is None):
            return evaluation.message('Manipulate', 'jupyter')

        instantiator = _WidgetInstantiator()  # knows about the arguments and their widgets

        for arg in args.get_sequence():
            try:
                if not instantiator.add(arg, evaluation):  # not a valid argument pattern?
                    return
            except IllegalWidgetArguments as e:
                return evaluation.message('Manipulate', 'widgetargs', strip_context(str(e.var)))
            except JupyterWidgetError as e:
                return evaluation.message('Manipulate', 'widgetmake', e.err)

        clear_output_callback = evaluation.output.clear
        display_data_callback = evaluation.output.display  # for pushing updates

        try:
            clear_output_callback(wait=True)
        except NotImplementedError:
            return evaluation.message('Manipulate', 'imathics')

        def callback(**kwargs):
            clear_output_callback(wait=True)

            line_no = evaluation.definitions.get_line_no()

            vars = [Expression('Set', Symbol(name), value) for name, value in kwargs.items()]
            evaluatable = Expression('ReleaseHold', Expression('Module', Expression('List', *vars), expr))

            result = evaluation.evaluate(evaluatable, timeout=settings.TIMEOUT)
            if result:
                display_data_callback(data=result.result, metadata={})

            evaluation.definitions.set_line_no(line_no)  # do not increment line_no for manipulate computations

        widgets = instantiator.get_widgets()
        if len(widgets) > 0:
            box = _interactive(instantiator.build_callback(callback), widgets)  # create the widget
            formatter = IPythonDisplayFormatter()
            if not formatter(box):  # make the widget appear on the Jupyter notebook
                return evaluation.message('Manipulate', 'widgetdisp')

        return Symbol('Null')  # the interactive output is pushed via kernel.display_data_callback (see above)
Exemplo n.º 10
0
    def _load_wordnet(self, evaluation, language_name):
        language_code = None
        if isinstance(language_name, String):
            language_code = iso639_3.get(language_name.get_string_value())
        if not language_code:
            evaluation.message(self.get_name(), 'lang', language_name, strip_context(self.get_name()))
            return None, None

        wordnet = _WordNetBuiltin._wordnet_instances.get(language_code)
        if not wordnet:
            try:
                wordnet = self._init_wordnet(evaluation, language_name, language_code)
            except LookupError as e:
                evaluation.message(self.get_name(), 'package', _parse_nltk_lookup_error(e))
                return None, None

            _WordNetBuiltin._wordnet_instances[language_code] = wordnet

        return wordnet, language_code
Exemplo n.º 11
0
    def _init_wordnet(self, evaluation, language_name, language_code):
        try:
            wordnet_resource = nltk.data.find('corpora/wordnet')
            _init_nltk_maps()
        except LookupError:
            evaluation.message(self.get_name(), 'package', 'wordnet')
            return None

        try:
            omw = nltk.corpus.util.LazyCorpusLoader(
                'omw', nltk.corpus.reader.CorpusReader, r'.*/wn-data-.*\.tab', encoding='utf8')
        except LookupError:
            evaluation.message(self.get_name(), 'package', 'omw')
            return None

        wordnet = nltk.corpus.reader.wordnet.WordNetCorpusReader(wordnet_resource, omw)

        if language_code not in wordnet.langs():
            evaluation.message(self.get_name(), 'lang', language_name, strip_context(self.get_name()))
            return None

        return wordnet
Exemplo n.º 12
0
def _importer_exporter_options(available_options, options, evaluation):
    stream_options = []
    custom_options = []

    if available_options and available_options.has_form('List', None):
        for name in available_options.leaves:
            if isinstance(name, String):
                py_name = name.get_string_value()
            elif isinstance(name, Symbol):
                py_name = strip_context(name.get_name())
            else:
                py_name = None

            if py_name:
                value = Builtin.get_option(options, py_name, evaluation)
                if value is not None:
                    expr = Expression('Rule', String(py_name), value)
                    if py_name == 'CharacterEncoding':
                        stream_options.append(expr)
                    else:
                        custom_options.append(expr)

    return stream_options, custom_options
Exemplo n.º 13
0
 def clear_definitions_cache(self, name):
     definitions_cache = self.definitions_cache
     tail = strip_context(name)
     for k in self.proxy.pop(tail, []):
         definitions_cache.pop(k, None)
Exemplo n.º 14
0
def options_to_rules(options, filter=None):
    items = sorted(options.items())
    if filter:
        items = [(name, value) for name, value in items
                 if strip_context(name) in filter.keys()]
    return [Expression("Rule", Symbol(name), value) for name, value in items]
Exemplo n.º 15
0
Arquivo: main.py Projeto: slel/Mathics
 def get_completion_candidates(self, text):
     matches = self.definitions.get_matching_names(text + "*")
     if "`" not in text:
         matches = [strip_context(m) for m in matches]
     return matches
Exemplo n.º 16
0
    def apply(self, symbol, evaluation):
        "SymbolName[symbol_Symbol]"

        # MMA docs say "SymbolName always gives the short name,
        # without any context"
        return String(strip_context(symbol.get_name()))
Exemplo n.º 17
0
 def __init__(self, *args, **kwargs):
     super(SympyObject, self).__init__(*args, **kwargs)
     if self.sympy_name is None:
         self.sympy_name = strip_context(self.get_name()).lower()
Exemplo n.º 18
0
 def __init__(self, *args, **kwargs):
     super(SympyObject, self).__init__(*args, **kwargs)
     if self.sympy_name is None:
         self.sympy_name = strip_context(self.get_name()).lower()
Exemplo n.º 19
0
 def apply(**kwargs):  # will override apply method
     kwargs['evaluation'].message(
         'General',
         'pyimport',  # see inout.py
         strip_context(self.get_name()),
         package)
Exemplo n.º 20
0
    def apply(self, expr, args, evaluation):
        "Manipulate[expr_, args__]"
        if (not _jupyter) or (not Kernel.initialized()) or (Kernel.instance()
                                                            is None):
            return evaluation.message("Manipulate", "jupyter")

        instantiator = (_WidgetInstantiator()
                        )  # knows about the arguments and their widgets

        for arg in args.get_sequence():
            try:
                if not instantiator.add(
                        arg, evaluation):  # not a valid argument pattern?
                    return
            except IllegalWidgetArguments as e:
                return evaluation.message("Manipulate", "widgetargs",
                                          strip_context(str(e.var)))
            except JupyterWidgetError as e:
                return evaluation.message("Manipulate", "widgetmake", e.err)

        clear_output_callback = evaluation.output.clear
        display_data_callback = evaluation.output.display  # for pushing updates

        try:
            clear_output_callback(wait=True)
        except NotImplementedError:
            return evaluation.message("Manipulate", "imathics")

        def callback(**kwargs):
            clear_output_callback(wait=True)

            line_no = evaluation.definitions.get_line_no()

            vars = [
                Expression("Set", Symbol(name), value)
                for name, value in kwargs.items()
            ]
            evaluatable = Expression(
                "ReleaseHold",
                Expression("Module", Expression("List", *vars), expr))

            result = evaluation.evaluate(evaluatable, timeout=settings.TIMEOUT)
            if result:
                display_data_callback(data=result.result, metadata={})

            evaluation.definitions.set_line_no(
                line_no
            )  # do not increment line_no for manipulate computations

        widgets = instantiator.get_widgets()
        if len(widgets) > 0:
            box = _interactive(instantiator.build_callback(callback),
                               widgets)  # create the widget
            formatter = IPythonDisplayFormatter()
            if not formatter(
                    box):  # make the widget appear on the Jupyter notebook
                return evaluation.message("Manipulate", "widgetdisp")

        return Symbol(
            "Null"
        )  # the interactive output is pushed via kernel.display_data_callback (see above)
Exemplo n.º 21
0
    def apply_name(self, expr, prop, evaluation):
        "ElementData[expr_, prop_]"

        if isinstance(expr, String):
            py_name = expr.to_python(string_quotes=False)
            names = ["StandardName", "Name", "Abbreviation"]
            iprops = [_ELEMENT_DATA[0].index(s) for s in names]

            indx = None
            for iprop in iprops:
                try:
                    indx = [element[iprop] for element in _ELEMENT_DATA[1:]
                            ].index(py_name) + 1
                except ValueError:
                    pass

            if indx is None:
                evaluation.message("ElementData", "noent", expr)
                return

            # Enter in the next if, but with expr being the index
            expr = from_python(indx)
        if isinstance(expr, Integer):
            py_n = expr.value
            py_prop = prop.to_python()

            # Check element specifier n or "name"
            if isinstance(py_n, int):
                if not 1 <= py_n <= 118:
                    evaluation.message("ElementData", "noent", expr)
                    return
            else:
                evaluation.message("ElementData", "noent", expr)
                return

            # Check property specifier
            if isinstance(py_prop, str):
                py_prop = str(py_prop)

            if py_prop == '"Properties"':
                result = []
                for i, p in enumerate(_ELEMENT_DATA[py_n]):
                    if p not in [
                            "NOT_AVAILABLE", "NOT_APPLICABLE", "NOT_KNOWN"
                    ]:
                        result.append(_ELEMENT_DATA[0][i])
                return from_python(sorted(result))

            if not (isinstance(py_prop, str)
                    and py_prop[0] == py_prop[-1] == '"'
                    and py_prop.strip('"') in _ELEMENT_DATA[0]):
                evaluation.message("ElementData", "noprop", prop)
                return

            iprop = _ELEMENT_DATA[0].index(py_prop.strip('"'))
            result = _ELEMENT_DATA[py_n][iprop]

            if result == "NOT_AVAILABLE":
                return Expression("Missing", "NotAvailable")

            if result == "NOT_APPLICABLE":
                return Expression("Missing", "NotApplicable")

            if result == "NOT_KNOWN":
                return Expression("Missing", "Unknown")

            result = evaluation.parse(result)
            if isinstance(result, Symbol):
                result = String(strip_context(result.get_name()))
            return result
Exemplo n.º 22
0
 def get_completion_candidates(self, text):
     matches = self.definitions.get_matching_names(text + '*')
     if '`' not in text:
         matches = [strip_context(m) for m in matches]
     return matches
Exemplo n.º 23
0
 def __init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     if self.numpy_name is None:
         self.numpy_name = strip_context(self.get_name()).lower()
     self.mathics_to_numpy[self.__class__.__name__] = self.numpy_name
Exemplo n.º 24
0
 def clear_definitions_cache(self, name) -> None:
     definitions_cache = self.definitions_cache
     tail = strip_context(name)
     for k in self.proxy.pop(tail, []):
         definitions_cache.pop(k, None)
Exemplo n.º 25
0
    def get_definition(self, name, only_if_exists=False) -> "Definition":
        definition = self.definitions_cache.get(name, None)
        if definition is not None:
            return definition

        original_name = name
        name = self.lookup_name(name)
        user = self.user.get(name, None)
        pymathics = self.pymathics.get(name, None)
        builtin = self.builtin.get(name, None)

        candidates = [user] if user else []
        builtin_instance = None
        if pymathics:
            builtin_instance = pymathics
            candidates.append(pymathics)
        if builtin:
            candidates.append(builtin)
            if builtin_instance is None:
                builtin_instance = builtin

        definition = candidates[0] if len(candidates) == 1 else None
        if len(candidates) > 0 and not definition:
            attributes = (user.attributes if user else
                          (pymathics.attributes if pymathics else
                           (builtin.attributes if builtin else set())))
            upvalues = ([], )
            messages = ([], )
            nvalues = ([], )
            defaultvalues = ([], )
            options = {}
            formatvalues = {
                "": [],
            }
            # Merge definitions
            its = [c for c in candidates]
            while its:
                curr = its.pop()
                options.update(curr.options)
                for form, rules in curr.formatvalues.items():
                    if form in formatvalues:
                        formatvalues[form].extend(rules)
                    else:
                        formatvalues[form] = rules
            # Build the new definition
            definition = Definition(
                name=name,
                ownvalues=sum((c.ownvalues for c in candidates), []),
                downvalues=sum((c.downvalues for c in candidates), []),
                subvalues=sum((c.subvalues for c in candidates), []),
                upvalues=sum((c.upvalues for c in candidates), []),
                formatvalues=formatvalues,
                messages=sum((c.messages for c in candidates), []),
                attributes=attributes,
                options=options,
                nvalues=sum((c.nvalues for c in candidates), []),
                defaultvalues=sum((c.defaultvalues for c in candidates), []),
                builtin=builtin_instance,
            )

        if definition is not None:
            self.proxy[strip_context(original_name)].add(original_name)
            self.definitions_cache[original_name] = definition
            self.lookup_cache[original_name] = name
        elif not only_if_exists:
            definition = Definition(name=name)
            if name[-1] != "`":
                self.user[name] = definition

        return definition
Exemplo n.º 26
0
 def apply(**kwargs):  # will override apply method
     kwargs["evaluation"].message(
         "General", "pyimport", strip_context(self.get_name()), package  # see inout.py
     )
Exemplo n.º 27
0
    def apply(self, symbol, evaluation):
        'SymbolName[symbol_Symbol]'

        # MMA docs say "SymbolName always gives the short name,
        # without any context"
        return String(strip_context(symbol.get_name()))
Exemplo n.º 28
0
 def get_word_names(self: str):
     names = self.definitions.get_names()
     short_names = [strip_context(m) for m in names]
     return list(names) + short_names