def test_mutate(self):
obj = PersistentExternalizableWeakList()
# Cannot set non-persistent objects
assert_that(
calling(obj.append).with_args(object()), raises(AttributeError))
pers = Persistent()
obj.append(pers)
assert_that(obj[0], is_(pers))
pers2 = Persistent()
obj[0] = pers2
assert_that(obj[0], is_(pers2))
assert_that(obj.count(pers2), is_(1))
assert_that(obj.count(pers), is_(0))
# iteration
for x in obj:
assert_that(x, is_(pers2))
assert_that(obj.index(pers2), is_(0))
assert_that(obj.pop(), is_(pers2))
assert_that(calling(obj.pop), raises(IndexError))
assert_that(obj, is_(obj))
obj.append(pers2)
# mul
assert_that(obj * 2,
is_(PersistentExternalizableWeakList([pers2, pers2])))
# imul
obj *= 2
assert_that(obj, is_(PersistentExternalizableWeakList([pers2, pers2])))
obj.pop()
# insert
obj.insert(1, pers2)
assert_that(obj, is_(PersistentExternalizableWeakList([pers2, pers2])))
assert_that(obj, is_([pers2, pers2]))
assert_that(obj, is_not([pers2, pers]))
assert_that(obj, is_not(pers))
obj.remove(pers2)
obj.remove(pers2)
assert_that(obj, is_([]))
def question1():
A = [7, 10, 20]
N = [20, 40, 60, 80, 100]
for n in N:
for a in A:
sim = Persistent()
sim.runSimulation(n, 1000, a)
def test_prefetch_multidb(self):
jar1 = self.Jar()
jar2 = self.Jar()
jar3 = self.Jar()
databases = {'1': jar1, '2': jar2, '3': jar3}
jar1.databases = jar2.databases = jar3.databases = databases
inst = self._makeOne([], 0)
chunk = [
(1, self.Obj(jar3)),
(2, self),
(3, object()),
(4, Persistent()),
(5, self.Obj(jar1, 1)),
(5, self.Obj(jar2, 2)),
(5, self.Obj(jar3, 3)),
(5, self.Obj(jar3, 4)),
(5, self.Obj(jar2, 5)),
(5, self.Obj(jar3, 5)), # dup, different jar
(5, self.Obj(jar3, 5)), # dup, same jar
]
inst._prefetch(chunk)
assert_that(inst._prefetch, is_(inst._prefetch_multidb))
assert_that(jar1.prefetched, is_(({
1,
}, )))
assert_that(jar2.prefetched, is_(({2, 5}, )))
assert_that(jar3.prefetched, is_(({3, 4, 5}, )))
def test_index_doc_persistent_value_raises(self):
from persistent import Persistent
index = self._makeOne(discriminator='abc')
class Dummy:
pass
dummy = Dummy()
dummy.abc = Persistent()
self.assertRaises(ValueError, index.index_doc, 1, dummy)
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 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 make_one(self):
db = DB(None)
conn = db.open()
pers = Persistent()
conn.add(pers)
orig_wref = WeakRef(pers)
return orig_wref
def __init__(self, host, port, cache_size, db_name):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))
self.cache = Cache(cache_size)
self.persistent = Persistent(db_name)
self.lock = threading.Lock()
def test_equality(self):
obj = PersistentExternalizableWeakList()
pers = Persistent()
obj.append(pers)
assert_that(obj, is_([pers]))
assert_that(obj, is_not([pers, pers]))
assert_that(obj, is_not([]))
assert_that(obj, is_not([self]))
def __init__(self, host, port, cache_size, db_name, workers):
self.host = host
self.port = port
self.cache = Cache(cache_size)
self.persistent = Persistent(db_name)
self.req_queue = Queue() # Unbounded queue
self.resp_queue = Queue()
self.pool = {}
self.workers = workers #number of workers in thread pool
self.polling = None
self.pending_reqs = {} #dict to store pending requests on a key
def test_index_doc_persistent_value_raises(self):
from persistent import Persistent
klass = self._getTargetClass()
class Test(klass, DummyIndex):
pass
index = Test('abc')
index._docids = set()
class Dummy:
pass
dummy = Dummy()
dummy.abc = Persistent()
self.assertRaises(ValueError, index.index_doc, 1, dummy)
def testInterface(self):
self.assert_(IPersistent.implementedBy(Persistent),
"%s does not implement IPersistent" % Persistent)
p = Persistent()
self.assert_(IPersistent.providedBy(p),
"%s does not implement IPersistent" % p)
self.assert_(IPersistent.implementedBy(P),
"%s does not implement IPersistent" % P)
p = self.klass()
self.assert_(IPersistent.providedBy(p),
"%s does not implement IPersistent" % p)
def test_copy(self):
db = DB(None)
conn = db.open()
pers = Persistent()
conn.add(pers)
conn.root()['a'] = pers
orig_wref = CopyingWeakRef(pers)
assert_that(orig_wref, validly_provides(ICachingWeakRef))
assert_that(orig_wref(), is_(same_instance(pers)))
del orig_wref._v_ob
orig_wref.dm = {}
assert_that(orig_wref(), is_not(same_instance(pers)))
def test_prefetch_singledb(self):
jar = self.Jar()
inst = self._makeOne([], 0)
chunk = [
(1, self.Obj()),
(2, self),
(3, object()),
(4, Persistent()),
(5, self.Obj(jar, 1)),
(5, self.Obj(jar, 2)),
(5, self.Obj(jar, 3)),
]
inst._prefetch(chunk)
assert_that(jar.prefetched, is_(({1, 2, 3}, )))
assert_that(inst._prefetch, is_(inst._prefetch_singledb))
def makePersistent(oid):
persist = Persistent()
persist._p_oid = oid
persist._p_jar = dummy_connection
return persist
def __db_default(self):
"""Return the default persisted database."""
return Persistent(self._db_factory, 'ets_perms_policydb',
"the policy database")
print(f"{k}:{v}")
"""
# execute only if run as a script
if __name__ == "__main__":
# --- PID FILE EXISTS ---
if os.path.isfile('smart4l.lock'):
# TODO check if python process run with this pid
Message.wrn("PID file already exists")
os.remove("smart4l.lock")
open("smart4l.lock", "w+").write(str(os.getpid()))
# --- === ---
app = Smart4l()
app.persistent = Persistent(app)
app.httpApi = FlaskAPI(app.persistent)
app.socket = Smart4lServeur(app.update_measure)
app.add_service(
Service(Sensor(DHT11(), "DHT11", app.update_measure), 1,
"Temperature"))
app.add_service(Service(app.persistent, 20, "DB"))
app.add_service(Service(app.httpApi, "API Http"))
app.reload()
try:
# Infinite loop for keyboard interuption
while True:
continue
def __db_default(self):
"""Return the default persisted database."""
return Persistent(dict, 'ets_perms_userdb', "the user database")
