def loadOdbcRequestDataset(request, vdm):
try:
logging.info("Initializing a connection.")
connection = pyodbc.connect(request.connectionString)
except Exception as e:
raise UserCausedException("Failed to connect: %s" % e)
cursor = connection.cursor()
# Attempt the query.
queries = request.query
for query in queries:
try:
logging.info("Executing query: %s", query)
cursor = cursor.execute(query)
except Exception as e:
logging.error("Query \"%s\" failed. Closing connection.", query)
connection.close()
raise UserCausedException("ODBC query failed: %s | Message: %s" %
(query, e))
columns, names = convertListOfTuplesToTupleOfVectors(cursor, vdm)
tr = ForaNative.CreateNamedTuple(tuple(columns), names)
connection.close()
return tr
def loadExternalDatasetAsForaValue(datasetDescriptor, vdm):
if datasetDescriptor.isTestDataset():
return normalComputationResult(ForaNative.ImplValContainer(
time.time()))
elif datasetDescriptor.isExceptionThrowingDataset():
return ForaNative.ComputationResult.Exception(
ForaNative.ImplValContainer("ExceptionThrowingDataset"),
ForaNative.ImplValContainer())
elif datasetDescriptor.isFailureInducingDataset():
raise DatasetLoadException("FailureInducingDataset")
elif datasetDescriptor.isHttpRequestDataset():
t0 = time.time()
data, statusCode = loadHttpRequestDataset(
datasetDescriptor.asHttpRequestDataset.dataset)
logging.info("Took %s to get %s bytes from loadHttpRequestDataset",
time.time() - t0, len(data))
return normalComputationResult(
ForaNative.CreateNamedTuple(
(vdm.loadByteArrayIntoNewVector(data),
ForaNative.ImplValContainer(int(statusCode))),
("result", "status")))
elif datasetDescriptor.isOdbcRequestDataset():
try:
logging.info("Attempting to initialize an ODBC request.")
data = loadOdbcRequestDataset(
datasetDescriptor.asOdbcRequestDataset.dataset, vdm)
return normalComputationResult(data)
except Exception as e:
raise UserCausedException("ODBC request failed: %s" % e.message)
else:
raise DatasetLoadException("Can't handle dataset %s" %
datasetDescriptor)
def convertUnresolvedVarWithPosition(self, objectId, arg):
# arg should be a TypeDescription.UnresolvedVarWithPosition
tr = ForaNative.CreateNamedTuple(
((arg.varname, arg.lineno, arg.col_offset),),
("PyforaNameError",))
self.convertedValues[objectId] = tr
return tr
def convertUnconvertibleValue(self, objectId, module_path):
# uh, yeah ... this guy probably needs a better name. Sorry.
tr = ForaNative.CreateNamedTuple(
(tuple(module_path) if module_path is not None else None,),
("PyforaUnconvertibleValue",))
self.convertedValues[objectId] = tr
return tr
def convertClassInstanceDescription(self, objectId, classInstanceDescription, convertedValues):
classMemberNameToImplVal = {
classMemberName: convertedValues[memberId]
for classMemberName, memberId in
classInstanceDescription.classMemberNameToClassMemberId.iteritems()
}
classImplVal = convertedValues[classInstanceDescription.classId]
if classImplVal.isSymbol():
convertedValues[objectId] = classImplVal
return
memberNames = tuple(sorted(name for name in classMemberNameToImplVal.iterkeys()))
memberValues = tuple(classMemberNameToImplVal[name] for name in memberNames)
convertedValueOrNone = ForaNative.simulateApply(
ForaNative.ImplValContainer(
(classImplVal,
Symbol_CreateInstance,
ForaNative.CreateNamedTuple(memberValues, memberNames))
)
)
if convertedValueOrNone is None:
raise pyfora.PythonToForaConversionError(
("An internal error occurred: " +
"function stage 1 simulation unexpectedly returned None")
)
convertedValues[objectId] = convertedValueOrNone
def _getFunctionExpressionFromWithBlockDescription(
self, withBlockDescription, objectIdToObjectDefinition):
nativeWithBodyAst = self._getNativePythonFunctionDefFromWithBlockDescription(
withBlockDescription, objectIdToObjectDefinition)
sourcePath = objectIdToObjectDefinition[
withBlockDescription.sourceFileId].path
sourceText = objectIdToObjectDefinition[
withBlockDescription.sourceFileId].text
newMetadata = ForaNative.CreateNamedTuple(
(ForaNative.encodeImplvalAsEmptyObjectMetadata(
ForaNative.ImplValContainer(sourceText)),
ForaNative.ImplValContainer(sourcePath),
ForaNative.ImplValContainer(withBlockDescription.lineNumber)),
("sourceText", "sourcePath", "sourceLine"))
foraFunctionExpression = \
self.nativeConverter.convertPythonAstWithBlockFunctionDefToForaOrParseError(
nativeWithBodyAst.asFunctionDef,
nativeWithBodyAst.extent,
ForaNative.CodeDefinitionPoint.ExternalFromStringList([sourcePath]),
[x.split(".")[0] for x in withBlockDescription.freeVariableMemberAccessChainsToId],
newMetadata
)
if isinstance(foraFunctionExpression,
ForaNative.PythonToForaConversionError):
raise convertNativePythonToForaConversionError(
foraFunctionExpression, objectIdToObjectDefinition[
withBlockDescription.sourceFileId].path)
return foraFunctionExpression
def _convertPyClassOrFunctionDefinitionToForaFunctionExpression(
self, classOrFunctionDefinition, objectIdToObjectDefinition):
pyAst = self._convertClassOrFunctionDefinitionToNativePyAst(
classOrFunctionDefinition, objectIdToObjectDefinition)
assert pyAst is not None
sourcePath = objectIdToObjectDefinition[
classOrFunctionDefinition.sourceFileId].path
sourceText = objectIdToObjectDefinition[
classOrFunctionDefinition.sourceFileId].text
newMetadata = ForaNative.CreateNamedTuple(
(ForaNative.encodeImplvalAsEmptyObjectMetadata(
ForaNative.ImplValContainer(sourceText)),
ForaNative.ImplValContainer(sourcePath),
ForaNative.ImplValContainer(pyAst.extent.start.line)),
("sourceText", "sourcePath", "sourceLine"))
tr = None
if isinstance(classOrFunctionDefinition,
TypeDescription.FunctionDefinition):
if isinstance(
pyAst,
ForaNative.PythonAstStatement) and pyAst.isFunctionDef():
tr = self.nativeConverter.convertPythonAstFunctionDefToForaOrParseError(
pyAst.asFunctionDef, pyAst.extent,
ForaNative.CodeDefinitionPoint.ExternalFromStringList(
[sourcePath]), newMetadata)
else:
assert pyAst.isLambda()
tr = self.nativeConverter.convertPythonAstLambdaToForaOrParseError(
pyAst.asLambda, pyAst.extent,
ForaNative.CodeDefinitionPoint.ExternalFromStringList(
[sourcePath]), newMetadata)
elif isinstance(classOrFunctionDefinition,
TypeDescription.ClassDefinition):
objectIdToFreeVar = {
v: k
for k, v in classOrFunctionDefinition.
freeVariableMemberAccessChainsToId.iteritems()
}
baseClasses = [
objectIdToFreeVar[baseId].split('.')
for baseId in classOrFunctionDefinition.baseClassIds
]
tr = self.nativeConverter.convertPythonAstClassDefToForaOrParseError(
pyAst.asClassDef, pyAst.extent,
ForaNative.CodeDefinitionPoint.ExternalFromStringList(
[sourcePath]), baseClasses, newMetadata)
else:
assert False
if isinstance(tr, ForaNative.PythonToForaConversionError):
raise convertNativePythonToForaConversionError(tr, sourcePath)
return tr
