def _classdef(node, scope): imports = [] dct = {} dct['left'] = do_left(ast.Name(node.name, {}), scope) dct['name'] = node.name; dct['rname'] = resolve(node.name, scope); dct['bases'] = ', '.join(resolve(name.id, scope) for name in node.bases) dct['dec_front'] = '' dct['dec_back'] = '' for dec in node.decorator_list: js = convert_node(dec, scope) dct['dec_front'] += js+'(' dct['dec_back'] += ')' scope = new_scope(scope) scope['exp locals'] = True text = convert_block(node.body, scope) prefix = local_prefix(scope) for name in scope['locals']: text = re.sub('{:undef:' + name + ':[^:]*:}', prefix + name, text) dct['contents'] = text dct['lnum'] = len(scope['parent locals']) text = TEMPLATES['class'] % dct return text
def attribute(conv, node, scope): if node.attr in utils.reserved_words: raise SyntaxError("Sorry, '%s' is a reserved word in javascript." % node.attr) js = conv.convert_node(node.value, scope) if js == 'js': return 'js.%s' % (utils.resolve(node.attr, scope)) return "%s.%s" % (js, node.attr)
def _attribute(node, scope): if node.attr in reserved_words: raise PJsException("Sorry, '%s' is a reserved word in javascript." % node.attr) js = convert_node(node.value, scope) if js == 'js': return 'js.%s' % (resolve(node.attr, scope)) return "%s.%s" % (js, node.attr)
def resolve_in_expression(self, expr, ctx): expr_type, expr = eval_expression(expr) if expr_type == 'name' and expr: resolved = resolve(expr, ctx) return eval_expression(resolved)[1] if resolved else None elif expr_type == 'literal': return expr
def render(self, context): kwargs = dict(self.kwargs) kwargs = utils.resolve(kwargs, context) #print repr(kwargs) context.update(kwargs) result = self.nodelist.render(context) context.pop() return result
def _functiondef(node, scope): dct = {} dct['left'] = do_left(ast.Name(node.name, []), scope) dct['name'] = node.name dct['lineno'] = node.lineno try: dct['rname'] = resolve(node.name, scope); except PJsNameError, e: print scope raise PJsException('UndefinedNameError: %s on line %d' % (e, node.lineno))
def main(): define('host', default='127.0.0.1', help='run on the given host', type=str) define('port', default=8000, help='run on the given port', type=int) define('debug', default=False, help='enable debug mode', type=bool) parse_command_line() settings = { 'debug': options.debug, 'cookie_secret': os.urandom(32), 'template_path': resolve('./templates'), 'static_path': resolve('./static'), } application = Application(routes, **settings) application.listen(options.port, options.host, xheaders=True) asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) IOLoop.configure('tornado.platform.asyncio.AsyncIOLoop') print('ยป listen to http://%s:%s' % (options.host, options.port)) IOLoop.instance().start()
def classdef(conv, node, scope): imports = [] dct = { 'name': node.name, 'bases': ', '.join(utils.resolve(base.id, scope) for base in node.bases), 'left': utils.lhand_assign(node.name, scope), 'rname': utils.resolve(node.name, scope), } dct['dec_front'] = '' dct['dec_back'] = '' for dec in node.decorator_list: dct['dec_front'] += conv.convert_node(dec, scope) + '(' dct['dec_back'] += ')' scope = scope.copy() scope.explicit_locals = True dct['contents'] = utils.fix_undef(conv.convert_block(node.body, scope), scope) dct['lnum'] = len(scope.parent_locals) return CLASS_TEMPLATE % dct
def render(self, context): if self._iter[0] == 'literal': items = self._iter[1] elif self._iter[0] == 'name': items = resolve(self._iter[1], context) # Since Py2.x can't mutate parent scope variables, # we use a dictionary to pass in the index to the function below. nonlocals = {'index': 0} def render_item(item): # Add the current item to be rendered into the context. context[self._loop_var] = item context['index'] = nonlocals['index'] nonlocals['index'] += 1 return self.render_children(context, self.children) return ''.join(map(render_item, items))
def functiondef(conv, node, scope): dct = { 'name': node.name, 'lineno': node.lineno, 'special': function_special(conv, node, scope), 'left': utils.lhand_assign(node.name, scope), 'rname': utils.resolve(node.name, scope), } args = function_args(conv, node, scope) dct['args'] = ', '.join(args) dct['dec_front'] = '' dct['dec_back'] = '' for dec in node.decorator_list: dct['dec_front'] += conv.convert_node(dec, scope) + '(' dct['dec_back'] += ')' scope = scope.copy() scope.explicit_locals = False scope.locals += args dct['contents'] = utils.fix_undef(conv.convert_block(node.body, scope), scope) return FUNC_TEMPLATE % dct
import sqlite3 from utils import resolve class IntegrityError(sqlite3.IntegrityError): pass DATABASE = resolve('../database.sqlite') conn = sqlite3.connect(DATABASE, isolation_level=None) conn.execute('PRAGMA journal_mode=WAL') conn.executescript(''' CREATE TABLE IF NOT EXISTS shorten ( id INTEGER PRIMARY KEY NOT NULL ON CONFLICT ROLLBACK, datetime INTEGER DEFAULT CURRENT_TIMESTAMP NOT NULL ON CONFLICT ROLLBACK, code TEXT UNIQUE NOT NULL ON CONFLICT ROLLBACK, url TEXT NOT NULL ON CONFLICT ROLLBACK ); CREATE INDEX IF NOT EXISTS idx_shorten ON shorten (code); CREATE TABLE IF NOT EXISTS pastebin ( id INTEGER PRIMARY KEY NOT NULL ON CONFLICT ROLLBACK, datetime INTEGER DEFAULT CURRENT_TIMESTAMP NOT NULL ON CONFLICT ROLLBACK, code TEXT UNIQUE NOT NULL ON CONFLICT ROLLBACK, data BLOB NOT NULL ON CONFLICT ROLLBACK ); CREATE INDEX IF NOT EXISTS idx_pastebin ON pastebin (code); ''')
from PyQt4.QtGui import QPixmap from PyQt4.QtCore import QSettings from PyQt4 import uic import resources_rc import utils FORM_CLASS, FORM_BASE = uic.loadUiType(utils.resolve("settingsdialog.ui")) class SettingsDialog(FORM_BASE, FORM_CLASS): def __init__(self, parent=None): super(SettingsDialog, self).__init__(parent) self.setupUi(self) self.settings = QSettings() def value(self, key, type=str): try: return self.settings.value(key, type=type) except TypeError: return None def showEvent(self, event): serviceUrl = self.value("plugins/Earthmine/serviceUrl") baseDataUrl = self.value("plugins/Earthmine/baseDataUrl", type=str) apiKey = self.value("plugins/Earthmine/apiKey", type=str) secretKey = self.value("plugins/Earthmine/secretKey", type=str) viewerUrl = self.value("plugins/Earthmine/viewerUrl", type=str) if not viewerUrl: viewerUrl = "http://qgis.mapsolutions.com.au/qgis/earthmine/view.html"
def _name(node, scope): try: return resolve(node.id, scope) except PJsNameError, e: print scope raise PJsException('UndefinedNameError: %s on line %d' % (e, node.lineno))
def render(self, context): return resolve(self.token.clean(), context)
def _name(conv, node, scope): return utils.resolve(node.id, scope)
def render(self, context): kwargs = dict(self.kwargs) kwargs = utils.resolve(kwargs, context) for key,value in kwargs.items(): context[key] = value return ''
import json import functools from PyQt4.QtWebKit import QWebView, QWebSettings from PyQt4.QtCore import QUrl, Qt, QObject, pyqtSlot, pyqtSignal from PyQt4.QtGui import QToolBar, QIcon, QWidget, QLabel, QSizePolicy, QActionGroup, QComboBox, QCheckBox from PyQt4 import uic from qgis.gui import QgsMapLayerComboBox, QgsMapLayerProxyModel from qgis.core import QgsMapLayer, QGis, QgsGeometry, QgsDistanceArea import resources_rc import utils ViewerClass, ViewerBase = uic.loadUiType(utils.resolve('viewer.ui')) MeasureClas, MeasureBase = uic.loadUiType(utils.resolve('measure.ui')) class EarthmineAPI(object): """ Convenience class to allows calling JS methods as Python attributes. """ def __init__(self, frame): """ frame -- The QWebFrame to evel the JS in """ self.frame = frame def __getattr__(self, item): return functools.partial(self._jscall, item)