def _same_function(func1, func2):
'''
Helper function, used during namespace resolution for comparing whether to
functions are the same. This takes care of treating a function and a
`Function` variables whose `Function.pyfunc` attribute matches as the
same. This prevents the user from getting spurious warnings when having
for example a numpy function such as :np:func:`~random.randn` in the local
namespace, while the ``randn`` symbol in the numpy namespace used for the
code objects refers to a `RandnFunction` specifier.
'''
# use the function itself if it doesn't have a pyfunc attribute and try
# to create a weak proxy to make a comparison to other weak proxys return
# true
func1 = getattr(func1, 'pyfunc', func1)
try:
func1 = weakref.proxy(func1)
except TypeError:
pass # already a weakref proxy
func2 = getattr(func2, 'pyfunc', func2)
try:
func2 = weakref.proxy(func2)
except TypeError:
pass
return func1 is func2
def __init__(self, frame):
super(LogitechMonitorBattleMonoScreen, self).__init__(frame)
self.__timerPresenter = _TimerPresenter(weakref.proxy(self))
self.__fragsPresenter = _FragsPresenter(weakref.proxy(self))
self.__timerDisplayData = None
self.__fragsDisplayData = None
return
def __init__(self, wrapped, callback=None):
# We need to determine if the wrapped function is actually a
# bound method. In the case of a bound method, we need to keep a
# reference to the original unbound function and the instance.
# This is necessary because if we hold a reference to the bound
# function, it will be the only reference and given it is a
# temporary object, it will almost immediately expire and
# the weakref callback triggered. So what is done is that we
# hold a reference to the instance and unbound function and
# when called bind the function to the instance once again and
# then call it. Note that we avoid using a nested function for
# the callback here so as not to cause any odd reference cycles.
_callback = callback and functools.partial(
_weak_function_proxy_callback, proxy=self,
callback=callback)
self._self_expired = False
try:
self._self_instance = weakref.ref(wrapped.__self__, _callback)
super(WeakFunctionProxy, self).__init__(
weakref.proxy(wrapped.__func__, _callback))
except AttributeError:
self._self_instance = None
super(WeakFunctionProxy, self).__init__(
weakref.proxy(wrapped, _callback))
def start(self):
import BattleReplay
replayCtrl = BattleReplay.g_replayCtrl
if isEventBattle():
replayCtrl.enableAutoRecordingBattles(0)
isReplayRecording = replayCtrl.isRecording
isReplayPlaying = replayCtrl.isPlaying
self.__arenaDP = ArenaDataProvider()
self.__ctx.start(self.__arenaDP)
self.__ammoCtrl = consumables.createAmmoCtrl(isReplayPlaying, isReplayRecording)
self.__equipmentsCtrl = consumables.createEquipmentCtrl(isReplayPlaying)
self.__optDevicesCtrl = consumables.createOptDevicesCtrl()
self.__vehicleStateCtrl = vehicle_state_ctrl.createCtrl(isReplayRecording)
self.__chatCommands = ChatCommandsController()
self.__arenaLoadCtrl = ArenaLoadController()
self.__drrScaleCtrl = DRRScaleController()
self.__respawnsCtrl = RespawnsController()
self.__notificationsCtrl = NotificationsController()
self.__repairCtrl = RepairController()
self.__arenaListeners = ListenersCollection()
self.__arenaListeners.addController(weakref.proxy(self.__ctx), self.__arenaLoadCtrl)
self.__arenaListeners.addController(weakref.proxy(self.__ctx), self.__respawnsCtrl)
self.__arenaListeners.start(arenaDP=self.__arenaDP)
self.__feedback = createFeedbackAdaptor(isReplayPlaying)
self.__feedback.start(self.__arenaDP)
self.__requestsCtrl = AvatarRequestsController()
def __init__(self, plugin, callback, userdata, is_unload):
self.is_unload = is_unload
self.plugin = weakref.proxy(plugin)
self.callback = callback
self.userdata = userdata
self.hexchat_hook = None
self.handle = ffi.new_handle(weakref.proxy(self))
def memhostalloc(self, bytesize, mapped=False, portable=False, wc=False):
self.trashing.service()
pointer = c_void_p()
flags = 0
if mapped:
flags |= enums.CU_MEMHOSTALLOC_DEVICEMAP
if portable:
flags |= enums.CU_MEMHOSTALLOC_PORTABLE
if wc:
flags |= enums.CU_MEMHOSTALLOC_WRITECOMBINED
driver.cuMemHostAlloc(byref(pointer), bytesize, flags)
owner = None
if mapped:
_hostalloc_finalizer = _make_mem_finalizer(driver.cuMemFreeHost)
finalizer = _hostalloc_finalizer(self, pointer)
mem = MappedMemory(weakref.proxy(self), owner, pointer,
bytesize, finalizer=finalizer)
self.allocations[mem.handle.value] = mem
return mem.own()
else:
finalizer = _pinnedalloc_finalizer(self.trashing, pointer)
mem = PinnedMemory(weakref.proxy(self), owner, pointer, bytesize,
finalizer=finalizer)
return mem
def mempin(self, owner, pointer, size, mapped=False):
self.trashing.service()
if isinstance(pointer, (int, long)):
pointer = c_void_p(pointer)
if mapped and not self.device.CAN_MAP_HOST_MEMORY:
raise CudaDriverError("%s cannot map host memory" % self.device)
# possible flags are "portable" (between context)
# and "device-map" (map host memory to device thus no need
# for memory transfer).
flags = 0
if mapped:
flags |= enums.CU_MEMHOSTREGISTER_DEVICEMAP
driver.cuMemHostRegister(pointer, size, flags)
if mapped:
_mapped_finalizer = _make_mem_finalizer(driver.cuMemHostUnregister)
finalizer = _mapped_finalizer(self, pointer)
mem = MappedMemory(weakref.proxy(self), owner, pointer, size,
finalizer=finalizer)
self.allocations[mem.handle.value] = mem
return mem.own()
else:
mem = PinnedMemory(weakref.proxy(self), owner, pointer, size,
finalizer=_pinned_finalizer(self.trashing,
pointer))
return mem
def __init__(self, inkmode, tdw):
super(Overlay, self).__init__()
self._inkmode = weakref.proxy(inkmode)
self._tdw = weakref.proxy(tdw)
self._button_pixbuf_cache = {}
self.accept_button_pos = None
self.reject_button_pos = None
def __init__(self, machine, communicator=None, **kwargs):
from candelabra.topology.machine import MachineNode
assert isinstance(machine, MachineNode)
assert isinstance(communicator, Communicator)
self.machine = proxy(machine)
self.communicator = proxy(communicator) if communicator else proxy(machine.communicator)
def __set__(self, instance, value):
"""Descriptor for assigning a value to a field in a document.
"""
# If setting to None and there is a default
# Then set the value to the default value
if value is None:
if self.null:
value = None
elif self.default is not None:
value = self.default
if callable(value):
value = value()
if instance._initialised:
try:
if (self.name not in instance._data or
instance._data[self.name] != value):
instance._mark_as_changed(self.name)
except:
# Values cant be compared eg: naive and tz datetimes
# So mark it as changed
instance._mark_as_changed(self.name)
EmbeddedDocument = _import_class('EmbeddedDocument')
if isinstance(value, EmbeddedDocument):
value._instance = weakref.proxy(instance)
elif isinstance(value, (list, tuple)):
for v in value:
if isinstance(v, EmbeddedDocument):
v._instance = weakref.proxy(instance)
instance._data[self.name] = value
def __init__(self, sess, gpcs, objectID, pa, refID):
try:
self.__dict__['session'] = weakref.proxy(sess)
except TypeError:
self.__dict__['session'] = sess
sys.exc_clear()
self.__dict__['objectID'] = objectID
self.__dict__['sessionCheck'] = None
self.__dict__['persistantObjectID'] = objectID
self.__dict__['gpcs'] = weakref.proxy(gpcs)
self.__dict__['__publicattributes__'] = pa
self.__dict__['objectChangeHandlers'] = weakref.WeakKeyDictionary({})
mask = sess.Masquerade()
try:
self.__dict__['clisid'] = gpcs.machoNet.GetClientSessionID()
finally:
mask.UnMask()
if objectID[0] == 'C':
self.__dict__['blocking'] = 0
cid, oid = objectID.split(':')
cid = cid.split('=')[1]
self.__dict__['destination'] = macho.MachoAddress(clientID=long(cid))
else:
self.__dict__['blocking'] = 1
nid, oid = objectID.split(':')
nid = nid.split('=')[1]
self.__dict__['destination'] = macho.MachoAddress(nodeID=long(nid))
self.__dict__['deleted'] = 0
sess.RegisterMachoObjectConnection(objectID, self, refID)
def test_proxy_reuse(self):
o = C()
proxy1 = weakref.proxy(o)
ref = weakref.ref(o)
proxy2 = weakref.proxy(o)
self.assert_(proxy1 is proxy2,
"proxy object w/out callback should have been re-used")
def test_basic_proxy(self):
o = C()
self.check_proxy(o, weakref.proxy(o))
L = UserList.UserList()
p = weakref.proxy(L)
self.failIf(p, "proxy for empty UserList should be false")
p.append(12)
self.assertEqual(len(L), 1)
self.failUnless(p, "proxy for non-empty UserList should be true")
p[:] = [2, 3]
self.assertEqual(len(L), 2)
self.assertEqual(len(p), 2)
self.failUnless(3 in p,
"proxy didn't support __contains__() properly")
p[1] = 5
self.assertEqual(L[1], 5)
self.assertEqual(p[1], 5)
L2 = UserList.UserList(L)
p2 = weakref.proxy(L2)
self.assertEqual(p, p2)
## self.assertEqual(repr(L2), repr(p2))
L3 = UserList.UserList(range(10))
p3 = weakref.proxy(L3)
self.assertEqual(L3[:], p3[:])
self.assertEqual(L3[5:], p3[5:])
self.assertEqual(L3[:5], p3[:5])
self.assertEqual(L3[2:5], p3[2:5])
def __init__(self, manager, module, message):
self.manager = weakref.proxy(manager)
self.module = None
if module is not None:
self.module = weakref.proxy(module)
self.kmail = message
self._info = message.toPyKol()
def process_ConnectionBind(self, head, payload):
log.info("%r process bind" % self)
try:
payload = json.loads(payload.decode())
connection_id = payload.get('connection_id')
self.connection_id = connection_id
relay_session = self.server.allocation.relay_sessions.get(connection_id)
data_session = self.server.allocation.data_sessions.get(connection_id)
if connection_id and relay_session and data_session is None:
relay_session.set_data_session(weakref.proxy(self))
self.set_relay_session(weakref.proxy(relay_session))
self.server.allocation.data_sessions[connection_id] = self
rsp = {
'code': 200
}
log.info("bind ok")
else:
rsp = {
'code': 400
}
self.send_response(head, json.dumps(rsp).encode())
except Exception as e:
log.error(e)
def __init__(self,world):
"""Args:
world (WorldModel): the world that should be simulated.
"""
Simulator.__init__(self,world)
#these are functions automatically called at each time step
self.robotControllers = [None]*world.numRobots()
self.sensorEmulators = [[DefaultSensorEmulator(weakref.proxy(self),self.controller(i))] for i in range(world.numRobots())]
self.actuatorEmulators = [[DefaultActuatorEmulator(weakref.proxy(self),self.controller(i))] for i in range(world.numRobots())]
self.hooks = []
self.hook_args = []
#the rate of applying simulation substeps. Hooks and actuator emulators are
#called at this rate. Note: this should be set at least as large as the simulation time step
self.substep_dt = 0.001
self.worst_status = Simulator.STATUS_NORMAL
#turn this on to save log to disk
self.logging = False
self.logger = None
self.log_state_fn="simulation_state.csv"
self.log_contact_fn="simulation_contact.csv"
#save state so controllers don't rely on world state
self.robotStates = []
self.objectStates = []
def solve(self):
dm = self.snes.getDM()
nlevel = len(self.ctx._problems)
dm.setAppCtx(weakref.proxy(self.ctx))
dm.setCreateMatrix(self.ctx.create_matrix)
# FIXME: Need to set this up on the subDMs
for i in range(nlevel - 1, 0, -1):
dm = dm.coarsen()
dm.setAppCtx(weakref.proxy(self.ctx))
for i in range(nlevel - 1):
dm.setCreateInterpolation(create_interpolation)
dm.setCreateInjection(create_injection)
dm.setCreateMatrix(self.ctx.create_matrix)
dm = dm.refine()
self.snes.setFromOptions()
for bc in self.problems[-1].bcs:
bc.apply(self.problems[-1].u)
with self.problems[-1].u.dat.vec as v:
self.snes.solve(None, v)
firedrake.solving_utils.check_snes_convergence(self.snes)
def __init__(self,
application,
parent,
relx=0,
rely=0,
width=None,
height=None,
max_width=None,
max_height=None,
editable=True,
hidden=False,
keep_starting_dimensions=True,
**kwargs):
try:
self.workspace = weakref.proxy(workspace)
except TypeError:
self.workspace = workspace
try:
self.parent = weakref.proxy(parent)
except TypeError:
self.parent = parent
self.keep_starting_dimensions = keep_starting_dimensions
self.max_width, self.max_height = max_width, max_height
self.requested_width, self.requested_height = width, height
self.width, self.height = width, height
self.relx, self.rely = relx, rely
self.editable = editable
self.hidden = hidden
def initialize_endpoints(self):
from predicthq import endpoints
self.oauth2 = endpoints.OAuth2Endpoint(proxy(self))
self.events = endpoints.EventsEndpoint(proxy(self))
self.accounts = endpoints.AccountsEndpoint(proxy(self))
self.signals = endpoints.SignalsEndpoint(proxy(self))
self.places = endpoints.PlacesEndpoint(proxy(self))
def __init__(self, registry, parent, command, target=None, is_background=False):
super(ShBaseThread, self).__init__(group=None,
target=target,
name='_shthread',
args=(),
kwargs=None)
# Registry management
self.registry = weakref.proxy(registry)
self.job_id = None # to be set by the registry
registry.add_worker(self)
# The command that the thread runs
if command.__class__.__name__ == 'ShIO':
self.command = ''.join(command._buffer)[::-1].strip()
else:
self.command = command
self.parent = weakref.proxy(parent)
# Set up the state based on parent's state
self.state = ShState.new_from_parent(parent.state)
self.killed = False
self.child_thread = None
self.set_background(is_background)
def get_master(self, flags=[], timeout=None):
"""
Start (if necessary) an SSH master connection to speed up subsequent
SSH sessions. Returns the SSHMaster instance on success.
"""
flags = flags + self._get_flags()
if self._ssh_master is not None:
return weakref.proxy(self._ssh_master)
tries = 5
if timeout is not None:
flags = flags + ["-o", "ConnectTimeout={0}".format(timeout)]
tries = 1
if self._host_fun() == "localhost":
tries = 1
sleep_time = 1
while True:
try:
started_at = time.time()
self._ssh_master = SSHMaster(self._get_target(), self._logger,
flags, self._get_passwd())
break
except Exception:
tries = tries - 1
if tries == 0:
raise
self._logger.log("could not connect to ‘{0}’, retrying in {1} seconds...".format(self._get_target(), sleep_time))
time.sleep(sleep_time)
sleep_time = sleep_time * 2
pass
return weakref.proxy(self._ssh_master)
def __init__(self, name=None, parent=None, clear_lookup=True,
project=None):
self._name = name
if name is None:
self._name = u"Default Segment Category"
self._id = self.nextid
if clear_lookup:
self.id2obj.clear()
self.id2obj[self._id] = self
# weakref.proxy to this segment's parent segment.
# If segment is child of project node in gui tree, then parent
# should be None.
# Get using parent property.
self._parent = None
if parent:
if isinstance(parent, ProxyType):
self._parent = parent
else:
self._parent = proxy(parent)
# List of 0 - N child (sub) segments associated with this segment.
# If segment has no children, then _childsegments should be [].
# Get childsegments property.
self._childsegments = []
self._childsegment_ids = []
# If a segment is locked, it can not be deleted or modified.
self._locked = False
if project:
if isinstance(project, ProxyType):
PenDataSegmentCategory._project = project
else:
PenDataSegmentCategory._project = proxy(project)
def onSessionStart(self, hdrs):
self.__init__()
self.loadVoiceLib()
self.mailbox = IMAP4_Mailbox(getSessionParam(hdrs, "Mailbox-URL"))
debug("***** Mailbox Url: ******\n" + str(self.mailbox.url))
self.new_msgs = self.loadMsgList("UNSEEN")
self.saved_msgs = self.loadMsgList("SEEN")
if (len(self.new_msgs) == 0) and (len(self.saved_msgs) == 0):
self.enqueue(self.voice_lib["no_msg"], None)
self.enqueue(self.voice_lib["bye"], None)
self.exit = True
return
self.enqueue(self.voice_lib["you_have"], None)
if len(self.new_msgs) > 0:
self.enqueue(self.voice_lib["new_msg"], None)
self.msg_list = weakref.proxy(self.new_msgs)
self.cur_list = weakref.ref(self.new_msgs)
if len(self.saved_msgs) > 0:
self.enqueue(self.voice_lib["and"], None)
self.enqueue(self.voice_lib["saved_msg"], None)
else:
self.enqueue(self.voice_lib["saved_msg"], None)
self.msg_list = weakref.proxy(self.saved_msgs)
self.cur_list = weakref.ref(self.saved_msgs)
self.enqueueCurMsg()
def join(self, drone):
'Add this drone to our ring'
# Make sure he's not already in our ring according to our 'database'
if self.members.has_key(drone.designation):
print self.members
raise ValueError("Drone %s is already a member of this ring [%s]"
% (drone.designation, self.name))
# Insert this drone into our 'database', and us into the drone's
self.members[drone.designation] = weakref.proxy(drone)
drone.ringmemberships[self.name] = weakref.proxy(self)
partners = self._findringpartners(drone) # Also adds drone to memberlist
#print >>sys.stderr,'Adding drone %s to talk to partners'%drone.designation, partners
if partners == None: return
if len(self.memberlist) == 2:
drone.start_heartbeat(self, partners[0])
partners[0].start_heartbeat(self, drone)
return
elif len(self.memberlist) > 3:
partners[0].stop_heartbeat(self, partners[1])
partners[1].stop_heartbeat(self, partners[0])
drone.start_heartbeat(self, partners[0], partners[1])
partners[0].start_heartbeat(self, drone)
partners[1].start_heartbeat(self, drone)
def setSetting(solver, value):
app = solver.get_app()
try:
root = solver.get_root_parent()
exec root._name + ' = root'
if len(value[1].split()) != 0:
a = eval(value[1])
if isinstance(a, PyModel):
solver._model = weakref.proxy(a)
else:
dialog.message(app, 'Model should be PyModel', 'Error')
solver._model = None
if len(value[2].split()) != 0:
b = eval(value[2])
if isinstance(b, PySol):
solver._sol = weakref.proxy(b)
else:
dialog.message(app, 'Sol should be PySol', 'Error')
solver._sol = None
if len(value[3].split()) != 0:
b = eval(value[3])
if isinstance(b, PyParam):
solver._param = weakref.proxy(b)
else:
dialog.message(app, 'Parameter should be PyParam', 'Error')
solver._param = None
except Exception:
logging.exception("Solver Setting Failed")
def testIsSame(self):
s1 = _Stub()
s2 = _Stub()
r1 = weakref.ref(s1)
r2 = weakref.ref(s2)
p1 = weakref.proxy(s1)
p2 = weakref.proxy(s2)
assert IsSame(s1, s1)
assert not IsSame(s1, s2)
assert IsSame(s1, r1)
assert IsSame(s1, p1)
assert not IsSame(s1, r2)
assert not IsSame(s1, p2)
assert IsSame(p2, r2)
assert IsSame(r1, p1)
assert not IsSame(r1, p2)
with pytest.raises(ReferenceError):
IsSame(p1, p2)
def post_init(self):
""" Finalizes client initialization by querying API root info
"""
log.debug("Getting root resources")
response = self.nc.request(self.api_root)
# obtain api info info
self.root = Root.from_response(response, self.root_url)
# instantiating handlers
self._projects = ProjectHandle(
weakref.proxy(self), self.nc, root_url=self.root_url,
projects_href=self.root.get_href_by_name(u"projects"),)
self._project_chroots = ProjectChrootHandle(
weakref.proxy(self), self.nc, root_url=self.root_url)
self._builds = BuildHandle(
weakref.proxy(self), self.nc, root_url=self.root_url,
builds_href=self.root.get_href_by_name(u"builds"),)
self._build_tasks = BuildTaskHandle(
weakref.proxy(self), self.nc, root_url=self.root_url,
build_tasks_href=self.root.get_href_by_name("build_tasks")
)
self._mock_chroots = MockChrootHandle(
weakref.proxy(self), self.nc, root_url=self.root_url,
href=self.root.get_href_by_name(u"mock_chroots")
)
self._post_init_done = True
def __init__(self, form, parent):
try:
self.form = weakref.proxy(form)
except TypeError:
self.form = form
try:
self.parent = weakref.proxy(parent)
except TypeError:
self.parent = parent
self._commands = {'abort': basic.abort,
'action': basic.action,
'brakes': basic.brakes,
'connect': basic.connect,
'disconnect': basic.disconnect,
'fbw': basic.fbw,
'gear': basic.gear,
'haiku': basic.haiku,
'help': self.helps,
'lights': basic.lights,
'log': logs.logs,
'rate': basic.rate,
'rcs': basic.rcs,
'sas': basic.sas,
'sa': mechjeb.smartass,
'send': basic.send,
'stage': basic.stage,
'text': basic.text,
'telemetry': basic.telemetry,
'throttle': basic.throttle,
'quit': basic.quits,
'exit': basic.quits, # overlaps with quit
}
def __init__(self, handler):
self.handler = weakref.proxy(handler)
self.log = weakref.proxy(self.handler.log)
if tornado.options.options.executor_type == 'threaded':
self.executor = frontik.jobs.get_threadpool_executor()
elif tornado.options.options.executor_type == 'ioloop':
self.executor = frontik.jobs.IOLoopExecutor
else:
raise ValueError('Cannot initialize XslProducer with executor_type {0!r}'.format(
tornado.options.options.executor_type))
self.xml_cache = self.handler.ph_globals.xml.xml_cache
self.xsl_cache = self.handler.ph_globals.xml.xsl_cache
self.doc = frontik.doc.Doc(root_node=etree.Element('doc', frontik='true'))
self.transform = None
self.transform_filename = None
if not self.handler.config.apply_xsl:
self.log.debug('ignoring set_xsl() because config.apply_xsl=%s', self.handler.config.apply_xsl)
self.apply_xsl = False
elif frontik.util.get_cookie_or_url_param_value(self.handler, 'noxsl') is not None:
self.handler.require_debug_access()
self.log.debug('ignoring set_xsl() because noxsl parameter is set')
self.apply_xsl = False
else:
self.apply_xsl = True
def __init__(self, plugins):
super(MigrationPlugin, self).__init__()
self.__bwProto = weakref.proxy(plugins[PROTO_TYPE.BW])
self.__bw2Proto = weakref.proxy(plugins[PROTO_TYPE.BW_CHAT2])
self.__xmppProto = weakref.proxy(plugins[PROTO_TYPE.XMPP])
self.__contacts = None
return
def __init__(self, trainer: 'pl.Trainer') -> None:
self.trainer = proxy(trainer)
self._internals = {}
self.reset()
def __init__(self, section, preBattleCond):
self.__preBattleCond = weakref.proxy(preBattleCond)
super(PostBattleConditions, self).__init__(section,
rootName='postBattle')
def test_objecttypes(self):
# check all types defined in Objects/
size = test.support.calcobjsize
vsize = test.support.calcvobjsize
check = self.check_sizeof
# bool
check(True, vsize('') + self.longdigit)
# buffer
# XXX
# builtin_function_or_method
check(len, size('3P')) # XXX check layout
# bytearray
samples = [b'', b'u' * 100000]
for sample in samples:
x = bytearray(sample)
check(x, vsize('n2Pi') + x.__alloc__())
# bytearray_iterator
check(iter(bytearray()), size('nP'))
# bytes
check(b'', vsize('n') + 1)
check(b'x' * 10, vsize('n') + 11)
# cell
def get_cell():
x = 42
def inner():
return x
return inner
check(get_cell().__closure__[0], size('P'))
# code
check(get_cell().__code__, size('5i9Pi3P'))
check(get_cell.__code__, size('5i9Pi3P'))
def get_cell2(x):
def inner():
return x
return inner
check(get_cell2.__code__, size('5i9Pi3P') + 1)
# complex
check(complex(0, 1), size('2d'))
# method_descriptor (descriptor object)
check(str.lower, size('3PP'))
# classmethod_descriptor (descriptor object)
# XXX
# member_descriptor (descriptor object)
import datetime
check(datetime.timedelta.days, size('3PP'))
# getset_descriptor (descriptor object)
import collections
check(collections.defaultdict.default_factory, size('3PP'))
# wrapper_descriptor (descriptor object)
check(int.__add__, size('3P2P'))
# method-wrapper (descriptor object)
check({}.__iter__, size('2P'))
# dict
check({}, size('n2P' + '2nPn' + 8 * 'n2P'))
longdict = {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8}
check(longdict, size('n2P' + '2nPn') + 16 * struct.calcsize('n2P'))
# dictionary-keyiterator
check({}.keys(), size('P'))
# dictionary-valueiterator
check({}.values(), size('P'))
# dictionary-itemiterator
check({}.items(), size('P'))
# dictionary iterator
check(iter({}), size('P2nPn'))
# dictproxy
class C(object):
pass
check(C.__dict__, size('P'))
# BaseException
check(BaseException(), size('5Pb'))
# UnicodeEncodeError
check(UnicodeEncodeError("", "", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeDecodeError
check(UnicodeDecodeError("", b"", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeTranslateError
check(UnicodeTranslateError("", 0, 1, ""), size('5Pb 2P2nP'))
# ellipses
check(Ellipsis, size(''))
# EncodingMap
import codecs, encodings.iso8859_3
x = codecs.charmap_build(encodings.iso8859_3.decoding_table)
check(x, size('32B2iB'))
# enumerate
check(enumerate([]), size('n3P'))
# reverse
check(reversed(''), size('nP'))
# float
check(float(0), size('d'))
# sys.floatinfo
check(sys.float_info, vsize('') + self.P * len(sys.float_info))
# frame
import inspect
CO_MAXBLOCKS = 20
x = inspect.currentframe()
ncells = len(x.f_code.co_cellvars)
nfrees = len(x.f_code.co_freevars)
extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
ncells + nfrees - 1
check(x, vsize('12P3ic' + CO_MAXBLOCKS * '3i' + 'P' + extras * 'P'))
# function
def func():
pass
check(func, size('12P'))
class c():
@staticmethod
def foo():
pass
@classmethod
def bar(cls):
pass
# staticmethod
check(foo, size('PP'))
# classmethod
check(bar, size('PP'))
# generator
def get_gen():
yield 1
check(get_gen(), size('Pb2P'))
# iterator
check(iter('abc'), size('lP'))
# callable-iterator
import re
check(re.finditer('', ''), size('2P'))
# list
samples = [[], [1, 2, 3], ['1', '2', '3']]
for sample in samples:
check(sample, vsize('Pn') + len(sample) * self.P)
# sortwrapper (list)
# XXX
# cmpwrapper (list)
# XXX
# listiterator (list)
check(iter([]), size('lP'))
# listreverseiterator (list)
check(reversed([]), size('nP'))
# int
check(0, vsize(''))
check(1, vsize('') + self.longdigit)
check(-1, vsize('') + self.longdigit)
PyLong_BASE = 2**sys.int_info.bits_per_digit
check(int(PyLong_BASE), vsize('') + 2 * self.longdigit)
check(int(PyLong_BASE**2 - 1), vsize('') + 2 * self.longdigit)
check(int(PyLong_BASE**2), vsize('') + 3 * self.longdigit)
# module
check(unittest, size('PnPPP'))
# None
check(None, size(''))
# NotImplementedType
check(NotImplemented, size(''))
# object
check(object(), size(''))
# property (descriptor object)
class C(object):
def getx(self):
return self.__x
def setx(self, value):
self.__x = value
def delx(self):
del self.__x
x = property(getx, setx, delx, "")
check(x, size('4Pi'))
# PyCapsule
# XXX
# rangeiterator
check(iter(range(1)), size('4l'))
# reverse
check(reversed(''), size('nP'))
# range
check(range(1), size('4P'))
check(range(66000), size('4P'))
# set
# frozenset
PySet_MINSIZE = 8
samples = [[], range(10), range(50)]
s = size('3n2P' + PySet_MINSIZE * 'nP' + 'nP')
for sample in samples:
minused = len(sample)
if minused == 0: tmp = 1
# the computation of minused is actually a bit more complicated
# but this suffices for the sizeof test
minused = minused * 2
newsize = PySet_MINSIZE
while newsize <= minused:
newsize = newsize << 1
if newsize <= 8:
check(set(sample), s)
check(frozenset(sample), s)
else:
check(set(sample), s + newsize * struct.calcsize('nP'))
check(frozenset(sample), s + newsize * struct.calcsize('nP'))
# setiterator
check(iter(set()), size('P3n'))
# slice
check(slice(0), size('3P'))
# super
check(super(int), size('3P'))
# tuple
check((), vsize(''))
check((1, 2, 3), vsize('') + 3 * self.P)
# type
# static type: PyTypeObject
s = vsize('P2n15Pl4Pn9Pn11PIP')
check(int, s)
# (PyTypeObject + PyNumberMethods + PyMappingMethods +
# PySequenceMethods + PyBufferProcs + 4P)
s = vsize('P2n15Pl4Pn9Pn11PIP') + struct.calcsize('34P 3P 10P 2P 4P')
# Separate block for PyDictKeysObject with 4 entries
s += struct.calcsize("2nPn") + 4 * struct.calcsize("n2P")
# class
class newstyleclass(object):
pass
check(newstyleclass, s)
# dict with shared keys
check(newstyleclass().__dict__, size('n2P' + '2nPn'))
# unicode
# each tuple contains a string and its expected character size
# don't put any static strings here, as they may contain
# wchar_t or UTF-8 representations
samples = [
'1' * 100, '\xff' * 50, '\u0100' * 40, '\uffff' * 100,
'\U00010000' * 30, '\U0010ffff' * 100
]
asciifields = "nnbP"
compactfields = asciifields + "nPn"
unicodefields = compactfields + "P"
for s in samples:
maxchar = ord(max(s))
if maxchar < 128:
L = size(asciifields) + len(s) + 1
elif maxchar < 256:
L = size(compactfields) + len(s) + 1
elif maxchar < 65536:
L = size(compactfields) + 2 * (len(s) + 1)
else:
L = size(compactfields) + 4 * (len(s) + 1)
check(s, L)
# verify that the UTF-8 size is accounted for
s = chr(0x4000) # 4 bytes canonical representation
check(s, size(compactfields) + 4)
# compile() will trigger the generation of the UTF-8
# representation as a side effect
compile(s, "<stdin>", "eval")
check(s, size(compactfields) + 4 + 4)
# TODO: add check that forces the presence of wchar_t representation
# TODO: add check that forces layout of unicodefields
# weakref
import weakref
check(weakref.ref(int), size('2Pn2P'))
# weakproxy
# XXX
# weakcallableproxy
check(weakref.proxy(int), size('2Pn2P'))
def __init__(self, parent):
self.tframe = Frame(parent)
TimeFrame.me = weakref.proxy(self)
def bindDataProvider(self, dataProvider):
self.__dataProvider = weakref.proxy(dataProvider)
def __init__(self,
screen,
relx=0,
rely=0,
name=None,
value=None,
width=False,
height=False,
max_height=False,
max_width=False,
editable=True,
hidden=False,
color='DEFAULT',
use_max_space=False,
check_value_change=True,
check_cursor_move=True,
value_changed_callback=None,
**keywords):
"""The following named arguments may be supplied:
name= set the name of the widget.
width= set the width of the widget.
height= set the height.
max_height= let the widget choose a height up to this maximum.
max_width= let the widget choose a width up to this maximum.
editable=True/False the user may change the value of the widget.
hidden=True/False The widget is hidden.
check_value_change=True - perform a check on every keypress and run when_value_edit if the value is different.
check_cursor_move=True - perform a check every keypress and run when_cursor_moved if the cursor has moved.
value_changed_callback - should be None or a Function. If it is a function, it will have be called when the value changes
and passed the keyword argument widget=self.
"""
self.check_value_change = check_value_change
self.check_cursor_move = check_cursor_move
self.hidden = hidden
self.interested_in_mouse_even_when_not_editable = False # used only for rare widgets to allow user to click
# even if can't actually select the widget. See mutt-style forms
try:
self.parent = weakref.proxy(screen)
except TypeError:
self.parent = screen
self.use_max_space = use_max_space
self.set_relyx(rely, relx)
#self.relx = relx
#self.rely = rely
self.color = color
self.encoding = 'utf-8' #locale.getpreferredencoding()
if GlobalOptions.ASCII_ONLY or locale.getpreferredencoding(
) == 'US-ASCII':
self._force_ascii = True
else:
self._force_ascii = False
self.set_up_handlers()
# To allow derived classes to set this and then call this method safely...
try:
self.value
except AttributeError:
self.value = value
# same again
try:
self.name
except Exception:
self.name = name
self.request_width = width # widgets should honour if possible
self.request_height = height # widgets should honour if possible
self.max_height = max_height
self.max_width = max_width
self.set_size()
self.editing = False # Change to true during an edit
self.editable = editable
if self.parent.curses_pad.getmaxyx()[0] - 1 == self.rely:
self.on_last_line = True
else:
self.on_last_line = False
if value_changed_callback:
self.value_changed_callback = value_changed_callback
else:
self.value_changed_callback = None
self.initialize_event_handling()
def __init__(self, trigger):
super(SimpleDialogResultAspect, self).__init__()
self._trigger = weakref.proxy(trigger)
def get_audio_player(self):
if not self._audio_player:
self._audio_player = XbmcPlayer('audio', weakref.proxy(self))
return self._audio_player
def get_audio_playlist(self):
if not self._audio_playlist:
self._audio_playlist = XbmcPlaylist('audio', weakref.proxy(self))
return self._audio_playlist
def get_ui(self):
if not self._ui:
self._ui = XbmcContextUI(self._addon, weakref.proxy(self))
return self._ui
def source(self, value):
self._source = weakref.proxy(value)
def get_video_player(self):
if not self._video_player:
self._video_player = XbmcPlayer('video', weakref.proxy(self))
return self._video_player
def __init__(self, driver):
import weakref
self._driver = weakref.proxy(driver)
def get_video_playlist(self):
if not self._video_playlist:
self._video_playlist = XbmcPlaylist('video', weakref.proxy(self))
return self._video_playlist
def test_weakref(self):
f = self.thetype(int, base=16)
p = proxy(f)
self.assertEqual(f.func, p.func)
f = None
self.assertRaises(ReferenceError, getattr, p, 'func')
def test_weakref(self):
s = array.array(self.typecode, self.example)
p = weakref.proxy(s)
self.assertEqual(p.tobytes(), s.tobytes())
s = None
self.assertRaises(ReferenceError, len, p)
def setCallback(self, callback=None):
""" setCallback(callback: class) -> None
Sets a callback when receiving commands
"""
self.callback = weakref.proxy(callback)
def __init__(self, parent):
super(Control, self).__init__()
self.parent = weakref.proxy(parent)
def weakref(self) -> anki.storage._Collection:
"Shortcut to create a weak reference that doesn't break code completion."
return weakref.proxy(self)
def __init__(self, parent, proteins):
super(TableTabs, self).__init__(parent)
self.proteins = weakref.proxy(proteins)
self.tables = []
self.load()
def __init__(self, native_dsound):
# We only keep a weakref to native_dsound which is owned by
# interface.DirectSoundDriver
self._native_dsound = weakref.proxy(native_dsound)
def __init__(self, obj):
"""
Initialized on the object
"""
self._store = {}
self.obj = weakref.proxy(obj)
['x', 'y', 'A'])
mahalanobis_distance.autoSetJacobians()
unit.setDeriv(0,
lambda x, dx: if_(x == 0, zero(shape(x)), dx / norm(x) - x *
(dot(x, dx) / norm(x))**3),
stackable=True)
inv = Function('inv', np.linalg.inv, ['A'], returnType='M')
inv.argTypes = [Matrix]
def _inv_deriv(A, dA):
Ainv = inv(A)
return -dot(Ainv, dot(dA, Ainv))
inv.properties['inverse'] = weakref.proxy(inv)
#patch the dot function
dot.addSimplifier(['inv', 'inv'],
lambda Ainv, Binv: inv(dot(Binv.args[0], Ainv.args[0])))
dot.addSimplifier(['linalg.inv', 'linalg.inv'],
lambda Ainv, Binv: inv(dot(Binv.args[0], Ainv.args[0])))
inv.addSimplifier(['neg'], lambda x: -inv(x.args[0]))
inv.setDeriv(0, _inv_deriv, asExpr=True)
inv.printers['str'] = lambda expr, astr: astr[0] + '^-1'
pinv = Function('pinv', np.linalg.pinv, ['A'], returnType='M')
pinv.argTypes = [Matrix]
pinv.addSimplifier(['neg'], lambda x: -pinv(x.args[0]))
pinv.printers['str'] = lambda expr, astr: astr[0] + '^+'
def _pinv_deriv(A, dA):
def __init__(self, obj):
self.proxy = weakref.proxy(obj)
def __init__(self, program, name, index, size, uniforms):
self.program = proxy(program)
self.name = name
self.index = index
self.size = size
self.uniforms = uniforms
def __init__(self, ds_buffer, native_listener):
# We only keep a weakref to ds_buffer as it is owned by
# interface.DirectSound or a DirectSoundAudioPlayer
self.ds_buffer = weakref.proxy(ds_buffer)
self._native_listener = native_listener
def __init__(self, obj, method):
self.obj = weakref.proxy(obj)
self.method = method
def __init__(self, selfNodeAddr, otherNodesAddrs, conf=None):
if conf is None:
self.__conf = SyncObjConf()
else:
self.__conf = conf
self.__conf.validate()
if self.__conf.password is not None:
if not HAS_CRYPTO:
raise ImportError("Please install 'cryptography' module")
self.__encryptor = getEncryptor(self.__conf.password)
else:
self.__encryptor = None
self.__selfNodeAddr = selfNodeAddr
self.__otherNodesAddrs = otherNodesAddrs
self.__unknownConnections = {} # descr => _Connection
self.__raftState = _RAFT_STATE.FOLLOWER
self.__raftCurrentTerm = 0
self.__votedFor = None
self.__votesCount = 0
self.__raftLeader = None
self.__raftElectionDeadline = time.time() + self.__generateRaftTimeout(
)
self.__raftLog = createJournal(self.__conf.journalFile)
if len(self.__raftLog) == 0:
self.__raftLog.add(_bchr(_COMMAND_TYPE.NO_OP), 1,
self.__raftCurrentTerm)
self.__raftCommitIndex = 1
self.__raftLastApplied = 1
self.__raftNextIndex = {}
self.__raftMatchIndex = {}
self.__lastSerializedTime = time.time()
self.__lastSerializedEntry = None
self.__forceLogCompaction = False
self.__leaderCommitIndex = None
self.__onReadyCalled = False
self.__changeClusterIDx = None
self.__noopIDx = None
self.__destroying = False
self.__startTime = time.time()
globalDnsResolver().setTimeouts(self.__conf.dnsCacheTime,
self.__conf.dnsFailCacheTime)
self.__serializer = Serializer(self.__conf.fullDumpFile,
self.__conf.logCompactionBatchSize,
self.__conf.useFork,
self.__conf.serializer,
self.__conf.deserializer,
self.__conf.serializeChecker)
self.__isInitialized = False
self.__lastInitTryTime = 0
self._poller = createPoller(self.__conf.pollerType)
host, port = selfNodeAddr.split(':')
self.__server = TcpServer(
self._poller,
host,
port,
onNewConnection=self.__onNewConnection,
sendBufferSize=self.__conf.sendBufferSize,
recvBufferSize=self.__conf.recvBufferSize,
connectionTimeout=self.__conf.connectionTimeout)
self._methodToID = {}
self._idToMethod = {}
methods = sorted([
m for m in dir(self)
if isinstance(getattr(self, m), collections.Callable)
])
for i, method in enumerate(methods):
self._methodToID[method] = i
self._idToMethod[i] = getattr(self, method)
self.__thread = None
self.__mainThread = None
self.__initialised = None
self.__commandsQueue = queue.Queue(self.__conf.commandsQueueSize)
self.__nodes = []
self.__newAppendEntriesTime = 0
self.__commandsWaitingCommit = collections.defaultdict(
list) # logID => [(termID, callback), ...]
self.__commandsLocalCounter = 0
self.__commandsWaitingReply = {} # commandLocalCounter => callback
self.__properies = set()
for key in self.__dict__:
self.__properies.add(key)
if self.__conf.autoTick:
self.__mainThread = threading.current_thread()
self.__initialised = threading.Event()
self.__thread = threading.Thread(target=SyncObj._autoTickThread,
args=(weakref.proxy(self), ))
self.__thread.start()
while not self.__initialised.is_set():
pass
else:
self.__initInTickThread()
def low(self, fun, low):
'''
Execute a function from low data
Low data includes:
required:
- fun: the name of the function to run
optional:
- args: a list of args to pass to fun
- kwargs: kwargs for fun
- __user__: user who is running the command
- __jid__: jid to run under
- __tag__: tag to run under
'''
# fire the mminion loading (if not already done) here
# this is not to clutter the output with the module loading
# if we have a high debug level.
self.mminion # pylint: disable=W0104
jid = low.get('__jid__', salt.utils.jid.gen_jid())
tag = low.get('__tag__', tagify(jid, prefix=self.tag_prefix))
data = {
'fun': '{0}.{1}'.format(self.client, fun),
'jid': jid,
'user': low.get('__user__', 'UNKNOWN'),
}
event = salt.utils.event.get_event('master',
self.opts['sock_dir'],
self.opts['transport'],
opts=self.opts,
listen=False)
namespaced_event = salt.utils.event.NamespacedEvent(
event,
tag,
print_func=self.print_async_event if hasattr(
self, 'print_async_event') else None)
# TODO: document these, and test that they exist
# TODO: Other things to inject??
func_globals = {
'__jid__': jid,
'__user__': data['user'],
'__tag__': tag,
# weak ref to avoid the Exception in interpreter
# teardown of event
'__jid_event__': weakref.proxy(namespaced_event),
}
func_globals['__jid_event__'].fire_event(data, 'new')
try:
verify_fun(self.functions, fun)
# Inject some useful globals to *all* the function's global
# namespace only once per module-- not per func
completed_funcs = []
for mod_name in six.iterkeys(self.functions):
if '.' not in mod_name:
continue
mod, _ = mod_name.split('.', 1)
if mod in completed_funcs:
continue
completed_funcs.append(mod)
for global_key, value in six.iteritems(func_globals):
self.functions[mod_name].__globals__[global_key] = value
# There are some descrepencies of what a "low" structure is in the
# publisher world it is a dict including stuff such as jid, fun,
# arg (a list of args, with kwargs packed in). Historically this
# particular one has had no "arg" and just has had all the kwargs
# packed into the top level object. The plan is to move away from
# that since the caller knows what is an arg vs a kwarg, but while
# we make the transition we will load "kwargs" using format_call if
# there are no kwargs in the low object passed in
f_call = None
if 'args' not in low:
f_call = salt.utils.format_call(
self.functions[fun],
low,
expected_extra_kws=CLIENT_INTERNAL_KEYWORDS)
args = f_call.get('args', ())
else:
args = low['args']
if 'kwargs' not in low:
if f_call is None:
f_call = salt.utils.format_call(
self.functions[fun],
low,
expected_extra_kws=CLIENT_INTERNAL_KEYWORDS)
kwargs = f_call.get('kwargs', {})
# throw a warning for the badly formed low data if we found
# kwargs using the old mechanism
if kwargs:
salt.utils.warn_until(
'Boron',
'kwargs must be passed inside the low under "kwargs"')
else:
kwargs = low['kwargs']
# Initialize a context for executing the method.
with tornado.stack_context.StackContext(
self.functions.context_dict.clone):
data['return'] = self.functions[fun](*args, **kwargs)
data['success'] = True
except (Exception, SystemExit) as ex:
if isinstance(ex, salt.exceptions.NotImplemented):
data['return'] = str(ex)
else:
data['return'] = 'Exception occurred in {0} {1}: {2}'.format(
self.client,
fun,
traceback.format_exc(),
)
data['success'] = False
namespaced_event.fire_event(data, 'ret')
try:
salt.utils.job.store_job(
self.opts,
{
'id': self.opts['id'],
'tgt': self.opts['id'],
'jid': data['jid'],
'return': data,
},
event=None,
mminion=self.mminion,
)
except salt.exceptions.SaltCacheError:
log.error(
'Could not store job cache info. Job details for this run may be unavailable.'
)
# if we fired an event, make sure to delete the event object.
# This will ensure that we call destroy, which will do the 0MQ linger
log.info('Runner completed: {0}'.format(data['jid']))
del event
del namespaced_event
return data['return']
def start(self, setup):
self._visitor = weakref.proxy(setup.arenaVisitor)
self._arenaDP = weakref.proxy(setup.arenaDP)
