Пример #1
0
def collect_objects(package, recursive=False):
    """
    Run through `$PACKAGE.objects` and collect all objects which
    are subclasses of the superclasses provided in the
    `$PACKAGE.objects.initialize` function.
    """
    pack_objects = load_package_module(package,'objects')
    super_clss, nullary_types = pack_objects.initialize()

    classes = {}
    inherited = {}

    for clsname, cls in pack_objects.__dict__.iteritems():
        if type(cls) is TypeType and issubclass(cls,tuple(super_clss)):
            classes[cls.__name__] = cls

    if recursive:
        for cls in classes.itervalues():
            for scls in all_subclasses(cls):
                inherited[scls.__name__] =  scls

    if recursive:
        return classes, inherited
    else:
        return classes
Пример #2
0
def build_pure_lookup(force=False):
    if pure_trans.loaded and not force:
        return

    for name in settings.INSTALLED_MATH_PACKAGES:
        pack_module = load_package(name)
        package = wise.meta_inspector.PACKAGES[name]

        if module_has_submodule(pack_module, 'objects'):
            print 'Building Pure translation table from ... ' + name

            pack_objects = load_package_module(name,'objects')
            super_clss, nullary_types = pack_objects.initialize()

            # Populate the Pure translation table with nullary
            # objects
            pure_trans.populate(nullary_types)

    _pure_trans = {}
    for cls in python_trans.table.values():
        if hasattr(cls,'pure'):
            _pure_trans[cls.pure] = cls

    pure_trans.populate(_pure_trans)

    return pure_trans
Пример #3
0
def build_python_lookup(force=False):
    if python_trans.loaded and not force:
        return

    for name in settings.INSTALLED_MATH_PACKAGES:
        pack_module = load_package(name)
        package = wise.meta_inspector.PACKAGES[name]

        if module_has_submodule(pack_module, 'objects'):
            print 'Building Python translation table from ... ' + name

            pack_objects = load_package_module(name,'objects')
            super_clss, nullary_types = pack_objects.initialize()

            first_order_symbols, all_symbols = collect_objects(name, recursive=True)
            python_trans.populate(first_order_symbols)
            python_trans.populate(all_symbols)

            # Give the package a list of strings containing the
            # classnames of the provided symbols and update the
            # persistence in memory value and sync to the disk
            if not package.provided_symbols:
                wise.meta_inspector.PACKAGES.make_writable()

                for sym in first_order_symbols.iterkeys():
                    package.provides(sym)

                wise.meta_inspector.PACKAGES[name] = package
                wise.meta_inspector.PACKAGES.sync()
            else:
                if settings.DEBUG:
                    pass
                    #print 'Not rebuilding symbol table for:', name

    return python_trans
Пример #4
0
def build_panels(force=False):
    if panels and not settings.NOCACHE:
        print 'Using cached panels file.'
        return

    for pack_name in settings.INSTALLED_MATH_PACKAGES:
        print 'Importing panels from ... ' + pack_name
        pack_module = loader.load_package(pack_name)

        # Load PACKAGE/panel.py
        if module_has_submodule(pack_module, 'panel'):
            pack_panels = loader.load_package_module(pack_name,'panel')

            panels.make_writable()
            for panel_name, symbol in pack_panels.__dict__.iteritems():
                if is_panel(symbol):
                    symbol.package = pack_name
                    panels[panel_name] = symbol

            panels.sync()
Пример #5
0
import os

from inspect import getargspec
from types import TypeType

from django.conf import settings
from django.template import Context

from wise.worksheet.utils import load_haml_template
from wise.worksheet.utils import trim_docstring
from wise.utils.patterns import Aggregator
from wise.utils.module_loading import module_has_submodule
from wise.packages import loader

Placeholder = loader.load_package_module('base','objects').Placeholder
panels = Aggregator(file='cache/panels_cache')

def _map_panel_types(obj):
    # If we have a Class read the argument signature of the
    # __init__ function and fill in all required arguments with
    # Placeholders.
    # Example:
    #   Addition -> Addition(Placeholder(),Placeholder())
    if isinstance(obj, TypeType):
        # Get the number of arguments the __init__ function for
        # the mathobject takes and substitute placeholder in for
        # each argument
        args, varargs, keywords, defaults = getargspec(obj.__init__)

        # decrement the len(args) since we ignore the self
        # argument
Пример #6
0
from django.utils import simplejson as json
from django.views.generic import ListView, DetailView
from django.views.generic.edit import (UpdateView, DeleteView,
    CreateView)
from wise.translators.pytopure import parse_sexp
from wise.worksheet import models
from wise.worksheet.forms import WorksheetForm
from wise.worksheet.utils import *
from wise.packages import loader

from operator import itemgetter

wise.boot.start_python_pure()
panel.build_panels()

basecell = loader.load_package_module('base','cell')

#---------------------------
# Home Page
#---------------------------

class HomeView(ListView):
    model = models.Workspace
    template_name = "home.html"
    context_object_name = 'workspaces'

    def get_queryset(self):
        return models.Workspace.objects.filter(owner=self.request.user)

#---------------------------
# Worksheet CRUD
Пример #7
0
from django import template
from wise.worksheet.utils import load_haml_template
from wise.packages.loader import load_package_module
from wise.worksheet.utils import purify
base_objects = load_package_module('base','objects')

def initialize():
    super_classes = [Integral, Diff, Taylor]
    nullary_types = {}

    return super_classes, nullary_types

class Integral(base_objects.Term):
    """
    This symbol is used to represent indefinite integration of
    unary functions. The first argument is the unary function the
    second argument is a variable of integration.
    """

    show_parenthesis = True
    html = load_haml_template('integral.tpl')
    pure = 'integrate'

    def __init__(self, f, dx):
        self.integrand = f
        self.variable = dx
        self.terms = [f, dx]

    def _pure_(self):
        return self.po(self.integrand._pure_(),self.variable._pure_())
Пример #8
0
Файл: viz.py Проект: sdiehl/wise
def package_to_graph(package):
    tops, nullary = load_package_module(package,'objects').initialize()
    return pycls2graph(*tops)