code: def build_lane_from_yaml(path):
      
      # Open
      with open(path, 'rb') as yaml_definition:
          definition = yaml.load(yaml_definition)
  
      # Validate schema
      try:
          validate_schema(definition)
      except SchemaError as exc:
          raise LaneSchemaError(**exc.__dict__)
  
      def build(lb_def, branch=False):
          """Function to recursively build the `sparklanes.Lane` object from a YAML definition"""
          init_kwargs = {k: lb_def[k] for k in (a for a in ('run_parallel', 'name') if a in lb_def)}
          lane_or_branch = Lane(**init_kwargs) if not branch else Branch(**init_kwargs)
  
          for task in lb_def['tasks']:
              if 'branch' in task:
                  branch_def = task['branch']
                  lane_or_branch.add(build(branch_def, True))
              else:
                  sep = task['class'].rfind('.')
                  if sep == -1:
                      raise LaneImportError('Class must include its parent module')
                  mdl = task['class'][:sep]
                  cls_ = task['class'][sep + 1:]
  
                  try:
                      cls = getattr(import_module(mdl), cls_)
                  except ImportError:
                      raise LaneImportError('Could not find module %s' % mdl)
                  except AttributeError:
                      raise LaneImportError('Could not find class %s' % cls_)
  
                  args = task['args'] if 'args' in task else []
                  args = [args] if not isinstance(args, list) else args
                  kwargs = task['kwargs'] if 'kwargs' in task else {}
                  lane_or_branch.add(cls, *args, **kwargs)
  
          return lane_or_branch
  
      return build(definition['lane'])
docs: Builds a `sparklanes.Lane` object from a YAML definition file.
  
      Parameters
      ----------
      path: str
          Path to the YAML definition file
  
      Returns
      -------
      Lane
          Lane, built according to definition in YAML file