def _unbool(element, true=object(), false=object()):
"""A hack to make True and 1 and False and 0 unique for _uniq."""
if element is True:
return true
elif element is False:
return false
return element
class CounterName(_CounterName):
"""Naming information for a counter."""
SYSTEM = object()
USER = object()
def __new__(cls,
name,
stage_name=None,
step_name=None,
system_name=None,
namespace=None,
origin=None,
output_index=None,
io_target=None):
origin = origin or CounterName.SYSTEM
return super(CounterName,
cls).__new__(cls, name, stage_name, step_name,
system_name, namespace, origin, output_index,
io_target)
def __repr__(self):
return '<CounterName<%s> at %s>' % (self._str_internal(), hex(
id(self)))
def __str__(self):
return self._str_internal()
def _str_internal(self):
if self.origin == CounterName.USER:
return 'user-%s-%s' % (self.step_name, self.name)
elif self.origin == CounterName.SYSTEM and self.output_index:
return '%s-out%s-%s' % (self.step_name, self.output_index,
self.name)
else:
return '%s-%s-%s' % (self.stage_name, self.step_name, self.name)
class SourceRelationMeta(ClassMeta):
"""The meta data for a source object in a relationship"""
# Cardinality constants
ONE_TO_ONE = object()
ONE_TO_M = object()
N_TO_ONE = object()
N_TO_M = object()
def __init__(self, className, targetClassName):
"""Initialize a source relationship meta object
Args:
className (str): The source Mo class name for the relationship
targetClassName (str): The target class name for the relationship
"""
ClassMeta.__init__(self, className)
self.targetClassName = targetClassName
self.cardinality = None
self.isRelation = True
self.isSource = True
self.isExplicit = True
def getTargetClass(self):
"""Imports and returns the target class for a relationship
Returns:
cobra.mit.mo.Mo: The target class
"""
return ClassLoader.loadClass(self.targetClassName)
def test_remove_tracer(self):
"""The C{remote_tracer} function removes a specific tracer."""
tracer1 = object()
tracer2 = object()
install_tracer(tracer1)
install_tracer(tracer2)
remove_tracer(tracer1)
self.assertEquals(get_tracers(), [tracer2])
def execute(self, slot, *args, **kwargs):
if slot == self.OutputList:
return [1, 2, 3]
elif slot == self.OutputOpaque:
return object()
elif slot == self.OutputUnsupportedType:
return object()
else:
return numpy.ones((2, 2), dtype=int)
def all_equal(iter1, iter2):
# Sentinel object used to check that both iterators are the same length
diff_length_sentinel = object()
try:
if iter1 == iter2:
return True
except ValueError:
pass
if iter1 is None and iter2 is None:
return True
try:
i1 = iter(iter1)
i2 = iter(iter2)
except TypeError:
return iter1 == iter2
for [ip1, ip2] in zip_longest(i1, i2,
fillvalue=diff_length_sentinel):
# Verify that none of the lists has ended (then they are not the
# same size)
if ip1 is diff_length_sentinel or ip2 is diff_length_sentinel:
return False
if not all_equal(ip1, ip2):
return False
return True
def test_auto_remove_change_notification_with_arg(self):
changes1 = []
changes2 = []
def object_changed1(obj_info, variable, old_value, new_value, fromdb,
arg):
changes1.append(
(1, obj_info, variable, old_value, new_value, fromdb, arg))
return False
def object_changed2(obj_info, variable, old_value, new_value, fromdb,
arg):
changes2.append(
(2, obj_info, variable, old_value, new_value, fromdb, arg))
return False
self.obj_info.checkpoint()
obj = object()
self.obj_info.event.hook("changed", object_changed1, obj)
self.obj_info.event.hook("changed", object_changed2, obj)
self.obj.prop2 = 20
self.obj.prop1 = 10
self.assertEquals(
changes1,
[(1, self.obj_info, self.variable2, Undef, 20, False, obj)])
self.assertEquals(
changes2,
[(2, self.obj_info, self.variable2, Undef, 20, False, obj)])
def test_timedelta(self):
self.setup(TimeDelta,
default=timedelta(days=1, seconds=2, microseconds=3),
allow_none=False)
self.assertTrue(isinstance(self.column1, Column))
self.assertTrue(isinstance(self.column2, Column))
self.assertEquals(self.column1.name, "column1")
self.assertEquals(self.column1.table, self.SubClass)
self.assertEquals(self.column2.name, "prop2")
self.assertEquals(self.column2.table, self.SubClass)
self.assertTrue(isinstance(self.variable1, TimeDeltaVariable))
self.assertTrue(isinstance(self.variable2, TimeDeltaVariable))
self.assertEquals(self.obj.prop1,
timedelta(days=1, seconds=2, microseconds=3))
self.assertRaises(NoneError, setattr, self.obj, "prop1", None)
self.obj.prop2 = None
self.assertEquals(self.obj.prop2, None)
self.obj.prop1 = timedelta(days=42, seconds=42, microseconds=42)
self.assertEquals(self.obj.prop1,
timedelta(days=42, seconds=42, microseconds=42))
self.assertRaises(TypeError, setattr, self.obj, "prop1", object())
def all_almost_equal(iter1, iter2, places=None):
"""`True` if all elements in ``a`` and ``b`` are almost equal."""
try:
if iter1 is iter2 or iter1 == iter2:
return True
except ValueError:
pass
if iter1 is None and iter2 is None:
return True
if places is None:
places = _places(iter1, iter2, None)
if hasattr(iter1, '__array__') and hasattr(iter2, '__array__'):
return all_almost_equal_array(iter1, iter2, places)
try:
it1 = iter(iter1)
it2 = iter(iter2)
except TypeError:
return almost_equal(iter1, iter2, places)
diff_length_sentinel = object()
for [ip1, ip2] in zip_longest(it1, it2,
fillvalue=diff_length_sentinel):
# Verify that none of the lists has ended (then they are not the
# same size)
if ip1 is diff_length_sentinel or ip2 is diff_length_sentinel:
return False
if not all_almost_equal(ip1, ip2, places):
return False
return True
def __eq__(self, other):
if isinstance(other, collections.Iterable):
return all(
a == b
for a, b in zip_longest(self, other, fillvalue=object()))
else:
return NotImplemented
def __eq__(self, other):
if isinstance(other, collections.Iterable):
return all(
a == b
for a, b in zip_longest(self, other, fillvalue=object()))
else:
return NotImplemented
def resize(self, maxsize):
""" Resize the cache. Increasing the size of the cache is non-destructive, i.e.,
previously cached inputs remain in the cache. Decreasing the size of the cache will
necessarily remove items from the cache if the cache is already filled. Items are removed
in least recently used order.
@param maxsize The new maximum number of inputs to cache.
"""
oldsize = len(self.cache)
if maxsize == oldsize:
return
else:
root = self.root
cache = self.cache
if maxsize < oldsize:
for i in range(oldsize - maxsize):
# Delete root.next
current_next_link = root[1]
new_next_link = root[1] = root[1][1]
new_next_link[0] = root
del cache[current_next_link[2]]
elif maxsize > oldsize:
for i in range(maxsize - oldsize):
# Insert between root and root.next
key = object()
cache[key] = link = [root, root[1], key, None]
root[1][0] = link
root[1] = link
else:
raise ValueError("Invalid maxsize: {0:}".format(maxsize))
def all_almost_equal(iter1, iter2, places=None):
"""Return ``True`` if all elements in ``a`` and ``b`` are almost equal."""
try:
if iter1 is iter2 or iter1 == iter2:
return True
except ValueError:
pass
if iter1 is None and iter2 is None:
return True
if hasattr(iter1, '__array__') and hasattr(iter2, '__array__'):
# Only get default places if comparing arrays, need to keep `None`
# otherwise for recursive calls.
if places is None:
places = _places(iter1, iter2, None)
return all_almost_equal_array(iter1, iter2, places)
try:
it1 = iter(iter1)
it2 = iter(iter2)
except TypeError:
return almost_equal(iter1, iter2, places)
diff_length_sentinel = object()
for [ip1, ip2] in zip_longest(it1, it2, fillvalue=diff_length_sentinel):
# Verify that none of the lists has ended (then they are not the
# same size)
if ip1 is diff_length_sentinel or ip2 is diff_length_sentinel:
return False
if not all_almost_equal(ip1, ip2, places):
return False
return True
def run(self):
control_stub = beam_fn_api_pb2_grpc.BeamFnControlStub(
self._control_channel)
no_more_work = object()
# Create workers
bundle_processor_cache = BundleProcessorCache(
state_handler_factory=self._state_handler_factory,
data_channel_factory=self._data_channel_factory,
fns=self._fns)
for _ in range(self._worker_count):
# SdkHarness manage function registration and share self._fns with all
# the workers. This is needed because function registration (register)
# and exceution(process_bundle) are send over different request and we
# do not really know which woker is going to process bundle
# for a function till we get process_bundle request. Moreover
# same function is reused by different process bundle calls and
# potentially get executed by different worker. Hence we need a
# centralized function list shared among all the workers.
self.workers.put(
SdkWorker(bundle_processor_cache,
profiler_factory=self._profiler_factory))
def get_responses():
while True:
response = self._responses.get()
if response is no_more_work:
return
yield response
self._alive = True
monitoring_thread = threading.Thread(
target=self._monitor_process_bundle)
monitoring_thread.daemon = True
monitoring_thread.start()
try:
for work_request in control_stub.Control(get_responses()):
logging.debug('Got work %s', work_request.instruction_id)
request_type = work_request.WhichOneof('request')
# Name spacing the request method with 'request_'. The called method
# will be like self.request_register(request)
getattr(self, SdkHarness.REQUEST_METHOD_PREFIX +
request_type)(work_request)
finally:
self._alive = False
logging.info('No more requests from control plane')
logging.info('SDK Harness waiting for in-flight requests to complete')
# Wait until existing requests are processed.
self._progress_thread_pool.shutdown()
self._process_thread_pool.shutdown()
# get_responses may be blocked on responses.get(), but we need to return
# control to its caller.
self._responses.put(no_more_work)
# Stop all the workers and clean all the associated resources
self._data_channel_factory.close()
self._state_handler_factory.close()
logging.info('Done consuming work.')
def test_should_fail_if_service_is_bad(self):
testfs = [
lambda: self._get_registry(),
lambda: service.MethodRegistry(None),
lambda: service.MethodRegistry(object()),
]
for f in testfs:
expect(f).to(raise_error(ValueError))
def test_sign_invalid_pubkey(self):
'''
signing data using an invalid key-object fails
'''
priv, pub = rsa.create_signing_keypair(1024)
with self.assertRaises(ValueError) as ctx:
rsa.sign_data(object(), b"data")
self.assertIn("must be an RSAPrivateKey", str(ctx.exception))
def test_should_fail_if_service_is_bad(self):
testfs = [
lambda: self._get_registry(),
lambda: service.MethodRegistry(None),
lambda: service.MethodRegistry(object()),
]
for f in testfs:
expect(f).to(raise_error(ValueError))
def test_verify_invalid_pubkey(self):
'''
pubkey must be correct kind of object
'''
priv, pub = ed25519.create_signing_keypair()
with self.assertRaises(ValueError) as ctx:
ed25519.verify_signature(object(), b"signature", b"data")
self.assertIn("must be an Ed25519PublicKey", str(ctx.exception))
def test_verify_invalid_pubkey(self):
'''
verifying a signature using an invalid key-object fails
'''
priv, pub = rsa.create_signing_keypair(1024)
with self.assertRaises(ValueError) as ctx:
rsa.verify_signature(object(), b"signature", b"data")
self.assertIn("must be an RSAPublicKey", str(ctx.exception))
class SourceRelationMeta(ClassMeta):
# Cardinality constants
ONE_TO_ONE = object()
ONE_TO_M = object()
N_TO_ONE = object()
N_TO_M = object()
def __init__(self, className, targetClassName):
ClassMeta.__init__(self, className)
self.targetClassName = targetClassName
self.cardinality = None
self.isRelation = True
self.isSource = True
self.isExplicit = True
def getTargetClass(self):
return ClassLoader.loadClass(self.targetClassName)
def dict_diff(left, right):
u"""
Computes a dictionary with the elements that are in the right but
not or different in the left.
"""
dummy = object()
return dict([
k_v for k_v in iter(right.items()) if left.get(k_v[0], dummy) != k_v[1]
])
def run(self):
control_stub = beam_fn_api_pb2_grpc.BeamFnControlStub(self._control_channel)
no_more_work = object()
# Create workers
for _ in range(self._worker_count):
# SdkHarness manage function registration and share self._fns with all
# the workers. This is needed because function registration (register)
# and exceution(process_bundle) are send over different request and we
# do not really know which woker is going to process bundle
# for a function till we get process_bundle request. Moreover
# same function is reused by different process bundle calls and
# potentially get executed by different worker. Hence we need a
# centralized function list shared among all the workers.
self.workers.put(
SdkWorker(
state_handler_factory=self._state_handler_factory,
data_channel_factory=self._data_channel_factory,
fns=self._fns,
profiler_factory=self._profiler_factory))
def get_responses():
while True:
response = self._responses.get()
if response is no_more_work:
return
yield response
self._alive = True
monitoring_thread = threading.Thread(target=self._monitor_process_bundle)
monitoring_thread.daemon = True
monitoring_thread.start()
try:
for work_request in control_stub.Control(get_responses()):
logging.debug('Got work %s', work_request.instruction_id)
request_type = work_request.WhichOneof('request')
# Name spacing the request method with 'request_'. The called method
# will be like self.request_register(request)
getattr(self, SdkHarness.REQUEST_METHOD_PREFIX + request_type)(
work_request)
finally:
self._alive = False
logging.info('No more requests from control plane')
logging.info('SDK Harness waiting for in-flight requests to complete')
# Wait until existing requests are processed.
self._progress_thread_pool.shutdown()
self._process_thread_pool.shutdown()
# get_responses may be blocked on responses.get(), but we need to return
# control to its caller.
self._responses.put(no_more_work)
# Stop all the workers and clean all the associated resources
self._data_channel_factory.close()
self._state_handler_factory.close()
logging.info('Done consuming work.')
def test_successResultOf_ok(self):
"""
successResultOf will not fail if deferred has a result.
"""
value = object()
deferred = defer.succeed(value)
result = self.successResultOf(deferred)
self.assertEqual(value, result)
def memoize(func):
cache = {}
missing = object()
def wrapper(*args):
result = cache.get(args, missing)
if result is missing:
result = cache[args] = func(*args)
return result
return wrapper
def test_get_patch_module_no_sub_level(self):
"""
The C{get_patch_module} method returns a dummy patch module if no
sub-level file exists in the patch directory for the given version.
"""
patch_1_dir = os.path.join(self.package_dir, "patch_1")
os.makedirs(patch_1_dir)
patch_module = self.patch_package.get_patch_module(1)
store = object()
self.assertIsNone(patch_module.apply(store))
def memoize(func):
cache = {}
missing = object()
def wrapper(*args):
result = cache.get(args, missing)
if result is missing:
result = cache[args] = func(*args)
return result
return wrapper
def test_scoped_to_request(self):
"""Test that the cache is scoped to requests."""
c = CacheClass()
self.assertEqual(2, c.foo(1))
self.mock.get_request.return_value = object()
self.assertEqual(2, c.foo(1))
self.assertListEqual([
(1, ),
(1, ),
], c.called)
def __init__(self,
channel,
queue_capacity=100,
batch_size=10,
flush_interval=DEFAULT_FLUSH_INTERVAL,
io_loop=None,
error_reporter=None,
metrics=None,
metrics_factory=None,
**kwargs):
"""
:param channel: a communication channel to jaeger-agent
:param queue_capacity: how many spans we can hold in memory before
starting to drop spans
:param batch_size: how many spans we can submit at once to Collector
:param flush_interval: how often the auto-flush is called (in seconds)
:param io_loop: which IOLoop to use. If None, try to get it from
channel (only works if channel is tchannel.sync)
:param error_reporter:
:param metrics: an instance of Metrics class, or None. This parameter
has been deprecated, please use metrics_factory instead.
:param metrics_factory: an instance of MetricsFactory class, or None.
:param kwargs:
'logger'
:return:
"""
from threading import Lock
self._channel = channel
self.queue_capacity = queue_capacity
self.batch_size = batch_size
self.metrics_factory = metrics_factory or LegacyMetricsFactory(
metrics or Metrics())
self.metrics = ReporterMetrics(self.metrics_factory)
self.error_reporter = error_reporter or ErrorReporter(Metrics())
self.logger = kwargs.get('logger', default_logger)
self.agent = Agent.Client(self._channel, self)
if queue_capacity < batch_size:
raise ValueError('Queue capacity cannot be less than batch size')
self.io_loop = io_loop or channel.io_loop
if self.io_loop is None:
self.logger.error('Jaeger Reporter has no IOLoop')
else:
self.queue = tornado.queues.Queue(maxsize=queue_capacity)
self.stop = object()
self.stopped = False
self.stop_lock = Lock()
self.flush_interval = flush_interval or None
self.io_loop.spawn_callback(self._consume_queue)
self._process_lock = Lock()
self._process = None
class BeamFnControlServicer(beam_fn_api_pb2_grpc.BeamFnControlServicer):
UNSTARTED_STATE = 'unstarted'
STARTED_STATE = 'started'
DONE_STATE = 'done'
_DONE_MARKER = object()
def __init__(self):
self._push_queue = queue.Queue()
self._futures_by_id = dict()
self._read_thread = threading.Thread(
name='beam_control_read', target=self._read)
self._uid_counter = 0
self._state = self.UNSTARTED_STATE
self._lock = threading.Lock()
def Control(self, iterator, context):
with self._lock:
if self._state == self.DONE_STATE:
return
else:
self._state = self.STARTED_STATE
self._inputs = iterator
# Note: We only support one client for now.
self._read_thread.start()
while True:
to_push = self._push_queue.get()
if to_push is self._DONE_MARKER:
return
yield to_push
def _read(self):
for data in self._inputs:
self._futures_by_id.pop(data.instruction_id).set(data)
def push(self, item):
if item is self._DONE_MARKER:
future = None
else:
if not item.instruction_id:
self._uid_counter += 1
item.instruction_id = 'control_%s' % self._uid_counter
future = ControlFuture(item.instruction_id)
self._futures_by_id[item.instruction_id] = future
self._push_queue.put(item)
return future
def done(self):
with self._lock:
if self._state == self.STARTED_STATE:
self.push(self._DONE_MARKER)
self._read_thread.join()
self._state = self.DONE_STATE
def test_index_doc_callback_discriminator(self):
OTHER_FACETS = ['foo', 'foo:bar', 'foo:baz']
def _discrimintator(obj, default):
return ['foo:bar']
index = self._makeOne(_discrimintator, OTHER_FACETS)
index.index_doc(1, object())
self.assertEqual(list(index._fwd_index['foo']), [1])
self.assertEqual(list(index._fwd_index['foo:bar']), [1])
self.assertEqual(list(index._rev_index[1]), ['foo', 'foo:bar'])
def __init__(self, user_function, maxsize=1024):
# Link layout: [PREV, NEXT, KEY, RESULT]
self.root = root = [None, None, None, None]
self.user_function = user_function
self.cache = cache = {}
last = root
for i in range(maxsize):
key = object()
cache[key] = last[1] = last = [last, root, key, None]
root[0] = last
def test_notify(self):
"""
The notify() API allows getting all events passed to the Discovery instance.
"""
disco = create_disco()
messages = [object(), NodeActive(create_node("hello"))]
result = []
disco.notify(result.append)
for m in messages:
disco.onMessage(None, m)
self.assertEqual(messages, result)
def setUp(self):
super(ClusterScalerTest, self).setUp()
self.config = Config()
self.config.targetTime = 1800
self.config.nodeTypes = ['r3.8xlarge', 'c4.8xlarge:0.6']
# Set up a stub provisioner with some nodeTypes and nodeShapes.
self.provisioner = object()
self.provisioner.nodeTypes = ['r3.8xlarge', 'c4.8xlarge']
self.provisioner.nodeShapes = [r3_8xlarge, c4_8xlarge_preemptable]
self.provisioner.setStaticNodes = lambda _, __: None
self.provisioner.retryPredicate = lambda _: False
self.leader = MockBatchSystemAndProvisioner(self.config, 1)
def initiate_checkpoint():
with self._checkpoint_lock:
if checkpoint_state.checkpointed:
return
checkpoint_state.checkpointed = object()
split = sdf_invoker.try_split(0)
if split:
_, checkpoint_state.residual_restriction = split
else:
# Clear the checkpoint if the split didn't happen. This counters
# a very unlikely race condition that the Timer attempted to initiate
# a checkpoint before invoke_process set the current element allowing
# for another attempt to checkpoint.
checkpoint_state.checkpointed = None
def memoize_on_instance(f):
missing = object()
def wrapper(self, *args):
try:
cache = getattr(self, '_cache_%s' % f.__name__)
except AttributeError:
cache = {}
setattr(self, '_cache_%s' % f.__name__, cache)
result = cache.get(args, missing)
if result is missing:
result = cache[args] = f(self, *args)
return result
return wrapper
def test_commit_already_committed(self):
from google.cloud.spanner_v1.keyset import KeySet
keys = [[0], [1], [2]]
keyset = KeySet(keys=keys)
database = _Database()
session = _Session(database)
batch = self._make_one(session)
batch.committed = object()
batch.delete(TABLE_NAME, keyset=keyset)
with self.assertRaises(ValueError):
batch.commit()
self.assertNoSpans()
def test_container(self):
"""
base test for Container class
"""
foo = object()
foo.id = TEST_ID
foo.name = TEST_NAME
foo.addrs = TEST_ADDRS
container = Container(foo)
self.assertEquals(container.id, TEST_ID)
self.assertEquals(container.name, TEST_NAME)
self.assertEquals(container.addrs, TEST_ADDRS)
self.assertIsNotNone(str(container))
def memoize_on_instance(f):
missing = object()
def wrapper(self, *args):
try:
cache = getattr(self, '_cache_%s' % f.__name__)
except AttributeError:
cache = {}
setattr(self, '_cache_%s' % f.__name__, cache)
result = cache.get(args, missing)
if result is missing:
result = cache[args] = f(self, *args)
return result
return wrapper
def testOsFunctionMapper(self):
from Exscript.util.decorator import os_function_mapper
cb_map = {'ios': self.ios_cb, 'junos': self.junos_cb}
mapper = os_function_mapper(cb_map)
job = FakeJob()
host = object()
# Test with 'ios'.
conn = FakeConnection(os='ios')
result = mapper(job, host, conn)
self.assertEqual(result, 'hello ios')
# Test with 'junos'.
conn = FakeConnection(os='junos')
result = mapper(job, host, conn)
self.assertEqual(result, 'hello junos')
# Test with unsupported OS.
conn = FakeConnection(os='unknown')
self.assertRaises(Exception, mapper, job, host, conn)
def all_equal(iter1, iter2):
"""`True` if all elements in ``a`` and ``b`` are equal."""
# Direct comparison for scalars, tuples or lists
try:
if iter1 == iter2:
return True
except ValueError: # Raised by NumPy when comparing arrays
pass
# Special case for None
if iter1 is None and iter2 is None:
return True
# If one nested iterator is exhausted, go to direct comparison
try:
it1 = iter(iter1)
it2 = iter(iter2)
except TypeError:
try:
return iter1 == iter2
except ValueError: # Raised by NumPy when comparing arrays
return False
diff_length_sentinel = object()
# Compare element by element and return False if the sequences have
# different lengths
for [ip1, ip2] in zip_longest(it1, it2,
fillvalue=diff_length_sentinel):
# Verify that none of the lists has ended (then they are not the
# same size)
if ip1 is diff_length_sentinel or ip2 is diff_length_sentinel:
return False
if not all_equal(ip1, ip2):
return False
return True
def test_kwargs():
"""
Verify that kwargs can be adapted
"""
class Test(object):
@anticipate(foo=int, bar=str)
def get_args(self, arg, **kwargs):
return arg, kwargs
@anticipate(foo=int, bar=str)
def get_args(arg, **kwargs):
return arg, kwargs
t = Test()
obj = object()
r = t.get_args(obj, foo='2', bar=3)
assert r[0] is obj
assert r[1]['foo'] == 2
assert r[1]['bar'] == '3'
r = get_args(obj, foo='2', bar=3)
assert r[0] is obj
assert r[1]['foo'] == 2
assert r[1]['bar'] == '3'
r = t.get_args(arg=obj, foo='2', bar=3)
assert r[0] is obj
assert r[1]['foo'] == 2
assert r[1]['bar'] == '3'
r = get_args(arg=obj, foo='2', bar=3)
assert r[0] is obj
assert r[1]['foo'] == 2
assert r[1]['bar'] == '3'
def roundrobin(*iterables):
sentinel = object()
return (x for x in chain(*izip_longest(fillvalue=sentinel, *iterables)) if x is not sentinel)
def _recurse(o, dct, depth):
if max_depth >= 0 and depth > max_depth:
return
for ref in get_referents(o):
idr = id(ref)
if not idr in dct:
dct[idr] = (ref, getsizeof(ref, default=0))
_recurse(ref, dct, depth+1)
sizedict = {}
_recurse(obj, sizedict, 0)
#count = len(sizedict) + 1
size = getsizeof(obj) + sum([p[1] for p in sizedict.values()])
return size
# lazy load handler
_missing = object()
class lazy_property(object):
"""
Delays loading of property until first access. Credit goes to the
Implementation in the werkzeug suite:
http://werkzeug.pocoo.org/docs/utils/#werkzeug.utils.cached_property
This should be used as a decorator in a class and in Evennia is
mainly used to lazy-load handlers:
```python
@lazy_property
def attributes(self):
return AttributeHandler(self)
```
def test_should_raise_if_constructed_with_a_bad_protocol(self):
testf = lambda: report_request.Info(protocol=object())
# not a report_request.ReportedProtocols
expect(testf).to(raise_error(ValueError))
import struct
import sys
import termios
t = gettext.translation('okaara', fallback=True)
if sys.version_info[0] < 3:
_ = t.ugettext
else:
_ = t.gettext
# -- constants ----------------------------------------------------------------
LOG = logging.getLogger(__name__)
# Returned to indicate the user has interrupted the input
ABORT = object()
# Indicates the automatic wrap should use the current width of the screen,
# calculated at the time of rendering
WIDTH_TERMINAL = object()
COLOR_WHITE = '\033[0m'
COLOR_BRIGHT_WHITE = '\033[1m'
COLOR_GRAY = '\033[30m'
COLOR_RED = '\033[31m'
COLOR_GREEN = '\033[32m'
COLOR_YELLOW = '\033[33m'
COLOR_BLUE = '\033[34m'
COLOR_PURPLE = '\033[35m'
COLOR_CYAN = '\033[36m'
def __exit__(self, exc_type, exc_value, traceback):
pass
try: # Python 2.7+
from collections import OrderedDict
except ImportError:
from .packages.ordered_dict import OrderedDict
from .packages.six import itervalues
__all__ = ['RecentlyUsedContainer', 'HTTPHeaderDict']
_Null = object()
class RecentlyUsedContainer(MutableMapping):
"""
Provides a thread-safe dict-like container which maintains up to
``maxsize`` keys while throwing away the least-recently-used keys beyond
``maxsize``.
:param maxsize:
Maximum number of recent elements to retain.
:param dispose_func:
Every time an item is evicted from the container,
``dispose_func(value)`` is called. Callback which will get called
"""
""" Copyright (c) 2002-2003 LOGILAB S.A. (Paris, FRANCE). http://www.logilab.fr/ -- mailto:[email protected] Cache module, with a least recently used algorithm for the management of the deletion of entries. """ from __future__ import unicode_literals from __future__ import print_function from __future__ import division from __future__ import absolute_import from future import standard_library standard_library.install_aliases() from builtins import * from builtins import object _marker = object() class Cache(object): """ a dictionnary like cache inv: len(self._usage) <= self.size len(self.data) <= self.size """ def __init__(self, size=100): self.data = {} self.size = size self._usage = [] def __repr__(self):
def test_should_raise_if_constructed_with_a_bad_error_cause(self):
testf = lambda: report_request.Info(error_cause=object())
expect(testf).to(raise_error(ValueError))
def __init__(self): self.objects = FakeGcsObjects() # Referenced in GcsIO.copy_batch() and GcsIO.delete_batch(). self._http = object()
FlavorError,
ImageError,
InstanceNotFoundError,
KeypairError,
SecurityGroupError,
)
# these defaults should be kept in sync w/ `conf.py`
DEFAULT_OS_COMPUTE_API_VERSION='2'
DEFAULT_OS_IDENTITY_API_VERSION='3'
DEFAULT_OS_IMAGE_API_VERSION='2'
DEFAULT_OS_NETWORK_API_VERSION='2.0' # no choice as of Aug. 2017
DEFAULT_OS_VOLUME_API_VERSION='2'
_NO_DEFAULT = object()
"""
Special value used in `_get_os_config_value` to indicate that a
value *must* be provided.
"""
class OpenStackCloudProvider(AbstractCloudProvider):
"""
This implementation of
:py:class:`elasticluster.providers.AbstractCloudProvider` uses the
OpenStack native python bindings to connect to OpenStack clouds
and manage instances.
:param str username: username of the keystone user
def test_get_namespace_error(self):
with self.assertRaises(ValueError):
Metrics.get_namespace(object())
def __init__(self): self.objects = FakeGcsObjects() # Referenced in GcsIO.batch_copy() and GcsIO.batch_delete(). self._http = object()
def test_should_fail_on_invalid_input(self):
testf = lambda: check_request.sign(None)
expect(testf).to(raise_error(ValueError))
testf = lambda: check_request.sign(object())
expect(testf).to(raise_error(ValueError))
def test_should_fail_if_req_is_bad(self):
testf = lambda: self.agg.report(object())
expect(testf).to(raise_error(ValueError))
testf = lambda: self.agg.report(None)
expect(testf).to(raise_error(ValueError))
# Internal country indexes
_by_alpha2 = _build_index(1)
_by_alpha3 = _build_index(2)
_by_numeric = _build_index(3)
_by_name = _build_index(0)
# Documented accessors for the country indexes
countries_by_alpha2 = _by_alpha2
countries_by_alpha3 = _by_alpha3
countries_by_numeric = _by_numeric
countries_by_name = _by_name
NOT_FOUND = object()
class _CountryLookup(object):
def get(self, key, default=NOT_FOUND):
if isinstance(key, Integral):
r = _by_numeric.get("%03d" % key, default)
else:
k = key.upper()
if len(k) == 2:
r = _by_alpha2.get(k, default)
elif len(k) == 3 and re.match(r"[0-9]{3}", k):
r = _by_numeric.get(k, default)
elif len(k) == 3:
r = _by_alpha3.get(k, default)
else:
raise ValueError('Invalid state spec: %s' % state_spec)
def _encode(self, value):
return self._state_spec.coder.encode(value)
def _decode(self, value):
return self._state_spec.coder.decode(value)
def prefetch(self):
# The default implementation here does nothing.
pass
# Sentinel designating an unread value.
UNREAD_VALUE = object()
class BagRuntimeState(RuntimeState):
"""Bag state interface object passed to user code."""
def __init__(self, state_spec, state_tag, current_value_accessor):
super(BagRuntimeState, self).__init__(
state_spec, state_tag, current_value_accessor)
self._cached_value = UNREAD_VALUE
self._cleared = False
self._new_values = []
def read(self):
if self._cached_value is UNREAD_VALUE:
self._cached_value = self._current_value_accessor()
def initiate_checkpoint():
with self._checkpoint_lock:
if checkpoint_state.checkpointed:
return
checkpoint_state.residual_restriction = tracker.checkpoint()
checkpoint_state.checkpointed = object()
def __gt__(s, o): return (s.time, s.priority) > (o.time, o.priority)
def __ge__(s, o): return (s.time, s.priority) >= (o.time, o.priority)
if PY3:
Event.time.__doc__ = ('''Numeric type compatible with the return value of the
timefunc function passed to the constructor.''')
Event.priority.__doc__ = ('''Events scheduled for the same time will be executed
in the order of their priority.''')
Event.action.__doc__ = ('''Executing the event means executing
action(*argument, **kwargs)''')
Event.argument.__doc__ = ('''argument is a sequence holding the positional
arguments for the action.''')
Event.kwargs.__doc__ = ('''kwargs is a dictionary holding the keyword
arguments for the action.''')
_sentinel = object()
class scheduler(object):
def __init__(self, timefunc=_time, delayfunc=time.sleep):
"""Initialize a new instance, passing the time and delay
functions"""
self._queue = []
self._lock = threading.RLock()
self.timefunc = timefunc
self.delayfunc = delayfunc
def enterabs(self, time, priority, action, argument=(), kwargs=_sentinel):
"""Enter a new event in the queue at an absolute time.
Returns an ID for the event which can be used to remove it,
