def sum_all_to_range_with_lua_python(end_range_number):
start_time = time.time()
lua_code = """
function(n)
sum = 0
for i=1,n,1 do
sum = sum + i
end
return sum
end
"""
lua_func = LuaRuntime(encoding=None).eval(lua_code)
the_sum = lua_func(end_range_number)
stop_time = time.time()
return (end_range_number, stop_time - start_time, the_sum)
def is_constraint_satisfied(self, vars: List[Self],
vals: List[Optional[float]]) -> bool:
if self.constraint is None:
return True
lua = LuaRuntime()
for var, val in zip(vars, vals):
if val is None:
continue
if isinstance(var.range, CategoricalRange):
val = var.range.choices[int(val)] # type: ignore
lua.execute("{} = {}".format(var.name, repr(val)))
return lua.eval(self.constraint)
def __init__(self, lua_file, *args, **kwargs):
super(LuaWrapperPlugin, self).__init__(*args, **kwargs)
self.runtime = LuaRuntime(unpack_returned_tuples=True)
self.setup_globals()
base_plugin = self.create_base_plugin()
with open(lua_file, "r") as fh:
data = fh.read()
# Pass base plugin as arg to module
self.lua_plugin = self.runtime.execute(data, base_plugin)
# If the module doesn't return anything, use the base plugin reference
# and assume it modified it anyway.
if self.lua_plugin is None:
self.lua_plugin = base_plugin
def parse_storage(self):
self.lua = LuaRuntime()
self.urlParser = re.compile('([a-zA-Z0-9_-]+)/(\d+)')
with open(Path(f'WTF/Account/{self.accountName}/SavedVariables/WeakAuras.lua'), 'r', encoding='utf-8') as file:
data = file.read().replace('WeakAurasSaved = {', '{')
wadata = self.lua.eval(data)
for wa in wadata['displays']:
if wadata['displays'][wa]['url']:
search = self.urlParser.search(wadata['displays'][wa]['url'])
if search is not None and search.group(1) and search.group(2):
self.uidCache[wadata['displays'][wa]['uid']] = search.group(1)
self.idCache[wadata['displays'][wa]['id']] = search.group(1)
if not wadata['displays'][wa]['parent'] and not wadata['displays'][wa]['ignoreWagoUpdate']:
if wadata['displays'][wa]['skipWagoUpdate']:
self.waIgnored[search.group(1)] = int(wadata['displays'][wa]['skipWagoUpdate'])
self.waList[search.group(1)] = int(search.group(2))
async def evalraw(self, ctx: Context, *, code: str):
"""
Evaluates a lua command in the raw form.
This does not go through the sandbox, and is owner only.
"""
lua = LuaRuntime(unpack_returned_tuples=True)
if code.startswith("```"):
code = code[3:]
if code.endswith("```"):
code = code[:-3]
result = lua.execute(code)
await ctx.send("```{}```".format(result))
def __init__(self, username, accountname, apikey):
self.username = username
self.accountName = accountname
self.apiKey = apikey
self.lua = LuaRuntime()
self.urlParser = re.compile('/([a-zA-Z0-9_-]+)/(\d+)')
self.waList = {}
self.waIgnored = {}
self.uidCache = {}
self.idCache = {}
self.dataCache = {'slugs': [], 'uids': [], 'ids': []}
if self.username == 'DISABLED':
self.username = ''
if not os.path.isfile(
Path(
f'WTF/Account/{self.accountName}/SavedVariables/WeakAuras.lua'
)):
raise RuntimeError('Incorrect WoW account name!')
def __init__(self, path: Path, prototypes: Prototypes):
self.path = path
self.lua = LuaRuntime()
self.prototypes = prototypes
self.lua.execute(
f"package.path = package.path .. ';{self.path.parent.as_posix()}/?.lua'"
)
self.lua.execute('''data = {
extend = function(self, otherdata)
if type(otherdata) ~= 'table' or #otherdata == 0 then
error('Invalid prototype array in ' .. python.eval('prototype'))
end
for key, block in pairs(otherdata) do
table.insert(self, block)
end
end
}''')
def load_mods(self):
# load locale
for mod in self.modlist.mod_order:
locale_dir = '%s/locale/en/' % mod.path
if os.path.exists(locale_dir):
for fn in os.listdir(locale_dir):
fn = os.path.join(locale_dir, fn)
if os.path.isfile(fn) and fn.endswith('.cfg'):
self.locale.load(fn)
old = os.path.abspath(os.curdir)
os.chdir('factorio-lua-tools')
lua = LuaRuntime(unpack_returned_tuples=True)
loader = lua.require('loader')
# TODO this is awful
lua.execute('defines = {}')
lua.execute('defines.difficulty_settings = {}')
lua.execute('defines.difficulty_settings.recipe_difficulty = {}')
lua.execute('defines.difficulty_settings.recipe_difficulty.normal = 1')
lua.execute(
'defines.difficulty_settings.recipe_difficulty.expensive = 2')
lua.execute('defines.difficulty_settings.technology_difficulty = {}')
lua.execute(
'defines.difficulty_settings.technology_difficulty.normal = 1')
lua.execute(
'defines.difficulty_settings.technology_difficulty.expensive = 2')
lua.execute('defines.direction = {}')
lua.execute('defines.direction.north = 0')
lua.execute('defines.direction.east = 1')
lua.execute('defines.direction.south = 2')
lua.execute('defines.direction.west = 3')
lua.execute('function log(x) end')
core_path = '%s/data/core/' % self.factorio_path
mod_paths = [mod.path for mod in self.modlist.mod_order]
loader.load_data(lua.table_from([core_path] + mod_paths))
os.chdir(old)
self.data = FactorioState.table_to_dict(loader.data)
def load_recipes(factorio_dir: str):
"""
Load recipes from Factorio data directory by interpreting the Lua scripts.
"""
lua = LuaRuntime(unpack_returned_tuples=True)
preamble = '''
aggregator = {}
data = {}
data["extend"] = function (data, list_of_things)
for key, thing in ipairs(list_of_things) do
table.insert(aggregator, thing)
end
end
'''
lua.execute(preamble)
recipe_files = [
'data/base/prototypes/recipe.lua',
]
for filename in recipe_files:
full_path = path.join(factorio_dir, path.normpath(filename))
with open(full_path, 'r') as fp:
lua.execute(fp.read())
def lua2py(obj):
t = lua_type(obj)
if t == 'table':
keys = list(obj.keys())
is_sequence = keys == [i + 1 for i in range(len(keys))]
if is_sequence:
return [lua2py(v) for v in obj.values()]
else:
return {lua2py(k): lua2py(obj[k]) for k in keys}
elif t is None:
return obj
else:
raise ValueError(f'unsupported Lua type {t}')
aggregator = lua.eval('aggregator')
return lua2py(aggregator)
def _get_dict_from_lua_source(code):
def recursice_dict(lua_dict):
d = {}
is_list = True
for key, value in lua_dict.items():
if not isinstance(key, int):
is_list = False
if lupa.lua_type(value) == "table":
value = recursice_dict(value)
d[key] = value
if is_list:
return list(d.values())
else:
return d
lua = LuaRuntime(unpack_returned_tuples=True)
l_table = lua.execute(code)
return recursice_dict(l_table)
def read_lua_table(file_name: Path) -> Optional[List]:
"""Read a single lua stat file, returning a dict."""
fp_ = get_filehandle_maybe_gzip(file_name)
file_contents = " ".join([f.decode('UTF-8') for f in fp_.readlines()])
fp_.close()
if file_contents == "placeholder":
return None
lua_code = f"\n function() \r\n local {file_contents} return misStats end"
thread_count = 1
lua_funcs = [
LuaRuntime(encoding=None).eval(lua_code) for _ in range(thread_count)
]
results: List[Dict] = [{}]
def read_tab_func(i, lua_func):
results[i] = lua_func()
threads = [
threading.Thread(target=read_tab_func, args=(i, lua_func))
for i, lua_func in enumerate(lua_funcs)
]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
result = lua_tbl_to_py(results[0])
results_out = []
for res in result.values():
tmp = result_to_flat_dict(res)
entry = {
'file_name': str(file_name),
'pilot': tmp.pop('pilot'),
'pilot_id': tmp.pop('id'),
'record': tmp
}
results_out.append(entry)
return results_out
def is_constraint_satisfied(self, vars: List[Self],
vals: List[Optional[float]]) -> bool:
if self.constraint is None:
return True
if not _lupa_available:
raise RuntimeError(
"Please install `lupa` to handle problems containing conditional search space."
)
lua = LuaRuntime()
for var, val in zip(vars, vals):
if val is None:
continue
if isinstance(var.range, CategoricalRange):
val = var.range.choices[int(val)] # type: ignore
lua.execute("{} = {}".format(var.name, repr(val)))
return lua.eval(self.constraint)
def initialize_lua(ctx):
assert ctx.lua is None
# Load Lua sandbox code.
lua_sandbox = open(lua_dir + "sandbox.lua").read()
def filter_attribute_access(obj, attr_name, is_setting):
if isinstance(attr_name, unicode):
if not attr_name.startswith("_"):
return attr_name
raise AttributeError("access denied")
lua = LuaRuntime(unpack_returned_tuples=True,
register_eval=False,
attribute_filter=filter_attribute_access)
lua.execute(lua_sandbox)
lua.eval("lua_set_loader")(
lambda x: lua_loader(ctx, x), mw_text_decode, mw_text_encode,
mw_text_jsonencode, lambda x, *rest: mw_text_jsondecode(ctx, x, *rest),
lambda x: get_page_info(ctx, x), lambda x: get_page_content(ctx, x),
fetch_language_name, lambda x: fetch_language_names(ctx, x))
ctx.lua = lua
def new_runtime():
rt = LuaRuntime()
lua_root = os.path.join(os.path.dirname(__file__), 'lua')
path = os.path.join(lua_root, '?.lua')
rt.eval("function(path) package.path = package.path .. ';' .. path end")(
path)
#rt.require('utils.common')
rt.require('win.Fight.verify_manager')
require_configs(rt, lua_root)
reg_proto = rt.eval('protobuf.register')
reg_proto(open(os.path.join(lua_root, 'config/poem.pb'), 'rb').read())
reg_proto(open(os.path.join(lua_root, 'config/config.pb'), 'rb').read())
#zip_loader = get_zip_loader(rt, '/tmp/test.zip')
#set_loader(rt, zip_loader)
#rt.require('test.xxx')
return rt
def createMinHash(self):
# We are working with a processor that has 28 cores.
step = 28
for start in range(0, self.n_points, step):
threads = []
if start > self.n_points:
break
for col_j in range(start, start + step):
if col_j >= self.n_points:
break
lua = LuaRuntime(unpack_returned_tuples=True, encoding=None)
pop_index = lua.eval(self.lua_sparse)
zeroes_index = lua.eval(self.lua_dense)
t = threading.Thread(target=self.worker,
args=(col_j, self.signatures[col_j],
pop_index, zeroes_index))
threads.append(t)
for t in threads:
t.start()
for t in threads:
t.join()
class QKernel(Kernel):
implementation = 'Q'
implementation_version = '1.0'
language = 'no-op'
language_version = '0.1'
language_info = {
'name': 'Any text',
'mimetype': 'text/plain',
'file_extension': '.txt',
}
banner = "Q kernel - enjoy analytics"
lua = LuaRuntime(unpack_returned_tuples=True)
lua.execute("Q = require 'Q'")
def do_execute(self,
code,
silent,
store_history=True,
user_expressions=None,
allow_stdin=False):
if not silent:
try:
result = QKernel.lua.execute(code)
except Exception as exc:
result = str(exc)
#with open("/tmp/output.txt", "a") as f:
# f.write("%s\n" % str(result))
if not result:
result = ''
stream_content = {'name': 'stdout', 'text': str(result)}
self.send_response(self.iopub_socket, 'stream', stream_content)
return {
'status': 'ok',
# The base class increments the execution count
'execution_count': self.execution_count,
'payload': [],
'user_expressions': {},
}
def load(self, filepath):
self.towninfoDict.clear()
luafile = open(filepath, 'r', encoding='latin1')
content = luafile.read()
luafile.close()
lua = LuaRuntime(unpack_returned_tuples=True)
lua.execute(content)
g = lua.globals()
for mapname in list(g.mapNPCInfoTable):
self.towninfoDict[mapname] = []
for tagid in list(g.mapNPCInfoTable[mapname]):
singleItem = LeeTowninfoSingleItem(
tagname=g.mapNPCInfoTable[mapname][tagid]['name'],
gbkname=g.mapNPCInfoTable[mapname][tagid]['name'].encode(
'latin1').decode('gbk'),
x=g.mapNPCInfoTable[mapname][tagid]['X'],
y=g.mapNPCInfoTable[mapname][tagid]['Y'],
tagtype=g.mapNPCInfoTable[mapname][tagid]['TYPE'])
self.towninfoDict[mapname].append(singleItem)
def process_rockspec(self, rsname):
source = None
rock_def = {}
try:
with open(rsname, 'r') as fh:
source = fh.read()
except Exception as e:
return self.severe('failed to open/read rockspec: %s' % repr(e))
lr = LuaRuntime()
try:
lr.execute(source)
_G = lr.globals()
rock_def['package'] = _G['package']
rock_def['version'] = _G['version']
rock_def['source'] = dict(_G['source'])
rock_def['description'] = dict(_G['description'])
except Exception as e:
return self.severe('failed process rockspec: %s' % repr(e))
rock = wp_rock()
rock.defs = rock_def
rock.filename = os.path.basename(rsname)
return rock
def load(self, filepath):
self.itemInfoDict.clear()
try:
luafile = open(filepath, 'r', encoding = 'latin1')
content = luafile.read()
luafile.close()
lua = LuaRuntime(unpack_returned_tuples=True)
lua.execute(content)
g = lua.globals()
except Exception as _err:
print('解析文件时发生了错误: %s' % filepath)
raise
for itemID in list(g.tbl):
try:
singleItem = LeeIteminfoSingleItem(
itemID = itemID,
unidentifiedDisplayName = g.tbl[itemID]['unidentifiedDisplayName'],
unidentifiedResourceName = g.tbl[itemID]['unidentifiedResourceName'],
unidentifiedDescriptionName = self.__normdesc(
g.tbl[itemID]['unidentifiedDescriptionName']
),
identifiedDisplayName = g.tbl[itemID]['identifiedDisplayName'],
identifiedResourceName = g.tbl[itemID]['identifiedResourceName'],
identifiedDescriptionName = self.__normdesc(
g.tbl[itemID]['identifiedDescriptionName']
),
slotCount = g.tbl[itemID]['slotCount'],
ClassNum = g.tbl[itemID]['ClassNum'],
)
self.itemInfoDict[self.leeCommon.atoi(itemID)] = singleItem
except Exception as _err:
print('Error Item ID = %d' % itemID)
raise
def load_lua_table(path, key_type=int):
with open(path, encoding='utf-8') as f:
s = f.read()
m = re.search('_G.pg.([a-z_]+)', s)
if m:
table_name = m.group(1)
s = 'pg = {}\npg.' + table_name + '= {}\n' + re.sub('_G.', '', s)
s = re.sub('if rawget.*', '', s, flags=re.DOTALL)
if s[0] == '{':
s = 'pg = pg or {}\npg.data = ' + s
s = re.sub('Vector3\((.*?)\)', '{\g<1>}', s)
s = re.sub('AspectMode\.[A-Za-z]+', '"\g<0>"', s)
s = re.sub('function \\(\\)', '', s)
s = re.sub('end\\(\\)', '', s)
s = re.sub('uv0', 'pg', s)
lua = LuaRuntime(unpack_returned_tuples=True)
lua.execute(s)
g = lua.globals()
for value in g.pg.values():
return convert_lua_to_python_dict(value, key_type)
if not has_lock(id_):
return_message = 'NO_LOCK'
else:
if not TESTING_MODE:
try:
manualDrive.delete_command('right')
manual = manualDrive.run()
return_message = 'SUCCES'
except:
return_message = 'FAILURE'
else:
return_message = 'SUCCES'
elif message[0] == 'COMMAND':
id_ = message[2]
if not has_lock(id_):
return_message = 'NO_LOCK'
else:
print parse_command(message[1])
if not TESTING_MODE:
lua = LuaRuntime()
func = lua.eval("require('linerecog')")
func(commands, conroller.get_engine_distance,
controller.start_commmand, controller.stop_commmand,
controller.drive_distance)
return_message = 'SUCCES'
else:
return_message = 'ILLEGAL_MESSAGE'
print 'Return message: ', return_message
socket.send(return_message)
# Load Lua sandbox code.
lua_sandbox = open("lua/lua_sandbox.lua").read()
def filter_attribute_access(obj, attr_name, is_setting):
print("FILTER:", attr_name, is_setting)
if isinstance(attr_name, unicode):
if not attr_name.startswith("_"):
return attr_name
raise AttributeError("access denied")
lua = LuaRuntime(unpack_returned_tuples=True,
register_eval=False,
attribute_filter=filter_attribute_access)
lua.execute(lua_sandbox)
lua.eval("lua_set_loader")(lua_loader, mw_text_decode, mw_text_encode,
get_page_info, fetch_language_name,
fetch_language_names)
# Process test page
page = open("tests/animal.txt").read()
page_title = "animal"
page = wikitext.preprocess_text(page)
print("=== Expanding templates")
page = expand_listed_templates(page_title, page, templates, invoke_fn)
# XXX expand only need_pre_expand here (now expanding all for testing purposes)
print(page)
def _read_casrc(path):
'''
Read the .casrc file using Lua
Parameters
----------
path : string
Path to the .casrc file
Returns
-------
(cashost, casport, casprotocol)
'''
cashost = None
casport = None
casprotocol = None
if not os.path.isfile(path):
return cashost, casport, casprotocol
try:
from lupa import LuaRuntime
lua = LuaRuntime()
lua.eval('dofile("%s")' % path)
lg = lua.globals()
except ImportError:
import subprocess
import tempfile
lua_script = tempfile.TemporaryFile(mode='w')
lua_script.write('''
if arg[1] then
dofile(arg[1])
for name, value in pairs(_G) do
if name:match('cas') then
print(name .. ' ' .. tostring(value))
end
end
end
''')
lua_script.seek(0)
class LuaGlobals(object):
pass
lg = LuaGlobals()
config = None
try:
config = subprocess.check_output(
'lua - %s' % path, stdin=lua_script,
shell=True).strip().decode('utf-8')
except (OSError, IOError, subprocess.CalledProcessError):
pass
finally:
lua_script.close()
if config:
for name, value in re.findall(r'^\s*(cas\w+)\s+(.+?)\s*$', config,
re.M):
setattr(lg, name, value)
else:
# Try to parse manually
config = re.sub(r'\-\-.*?$',
r' ',
open(path, 'r').read(),
flags=re.M)
for name, value in re.findall(
r'\b(cas\w+)\s*=\s*(\S+)(?:\s+|\s*$)', config):
setattr(lg, name, eval(value))
try:
cashost = str(lg.cashost)
except:
sys.sterr.write('ERROR: Could not access cashost setting\n')
sys.exit(1)
try:
casport = int(lg.casport)
except:
sys.sterr.write('ERROR: Could not access casport setting\n')
sys.exit(1)
try:
if lg.casprotocol:
casprotocol = str(lg.casprotocol)
except:
pass
return cashost, casport, casprotocol
import lupa
from lupa import LuaRuntime
lua = LuaRuntime(unpack_returned_tuples=True)
fileName = "test_json/3.json"
repo_name = "aaa"
meta_version = "bbbb"
comd = ""
comd += "fileName = " + "'" + fileName + "'\n"
comd += "repo_name = " + "'" + repo_name + "'\n"
comd += "meta_version = " + "'" + meta_version + "'\n"
print comd
#lua.eval("dostring("+comd+")")
fo = open("jsonForPY.lua", "w+")
fo.write(comd)
fo.close()
lua.eval("dofile('jsonForPY.lua')")
a = lua.eval("dofile('jsonCompletion.lua')")
print a['appname']
print a['procs']['bar']['port']['port']
def __init__(self, bot):
super().__init__(bot)
self.lua = LuaRuntime(unpack_returned_tuples=True)
self.mp_pool = ProcessPoolExecutor(max_workers=4)
def get_lua_runtime():
from lupa import LuaRuntime
global LUA_RUNTIME # pylint: disable=global-statement
if LUA_RUNTIME is None:
LUA_RUNTIME = LuaRuntime()
return LUA_RUNTIME
def get_label_for_problem(self):
def DENY_ALL(obj, attr_name, is_setting):
raise AttributeError()
lua = LuaRuntime(attribute_filter=DENY_ALL, register_eval=False, register_builtins=False)
return lua.eval(self.problem_label_script or self.format.get_contest_problem_label_script())
# HotFix: don't throw errors when LUA is getting an unknown key
def attr_getter(obj, name):
if name in obj:
if name in ['Blockable', 'HPCount', 'ReinforceArmor', 'TranscendArmor', 'ReinforceWeapon', 'TranscendWeapon']:
return int(obj[name])
else:
return obj[name]
return 0
def attr_setter(obj, name, value):
obj[name] = value
lua = LuaRuntime(attribute_handlers=(attr_getter, attr_setter), unpack_returned_tuples=True)
LUA_OVERRIDE = [
'function GET_ITEM_LEVEL(item) return 0 end', # We cant emulate this function as geItemTable is undefined
'function IsBuffApplied(pc, buff) return "NO" end',
'function IsServerSection(pc) return 0 end',
'function GetExProp(entity, name) return entity[name] end',
'function GetExProp_Str(entity, name) return tostring(entity[name]) end',
'function GetIESID(item) end',
'function GetItemOwner(item) return {} end',
'function GetOwner(monster) end',
'function GetServerNation() end',
'function GetServerGroupID() end',
'function IsPVPServer(itemOwner) end',
'function IMCRandom(min, max) return 0 end',
'function ScpArgMsg(a, b, c) return "" end',
def __init__(
self,
*,
allow_global_state=True, # TODO not yet fully implemented
allow_random=True,
allow_time=True,
custom_globals=None,
**kwargs):
"""Initialize a sandboxed LuaRuntime.
Optional keyword arguments:
- `allow_global_state` -- bool; whether to allow setting global
variables and setting external variables from within a closure
[closures NYI]
- `allow_random` -- bool; whether to give access to Lua's PRNG functions
- `allow_time` -- bool; whether to give access to Lua's date/time
functions
- `custom_globals` -- dict; any extra variables to insert into the
global namespace
All other args and kwargs are passed to LuaRuntime(). It is not
necessary to pass `register_eval=False` or `register_builtins=False`,
since this is already done by LuaSandbox.
"""
self._allow_global_state = allow_global_state
# Prevent access to Python from Lua.
self._lua = LuaRuntime(register_eval=False,
register_builtins=False,
**kwargs)
# Get the behind-the-scenes global table.
allowed_names = LUA_SAFE_NAMES
if allow_random:
allowed_names += LUA_RANDOM_NAMES
if allow_time:
allowed_names += LUA_TIME_NAMES
new_globals = {}
for name in allowed_names:
# We have to handle names like `string.format` by making a new table
# `string` containing keys like `format`.
t = new_globals
keys = name.split('.')
for key in keys[:-1]:
if key not in t:
t[key] = self.table()
t = t[key]
t[keys[-1]] = self._lua.eval(name)
if custom_globals:
new_globals.update(custom_globals)
new_globals = self.table_from(new_globals)
# Override global table access if necessary.
self._sandboxer_code = ''
if not allow_global_state:
new_globals = lua_utils.make_table_readonly_recursive(
self, new_globals,
"Cannot set value '%s' on %s; global variables are forbidden")
self.globals().safe_globals = new_globals
if self.globals().setfenv:
# Lua 5.1
self._sandboxer_code = 'setfenv(1, safe_globals)\n'
else:
# Lua 5.2+
self._sandboxer_code = '_ENV = safe_globals\n'
def __init__(self, umka):
self.umka = umka
self.lua = LuaRuntime(unpack_returned_tuples=True)
