def generate(mrgeo, gateway, gateway_client):
global _initialized
if _initialized:
# Make sure the object have the proper code in them. In case somewhere we've made a new mrgeo object
for method_name, code in _mapop_code.items():
if not hasattr(mrgeo, method_name):
setattr(mrgeo, method_name,
code.compile(method_name).get(method_name))
for method_name, code in _rastermapop_code.items():
if not hasattr(RasterMapOp, method_name):
setattr(RasterMapOp, method_name,
code.compile(method_name).get(method_name))
for method_name, code in _vectormapop_code.items():
if not hasattr(VectorMapOp, method_name):
setattr(VectorMapOp, method_name,
code.compile(method_name).get(method_name))
return
jvm = gateway.jvm
client = gateway_client
java_import(jvm, "org.mrgeo.job.*")
java_import(jvm, "org.mrgeo.mapalgebra.MapOpFactory")
java_import(jvm, "org.mrgeo.mapalgebra.raster.RasterMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.vector.VectorMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.raster.MrsPyramidMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.IngestImageMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.ExportMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.PointsMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.MapOp")
java_import(jvm, "org.mrgeo.utils.SparkUtils")
java_import(jvm, "org.mrgeo.hdfs.utils.HadoopFileUtils")
java_import(jvm, "org.mrgeo.data.*")
mapops = jvm.MapOpFactory.getMapOpClasses()
for rawmapop in mapops:
mapop = str(rawmapop.getCanonicalName().rstrip('$'))
# Skip IngestImageMapOp because there is an explicit method defined in
# MrGeo class for ingesting an image, and _get_instance_type will raise
# an exception when run against that map op.
if not mapop.endswith(".IngestImageMapOp") and not mapop.endswith(
".InlineCsvMapOp"):
java_import(jvm, mapop)
cls = JavaClass(mapop, gateway_client=client)
signatures = jvm.MapOpFactory.getSignatures(mapop)
instance = _get_instance_type(signatures, gateway, cls, mapop)
# for s in signatures:
# print("signature: " + s)
for method in cls.register():
ooCodes = None
procCodes = None
if method is not None:
name = method.strip().lower()
if len(name) > 0:
if name in _reserved:
# print("reserved: " + name)
continue
elif name in _operators:
# print("operator: " + name)
ooCodes = _generate_operator_code(
mapop, name, signatures, instance)
else:
# print("method: " + name)
ooCodes = _generate_oo_method_code(
gateway, client, mapop, name, signatures,
instance)
procCodes = _generate_procedural_method_code(
gateway, client, mapop, name, signatures,
instance)
if ooCodes is not None:
for method_name, code in ooCodes.items():
# if method_name == "export":
# print(code.generate(), file=sys.stderr)
if instance == 'RasterMapOp':
_rastermapop_code[method_name] = code
setattr(RasterMapOp, method_name,
code.compile(method_name).get(method_name))
elif instance == "VectorMapOp":
_vectormapop_code[method_name] = code
setattr(VectorMapOp, method_name,
code.compile(method_name).get(method_name))
elif is_instance_of(gateway, cls, jvm.MapOp):
# _mapop_code[method_name] = code
_rastermapop_code[method_name] = code
setattr(RasterMapOp, method_name,
code.compile(method_name).get(method_name))
_vectormapop_code[method_name] = code
setattr(VectorMapOp, method_name,
code.compile(method_name).get(method_name))
if procCodes is not None:
for method_name, code in procCodes.items():
print(method_name)
_mapop_code[method_name] = code
setattr(mrgeo, method_name,
code.compile(method_name).get(method_name))
_initialized = True
print("add: " + str(hasattr(mrgeo, "add")))
def _load_mapops(self):
jvm = self.gateway.jvm
client = self.gateway._gateway_client
java_import(jvm, "org.mrgeo.job.*")
java_import(jvm, "org.mrgeo.mapalgebra.MapOpFactory")
java_import(jvm, "org.mrgeo.mapalgebra.raster.RasterMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.raster.MrsPyramidMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.ExportMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.vector.VectorMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.MapOp")
java_import(jvm, "org.mrgeo.utils.SparkUtils")
java_import(jvm, "org.mrgeo.data.*")
mapops = jvm.MapOpFactory.getMapOpClasses()
for rawmapop in mapops:
mapop = str(rawmapop.getCanonicalName().rstrip('$'))
java_import(jvm, mapop)
cls = JavaClass(mapop, gateway_client=client)
if self.is_instance_of(cls, jvm.RasterMapOp):
instance = 'RasterMapOp'
elif self.is_instance_of(cls, jvm.VectorMapOp):
instance = 'VectorMapOp'
elif self.is_instance_of(cls, jvm.MapOp):
instance = "MapOp"
else:
# raise Exception("mapop (" + mapop + ") is not a RasterMapOp, VectorMapOp, or MapOp")
print("mapop (" + mapop + ") is not a RasterMapOp, VectorMapOp, or MapOp")
continue
signatures = jvm.MapOpFactory.getSignatures(mapop)
for method in cls.register():
codes = None
if method is not None:
name = method.strip().lower()
if len(name) > 0:
if name in self.reserved:
# print("reserved: " + name)
continue
elif name in self.operators:
# print("operator: " + name)
codes = self._generate_operator_code(mapop, name, signatures, instance)
else:
# print("method: " + name)
codes = self._generate_method_code(mapop, name, signatures, instance)
if codes is not None:
for method_name, code in codes.iteritems():
# print(code)
compiled = {}
exec code in compiled
if instance == 'RasterMapOp':
setattr(RasterMapOp, method_name, compiled.get(method_name))
elif instance == "VectorMapOp":
# setattr(VectorMapOp, method_name, compiled.get(method_name))
pass
elif self.is_instance_of(cls, jvm.MapOp):
setattr(RasterMapOp, method_name, compiled.get(method_name))
def generate(gateway, gateway_client):
global _initialized
if _initialized:
return
jvm = gateway.jvm
client = gateway_client
java_import(jvm, "org.mrgeo.job.*")
java_import(jvm, "org.mrgeo.mapalgebra.MapOpFactory")
java_import(jvm, "org.mrgeo.mapalgebra.raster.RasterMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.vector.VectorMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.raster.MrsPyramidMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.IngestImageMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.ExportMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.PointsMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.MapOp")
java_import(jvm, "org.mrgeo.utils.SparkUtils")
java_import(jvm, "org.mrgeo.hdfs.utils.HadoopFileUtils")
java_import(jvm, "org.mrgeo.data.*")
mapops = jvm.MapOpFactory.getMapOpClasses()
for rawmapop in mapops:
mapop = str(rawmapop.getCanonicalName().rstrip('$'))
# Skip IngestImageMapOp because there is an explicit method defined in
# MrGeo class for ingesting an image, and _get_instance_type will raise
# an exception when run against that map op.
if not mapop.endswith(".IngestImageMapOp") and not mapop.endswith(".InlineCsvMapOp"):
java_import(jvm, mapop)
cls = JavaClass(mapop, gateway_client=client)
signatures = jvm.MapOpFactory.getSignatures(mapop)
instance = _get_instance_type(signatures, gateway, cls, mapop)
# for s in signatures:
# print("signature: " + s)
for method in cls.register():
codes = None
if method is not None:
name = method.strip().lower()
if len(name) > 0:
if name in _reserved:
# print("reserved: " + name)
continue
elif name in _operators:
# print("operator: " + name)
codes = _generate_operator_code(mapop, name, signatures, instance)
else:
# print("method: " + name)
codes = _generate_method_code(gateway, client, mapop, name, signatures, instance)
if codes is not None:
for method_name, code in codes.items():
# print(code)
compiled = {}
exec code in compiled
if instance == 'RasterMapOp':
_rastermapop_code[method_name] = code
setattr(RasterMapOp, method_name, compiled.get(method_name))
elif instance == "VectorMapOp":
_vectormapop_code[method_name] = code
setattr(VectorMapOp, method_name, compiled.get(method_name))
elif is_instance_of(gateway, cls, jvm.MapOp):
_mapop_code[method_name] = code
setattr(RasterMapOp, method_name, compiled.get(method_name))
setattr(VectorMapOp, method_name, compiled.get(method_name))
_initialized = True
def _load_mapops(self):
jvm = self.gateway.jvm
client = self.gateway._gateway_client
java_import(jvm, "org.mrgeo.job.*")
java_import(jvm, "org.mrgeo.mapalgebra.MapOpFactory")
java_import(jvm, "org.mrgeo.mapalgebra.raster.RasterMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.raster.MrsPyramidMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.ExportMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.vector.VectorMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.MapOp")
java_import(jvm, "org.mrgeo.utils.SparkUtils")
java_import(jvm, "org.mrgeo.data.*")
mapops = jvm.MapOpFactory.getMapOpClasses()
for rawmapop in mapops:
mapop = str(rawmapop.getCanonicalName().rstrip('$'))
java_import(jvm, mapop)
cls = JavaClass(mapop, gateway_client=client)
if self.is_instance_of(cls, jvm.RasterMapOp):
instance = 'RasterMapOp'
elif self.is_instance_of(cls, jvm.VectorMapOp):
instance = 'VectorMapOp'
elif self.is_instance_of(cls, jvm.MapOp):
instance = "MapOp"
else:
# raise Exception("mapop (" + mapop + ") is not a RasterMapOp, VectorMapOp, or MapOp")
print("mapop (" + mapop +
") is not a RasterMapOp, VectorMapOp, or MapOp")
continue
signatures = jvm.MapOpFactory.getSignatures(mapop)
for method in cls.register():
codes = None
if method is not None:
name = method.strip().lower()
if len(name) > 0:
if name in self.reserved:
# print("reserved: " + name)
continue
elif name in self.operators:
# print("operator: " + name)
codes = self._generate_operator_code(
mapop, name, signatures, instance)
else:
# print("method: " + name)
codes = self._generate_method_code(
mapop, name, signatures, instance)
if codes is not None:
for method_name, code in codes.iteritems():
# print(code)
compiled = {}
exec code in compiled
if instance == 'RasterMapOp':
setattr(RasterMapOp, method_name,
compiled.get(method_name))
elif instance == "VectorMapOp":
# setattr(VectorMapOp, method_name, compiled.get(method_name))
pass
elif self.is_instance_of(cls, jvm.MapOp):
setattr(RasterMapOp, method_name,
compiled.get(method_name))
def generate(gateway, gateway_client):
global _initialized
if _initialized:
return
jvm = gateway.jvm
client = gateway_client
java_import(jvm, "org.mrgeo.job.*")
java_import(jvm, "org.mrgeo.mapalgebra.MapOpFactory")
java_import(jvm, "org.mrgeo.mapalgebra.raster.RasterMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.vector.VectorMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.raster.MrsPyramidMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.IngestImageMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.ExportMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.PointsMapOp")
java_import(jvm, "org.mrgeo.mapalgebra.MapOp")
java_import(jvm, "org.mrgeo.utils.SparkUtils")
java_import(jvm, "org.mrgeo.hdfs.utils.HadoopFileUtils")
java_import(jvm, "org.mrgeo.data.*")
mapops = jvm.MapOpFactory.getMapOpClasses()
for rawmapop in mapops:
mapop = str(rawmapop.getCanonicalName().rstrip('$'))
java_import(jvm, mapop)
cls = JavaClass(mapop, gateway_client=client)
if is_instance_of(gateway, cls, jvm.RasterMapOp):
instance = 'RasterMapOp'
elif is_instance_of(gateway, cls, jvm.VectorMapOp):
instance = 'VectorMapOp'
elif is_instance_of(gateway, cls, jvm.MapOp):
instance = "MapOp"
else:
# raise Exception("mapop (" + mapop + ") is not a RasterMapOp, VectorMapOp, or MapOp")
print("mapop (" + mapop + ") is not a RasterMapOp, VectorMapOp, or MapOp")
continue
signatures = jvm.MapOpFactory.getSignatures(mapop)
# for s in signatures:
# print("signature: " + s)
for method in cls.register():
codes = None
if method is not None:
name = method.strip().lower()
if len(name) > 0:
if name in _reserved:
# print("reserved: " + name)
continue
elif name in _operators:
# print("operator: " + name)
codes = _generate_operator_code(mapop, name, signatures, instance)
else:
# print("method: " + name)
codes = _generate_method_code(gateway, client, mapop, name, signatures, instance)
if codes is not None:
for method_name, code in codes.items():
# print(code)
compiled = {}
exec code in compiled
if instance == 'RasterMapOp':
_rastermapop_code[method_name] = code
setattr(RasterMapOp, method_name, compiled.get(method_name))
elif instance == "VectorMapOp":
_vectormapop_code[method_name] = code
setattr(VectorMapOp, method_name, compiled.get(method_name))
elif is_instance_of(gateway, cls, jvm.MapOp):
_mapop_code[method_name] = code
setattr(RasterMapOp, method_name, compiled.get(method_name))
setattr(VectorMapOp, method_name, compiled.get(method_name))
_initialized = True
