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

assistant: scale_to_bounds=False*)
:   Project the UV vertices of the mesh as seen in current 3D view

    Parameters:
    :   - **orthographic** (*boolean**,* *(**optional**)*) – Orthographic, Use orthographic projection
        - **camera_bounds** (*boolean**,* *(**optional**)*) – Camera Bounds, Map UVs to the camera region taking resolution and aspect into account
        - **correct_aspect** (*boolean**,* *(**optional**)*) – Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
        - **clip_to_bounds** (*boolean**,* *(**optional**)*) – Clip to Bounds, Clip UV coordinates to bounds after unwrapping
        - **scale_to_bounds** (*boolean**,* *(**optional**)*) – Scale to Bounds, Scale UV coordinates to bounds after unwrapping

bpy.ops.uv.randomize_uv_transform(*\**, *random_seed=0*, *use_loc=True*, *loc=(0.0, 0.0)*, *use_rot=True*, *rot=0.0*, *use_scale=True*, *scale_even=False*, *scale=(1.0, 1.0)*)
:   Randomize the UV island’s location, rotation, and scale

    Parameters:
    :   - **random_seed** (*int in* *[**0**,* *10000**]**,* *(**optional**)*) – Random Seed, Seed value for the random generator
        - **use_loc** (*boolean**,* *(**optional**)*) – Randomize Location, Randomize the location values
        - **loc** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-100, 100], (optional)) – Location, Maximum distance the objects can spread over each axis
        - **use_rot** (*boolean**,* *(**optional**)*) – Randomize Rotation, Randomize the rotation value
        - **rot** (*float in* *[**-6.28319**,* *6.28319**]**,* *(**optional**)*) – Rotation, Maximum rotation
        - **use_scale** (*boolean**,* *(**optional**)*) – Randomize Scale, Randomize the scale values
        - **scale_even** (*boolean**,* *(**optional**)*) – Scale Even, Use the same scale value for both axes
        - **scale** (*float array* *of* *2 items in* *[**-100**,* *100**]**,* *(**optional**)*) – Scale, Maximum scale randomization over each axis

    File:
    :   [startup/bl_operators/uvcalc_transform.py:536](https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_operators/uvcalc_transform.py#L536)

bpy.ops.uv.remove_doubles(*\**, *threshold=0.02*, *use_unselected=False*, *use_shared_vertex=False*)
:   Selected UV vertices that are within a radius of each other are welded together

    Parameters:
    :   - **threshold** (*float in* *[**0**,* *10**]**,* *(**optional**)*) – Merge Distance, Maximum distance between welded vertices
        - **use_unselected** (*boolean**,* *(**optional**)*) – Unselected, Merge selected to other unselected vertices
        - **use_shared_vertex** (*boolean**,* *(**optional**)*) – Shared Vertex, Weld UVs based on shared vertices

bpy.ops.uv.reset()
:   Reset UV projection

bpy.ops.uv.reveal(*\**, *select=True*)
:   Reveal all hidden UV vertices

    Parameters:
    :   **select** (*boolean**,* *(**optional**)*) – Select

bpy.ops.uv.rip(*\**, *mirror=False*, *release_confirm=False*, *use_accurate=False*, *location=(0.0, 0.0)*)
:   Rip selected vertices or a selected region

    Parameters:
    :   - **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing
        - **release_confirm** (*boolean**,* *(**optional**)*) – Confirm on Release, Always confirm operation when releasing button
        - **use_accurate** (*boolean**,* *(**optional**)*) – Accurate, Use accurate transformation
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], (optional)) – Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds

bpy.ops.uv.rip_move(*\**, *UV_OT_rip=None*, *TRANSFORM_OT_translate=None*)
:   Unstitch UVs and move the result

    Parameters:
    :   - **UV_OT_rip** (`UV_OT_rip`, (optional)) – UV Rip, Rip selected vertices or a selected region
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.uv.seams_from_islands(*\**, *mark_seams=True*, *mark_sharp=False*)
:   Set mesh seams according to island setup in the UV editor

    Parameters:
    :   - **mark_seams** (*boolean**,* *(**optional**)*) – Mark Seams, Mark boundary edges as seams
        - **mark_sharp** (*boolean**,* *(**optional**)*) – Mark Sharp, Mark boundary edges as sharp

bpy.ops.uv.select(*\**, *extend=False*, *deselect=False*, *toggle=False*, *deselect_all=False*, *select_passthrough=False*, *location=(0.0, 0.0)*)
:   Select UV vertices

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection instead of deselecting everything first
        - **deselect** (*boolean**,* *(**optional**)*) – Deselect, Remove from selection
        - **toggle** (*boolean**,* *(**optional**)*) – Toggle Selection, Toggle the selection
        - **deselect_all** (*boolean**,* *(**optional**)*) – Deselect On Nothing, Deselect all when nothing under the cursor
        - **select_passthrough** (*boolean**,* *(**optional**)*) – Only Select Unselected, Ignore the select action when the element is already selected
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], (optional)) – Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds

bpy.ops.uv.select_all(*\**, *action='TOGGLE'*)
:   Change selection of all UV vertices

    Parameters:
    :   **action** (enum in [`'TOGGLE'`, `'SELECT'`, `'DESELECT'`, `'INVERT'`], (optional)) –

        Action, Selection action to execute

        - `TOGGLE`
          Toggle – Toggle selection for all elements.
        - `SELECT`
          Select – Select all elements.
        - `DESELECT`
          Deselect – Deselect all elements.
        - `INVERT`
          Invert – Invert selection of all elements.

bpy.ops.uv.select_box(*\**, *pinned=False*, *xmin=0*, *xmax=0*, *ymin=0*, *ymax=0*, *wait_for_input=True*, *mode='SET'*)
:   Select UV vertices using box selection

    Parameters:
    :   - **pinned** (*boolean**,* *(**optional**)*) – Pinned, Border select pinned UVs only
        - **xmin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Min
        - **xmax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Max
        - **ymin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Min
        - **ymax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Max
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input
        - **mode** (enum in [`'SET'`, `'ADD'`, `'SUB'`], (optional)) –

          Mode

          - `SET`
            Set – Set a new selection.
          - `ADD`
            Extend – Extend existing selection.
          - `SUB`
            Subtract – Subtract existing selection.

bpy.ops.uv.select_circle(*\**, *x=0*, *y=0*, *radius=25*, *wait_for_input=True*, *mode='SET'*)
:   Select UV vertices using circle selection

    Parameters:
    :   - **x** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X
        - **y** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y
        - **radius** (*int in* *[**1**,* *inf**]**,* *(**optional**)*) – Radius
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input
        - **mode** (enum in [`'SET'`, `'ADD'`, `'SUB'`], (optional)) –

          Mode

          - `SET`
            Set – Set a new selection.
          - `ADD`
            Extend – Extend existing selection.
          - `SUB`
            Subtract – Subtract existing selection.

bpy.ops.uv.select_edge_ring(*\**, *extend=False*, *location=(0.0, 0.0)*)
:   Select an edge ring of connected UV vertices

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection rather than clearing the existing selection
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], (optional)) – Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds

bpy.ops.uv.select_lasso(*\**, *path=None*, *use_smooth_stroke=False*, *smooth_stroke_factor=0.75*, *smooth_stroke_radius=35*, *mode='SET'*)
:   Select UVs using lasso selection

    Parameters:
    :   - **path** (`bpy_prop_collection` of `OperatorMousePath`, (optional)) – Path
        - **use_smooth_stroke** (*boolean**,* *(**optional**)*) – Stabilize Stroke, Selection lags behind mouse and follows a smoother path
        - **smooth_stroke_factor** (*float in* *[**0.5**,* *0.99**]**,* *(**optional**)*) – Smooth Stroke Factor, Higher values gives a smoother stroke
        - **smooth_stroke_radius** (*int in* *[**10**,* *200**]**,* *(**optional**)*) – Smooth Stroke Radius, Minimum distance from last point before selection continues
        - **mode** (enum in [`'SET'`, `'ADD'`, `'SUB'`], (optional)) –

          Mode

          - `SET`
            Set – Set a new selection.
          - `ADD`
            Extend – Extend existing selection.
          - `SUB`
            Subtract – Subtract existing selection.

bpy.ops.uv.select_less()
:   Deselect UV vertices at the boundary of each selection region

bpy.ops.uv.select_linked()
:   Select all UV vertices linked to the active UV map

bpy.ops.uv.select_linked_pick(*\**, *extend=False*, *deselect=False*, *location=(0.0, 0.0)*)
:   Select all UV vertices linked under the mouse

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection rather than clearing the existing selection
        - **deselect** (*boolean**,* *(**optional**)*) – Deselect, Deselect linked UV vertices rather than selecting them
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], (optional)) – Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds

bpy.ops.uv.select_loop(*\**, *extend=False*, *location=(0.0, 0.0)*)
:   Select a loop of connected UV vertices

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection rather than clearing the existing selection
        - **location** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], (optional)) – Location, Mouse location in normalized coordinates, 0.0 to 1.0 is within the image bounds

bpy.ops.uv.select_mode(*\**, *type='VERTEX'*)
:   Change UV selection mode

    Parameters:
    :   **type** (enum in [Mesh Select Mode Uv Items](bpy_types_enum_items/mesh_select_mode_uv_items.html#rna-enum-mesh-select-mode-uv-items), (optional)) – Type

bpy.ops.uv.select_more()
:   Select more UV vertices connected to initial selection

bpy.ops.uv.select_overlap(*\**, *extend=False*)
:   Select all UV faces which overlap each other

    Parameters:
    :   **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection rather than clearing the existing selection

bpy.ops.uv.select_pinned()
:   Select all pinned UV vertices

bpy.ops.uv.select_similar(*\**, *type='PIN'*, *compare='EQUAL'*, *threshold=0.0*)
:   Select similar UVs by property types

    Parameters:
    :   - **type** (enum in [`'PIN'`, `'LENGTH'`, `'LENGTH_3D'`, `'AREA'`, `'AREA_3D'`, `'MATERIAL'`, `'OBJECT'`, `'SIDES'`, `'WINDING'`, `'FACE'`], (optional)) –

          Type

          - `PIN`
            Pinned.
          - `LENGTH`
            Length – Edge length in UV space.
          - `LENGTH_3D`
            Length 3D – Length of edge in 3D space.
          - `AREA`
            Area – Face area in UV space.
          - `AREA_3D`
            Area 3D – Area of face in 3D space.
          - `MATERIAL`
            Material.
          - `OBJECT`
            Object.
          - `SIDES`
            Polygon Sides.
          - `WINDING`
            Winding – Face direction defined by (clockwise or anti-clockwise winding (facing up or facing down).
          - `FACE`
            Amount of Faces in Island.
        - **compare** (enum in [`'EQUAL'`, `'GREATER'`, `'LESS'`], (optional)) – Compare
        - **threshold** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Threshold

bpy.ops.uv.select_split()
:   Select only entirely selected faces

bpy.ops.uv.shortest_path_pick(*\**, *use_face_step=False*, *use_topology_distance=False*, *use_fill=False*, *skip=0*, *nth=1*, *offset=0*, *object_index=-1*, *index=-1*)
:   Select shortest path between two selections

    Parameters:
    :   - **use_face_step** (*boolean**,* *(**optional**)*) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
        - **use_topology_distance** (*boolean**,* *(**optional**)*) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
        - **use_fill** (*boolean**,* *(**optional**)*) – Fill Region, Select all paths between the source/destination elements
        - **skip** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Deselected, Number of deselected elements in the repetitive sequence
        - **nth** (*int in* *[**1**,* *inf**]**,* *(**optional**)*) – Selected, Number of selected elements in the repetitive sequence
        - **offset** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Offset, Offset from the starting point

bpy.ops.uv.shortest_path_select(*\**, *use_face_step=False*, *use_topology_distance=False*, *use_fill=False*, *skip=0*, *nth=1*, *offset=0*)
:   Selected shortest path between two vertices/edges/faces

    Parameters:
    :   - **use_face_step** (*boolean**,* *(**optional**)*) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
        - **use_topology_distance** (*boolean**,* *(**optional**)*) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
        - **use_fill** (*boolean**,* *(**optional**)*) – Fill Region, Select all paths between the source/destination elements
        - **skip** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Deselected, Number of deselected elements in the repetitive sequence
        - **nth** (*int in* *[**1**,* *inf**]**,* *(**optional**)*) – Selected, Number of selected elements in the repetitive sequence
        - **offset** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Offset, Offset from the starting point

bpy.ops.uv.smart_project(*\**, *angle_limit=1.15192*, *margin_method='SCALED'*, *rotate_method='AXIS_ALIGNED_Y'*, *island_margin=0.0*, *area_weight=0.0*, *correct_aspect=True*, *scale_to_bounds=False*)
:   Projection unwraps the selected faces of mesh objects

    Parameters:
    :   - **angle_limit** (*float in* *[**0**,* *1.5708**]**,* *(**optional**)*) – Angle Limit, Lower for more projection groups, higher for less distortion
        - **margin_method** (enum in [`'SCALED'`, `'ADD'`, `'FRACTION'`], (optional)) –

          Margin Method

          - `SCALED`
            Scaled – Use scale of existing UVs to multiply margin.
          - `ADD`
            Add – Just add the margin, ignoring any UV scale.
          - `FRACTION`
            Fraction – Specify a precise fraction of final UV output.
        - **rotate_method** (enum in [`'AXIS_ALIGNED'`, `'AXIS_ALIGNED_X'`, `'AXIS_ALIGNED_Y'`], (optional)) –

          Rotation Method

          - `AXIS_ALIGNED`
            Axis-aligned – Rotated to a minimal rectangle, either vertical or horizontal.
          - `AXIS_ALIGNED_X`
            Axis-aligned (Horizontal) – Rotate islands to be aligned horizontally.
          - `AXIS_ALIGNED_Y`
            Axis-aligned (Vertical) – Rotate islands to be aligned vertically.
        - **island_margin** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Island Margin, Margin to reduce bleed from adjacent islands
        - **area_weight** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Area Weight, Weight projection’s vector by faces with larger areas
        - **correct_aspect** (*boolean**,* *(**optional**)*) – Correct Aspect, Map UVs taking aspect ratio of the image associated with the material into account
        - **scale_to_bounds** (*boolean**,* *(**optional**)*) – Scale to Bounds, Scale UV coordinates to bounds after unwrapping

bpy.ops.uv.snap_cursor(*\**, *target='PIXELS'*)
:   Snap cursor to target type

    Parameters:
    :   **target** (enum in [`'PIXELS'`, `'SELECTED'`, `'ORIGIN'`], (optional)) – Target, Target to snap the selected UVs to

bpy.ops.uv.snap_selected(*\**, *target='PIXELS'*)
:   Snap selected UV vertices to target type

    Parameters:
    :   **target** (enum in [`'PIXELS'`, `'CURSOR'`, `'CURSOR_OFFSET'`, `'ADJACENT_UNSELECTED'`], (optional)) – Target, Target to snap the selected UVs to

bpy.ops.uv.sphere_project(*\**, *direction='VIEW_ON_EQUATOR'*, *align='POLAR_ZX'*, *pole='PINCH'*, *seam=False*, *correct_aspect=True*, *clip_to_bounds=False*, *scale_to_bounds=False*)
:   Project the UV vertices of the mesh over the curved surface of a sphere

    Parameters:
    :   - **direction** (enum in [`'VIEW_ON_EQUATOR'`, `'VIEW_ON_POLES'`, `'ALIGN_TO_OBJECT'`], (optional)) –

          Direction, Direction of the sphere or cylinder

          - `VIEW_ON_EQUATOR`
            View on Equator – 3D view is on the equator.
          - `VIEW_ON_POLES`
            View on Poles – 3D view is on the poles.
          - `ALIGN_TO_OBJECT`
            Align to Object – Align according to object transform.
        - **align** (enum in [`'POLAR_ZX'`, `'POLAR_ZY'`], (optional)) –

          Align, How to determine rotation around the pole

          - `POLAR_ZX`
            Polar ZX – Polar 0 is X.
          - `POLAR_ZY`
            Polar ZY – Polar 0 is Y.
        - **pole** (enum in [`'PINCH'`, `'FAN'`], (optional)) –

          Pole, How to handle faces at the poles

          - `PINCH`
            Pinch – UVs are pinched at the poles.
          - `FAN`
            Fan – UVs are fanned at the poles.
        - **seam** (*boolean**,* *(**optional**)*) – Preserve Seams, Separate projections by islands isolated by seams
        - **corr