def __call__(self, state, scope, pos, paramTypes, original, replacement):
if isinstance(original, bytes):
original = bytesToString(original)
if isinstance(replacement, bytes):
replacement = bytesToString(replacement)
length = min(len(original), len(replacement))
return replacement[0:length] + original[length:len(original)]
def __call__(self, state, scope, pos, paramTypes, haystack, pattern,
replacement):
original = haystack
if isinstance(original, bytes):
original = bytesToString(original)
haystack, pattern, to = convert(haystack, pattern, paramTypes[0])
if isinstance(replacement, bytes):
replacement = bytesToString(replacement)
re = Regexer(haystack, pattern, self.errcodeBase + 0, self.name, pos)
found = re.search(0)
region = re.getRegion()
beg = 0
end = region.beg[0]
out = ""
if found:
while found:
out = out + to(haystack[beg:end]) + replacement
beg = region.end[0]
found = re.search(beg)
region = re.getRegion()
end = region.beg[0]
if beg != len(haystack):
out = out + to(haystack[beg:])
else:
out = original
re.free()
return out
def __call__(self, state, scope, pos, paramTypes, x):
try:
out_bytes = codecs.encode(x, self.codec, "strict")
return bytesToString(out_bytes)
except UnicodeEncodeError:
raise PFARuntimeException("invalid string", self.errcodeBase + 0,
self.name, pos)
def __call__(self, state, scope, pos, paramTypes, size, *args):
if size <= 0:
raise PFARuntimeException("size must be positive",
self.errcodeBase + 0, self.name, pos)
if len(args) == 0:
return "".join(
chr(state.rand.randint(0, 255)) for x in range(size))
elif len(args) == 1:
if len(args[0]) == 0:
raise PFARuntimeException("population must be non-empty",
self.errcodeBase + 3, self.name, pos)
if isinstance(args[0], str):
population = list(args[0])
elif isinstance(args[0], bytes):
population = list(bytesToString(args[0]))
return "".join(population[state.rand.randint(0,
len(args[0]) - 1)]
for x in range(size))
else:
low, high = args
if high <= low:
raise PFARuntimeException("high must be greater than low",
self.errcodeBase + 1, self.name, pos)
if low < 0 or low > 255 or high < 0 or high > 256:
raise PFARuntimeException("invalid byte", self.errcodeBase + 2,
self.name, pos)
return "".join(
chr(state.rand.randint(low, high - 1)) for x in range(size))
def __call__(self, state, scope, pos, paramTypes, x):
schema = avro.schema.Parse(json.dumps(paramTypes[0]))
x = untagUnion(x, paramTypes[0])
bytes_io = io.BytesIO()
writer = DatumWriter(schema)
writer.write(x, BinaryEncoder(bytes_io))
bytes_io.flush()
return bytesToString(bytes_io.getvalue())
def __call__(self, state, scope, pos, paramTypes, s):
try:
if re.match("^[A-Za-z0-9\+/]*=*$", s) is None:
raise TypeError
out = base64.b64decode(s)
return bytesToString(out)
except TypeError:
raise PFARuntimeException("invalid base64", self.errcodeBase + 0,
self.name, pos)
def __call__(self, state, scope, pos, paramTypes, x, start, end,
replacement):
if isinstance(replacement, str):
replacement = stringToBytes(replacement)
if isinstance(x, str):
x = stringToBytes(x)
normStart, normEnd = startEnd(len(x), start, end)
before = x[:normStart]
after = x[normEnd:]
return bytesToString(before + replacement + after)
def testBase64(self):
self.assertEqual(
EngineConfig(
"test", Method.MAP, AvroInt(), AvroString(), [],
[LiteralBase64(bytesToString("hello".encode("utf-8")))], [],
{}, None, None, {}, {}, None, None, None, {}, {}),
jsonToAst('''{
"name": "test",
"input": "int",
"output": "string",
"action": [{"base64": "aGVsbG8="}]
}'''))
def convert(haystack, pattern, paramType0):
if paramType0 == "string":
return haystack.encode("utf-8"), pattern.encode(
"utf-8"), lambda x: x.decode("utf-8")
else:
if isinstance(haystack, bytes):
cnvtHaystack = haystack
else:
cnvtHaystack = stringToBytes(haystack)
if isinstance(pattern, bytes):
cnvtPattern = pattern
else:
cnvtPattern = stringToBytes(pattern)
return cnvtHaystack, cnvtPattern, lambda x: bytesToString(x)
def __call__(self, state, scope, pos, paramTypes, haystack, pattern,
replacement):
haystack, pattern, to = convert(haystack, pattern, paramTypes[0])
if isinstance(replacement, bytes):
replacement = bytesToString(replacement)
re = Regexer(haystack, pattern, self.errcodeBase + 0, self.name, pos)
found = re.search(0)
region = re.getRegion()
if found:
out = to(haystack[:region.beg[0]]) + replacement + to(
haystack[region.end[0]:])
else:
out = to(haystack)
re.free()
return out
def __call__(self, state, scope, pos, paramTypes, x, start, end):
if isinstance(x, str):
return x[start:end]
else:
return bytesToString(x[start:end])
def __call__(self, state, scope, pos, paramTypes, x):
if isinstance(x, bytes):
return bytesToString(x)
return x
def testBase64(self):
self.assertEqual(json.loads(LiteralBase64(bytesToString("hello".encode('utf-8'))).toJson(lineNumbers=False)), json.loads('''{"base64":"aGVsbG8="}'''))
self.assertEqual(json.loads(LiteralBase64(bytesToString('Δ'.encode('utf-8'))).toJson(lineNumbers=False)), json.loads('''{"base64":"zpQ="}'''))