def __init__(self, content_id, data=None, **kwargs):
if not data:
data = {}
Persistent.__init__(self)
Base.__init__(self, content_id, data=data)
def __init__(self, name,
display_file, original_file=None, thumbnail_file=None,
description=None,
location=None,
date=datetime.datetime.now(),
original_size=(-1, -1),
display_size=(-1, -1),
thumbnail_size=(-1, -1),
parent=None):
Persistent.__init__(self)
PersistentLocationAware.__init__(self)
self.__name__ = name
self.__parent__ = parent
self.display_file = display_file
self.original_file = original_file
self.thumbnail_file = thumbnail_file
self.description = description
self.location = location
self.date = date
self.original_width = original_size[0]
self.original_height = original_size[1]
self.display_width = display_size[0]
self.display_height = display_size[1]
self.thumbnail_width = thumbnail_size[0]
self.thumbnail_height = thumbnail_size[1]
def __getattribute__(self, name):
"""Get an attribute value
See the very important note in the comment below!
"""
#################################################################
# IMPORTANT! READ THIS! 8->
#
# We *always* give Persistent a chance first.
# Persistent handles certain special attributes, like _p_
# attributes. In particular, the base class handles __dict__
# and __class__.
#
# We call _p_getattr. If it returns True, then we have to
# use Persistent.__getattribute__ to get the value.
#
#################################################################
if Persistent._p_getattr(self, name):
return Persistent.__getattribute__(self, name)
# Data should be in our secret dictionary:
secret = self.__dict__['__secret__']
if name in secret:
return secret[name]
# Maybe it's a method:
meth = getattr(self.__class__, name, None)
if meth is None:
raise AttributeError(name)
return meth.__get__(self, self.__class__)
def __setattr__(self, name, value):
"""If name is __parent__, write value to _v_parent. This avoids
_p_changed to be set set by Persitent.__setattr__. Using a read/write
property for __parent__ won't work.
"""
if name == '__parent__':
name = '_v_parent'
Persistent.__setattr__(self, name, value)
def __init__(self, username, email, password):
Persistent.__init__(self)
UserMixin.__init__(self)
self.username = username
self.email = email
self.password = password
self._set_defaults()
self.uid = db['player_uid'].get_next_id()
def _p_accessed(self):
# The superclass has issues changing the MRU
# during initial serialization because we're not
# yet in the picklecache
try:
Persistent._p_accessed(self)
except KeyError:
pass
def __init__(self, crumb_name, owner, id):
Persistent.__init__(self)
self.owner = owner
self.timestamp = datetime.now()
self.id = id
# Name used in breadcrumps
self.crumb_name = crumb_name
def __init__(self):
Persistent.__init__(self)
UserMixin.__init__(self)
self.uid = WORLD_UID
self.username = '******'
self.email = ''
self._password = ''
self._set_defaults()
def __init__(self, name, contacts):
Persistent.__init__(self)
self.key = contacts.maxKey() + 1
self.__parent__ = contacts
self.__name__ = self.key
for heading in contacts.Headings:
self.__setattr__(heading, "")
self.name = name
contacts[self.key] = self
def __getattr__(self, key):
"""Maps values to attributes.
Only called if there *isn't* an attribute with this name
"""
if Persistent._p_getattr(self, key):
return Persistent.__getattribute__(self, key)
try:
return self.__getitem__(key)
except KeyError:
raise AttributeError(key)
def __init__(self, id=None):
Persistent.__init__(self)
if id is not None:
self.ID = id
else:
self.ID = uuid.uuid4()
self.Name = ""
self.Attributes = PersistentMapping()
self.TitleAttr = None
self.Graphics = None
def __init__(self, id = None): Persistent.__init__(self) if id is not None: self.ID = id else: self.ID = uuid.uuid4() self.Name = "" self.Attributes = PersistentMapping() self.TitleAttr = None self.Graphics = None
def __init__(self, id = None): Persistent.__init__(self) if id is not None: self.ID = id else: self.ID = uuid.uuid4() self.TemplateName = "" self.Attributes = PersistentMapping() self.TitleAttr = None self.Graphics = None self.IsReflection = False self.Tag = None
def __init__(self, id=None):
Persistent.__init__(self)
if id is not None:
self.ID = id
else:
self.ID = uuid.uuid4()
self.TemplateName = ""
self.Attributes = PersistentMapping()
self.TitleAttr = None
self.Graphics = None
self.IsReflection = False
self.Tag = None
def __setattr__(self, name, value):
#only run this if the name is within the current objects attributes
if self._v_book and name not in Persistent.__dict__:
# if the book exists AND
# if the value has changed
# and that attribute is an indexable attribute
# OR we want it to be indexed, however it is not actually in the index (this condition will be caught
# in updateIndexedValue)
if self._v_book and self.__dict__.get(name) != value and name in self.indexableAttrs:
self._v_book.updateIndexedValue(self, name, value)
# save changes
self._v_book.commitTransaction()
Persistent.__setattr__(self, name, value)
def __init__(
self,
transition_function=None,
initial_state=0,
data=None, transition_table=None):
"""Initialize with transition rules for each state, and optionally
include the initial state (default 0) or data (default None).
"""
Persistent.__init__(self)
if transition_function != None:
self.transition_function = transition_function
self.__transition_table = transition_table
self.__data = data
self.__state = initial_state
def __init__( self, name, owner, conference, modificationDate=None, createdInLocalServer=True, showRoom=False ):
Persistent.__init__(self)
self._name = name
self._owner = owner
self._creationDate = nowutc()
self._conferences = PersistentMapping()
self._conferences[conference.getId()] = conference
self._modificationDate = modificationDate
self._createdInLocalServer = createdInLocalServer
self._showRoom = showRoom
#the id will be assigned just before being stored in the DB.
#If we try to create a counter now it will fail if it's the first chatroom
#in the conference, since no indexes have been created yet
self._id = None
def __delattr__(self, name):
if name.startswith('_p_') or name in struct_attrs:
return Persistent.__delattr__(self, name)
# Set _p_changed before deleting the attribute. See
# comment above, on __setattr__
self._p_changed = 1
delattr(self.__proxied__, name, v)
def __new__(cls, obj):
inst = Persistent.__new__(cls)
inst._wrapped = obj
inst.__parent__ = None
inst.__name__ = None
inst._Persistent__flags = None
return inst
def __init__(self):
Persistent.__init__(self)
# mapping of front end transaction identifiers to
# backend transaction state machines
#
# perhaps this should be volitile?
self.__front_end_to_back = {}
# mapping of front end transaction identifiers to an input
# for that transaction's state machine
self.dirty_transaction_set = {}
# set of front end transaction identified that are dirty, but
# but are considered impossible to syncronize and are thus being
# held instead of subjected to failed attempt after failed
# attempt to syncrhonize
self.held_transaction_set = set()
def __setattr__(self, name, v):
if name.startswith('_p_') or name in struct_attrs:
return Persistent.__setattr__(self, name, v)
# Set _p_changed before calling the mutator on the
# proxied object, so we have the object marked
# as dirty even if an exception takes place later.
self._p_changed = 1
setattr(self.__proxied__, name, v)
def __getattribute__(self, name):
""" see http://svn.zope.org/ZODB/trunk/src/persistent/tests/test_overriding_attrs.py?rev=38214&view=markup """
#allow persistent to handle any special attributes it needs
if Persistent._p_getattr(self, name):
return Persistent.__getattribute__(self, name)
#otherwise, we use this hook point to see if the user is allowed to perform the action:
if name == 'privileges':
return super(Auth, self).__getattribute__(name)
elif name == 'has_privileges_on':
return super(Auth, self).__getattribute__(name)
elif name == '_v_current_user':
return super(Auth, self).__getattribute__(name)
elif Auth._v_current_user is None:#this is the case at startup, or if config.USE_AUTH is False
return super(Auth, self).__getattribute__(name)
elif Auth._v_current_user.has_privileges_on(self.__class__.__name__, name) is True:
return super(Auth, self).__getattribute__(name)
raise PermissionError(Auth._v_current_user, ' does not have permission to access ' , name)
def test_index_doc_persistent_value_raises(self):
from persistent import Persistent
OTHER_FACETS = ['foo', 'foo:bar', 'foo:baz']
class Dummy:
pass
index = self._makeOne('facets', OTHER_FACETS)
dummy = Dummy()
dummy.facets = Persistent()
self.assertRaises(ValueError, index.index_doc, 1, dummy)
def __new__(cls, *args, **kargs):
'''
@return: Division_Transporte
@author:
'''
if cls.instance is None:
cls.instance = Persistent.__new__(cls, *args, **kargs)
cls.instance.inicialize()
return cls.instance
def test_index_doc_persistent_value_raises(self):
from persistent import Persistent
index = self._makeIndex('abc')
index._docids = set()
class Dummy:
pass
dummy = Dummy()
dummy.abc = Persistent()
self.assertRaises(ValueError, index.index_doc, 1, dummy)
def __reduce__(self):
# Swap out the type constructor for the C version, if present.
func, typ_gna, state = Persistent.__reduce__(self)
# We ignore the returned type altogether in favor of
# our calculated class (which allows subclasses but replaces our exact
# type with the C equivalent)
typ = self.__class__
gna = typ_gna[1:]
return (func, (typ,) + gna, state)
def __init__(self, name, big_image_view, regular_image_view,
small_image_view, description=None, location=None,
date=datetime.datetime.now(), parent=None):
Persistent.__init__(self)
PersistentLocationAware.__init__(self, name, parent)
if isinstance(big_image_view, GalleryImageFile):
self.big_image_view = GalleryImageView(big_image_view)
else:
assert isinstance(big_image_view, GalleryImageView)
self.big_image_view = big_image_view
if isinstance(regular_image_view, GalleryImageFile):
self.regular_image_view = GalleryImageView(regular_image_view)
else:
assert isinstance(regular_image_view, GalleryImageView)
self.regular_image_view = regular_image_view
if isinstance(small_image_view, GalleryImageFile):
self.small_image_view = GalleryImageView(small_image_view)
else:
assert isinstance(small_image_view, GalleryImageView)
self.small_image_view = small_image_view
self.description = description
self.location = location
self.date = date
def __init__(self, settings = {}, initialValuesGenerator = None):
''' Init. settings provide many means to customize the spatial tree.
E.g. setting leaf_capacity and near_minimum_overlap_factor to "good"
values can help to reduce the possibility of write conflict errors.
Below is a list of the currently available properties. For more info
about these and other properties see the rtree docs and/or code.
writethrough
buffering_capacity
pagesize
leaf_capacity
near_minimum_overlap_factor
type
variant
dimension
index_capacity
index_pool_capacity
point_pool_capacity
region_pool_capacity
tight_mbr
fill_factor
split_distribution_factor
tpr_horizon
reinsert_factor
If you supply an initialValuesGenerator you can build a spatial index
from initial values. This is much faster than doing repeated insert()s.
'''
Persistent.__init__( self )
self.family = settings.pop( 'family', self.default_family )
self.settings = PersistentDict( settings )
self.pageData = self.family.IO.BTree() # here we save the actual rtree data in
self.idToCoordinates = self.family.IO.BTree() # we need to know the coordinates for each objectid to be able to delete it
# this creates the tree and creates header and root pages
self._getTree( initialValuesGenerator )
def __setattr__(self, name, value):
"""Set an attribute value
"""
#################################################################
# IMPORTANT! READ THIS! 8->
#
# We *always* give Persistent a chance first.
# Persistent handles certain special attributes, like _p_
# attributes.
#
# We call _p_setattr. If it returns True, then we are done.
# It has already set the attribute.
#
#################################################################
if Persistent._p_setattr(self, name, value):
return
self.__dict__['__secret__'][name] = value
if not name.startswith('tmp_'):
self._p_changed = 1
def __getattribute__(self, name):
if name.startswith('_p_') or name in struct_attrs:
v = Persistent.__getattribute__(self, name)
# Handle descriptors here, eg: __Security_checker__
# is a descriptor for Struct objects.
if hasattr(v, '__get__'):
return v.__get__(self, type(self))
return v
# TODO This is butt ugly. See the comment on SecurityDescriptor.
if self._p_state == GHOST:
self._p_activate()
proxied = self.__proxied__
v = getattr(proxied, name)
# And also handle descriptors for the proxied object,
# but using the proxied object on __get__ calls.
if hasattr(v, '__get__'):
# We should call it only if it came from the class,
# otherwise its a descriptor being used as an instance
# attribute, so just return it.
if (hasattr(proxied, '__class__') and
getattr(proxied.__class__, name) is v):
return v.__get__(proxied, type(proxied))
return v
def __getstate__(self):
if not hasattr(self, 'new_attribute'):
self.new_attribute = 1 # pylint:disable=attribute-defined-outside-init
return Persistent.__getstate__(self)
def __init__(self, *args, **kw):
Persistent.__init__(self)
Schedule.__init__(self, *args, **kw)
self.exceptions = PersistentDict()
def __init__(self):
Persistent.__init__(self)
self._items = PersistentList()
def __init__(self, email, message):
Persistent.__init__(self)
self.email = unicode(email)
self.message = unicode(message)
def __init__(self): Persistent.__init__(self) self.objects = PersistentMapping() self.templates = PersistentMapping() self.shapes = PersistentMapping() self.Tag = None