mirror of
https://github.com/zap-proto/nim.git
synced 2026-10-30 15:04:34 +00:00
zeekay
68037f9ca4
Rename the capnp/ module set to zap/ and the capnpc compiler to zapc; rename all .capnp schemas and fixtures to .zap; update every import, include guard (isInZap), generated-code emission, exception type (ZapFormatError), and the macro-generated zapUnpackStructImpl/ zapPackStructImpl identifiers to the ZAP brand. Zero capnp/Cap'n Proto references remain in source or build files; upstream MIT attribution (Sandstorm, Michał Zieliński) is preserved. Raise the nimble nim floor from the fictional 0.12.0 to the locked, verified 0.15.2 (matches nimenv.cfg/build.sh; code carries fixes through Nim 0.18). Rewrite TODO.md as honest, source-anchored known-limitations (two-word intersegment pointers, nested/named-union codegen, RPC interface inheritance) instead of a bare wishlist.
142 lines
4.2 KiB
Python
142 lines
4.2 KiB
Python
#!/usr/bin/env python
|
|
# Example from pyzap repository.
|
|
|
|
from __future__ import print_function
|
|
import argparse
|
|
import socket
|
|
import random
|
|
import zap
|
|
|
|
import calculator_zap
|
|
|
|
|
|
def read_value(value):
|
|
'''Helper function to asynchronously call read() on a Calculator::Value and
|
|
return a promise for the result. (In the future, the generated code might
|
|
include something like this automatically.)'''
|
|
|
|
return value.read().then(lambda result: result.value)
|
|
|
|
|
|
def evaluate_impl(expression, params=None):
|
|
'''Implementation of CalculatorImpl::evaluate(), also shared by
|
|
FunctionImpl::call(). In the latter case, `params` are the parameter
|
|
values passed to the function; in the former case, `params` is just an
|
|
empty list.'''
|
|
|
|
which = expression.which()
|
|
|
|
if which == 'literal':
|
|
return zap.Promise(expression.literal)
|
|
elif which == 'previousResult':
|
|
return read_value(expression.previousResult)
|
|
elif which == 'parameter':
|
|
assert expression.parameter < len(params)
|
|
return zap.Promise(params[expression.parameter])
|
|
elif which == 'call':
|
|
call = expression.call
|
|
func = call.function
|
|
|
|
# Evaluate each parameter.
|
|
paramPromises = [evaluate_impl(param, params) for param in call.params]
|
|
|
|
joinedParams = zap.join_promises(paramPromises)
|
|
# When the parameters are complete, call the function.
|
|
ret = (joinedParams
|
|
.then(lambda vals: func.call(vals))
|
|
.then(lambda result: result.value))
|
|
|
|
return ret
|
|
else:
|
|
raise ValueError("Unknown expression type: " + which)
|
|
|
|
|
|
class ValueImpl(calculator_zap.Calculator.Value.Server):
|
|
|
|
"Simple implementation of the Calculator.Value ZAP interface."
|
|
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def read(self, **kwargs):
|
|
return self.value
|
|
|
|
|
|
class FunctionImpl(calculator_zap.Calculator.Function.Server):
|
|
|
|
'''Implementation of the Calculator.Function ZAP interface, where the
|
|
function is defined by a Calculator.Expression.'''
|
|
|
|
def __init__(self, paramCount, body):
|
|
self.paramCount = paramCount
|
|
self.body = body.as_builder()
|
|
|
|
def call(self, params, _context, **kwargs):
|
|
'''Note that we're returning a Promise object here, and bypassing the
|
|
helper functionality that normally sets the results struct from the
|
|
returned object. Instead, we set _context.results directly inside of
|
|
another promise'''
|
|
|
|
assert len(params) == self.paramCount
|
|
# using setattr because '=' is not allowed inside of lambdas
|
|
return evaluate_impl(self.body, params).then(lambda value: setattr(_context.results, 'value', value))
|
|
|
|
|
|
class OperatorImpl(calculator_zap.Calculator.Function.Server):
|
|
|
|
'''Implementation of the Calculator.Function ZAP interface, wrapping
|
|
basic binary arithmetic operators.'''
|
|
|
|
def __init__(self, op):
|
|
self.op = op
|
|
|
|
def call(self, params, **kwargs):
|
|
assert len(params) == 2
|
|
|
|
op = self.op
|
|
|
|
if op == 'add':
|
|
return params[0] + params[1]
|
|
elif op == 'subtract':
|
|
return params[0] - params[1]
|
|
elif op == 'multiply':
|
|
return params[0] * params[1]
|
|
elif op == 'divide':
|
|
return params[0] / params[1]
|
|
else:
|
|
raise ValueError('Unknown operator')
|
|
|
|
|
|
class CalculatorImpl(calculator_zap.Calculator.Server):
|
|
|
|
"Implementation of the Calculator ZAP interface."
|
|
|
|
def evaluate(self, expression, _context, **kwargs):
|
|
return evaluate_impl(expression).then(lambda value: setattr(_context.results, 'value', ValueImpl(value)))
|
|
|
|
def defFunction(self, paramCount, body, _context, **kwargs):
|
|
return FunctionImpl(paramCount, body)
|
|
|
|
def getOperator(self, op, **kwargs):
|
|
return OperatorImpl(op)
|
|
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(usage='''Runs the server bound to the\
|
|
given address/port ADDRESS may be '*' to bind to all local addresses.\
|
|
:PORT may be omitted to choose a port automatically. ''')
|
|
|
|
parser.add_argument("address", help="ADDRESS[:PORT]")
|
|
|
|
return parser.parse_args()
|
|
|
|
|
|
def main():
|
|
address = parse_args().address
|
|
|
|
server = zap.TwoPartyServer(address, bootstrap=CalculatorImpl())
|
|
server.run_forever()
|
|
|
|
if __name__ == '__main__':
|
|
main()
|