def om(self):
return om.OMObject(
om.OMAttribution(
om.OMAttributionPairs([(om.OMSymbol('call_id', cd='scscp1'),
om.OMString(self.id))] + self.params),
om.OMApplication(om.OMSymbol(self.type, cd='scscp1'),
[self.data])))
def test_register_sym(self):
DefaultConverter.register_to_python_name('base', 'hello1', 'hello', 'world')
self.assertEqual(DefaultConverter.to_python(om.OMSymbol(cd='hello1', name='hello', cdbase='base')), 'world')
def echo(name):
return name
DefaultConverter.register_to_python_cd('base', 'echo1', echo)
self.assertEqual(DefaultConverter.to_python(om.OMSymbol(cd='echo1', name='echo',cdbase='base')), 'echo')
def handle_call(self, call):
if (call.type != 'procedure_call'):
raise SCSCPProtocolError('Bad message from client: %s.' % call.type, om=call.om())
try:
head = call.data.elem.name
self.log.debug('Requested head: %s...' % head)
if call.data.elem.cd == 'scscp2' and head in CD_SCSCP2:
res = getattr(self, head)(call.data)
elif call.data.elem.cd == 'singular' and head in CD_SINGULAR:
#args = [conv.to_python(a) for a in call.data.arguments]
args = call.data.arguments
handler = get_handler(head)
name = makename()
handler(name, args)
res = retrieve(name)
else:
self.log.debug('...head unknown.')
return self.scscp.terminated(call.id, om.OMError(
om.OMSymbol('unhandled_symbol', cd='error'), [call.data.elem]))
strlog = str(res)
print(colored(strlog, "green"))
self.log.debug('...sending result: %s' % (strlog[:20] + (len(strlog) > 20 and '...')))
return self.scscp.completed(call.id, res)
except (AttributeError, IndexError, TypeError) as e:
traceback.print_exc()
self.log.debug('...client protocol error.')
return self.scscp.terminated(call.id, om.OMError(
om.OMSymbol('unexpected_symbol', cd='error'), [call.data]))
except Exception as e:
self.log.exception('Unhandled exception:')
return self.scscp.terminated(call.id, 'system_specific',
'Unhandled exception %s.' % str(e))
def handle_call(self, call):
if (call.type != 'procedure_call'):
raise SCSCPProtocolError('Bad message from client: %s.' % call.type, om=call.om())
try:
head = call.data.elem.name
self.log.debug('Requested head: %s...' % head)
if call.data.elem.cd == 'scscp2' and head in CD_SCSCP2:
res = getattr(self, head)(call.data)
elif call.data.elem.cd == 'arith1' and head in CD_ARITH1:
args = [conv.to_python(a) for a in call.data.arguments]
res = conv.to_openmath(CD_ARITH1[head](*args))
else:
self.log.debug('...head unknown.')
return self.scscp.terminated(call.id, om.OMError(
om.OMSymbol('unhandled_symbol', cd='error'), [call.data.elem]))
strlog = str(res)
self.log.debug('...sending result: %s' % (strlog[:20] + (len(strlog) > 20 and '...')))
return self.scscp.completed(call.id, res)
except (AttributeError, IndexError, TypeError):
self.log.debug('...client protocol error.')
return self.scscp.terminated(call.id, om.OMError(
om.OMSymbol('unexpected_symbol', cd='error'), [call.data]))
except Exception as e:
self.log.exception('Unhandled exception:')
return self.scscp.terminated(call.id, 'system_specific',
'Unhandled exception %s.' % str(e))
def get_signature(self, data):
print(colored(str(data), "blue"))
if data.arguments[0].name == "groebner":
sig_sym = om.OMSymbol("signature", "scscp2")
func_sym = om.OMSymbol("groebner", "singular")
zero_sym = om.OMInteger(0)
infinity_sym = om.OMSymbol("infinity", "nums1")
all_set_sym = om.OMSymbol("symbol_set_all", "scscp2")
return om.OMApplication(sig_sym, [func_sym, zero_sym, infinity_sym, all_set_sym])
return om.OMApplication(om.OMSymbol("symbol_set", "scscp2"), [])
def test_call_wait(self):
""" Test a procedure call and wait """
call = self.client.call(scscp.get_allowed_heads())
self.assertEqual(call.type, "procedure_call")
self.assertEqual(call.params, [(om.OMSymbol('option_return_object', 'scscp1'), om.OMString(True))])
self.assertEqual(call.data, om.OMApplication(om.OMSymbol('get_allowed_heads', 'scscp2'), []))
msg = decode_bytes(self.server.receive())
self.assertEqual(msg, om.OMObject(om.OMAttribution(
om.OMAttributionPairs([
(om.OMSymbol('call_id', 'scscp1'), om.OMString(call.id)),
(om.OMSymbol('option_return_object', 'scscp1'), om.OMString('True'))
]),
om.OMApplication(om.OMSymbol('procedure_call', 'scscp1'), [
om.OMApplication(om.OMSymbol('get_allowed_heads', 'scscp2'), [])])
), version='2.0'))
comp = scscp.SCSCPProcedureMessage.completed(call.id, scscp.symbol_set())
self.server.send(encode_bytes(comp.om()))
resp = self.client.wait()
self.assertEqual(resp.type, "procedure_completed")
self.assertEqual(resp.id, call.id)
self.assertEqual(resp.params, [])
self.assertEqual(resp.data, om.OMApplication(
om.OMSymbol('symbol_set', 'scscp2'),
[om.OMApplication(om.OMSymbol('CDName', 'meta'), [om.OMString('scscp1')]),
om.OMApplication(om.OMSymbol('CDName', 'meta'), [om.OMString('scscp2')])
]
))
def __handle_call(self, call):
""" Safely handles a call """
if (call.type != 'procedure_call'):
raise SCSCPProtocolError('Bad message from client: %s.' %
call.type,
om=call.om())
try:
head = call.data.elem.name
self.log.debug('Requested head: %s...' % head)
# for the methods in scscp2, use the class methods
if call.data.elem.cd == 'scscp2':
if not head in CD_SCSCP2:
raise SCSCPUnknownHead
res = getattr(self, head)(call.data)
# else, handle the call internally
else:
res = self.handle_call(call, head)
strlog = str(res)
self.log.debug('...sending result: %s' %
(strlog[:20] + ('...' if len(strlog) > 20 else '')))
# if we already constructed a procedure message
# else just return it as is
if isinstance(res, SCSCPProcedureMessage):
return res
# else,
else:
return self.scscp.completed(call.id, res)
# User-thrown execption: I don't know this head
except SCSCPUnknownHead:
self.log.debug('...head unknown.')
return self.scscp.terminated(
call.id,
om.OMError(om.OMSymbol('unhandled_symbol', cd='error'),
[call.data.elem]))
# we tried to look up something, but it wasn't given by the client
except (AttributeError, IndexError, TypeError):
self.log.debug('...client protocol error.')
return self.scscp.terminated(
call.id,
om.OMError(om.OMSymbol('unexpected_symbol', cd='error'),
[call.data]))
# anything else
except Exception as e:
self.log.exception('Unhandled exception:')
return self.scscp.terminated(call.id, 'system_specific',
'Unhandled exception %s.' % str(e))
def test_register_sym(self):
register_to_python('hello1', 'hello', 'world')
self.assertEqual(to_python(om.OMSymbol(cd='hello1', name='hello')),
'world')
def echo(obj):
return obj.name
register_to_python('echo1', 'echo', echo)
self.assertEqual(to_python(om.OMSymbol(cd='echo1', name='echo')),
'echo')
def symbol_set(symbols=[],
cdnames=['scscp1', 'scscp2'],
cdurls=[],
groupnames=[],
groupurls=[]):
aggregations = (
(cdnames, om.OMSymbol('CDName', cd='meta')),
(cdurls, om.OMSymbol('CDURL', cd='meta')),
(groupnames, om.OMSymbol('CDGroupName', cd='metagrp')),
(groupurls, om.OMSymbol('CDGroupURL', cd='metagrp')),
)
return _apply(
'symbol_set', symbols +
sum([[om.OMApplication(symbol, [om.OMString(x)]) for x in list]
for (list, symbol) in aggregations], []))
def OMList(self, l):
"""
Convert a list of OM objects into an OM object
EXAMPLES::
>>> from openmath import openmath as om
>>> from openmath.convert_pickle import PickleConverter
>>> converter = PickleConverter()
>>> o = converter.OMList([om.OMInteger(2), om.OMInteger(2)]); o
OMApplication(elem=OMSymbol(name='list', cd='Python', id=None, cdbase='http://python.org/'),
arguments=[OMInteger(integer=2, id=None),
OMInteger(integer=2, id=None)],
id=None, cdbase=None)
>>> converter.to_python(o)
[2, 2]
"""
# Except for the conversion of operands, this duplicates the default
# implementation of python's list conversion to openmath in py_openmath
return om.OMApplication(elem=om.OMSymbol(
cdbase=self._cdbase,
cd='Python',
name='list',
),
arguments=l)
def terminated(cls, id, error, msg=None, **info):
if not isinstance(error, om.OMError):
if cls.errors[error] and msg is None:
raise RuntimeError('Must give an error message')
error = om.OMError(om.OMSymbol('error_' + error, cd='scscp1'),
[om.OMString(msg)])
return cls._w_info('procedure_terminated', id, error, **info)
def signature(name, cd, symbol_sets=None, min=None, max=None):
if isinstance(symbol_sets, list):
n = len(symbol_sets)
if min is None:
min = om.OMInteger(n)
else:
assert min <= n, "Too few parameters"
min = om.OMInteger(min)
assert max is None or max == n, "Too many parameters"
max = om.OMInteger(n)
symbol_sets = om.OMApplication(om.OMSymbol('list', cd='list1'),
symbol_sets)
else:
min = om.OMInteger(0 if min is None else min)
max = om.OMSymbol('infinity',
cd='nums1') if max is None else om.OMInteger(max)
if symbol_sets is None:
symbol_sets = om.OMSymbol('symbol_set_all', cd='scscp2')
return _apply('signature', [om.OMSymbol(name, cd), min, max, symbol_sets])
def OMSymbol(self, module, name):
r"""
Helper function to build an OMS object
EXAMPLES::
>>> from openmath.convert_pickle import PickleConverter
>>> converter = PickleConverter()
>>> o = converter.OMSymbol(module="foo.bar", name="baz"); o
OMSymbol(name='baz', cd='foo.bar', id=None, cdbase='http://python.org/')
"""
return om.OMSymbol(cdbase=self._cdbase, cd=module, name=name)
def call(cls, data, id=None, **opts):
opts = [(om.OMSymbol('option_' + k, cd='scscp1'), cls.options[k](v))
for k, v in opts.items() if v is not None and v is not False]
return cls('procedure_call', data, id, opts)
def _w_info(cls, type, id, data, **info):
info = [(om.OMSymbol('info_' + k, cd='scscp1'), cls.infos[k](v))
for k, v in info.items() if v is not None]
return cls(type, data, id, info)
def is_allowed_head(self, name, cd):
return self.heads.scscp2.is_allowed_head([om.OMSymbol(name, cd)])
def no_such_transient_cd(cd):
return om.OMError(om.OMSymbol('no_such_transient_cd', cd='scscp2'),
[om.OMString(cd)])
def get_transient_cd(name):
return _apply(
'get_transient_cd',
[om.OMApply(om.OMSymbol('CDName', cd='meta'), [om.OMString(name)])])
def get_signature(name, cd):
return _apply('get_signature', [om.OMSymbol(name, cd)])
def __init__(self, name, cd, cli):
self._name = name
self.cd = cd
self._cli = cli
self._om = om.OMSymbol(name, cd=cd)
def is_allowed_head(name, cd):
return _apply('is_allowed_head', [om.OMSymbol(name, cd)])
def to_om_rat(obj):
return om.OMApplication(
om.OMSymbol('rational', cd='nums1'),
map(to_openmath, [obj.numerator, obj.denominator]))
def _apply(cmd, data):
return om.OMApplication(om.OMSymbol(cmd, cd='scscp2'), data)
def to_om_rat(obj):
return om.OMApplication(om.OMSymbol('rational', cd='nums1', cdbase=omBase),
map(DefaultConverter.to_openmath, [obj.numerator, obj.denominator]))
def get_allowed_heads(self, data):
return scscp.symbol_set(
[om.OMSymbol(base=MitMEval, cd=MitMCD, name=MitMEval)],
cdnames=[MitMCD, 'scscp1'])
def query(self):
""" Applies all tags and wrap this query in the mitm eval symbol """
query = self.get()
return _QueryBuilder(query._converter, om.OMSymbol(name="ODKQuery", cd="Systems", cdbase="http://opendreamkit.org")(query._query), tags=query._tags)
import logging
from openmath import openmath as om, convert as conv
from scscp.client import TimeoutError, CONNECTED
from scscp.server import SCSCPServer
from scscp.scscp import SCSCPQuit, SCSCPProtocolError
from scscp import scscp
import PySingular as sing
import poly_parsing as parse
import traceback
from termcolor import colored
false_sym = om.OMSymbol("false", "logic1")
true_sym = om.OMSymbol("true", "logic1")
int_ring_sym = om.OMSymbol("integers", "ring3")
sdmp_sym = om.OMSymbol("SDMP", "polyd")
term_sym = om.OMSymbol("term", "polyd")
poly_ring_sym = om.OMSymbol("poly_ring_d_named", "polyd")
dmp_sym = om.OMSymbol("DMP", "polyd")
list_sym = om.OMSymbol("list", "list1")
def RunSingularCommand(cmd):
print(colored("Running command: " + cmd, "green"))
return sing.RunSingularCommand(cmd)
def makename():
def get_allowed_heads(self, data):
return scscp.symbol_set(
[om.OMSymbol(head, cd='scscp2') for head in CD_SCSCP2] +
[om.OMSymbol(head, cd='singular') for head in CD_SINGULAR],
cdnames=['scscp1'])
# coding: utf-8
# In[ ]:
from openmath import openmath as om
import collections
# In[ ]:
int_ring = om.OMSymbol("integers", "ring3")
sdmp_sym = om.OMSymbol("SDMP", "polyd1")
term_sym = om.OMSymbol("term", "polyd1")
poly_ring_sym = om.OMSymbol("poly_ring_d_named", "polyd1")
dmp_sym = om.OMSymbol("DMP", "polyd1")
# In[ ]:
def tokenise(poly_str):
poly_str = poly_str.replace(" ", "")
tokens = collections.deque()
while len(poly_str) > 0:
current_token = ""
if str(poly_str[0]).isalpha():
while len(poly_str) > 0 and str(poly_str[0]).isalnum():
current_token = current_token + poly_str[0]
poly_str = poly_str[1:]
tokens.append(current_token)
elif str(poly_str[0]).isnumeric():
while len(poly_str) > 0 and str(poly_str[0]).isnumeric():
current_token = current_token + poly_str[0]
def get_allowed_heads(self, data):
return scscp.symbol_set([om.OMSymbol(head, cd='scscp2') for head in CD_SCSCP2]
+ [om.OMSymbol(head, cd='arith1') for head in CD_ARITH1],
cdnames=['scscp1'])