def renderWindowSerializer(parent, instance, objId, context, depth):
dependencies = []
rendererIds = []
rendererCollection = instance.GetRenderers()
for rIdx in range(rendererCollection.GetNumberOfItems()):
# Grab the next vtkRenderer
renderer = rendererCollection.GetItemAsObject(rIdx)
rendererId = getReferenceId(renderer)
rendererInstance = serializeInstance(
instance, renderer, rendererId, context, depth + 1
)
if rendererInstance:
dependencies.append(rendererInstance)
rendererIds.append(rendererId)
calls = context.buildDependencyCallList(
objId, rendererIds, "addRenderer", "removeRenderer"
)
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {"numberOfLayers": instance.GetNumberOfLayers()},
"dependencies": dependencies,
"calls": calls,
"mtime": instance.GetMTime(),
}
def propertySerializer(parent, propObj, propObjId, context, depth):
representation = (
propObj.GetRepresentation() if hasattr(propObj, "GetRepresentation") else 2
)
colorToUse = (
propObj.GetDiffuseColor() if hasattr(propObj, "GetDiffuseColor") else [1, 1, 1]
)
if representation == 1 and hasattr(propObj, "GetColor"):
colorToUse = propObj.GetColor()
return {
"parent": getReferenceId(parent),
"id": propObjId,
"type": class_name(propObj),
"properties": {
"representation": representation,
"diffuseColor": colorToUse,
"color": propObj.GetColor(),
"ambientColor": propObj.GetAmbientColor(),
"specularColor": propObj.GetSpecularColor(),
"edgeColor": propObj.GetEdgeColor(),
"ambient": propObj.GetAmbient(),
"diffuse": propObj.GetDiffuse(),
"specular": propObj.GetSpecular(),
"specularPower": propObj.GetSpecularPower(),
"opacity": propObj.GetOpacity(),
"interpolation": propObj.GetInterpolation(),
"edgeVisibility": 1 if propObj.GetEdgeVisibility() else 0,
"backfaceCulling": 1 if propObj.GetBackfaceCulling() else 0,
"frontfaceCulling": 1 if propObj.GetFrontfaceCulling() else 0,
"pointSize": propObj.GetPointSize(),
"lineWidth": propObj.GetLineWidth(),
"lighting": 1 if propObj.GetLighting() else 0,
},
}
def colorTransferFunctionSerializer(parent, instance, objId, context, depth):
nodes = []
for i in range(instance.GetSize()):
# x, r, g, b, midpoint, sharpness
node = [0, 0, 0, 0, 0, 0]
instance.GetNodeValue(i, node)
nodes.append(node)
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {
"clamping": 1 if instance.GetClamping() else 0,
"colorSpace": instance.GetColorSpace(),
"hSVWrap": 1 if instance.GetHSVWrap() else 0,
# 'nanColor': instance.GetNanColor(), # Breaks client
# 'belowRangeColor': instance.GetBelowRangeColor(), # Breaks client
# 'aboveRangeColor': instance.GetAboveRangeColor(), # Breaks client
# 'useAboveRangeColor': 1 if instance.GetUseAboveRangeColor() else 0,
# 'useBelowRangeColor': 1 if instance.GetUseBelowRangeColor() else 0,
"allowDuplicateScalars": 1 if instance.GetAllowDuplicateScalars() else 0,
"alpha": instance.GetAlpha(),
"vectorComponent": instance.GetVectorComponent(),
"vectorSize": instance.GetVectorSize(),
"vectorMode": instance.GetVectorMode(),
"indexedLookup": instance.GetIndexedLookup(),
"nodes": nodes,
},
}
def volumePropertySerializer(parent, propObj, propObjId, context, depth):
calls = []
dependencies = []
# Color handling
lut = propObj.GetRGBTransferFunction()
if lut:
lookupTableId = getReferenceId(lut)
lookupTableInstance = serializeInstance(
propObj, lut, lookupTableId, context, depth + 1
)
if lookupTableInstance:
dependencies.append(lookupTableInstance)
calls.append(["setRGBTransferFunction", [0, wrapId(lookupTableId)]])
# Piecewise handling
pwf = propObj.GetScalarOpacity()
if pwf:
pwfId = getReferenceId(pwf)
pwfInstance = serializeInstance(
propObj, pwf, pwfId, context, depth + 1
)
if pwfInstance:
dependencies.append(pwfInstance)
calls.append(["setScalarOpacity", [0, wrapId(pwfId)]])
return {
"parent": getReferenceId(parent),
"id": propObjId,
"type": class_name(propObj),
"properties": {
"independentComponents": propObj.GetIndependentComponents(),
"interpolationType": propObj.GetInterpolationType(),
"shade": propObj.GetShade(),
"ambient": propObj.GetAmbient(),
"diffuse": propObj.GetDiffuse(),
"specular": propObj.GetSpecular(),
"specularPower": propObj.GetSpecularPower(),
# "useLabelOutline": propObj.GetUseLabelOutline(),
# "labelOutlineThickness": propObj.GetLabelOutlineThickness(),
},
"calls": calls,
"dependencies": dependencies,
}
def cameraSerializer(parent, instance, objId, context, depth):
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {
"focalPoint": instance.GetFocalPoint(),
"position": instance.GetPosition(),
"viewUp": instance.GetViewUp(),
"clippingRange": instance.GetClippingRange(),
},
}
def polydataSerializer(parent, dataset, datasetId, context, depth, requested_fields = ["Normals", "TCoords"]):
if dataset and dataset.GetPoints():
properties = {}
# Points
points = getArrayDescription(dataset.GetPoints().GetData(), context)
points["vtkClass"] = "vtkPoints"
properties["points"] = points
# Verts
if dataset.GetVerts() and dataset.GetVerts().GetData().GetNumberOfTuples() > 0:
_verts = getArrayDescription(dataset.GetVerts().GetData(), context)
properties["verts"] = _verts
properties["verts"]["vtkClass"] = "vtkCellArray"
# Lines
if dataset.GetLines() and dataset.GetLines().GetData().GetNumberOfTuples() > 0:
_lines = getArrayDescription(dataset.GetLines().GetData(), context)
properties["lines"] = _lines
properties["lines"]["vtkClass"] = "vtkCellArray"
# Polys
if dataset.GetPolys() and dataset.GetPolys().GetData().GetNumberOfTuples() > 0:
_polys = getArrayDescription(dataset.GetPolys().GetData(), context)
properties["polys"] = _polys
properties["polys"]["vtkClass"] = "vtkCellArray"
# Strips
if (
dataset.GetStrips()
and dataset.GetStrips().GetData().GetNumberOfTuples() > 0
):
_strips = getArrayDescription(dataset.GetStrips().GetData(), context)
properties["strips"] = _strips
properties["strips"]["vtkClass"] = "vtkCellArray"
# Fields
properties["fields"] = []
extractRequiredFields(properties["fields"], parent, dataset, context, requested_fields)
return {
"parent": getReferenceId(parent),
"id": datasetId,
"type": class_name(dataset),
"properties": properties,
}
if context.debugAll:
print("This dataset has no points!")
return None
def digest(array):
objId = getReferenceId(array)
record = None
if objId in dataArrayShaMapping:
record = dataArrayShaMapping[objId]
if record and record["mtime"] == array.GetMTime():
return record["sha"]
record = {"sha": hashDataArray(array), "mtime": array.GetMTime()}
dataArrayShaMapping[objId] = record
return record["sha"]
def genericVolumeMapperSerializer(parent, mapper, mapperId, context, depth):
# This kind of mapper requires us to get 2 items: input data and lookup
# table
dataObject = None
dataObjectInstance = None
lookupTableInstance = None
calls = []
dependencies = []
if hasattr(mapper, "GetInputDataObject"):
mapper.GetInputAlgorithm().Update()
dataObject = mapper.GetInputDataObject(0, 0)
else:
if context.debugAll:
print("This mapper does not have GetInputDataObject method")
if dataObject:
dataObjectId = "%s-dataset" % mapperId
dataObjectInstance = serializeInstance(
mapper, dataObject, dataObjectId, context, depth + 1
)
if dataObjectInstance:
dependencies.append(dataObjectInstance)
calls.append(["setInputData", [wrapId(dataObjectId)]])
if dataObjectInstance:
return {
"parent": getReferenceId(parent),
"id": mapperId,
"type": class_name(mapper),
"properties": {
# VolumeMapper
"sampleDistance": mapper.GetSampleDistance(),
"imageSampleDistance": mapper.GetImageSampleDistance(),
# "maximumSamplesPerRay": mapper.GetMaximumSamplesPerRay(),
"autoAdjustSampleDistances": mapper.GetAutoAdjustSampleDistances(),
"blendMode": mapper.GetBlendMode(),
# "ipScalarRange": mapper.GetIpScalarRange(),
# "filterMode": mapper.GetFilterMode(),
# "preferSizeOverAccuracy": mapper.Get(),
},
"calls": calls,
"dependencies": dependencies,
}
return None
def lookupTableSerializer(parent, lookupTable, lookupTableId, context, depth):
# No children in this case, so no additions to bindings and return empty list
# But we do need to add instance
lookupTableRange = lookupTable.GetRange()
lookupTableHueRange = [0.5, 0]
if hasattr(lookupTable, "GetHueRange"):
try:
lookupTable.GetHueRange(lookupTableHueRange)
except Exception as inst:
pass
lutSatRange = lookupTable.GetSaturationRange()
lutAlphaRange = lookupTable.GetAlphaRange()
return {
"parent": getReferenceId(parent),
"id": lookupTableId,
"type": class_name(lookupTable),
"properties": {
"numberOfColors": lookupTable.GetNumberOfColors(),
"valueRange": lookupTableRange,
"hueRange": lookupTableHueRange,
# 'alphaRange': lutAlphaRange, # Causes weird rendering artifacts on client
"saturationRange": lutSatRange,
"nanColor": lookupTable.GetNanColor(),
"belowRangeColor": lookupTable.GetBelowRangeColor(),
"aboveRangeColor": lookupTable.GetAboveRangeColor(),
"useAboveRangeColor": True
if lookupTable.GetUseAboveRangeColor()
else False,
"useBelowRangeColor": True
if lookupTable.GetUseBelowRangeColor()
else False,
"alpha": lookupTable.GetAlpha(),
"vectorSize": lookupTable.GetVectorSize(),
"vectorComponent": lookupTable.GetVectorComponent(),
"vectorMode": lookupTable.GetVectorMode(),
"indexedLookup": lookupTable.GetIndexedLookup(),
},
}
def pwfSerializer(parent, instance, objId, context, depth):
nodes = []
for i in range(instance.GetSize()):
# x, y, midpoint, sharpness
node = [0, 0, 0, 0]
instance.GetNodeValue(i, node)
nodes.append(node)
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {
"range": list(instance.GetRange()),
"clamping": instance.GetClamping(),
"allowDuplicateScalars": instance.GetAllowDuplicateScalars(),
"nodes": nodes,
},
}
def lightSerializer(parent, instance, objId, context, depth):
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {
# 'specularColor': instance.GetSpecularColor(),
# 'ambientColor': instance.GetAmbientColor(),
"switch": instance.GetSwitch(),
"intensity": instance.GetIntensity(),
"color": instance.GetDiffuseColor(),
"position": instance.GetPosition(),
"focalPoint": instance.GetFocalPoint(),
"positional": instance.GetPositional(),
"exponent": instance.GetExponent(),
"coneAngle": instance.GetConeAngle(),
"attenuationValues": instance.GetAttenuationValues(),
"lightType": lightTypeToString(instance.GetLightType()),
"shadowAttenuation": instance.GetShadowAttenuation(),
},
}
def imagedataSerializer(parent, dataset, datasetId, context, depth, requested_fields = ["Normals", "TCoords"]):
if hasattr(dataset, "GetDirectionMatrix"):
direction = [dataset.GetDirectionMatrix().GetElement(0, i) for i in range(9)]
else:
direction = [1, 0, 0, 0, 1, 0, 0, 0, 1]
# Extract dataset fields
fields = []
extractRequiredFields(fields, parent, dataset, context, "*")
return {
"parent": getReferenceId(parent),
"id": datasetId,
"type": class_name(dataset),
"properties": {
"spacing": dataset.GetSpacing(),
"origin": dataset.GetOrigin(),
"dimensions": dataset.GetDimensions(),
"direction": direction,
"fields": fields,
},
}
def textureSerializer(parent, texture, textureId, context, depth):
# This kind of mapper requires us to get 2 items: input data and lookup
# table
dataObject = None
dataObjectInstance = None
calls = []
dependencies = []
if hasattr(texture, "GetInput"):
dataObject = texture.GetInput()
else:
if context.debugAll:
print("This texture does not have GetInput method")
if dataObject:
dataObjectId = "%s-texture" % textureId
dataObjectInstance = serializeInstance(
texture, dataObject, dataObjectId, context, depth + 1
)
if dataObjectInstance:
dependencies.append(dataObjectInstance)
calls.append(["setInputData", [wrapId(dataObjectId)]])
if dataObjectInstance:
return {
"parent": getReferenceId(parent),
"id": textureId,
"type": "vtkTexture",
"properties": {
"interpolate": texture.GetInterpolate(),
"repeat": texture.GetRepeat(),
"edgeClamp": texture.GetEdgeClamp(),
},
"calls": calls,
"dependencies": dependencies,
}
return None
def genericVolumeSerializer(parent, actor, actorId, context, depth):
# This kind of actor has two "children" of interest, a property and a
# mapper
actorVisibility = actor.GetVisibility()
mapperInstance = None
propertyInstance = None
calls = []
dependencies = []
if actorVisibility:
mapper = None
if not hasattr(actor, "GetMapper"):
if context.debugAll:
print("This actor does not have a GetMapper method")
else:
mapper = actor.GetMapper()
if mapper:
mapperId = getReferenceId(mapper)
mapperInstance = serializeInstance(
actor, mapper, mapperId, context, depth + 1
)
if mapperInstance:
dependencies.append(mapperInstance)
calls.append(["setMapper", [wrapId(mapperId)]])
prop = None
if hasattr(actor, "GetProperty"):
prop = actor.GetProperty()
else:
if context.debugAll:
print("This actor does not have a GetProperty method")
if prop:
propId = getReferenceId(prop)
propertyInstance = serializeInstance(
actor, prop, propId, context, depth + 1
)
if propertyInstance:
dependencies.append(propertyInstance)
calls.append(["setProperty", [wrapId(propId)]])
if actorVisibility == 0 or (mapperInstance and propertyInstance):
return {
"parent": getReferenceId(parent),
"id": actorId,
"type": class_name(actor),
"properties": {
# vtkProp
"visibility": actorVisibility,
"pickable": actor.GetPickable(),
"dragable": actor.GetDragable(),
"useBounds": actor.GetUseBounds(),
# vtkProp3D
"origin": actor.GetOrigin(),
"position": actor.GetPosition(),
"scale": actor.GetScale(),
},
"calls": calls,
"dependencies": dependencies,
}
return None
def cubeAxesSerializer(parent, actor, actorId, context, depth):
"""
Possible add-on properties for vtk.js:
gridLines: True,
axisLabels: None,
axisTitlePixelOffset: 35.0,
axisTextStyle: {
fontColor: 'white',
fontStyle: 'normal',
fontSize: 18,
fontFamily: 'serif',
},
tickLabelPixelOffset: 12.0,
tickTextStyle: {
fontColor: 'white',
fontStyle: 'normal',
fontSize: 14,
fontFamily: 'serif',
},
"""
axisLabels = ["", "", ""]
if actor.GetXAxisLabelVisibility():
axisLabels[0] = actor.GetXTitle()
if actor.GetYAxisLabelVisibility():
axisLabels[1] = actor.GetYTitle()
if actor.GetZAxisLabelVisibility():
axisLabels[2] = actor.GetZTitle()
return {
"parent": getReferenceId(parent),
"id": actorId,
"type": "vtkCubeAxesActor",
"properties": {
# vtkProp
"visibility": actor.GetVisibility(),
"pickable": actor.GetPickable(),
"dragable": actor.GetDragable(),
"useBounds": actor.GetUseBounds(),
# vtkProp3D
"origin": actor.GetOrigin(),
"position": actor.GetPosition(),
"scale": actor.GetScale(),
# vtkActor
"forceOpaque": actor.GetForceOpaque(),
"forceTranslucent": actor.GetForceTranslucent(),
# vtkCubeAxesActor
"dataBounds": actor.GetBounds(),
"faceVisibilityAngle": 8,
"gridLines": True,
"axisLabels": axisLabels,
"axisTitlePixelOffset": 35.0,
"axisTextStyle": {
"fontColor": "white",
"fontStyle": "normal",
"fontSize": 18,
"fontFamily": "serif",
},
"tickLabelPixelOffset": 12.0,
"tickTextStyle": {
"fontColor": "white",
"fontStyle": "normal",
"fontSize": 14,
"fontFamily": "serif",
},
},
"calls": [["setCamera", [wrapId(getReferenceId(actor.GetCamera()))]]],
"dependencies": [],
}
def scalarBarActorSerializer(parent, actor, actorId, context, depth):
dependencies = []
calls = []
lut = actor.GetLookupTable()
if not lut:
return None
lutId = getReferenceId(lut)
lutInstance = serializeInstance(actor, lut, lutId, context, depth + 1)
if not lutInstance:
return None
dependencies.append(lutInstance)
calls.append(["setScalarsToColors", [wrapId(lutId)]])
prop = None
if hasattr(actor, "GetProperty"):
prop = actor.GetProperty()
else:
if context.debugAll:
print("This scalarBarActor does not have a GetProperty method")
if prop:
propId = getReferenceId(prop)
propertyInstance = serializeInstance(
actor, prop, propId, context, depth + 1
)
if propertyInstance:
dependencies.append(propertyInstance)
calls.append(["setProperty", [wrapId(propId)]])
axisLabel = actor.GetTitle()
width = actor.GetWidth()
height = actor.GetHeight()
# axisTitlePixelOffset = actor.GetTextPad()
# position = actor.GetPosition()
# position2 = actor.GetPosition2()
# print(f'axisTitlePixelOffset: {axisTitlePixelOffset}')
# print(f'axisLabel: {axisLabel}')
# print(f'width: {width}')
# print(f'height: {height}')
# print(f'position: {position}')
# print(f'position2: {position2}')
return {
"parent": getReferenceId(parent),
"id": actorId,
"type": "vtkScalarBarActor",
"properties": {
# vtkProp
"visibility": actor.GetVisibility(),
"pickable": actor.GetPickable(),
"dragable": actor.GetDragable(),
"useBounds": actor.GetUseBounds(),
# vtkActor2D
# "position": actor.GetPosition(),
# "position2": actor.GetPosition2(),
# "width": actor.GetWidth(),
# "height": actor.GetHeight(),
# vtkScalarBarActor
"automated": True,
"axisLabel": axisLabel,
# 'barPosition': [0, 0],
# 'barSize': [0, 0],
"boxPosition": [0.88, -0.92],
"boxSize": [width, height],
"axisTitlePixelOffset": 36.0,
"axisTextStyle": {
"fontColor": "white",
"fontStyle": "normal",
"fontSize": 18,
"fontFamily": "serif",
},
"tickLabelPixelOffset": 14.0,
"tickTextStyle": {
"fontColor": "white",
"fontStyle": "normal",
"fontSize": 14,
"fontFamily": "serif",
},
},
"calls": calls,
"dependencies": dependencies,
}
def genericMapperSerializer(parent, mapper, mapperId, context, depth):
# This kind of mapper requires us to get 2 items: input data and lookup
# table
dataObject = None
dataObjectInstance = None
lookupTableInstance = None
calls = []
dependencies = []
if hasattr(mapper, "GetInputDataObject"):
mapper.GetInputAlgorithm().Update()
dataObject = mapper.GetInputDataObject(0, 0)
else:
if context.debugAll:
print("This mapper does not have GetInputDataObject method")
if dataObject:
dataObjectId = "%s-dataset" % mapperId
dataObjectInstance = serializeInstance(
mapper, dataObject, dataObjectId, context, depth + 1
)
if dataObjectInstance:
dependencies.append(dataObjectInstance)
calls.append(["setInputData", [wrapId(dataObjectId)]])
lookupTable = None
if hasattr(mapper, "GetLookupTable"):
lookupTable = mapper.GetLookupTable()
else:
if context.debugAll:
print("This mapper does not have GetLookupTable method")
if lookupTable:
lookupTableId = getReferenceId(lookupTable)
lookupTableInstance = serializeInstance(
mapper, lookupTable, lookupTableId, context, depth + 1
)
if lookupTableInstance:
dependencies.append(lookupTableInstance)
calls.append(["setLookupTable", [wrapId(lookupTableId)]])
if dataObjectInstance:
colorArrayName = (
mapper.GetArrayName()
if mapper.GetArrayAccessMode() == 1
else mapper.GetArrayId()
)
return {
"parent": getReferenceId(parent),
"id": mapperId,
"type": class_name(mapper),
"properties": {
"resolveCoincidentTopology": mapper.GetResolveCoincidentTopology(),
"renderTime": mapper.GetRenderTime(),
"arrayAccessMode": mapper.GetArrayAccessMode(),
"scalarRange": mapper.GetScalarRange(),
"useLookupTableScalarRange": 1
if mapper.GetUseLookupTableScalarRange()
else 0,
"scalarVisibility": mapper.GetScalarVisibility(),
"colorByArrayName": colorArrayName,
"colorMode": mapper.GetColorMode(),
"scalarMode": mapper.GetScalarMode(),
"interpolateScalarsBeforeMapping": 1
if mapper.GetInterpolateScalarsBeforeMapping()
else 0,
},
"calls": calls,
"dependencies": dependencies,
}
return None
def rendererSerializer(parent, instance, objId, context, depth):
dependencies = []
viewPropIds = []
lightsIds = []
calls = []
# Camera
camera = instance.GetActiveCamera()
cameraId = getReferenceId(camera)
cameraInstance = serializeInstance(instance, camera, cameraId, context, depth + 1)
if cameraInstance:
dependencies.append(cameraInstance)
calls.append(["setActiveCamera", [wrapId(cameraId)]])
# View prop as representation containers
viewPropCollection = instance.GetViewProps()
for rpIdx in range(viewPropCollection.GetNumberOfItems()):
viewProp = viewPropCollection.GetItemAsObject(rpIdx)
viewPropId = getReferenceId(viewProp)
viewPropInstance = serializeInstance(
instance, viewProp, viewPropId, context, depth + 1
)
if viewPropInstance:
dependencies.append(viewPropInstance)
viewPropIds.append(viewPropId)
calls += context.buildDependencyCallList(
"%s-props" % objId, viewPropIds, "addViewProp", "removeViewProp"
)
# Lights
lightCollection = instance.GetLights()
for lightIdx in range(lightCollection.GetNumberOfItems()):
light = lightCollection.GetItemAsObject(lightIdx)
lightId = getReferenceId(light)
lightInstance = serializeInstance(instance, light, lightId, context, depth + 1)
if lightInstance:
dependencies.append(lightInstance)
lightsIds.append(lightId)
calls += context.buildDependencyCallList(
"%s-lights" % objId, lightsIds, "addLight", "removeLight"
)
if len(dependencies) > 1:
return {
"parent": getReferenceId(parent),
"id": objId,
"type": class_name(instance),
"properties": {
"background": instance.GetBackground(),
"background2": instance.GetBackground2(),
"viewport": instance.GetViewport(),
# These commented properties do not yet have real setters in vtk.js
# 'gradientBackground': instance.GetGradientBackground(),
# 'aspect': instance.GetAspect(),
# 'pixelAspect': instance.GetPixelAspect(),
# 'ambient': instance.GetAmbient(),
"twoSidedLighting": instance.GetTwoSidedLighting(),
"lightFollowCamera": instance.GetLightFollowCamera(),
"layer": instance.GetLayer(),
"preserveColorBuffer": instance.GetPreserveColorBuffer(),
"preserveDepthBuffer": instance.GetPreserveDepthBuffer(),
"nearClippingPlaneTolerance": instance.GetNearClippingPlaneTolerance(),
"clippingRangeExpansion": instance.GetClippingRangeExpansion(),
"useShadows": instance.GetUseShadows(),
"useDepthPeeling": instance.GetUseDepthPeeling(),
"occlusionRatio": instance.GetOcclusionRatio(),
"maximumNumberOfPeels": instance.GetMaximumNumberOfPeels(),
"interactive": instance.GetInteractive(),
},
"dependencies": dependencies,
"calls": calls,
}
return None