Datasets:
h4iku
/
coconut_python2010_preprocessed

Dataset card Data Studio Files
xet
Community
rem
stringlengths
0
322k
add
stringlengths
0
2.05M
context
stringlengths
8
228k
param_stream.fields.id.convertFromString(parts[-1])
param_stream.fields.id.convertFromString(param_item_id_str)
def match(self, site, stream_path, tag=None): parts = stream_path.split('/') if len(parts)>=2 and '/'.join(parts[:-1])==self.prefix: param_stream = site.retrieveStream(self.paramStream, tag=site.transmitTag(tag)) try: param_item_id = \ param_stream.fields.id.convertFromString(parts[-1]) except ValueError: return param_item = param_stream.retrieveItem(param_item_id) if param_item is None: # no such item return params = self.streamParams.copy() params[self.paramName] = param_item if self.titleTemplate is not None: params['title'] = interpolateString(self.titleTemplate, params) return self.templateStream, params else: return
id_str = param_item.fields.id.convertToString(param_item.id) return '%s/%s' % (self.prefix, id_str)
param_item_id_str = param_item.fields.id.convertToString(param_item.id) return '%s%s%s' % (self.prefix, param_item_id_str, self.suffix)
def constructId(self, param_item): id_str = param_item.fields.id.convertToString(param_item.id) return '%s/%s' % (self.prefix, id_str)
FOREIGN_DROP.__init__(self, **kwargs)
FieldType.__init__(self, **kwargs)
def __init__(self, **kwargs): FOREIGN_DROP.__init__(self, **kwargs) self.itemField = self.itemFieldClass(**kwargs)
item_ids = [FOREIGN_DROP.convertToString(self, item, item) for item in value]
item_ids = [self.itemField.convertToString(i, item) for i in value]
def convertToString(self, value, item=None): item_ids = [FOREIGN_DROP.convertToString(self, item, item) for item in value] return self.fieldSeparator.join(item_ids)
if field_name!=self.fields.idFieldName:
if field_name!='id':
def createNewItem(self, item_id=None): item = self.itemClass(self.site, self, item_id) defaults = self.brickDefaults if hasattr(self, 'virtual'): virtual_param_names = self.virtual.itemParamNames else: virtual_param_names = [] for field_name, field_type in self.fields.iteritems(): if field_name!=self.fields.idFieldName: if field_name in virtual_param_names: value = getattr(self, field_name) elif defaults.has_key(field_name): value = field_type.convertFromCode(defaults[field_name], item) else: value = field_type.getDefault(item) setattr(item, field_name, value) return item
condition = stream.dbConn.join(self.conditions, cond_method)
if stream.condition: conditions = [stream.condition]+self.conditions else: conditions = self.conditions condition = stream.dbConn.join(conditions, cond_method)
def createStream(self, stream, loader, cond_method="AND"): condition = stream.dbConn.join(self.conditions, cond_method) jt = getattr(stream, "joinTemplate", "%(brick.tableName)s") jt = ' '.join([jt]+self.joinTemplates) return loader(stream.id, condition=condition, joinTemplate=jt)
if image:
if value.body and image:
def convertFromForm(self, form, name, item): value = IMAGE.convertFromForm(self, form, name, item) image = image_orig = value._image
image = image_orig = getattr( getattr(item, self.fieldToThumb, None), '_image', None)
_image = getattr(item, self.fieldToThumb, None) image = image_orig = getattr(_image, '_image', None)
def convertFromForm(self, form, name, item): if self.fieldToThumb: # we have field to thumbnail image = image_orig = getattr( getattr(item, self.fieldToThumb, None), '_image', None) else: # field thumbnails itself if form.has_key(name+'-delete'): old_path = getattr(getattr(item, name), 'path', None) return self._Image(self, item, '', old_path) image = image_orig = getattr( IMAGE.convertFromForm(self, form, name, item), '_image', None)
image = image_orig = getattr( IMAGE.convertFromForm(self, form, name, item), '_image', None)
_image = IMAGE.convertFromForm(self, form, name, item) image = image_orig = getattr(_image, '_image', None) if not _image.body: return _image
def convertFromForm(self, form, name, item): if self.fieldToThumb: # we have field to thumbnail image = image_orig = getattr( getattr(item, self.fieldToThumb, None), '_image', None) else: # field thumbnails itself if form.has_key(name+'-delete'): old_path = getattr(getattr(item, name), 'path', None) return self._Image(self, item, '', old_path) image = image_orig = getattr( IMAGE.convertFromForm(self, form, name, item), '_image', None)
form = qps.qHTTP.Form(request, self.getClientCharset(request))
form = qHTTP.Form(request, self.getClientCharset(request))
def dispatch(self, request, response, field_name='qps-action', **kwargs): form = qps.qHTTP.Form(request, self.getClientCharset(request)) action = form.getfirst(field_name) if action: try: method = getattr(self, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return self.cmd_invalidCommand(request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return self.cmd_defaultCommand(request, response, form, **kwargs)
if 'w' in perms or 'r' in perms and \ not (self.isNew and field_type.omitForNew):
if ('w' in perms or 'r' in perms) and \ not (self.isNew and field_type.omitForNew):
def allowedFields(self, item): # assume item.type=='item' itemFieldsOrder = [] for field_name, field_type in item.fields.iteritems(): perms = self.user.getPermissions(field_type.permissions) if 'w' in perms or 'r' in perms and \ not (self.isNew and field_type.omitForNew): itemFieldsOrder.append(field_name) return itemFieldsOrder
result[key] = field_type.convertFromCode(value, item)
result[key] = field_type.convertFromCode(value[key], item)
def convertFromCode(self, value, item=None): # XXX Looks like broken. Need to test it result = self.dictClass() for key, field_type in self.fields: result[key] = field_type.convertFromCode(value, item) return result
if self.charset: from email.Header import Header Subject = Header(Subject, self.charset) message = self.messageClass(body, _charset=self.charset) else: message = self.messageClass(body)
def compose(self, body, Subject, **kwargs): '''Takes message body and headers as named params, replace "-" with "_" in headers names. Returns email.Message.Message object''' if self.charset: # subject is an internationalized header, should be quoted from email.Header import Header Subject = Header(Subject, self.charset) message = self.messageClass(body, _charset=self.charset) else: message = self.messageClass(body)
message[name.replace('_', '-')] = value message['Subject'] = Subject
message[name.replace('_', '-')] = Header(value, self.charset)
def compose(self, body, Subject, **kwargs): '''Takes message body and headers as named params, replace "-" with "_" in headers names. Returns email.Message.Message object''' if self.charset: # subject is an internationalized header, should be quoted from email.Header import Header Subject = Header(Subject, self.charset) message = self.messageClass(body, _charset=self.charset) else: message = self.messageClass(body)
class NonMultipartComposer(Composer): '''Non Multipart messages composer''' messageClass = email.MIMEText.MIMEText
def compose(self, body, Subject, **kwargs): '''Takes message body and headers as named params, replace "-" with "_" in headers names. Returns email.Message.Message object''' if self.charset: # subject is an internationalized header, should be quoted from email.Header import Header Subject = Header(Subject, self.charset) message = self.messageClass(body, _charset=self.charset) else: message = self.messageClass(body)
def send(mfrom, mto, subject, body, composer=NonMultipartComposer(),
def send(mfrom, mto, subject, body, composer=Composer(),
def send(mfrom, mto, subject, body, composer=NonMultipartComposer(), sender=SendmailSender()): message = composer.compose(body, From=mfrom, To=mto, Subject=subject) return sender.send(message)
value = form.getfirst(name, '')
value = form.getfirst(name, None)
def convertFromForm(self, form, name, item): value = form.getfirst(name, '') if value: stream = self._retrieve_stream(item) value = self.proxyClass(item.site, self._stream_params(item), stream.fields.id.convertFromString(value, item)) if not (self.allowNull or value): raise self.InvalidFieldContent(self.null_not_allowed_error) else: return value
class LazyItem(object):
class LazyItem:
def convertFromForm(self, form, name, item=None): return form.getlist(name)
if name.startswith('_'): object.__setattr__(self, name, value)
if name in ('_site', '_stream_id', '_stream_tag', '_item_id', '_item'): self.__dict__[name] = value
def __setattr__(self, name, value): if name.startswith('_'): object.__setattr__(self, name, value) else: setattr(self._item, name, value)
"%s:%s" % (user.login, user.passwd),
"%s:%s" % (getattr(user, stream.loginField), getattr(user, stream.passwdField)),
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')] # crypt method used below only supports string types try: passwd = str(passwd) except UnicodeEncodeError: passwd = None
params.update(new_params)
_update_stream_params(params, new_params)
def getStreamConf(self, stream_id, tag=None): '''Returns qUtils.DictRecord of stream configuration for stream identified by stream_id and (optionaly) tag. All stream configuration resolution is done here''' params = {} try: # have we real stream with such id? stream_conf = self.streamDescriptions[stream_id] except KeyError: # no real stream - expand alias (look for virtual streams, if # supported) template_stream_id = stream_id for depth in range(self.maxAliasDepth): new_template_stream_id, new_params = \ self.expandStreamAlias(template_stream_id, tag) params.update(new_params) if new_template_stream_id==template_stream_id: raise StreamNotFoundError(stream_id) else: logger.debug('Virtual: %s -> %s', stream_id, new_template_stream_id) try: stream_conf = \ self.streamDescriptions[new_template_stream_id] except KeyError: template_stream_id = new_template_stream_id else: break else: raise RuntimeError('Maximum alias depth exceeded')
result_conf = qUtils.DictRecord() for dict in self.defaultStreamConf, stream_conf, params, {'tag': tag}:
result_conf = {} for dict in self.defaultStreamConf, stream_conf, params: _update_stream_params(result_conf, dict)
def getStreamConf(self, stream_id, tag=None): '''Returns qUtils.DictRecord of stream configuration for stream identified by stream_id and (optionaly) tag. All stream configuration resolution is done here''' params = {} try: # have we real stream with such id? stream_conf = self.streamDescriptions[stream_id] except KeyError: # no real stream - expand alias (look for virtual streams, if # supported) template_stream_id = stream_id for depth in range(self.maxAliasDepth): new_template_stream_id, new_params = \ self.expandStreamAlias(template_stream_id, tag) params.update(new_params) if new_template_stream_id==template_stream_id: raise StreamNotFoundError(stream_id) else: logger.debug('Virtual: %s -> %s', stream_id, new_template_stream_id) try: stream_conf = \ self.streamDescriptions[new_template_stream_id] except KeyError: template_stream_id = new_template_stream_id else: break else: raise RuntimeError('Maximum alias depth exceeded')
result_conf = qUtils.DictRecord(result_conf, dict, tag_params) return result_conf
_update_stream_params(result_conf, tag_params) return qUtils.DictRecord(result_conf, tag=tag)
def getStreamConf(self, stream_id, tag=None): '''Returns qUtils.DictRecord of stream configuration for stream identified by stream_id and (optionaly) tag. All stream configuration resolution is done here''' params = {} try: # have we real stream with such id? stream_conf = self.streamDescriptions[stream_id] except KeyError: # no real stream - expand alias (look for virtual streams, if # supported) template_stream_id = stream_id for depth in range(self.maxAliasDepth): new_template_stream_id, new_params = \ self.expandStreamAlias(template_stream_id, tag) params.update(new_params) if new_template_stream_id==template_stream_id: raise StreamNotFoundError(stream_id) else: logger.debug('Virtual: %s -> %s', stream_id, new_template_stream_id) try: stream_conf = \ self.streamDescriptions[new_template_stream_id] except KeyError: template_stream_id = new_template_stream_id else: break else: raise RuntimeError('Maximum alias depth exceeded')
return form.getlist(self.name)
return form.getlist(name)
def convertFromForm(self, form, name, item=None): return form.getlist(self.name)
value = self.convertToForm(self.getDefault(item)) else: value = self.convertToForm(value)
value = self.convertToForm(self.getDefault(item), item) else: value = self.convertToForm(value, item)
def show(self, item, name, template_type, template_getter, global_namespace={}): '''Return HTML representation of field in editor interface item - item object name - field name user - login of user, requested this operation''' value = getattr(item, name) if value is None: value = self.convertToForm(self.getDefault(item)) else: value = self.convertToForm(value) namespace = global_namespace.copy() namespace.update({'title': name, 'value': value, 'item': item, 'brick': self}) namespace.setdefault('name', name) template = self.getTemplate(template_type, template_getter) return template(namespace)
def convertToForm(self, value):
def convertToForm(self, value, item):
def convertToForm(self, value): if value is None: return '' else: return value.strftime(self.format)
if image and self.width and self.height:
if not (image and self.width and self.height): return self._Image(self, item) w, h = image.size if w > self.width or h > self.height:
def convertFromForm(self, form, name, item): if self.fieldToThumb: # we have field to thumbnail _image = getattr(item, self.fieldToThumb, None) image = image_orig = getattr(_image, '_image', None) else: # field thumbnails itself if form.has_key(name+'-delete'): old_path = getattr(getattr(item, name), 'path', None) return self._Image(self, item, '', old_path)
else: from cStringIO import StringIO fp = StringIO() image.save(fp, image_orig.format) fp.seek(0) return self._Image(self, item, fp.read(), getattr(getattr(item, name), 'path', None)) else: return self._Image(self, item)
from cStringIO import StringIO fp = StringIO() image.save(fp, image_orig.format) fp.seek(0) return self._Image(self, item, fp.read(), getattr(getattr(item, name), 'path', None)) else: return _image
def convertFromForm(self, form, name, item): if self.fieldToThumb: # we have field to thumbnail _image = getattr(item, self.fieldToThumb, None) image = image_orig = getattr(_image, '_image', None) else: # field thumbnails itself if form.has_key(name+'-delete'): old_path = getattr(getattr(item, name), 'path', None) return self._Image(self, item, '', old_path)
def convertFromDB(self, value, item):
def convertFromString(self, value, item):
def convertFromDB(self, value, item): if value: item_ids = value.split(self.fieldSeparator) stream = self._retrieve_stream(item) return self.convertFromCode( [stream.fields.id.convertFromString(id, item) \ for id in item_ids], item) else: return []
def convertToDB(self, value, item=None): item_ids = [FOREIGN_DROP.convertToString(self, item.id, item)
def convertToString(self, value, item=None): item_ids = [FOREIGN_DROP.convertToString(self, item, item)
def convertToDB(self, value, item=None): item_ids = [FOREIGN_DROP.convertToString(self, item.id, item) for item in value] return self.fieldSeparator.join(item_ids)
value = self.convertToForm(self.default)
value = self.convertToForm(self.getDefault(item))
def show(self, item, name, template_type, template_getter, global_namespace={}): '''Return HTML representation of field in editor interface item - item object name - field name user - login of user, requested this operation''' value = getattr(item, name) if value is None: value = self.convertToForm(self.default) else: value = self.convertToForm(value) namespace = global_namespace.copy() namespace.update({'name': name, 'title': name, 'value': value, 'item': item, 'brick': self}) template = self.getTemplate(template_type, template_getter) return template(namespace)
url = form[name+'-url'].value referer = '/'.join(url.split('/')[:-1])+'/' import urllib2 req = urllib2.Request(url=url) req.add_header('Referer', referer) sources.append(urllib2.urlopen(req)) except (IOError, KeyError, AttributeError, ValueError):
url = form.getfirst(name+'-url') if url: referer = '/'.join(url.split('/')[:-1])+'/' import urllib2 req = urllib2.Request(url=url) req.add_header('Referer', referer) sources.append(urllib2.urlopen(req)) except ValueError:
def convertFromForm(self, form, name, item): old_path = getattr(getattr(item, name), 'path', None) if form.has_key(name+'-delete'): return self._Image(self, item, '', old_path)
return stream.id==self.paramStream or \ hasattr(stream, 'virtual') and \ stream.virtual.templateStream == self.paramStream
return stream.id==self.paramStream
def matchParamStream(self, stream): return stream.id==self.paramStream or \ hasattr(stream, 'virtual') and \ stream.virtual.templateStream == self.paramStream
return self.site.fields.get(self.joinTable, default)
return self.site.fields.get(self.joinTable, default).main
def joinFields(self): import qps.qFieldTypes default = qps.qFieldTypes.FieldDescriptions([]) if hasattr(self, 'joinTable'): return self.site.fields.get(self.joinTable, default) else: return default
Query(*field_values) + ')'
field_values + ')'
def insert(self, table, field_dict): '''Construct and execute SQL INSERT command and return cursor.''' field_names = ','.join(field_dict.keys()) field_values = Query(',').join( [Param(fv) for fv in field_dict.values()]) query = 'INSERT INTO %s (%s) VALUES (' % (table, field_names) + \ Query(*field_values) + ')' return self.execute(query)
Query(*field_values) + ')'
field_values + ')'
def insertMany(self, table, fields, values): '''Construct and execute SQL INSERT command with executemany.
itemModifiers = [] features = []
def deleteExtFields(self): self.stream.deleteExtFields([self.id])
if obj and obj.type == deco.type:
if obj is not None and obj.type == deco.type:
def wrapper(self, request, response, form, objs, user): obj = objs[-1] if obj and obj.type == deco.type: return func(self, request, response, form, objs, user) else: raise self.cmd_invalidCommand(request, response, form, objs, user)
if obj and user.checkPermission(deco.perm, obj.permissions):
if obj is not None \ and user.checkPermission(deco.perm, obj.permissions):
def wrapper(self, request, response, form, objs, user): obj = objs[-1] if obj and user.checkPermission(deco.perm, obj.permissions): return func(self, request, response, form, objs, user) else: raise self.ClientError(403, deco.message)
(item.fields['id'].convertToString(item.id), name)}
(item.fields['id'].convertToString(item.id, item), name)}
def showFieldInIndex(self, item, name, allow_edit=True, allow_link_through=True): '''Return representation of field in stream.
value = value.strip()
if value is None: return value
def convertFromDB(self, value, item): value = value.strip() if item.dbConn.charset: value = value.decode(item.dbConn.charset) return value
default = self.site.createStream(self.id).order
default = self.site.createStream(self.id, tag=self.tag).order
def isDefaultOrder(self): """Checks if current stream order is default""" default = self.site.createStream(self.id).order return (default == self.order)
fp.write(open(field_type.editRoot+image.path).read())
fp.write(open(field_type.editRoot+image.path, 'rb').read())
def do_make(self, item): from qFieldTypes import IMAGE from glob import glob for field_name, field_type in item.fields.external.iteritems(): if isinstance(field_type, IMAGE): image = getattr(item, field_name) if image: fp = self.writer.getFP(image.path) fp.write(open(field_type.editRoot+image.path).read()) fp.close() else: path = None for old_path in glob(image.pattern+'.*'): if old_path!=path: os.remove(old_path)
query = 'DELETE FROM '+table
query = Query('DELETE FROM '+table)
def delete(self, table, condition): '''Construct and execute SQL DELETE command and return cursor.''' query = 'DELETE FROM '+table if condition: query += ' WHERE '+condition return self.execute(query)
for field_name in stream.itemFieldsOrder:
for field_name in ['id']+stream.itemFieldsOrder:
def getBindingIndexFields(self, obj=None): if obj is None: obj = self.object # assume self.object.type=='stream': stream = obj item_fields = stream.allItemFields itemFieldsOrder = [] for field_name in stream.itemFieldsOrder: field_type = item_fields[field_name] if field_type.showInBinding and \ self.edUser.checkPermission('r', field_type.permissions): itemFieldsOrder.append(field_name) return itemFieldsOrder
self.edUser.checkPermission('r', field_type.permissions):
self.edUser.checkPermission('r', field_type.indexPermissions):
def getBindingIndexFields(self, obj=None): if obj is None: obj = self.object # assume self.object.type=='stream': stream = obj item_fields = stream.allItemFields itemFieldsOrder = [] for field_name in stream.itemFieldsOrder: field_type = item_fields[field_name] if field_type.showInBinding and \ self.edUser.checkPermission('r', field_type.permissions): itemFieldsOrder.append(field_name) return itemFieldsOrder
return template % EvalDict(namespace, namespace)
return template % EvalDict({}, namespace)
def interpolateString(template, namespace): return template % EvalDict(namespace, namespace)
action = form.getfirst(field_name)
action = form.getfirst(self.field_name)
def __call__(self, publisher, request, response, form, **kwargs): action = form.getfirst(field_name) if action: try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand(request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand(request, response, form, **kwargs)
return FieldDescriptions(self._config + other._config)
return self.__class__(self._config + other._config)
def __add__(self, other): return FieldDescriptions(self._config + other._config)
return FieldDescriptions(
return self.__class__(
def external(self): return FieldDescriptions( [(fn, ft) for fn, ft in self._config if hasattr(ft, 'store')])
return FieldDescriptions(
return self.__class__(
def main(self): return FieldDescriptions( [(fn, ft) for fn, ft in self._config if not hasattr(ft, 'store')])
return value.strftime(self.format)
if value is None: return str(value) else: return value.strftime(self.format)
def convertToString(self, value, item=None): return value.strftime(self.format)
return value.strftime(self.format)
if value is None: return '' else: return value.strftime(self.format)
def convertToForm(self, value): return value.strftime(self.format)
try: sources.append(form[name+'-body'].file) except (KeyError, AttributeError): pass try: url = form[name+'-url'].value referer = '/'.join(url.split('/')[:-1])+'/'
if self.allowFile: try: sources.append(form[name+'-body'].file) except (KeyError, AttributeError): pass if self.allowUrl: try: url = form[name+'-url'].value referer = '/'.join(url.split('/')[:-1])+'/'
def convertFromForm(self, form, name, item): old_path = getattr(getattr(item, name), 'path', None) if form.has_key(name+'-delete'): return self._Image(self, item, '', old_path)
permissions = [('all', 'rw')]
permissions = [('all', 'r')] createPermissions = [('all', 'rw')]
def convertToDB(self, value, item): if item.site.dbCharset: value = value.encode(item.site.dbCharset) return value
logger.warn('Invalid command %r', action)
logger.warn('Invalid command %r', command)
def __call__(self, publisher, request, response, form, **kwargs): """Is called by publisher, dispatches request to method""" command, params = self.parseRequest(publisher, request, response, form, **kwargs) if command: try: method = getattr(publisher, 'do_'+command) except AttributeError: logger.warn('Invalid command %r', action) method = publisher.cmd_invalidCommand else: logger.debug('Dispatching for command %r', command) else: logger.debug('Assuming default command') method = publisher.cmd_defaultCommand kwargs.update(params) return method(request, response, form, **kwargs)
def rglob(dir):
def rglob(where, dir):
def rglob(dir): result = [] for root, dirs, files in os.walk(dir): if 'CVS' in dirs: dirs.remove('CVS') for file in files: if not (file.startswith('.') or file.endswith('~')): result.append(os.path.join(root, file)) return result
for file in files: if not (file.startswith('.') or file.endswith('~')): result.append(os.path.join(root, file))
files = [file for file in files if not (file.startswith('.') or file.endswith('~'))] result.append((os.path.join(where, root), files))
def rglob(dir): result = [] for root, dirs, files in os.walk(dir): if 'CVS' in dirs: dirs.remove('CVS') for file in files: if not (file.startswith('.') or file.endswith('~')): result.append(os.path.join(root, file)) return result
data_files=[ ('share/QPS', rglob('themes')), ],
data_files=rglob('share/QPS', 'themes'),
def rglob(dir): result = [] for root, dirs, files in os.walk(dir): if 'CVS' in dirs: dirs.remove('CVS') for file in files: if not (file.startswith('.') or file.endswith('~')): result.append(os.path.join(root, file)) return result
def parseRequest(publisher, request, response, form, **kwargs):
def parseRequest(self, publisher, request, response, form, **kwargs):
def parseRequest(publisher, request, response, form, **kwargs): '''Parses request and returns command (Empty string or None means default command)''' raise NotImplementedError
files = [file for file in files
files = [os.path.join(root, file) for file in files
def rglob(where, dir): result = [] for root, dirs, files in os.walk(dir): if 'CVS' in dirs: dirs.remove('CVS') files = [file for file in files if not (file.startswith('.') or file.endswith('~'))] result.append((os.path.join(where, root), files)) return result
defaultHeaders = {}
defaultHeaders = { 'User-Agent': "qps.qMail/%s" % qps.__version__ }
def send(self, message): logger.info('Sending mail to %s', message['to'])
def compose(self, body, Subject, **kwargs):
def compose(self, From, To, body, **headers):
def compose(self, body, Subject, **kwargs): '''Takes message body and headers as named params, replace "-" with "_" in headers names. Returns email.Message.Message object'''
headers = self.defaultHeaders.copy() headers.update(kwargs) headers['Subject'] = Subject for name, value in headers.items(): message[name.replace('_', '-')] = Header(value, self.charset)
h = self.defaultHeaders.copy() h.update(headers) for name, value in h.items(): name = name.replace('_', '-') try: type(value) == str and value.decode('us-ascii') type(value) == unicode and value.encode('us-ascii') except UnicodeError: message[name] = Header(value, self.charset) else: message[name] = str(value)
def compose(self, body, Subject, **kwargs): '''Takes message body and headers as named params, replace "-" with "_" in headers names. Returns email.Message.Message object'''
def send(mfrom, mto, subject, body, composer=Composer(),
def send(From, To, subject, body, composer=Composer(),
def send(mfrom, mto, subject, body, composer=Composer(), sender=SendmailSender()): message = composer.compose(body, From=mfrom, To=mto, Subject=subject) return sender.send(message)
message = composer.compose(body, From=mfrom, To=mto, Subject=subject)
message = composer.compose(From, To, body, Subject=subject)
def send(mfrom, mto, subject, body, composer=Composer(), sender=SendmailSender()): message = composer.compose(body, From=mfrom, To=mto, Subject=subject) return sender.send(message)
def convertToString(self, value):
def convertToString(self, value, item=None):
def convertToString(self, value): if value: return value.stream.fields.id.convertToString(value.id) else: return ''
if objs[-1]: path = objs[-1].path() else: path = '/'
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')] # crypt method used below only supports string types try: passwd = str(passwd) except UnicodeEncodeError: passwd = None
response.write(template('login', brick=self.site, path=path))
response.write(template('login', brick=obj))
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')] # crypt method used below only supports string types try: passwd = str(passwd) except UnicodeEncodeError: passwd = None
elif login and passwd:
else:
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')] # crypt method used below only supports string types try: passwd = str(passwd) except UnicodeEncodeError: passwd = None
raise self.SeeOther(self.prefix+objs[-1].path())
try: required_permission, error = \ self.required_object_permission[obj.type] except KeyError: raise RuntimeError('Object of unexpected type %r' % obj.type) else: if required_permission and \ not user.checkPermission(required_permission, obj.permissions): obj = self.site raise self.SeeOther(self.prefix+obj.path())
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')] # crypt method used below only supports string types try: passwd = str(passwd) except UnicodeEncodeError: passwd = None
def __init__(self, **kwargs): FOREIGN_MULTISELECT.__init__(self, **kwargs) self.itemField = FOREIGN_DROP(stream=kwargs['stream'])
def _items(self): conn = self.item.dbConn field_type = self.field_type db_values = conn.selectFieldAsList( field_type.tableName, field_type.valueFieldName, field_type.condition(self.item)) items = [] for db_value in db_values: items.append( field_type.itemField.convertFromDB(db_value, item=self.item)) return filter(None, items)
site.defaultStreamConf, streamClass="qps.qBricks.qBase.Stream",
site.defaultStreamConf, streamClass="qps.qBricks.qStatic.StaticStream",
def initFields(self, site, fields): """Inits fields from form and returns a tuple of (item, errors)"""
image = self.thumbnail(image) from cStringIO import StringIO fp = StringIO() image.save(fp, image_orig.format) fp.seek(0) return self._Image(self, item, fp.read(), getattr(getattr(item, name), 'path', None))
try: image = self.thumbnail(image) except IOError, why: logger.warn('IOError occured while thumbnailing image: %s', why) return self._Image(self, item) else: from cStringIO import StringIO fp = StringIO() image.save(fp, image_orig.format) fp.seek(0) return self._Image(self, item, fp.read(), getattr(getattr(item, name), 'path', None))
def convertFromForm(self, form, name, item): if self.fieldToThumb: # we have field to thumbnail _image = getattr(item, self.fieldToThumb, None) image = image_orig = getattr(_image, '_image', None) else: # field thumbnails itself if form.has_key(name+'-delete'): old_path = getattr(getattr(item, name), 'path', None) return self._Image(self, item, '', old_path)
if self.min_value<=value<=self.max_value:
if self.minValue<=value<=self.maxValue:
def convertFromForm(self, form, name, item=None): value = form.getfirst(name, '').strip() if not value: if self.allowNull: return else: value = self.getDefault(item) message = qUtils.interpolateString(self.error_message, {'brick': self}) try: value = self.type(value) except ValueError: raise self.InvalidFieldContent(message) if self.min_value<=value<=self.max_value: return value else: raise self.InvalidFieldContent(message)
def prepareFieldsForDB(self):
def prepareFieldsForDB(self, fields):
def prepareFieldsForDB(self): '''Reverse for initFieldsFromDB: return dictionary with current values of fields suitable to store in DB''' # XXX This code would be faster in place of use # another solution - adding optional field_names argument fields = {} for field_name, field_type in self.fields.iteritems(): if field_type.storeControl!='never': fields[field_name] = field_type.convertToDB( getattr(self, field_name), self) return fields
of fields suitable to store in DB'''
of fields suitable to store in DB, fields param is a FieldDescriptions object'''
def prepareFieldsForDB(self): '''Reverse for initFieldsFromDB: return dictionary with current values of fields suitable to store in DB''' # XXX This code would be faster in place of use # another solution - adding optional field_names argument fields = {} for field_name, field_type in self.fields.iteritems(): if field_type.storeControl!='never': fields[field_name] = field_type.convertToDB( getattr(self, field_name), self) return fields
for field_name, field_type in self.fields.iteritems(): if field_type.storeControl!='never': fields[field_name] = field_type.convertToDB( getattr(self, field_name), self) return fields def prepareJoinFieldsForDB(self): fields = {} for field_name, field_type in self.stream.joinFields.items():
for field_name, field_type in fields.iteritems():
def prepareFieldsForDB(self): '''Reverse for initFieldsFromDB: return dictionary with current values of fields suitable to store in DB''' # XXX This code would be faster in place of use # another solution - adding optional field_names argument fields = {} for field_name, field_type in self.fields.iteritems(): if field_type.storeControl!='never': fields[field_name] = field_type.convertToDB( getattr(self, field_name), self) return fields
fields = self.prepareFieldsForDB() join_fields = self.prepareJoinFieldsForDB()
fields = self.prepareFieldsForDB(fields=self.fields.main) join_fields = self.prepareFieldsForDB(fields=self.stream.joinFields)
def store(self, names=None): '''Store data of item (new or existing) in DB''' fields = self.prepareFieldsForDB() join_fields = self.prepareJoinFieldsForDB() # remove from fields read-only fields for field_name in fields.keys(): field_type = self.indexFields[field_name] if field_type.storeControl=='never' or \ (field_type.storeControl!='always' and \ names is not None and field_name not in names): del fields[field_name] tnx = self.dbConn.getTransaction() if not self.exists(1): # INSERT id_field_type = self.fields['id'] if not (id_field_type.omitForNew and self.id is None): fields['id'] = id_field_type.convertToDB(self.id, self) cursor = self.dbConn.insert(self.stream.tableName, fields)
if self.templateCat is not None: return template_getter('%s.%s' % (self.templateCat, template_type))
def getTemplate(self, template_type, template_getter): if self.templateCat is not None: # Such templates MUST exist and MUST NOT be cached in class return template_getter('%s.%s' % (self.templateCat, template_type)) from qWebUtils import TemplateNotFoundError for cls in self.__class__.__mro__: if not cls.__dict__.has_key('_templates'): cls._templates = {} if not cls._templates.has_key(template_type): try: template = template_getter( '%s.%s' % (cls.__name__, template_type)) except TemplateNotFoundError: if cls is FieldType: raise else: continue cls._templates[template_type] = template return cls._templates[template_type]
not id_field_ytpe.omitForNew):
not id_field_type.omitForNew):
def store(self, names=None): '''Store data of item (new or existing) in DB''' fields = self.prepareFieldsForDB(self.fields.main) join_fields = self.prepareFieldsForDB(self.stream.joinFields) # remove from fields read-only fields for field_name in fields.keys(): field_type = self.indexFields[field_name] if field_type.storeControl=='never' or \ (field_type.storeControl!='always' and \ names is not None and field_name not in names): del fields[field_name] tnx = self.dbConn.getTransaction() if not self.exists(1): # INSERT id_field_type = self.fields.id id_field_name = self.fields.idFieldName if not fields.has_key(id_field_name) and \ (not (id_field_type.omitForNew and self.id is None) or \ not id_field_ytpe.omitForNew): fields[id_field_name] = id_field_type.convertToDB(self.id,self) cursor = self.dbConn.insert(self.stream.tableName, fields)
addr = email.Utils.parseaddr(message['to'])[1]
addr = parseaddr(message['to'])[1]
def send(self, message): addr = email.Utils.parseaddr(message['to'])[1] logger.info('Sending mail to %s', addr)
def convertToString(self, value):
def convertToString(self, value, item=None):
def convertToString(self, value): seq = [] for key, field in value.items(): field_type = self.itemFields[key] seq.append((key, field_type.convertToString(field))) return self._join(seq)
seq.append((key, field_type.convertToString(field)))
seq.append((key, field_type.convertToString(field, item)))
def convertToString(self, value): seq = [] for key, field in value.items(): field_type = self.itemFields[key] seq.append((key, field_type.convertToString(field))) return self._join(seq)
def convertToString(self, value): return self._join([self.itemField.convertToString(field)
def convertToString(self, value, item=None): return self._join([self.itemField.convertToString(field, item)
def convertToString(self, value): return self._join([self.itemField.convertToString(field) for field in value])
if not login:
if not (login and passwd):
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')]
elif passwd:
elif login and passwd:
def cmd_notAuthorized(self, request, response, form, objs, user): login, passwd, perm_login = [form.getfirst(name) for name in \ ('login', 'passwd', 'perm_login')]
query = 'UPDATE %s SET ' % table + query
query = 'REPLACE %s SET ' % table + query
def replace(self, table, field_dict): '''Construct and execute MySQL REPLACE command and return cursor.''' if not self._current_transaction: raise self.ExecuteOutsideOfTransaction() query = Query() for name, value in field_dict.items(): if query: query += ',' query += Query('%s=' % name, Param(value)) query = 'UPDATE %s SET ' % table + query return self.execute(query)
ns.update({'linkThrough': self.user.checkPermission( 'r', item.permissions) and field_type.linkThrough})
ns.update( {'linkThrough': self.user.checkPermission( 'r', item.permissions) and field_type.linkThrough, 'field_suffix': '%s:%s' % \ (item.fields['id'].convertToString(item.id), name)} )
def showFieldInIndex(self, item, name, allow_edit=1): '''Return representation of field in stream''' stream = item.stream field_type = stream.indexFields[name] stream_perms = self.user.getPermissions(stream.permissions) perms = self.user.getPermissions(field_type.indexPermissions) if allow_edit and 'w' in stream_perms and 'w' in perms: template_type = 'edit' elif 'r' in perms: template_type = 'view' else: return '' template_type = 'index-' + template_type ns = self.fieldGlobalNamespace.copy() ns.update({'linkThrough': self.user.checkPermission( 'r', item.permissions) and field_type.linkThrough}) return field_type.show(item, name, template_type, self.edit.getFieldTemplate, ns) # XXX namespace
fields = self.stream.indexFields
fields = self.indexFields
def initFieldsFromDB(self, row): '''Initialize item fields from DB row''' fields = self.stream.indexFields for field_name, db_value in row.items(): if fields.has_key(field_name): value = fields[field_name].convertFromDB(db_value, item=self) setattr(self, field_name, value)
def __del__(self): file.__del__(self) if not __debug__: os.remove(self._tmp_path)
if not __debug__: def __del__(self): if not self.closed: file.close(self) os.remove(self._tmp_path)
def __del__(self): # Inherited __del__ calls file.close() and file is not renamed. So # redefined close() method is like a commit. file.__del__(self) if not __debug__: os.remove(self._tmp_path)
field_name, exc)
field_name, exc.message)
def updateStream(self, stream, form, user): '''Method to update several items of stream at once. Only changed fields are updated. Names for fields are rewriten (in sense of field_type.convertFromForm()) from "name" to "qps-old:%s:%s" % (item.id, name) and "qps-new:%s:%s" % (item.id, name).''' if not user.checkPermission('w', stream.permissions): raise self.ClientError(403, self.edit_denied_error) updatable_fields = self.allowedStreamFields(stream, user) item_fields = stream.allStreamFields if updatable_fields: item_id_strs = {} # simulating set for name in form.keys(): if name.startswith('qps-new:') or name.startswith('qps-old:'): parts = name.split(':', 2) if len(parts)!=3: continue item_id_strs[parts[1]] = 1 for item_id_str in item_id_strs.keys(): changed_fields = [] item_id = stream.itemIDField.convertFromString(item_id_str) item = stream.retrieveItem(item_id) if item is None: # Somebody deleted it :) continue for field_name in updatable_fields: field_type = item_fields[field_name] try: old_value = field_type.convertFromForm(form, ':'.join(['qps-old', item_id_str, field_name]), item) new_value = field_type.convertFromForm(form, ':'.join(['qps-new', item_id_str, field_name]), item) if new_value!=old_value: setattr(item, field_name, new_value) changed_fields.append(field_name) except field_type.InvalidFieldContent, exc: logger.warning( 'Error in updateStream for field %s: %s', field_name, exc) if changed_fields: item.store(changed_fields)
command = self.parseRequest(publisher, request, response, form, **kwargs) if command: try: method = getattr(publisher, 'do_'+command) except AttributeError: logger.warn('Invalid command %r', action) method = publisher.cmd_invalidCommand else: logger.debug('Dispatching for command %r', command) else: logger.debug('Assuming default command') method = publisher.cmd_defaultCommand return method(request, response, form, **kwargs) def parseRequest(publisher, request, response, form, **kwargs): '''Parses request and returns command (Empty string or None means default command)'''
def __call__(self, publisher, request, response, form, **kwargs): """Is called by publisher, dispatches request to method""" raise NotImplementedError
def __call__(self, publisher, request, response, form, **kwargs):
def parseRequest(self, publisher, request, response, form, **kwargs):
def __call__(self, publisher, request, response, form, **kwargs): for field_name in form.keys(): if field_name.startswith(self.field_name_prefix): action = field_name[len(self.field_name_prefix):] try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand( request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand( request, response, form, **kwargs)
action = field_name[len(self.field_name_prefix):] try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand( request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand( request, response, form, **kwargs)
return field_name[len(self.field_name_prefix):]
def __call__(self, publisher, request, response, form, **kwargs): for field_name in form.keys(): if field_name.startswith(self.field_name_prefix): action = field_name[len(self.field_name_prefix):] try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand( request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand( request, response, form, **kwargs)
def __call__(self, publisher, request, response, form, **kwargs): action = form.getfirst(self.field_name) if action: try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand(request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand(request, response, form, **kwargs)
def parseRequest(self, publisher, request, response, form, **kwargs): return form.getfirst(self.field_name)
def __call__(self, publisher, request, response, form, **kwargs): action = form.getfirst(self.field_name) if action: try: method = getattr(publisher, 'do_'+action) except AttributeError: logger.warn('Invalid command %r', action) return publisher.cmd_invalidCommand(request, response, form, **kwargs) else: logger.debug('Dispatching for command %r', action) return method(request, response, form, **kwargs) else: logger.debug('Assuming default command') return publisher.cmd_defaultCommand(request, response, form, **kwargs)
def __call__(self, publisher, request, response, form, **kwargs): action = request.pathInfo[1:] if action: try: method = getattr(publisher, 'do_'+action) except AttributeError: method = publisher.cmd_invalidCommand else: method = publisher.cmd_defaultCommand return method(request, response, form, **kwargs)
def parseRequest(self, publisher, request, response, form, **kwargs): return request.pathInfo[1:]
def __call__(self, publisher, request, response, form, **kwargs): action = request.pathInfo[1:] if action: try: method = getattr(publisher, 'do_'+action) except AttributeError: method = publisher.cmd_invalidCommand else: method = publisher.cmd_defaultCommand return method(request, response, form, **kwargs)
def __init__(self, site, **kwargs): self.dispatcher = FieldNameCommandDispatcher( field_name_prefix='qps-action:') Publisher.__init__(self, site, **kwargs)
dispatcher = FieldNameCommandDispatcher(field_name_prefix='qps-action:')
def __init__(self, site, **kwargs): self.dispatcher = FieldNameCommandDispatcher( field_name_prefix='qps-action:') Publisher.__init__(self, site, **kwargs)
logger.info('New transaction')
logger.debug('Transaction started')
def __init__(self, conn): self.dbConn = conn if not conn._current_transaction: self.impl = conn._current_transaction = TransactionImpl(conn) logger.info('New transaction') else: self.impl = conn._current_transaction logger.info('Existing transaction level %s', self.impl.level) conn._current_transaction.pushLevel() self.opened = 1
logger.info('Existing transaction level %s', self.impl.level)
logger.debug('Transaction reused (level=%s)', self.impl.level)
def __init__(self, conn): self.dbConn = conn if not conn._current_transaction: self.impl = conn._current_transaction = TransactionImpl(conn) logger.info('New transaction') else: self.impl = conn._current_transaction logger.info('Existing transaction level %s', self.impl.level) conn._current_transaction.pushLevel() self.opened = 1