class_docstr: Wrap vtkProperty and expose it pythonically.
  
  This class is used to set the property of actors.
  
  Parameters
  ----------
  theme : pyvista.plotting.themes.Theme, optional
      Plot-specific theme.
  
  interpolation : str, default: :attr:`pyvista.plotting.themes._LightingConfig.interpolation`
      Set the method of shading. One of the following:
  
      * ``'Physically based rendering'`` - Physically based rendering.
      * ``'pbr'`` - Alias for Physically based rendering.
      * ``'Phong'`` - Phong shading.
      * ``'Gouraud'`` - Gouraud shading.
      * ``'Flat'`` - Flat Shading.
  
      This parameter is case insensitive.
  
  color : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.color`
      Used to make the entire mesh have a single solid color.
      Either a string, RGB list, or hex color string.  For example:
      ``color='white'``, ``color='w'``, ``color=[1.0, 1.0, 1.0]``, or
      ``color='#FFFFFF'``. Color will be overridden if scalars are
      specified.
  
  style : str, default: 'surface'
      Visualization style of the mesh.  One of the following:
      ``style='surface'``, ``style='wireframe'``, ``style='points'``.
      Note that ``'wireframe'`` only shows a wireframe of the outer
      geometry.
  
  metallic : float, default: :attr:`pyvista.plotting.themes._LightingConfig.metallic`
      Usually this value is either 0 or 1 for a real material but any
      value in between is valid. This parameter is only used by PBR
      interpolation.
  
  roughness : float, default: :attr:`pyvista.plotting.themes._LightingConfig.roughness`
      This value has to be between 0 (glossy) and 1 (rough). A glossy
      material has reflections and a high specular part. This parameter
      is only used by PBR interpolation.
  
  point_size : float, default: :attr:`pyvista.plotting.themes.Theme.point_size`
      Size of the points represented by this property.
  
  opacity : float, default: :attr:`pyvista.plotting.themes.Theme.opacity`
      Opacity of the mesh. A single float value that will be applied globally
      opacity of the mesh and uniformly applied everywhere - should be
      between 0 and 1.
  
  ambient : float, default: :attr:`pyvista.plotting.themes._LightingConfig.ambient`
      When lighting is enabled, this is the amount of light in the range
      of 0 to 1 that reaches the actor when not directed at the light
      source emitted from the viewer.
  
  diffuse : float, default: :attr:`pyvista.plotting.themes._LightingConfig.diffuse`
      The diffuse lighting coefficient.
  
  specular : float, default: :attr:`pyvista.plotting.themes._LightingConfig.specular`
      The specular lighting coefficient.
  
  specular_power : float, default: :attr:`pyvista.plotting.themes._LightingConfig.specular_power`
      The specular power. Must be between 0.0 and 128.0.
  
  show_edges : bool, default: :attr:`pyvista.plotting.themes.Theme.show_edges`
      Shows the edges.  Does not apply to a wireframe representation.
  
  edge_color : ColorLike, default: :attr:`pyvista.plotting.themes.Theme.edge_color`
      The solid color to give the edges when ``show_edges=True``.
      Either a string, RGB list, or hex color string.
  
  render_points_as_spheres : bool, default: :attr:`pyvista.plotting.themes.Theme.render_points_as_spheres`
      Render points as spheres rather than dots.
  
  render_lines_as_tubes : bool, default: :attr:`pyvista.plotting.themes.Theme.render_lines_as_tubes`
      Show lines as thick tubes rather than flat lines.  Control
      the width with ``line_width``.
  
  lighting : bool, default: :attr:`pyvista.plotting.themes.Theme.lighting`
      Enable or disable view direction lighting.
  
  line_width : float, default: :attr:`pyvista.plotting.themes.Theme.line_width`
      Thickness of lines.  Only valid for wireframe and surface
      representations.
  
  culling : str | bool, optional
      Does not render faces that are culled. This can be helpful for
      dense surface meshes, especially when edges are visible, but can
      cause flat meshes to be partially displayed. Defaults to
      ``'none'``. One of the following:
  
      * ``"back"`` - Enable backface culling
      * ``"front"`` - Enable frontface culling
      * ``'none'`` - Disable both backface and frontface culling
  
  edge_opacity : float, default: :attr:`pyvista.plotting.themes.Theme.edge_opacity`
      Edge opacity of the mesh. A single float value that will be applied globally
      edge opacity of the mesh and uniformly applied everywhere - should be
      between 0 and 1.
  
      .. note::
          `edge_opacity` uses ``SetEdgeOpacity`` as the underlying method which
          requires VTK version 9.3 or higher. If ``SetEdgeOpacity`` is not
          available, `edge_opacity` is set to 1.
  
  Examples
  --------
  Create a :class:`pyvista.Actor` and assign properties to it.
  
  >>> import pyvista as pv
  >>> actor = pv.Actor()
  >>> actor.prop = pv.Property(
  ...     color='r',
  ...     show_edges=True,
  ...     interpolation='Physically based rendering',
  ...     metallic=0.5,
  ...     roughness=0.1,
  ... )
  
  Visualize how the property would look when applied to a mesh.
  
  >>> actor.prop.plot()
  
  Set custom properties not directly available in
  :func:`pyvista.Plotter.add_mesh`. Here, we set diffuse, ambient, and
  specular power and colors.
  
  >>> pl = pv.Plotter()
  >>> actor = pl.add_mesh(pv.Sphere())
  >>> prop = actor.prop
  >>> prop.diffuse = 0.6
  >>> prop.diffuse_color = 'w'
  >>> prop.ambient = 0.3
  >>> prop.ambient_color = 'r'
  >>> prop.specular = 0.5
  >>> prop.specular_color = 'b'
  >>> pl.show()
code: def render_lines_as_tubes(self, value: bool):  # numpydoc ignore=GL08
      self.SetRenderLinesAsTubes(value)
  
imports: from typing import Union
  import pyvista
  from pyvista import vtk_version_info
  from pyvista.core.utilities.misc import _check_range, no_new_attr
  from .None import _vtk
  from .colors import Color
  from .opts import InterpolationType
label_desc: Use image node_id 33 for calling the Property obj's underlying member method code with example usage: obj.render_lines_as_tubes(value) without return types