1546 lines
62 KiB
Python
1546 lines
62 KiB
Python
import sys
|
|
|
|
import math as python_lib_Math
|
|
import math as Math
|
|
import inspect as python_lib_Inspect
|
|
import sys as python_lib_Sys
|
|
import functools as python_lib_Functools
|
|
import re as python_lib_Re
|
|
import traceback as python_lib_Traceback
|
|
import urllib.parse as python_lib_urllib_Parse
|
|
|
|
|
|
class _hx_AnonObject:
|
|
_hx_disable_getattr = False
|
|
def __init__(self, fields):
|
|
self.__dict__ = fields
|
|
def __repr__(self):
|
|
return repr(self.__dict__)
|
|
def __contains__(self, item):
|
|
return item in self.__dict__
|
|
def __getitem__(self, item):
|
|
return self.__dict__[item]
|
|
def __getattr__(self, name):
|
|
if (self._hx_disable_getattr):
|
|
raise AttributeError('field does not exist')
|
|
else:
|
|
return None
|
|
def _hx_hasattr(self,field):
|
|
self._hx_disable_getattr = True
|
|
try:
|
|
getattr(self, field)
|
|
self._hx_disable_getattr = False
|
|
return True
|
|
except AttributeError:
|
|
self._hx_disable_getattr = False
|
|
return False
|
|
|
|
|
|
|
|
class Enum:
|
|
_hx_class_name = "Enum"
|
|
__slots__ = ("tag", "index", "params")
|
|
_hx_fields = ["tag", "index", "params"]
|
|
_hx_methods = ["__str__"]
|
|
|
|
def __init__(self,tag,index,params):
|
|
self.tag = tag
|
|
self.index = index
|
|
self.params = params
|
|
|
|
def __str__(self):
|
|
if (self.params is None):
|
|
return self.tag
|
|
else:
|
|
return self.tag + '(' + (', '.join(str(v) for v in self.params)) + ')'
|
|
|
|
|
|
|
|
class Class: pass
|
|
|
|
|
|
class EReg:
|
|
_hx_class_name = "EReg"
|
|
__slots__ = ("pattern", "matchObj", "_hx_global")
|
|
_hx_fields = ["pattern", "matchObj", "global"]
|
|
_hx_methods = ["split"]
|
|
|
|
def __init__(self,r,opt):
|
|
self.matchObj = None
|
|
self._hx_global = False
|
|
options = 0
|
|
_g = 0
|
|
_g1 = len(opt)
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
c = (-1 if ((i >= len(opt))) else ord(opt[i]))
|
|
if (c == 109):
|
|
options = (options | python_lib_Re.M)
|
|
if (c == 105):
|
|
options = (options | python_lib_Re.I)
|
|
if (c == 115):
|
|
options = (options | python_lib_Re.S)
|
|
if (c == 117):
|
|
options = (options | python_lib_Re.U)
|
|
if (c == 103):
|
|
self._hx_global = True
|
|
self.pattern = python_lib_Re.compile(r,options)
|
|
|
|
def split(self,s):
|
|
if self._hx_global:
|
|
ret = []
|
|
lastEnd = 0
|
|
x = python_HaxeIterator(python_lib_Re.finditer(self.pattern,s))
|
|
while x.hasNext():
|
|
x1 = x.next()
|
|
x2 = HxString.substring(s,lastEnd,x1.start())
|
|
ret.append(x2)
|
|
lastEnd = x1.end()
|
|
x = HxString.substr(s,lastEnd,None)
|
|
ret.append(x)
|
|
return ret
|
|
else:
|
|
self.matchObj = python_lib_Re.search(self.pattern,s)
|
|
if (self.matchObj is None):
|
|
return [s]
|
|
else:
|
|
return [HxString.substring(s,0,self.matchObj.start()), HxString.substr(s,self.matchObj.end(),None)]
|
|
|
|
|
|
|
|
class Reflect:
|
|
_hx_class_name = "Reflect"
|
|
__slots__ = ()
|
|
_hx_statics = ["field"]
|
|
|
|
@staticmethod
|
|
def field(o,field):
|
|
return python_Boot.field(o,field)
|
|
|
|
|
|
class Std:
|
|
_hx_class_name = "Std"
|
|
__slots__ = ()
|
|
_hx_statics = ["isOfType", "string", "parseInt", "shortenPossibleNumber", "parseFloat"]
|
|
|
|
@staticmethod
|
|
def isOfType(v,t):
|
|
if ((v is None) and ((t is None))):
|
|
return False
|
|
if (t is None):
|
|
return False
|
|
if ((type(t) == type) and (t == Dynamic)):
|
|
return (v is not None)
|
|
isBool = isinstance(v,bool)
|
|
if (((type(t) == type) and (t == Bool)) and isBool):
|
|
return True
|
|
if ((((not isBool) and (not ((type(t) == type) and (t == Bool)))) and ((type(t) == type) and (t == Int))) and isinstance(v,int)):
|
|
return True
|
|
vIsFloat = isinstance(v,float)
|
|
tmp = None
|
|
tmp1 = None
|
|
if (((not isBool) and vIsFloat) and ((type(t) == type) and (t == Int))):
|
|
f = v
|
|
tmp1 = (((f != Math.POSITIVE_INFINITY) and ((f != Math.NEGATIVE_INFINITY))) and (not python_lib_Math.isnan(f)))
|
|
else:
|
|
tmp1 = False
|
|
if tmp1:
|
|
tmp1 = None
|
|
try:
|
|
tmp1 = int(v)
|
|
except BaseException as _g:
|
|
None
|
|
tmp1 = None
|
|
tmp = (v == tmp1)
|
|
else:
|
|
tmp = False
|
|
if ((tmp and ((v <= 2147483647))) and ((v >= -2147483648))):
|
|
return True
|
|
if (((not isBool) and ((type(t) == type) and (t == Float))) and isinstance(v,(float, int))):
|
|
return True
|
|
if ((type(t) == type) and (t == str)):
|
|
return isinstance(v,str)
|
|
isEnumType = ((type(t) == type) and (t == Enum))
|
|
if ((isEnumType and python_lib_Inspect.isclass(v)) and hasattr(v,"_hx_constructs")):
|
|
return True
|
|
if isEnumType:
|
|
return False
|
|
isClassType = ((type(t) == type) and (t == Class))
|
|
if ((((isClassType and (not isinstance(v,Enum))) and python_lib_Inspect.isclass(v)) and hasattr(v,"_hx_class_name")) and (not hasattr(v,"_hx_constructs"))):
|
|
return True
|
|
if isClassType:
|
|
return False
|
|
tmp = None
|
|
try:
|
|
tmp = isinstance(v,t)
|
|
except BaseException as _g:
|
|
None
|
|
tmp = False
|
|
if tmp:
|
|
return True
|
|
if python_lib_Inspect.isclass(t):
|
|
cls = t
|
|
loop = None
|
|
def _hx_local_1(intf):
|
|
f = (intf._hx_interfaces if (hasattr(intf,"_hx_interfaces")) else [])
|
|
if (f is not None):
|
|
_g = 0
|
|
while (_g < len(f)):
|
|
i = (f[_g] if _g >= 0 and _g < len(f) else None)
|
|
_g = (_g + 1)
|
|
if (i == cls):
|
|
return True
|
|
else:
|
|
l = loop(i)
|
|
if l:
|
|
return True
|
|
return False
|
|
else:
|
|
return False
|
|
loop = _hx_local_1
|
|
currentClass = v.__class__
|
|
result = False
|
|
while (currentClass is not None):
|
|
if loop(currentClass):
|
|
result = True
|
|
break
|
|
currentClass = python_Boot.getSuperClass(currentClass)
|
|
return result
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def string(s):
|
|
return python_Boot.toString1(s,"")
|
|
|
|
@staticmethod
|
|
def parseInt(x):
|
|
if (x is None):
|
|
return None
|
|
try:
|
|
return int(x)
|
|
except BaseException as _g:
|
|
None
|
|
base = 10
|
|
_hx_len = len(x)
|
|
foundCount = 0
|
|
sign = 0
|
|
firstDigitIndex = 0
|
|
lastDigitIndex = -1
|
|
previous = 0
|
|
_g = 0
|
|
_g1 = _hx_len
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
c = (-1 if ((i >= len(x))) else ord(x[i]))
|
|
if (((c > 8) and ((c < 14))) or ((c == 32))):
|
|
if (foundCount > 0):
|
|
return None
|
|
continue
|
|
else:
|
|
c1 = c
|
|
if (c1 == 43):
|
|
if (foundCount == 0):
|
|
sign = 1
|
|
elif (not (((48 <= c) and ((c <= 57))))):
|
|
if (not (((base == 16) and ((((97 <= c) and ((c <= 122))) or (((65 <= c) and ((c <= 90))))))))):
|
|
break
|
|
elif (c1 == 45):
|
|
if (foundCount == 0):
|
|
sign = -1
|
|
elif (not (((48 <= c) and ((c <= 57))))):
|
|
if (not (((base == 16) and ((((97 <= c) and ((c <= 122))) or (((65 <= c) and ((c <= 90))))))))):
|
|
break
|
|
elif (c1 == 48):
|
|
if (not (((foundCount == 0) or (((foundCount == 1) and ((sign != 0))))))):
|
|
if (not (((48 <= c) and ((c <= 57))))):
|
|
if (not (((base == 16) and ((((97 <= c) and ((c <= 122))) or (((65 <= c) and ((c <= 90))))))))):
|
|
break
|
|
elif ((c1 == 120) or ((c1 == 88))):
|
|
if ((previous == 48) and ((((foundCount == 1) and ((sign == 0))) or (((foundCount == 2) and ((sign != 0))))))):
|
|
base = 16
|
|
elif (not (((48 <= c) and ((c <= 57))))):
|
|
if (not (((base == 16) and ((((97 <= c) and ((c <= 122))) or (((65 <= c) and ((c <= 90))))))))):
|
|
break
|
|
elif (not (((48 <= c) and ((c <= 57))))):
|
|
if (not (((base == 16) and ((((97 <= c) and ((c <= 122))) or (((65 <= c) and ((c <= 90))))))))):
|
|
break
|
|
if (((foundCount == 0) and ((sign == 0))) or (((foundCount == 1) and ((sign != 0))))):
|
|
firstDigitIndex = i
|
|
foundCount = (foundCount + 1)
|
|
lastDigitIndex = i
|
|
previous = c
|
|
if (firstDigitIndex <= lastDigitIndex):
|
|
digits = HxString.substring(x,firstDigitIndex,(lastDigitIndex + 1))
|
|
try:
|
|
return (((-1 if ((sign == -1)) else 1)) * int(digits,base))
|
|
except BaseException as _g:
|
|
return None
|
|
return None
|
|
|
|
@staticmethod
|
|
def shortenPossibleNumber(x):
|
|
r = ""
|
|
_g = 0
|
|
_g1 = len(x)
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
c = ("" if (((i < 0) or ((i >= len(x))))) else x[i])
|
|
_g2 = HxString.charCodeAt(c,0)
|
|
if (_g2 is None):
|
|
break
|
|
else:
|
|
_g3 = _g2
|
|
if (((((((((((_g3 == 57) or ((_g3 == 56))) or ((_g3 == 55))) or ((_g3 == 54))) or ((_g3 == 53))) or ((_g3 == 52))) or ((_g3 == 51))) or ((_g3 == 50))) or ((_g3 == 49))) or ((_g3 == 48))) or ((_g3 == 46))):
|
|
r = (("null" if r is None else r) + ("null" if c is None else c))
|
|
else:
|
|
break
|
|
return r
|
|
|
|
@staticmethod
|
|
def parseFloat(x):
|
|
try:
|
|
return float(x)
|
|
except BaseException as _g:
|
|
None
|
|
if (x is not None):
|
|
r1 = Std.shortenPossibleNumber(x)
|
|
if (r1 != x):
|
|
return Std.parseFloat(r1)
|
|
return Math.NaN
|
|
|
|
|
|
class Float: pass
|
|
|
|
|
|
class Int: pass
|
|
|
|
|
|
class Bool: pass
|
|
|
|
|
|
class Dynamic: pass
|
|
|
|
|
|
class StringTools:
|
|
_hx_class_name = "StringTools"
|
|
__slots__ = ()
|
|
_hx_statics = ["isSpace", "ltrim", "rtrim", "trim", "replace"]
|
|
|
|
@staticmethod
|
|
def isSpace(s,pos):
|
|
if (((len(s) == 0) or ((pos < 0))) or ((pos >= len(s)))):
|
|
return False
|
|
c = HxString.charCodeAt(s,pos)
|
|
if (not (((c > 8) and ((c < 14))))):
|
|
return (c == 32)
|
|
else:
|
|
return True
|
|
|
|
@staticmethod
|
|
def ltrim(s):
|
|
l = len(s)
|
|
r = 0
|
|
while ((r < l) and StringTools.isSpace(s,r)):
|
|
r = (r + 1)
|
|
if (r > 0):
|
|
return HxString.substr(s,r,(l - r))
|
|
else:
|
|
return s
|
|
|
|
@staticmethod
|
|
def rtrim(s):
|
|
l = len(s)
|
|
r = 0
|
|
while ((r < l) and StringTools.isSpace(s,((l - r) - 1))):
|
|
r = (r + 1)
|
|
if (r > 0):
|
|
return HxString.substr(s,0,(l - r))
|
|
else:
|
|
return s
|
|
|
|
@staticmethod
|
|
def trim(s):
|
|
return StringTools.ltrim(StringTools.rtrim(s))
|
|
|
|
@staticmethod
|
|
def replace(s,sub,by):
|
|
_this = (list(s) if ((sub == "")) else s.split(sub))
|
|
return by.join([python_Boot.toString1(x1,'') for x1 in _this])
|
|
|
|
|
|
class Test:
|
|
_hx_class_name = "Test"
|
|
__slots__ = ()
|
|
_hx_statics = ["main", "test", "equalMulti"]
|
|
|
|
@staticmethod
|
|
def main():
|
|
Test.test([_hx_AnonObject({'fn': "url", 'expect': _hx_AnonObject({'fn': "equal.string", 'input': "bar", 'out': "flop"}), 'data': "http://foo.com?foo=1#bar=flop&a=1,2&b=c|d|1,2,3"}), _hx_AnonObject({'fn': "url", 'expect': _hx_AnonObject({'fn': "equal.xy", 'input': "a", 'out': "1.22.2"}), 'label': "a equal.xy", 'data': "http://foo.com?foo=1#bar=flop&a=1.2,2.2&b=c|d|1,2,3"}), _hx_AnonObject({'fn': "url", 'expect': _hx_AnonObject({'fn': "equal.multi", 'input': "b", 'out': "c|d|1,2,3"}), 'label': "b equal.multi", 'data': "http://foo.com?foo=1#b=c|d|1,2,3"})])
|
|
Test.test([_hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "bar"], 'out': True}), 'data': "class:bar"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "bar"], 'out': True}), 'label': ".bar shorthand", 'data': ".bar"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': False}), 'data': ".bar -.foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'data': ".bar -.foo .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "bar"], 'out': True}), 'data': ".bar -.bar .bar"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["id", "foo"], 'out': True}), 'label': "id:foo?", 'data': "foo -foo foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'label': "class:foo", 'data': ".foo -.foo .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'label': "class:foo", 'data': ".foo -.foo bar:5 .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'label': "class:foo", 'data': ".foo -.foo bar:>5 .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'label': "class:foo", 'data': ".foo -.foo bar:>5 .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["class", "foo"], 'out': True}), 'label': "class:foo", 'data': ".foo -.foo .foo"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["id", "foo"], 'out': False}), 'label': "!id:foo", 'data': ".foo -.foo .foo"})])
|
|
Test.test([_hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["price", "10"], 'out': True}), 'data': "price:>=5"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["price", "10"], 'out': False}), 'data': "price:>=15"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["price", "4"], 'out': False}), 'data': "price:>=5"}), _hx_AnonObject({'fn': "query", 'expect': _hx_AnonObject({'fn': "test", 'input': ["price", "0"], 'out': False}), 'data': "price:>=5"})])
|
|
|
|
@staticmethod
|
|
def test(spec):
|
|
Query = xrfragment_Query
|
|
errors = 0
|
|
_g = 0
|
|
_g1 = len(spec)
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
q = None
|
|
res = None
|
|
valid = False
|
|
item = (spec[i] if i >= 0 and i < len(spec) else None)
|
|
if (Reflect.field(item,"fn") == "query"):
|
|
q = xrfragment_Query(Reflect.field(item,"data"))
|
|
if (Reflect.field(item,"fn") == "url"):
|
|
res = xrfragment_Url.parse(Reflect.field(item,"data"))
|
|
if (Reflect.field(Reflect.field(item,"expect"),"fn") == "test"):
|
|
valid = (Reflect.field(Reflect.field(item,"expect"),"out") == q.test(HxOverrides.arrayGet(Reflect.field(Reflect.field(item,"expect"),"input"), 0),HxOverrides.arrayGet(Reflect.field(Reflect.field(item,"expect"),"input"), 1)))
|
|
if (Reflect.field(Reflect.field(item,"expect"),"fn") == "equal.string"):
|
|
valid = HxOverrides.eq(Reflect.field(Reflect.field(item,"expect"),"out"),Reflect.field(Reflect.field(res,Reflect.field(Reflect.field(item,"expect"),"input")),"string"))
|
|
if (Reflect.field(Reflect.field(item,"expect"),"fn") == "equal.xy"):
|
|
valid = (Reflect.field(Reflect.field(item,"expect"),"out") == ((Std.string(Reflect.field(Reflect.field(res,Reflect.field(Reflect.field(item,"expect"),"input")),"x")) + Std.string(Reflect.field(Reflect.field(res,Reflect.field(Reflect.field(item,"expect"),"input")),"y")))))
|
|
if (Reflect.field(Reflect.field(item,"expect"),"fn") == "equal.multi"):
|
|
valid = Test.equalMulti(res,item)
|
|
ok = ("[ ✔ ] " if valid else "[ ❌] ")
|
|
print(str((((((("null" if ok is None else ok) + Std.string(Reflect.field(item,"fn"))) + ": '") + Std.string(Reflect.field(item,"data"))) + "'") + HxOverrides.stringOrNull((((" <= " + HxOverrides.stringOrNull(((Reflect.field(item,"label") if (Reflect.field(item,"label")) else Reflect.field(Reflect.field(item,"expect"),"fn"))))) if (Reflect.field(item,"label")) else ""))))))
|
|
if (not valid):
|
|
errors = (errors + 1)
|
|
if (errors > 1):
|
|
print(str((("\n-----\n[ ❌] " + Std.string(errors)) + " errors :/")))
|
|
|
|
@staticmethod
|
|
def equalMulti(res,item):
|
|
target = Reflect.field(res,Reflect.field(Reflect.field(item,"expect"),"input"))
|
|
_hx_str = ""
|
|
_g = 0
|
|
_g1 = Reflect.field(Reflect.field(target,"args"),"length")
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
_hx_str = ((("null" if _hx_str is None else _hx_str) + "|") + HxOverrides.stringOrNull(HxOverrides.arrayGet(Reflect.field(target,"args"), i).string))
|
|
_hx_str = HxString.substr(_hx_str,1,None)
|
|
return (_hx_str == Reflect.field(Reflect.field(item,"expect"),"out"))
|
|
|
|
|
|
class haxe_Exception(Exception):
|
|
_hx_class_name = "haxe.Exception"
|
|
__slots__ = ("_hx___nativeStack", "_hx___nativeException", "_hx___previousException")
|
|
_hx_fields = ["__nativeStack", "__nativeException", "__previousException"]
|
|
_hx_methods = ["unwrap"]
|
|
_hx_statics = ["caught"]
|
|
_hx_interfaces = []
|
|
_hx_super = Exception
|
|
|
|
|
|
def __init__(self,message,previous = None,native = None):
|
|
self._hx___previousException = None
|
|
self._hx___nativeException = None
|
|
self._hx___nativeStack = None
|
|
super().__init__(message)
|
|
self._hx___previousException = previous
|
|
if ((native is not None) and Std.isOfType(native,BaseException)):
|
|
self._hx___nativeException = native
|
|
self._hx___nativeStack = haxe_NativeStackTrace.exceptionStack()
|
|
else:
|
|
self._hx___nativeException = self
|
|
infos = python_lib_Traceback.extract_stack()
|
|
if (len(infos) != 0):
|
|
infos.pop()
|
|
infos.reverse()
|
|
self._hx___nativeStack = infos
|
|
|
|
def unwrap(self):
|
|
return self._hx___nativeException
|
|
|
|
@staticmethod
|
|
def caught(value):
|
|
if Std.isOfType(value,haxe_Exception):
|
|
return value
|
|
elif Std.isOfType(value,BaseException):
|
|
return haxe_Exception(str(value),None,value)
|
|
else:
|
|
return haxe_ValueException(value,None,value)
|
|
|
|
|
|
|
|
class haxe_NativeStackTrace:
|
|
_hx_class_name = "haxe.NativeStackTrace"
|
|
__slots__ = ()
|
|
_hx_statics = ["saveStack", "exceptionStack"]
|
|
|
|
@staticmethod
|
|
def saveStack(exception):
|
|
pass
|
|
|
|
@staticmethod
|
|
def exceptionStack():
|
|
exc = python_lib_Sys.exc_info()
|
|
if (exc[2] is not None):
|
|
infos = python_lib_Traceback.extract_tb(exc[2])
|
|
infos.reverse()
|
|
return infos
|
|
else:
|
|
return []
|
|
|
|
|
|
class haxe_ValueException(haxe_Exception):
|
|
_hx_class_name = "haxe.ValueException"
|
|
__slots__ = ("value",)
|
|
_hx_fields = ["value"]
|
|
_hx_methods = ["unwrap"]
|
|
_hx_statics = []
|
|
_hx_interfaces = []
|
|
_hx_super = haxe_Exception
|
|
|
|
|
|
def __init__(self,value,previous = None,native = None):
|
|
self.value = None
|
|
super().__init__(Std.string(value),previous,native)
|
|
self.value = value
|
|
|
|
def unwrap(self):
|
|
return self.value
|
|
|
|
|
|
|
|
class haxe_iterators_ArrayIterator:
|
|
_hx_class_name = "haxe.iterators.ArrayIterator"
|
|
__slots__ = ("array", "current")
|
|
_hx_fields = ["array", "current"]
|
|
_hx_methods = ["hasNext", "next"]
|
|
|
|
def __init__(self,array):
|
|
self.current = 0
|
|
self.array = array
|
|
|
|
def hasNext(self):
|
|
return (self.current < len(self.array))
|
|
|
|
def next(self):
|
|
def _hx_local_3():
|
|
def _hx_local_2():
|
|
_hx_local_0 = self
|
|
_hx_local_1 = _hx_local_0.current
|
|
_hx_local_0.current = (_hx_local_1 + 1)
|
|
return _hx_local_1
|
|
return python_internal_ArrayImpl._get(self.array, _hx_local_2())
|
|
return _hx_local_3()
|
|
|
|
|
|
|
|
class haxe_iterators_ArrayKeyValueIterator:
|
|
_hx_class_name = "haxe.iterators.ArrayKeyValueIterator"
|
|
__slots__ = ("current", "array")
|
|
_hx_fields = ["current", "array"]
|
|
_hx_methods = ["hasNext", "next"]
|
|
|
|
def __init__(self,array):
|
|
self.current = 0
|
|
self.array = array
|
|
|
|
def hasNext(self):
|
|
return (self.current < len(self.array))
|
|
|
|
def next(self):
|
|
def _hx_local_3():
|
|
def _hx_local_2():
|
|
_hx_local_0 = self
|
|
_hx_local_1 = _hx_local_0.current
|
|
_hx_local_0.current = (_hx_local_1 + 1)
|
|
return _hx_local_1
|
|
return _hx_AnonObject({'value': python_internal_ArrayImpl._get(self.array, self.current), 'key': _hx_local_2()})
|
|
return _hx_local_3()
|
|
|
|
|
|
|
|
class python_Boot:
|
|
_hx_class_name = "python.Boot"
|
|
__slots__ = ()
|
|
_hx_statics = ["keywords", "toString1", "fields", "simpleField", "field", "getInstanceFields", "getSuperClass", "getClassFields", "prefixLength", "unhandleKeywords"]
|
|
|
|
@staticmethod
|
|
def toString1(o,s):
|
|
if (o is None):
|
|
return "null"
|
|
if isinstance(o,str):
|
|
return o
|
|
if (s is None):
|
|
s = ""
|
|
if (len(s) >= 5):
|
|
return "<...>"
|
|
if isinstance(o,bool):
|
|
if o:
|
|
return "true"
|
|
else:
|
|
return "false"
|
|
if (isinstance(o,int) and (not isinstance(o,bool))):
|
|
return str(o)
|
|
if isinstance(o,float):
|
|
try:
|
|
if (o == int(o)):
|
|
return str(Math.floor((o + 0.5)))
|
|
else:
|
|
return str(o)
|
|
except BaseException as _g:
|
|
None
|
|
return str(o)
|
|
if isinstance(o,list):
|
|
o1 = o
|
|
l = len(o1)
|
|
st = "["
|
|
s = (("null" if s is None else s) + "\t")
|
|
_g = 0
|
|
_g1 = l
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
prefix = ""
|
|
if (i > 0):
|
|
prefix = ","
|
|
st = (("null" if st is None else st) + HxOverrides.stringOrNull(((("null" if prefix is None else prefix) + HxOverrides.stringOrNull(python_Boot.toString1((o1[i] if i >= 0 and i < len(o1) else None),s))))))
|
|
st = (("null" if st is None else st) + "]")
|
|
return st
|
|
try:
|
|
if hasattr(o,"toString"):
|
|
return o.toString()
|
|
except BaseException as _g:
|
|
None
|
|
if hasattr(o,"__class__"):
|
|
if isinstance(o,_hx_AnonObject):
|
|
toStr = None
|
|
try:
|
|
fields = python_Boot.fields(o)
|
|
_g = []
|
|
_g1 = 0
|
|
while (_g1 < len(fields)):
|
|
f = (fields[_g1] if _g1 >= 0 and _g1 < len(fields) else None)
|
|
_g1 = (_g1 + 1)
|
|
x = ((("" + ("null" if f is None else f)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f),(("null" if s is None else s) + "\t"))))
|
|
_g.append(x)
|
|
fieldsStr = _g
|
|
toStr = (("{ " + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr]))) + " }")
|
|
except BaseException as _g:
|
|
None
|
|
return "{ ... }"
|
|
if (toStr is None):
|
|
return "{ ... }"
|
|
else:
|
|
return toStr
|
|
if isinstance(o,Enum):
|
|
o1 = o
|
|
l = len(o1.params)
|
|
hasParams = (l > 0)
|
|
if hasParams:
|
|
paramsStr = ""
|
|
_g = 0
|
|
_g1 = l
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
prefix = ""
|
|
if (i > 0):
|
|
prefix = ","
|
|
paramsStr = (("null" if paramsStr is None else paramsStr) + HxOverrides.stringOrNull(((("null" if prefix is None else prefix) + HxOverrides.stringOrNull(python_Boot.toString1(o1.params[i],s))))))
|
|
return (((HxOverrides.stringOrNull(o1.tag) + "(") + ("null" if paramsStr is None else paramsStr)) + ")")
|
|
else:
|
|
return o1.tag
|
|
if hasattr(o,"_hx_class_name"):
|
|
if (o.__class__.__name__ != "type"):
|
|
fields = python_Boot.getInstanceFields(o)
|
|
_g = []
|
|
_g1 = 0
|
|
while (_g1 < len(fields)):
|
|
f = (fields[_g1] if _g1 >= 0 and _g1 < len(fields) else None)
|
|
_g1 = (_g1 + 1)
|
|
x = ((("" + ("null" if f is None else f)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f),(("null" if s is None else s) + "\t"))))
|
|
_g.append(x)
|
|
fieldsStr = _g
|
|
toStr = (((HxOverrides.stringOrNull(o._hx_class_name) + "( ") + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr]))) + " )")
|
|
return toStr
|
|
else:
|
|
fields = python_Boot.getClassFields(o)
|
|
_g = []
|
|
_g1 = 0
|
|
while (_g1 < len(fields)):
|
|
f = (fields[_g1] if _g1 >= 0 and _g1 < len(fields) else None)
|
|
_g1 = (_g1 + 1)
|
|
x = ((("" + ("null" if f is None else f)) + " : ") + HxOverrides.stringOrNull(python_Boot.toString1(python_Boot.simpleField(o,f),(("null" if s is None else s) + "\t"))))
|
|
_g.append(x)
|
|
fieldsStr = _g
|
|
toStr = (((("#" + HxOverrides.stringOrNull(o._hx_class_name)) + "( ") + HxOverrides.stringOrNull(", ".join([x1 for x1 in fieldsStr]))) + " )")
|
|
return toStr
|
|
if ((type(o) == type) and (o == str)):
|
|
return "#String"
|
|
if ((type(o) == type) and (o == list)):
|
|
return "#Array"
|
|
if callable(o):
|
|
return "function"
|
|
try:
|
|
if hasattr(o,"__repr__"):
|
|
return o.__repr__()
|
|
except BaseException as _g:
|
|
None
|
|
if hasattr(o,"__str__"):
|
|
return o.__str__([])
|
|
if hasattr(o,"__name__"):
|
|
return o.__name__
|
|
return "???"
|
|
else:
|
|
return str(o)
|
|
|
|
@staticmethod
|
|
def fields(o):
|
|
a = []
|
|
if (o is not None):
|
|
if hasattr(o,"_hx_fields"):
|
|
fields = o._hx_fields
|
|
if (fields is not None):
|
|
return list(fields)
|
|
if isinstance(o,_hx_AnonObject):
|
|
d = o.__dict__
|
|
keys = d.keys()
|
|
handler = python_Boot.unhandleKeywords
|
|
for k in keys:
|
|
if (k != '_hx_disable_getattr'):
|
|
a.append(handler(k))
|
|
elif hasattr(o,"__dict__"):
|
|
d = o.__dict__
|
|
keys1 = d.keys()
|
|
for k in keys1:
|
|
a.append(k)
|
|
return a
|
|
|
|
@staticmethod
|
|
def simpleField(o,field):
|
|
if (field is None):
|
|
return None
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
|
|
@staticmethod
|
|
def field(o,field):
|
|
if (field is None):
|
|
return None
|
|
if isinstance(o,str):
|
|
field1 = field
|
|
_hx_local_0 = len(field1)
|
|
if (_hx_local_0 == 10):
|
|
if (field1 == "charCodeAt"):
|
|
return python_internal_MethodClosure(o,HxString.charCodeAt)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 11):
|
|
if (field1 == "lastIndexOf"):
|
|
return python_internal_MethodClosure(o,HxString.lastIndexOf)
|
|
elif (field1 == "toLowerCase"):
|
|
return python_internal_MethodClosure(o,HxString.toLowerCase)
|
|
elif (field1 == "toUpperCase"):
|
|
return python_internal_MethodClosure(o,HxString.toUpperCase)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 9):
|
|
if (field1 == "substring"):
|
|
return python_internal_MethodClosure(o,HxString.substring)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 5):
|
|
if (field1 == "split"):
|
|
return python_internal_MethodClosure(o,HxString.split)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 7):
|
|
if (field1 == "indexOf"):
|
|
return python_internal_MethodClosure(o,HxString.indexOf)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 8):
|
|
if (field1 == "toString"):
|
|
return python_internal_MethodClosure(o,HxString.toString)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_0 == 6):
|
|
if (field1 == "charAt"):
|
|
return python_internal_MethodClosure(o,HxString.charAt)
|
|
elif (field1 == "length"):
|
|
return len(o)
|
|
elif (field1 == "substr"):
|
|
return python_internal_MethodClosure(o,HxString.substr)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif isinstance(o,list):
|
|
field1 = field
|
|
_hx_local_1 = len(field1)
|
|
if (_hx_local_1 == 11):
|
|
if (field1 == "lastIndexOf"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.lastIndexOf)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 4):
|
|
if (field1 == "copy"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.copy)
|
|
elif (field1 == "join"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.join)
|
|
elif (field1 == "push"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.push)
|
|
elif (field1 == "sort"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.sort)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 5):
|
|
if (field1 == "shift"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.shift)
|
|
elif (field1 == "slice"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.slice)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 7):
|
|
if (field1 == "indexOf"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.indexOf)
|
|
elif (field1 == "reverse"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.reverse)
|
|
elif (field1 == "unshift"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.unshift)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 3):
|
|
if (field1 == "map"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.map)
|
|
elif (field1 == "pop"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.pop)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 8):
|
|
if (field1 == "contains"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.contains)
|
|
elif (field1 == "iterator"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.iterator)
|
|
elif (field1 == "toString"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.toString)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 16):
|
|
if (field1 == "keyValueIterator"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.keyValueIterator)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
elif (_hx_local_1 == 6):
|
|
if (field1 == "concat"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.concat)
|
|
elif (field1 == "filter"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.filter)
|
|
elif (field1 == "insert"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.insert)
|
|
elif (field1 == "length"):
|
|
return len(o)
|
|
elif (field1 == "remove"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.remove)
|
|
elif (field1 == "splice"):
|
|
return python_internal_MethodClosure(o,python_internal_ArrayImpl.splice)
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
else:
|
|
field1 = (("_hx_" + field) if ((field in python_Boot.keywords)) else (("_hx_" + field) if (((((len(field) > 2) and ((ord(field[0]) == 95))) and ((ord(field[1]) == 95))) and ((ord(field[(len(field) - 1)]) != 95)))) else field))
|
|
if hasattr(o,field1):
|
|
return getattr(o,field1)
|
|
else:
|
|
return None
|
|
|
|
@staticmethod
|
|
def getInstanceFields(c):
|
|
f = (list(c._hx_fields) if (hasattr(c,"_hx_fields")) else [])
|
|
if hasattr(c,"_hx_methods"):
|
|
f = (f + c._hx_methods)
|
|
sc = python_Boot.getSuperClass(c)
|
|
if (sc is None):
|
|
return f
|
|
else:
|
|
scArr = python_Boot.getInstanceFields(sc)
|
|
scMap = set(scArr)
|
|
_g = 0
|
|
while (_g < len(f)):
|
|
f1 = (f[_g] if _g >= 0 and _g < len(f) else None)
|
|
_g = (_g + 1)
|
|
if (not (f1 in scMap)):
|
|
scArr.append(f1)
|
|
return scArr
|
|
|
|
@staticmethod
|
|
def getSuperClass(c):
|
|
if (c is None):
|
|
return None
|
|
try:
|
|
if hasattr(c,"_hx_super"):
|
|
return c._hx_super
|
|
return None
|
|
except BaseException as _g:
|
|
None
|
|
return None
|
|
|
|
@staticmethod
|
|
def getClassFields(c):
|
|
if hasattr(c,"_hx_statics"):
|
|
x = c._hx_statics
|
|
return list(x)
|
|
else:
|
|
return []
|
|
|
|
@staticmethod
|
|
def unhandleKeywords(name):
|
|
if (HxString.substr(name,0,python_Boot.prefixLength) == "_hx_"):
|
|
real = HxString.substr(name,python_Boot.prefixLength,None)
|
|
if (real in python_Boot.keywords):
|
|
return real
|
|
return name
|
|
|
|
|
|
class python_HaxeIterator:
|
|
_hx_class_name = "python.HaxeIterator"
|
|
__slots__ = ("it", "x", "has", "checked")
|
|
_hx_fields = ["it", "x", "has", "checked"]
|
|
_hx_methods = ["next", "hasNext"]
|
|
|
|
def __init__(self,it):
|
|
self.checked = False
|
|
self.has = False
|
|
self.x = None
|
|
self.it = it
|
|
|
|
def next(self):
|
|
if (not self.checked):
|
|
self.hasNext()
|
|
self.checked = False
|
|
return self.x
|
|
|
|
def hasNext(self):
|
|
if (not self.checked):
|
|
try:
|
|
self.x = self.it.__next__()
|
|
self.has = True
|
|
except BaseException as _g:
|
|
None
|
|
if Std.isOfType(haxe_Exception.caught(_g).unwrap(),StopIteration):
|
|
self.has = False
|
|
self.x = None
|
|
else:
|
|
raise _g
|
|
self.checked = True
|
|
return self.has
|
|
|
|
|
|
|
|
class python_internal_ArrayImpl:
|
|
_hx_class_name = "python.internal.ArrayImpl"
|
|
__slots__ = ()
|
|
_hx_statics = ["get_length", "concat", "copy", "iterator", "keyValueIterator", "indexOf", "lastIndexOf", "join", "toString", "pop", "push", "unshift", "remove", "contains", "shift", "slice", "sort", "splice", "map", "filter", "insert", "reverse", "_get"]
|
|
|
|
@staticmethod
|
|
def get_length(x):
|
|
return len(x)
|
|
|
|
@staticmethod
|
|
def concat(a1,a2):
|
|
return (a1 + a2)
|
|
|
|
@staticmethod
|
|
def copy(x):
|
|
return list(x)
|
|
|
|
@staticmethod
|
|
def iterator(x):
|
|
return python_HaxeIterator(x.__iter__())
|
|
|
|
@staticmethod
|
|
def keyValueIterator(x):
|
|
return haxe_iterators_ArrayKeyValueIterator(x)
|
|
|
|
@staticmethod
|
|
def indexOf(a,x,fromIndex = None):
|
|
_hx_len = len(a)
|
|
l = (0 if ((fromIndex is None)) else ((_hx_len + fromIndex) if ((fromIndex < 0)) else fromIndex))
|
|
if (l < 0):
|
|
l = 0
|
|
_g = l
|
|
_g1 = _hx_len
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
if HxOverrides.eq(a[i],x):
|
|
return i
|
|
return -1
|
|
|
|
@staticmethod
|
|
def lastIndexOf(a,x,fromIndex = None):
|
|
_hx_len = len(a)
|
|
l = (_hx_len if ((fromIndex is None)) else (((_hx_len + fromIndex) + 1) if ((fromIndex < 0)) else (fromIndex + 1)))
|
|
if (l > _hx_len):
|
|
l = _hx_len
|
|
while True:
|
|
l = (l - 1)
|
|
tmp = l
|
|
if (not ((tmp > -1))):
|
|
break
|
|
if HxOverrides.eq(a[l],x):
|
|
return l
|
|
return -1
|
|
|
|
@staticmethod
|
|
def join(x,sep):
|
|
return sep.join([python_Boot.toString1(x1,'') for x1 in x])
|
|
|
|
@staticmethod
|
|
def toString(x):
|
|
return (("[" + HxOverrides.stringOrNull(",".join([python_Boot.toString1(x1,'') for x1 in x]))) + "]")
|
|
|
|
@staticmethod
|
|
def pop(x):
|
|
if (len(x) == 0):
|
|
return None
|
|
else:
|
|
return x.pop()
|
|
|
|
@staticmethod
|
|
def push(x,e):
|
|
x.append(e)
|
|
return len(x)
|
|
|
|
@staticmethod
|
|
def unshift(x,e):
|
|
x.insert(0, e)
|
|
|
|
@staticmethod
|
|
def remove(x,e):
|
|
try:
|
|
x.remove(e)
|
|
return True
|
|
except BaseException as _g:
|
|
None
|
|
return False
|
|
|
|
@staticmethod
|
|
def contains(x,e):
|
|
return (e in x)
|
|
|
|
@staticmethod
|
|
def shift(x):
|
|
if (len(x) == 0):
|
|
return None
|
|
return x.pop(0)
|
|
|
|
@staticmethod
|
|
def slice(x,pos,end = None):
|
|
return x[pos:end]
|
|
|
|
@staticmethod
|
|
def sort(x,f):
|
|
x.sort(key= python_lib_Functools.cmp_to_key(f))
|
|
|
|
@staticmethod
|
|
def splice(x,pos,_hx_len):
|
|
if (pos < 0):
|
|
pos = (len(x) + pos)
|
|
if (pos < 0):
|
|
pos = 0
|
|
res = x[pos:(pos + _hx_len)]
|
|
del x[pos:(pos + _hx_len)]
|
|
return res
|
|
|
|
@staticmethod
|
|
def map(x,f):
|
|
return list(map(f,x))
|
|
|
|
@staticmethod
|
|
def filter(x,f):
|
|
return list(filter(f,x))
|
|
|
|
@staticmethod
|
|
def insert(a,pos,x):
|
|
a.insert(pos, x)
|
|
|
|
@staticmethod
|
|
def reverse(a):
|
|
a.reverse()
|
|
|
|
@staticmethod
|
|
def _get(x,idx):
|
|
if ((idx > -1) and ((idx < len(x)))):
|
|
return x[idx]
|
|
else:
|
|
return None
|
|
|
|
|
|
class HxOverrides:
|
|
_hx_class_name = "HxOverrides"
|
|
__slots__ = ()
|
|
_hx_statics = ["eq", "stringOrNull", "length", "arrayGet"]
|
|
|
|
@staticmethod
|
|
def eq(a,b):
|
|
if (isinstance(a,list) or isinstance(b,list)):
|
|
return a is b
|
|
return (a == b)
|
|
|
|
@staticmethod
|
|
def stringOrNull(s):
|
|
if (s is None):
|
|
return "null"
|
|
else:
|
|
return s
|
|
|
|
@staticmethod
|
|
def length(x):
|
|
if isinstance(x,str):
|
|
return len(x)
|
|
elif isinstance(x,list):
|
|
return len(x)
|
|
return x.length
|
|
|
|
@staticmethod
|
|
def arrayGet(a,i):
|
|
if isinstance(a,list):
|
|
x = a
|
|
if ((i > -1) and ((i < len(x)))):
|
|
return x[i]
|
|
else:
|
|
return None
|
|
else:
|
|
return a[i]
|
|
|
|
|
|
class python_internal_MethodClosure:
|
|
_hx_class_name = "python.internal.MethodClosure"
|
|
__slots__ = ("obj", "func")
|
|
_hx_fields = ["obj", "func"]
|
|
_hx_methods = ["__call__"]
|
|
|
|
def __init__(self,obj,func):
|
|
self.obj = obj
|
|
self.func = func
|
|
|
|
def __call__(self,*args):
|
|
return self.func(self.obj,*args)
|
|
|
|
|
|
|
|
class HxString:
|
|
_hx_class_name = "HxString"
|
|
__slots__ = ()
|
|
_hx_statics = ["split", "charCodeAt", "charAt", "lastIndexOf", "toUpperCase", "toLowerCase", "indexOf", "indexOfImpl", "toString", "get_length", "substring", "substr"]
|
|
|
|
@staticmethod
|
|
def split(s,d):
|
|
if (d == ""):
|
|
return list(s)
|
|
else:
|
|
return s.split(d)
|
|
|
|
@staticmethod
|
|
def charCodeAt(s,index):
|
|
if ((((s is None) or ((len(s) == 0))) or ((index < 0))) or ((index >= len(s)))):
|
|
return None
|
|
else:
|
|
return ord(s[index])
|
|
|
|
@staticmethod
|
|
def charAt(s,index):
|
|
if ((index < 0) or ((index >= len(s)))):
|
|
return ""
|
|
else:
|
|
return s[index]
|
|
|
|
@staticmethod
|
|
def lastIndexOf(s,_hx_str,startIndex = None):
|
|
if (startIndex is None):
|
|
return s.rfind(_hx_str, 0, len(s))
|
|
elif (_hx_str == ""):
|
|
length = len(s)
|
|
if (startIndex < 0):
|
|
startIndex = (length + startIndex)
|
|
if (startIndex < 0):
|
|
startIndex = 0
|
|
if (startIndex > length):
|
|
return length
|
|
else:
|
|
return startIndex
|
|
else:
|
|
i = s.rfind(_hx_str, 0, (startIndex + 1))
|
|
startLeft = (max(0,((startIndex + 1) - len(_hx_str))) if ((i == -1)) else (i + 1))
|
|
check = s.find(_hx_str, startLeft, len(s))
|
|
if ((check > i) and ((check <= startIndex))):
|
|
return check
|
|
else:
|
|
return i
|
|
|
|
@staticmethod
|
|
def toUpperCase(s):
|
|
return s.upper()
|
|
|
|
@staticmethod
|
|
def toLowerCase(s):
|
|
return s.lower()
|
|
|
|
@staticmethod
|
|
def indexOf(s,_hx_str,startIndex = None):
|
|
if (startIndex is None):
|
|
return s.find(_hx_str)
|
|
else:
|
|
return HxString.indexOfImpl(s,_hx_str,startIndex)
|
|
|
|
@staticmethod
|
|
def indexOfImpl(s,_hx_str,startIndex):
|
|
if (_hx_str == ""):
|
|
length = len(s)
|
|
if (startIndex < 0):
|
|
startIndex = (length + startIndex)
|
|
if (startIndex < 0):
|
|
startIndex = 0
|
|
if (startIndex > length):
|
|
return length
|
|
else:
|
|
return startIndex
|
|
return s.find(_hx_str, startIndex)
|
|
|
|
@staticmethod
|
|
def toString(s):
|
|
return s
|
|
|
|
@staticmethod
|
|
def get_length(s):
|
|
return len(s)
|
|
|
|
@staticmethod
|
|
def substring(s,startIndex,endIndex = None):
|
|
if (startIndex < 0):
|
|
startIndex = 0
|
|
if (endIndex is None):
|
|
return s[startIndex:]
|
|
else:
|
|
if (endIndex < 0):
|
|
endIndex = 0
|
|
if (endIndex < startIndex):
|
|
return s[endIndex:startIndex]
|
|
else:
|
|
return s[startIndex:endIndex]
|
|
|
|
@staticmethod
|
|
def substr(s,startIndex,_hx_len = None):
|
|
if (_hx_len is None):
|
|
return s[startIndex:]
|
|
else:
|
|
if (_hx_len == 0):
|
|
return ""
|
|
if (startIndex < 0):
|
|
startIndex = (len(s) + startIndex)
|
|
if (startIndex < 0):
|
|
startIndex = 0
|
|
return s[startIndex:(startIndex + _hx_len)]
|
|
|
|
|
|
class xrfragment_Query:
|
|
_hx_class_name = "xrfragment.Query"
|
|
__slots__ = ("str", "q", "isProp", "isExclude")
|
|
_hx_fields = ["str", "q", "isProp", "isExclude"]
|
|
_hx_methods = ["toObject", "expandAliases", "parse", "test"]
|
|
|
|
def __init__(self,_hx_str):
|
|
self.isExclude = EReg("^-","")
|
|
self.isProp = EReg("^.*:[><=!]?","")
|
|
self.q = _hx_AnonObject({})
|
|
self.str = ""
|
|
if (_hx_str is not None):
|
|
self.parse(_hx_str)
|
|
|
|
def toObject(self):
|
|
return self.q
|
|
|
|
def expandAliases(self,token):
|
|
classAlias = EReg("^(-)?\\.","")
|
|
classAlias.matchObj = python_lib_Re.search(classAlias.pattern,token)
|
|
if (classAlias.matchObj is not None):
|
|
return StringTools.replace(token,".","class:")
|
|
else:
|
|
return token
|
|
|
|
def parse(self,_hx_str,recurse = None):
|
|
if (recurse is None):
|
|
recurse = False
|
|
_gthis = self
|
|
token = _hx_str.split(" ")
|
|
q = _hx_AnonObject({})
|
|
def _hx_local_0(_hx_str,prefix = None):
|
|
if (prefix is None):
|
|
prefix = ""
|
|
_hx_str = StringTools.trim(_hx_str)
|
|
value = _hx_AnonObject({})
|
|
_this = _gthis.isProp
|
|
_this.matchObj = python_lib_Re.search(_this.pattern,_hx_str)
|
|
if (_this.matchObj is not None):
|
|
oper = ""
|
|
startIndex = None
|
|
if (((_hx_str.find("*") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,"*",startIndex))) != -1):
|
|
oper = "*"
|
|
startIndex = None
|
|
if (((_hx_str.find(">") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,">",startIndex))) != -1):
|
|
oper = ">"
|
|
startIndex = None
|
|
if (((_hx_str.find("<") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,"<",startIndex))) != -1):
|
|
oper = "<"
|
|
startIndex = None
|
|
if (((_hx_str.find("!=") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,"!=",startIndex))) != -1):
|
|
oper = "!="
|
|
startIndex = None
|
|
if (((_hx_str.find(">=") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,">=",startIndex))) != -1):
|
|
oper = ">="
|
|
startIndex = None
|
|
if (((_hx_str.find("<=") if ((startIndex is None)) else HxString.indexOfImpl(_hx_str,"<=",startIndex))) != -1):
|
|
oper = "<="
|
|
k = HxOverrides.arrayGet(_hx_str.split(":"), 0)
|
|
v = HxOverrides.arrayGet(_hx_str.split(":"), 1)
|
|
if Reflect.field(q,(("null" if prefix is None else prefix) + ("null" if k is None else k))):
|
|
value = Reflect.field(q,(("null" if prefix is None else prefix) + ("null" if k is None else k)))
|
|
if (len(oper) > 0):
|
|
value1 = Std.parseFloat(HxString.substr(v,len(oper),None))
|
|
setattr(value,(("_hx_" + oper) if ((oper in python_Boot.keywords)) else (("_hx_" + oper) if (((((len(oper) > 2) and ((ord(oper[0]) == 95))) and ((ord(oper[1]) == 95))) and ((ord(oper[(len(oper) - 1)]) != 95)))) else oper)),value1)
|
|
setattr(q,(("_hx_" + k) if ((k in python_Boot.keywords)) else (("_hx_" + k) if (((((len(k) > 2) and ((ord(k[0]) == 95))) and ((ord(k[1]) == 95))) and ((ord(k[(len(k) - 1)]) != 95)))) else k)),value)
|
|
else:
|
|
_this = _gthis.isExclude
|
|
_this.matchObj = python_lib_Re.search(_this.pattern,k)
|
|
key = (("null" if prefix is None else prefix) + HxOverrides.stringOrNull(((HxString.substr(k,1,None) if ((_this.matchObj is not None)) else k))))
|
|
_this = _gthis.isExclude
|
|
_this.matchObj = python_lib_Re.search(_this.pattern,k)
|
|
value1 = ((_this.matchObj is not None) == False)
|
|
setattr(value,(("_hx_" + key) if ((key in python_Boot.keywords)) else (("_hx_" + key) if (((((len(key) > 2) and ((ord(key[0]) == 95))) and ((ord(key[1]) == 95))) and ((ord(key[(len(key) - 1)]) != 95)))) else key)),value1)
|
|
setattr(q,(("_hx_" + v) if ((v in python_Boot.keywords)) else (("_hx_" + v) if (((((len(v) > 2) and ((ord(v[0]) == 95))) and ((ord(v[1]) == 95))) and ((ord(v[(len(v) - 1)]) != 95)))) else v)),value)
|
|
return
|
|
else:
|
|
_this = _gthis.isExclude
|
|
_this.matchObj = python_lib_Re.search(_this.pattern,_hx_str)
|
|
value1 = (False if ((_this.matchObj is not None)) else True)
|
|
setattr(value,(("_hx_" + "id") if (("id" in python_Boot.keywords)) else (("_hx_" + "id") if (((((len("id") > 2) and ((ord("id"[0]) == 95))) and ((ord("id"[1]) == 95))) and ((ord("id"[(len("id") - 1)]) != 95)))) else "id")),value1)
|
|
_this = _gthis.isExclude
|
|
_this.matchObj = python_lib_Re.search(_this.pattern,_hx_str)
|
|
key = (HxString.substr(_hx_str,1,None) if ((_this.matchObj is not None)) else _hx_str)
|
|
setattr(q,(("_hx_" + key) if ((key in python_Boot.keywords)) else (("_hx_" + key) if (((((len(key) > 2) and ((ord(key[0]) == 95))) and ((ord(key[1]) == 95))) and ((ord(key[(len(key) - 1)]) != 95)))) else key)),value)
|
|
process = _hx_local_0
|
|
_g = 0
|
|
_g1 = len(token)
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
process(self.expandAliases((token[i] if i >= 0 and i < len(token) else None)))
|
|
self.q = q
|
|
return self.q
|
|
|
|
def test(self,property,value = None):
|
|
conds = 0
|
|
fails = 0
|
|
qualify = 0
|
|
def _hx_local_2(expr):
|
|
nonlocal fails
|
|
nonlocal conds
|
|
conds = (conds + 1)
|
|
fails = (fails + (0 if expr else 1))
|
|
return expr
|
|
testprop = _hx_local_2
|
|
if (Reflect.field(self.q,value) is not None):
|
|
v = Reflect.field(self.q,value)
|
|
if (Reflect.field(v,property) is not None):
|
|
return Reflect.field(v,property)
|
|
_g = 0
|
|
_g1 = python_Boot.fields(self.q)
|
|
while (_g < len(_g1)):
|
|
k = (_g1[_g] if _g >= 0 and _g < len(_g1) else None)
|
|
_g = (_g + 1)
|
|
qval = Reflect.field(self.q,k)
|
|
if Std.isOfType(value,str):
|
|
continue
|
|
if ((Reflect.field(qval,"=") is not None) and testprop(HxOverrides.eq(value,Reflect.field(qval,"=")))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,"*") is not None) and testprop((value is not None))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,">") is not None) and testprop((value > Std.parseFloat(Reflect.field(qval,">"))))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,"<") is not None) and testprop((value < Std.parseFloat(Reflect.field(qval,"<"))))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,">=") is not None) and testprop((value >= Std.parseFloat(Reflect.field(qval,">="))))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,"<=") is not None) and testprop((value >= Std.parseFloat(Reflect.field(qval,"<="))))):
|
|
qualify = (qualify + 1)
|
|
if ((Reflect.field(qval,"!=") is not None) and testprop((value != Std.parseFloat(Reflect.field(qval,"!="))))):
|
|
qualify = (qualify + 1)
|
|
return (qualify > 0)
|
|
|
|
|
|
|
|
class xrfragment_Value:
|
|
_hx_class_name = "xrfragment.Value"
|
|
__slots__ = ("x", "y", "z", "color", "string", "int", "float", "args")
|
|
_hx_fields = ["x", "y", "z", "color", "string", "int", "float", "args"]
|
|
|
|
def __init__(self):
|
|
self.args = None
|
|
self.float = None
|
|
self.int = None
|
|
self.string = None
|
|
self.color = None
|
|
self.z = None
|
|
self.y = None
|
|
self.x = None
|
|
|
|
|
|
|
|
class xrfragment_Url:
|
|
_hx_class_name = "xrfragment.Url"
|
|
__slots__ = ()
|
|
_hx_statics = ["parse", "guessType"]
|
|
|
|
@staticmethod
|
|
def parse(qs):
|
|
fragment = qs.split("#")
|
|
_this = (fragment[1] if 1 < len(fragment) else None)
|
|
splitArray = _this.split("&")
|
|
regexPlus = EReg("\\+","g")
|
|
resultMap = _hx_AnonObject({})
|
|
_g = 0
|
|
_g1 = len(splitArray)
|
|
while (_g < _g1):
|
|
i = _g
|
|
_g = (_g + 1)
|
|
_this = (splitArray[i] if i >= 0 and i < len(splitArray) else None)
|
|
splitByEqual = _this.split("=")
|
|
key = (splitByEqual[0] if 0 < len(splitByEqual) else None)
|
|
v = xrfragment_Value()
|
|
if (len(splitByEqual) > 1):
|
|
_this1 = regexPlus.split((splitByEqual[1] if 1 < len(splitByEqual) else None))
|
|
value = python_lib_urllib_Parse.unquote(" ".join([python_Boot.toString1(x1,'') for x1 in _this1]))
|
|
xrfragment_Url.guessType(v,value)
|
|
if (len(value.split("|")) > 1):
|
|
v.args = list()
|
|
args = value.split("|")
|
|
_g2 = 0
|
|
_g3 = len(args)
|
|
while (_g2 < _g3):
|
|
i1 = _g2
|
|
_g2 = (_g2 + 1)
|
|
x = xrfragment_Value()
|
|
xrfragment_Url.guessType(x,(args[i1] if i1 >= 0 and i1 < len(args) else None))
|
|
_this2 = v.args
|
|
_this2.append(x)
|
|
setattr(resultMap,(("_hx_" + key) if ((key in python_Boot.keywords)) else (("_hx_" + key) if (((((len(key) > 2) and ((ord(key[0]) == 95))) and ((ord(key[1]) == 95))) and ((ord(key[(len(key) - 1)]) != 95)))) else key)),v)
|
|
return resultMap
|
|
|
|
@staticmethod
|
|
def guessType(v,_hx_str):
|
|
isColor = EReg("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$","")
|
|
isInt = EReg("^[0-9]+$","")
|
|
isFloat = EReg("^[0-9]+\\.[0-9]+$","")
|
|
v.string = _hx_str
|
|
if (len(_hx_str.split(",")) > 1):
|
|
xyz = _hx_str.split(",")
|
|
if (len(xyz) > 0):
|
|
v.x = Std.parseFloat((xyz[0] if 0 < len(xyz) else None))
|
|
if (len(xyz) > 1):
|
|
v.y = Std.parseFloat((xyz[1] if 1 < len(xyz) else None))
|
|
if (len(xyz) > 2):
|
|
v.z = Std.parseFloat((xyz[2] if 2 < len(xyz) else None))
|
|
isColor.matchObj = python_lib_Re.search(isColor.pattern,_hx_str)
|
|
if (isColor.matchObj is not None):
|
|
v.color = _hx_str
|
|
isFloat.matchObj = python_lib_Re.search(isFloat.pattern,_hx_str)
|
|
if (isFloat.matchObj is not None):
|
|
v.float = Std.parseFloat(_hx_str)
|
|
isInt.matchObj = python_lib_Re.search(isInt.pattern,_hx_str)
|
|
if (isInt.matchObj is not None):
|
|
v.int = Std.parseInt(_hx_str)
|
|
|
|
Math.NEGATIVE_INFINITY = float("-inf")
|
|
Math.POSITIVE_INFINITY = float("inf")
|
|
Math.NaN = float("nan")
|
|
Math.PI = python_lib_Math.pi
|
|
|
|
python_Boot.keywords = set(["and", "del", "from", "not", "with", "as", "elif", "global", "or", "yield", "assert", "else", "if", "pass", "None", "break", "except", "import", "raise", "True", "class", "exec", "in", "return", "False", "continue", "finally", "is", "try", "def", "for", "lambda", "while"])
|
|
python_Boot.prefixLength = len("_hx_")
|
|
|
|
Test.main()
|