def _uncall(self):
from typhon.objects.makers import theMakeBytes
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
ints = [IntObject(ord(c)) for c in self._bs]
return [theMakeBytes, StrObject(u"fromInts"),
wrapList([wrapList(ints)]), EMPTY_MAP]
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
# [1,2,3].asSet().diverge() -> [[[1,2,3], "asSet"], "diverge"]
rv = wrapList(self.objectSet.keys())
return [wrapList([rv, StrObject(u"asSet"), wrapList([]), EMPTY_MAP]),
StrObject(u"diverge"), wrapList([]), EMPTY_MAP]
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.scopes.safe import theMakeMap
pairs = wrapList([wrapList([k, v])
for k, v in self.objectMap.items()])
rv = wrapList([pairs])
return [theMakeMap, StrObject(u"fromPairs"), rv, EMPTY_MAP]
def uncall(self):
return wrapList([
self._target,
StrObject(self._verb),
wrapList(self._args),
wrapList(self._namedArgs)
])
def _uncall(self):
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.scopes.safe import theSlotBinder
return [wrapList([theSlotBinder, StrObject(u"run"),
wrapList([self.guard])]),
StrObject(u"run"),
wrapList([self.slot, NullObject]),
EMPTY_MAP]
def uncall(self):
return wrapList([
StrObject(self._d if self._d else u""),
StrObject(self._verb),
wrapList(self._ps),
wrapList(self._namedParams),
self._g if self._g is not None else NullObject, self._b
])
def testListEqualityRecursion(self):
first = wrapList([IntObject(42), NullObject])
# Hax.
first.objs.append(first)
second = wrapList([IntObject(42), NullObject])
# Hax.
second.objs.append(second)
self.assertEqual(optSame(first, second), EQUAL)
def unsealException(specimen, ej):
"""
Unseal a specimen.
"""
if isinstance(specimen, SealedException):
trail = wrapList([StrObject(s) for s in specimen.trail])
return wrapList([specimen.value, trail])
throwStr(ej, u"Cannot unseal non-thrown object")
def _uncall(self):
from typhon.objects.makers import theMakeBytes
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
ints = [IntObject(ord(c)) for c in self._bs]
return [
theMakeBytes,
StrObject(u"fromInts"),
wrapList([wrapList(ints)]), EMPTY_MAP
]
def unsealException(specimen, ej):
"""
Unseal a specimen.
"""
if isinstance(specimen, SealedException):
ue = specimen.ue
trail = wrapList([StrObject(s) for s in ue.formatTrail()])
return wrapList([ue.getPayload(), trail])
throwStr(ej, u"Cannot unseal non-thrown object")
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
# [1,2,3].asSet().diverge() -> [[[1,2,3], "asSet"], "diverge"]
rv = wrapList(self.objectSet.keys())
return [
wrapList([rv, StrObject(u"asSet"),
wrapList([]), EMPTY_MAP]),
StrObject(u"diverge"),
wrapList([]), EMPTY_MAP
]
def bench(obj, name):
name = unwrapStr(name).encode("utf-8")
if not benchmarkSettings.enabled:
debug_print("Not running benchmark", name,
"since benchmarking is disabled")
return wrapList([IntObject(0), DoubleObject(0.0)])
debug_print("Benchmarking", name)
# Step 1: Calibrate timing loop.
debug_print("Calibrating timing loop...")
# Unroll do-while iteration.
loops = 1
debug_print("Trying 1 loop...")
taken = time.time()
obj.call(u"run", [])
taken = time.time() - taken
while taken < 1.0 and loops < 100000000:
debug_print("Took", taken, "seconds to run", loops, "loops")
loops *= 10
debug_print("Trying", loops, "loops...")
acc = 0
taken = time.time()
while acc < loops:
acc += 1
obj.call(u"run", [])
taken = time.time() - taken
debug_print("Okay! Will take", loops, "loops at", taken, "seconds")
# Step 2: Take trials.
debug_print("Taking trials...")
trialCount = 3 - 1
# Unroll first iteration to get maximum.
acc = 0
taken = time.time()
while acc < loops:
acc += 1
obj.call(u"run", [])
taken = time.time() - taken
result = taken
while trialCount:
trialCount -= 1
acc = 0
taken = time.time()
while acc < loops:
acc += 1
obj.call(u"run", [])
taken = time.time() - taken
if taken < result:
result = taken
# All done!
return wrapList([IntObject(loops), DoubleObject(taken)])
def _uncall(self):
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.scopes.safe import theSlotBinder
return [
wrapList(
[theSlotBinder,
StrObject(u"run"),
wrapList([self.guard])]),
StrObject(u"run"),
wrapList([self.slot, NullObject]), EMPTY_MAP
]
def _uncall(self):
from typhon.objects.collections.lists import wrapList
return [
ConstMap(self.objectMap.copy()),
StrObject(u"diverge"),
wrapList([]), EMPTY_MAP
]
def _uncall(self):
span = wrapList([NullObject])
return [
self.nodeMaker,
StrObject(u"run"),
self.uncall().call(u"add", [span]), EMPTY_MAP
]
def _uncall(self):
from typhon.objects.collections.lists import wrapList
args = wrapList([] if (self._kg is None and self._vg is None) else [
self._kg, self._vg
])
return [ConstMap(self.objectMap.copy()), StrObject(u"diverge"), args,
EMPTY_MAP]
def _uncall(self):
from typhon.scopes.safe import theFinalSlotMaker
from typhon.objects.collections.maps import EMPTY_MAP
return [
theFinalSlotMaker,
StrObject(u"run"),
wrapList([self._obj, self._guard, NullObject]), EMPTY_MAP
]
def sendAll(self, atom, args, namedArgs):
if self.checkSlot():
ref = self.resolutionBox.get()
return send(ref, atom, args, namedArgs)
else:
return send(self.handler, HANDLESEND_3, [StrObject(atom.verb),
wrapList(args),
namedArgs], EMPTY_MAP)
def runMatchers(self, atom, args, namedArgs):
message = wrapList([StrObject(atom.verb), wrapList(args),
namedArgs])
for matcher in self.getMatchers():
with Ejector() as ej:
try:
return self.runMatcher(matcher, message, ej)
except Ejecting as e:
if e.ejector is ej:
# Looks like unification failed. On to the next
# matcher!
continue
else:
# It's not ours, cap'n.
raise
raise Refused(self, atom, args)
def sendAll(self, atom, args, namedArgs):
if self.checkSlot():
ref = self.resolutionBox.get()
return send(ref, atom, args, namedArgs)
else:
return send(self.handler, HANDLESEND_3, [StrObject(atom.verb),
wrapList(args),
namedArgs], EMPTY_MAP)
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
return [
makeSourceSpan, StrObject(u"run"),
wrapList([wrapBool(self._isOneToOne), IntObject(self.startLine),
IntObject(self.startCol), IntObject(self.endLine),
IntObject(self.endCol)]), EMPTY_MAP]
def gaiCB(gai, status, ai):
status = intmask(status)
vat, resolver = ruv.unstashGAI(gai)
with scopedVat(vat):
assert isinstance(resolver, LocalResolver), "implementation error"
if status < 0:
msg = ruv.formatError(status).decode("utf-8")
resolver.smash(StrObject(u"libuv error: %s" % msg))
else:
gaiList = walkAI(ai)
resolver.resolve(wrapList(gaiList[:]))
ruv.freeAddrInfo(ai)
ruv.free(gai)
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
return [
makeSourceSpan,
StrObject(u"run"),
wrapList([
wrapBool(self._isOneToOne),
IntObject(self.startLine),
IntObject(self.startCol),
IntObject(self.endLine),
IntObject(self.endCol)
]), EMPTY_MAP
]
def getAddrInfo(node, service):
node = unwrapBytes(node)
service = unwrapBytes(service)
vat = currentVat.get()
p, r = makePromise()
emptyAI = nullptr(ruv.s.addrinfo)
with io:
ai = emptyAI
try:
ai = ruv.magic_getAddrInfo(vat, node, service)
except object as err:
smash(r, StrObject(u"libuv error: %s" % err))
else:
resolve(r, wrapList(walkAI(ai)[:]))
return p
def connect(self):
vat = currentVat.get()
stream = ruv.alloc_tcp(vat.uv_loop)
fount, fountResolver = makePromise()
drain, drainResolver = makePromise()
# Ugh, the hax.
resolvers = wrapList([fountResolver, drainResolver])
ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
(vat, resolvers))
# Make the actual connection.
ruv.tcpConnect(stream, self.host, self.port, connectCB)
# Return the promises.
return [fount, drain]
def connectStream(self):
vat = currentVat.get()
stream = ruv.alloc_tcp(vat.uv_loop)
source, sourceResolver = makePromise()
sink, sinkResolver = makePromise()
# Ugh, the hax.
resolvers = wrapList([sourceResolver, sinkResolver])
ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
(vat, resolvers))
# Make the actual connection.
ruv.tcpConnect(stream, self.host, self.port, connectStreamCB)
# Return the promises.
return [source, sink]
def connectStream(self):
"""
Connect this endpoint, returning a `[source, sink]` pair.of vows.
"""
vat = currentVat.get()
stream = ruv.alloc_tcp(vat.uv_loop)
source, sourceResolver = makePromise()
sink, sinkResolver = makePromise()
# Ugh, the hax.
resolvers = wrapList([sourceResolver, sinkResolver])
ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream),
(vat, resolvers))
vat.enqueueEvent(ConnectStreamIOEvent(
vat, stream, self.host, self.port, self.inet_type))
# Return the promises.
return [source, sink]
def connectStream(self):
"""
Connect this endpoint, returning a `[source, sink]` pair.of vows.
"""
vat = currentVat.get()
stream = ruv.alloc_tcp(vat.uv_loop)
source, sourceResolver = makePromise()
sink, sinkResolver = makePromise()
# Ugh, the hax.
resolvers = wrapList([sourceResolver, sinkResolver])
ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers))
# Make the actual connection.
if self.inet_type == 4:
ruv.tcp4Connect(stream, self.host, self.port, connectStreamCB)
elif self.inet_type == 6:
ruv.tcp6Connect(stream, self.host, self.port, connectStreamCB)
# Return the promises.
return [source, sink]
def _uncall(self):
return SealedPortrayal(wrapList([
makeSealedException, StrObject(u"run"),
wrapList([self.ue.getPayload()]), EMPTY_MAP]))
def uncall(self):
return wrapList(
[StrObject(self._d if self._d else u""), StrObject(self._verb),
wrapList(self._ps), wrapList(self._namedParams), self._g,
self._b])
def uncall(self):
return wrapList([self._pattern, self._block])
def uncall(self):
return wrapList([self._inner])
def uncall(self):
return wrapList(
[self._pattern, self._node,
self._catchPattern if self._catchPattern is not None else NullObject,
self._catchNode if self._catchNode is not None else NullObject])
def uncall(self):
return wrapList([self._target, StrObject(self._verb),
wrapList(self._args),
wrapList(self._namedArgs)])
def uncall(self):
return wrapList([Noun(self.name)])
def testHashInequalItems(self):
a = wrapList([IntObject(42), CharObject(u'é')])
b = wrapList([IntObject(42), CharObject(u'e')])
self.assertNotEqual(a.samenessHash(), b.samenessHash())
def testSlice(self):
l = wrapList(map(CharObject, "abcdefg"))
result = l.call(u"slice", [IntObject(3), IntObject(6)])
chars = [char._c for char in unwrapList(result)]
self.assertEqual(chars, list("def"))
def testUnwrapListPromise(self):
with scopedVat(testingVat()):
p = makeNear(wrapList([]))
self.assertEqual(unwrapList(p), [])
def testJoin(self):
s = StrObject(u"|")
result = s.call(
u"join",
[wrapList([StrObject(u"5"), StrObject(u"42")])])
self.assertEqual(result._s, u"5|42")
def uncall(self):
return wrapList([self._inner])
def uncall(self):
return wrapList([self._test, self._then, self._otherwise])
def uncall(self):
return wrapList([])
def uncall(self):
return wrapList([Noun(self.target), self.rvalue])
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.scopes.safe import theMakeMap
pairs = wrapList([wrapList([k, v]) for k, v in self.objectMap.items()])
rv = wrapList([pairs])
return [theMakeMap, StrObject(u"fromPairs"), rv, EMPTY_MAP]
def uncall(self):
return wrapList([self.key, self.value])
def uncall(self):
return wrapList([self._block, self._atLast])
def uncall(self):
return wrapList([self._p,
self._e if self._e is not None else NullObject,
self._v])
def testCmpShortRight(self):
a = wrapList([IntObject(2), IntObject(4)])
b = wrapList([IntObject(2)])
result = a.call(u"op__cmp", [b])
self.assertEqual(result.getInt(), 1)
def uncall(self):
return wrapList([self._block, self._atLast])
def testHashEqual(self):
a = wrapList([IntObject(42), CharObject(u'é')])
b = wrapList([IntObject(42), CharObject(u'é')])
self.assertEqual(a.samenessHash(), b.samenessHash())
def uncall(self):
return wrapList([self._test, self._then, self._otherwise])
def testGetNegative(self):
l = wrapList([])
self.assertRaises(UserException, l.call, u"get", [IntObject(-1)])
def uncall(self):
return wrapList([])
def uncall(self):
return wrapList(
[self._p, self._e if self._e is not None else NullObject, self._v])
def uncall(self):
return wrapList([StrObject(self.name)])
def uncall(self):
return wrapList([CharObject(self._c)])
def uncall(self):
return wrapList([
self._pattern, self._node, self._catchPattern
if self._catchPattern is not None else NullObject,
self._catchNode if self._catchNode is not None else NullObject
])
def uncall(self):
return wrapList([self._pattern, self._block])
