Deletes all vision styles except for default style

        :param verbose: print more

        :returns: default: successful operation
6552
def deleteAllStyles(self, verbose=None):
        

        response=api(url=self.___url+'styles', method="DELETE", verbose=verbose)
        return response
1117708
def clear(self, color: Tuple[int, int, int]) -> None:
        
        lib.TCOD_image_clear(self.image_c, color)
715842
def print_verbose(self):
        """"""
        print "Nodes: "
        for a in (self.nodes(failed="all")):
            print a

        print "\nVectors: "
        for v in (self.vectors(failed="all")):
            print v

        print "\nInfos: "
        for i in (self.infos(failed="all")):
            print i

        print "\nTransmissions: "
        for t in (self.transmissions(failed="all")):
            print t

        print "\nTransformations: "
        for t in (self.transformations(failed="all")):
            print t
1137383
def verbose(self_,msg,*args,**kw):
        
        self_.__db_print(VERBOSE,msg,*args,**kw)
317002
def remove_all_lvs(self):
        
        lvs = self.lvscan()
        for lv in lvs:
            self.remove_lv(lv)
632444
public void remove(String applicationName, Class<?> robotContext, boolean verbose) {
        logger.info("Remove application named [{}].", applicationName);
        removeApplicationPages(applicationName, robotContext, verbose);
        removeApplicationSteps(applicationName, robotContext, verbose);
        removeApplicationModel(applicationName, robotContext, verbose);
        removeApplicationContext(robotContext, applicationName, verbose);
        removeApplicationSelector(applicationName, verbose);
        removeApplicationInPropertiesFile(applicationName, robotContext.getSimpleName().replaceAll("Context", ""), verbose);
        removeApplicationInEnvPropertiesFile(applicationName, "ci", verbose);
        removeApplicationInEnvPropertiesFile(applicationName, "dev", verbose);
        removeApplicationInEnvPropertiesFile(applicationName, "prod", verbose);
    }
994448
public final ZMonitor verbose(boolean verbose)
    {
        if (started) {
            System.out.println("ZMonitor: Unable to change verbosity while already started.");
            return this;
        }
        agent.send(VERBOSE, true);
        agent.send(Boolean.toString(verbose));
        agent.recv();
        return this;
    }
1096548
def reset_default(verbose=False):
    """"""
    paths = [jupyter_custom, jupyter_nbext]

    for fpath in paths:
        custom = '{0}{1}{2}.css'.format(fpath, os.sep, 'custom')
        try:
            os.remove(custom)
        except Exception:
            pass
    try:
        delete_font_files()
    except Exception:
        check_directories()
        delete_font_files()

    copyfile(defaultCSS, jupyter_customcss)
    copyfile(defaultJS, jupyter_customjs)

    if os.path.exists(theme_name_file):
        os.remove(theme_name_file)

    if verbose:
        print("Reset css and font defaults in:\n{} &\n{}".format(*paths))
1105462
def verbose(self, msg, *args, **kw):
        """"""
        if self.isEnabledFor(VERBOSE):
            self._log(VERBOSE, msg, args, **kw)
834726
def update_style(self, title=None,defaults=None,mappings=None, verbose=False):
        
        u=self.__url
        host=u.split("//")[1].split(":")[0]
        port=u.split(":")[2].split("/")[0]
        version=u.split(":")[2].split("/")[1]

        if defaults:
            defaults_=[]
            for d in defaults:
                if d:
                    defaults_.append(d)
            defaults=defaults_

        if mappings:
            mappings_=[]
            for m in mappings:
                if m:
                    mappings_.append(m)
            mappings=mappings_

        URL="http://"+str(host)+":"+str(port)+"/v1/styles/"+str(title)
        if verbose:
            print(URL)
            sys.stdout.flush()

        response = requests.get(URL).json()

        olddefaults=response["defaults"]
        oldmappings=response["mappings"]

        if mappings:
            mappings_visual_properties=[ m["visualProperty"] for m in mappings ]
            newmappings=[ m for m in oldmappings if m["visualProperty"] not in mappings_visual_properties ]
            for m in mappings:
                newmappings.append(m)
        else:
            newmappings=oldmappings

        if defaults:
            defaults_visual_properties=[ m["visualProperty"] for m in defaults ]
            newdefaults=[ m for m in olddefaults if m["visualProperty"] not in defaults_visual_properties ]
            for m in defaults:
                newdefaults.append(m)
        else:
            newdefaults=olddefaults

        r=requests.delete(URL)
        checkresponse(r)

        URL="http://"+str(host)+":"+str(port)+"/v1/styles"
        PARAMS={"title":title,\
            "defaults":newdefaults,\
            "mappings":newmappings}
        r = requests.post(url = URL, json = PARAMS)
        checkresponse(r)
663639
def remove_existing_fpaths(fpath_list, verbose=VERBOSE, quiet=QUIET,
                           strict=False, print_caller=PRINT_CALLER,
                           lbl='files'):
    
    import utool as ut
    if print_caller:
        print(util_dbg.get_caller_name(range(1, 4)) + ' called remove_existing_fpaths')
    fpath_list_ = ut.filter_Nones(fpath_list)
    exists_list = list(map(exists, fpath_list_))
    if verbose:
        n_total = len(fpath_list)
        n_valid = len(fpath_list_)
        n_exist = sum(exists_list)
        print('[util_path.remove_existing_fpaths] request delete of %d %s' % (
            n_total, lbl))
        if n_valid != n_total:
            print(('[util_path.remove_existing_fpaths] '
                   'trying to delete %d/%d non None %s ') %
                  (n_valid, n_total, lbl))
        print(('[util_path.remove_existing_fpaths] '
               ' %d/%d exist and need to be deleted')
              % (n_exist, n_valid))
    existing_fpath_list = ut.compress(fpath_list_, exists_list)
    return remove_fpaths(existing_fpath_list, verbose=verbose, quiet=quiet,
                            strict=strict, print_caller=False, lbl=lbl)
459431
def pformat(obj, verbose=False):
    
    try:
        from pretty import pretty
        return pretty(obj, verbose=verbose)
    except ImportError:
        from pprint import pformat
        return pformat(obj)
1014312
def remove_fpaths(fpaths, verbose=VERBOSE, quiet=QUIET, strict=False,
                  print_caller=PRINT_CALLER, lbl='files'):
    
    import utool as ut
    if print_caller:
        print(util_dbg.get_caller_name(range(1, 4)) + ' called remove_fpaths')
    n_total = len(fpaths)
    _verbose = (not quiet and n_total > 0) or VERYVERBOSE
    if _verbose:
        print('[util_path.remove_fpaths] try removing %d %s' % (n_total, lbl))
    n_removed = 0
    prog = ut.ProgIter(fpaths, label='removing files', enabled=verbose)
    _iter = iter(prog)
    # Try to be fast at first
    try:
        for fpath in _iter:
            os.remove(fpath)
            n_removed += 1
    except OSError as ex:
        # Buf if we fail put a try in the inner loop
        if VERYVERBOSE:
            print('WARNING: Could not remove fpath = %r' % (fpath,))
        if strict:
            util_dbg.printex(ex, 'Could not remove fpath = %r' % (fpath,),
                             iswarning=False)
            raise
        for fpath in _iter:
            try:
                os.remove(fpath)
                n_removed += 1
            except OSError as ex:
                if VERYVERBOSE:
                    print('WARNING: Could not remove fpath = %r' % (fpath,))
    if _verbose:
        print('[util_path.remove_fpaths] ... removed %d / %d %s' % (
            n_removed, n_total, lbl))
    return n_removed
340700
def clear_text(self):
        
        # Implemented from template for osid.repository.AssetForm.clear_title_template
        if (self.get_text_metadata().is_read_only() or
                self.get_text_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['text'] = dict(self._text_default)
1227268
def clear(self):
        
        self._decorations[:] = []
        try:
            self.editor.setExtraSelections(self._decorations)
        except RuntimeError:
            pass
722547
def delete(self, verbose=True):
        
        conn = self.connection
        already_in_transaction = conn.in_transaction
        safe = config['safemode']
        if already_in_transaction and safe:
            raise DataJointError('Cannot delete within a transaction in safemode. '
                                 'Set dj.config["safemode"] = False or complete the ongoing transaction first.')
        graph = conn.dependencies
        graph.load()
        delete_list = collections.OrderedDict(
            (name, _rename_map(next(iter(graph.parents(name).items()))) if name.isdigit() else FreeTable(conn, name))
            for name in graph.descendants(self.full_table_name))

        # construct restrictions for each relation
        restrict_by_me = set()
        # restrictions: Or-Lists of restriction conditions for each table.
        # Uncharacteristically of Or-Lists, an empty entry denotes "delete everything".
        restrictions = collections.defaultdict(list)
        # restrict by self
        if self.restriction:
            restrict_by_me.add(self.full_table_name)
            restrictions[self.full_table_name].append(self.restriction)  # copy own restrictions
        # restrict by renamed nodes
        restrict_by_me.update(table for table in delete_list if table.isdigit())  # restrict by all renamed nodes
        # restrict by secondary dependencies
        for table in delete_list:
            restrict_by_me.update(graph.children(table, primary=False))   # restrict by any non-primary dependents

        # compile restriction lists
        for name, table in delete_list.items():
            for dep in graph.children(name):
                # if restrict by me, then restrict by the entire relation otherwise copy restrictions
                restrictions[dep].extend([table] if name in restrict_by_me else restrictions[name])

        # apply restrictions
        for name, table in delete_list.items():
            if not name.isdigit() and restrictions[name]:  # do not restrict by an empty list
                table.restrict([
                    r.proj() if isinstance(r, FreeTable) else (
                        delete_list[r[0]].proj(**{a: b for a, b in r[1]['attr_map'].items()})
                        if isinstance(r, _rename_map) else r)
                    for r in restrictions[name]])
        if safe:
            print('About to delete:')

        if not already_in_transaction:
            self.connection.start_transaction()
        total = 0
        try:
            for name, table in reversed(list(delete_list.items())):
                if not name.isdigit():
                    count = table.delete_quick(get_count=True)
                    total += count
                    if (verbose or safe) and count:
                        print('{table}: {count} items'.format(table=name, count=count))
        except:
            # Delete failed, perhaps due to insufficient privileges. Cancel transaction.
            if not already_in_transaction:
                self.connection.cancel_transaction()
            raise
        else:
            assert not (already_in_transaction and safe)
            if not total:
                print('Nothing to delete')
                if not already_in_transaction:
                    self.connection.cancel_transaction()
            else:
                if already_in_transaction:
                    if verbose:
                        print('The delete is pending within the ongoing transaction.')
                else:
                    if not safe or user_choice("Proceed?", default='no') == 'yes':
                        self.connection.commit_transaction()
                        if verbose or safe:
                            print('Committed.')
                    else:
                        self.connection.cancel_transaction()
                        if verbose or safe:
                            print('Cancelled deletes.')
109715
def delete(self,*args):
		
		if args:
			args=args[0] if utils.is_list(args[0]) else args
			path=utils.dict_path(self.__dict__)
			for _ in args:
				if _ in self.__dict__.keys():
					raise Exception('"{0}" cannot be deleted'.format(_))

			for a in args:
				try:
					if a in ('shapes'):
						self.layout[a].clear()
					elif a=='annotations':
						self.layout['annotations']={'values':[],'params':{}}
					else:
						del reduce(dict.get, path[a],self.__dict__)[a]
				except:
					raise Exception('Key: {0} not found'.format(a))