Create a copy of the current one.
19759
def copy(self):
        """"""
        rv = object.__new__(self.__class__)
        rv.__dict__.update(self.__dict__)
        rv.symbols = self.symbols.copy()
        return rv
753944
def copy(self):
        """"""
        result = self.space.element()
        result.assign(self)
        return result
1297498
def copy(self):
        """"""
        attrs = {k: self.__dict__[k].copy() for k in self.containers}
        attrs.update({k: cp.deepcopy(self.__dict__[k]) for k in self.shared})
        return self.__class__(**attrs)
369500
def copy(self):
        """"""
        ret = self.__class__(self.callback, **self.__original_kwargs__)
        return self._ensure_assignment_on_copy(ret)
684583
def copy(self):
        
        # new objects are constructed for each, so we just need to pass them in
        return BinaryQuadraticModel(self.linear, self.quadratic, self.offset, self.vartype, **self.info)
423209
def copy(self):
        """"""
        animation = AnimationList()
        animation.set_frame_rate(self.frame_rate)
        animation.__coords = self.__coords
        animation.__horizontal_flip = self.__horizontal_flip
        animation.__vertical_flip = self.__vertical_flip
        animation.should_repeat = self.should_repeat
        animation.draw_order = self.draw_order
        animation.update_order = self.update_order
        for image in self.images:
            new_image = Sprite()
            new_image.coords = image.coords
            new_image.apply_texture(image.image)
            animation.images.append(new_image)

        return animation
1265146
def copy(self, name=None, prefix=None):
        """"""
        setting = self.__class__.__new__(self.__class__)
        setting.__dict__.update(self.__dict__)
        # Keep the modified flag?
        # setting.modified = False
        if prefix and not setting.is_global:
            flags = setting.flags
            # Prefix a setting
            setting.orig_name = setting.name
            setting.name = '%s_%s' % (prefix, setting.name)
            if flags and flags[-1].startswith('--'):
                setting.flags = ['--%s-%s' % (prefix, flags[-1][2:])]
        if name and not setting.is_global:
            setting.short = '%s application. %s' % (name, setting.short)
        return setting
595299
def copy(self):
        
        c = copy.deepcopy(self)
        for key in c.conns:
            c.conns[key] = self.conns[key].copy()
        return c
771557
def copy(self):
        
        result = copy.deepcopy(self)
        result._cache.clear()
        return result
887395
def copy(self):
        """"""
        if self.has_selected_text():
            ConsoleBaseWidget.copy(self)
        elif not sys.platform == 'darwin':
            self.interrupt()
211980
def clone(self):
    """"""
    return type(self)(self.__cmp, self.__key, self.__reverse, name = self.name, dataFormat = self._dataFormat)
442076
def copy(self):
        """"""
        o = self.__class__(self.project, self.name)
        Scriptable.copy(self, o)
        o.position = tuple(self.position)
        o.direction = self.direction
        o.rotation_style = self.rotation_style
        o.size = self.size
        o.is_draggable = self.is_draggable
        o.is_visible = self.is_visible
        return o
531821
def _copy(self):
    """"""
    copied_uri = Uri(self.uri.scheme, self.uri.host, self.uri.port,
                     self.uri.path, self.uri.query.copy())
    new_request = HttpRequest(uri=copied_uri, method=self.method,
                              headers=self.headers.copy())
    new_request._body_parts = self._body_parts[:]
    return new_request
500020
def copy(self):
        """"""
        other = ContextModel(self._context, self.parent())
        other._stale = self._stale
        other._modified = self._modified
        other.request = self.request[:]
        other.packages_path = self.packages_path
        other.implicit_packages = self.implicit_packages
        other.package_filter = self.package_filter
        other.caching = self.caching
        other.default_patch_lock = self.default_patch_lock
        other.patch_locks = copy.deepcopy(self.patch_locks)
        return other
1236620
def copy(self):
        '''  '''
        # TODO
        copy = Response()
        copy.status = self.status
        copy._headers = dict((k, v[:]) for (k, v) in self._headers.items())
        return copy
604577
def copy(self, *args, **kw):
        """"""
        if not self._loaded:
            self.load_config()
        return super(FedmsgConfig, self).copy(*args, **kw)
1046983
def copy(self):
        """"""
        return self._fromset(set(self._set), key=self._key)