Creates a new thin clone from this snapshot.
        .. note:: this snapshot should not enable Auto-Delete.
761154
def thin_clone(self, name, io_limit_policy=None, description=None):
        
        if self.is_member_snap():
            raise UnityCGMemberActionNotSupportError()

        if self.lun and not self.lun.is_thin_enabled:
            raise UnityThinCloneNotAllowedError()

        return TCHelper.thin_clone(self._cli, self, name, io_limit_policy,
                                   description)
94608
def clonerepo(barerepo, userrepo):
    

    git.clone(barerepo, userrepo)
    ag = activegit.ActiveGit(userrepo)
1280196
def clone(src, **kwargs):
    """"""
    obj = object.__new__(type(src))
    obj.__dict__.update(src.__dict__)
    obj.__dict__.update(kwargs)
    return obj
117092
def clone(self) -> "Event":
        
        return self.__class__(copy.deepcopy(self.event), copy.deepcopy(self.metadata))
39171
def clone(self):
        

        p = type(self)(self.id)
        p.hooks = list(self.hooks)
        p.instance = self.instance
        return p
123804
def clone_(self, quiet=False):
        
        ds2 = self._duplicate_(quiet=True)
        if ds2 is None:
            self.err("Can not clone instance")
        else:
            if quiet is False:
                self.ok("Instance cloned")
        return ds2
1361510
def clone(self):
		
		snapshot = DistributionSnapshot(self.distribution(), self.go_version)
		for package in self.builds:
			snapshot.setRpms(package, self.builds[package]["build"], self.builds[package]["build_ts"], self.builds[package]["rpms"])

		return snapshot
831499
def clone(self, spawn_mapping=None):
        
        c = self.spawn(spawn_mapping)
        self.register_clone(c)
        c.register_parent(self)
        return c
152694
def clone_subtree start_node 
      new_tree = self.class.new
      list = [start_node] + start_node.descendents
      list.each do |x|
        new_tree.add_node(x)
      end
      each_edge do |node1, node2, edge|
        if new_tree.include?(node1) and new_tree.include?(node2) 
          new_tree.add_edge(node1, node2, edge)
        end
      end
      new_tree
    end
947049
def clone(self):
        

        new_solution = self.__class__(self._problem, len(self._routes))

        # Clone routes
        for index, r in enumerate(self._routes):
            new_route = new_solution._routes[index]
            for node in r.nodes():
                # Insere new node on new route
                new_node = new_solution._nodes[node]
                new_route.allocate([new_node])

        return new_solution
1327771
def clone(self):
        
        from copy import copy
        clone = copy(self)
        clone.expr = copy(self.expr)
        clone.factory = False
        return clone
384235
def clone(self, population):
        
        new = empty_clone(self)
        new_dict = new.__dict__

        for key, value in self.__dict__.items():
            if key not in ('population', 'formula', 'simulation'):
                new_dict[key] = value

        new_dict['population'] = population
        new_dict['simulation'] = population.simulation

        return new
106933
def clone(self, new_object):
        
        return self.__class__(new_object, self.method, self.name)
918866
def clone(self):
        
        clone = copy.copy(self)
        clone._unused = clone._unused.clone()
        return clone
616533
def clone(self, name=None):
        
        ret = self.copy_template().insert_many(self.obs)(name)
        return ret
543271
def _clone(self):
        
        s = super(Search, self)._clone()

        s._response_class = self._response_class
        s._sort = self._sort[:]
        s._source = copy.copy(self._source) \
            if self._source is not None else None
        s._highlight = self._highlight.copy()
        s._highlight_opts = self._highlight_opts.copy()
        s._suggest = self._suggest.copy()
        s._script_fields = self._script_fields.copy()
        for x in ('query', 'post_filter'):
            getattr(s, x)._proxied = getattr(self, x)._proxied

        # copy top-level bucket definitions
        if self.aggs._params.get('aggs'):
            s.aggs._params = {'aggs': self.aggs._params['aggs'].copy()}
        return s
438147
def clone(self, **data):
        '''
'''
        meta = self._meta
        session = self.session
        pkname = meta.pkname()
        pkvalue = data.pop(pkname, None)
        fields = self.todict(exclude_cache=True)
        fields.update(data)
        fields.pop('__dbdata__', None)
        obj = self._meta.make_object((pkvalue, None, fields))
        obj.session = session
        return obj