user: Give a detailed overview of Mesh Operators: syntax, arguments, return values, common patterns.

assistant: # Mesh Operators

bpy.ops.mesh.attribute_set(*\**, *value_float=0.0*, *value_float_vector_2d=(0.0, 0.0)*, *value_float_vector_3d=(0.0, 0.0, 0.0)*, *value_int=0*, *value_int_vector_2d=(0, 0)*, *value_color=(1.0, 1.0, 1.0, 1.0)*, *value_bool=False*)
:   Set values of the active attribute for selected elements

    Parameters:
    :   - **value_float** (*float in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_float_vector_2d** (*float array* *of* *2 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_float_vector_3d** (*float array* *of* *3 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_int** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_int_vector_2d** (*int array* *of* *2 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_color** (*float array* *of* *4 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Value
        - **value_bool** (*boolean**,* *(**optional**)*) – Value

bpy.ops.mesh.average_normals(*\**, *average_type='CUSTOM_NORMAL'*, *weight=50*, *threshold=0.01*)
:   Average custom normals of selected vertices

    Parameters:
    :   - **average_type** (enum in [`'CUSTOM_NORMAL'`, `'FACE_AREA'`, `'CORNER_ANGLE'`], (optional)) –

          Type, Averaging method

          - `CUSTOM_NORMAL`
            Custom Normal – Take average of vertex normals.
          - `FACE_AREA`
            Face Area – Set all vertex normals by face area.
          - `CORNER_ANGLE`
            Corner Angle – Set all vertex normals by corner angle.
        - **weight** (*int in* *[**1**,* *100**]**,* *(**optional**)*) – Weight, Weight applied per face
        - **threshold** (*float in* *[**0**,* *10**]**,* *(**optional**)*) – Threshold, Threshold value for different weights to be considered equal

bpy.ops.mesh.beautify_fill(*\**, *angle_limit=3.14159*)
:   Rearrange some faces to try to get less degenerated geometry

    Parameters:
    :   **angle_limit** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Max Angle, Angle limit

bpy.ops.mesh.bevel(*\**, *offset_type='OFFSET'*, *offset=0.0*, *profile_type='SUPERELLIPSE'*, *offset_pct=0.0*, *segments=1*, *profile=0.5*, *affect='EDGES'*, *clamp_overlap=False*, *loop_slide=True*, *mark_seam=False*, *mark_sharp=False*, *material=-1*, *harden_normals=False*, *face_strength_mode='NONE'*, *miter_outer='SHARP'*, *miter_inner='SHARP'*, *spread=0.1*, *vmesh_method='ADJ'*, *release_confirm=False*)
:   Cut into selected items at an angle to create bevel or chamfer

    Parameters:
    :   - **offset_type** (enum in [`'OFFSET'`, `'WIDTH'`, `'DEPTH'`, `'PERCENT'`, `'ABSOLUTE'`], (optional)) –

          Width Type, The method for determining the size of the bevel

          - `OFFSET`
            Offset – Amount is offset of new edges from original.
          - `WIDTH`
            Width – Amount is width of new face.
          - `DEPTH`
            Depth – Amount is perpendicular distance from original edge to bevel face.
          - `PERCENT`
            Percent – Amount is percent of adjacent edge length.
          - `ABSOLUTE`
            Absolute – Amount is absolute distance along adjacent edge.
        - **offset** (*float in* *[**0**,* *1e+06**]**,* *(**optional**)*) – Width, Bevel amount
        - **profile_type** (enum in [`'SUPERELLIPSE'`, `'CUSTOM'`], (optional)) –

          Profile Type, The type of shape used to rebuild a beveled section

          - `SUPERELLIPSE`
            Superellipse – The profile can be a concave or convex curve.
          - `CUSTOM`
            Custom – The profile can be any arbitrary path between its endpoints.
        - **offset_pct** (*float in* *[**0**,* *100**]**,* *(**optional**)*) – Width Percent, Bevel amount for percentage method
        - **segments** (*int in* *[**1**,* *1000**]**,* *(**optional**)*) – Segments, Segments for curved edge
        - **profile** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Profile, Controls profile shape (0.5 = round)
        - **affect** (enum in [`'VERTICES'`, `'EDGES'`], (optional)) –

          Affect, Affect edges or vertices

          - `VERTICES`
            Vertices – Affect only vertices.
          - `EDGES`
            Edges – Affect only edges.
        - **clamp_overlap** (*boolean**,* *(**optional**)*) – Clamp Overlap, Do not allow beveled edges/vertices to overlap each other
        - **loop_slide** (*boolean**,* *(**optional**)*) – Loop Slide, Prefer sliding along edges to even widths
        - **mark_seam** (*boolean**,* *(**optional**)*) – Mark Seams, Preserve seams along beveled edges
        - **mark_sharp** (*boolean**,* *(**optional**)*) – Mark Sharp, Preserve sharp edges along beveled edges
        - **material** (*int in* *[**-1**,* *inf**]**,* *(**optional**)*) – Material Index, Material for bevel faces (-1 means use adjacent faces)
        - **harden_normals** (*boolean**,* *(**optional**)*) – Harden Normals, Match normals of new faces to adjacent faces
        - **face_strength_mode** (enum in [`'NONE'`, `'NEW'`, `'AFFECTED'`, `'ALL'`], (optional)) –

          Face Strength Mode, Whether to set face strength, and which faces to set face strength on

          - `NONE`
            None – Do not set face strength.
          - `NEW`
            New – Set face strength on new faces only.
          - `AFFECTED`
            Affected – Set face strength on new and modified faces only.
          - `ALL`
            All – Set face strength on all faces.
        - **miter_outer** (enum in [`'SHARP'`, `'PATCH'`, `'ARC'`], (optional)) –

          Outer Miter, Pattern to use for outside of miters

          - `SHARP`
            Sharp – Outside of miter is sharp.
          - `PATCH`
            Patch – Outside of miter is squared-off patch.
          - `ARC`
            Arc – Outside of miter is arc.
        - **miter_inner** (enum in [`'SHARP'`, `'ARC'`], (optional)) –

          Inner Miter, Pattern to use for inside of miters

          - `SHARP`
            Sharp – Inside of miter is sharp.
          - `ARC`
            Arc – Inside of miter is arc.
        - **spread** (*float in* *[**0**,* *1e+06**]**,* *(**optional**)*) – Spread, Amount to spread arcs for arc inner miters
        - **vmesh_method** (enum in [`'ADJ'`, `'CUTOFF'`], (optional)) –

          Vertex Mesh Method, The method to use to create meshes at intersections

          - `ADJ`
            Grid Fill – Default patterned fill.
          - `CUTOFF`
            Cutoff – A cutoff at each profile’s end before the intersection.
        - **release_confirm** (*boolean**,* *(**optional**)*) – Confirm on Release

bpy.ops.mesh.bisect(*\**, *plane_co=(0.0, 0.0, 0.0)*, *plane_no=(0.0, 0.0, 0.0)*, *use_fill=False*, *clear_inner=False*, *clear_outer=False*, *threshold=0.0001*, *xstart=0*, *xend=0*, *ystart=0*, *yend=0*, *flip=False*, *cursor=5*)
:   Cut geometry along a plane (click-drag to define plane)

    Parameters:
    :   - **plane_co** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (optional)) – Plane Point, A point on the plane
        - **plane_no** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-1, 1], (optional)) – Plane Normal, The direction the plane points
        - **use_fill** (*boolean**,* *(**optional**)*) – Fill, Fill in the cut
        - **clear_inner** (*boolean**,* *(**optional**)*) – Clear Inner, Remove geometry behind the plane
        - **clear_outer** (*boolean**,* *(**optional**)*) – Clear Outer, Remove geometry in front of the plane
        - **threshold** (*float in* *[**0**,* *10**]**,* *(**optional**)*) – Axis Threshold, Preserves the existing geometry along the cut plane
        - **xstart** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Start
        - **xend** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X End
        - **ystart** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Start
        - **yend** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y End
        - **flip** (*boolean**,* *(**optional**)*) – Flip
        - **cursor** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Cursor, Mouse cursor style to use during the modal operator

bpy.ops.mesh.blend_from_shape(*\**, *shape=''*, *blend=1.0*, *add=True*)
:   Blend in shape from a shape key

    Parameters:
    :   - **shape** (*enum in* *[**]**,* *(**optional**)*) – Shape, Shape key to use for blending
        - **blend** (*float in* *[**-1000**,* *1000**]**,* *(**optional**)*) – Blend, Blending factor
        - **add** (*boolean**,* *(**optional**)*) – Add, Add rather than blend between shapes

bpy.ops.mesh.bridge_edge_loops(*\**, *type='SINGLE'*, *use_merge=False*, *merge_factor=0.5*, *twist_offset=0*, *number_cuts=0*, *interpolation='PATH'*, *smoothness=1.0*, *profile_shape_factor=0.0*, *profile_shape='SMOOTH'*)
:   Create a bridge of faces between two or more selected edge loops

    Parameters:
    :   - **type** (enum in [`'SINGLE'`, `'CLOSED'`, `'PAIRS'`], (optional)) – Connect Loops, Method of bridging multiple loops
        - **use_merge** (*boolean**,* *(**optional**)*) – Merge, Merge rather than creating faces
        - **merge_factor** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Merge Factor
        - **twist_offset** (*int in* *[**-1000**,* *1000**]**,* *(**optional**)*) – Twist, Twist offset for closed loops
        - **number_cuts** (*int in* *[**0**,* *1000**]**,* *(**optional**)*) – Number of Cuts
        - **interpolation** (enum in [`'LINEAR'`, `'PATH'`, `'SURFACE'`], (optional)) – Interpolation, Interpolation method
        - **smoothness** (*float in* *[**0**,* *1000**]**,* *(**optional**)*) – Smoothness, Smoothness factor
        - **profile_shape_factor** (*float in* *[**-1000**,* *1000**]**,* *(**optional**)*) – Profile Factor, How much intermediary new edges are shrunk/expanded
        - **profile_shape** (enum in [Proportional Falloff Curve Only Items](bpy_types_enum_items/proportional_falloff_curve_only_items.html#rna-enum-proportional-falloff-curve-only-items), (optional)) – Profile Shape, Shape of the profile

bpy.ops.mesh.colors_reverse()
:   Flip direction of face corner color attribute inside faces

bpy.ops.mesh.colors_rotate(*\**, *use_ccw=False*)
:   Rotate face corner color attribute inside faces

    Parameters:
    :   **use_ccw** (*boolean**,* *(**optional**)*) – Counter Clockwise

bpy.ops.mesh.convex_hull(*\**, *delete_unused=True*, *use_existing_faces=True*, *make_holes=False*, *join_triangles=True*, *face_threshold=0.698132*, *shape_threshold=0.698132*, *topology_influence=0.0*, *uvs=False*, *vcols=False*, *seam=False*, *sharp=False*, *materials=False*, *deselect_joined=False*)
:   Enclose selected vertices in a convex polyhedron

    Parameters:
    :   - **delete_unused** (*boolean**,* *(**optional**)*) – Delete Unused, Delete selected elements that are not used by the hull
        - **use_existing_faces** (*boolean**,* *(**optional**)*) – Use Existing Faces, Skip hull triangles that are covered by a pre-existing face
        - **make_holes** (*boolean**,* *(**optional**)*) – Make Holes, Delete selected faces that are used by the hull
        - **join_triangles** (*boolean**,* *(**optional**)*) – Join Triangles, Merge adjacent triangles into quads
        - **face_threshold** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Max Face Angle, Face angle limit
        - **shape_threshold** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Max Shape Angle, Shape angle limit
        - **topology_influence** (*float in* *[**0**,* *2**]**,* *(**optional**)*) – Topology Influence, How much to prioritize regular grids of quads as well as quads that touch existing quads
        - **uvs** (*boolean**,* *(**optional**)*) – Compare UVs
        - **vcols** (*boolean**,* *(**optional**)*) – Compare Color Attributes
        - **seam** (*boolean**,* *(**optional**)*) – Compare Seam
        - **sharp** (*boolean**,* *(**optional**)*) – Compare Sharp
        - **materials** (*boolean**,* *(**optional**)*) – Compare Materials
        - **deselect_joined** (*boolean**,* *(**optional**)*) – Deselect Joined, Only select remaining triangles that were not merged

bpy.ops.mesh.customdata_custom_splitnormals_add()
:   Add a custom normals layer, if none exists yet

bpy.ops.mesh.customdata_custom_splitnormals_clear()
:   Remove the custom normals layer, if it exists

bpy.ops.mesh.customdata_mask_clear()
:   Clear vertex sculpt masking data from the mesh

bpy.ops.mesh.customdata_skin_add()
:   Add a vertex skin layer

bpy.ops.mesh.customdata_skin_clear()
:   Clear vertex skin layer

bpy.ops.mesh.decimate(*\**, *ratio=1.0*, *use_vertex_group=False*, *vertex_group_factor=1.0*, *invert_vertex_group=False*, *use_symmetry=False*, *symmetry_axis='Y'*)
:   Simplify geometry by collapsing edges

    Parameters:
    :   - **ratio** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Ratio
        - **use_vertex_group** (*boolean**,* *(**optional**)*) – Vertex Group, Use active vertex group as an influence
        - **vertex_group_factor** (*float in* *[**0**,* *1000**]**,* *(**optional**)*) – Weight, Vertex group strength
        - **invert_vertex_group** (*boolean**,* *(**optional**)*) – Invert, Invert vertex group influence
        - **use_symmetry** (*boolean**,* *(**optional**)*) – Symmetry, Maintain symmetry on an axis
        - **symmetry_axis** (enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), (optional)) – Axis, Axis of symmetry

bpy.ops.mesh.delete(*\**, *type='VERT'*)
:   Delete selected vertices, edges or faces

    Parameters:
    :   **type** (enum in [`'VERT'`, `'EDGE'`, `'FACE'`, `'EDGE_FACE'`, `'ONLY_FACE'`], (optional)) – Type, Method used for deleting mesh data

bpy.ops.mesh.delete_edgeloop(*\**, *use_face_split=True*)
:   Delete an edge loop by merging the faces on each side

    Parameters:
    :   **use_face_split** (*boolean**,* *(**optional**)*) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.delete_loose(*\**, *use_verts=True*, *use_edges=True*, *use_faces=False*)
:   Delete loose vertices, edges or faces

    Parameters:
    :   - **use_verts** (*boolean**,* *(**optional**)*) – Vertices, Remove loose vertices
        - **use_edges** (*boolean**,* *(**optional**)*) – Edges, Remove loose edges
        - **use_faces** (*boolean**,* *(**optional**)*) – Faces, Remove loose faces

bpy.ops.mesh.dissolve_degenerate(*\**, *threshold=0.0001*)
:   Dissolve zero area faces and zero length edges

    Parameters:
    :   **threshold** (*float in* *[**1e-06**,* *50**]**,* *(**optional**)*) – Merge Distance, Maximum distance between elements to merge

bpy.ops.mesh.dissolve_edges(*\**, *use_verts=True*, *angle_threshold=3.14159*, *use_face_split=False*)
:   Dissolve edges, merging faces

    Parameters:
    :   - **use_verts** (*boolean**,* *(**optional**)*) – Dissolve Vertices, Dissolve remaining vertices which connect to only two edges
        - **angle_threshold** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Angle Threshold, Remaining vertices which separate edge pairs are preserved if their edge angle exceeds this threshold.
        - **use_face_split** (*boolean**,* *(**optional**)*) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.dissolve_faces(*\**, *use_verts=False*)
:   Dissolve faces

    Parameters:
    :   **use_verts** (*boolean**,* *(**optional**)*) – Dissolve Vertices, Dissolve remaining vertices which connect to only two edges

bpy.ops.mesh.dissolve_limited(*\**, *angle_limit=0.0872665*, *use_dissolve_boundaries=False*, *delimit={'NORMAL'}*)
:   Dissolve selected edges and vertices, limited by the angle of surrounding geometry

    Parameters:
    :   - **angle_limit** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Max Angle, Angle limit
        - **use_dissolve_boundaries** (*boolean**,* *(**optional**)*) – All Boundaries, Dissolve all vertices in between face boundaries
        - **delimit** (enum set in [Mesh Delimit Mode Items](bpy_types_enum_items/mesh_delimit_mode_items.html#rna-enum-mesh-delimit-mode-items), (optional)) – Delimit, Delimit dissolve operation

bpy.ops.mesh.dissolve_mode(*\**, *use_verts=False*, *angle_threshold=3.14159*, *use_face_split=False*, *use_boundary_tear=False*)
:   Dissolve geometry based on the selection mode

    Parameters:
    :   - **use_verts** (*boolean**,* *(**optional**)*) – Dissolve Vertices, Dissolve remaining vertices which connect to only two edges
        - **angle_threshold** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Angle Threshold, Remaining vertices which separate edge pairs are preserved if their edge angle exceeds this threshold.
        - **use_face_split** (*boolean**,* *(**optional**)*) – Face Split, Split off face corners to maintain surrounding geometry
        - **use_boundary_tear** (*boolean**,* *(**optional**)*) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.dissolve_verts(*\**, *use_face_split=False*, *use_boundary_tear=False*)
:   Dissolve vertices, merge edges and faces

    Parameters:
    :   - **use_face_split** (*boolean**,* *(**optional**)*) – Face Split, Split off face corners to maintain surrounding geometry
        - **use_boundary_tear** (*boolean**,* *(**optional**)*) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.dupli_extrude_cursor(*\**, *rotate_source=True*)
:   Duplicate and extrude selected vertices, edges or faces towards the mouse cursor

    Parameters:
    :   **rotate_source** (*boolean**,* *(**optional**)*) – Rotate Source, Rotate initial selection giving better shape

bpy.ops.mesh.duplicate(*\**, *mode=1*)
:   Duplicate selected vertices, edges or faces

    Parameters:
    :   **mode** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Mode

bpy