How to use the rhino3dm.ObjectType function in rhino3dm

else:
            matname = converters.material_name(rhino_material)

        # Handle object view color
        if ob.Attributes.ColorSource == r3d.ObjectColorSource.ColorFromLayer:
            view_color = rhinolayer.Color
        else:
            view_color = ob.Attributes.ObjectColor

        rhinomat = materials[matname]

        # Fetch layer
        layer = layerids[str(rhinolayer.Id)][1]

        
        if og.ObjectType==r3d.ObjectType.InstanceReference and import_instances:
            n = model.InstanceDefinitions.FindId(og.ParentIdefId).Name

        # Convert object
        converters.convert_object(context, ob, n, layer, rhinomat, view_color, scale, options)

        #convert_rhino_object(og, context, n, attr.Name, attr.Id, layer, rhinomat, scale)

        if import_groups:
            converters.handle_groups(context,attr,toplayer,import_nested_groups)

    if import_instances:
        converters.populate_instance_definitions(context, model, toplayer, "Instance Definitions")

    # finally link in the container collection (top layer) into the main
    # scene collection.
    try:

matname = None
        if attr.MaterialIndex != -1:
            matname = material_name(model.Materials[attr.MaterialIndex])

        layeruuid = rhinolayer.Id
        rhinomatname = rhinolayer.Name + "+" + str(layeruuid)
        if matname:
            rhinomat = materials[matname]
        else:
            rhinomat = materials[rhinomatname]
        layer = layerids[str(layeruuid)][1]

        # concatenate all meshes from all (brep) faces,
        # adjust vertex indices for faces accordingly
        # first get all render meshes
        if og.ObjectType==r3d.ObjectType.Extrusion:
            msh = [og.GetMesh(r3d.MeshType.Any)]
        elif og.ObjectType==r3d.ObjectType.Mesh:
            msh = [og]
        elif og.ObjectType==r3d.ObjectType.Brep:
            msh = [og.Faces[f].GetMesh(r3d.MeshType.Any) for f in range(len(og.Faces)) if type(og.Faces[f])!=list]
        else:
            continue
        fidx=0
        faces = []
        vertices = []
        # now add all faces and vertices to the main lists
        for m in msh:
            if not m: continue
            faces.extend([list(map(lambda x: x + fidx, m.Faces[f])) for f in range(len(m.Faces))])
            fidx = fidx + len(m.Vertices)
            vertices.extend([(m.Vertices[v].X, m.Vertices[v].Y, m.Vertices[v].Z) for v in range(len(m.Vertices))])

from .layers import handle_layers
from .render_mesh import import_render_mesh
from .curve import import_curve
from .views import handle_views
from .groups import handle_groups
from .instances import import_instance_reference, handle_instance_definitions, populate_instance_definitions

'''
Dictionary mapping between the Rhino file types and importer functions
'''

RHINO_TYPE_TO_IMPORT = {
    r3d.ObjectType.Brep : import_render_mesh,
    r3d.ObjectType.Extrusion : import_render_mesh,
    r3d.ObjectType.Mesh : import_render_mesh,
    r3d.ObjectType.Curve : import_curve,
    #r3d.ObjectType.InstanceReference : import_instance_reference
}



# TODO: Decouple object data creation from object creation
#       and consolidate object-level conversion.

def convert_object(context, ob, name, layer, rhinomat, view_color, scale, options):
    """
    Add a new object with given data, link to
    collection given by layer
    """

    data = None
    blender_object = None