def swap(self, context):
swapped = DictValue(TextType.instance, True)
for k,v in self.value.items():
if not isinstance(v, TextValue):
v = TextValue(v.getMember(context, "text", False))
swapped.setItem(context, v, k)
swapped.mutable = False
return swapped
def getMemberValue(self, context, name, autoCreate=False):
from prompto.value.TextValue import TextValue
if "text" == name:
return TextValue(str(self))
elif "json" == name:
val = json.dumps(self.toJsonNode(), separators=(',', ':'))
return TextValue(val)
else:
raise Exception("No member support for " + type(self).__name__)
def parseCmdLineArgs(cmdLineArgs):
try:
args = CmdLineParser.parseCmdLine(cmdLineArgs)
valueArgs = dict()
for key, value in args:
valueArgs[TextValue(key)] = TextValue(value)
dict_ = DictValue(TextType.instance, False, value=valueArgs)
return ValueExpression(Interpreter.argsType, dict_)
except:
# TODO
return DictLiteral(False)
def Multiply(self, context, value):
from prompto.value.IntegerValue import IntegerValue
if isinstance(value, IntegerValue):
from prompto.value.TextValue import TextValue
count = value.IntegerValue()
if count < 0:
raise SyntaxError("Negative repeat count:" + count)
if count == 0:
return TextValue("")
if count == 1:
return TextValue(self.value)
return TextValue(self.value * count)
else:
raise SyntaxError("Illegal: Character * " + type(value).__name__)
def interpret(self, context):
from prompto.value.TextValue import TextValue
items = self.getItems(context)
items = [str(item) for item in items]
delimiter = context.getValue("delimiter").value
joined = delimiter.join(items)
return TextValue(joined)
def getMemberValue(self, context, name, autoCreate):
if "name" == name:
return TextValue(self.getName())
elif "value" == name:
return self.expression.interpret(context)
else:
return super(NativeSymbol, self).getMemberValue(context, name, autoCreate)
def interpret(self, context):
from prompto.value.TextValue import TextValue
value = self.getValue(context).value
format = context.getValue("format").value
format = translateFormat(format)
text = format.format(value)
return TextValue(text)
def convertPythonValueToPromptoValue(self, context, value, returnType):
from prompto.value.TextValue import TextValue
if isinstance(value, basestring):
return TextValue(value)
else:
return super(TextType, self).convertPythonValueToPromptoValue(
context, value, returnType) # TODO for now
def interpret(self, context):
from prompto.value.TextValue import TextValue
from prompto.value.ListValue import ListValue
value = self.getValue(context).value
sep = context.getValue("separator").value
parts = [TextValue(part) for part in value.split(sep)]
return ListValue(TextType.instance, parts, mutable=False)
def interpret(self, context):
from prompto.value.TextValue import TextValue
value = self.getValue(context).value
toReplace = context.getValue("toReplace").value
replaceWith = context.getValue("replaceWith").value
value = value.replace(toReplace, replaceWith)
return TextValue(value)
def getMemberValue(self, context, name, autoCreate=False):
from prompto.value.IntegerValue import IntegerValue
if "year" == name:
return IntegerValue(self.value.year)
elif "month" == name:
return IntegerValue(self.value.month)
elif "dayOfMonth" == name:
return IntegerValue(self.value.day)
elif "dayOfYear" == name:
day = 1 + self.value.toordinal() - date(self.value.year, 1, 1).toordinal()
return IntegerValue(day)
elif "hour" == name:
return IntegerValue(self.value.hour)
elif "minute" == name:
return IntegerValue(self.value.minute)
elif "second" == name:
return IntegerValue(self.value.second)
elif "millisecond" == name:
return IntegerValue(self.value.microsecond // 1000)
elif "tzOffset" == name:
return IntegerValue(0) # self.value.getZone().toTimeZone().getRawOffset() / 1000)
elif "tzName" == name:
from prompto.value.TextValue import TextValue
return TextValue("Z") # self.value.getZone().toTimeZone().getDisplayName())
elif "date" == name:
from prompto.value.DateValue import DateValue
return DateValue(years=self.value.year, months=self.value.month, days=self.value.day)
elif "time" == name:
from prompto.value.TimeValue import TimeValue
return TimeValue(hours=self.value.hour, minutes=self.value.minute, seconds=self.value.second, millis=self.value.microsecond // 1000)
else:
return super().getMemberValue(context, name, autoCreate)
def convertPythonValueToPromptoValue(self, context, value, returnType):
from prompto.value.TextValue import TextValue
if isinstance(value, str):
return TextValue(value)
else:
return super().convertPythonValueToPromptoValue(
context, value, returnType)
def convertElementValue(self, element):
hasAttributes = self.keepAttributes and element.hasAttributes()
hasChildren = self.elementHasChildren(element)
if hasAttributes or hasChildren:
result = DocumentValue()
if self.keepAttributes:
for attr in element.attributes:
result.setMember(None, "@" + attr.name, TextValue(attr.value))
if hasChildren:
for node in element.childNodes:
if isinstance(node, minidom.Element):
self.convertElement(result, node)
else:
result.setMember(None, "$value", element.firstChild.nodeValue)
return result
else:
return TextValue(element.firstChild.nodeValue)
def interpretPromotion(self, item):
if item is None:
return item
if DecimalType.instance == self.itemType and item.itype == IntegerType.instance:
return DecimalValue(item.DecimalValue())
elif TextType.instance == self.itemType and item.itype == CharacterType.instance:
return TextValue(item.value)
else:
return item
def getMemberValue(self, context, name, autoCreate=False):
if "count" == name:
return IntegerValue(self.size())
elif "keys" == name:
res = set([TextValue(k) for k in self.value.keys()])
return SetValue(TextType.instance, items=res)
elif "values" == name:
return ListValue(self.itype.itemType, items=self.value.values())
else:
return super().getMemberValue(context, name, autoCreate)
def getMemberValue(self, context, name, autoCreate=False):
if "major" == name:
return IntegerValue(self.major)
elif "minor" == name:
return IntegerValue(self.minor)
elif "fix" == name:
return IntegerValue(self.fix)
elif "qualifier" == name:
return TextValue(self.qualifierString())
else:
return super().getMemberValue(context, name, autoCreate)
def doGetMember(self, context, attrName, allowGetter):
getter = self.declaration.findGetter(context, attrName) if allowGetter else None
if getter is not None:
context = context.newInstanceContext(self, None).newChildContext()
return getter.interpret(context)
elif self.declaration.hasAttribute(context, attrName) or "dbId" == attrName:
return self.values.get(attrName, NullValue.instance)
elif "text" == attrName:
return TextValue(unicode(self))
else:
return NullValue.instance
def getMemberValue(self, context, name, autoCreate=False):
if "count" == name:
return IntegerValue(self.size())
elif "keys" == name:
res = set([TextValue(k) for k in self.values.keys()])
return SetValue(TextType.instance, items=res)
elif "values" == name:
return ListValue(AnyType.instance, items=self.values.values())
else:
result = self.values.get(name, None)
if result is not None:
return result
elif "text" == name:
return TextValue(str(self))
elif autoCreate:
result = DocumentValue()
self.values[name] = result
return result
else:
return NullValue.instance
def makeInstance(self, context):
if self.instance is None:
from prompto.value.TextValue import TextValue
instance = self.itype.newInstance(context)
instance.mutable = True
if self.arguments != None:
context = context.newLocalContext()
for argument in self.arguments:
value = argument.getExpression().interpret(context)
instance.setMember(context, argument.getName(), value)
instance.setMember(context, "name", TextValue(self.symbol))
instance.mutable = False
self.instance = instance
return self.instance
def readJSONField(self, context, node, parts):
if node is None:
return NullValue.instance
elif isinstance(node, bool):
return BooleanValue.ValueOf(node)
elif isinstance(node, int):
return IntegerValue(node)
elif isinstance(node, float):
return DecimalValue(node)
elif isinstance(node, str):
return TextValue(node)
elif isinstance(node, list):
raise Exception("list")
elif isinstance(node, dict):
raise Exception("dict")
elif isinstance(node, object):
raise Exception("object")
else:
raise Exception(str(type(node)))
def convert(obj):
if obj is None:
return NullValue.instance
elif inspect.isgenerator(obj):
return convert(list(obj))
elif isinstance(obj, list):
return convertList(obj)
elif isinstance(obj, dict):
return convertDocument(obj)
elif isinstance(obj, int):
return IntegerValue(obj)
elif isinstance(obj, float):
return DecimalValue(obj)
elif isinstance(obj, bool):
return BooleanValue(obj)
elif isinstance(obj, str):
return TextValue(obj)
else:
raise ReadWriteError("Cannot convert: " + type(obj).__name__)
def readBinary(self):
s = self.instance.readBinary()
return TextValue(s)
def __init__(self, key, value):
super(KVPValue, self).__init__(MissingType.instance)
self.key = TextValue(key)
self.value = value
def getKeys(self):
for k in iter(self.value.keys()):
yield TextValue(k)
def toDocumentValue(self, context):
from prompto.value.TextValue import TextValue
return TextValue(str(self))
def interpret(self, context):
from prompto.value.TextValue import TextValue
value = self.getValue(context).getStorableData()
return TextValue(value.strip())
def interpret(self, context):
from prompto.value.TextValue import TextValue
return TextValue(self.name)
def readLine(self):
s = self.instance.readLine()
return NullValue.instance if s is None else TextValue(s)
def interpret(self, context):
from prompto.value.TextValue import TextValue
s = unescape(self.text)
return TextValue(s)
def readFully(self):
s = self.instance.readFully()
return TextValue(s)