def __init__(self, address="localhost", port=0, *args, **kargs):
EPCServer.__init__(self, (address, port), *args, **kargs)
def complete(*cargs, **ckargs):
return self.complete(*cargs, **ckargs)
self.register_function(complete)
def add_server(address='localhost', port=0):
server = EPCServer((address, port), log_traceback=True)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
server.logger.addHandler(ch)
def add(*args):
return sum(map(int, args))
server.register_function(add)
return server
def echo_server(address='localhost', port=0, logfilename='python-epc.log'):
server = EPCServer((address, port), log_traceback=True)
server.logger.setLevel(logging.DEBUG)
ch = logging.FileHandler(filename=logfilename, mode='w')
ch.setLevel(logging.DEBUG)
server.logger.addHandler(ch)
def echo(*a):
"""Return argument unchanged."""
return a
server.register_function(echo)
return server
def jedi_epc_server(address='localhost', port=0, sys_path=[]):
sys_path = map(os.path.expandvars, map(os.path.expanduser, sys_path))
sys.path = [''] + filter(None, sys_path + sys.path)
# Workaround Jedi's module cache. Use this workaround until Jedi
# got an API to set module paths.
# See also: https://github.com/davidhalter/jedi/issues/36
import_jedi()
from epc.server import EPCServer
server = EPCServer((address, port))
server.register_function(complete)
server.register_function(get_in_function_call)
server.register_function(goto)
server.register_function(get_definition)
return server
import parser
from epc.server import EPCServer
server = EPCServer(('localhost', 0))
@server.register_function
def echo(*a):
return a
@server.register_function
def parse(input) :
return parser.get_tags(input)
server.print_port()
server.serve_forever()
def start_server(host='localhost', port=0):
server = EPCServer((host, port))
server.register_function(asyncio_wait(run_eval))
server.register_function(code_format)
server.register_function(asyncio_wait(get_completions))
server.print_port()
server.serve_forever()
def print_port(self, stream=None):
if stream is None:
stream = sys.stdout
stream.write("___EPCCompletionServer_PORT=")
EPCServer.print_port(self, stream)
def getTemplate(self, name):
d = self.cf.get_template(name)
print d
def validateTemplate(self, template):
ret = "Template Passed"
try:
self.cf.validate_template(template)
except Exception,e:
ret = e.message
return ret
if __name__ == "__main__":
server = EPCServer(('localhost', 0))
Aws = AwsEl('dev')
@server.register_function
def cfValidate(*template):
f = ''.join(template)
return Aws.validateTemplate(f)
@server.register_function
def cfTest(*template):
f = ''.join(template)
return f
server.print_port()
server.serve_forever()
"""
def main():
server = EPCServer(('localhost', 9898))
server.register_function(echo)
server.register_function(get_file_def_pos)
server.print_port()
server.serve_forever()
def __init__(self, *args, **kwds):
kwds.update(RequestHandlerClass=ThreadingDaemonEPCHandler)
EPCServer.__init__(self, *args, **kwds)
#epc_browser.py
from browser import Browser
from epc.server import EPCServer
from epc.server import ThreadingEPCServer
import threading
global server
server = None
try:
__IPYTHON__
server = ThreadingEPCServer(('localhost', 0))
except:
server = EPCServer(('localhost', 0))
class EpcBrowser(Browser):
def setup(self):
result = Browser.setup(self, visible=True, driver="firefox_firebug")
return result
global browser
browser = EpcBrowser()
browser.setup()
def js_ex(string):
print "js_ex "
result = browser.js_ex(string)
print result
return result
def startEpcServer( pd, pi ):
"""
Start the Emacs RPC Server.
"""
from epc.server import EPCServer
server = EPCServer(('localhost', 0))
poem = Poem( pd, pi, "" )
# TODO!!!
# Merge all of this with SylviaConsole in a
# SylviaApis class (or something like that)
@server.register_function
def lookup( word ):
return pd.findPronunciations( as_ascii( word ) )
@server.register_function
def infer( word ):
return pi.pronounce( as_ascii( word ) )
@server.register_function
def rhyme_levels():
return pd.getRhymeLevels()
@server.register_function
def rhyme_regex( pronunciationOrWord, rhymeLevel ):
return pd.getRhymeRegex( as_ascii( pronunciationOrWord ), as_ascii( rhymeLevel ) )
@server.register_function
def rhyme(word, level):
if level == []:
level = "default"
level = as_ascii( level )
word = as_ascii( word )
query = word
results = None
if len( pd.findPronunciations( word ) ) == 0:
pronunciation = pi.pronounce( word )
query = pronunciation
results = pd.regexSearch( pd.getRhymeRegex( query, level ) )
return [ r for r in results if r.lower() != word.lower() ]
@server.register_function
def regex( phoneme_regex ):
return pd.regexSearch( as_ascii( phoneme_regex ) )
@server.register_function
def update_poem( poem_text ):
poem.setText( as_ascii( poem_text ) )
@server.register_function
def poem_syllable_counts():
return poem.syllableCounts()
@server.register_function
def poem_phonemes_in_region( begin, end ):
return poem.phonemesInRegion( begin, end )
server.print_port()
server.serve_forever()
