Prints every page in the project to the console.

    Args:
        matching (str, optional): if given, only return names with this string in it
963638
def listEverything(matching=False):
    
    pages=pageNames()
    if matching:
        pages=[x for x in pages if matching in x]
    for i,page in enumerate(pages):
        pages[i]="%s%s (%s)"%(pageFolder(page),page,getPageType(page))
    print("\n".join(sorted(pages)))
906397
def getcols(sheetMatch=None,colMatch="Decay"):
    """"""
    book=BOOK()
    if sheetMatch is None:
        matchingSheets=book.sheetNames
        print('all %d sheets selected '%(len(matchingSheets)))
    else:
        matchingSheets=[x for x in book.sheetNames if sheetMatch in x]
        print('%d of %d sheets selected matching "%s"'%(len(matchingSheets),len(book.sheetNames),sheetMatch))
    matchingSheetsWithCol=[]
    for sheetName in matchingSheets:
        i = book.sheetNames.index(sheetName) # index of that sheet
        for j,colName in enumerate(book.sheets[i].colDesc):
            if colMatch in colName:
                matchingSheetsWithCol.append((sheetName,j))
                break
        else:
            print("  no match in [%s]%s"%(book.bookName,sheetName))
    print("%d of %d of those have your column"%(len(matchingSheetsWithCol),len(matchingSheets)))
    for item in matchingSheetsWithCol:
        print(item,item[0],item[1])
1249179
def print_runs(query):
    

    if query is None:
        return

    for tup in query:
        print(("{0} @ {1} - {2} id: {3} group: {4}".format(
            tup.end, tup.experiment_name, tup.project_name,
            tup.experiment_group, tup.run_group)))
1239618
def _do_print(self, cmd, args):
        
        name = args[0].strip()
        if not name:
            self.stderr.write('TODO: Display names of inspectable objects.\n')
            return
        try:
            code = textwrap.dedent(r'''
                    self.stdout.write(name + ':\n' + textwrap.indent(pprint.pformat({}), '    ') + '\n')
                    ''').format(name).strip()
            eval(code, globals(), locals())
        except NameError:
            self.stderr.write("p: name '{}' is not defined\n".format(name))
        self.stdout.flush()
1175980
def print_context_names(ctx, param, value):
    """"""
    if not value or ctx.resilient_parsing:
        return
    click.echo('\n'.join(_context_names()))
    ctx.exit()
932724
def print_facilities(self, facilities):
        
        for facility in facilities:
            print('{} - ({}): {}'.format(facility.code, facility.name, ",".join(facility.features)))
460558
final String printToString(boolean reportMismatchesOnly) {
    StringBuilder sb = new StringBuilder();

    if (!isMatched()) {
      sb.append("Differences were found:\n");
      printContents(/* includeMatches = */ false, /* fieldPrefix = */ "", sb);

      if (!reportMismatchesOnly && isAnyChildMatched()) {
        sb.append("\nFull diff report:\n");
        printContents(/* includeMatches = */ true, /* fieldPrefix = */ "", sb);
      }
    } else {
      sb.append("No differences were found.");
      if (!reportMismatchesOnly) {
        if (isAnyChildIgnored()) {
          sb.append("\nSome fields were ignored for comparison, however.\n");
        } else {
          sb.append("\nFull diff report:\n");
        }
        printContents(/* includeMatches = */ true, /* fieldPrefix = */ "", sb);
      }
    }

    return sb.toString();
  }
1231837
def ALL(self):
        
        if not self.sas.batch:
           for i in self._names:
               if i.upper()!='LOG':
                   x = self.__getattr__(i)
                   if isinstance(x, pd.DataFrame):
                      if self.sas.sascfg.display.lower() == 'zeppelin':
                         print("%text "+i+"\n"+str(x)+"\n")
                      else:
                         self.sas.DISPLAY(x)
        else:
           ret = []
           for i in self._names:
               if i.upper()!='LOG':
                   ret.append(self.__getattr__(i))
           return ret
1254589
def pagination_for(context, current_page, page_var="page", exclude_vars=""):
    
    querystring = context["request"].GET.copy()
    exclude_vars = [v for v in exclude_vars.split(",") if v] + [page_var]
    for exclude_var in exclude_vars:
        if exclude_var in querystring:
            del querystring[exclude_var]
    querystring = querystring.urlencode()
    return {
        "current_page": current_page,
        "querystring": querystring,
        "page_var": page_var,
    }
459956
def main(): # mini/unit test
    
    options = optionsParser().parse_args()
    params = getSelectionParams(options)
    if options.list or options.details:
        specifiedMaps = filterMapNames(
            options.mapname,
            records = filterMapAttrs(**params),
            excludeRegex=options.exclude,
            closestMatch=options.best
        )
        if specifiedMaps:
            for v in specifiedMaps:
                if options.details: v.display()
                else:               print(v)
            print("Found %d maps that match given criteria."%(len(specifiedMaps)))
        else:
            print("No matching maps found.")
    else:
        try:
            specifiedMaps = selectMap(
                options.mapname,
                excludeName =options.exclude,
                closestMatch=options.best,
                **params)
        except Exception as e:
            specifiedMaps = []
            print("No matching maps found: %s"%e)
        if not isinstance(specifiedMaps, list):
            specifiedMaps = [specifiedMaps]
        for m in specifiedMaps:
            if options.path:    print(m.path)
            else:               print(m.name)
883317
def htmlprint(*values, plain=None, **options):
    
    print(*[htmlrender(x, plain=plain) for x in values], **options)
11374
public void printXMLParams(PrintWriter out, ResourceBundle reg)
    {
        String PARAMS = "params";
        
        out.println(Utility.startTag(PARAMS));
        
        ServletTask task = (ServletTask)this.getTask();
        Map<String,Object> properties = task.getRequestProperties(task.getServletRequest(), true);	// Including the url/domain
        Map<String,Object> propUser = task.getApplication().getSystemRecordOwner().getProperties();
        Map<String,Object> propServlet = task.getApplication().getProperties();
        
        if (propUser != null)
        {
            for (String strKey : propUser.keySet())
            {
            	String value = DBConstants.BLANK;
            	if (propUser.get(strKey) != null)
            		value = propUser.get(strKey).toString();
            	if ((value.length() > 0)
            		|| ((propUser.get(strKey) == null) && (propServlet.get(strKey) == null)))	// If a user property override a default value, use it
            	{
            		out.print(Utility.startTag(strKey));
            		out.print(value);
            		out.println(Utility.endTag(strKey));
            	}
            }
        }
        for (String strKey : properties.keySet())
        {
            if ((propUser == null) || (propUser.get(strKey) == null) || (propUser.get(strKey).toString().length() == 0))
            {   // Only if it doesn't exist in user properties
                out.print(Utility.startTag(strKey));
                out.print((properties.get(strKey) != null) ? properties.get(strKey) : DBConstants.BLANK);
                out.println(Utility.endTag(strKey));
            }
        }
        for (String strKey : propServlet.keySet())
        {
            if ((propUser == null) || (propUser.get(strKey) == null) || (propUser.get(strKey).toString().length() == 0))
                if ((properties == null) || (properties.get(strKey) == null))
            {   // Only if it doesn't exist in user or app properties
                out.print(Utility.startTag(strKey));
                out.print((propServlet.get(strKey) != null) ? propServlet.get(strKey) : DBConstants.BLANK);
                out.println(Utility.endTag(strKey));
            }
        }
        
        out.println(Utility.endTag(PARAMS));
    }
1296650
def match_pagination(ref_line):
    """"""
    pattern = ur'\(?\[?(\d{1,4})\]?\)?\.?\s*$'
    re_footer = re.compile(pattern, re.UNICODE)
    match = re_footer.match(ref_line)
    if match:
        return int(match.group(1))
    return None
323894
def pretty_print_match(match, parameterized=True):
    """"""
    left_curly = '{{' if parameterized else '{'
    right_curly = '}}' if parameterized else '}'
    match = remove_custom_formatting(match)
    parts = re.split('({}|{})'.format(left_curly, right_curly), match)

    inside_braces = False
    indent_size = 4
    indent = ' ' * indent_size

    output = [parts[0]]
    for current_index, current_part in enumerate(parts[1:]):
        if current_part == left_curly:
            if inside_braces:
                raise AssertionError(u'Found open-braces pair while already inside braces: '
                                     u'{} {} {}'.format(current_index, parts, match))
            inside_braces = True
            output.append(current_part + '\n')
        elif current_part == right_curly:
            if not inside_braces:
                raise AssertionError(u'Found close-braces pair while not inside braces: '
                                     u'{} {} {}'.format(current_index, parts, match))
            inside_braces = False
            output.append(current_part)
        else:
            if not inside_braces:
                stripped_part = current_part.lstrip()
                if stripped_part.startswith('.'):
                    # Strip whitespace before traversal steps.
                    output.append(stripped_part)
                else:
                    # Do not strip whitespace before e.g. the RETURN keyword.
                    output.append(current_part)
            else:
                # Split out the keywords, initially getting rid of commas.
                separate_keywords = re.split(', ([a-z]+:)', current_part)

                # The first item in the separated list is the full first "keyword: value" pair.
                # For every subsequent item, the keyword and value are separated; join them
                # back together, outputting the comma, newline and indentation before them.
                output.append(indent + separate_keywords[0].lstrip())
                for i in six.moves.xrange(1, len(separate_keywords) - 1, 2):
                    output.append(',\n{indent}{keyword} {value}'.format(
                        keyword=separate_keywords[i].strip(),
                        value=separate_keywords[i + 1].strip(),
                        indent=indent))
                output.append('\n')

    return ''.join(output).strip()
700824
def list(self, **kwargs):
        
        projects = Project.select().order_by(Project.name)
        if len(projects) == 0:
            self._print('No projects available', 'yellow')
            return

        for project in projects:
            project_repr = self._PROJECT_ITEM.format(project.name, project.path)
            row = '- {}'.format(self._PROJECT_ITEM.format(project.name, project.path))
            six.print_(row)
392560
def by_name(self, name, archived=False, limit=None, page=None):
        
        # this only works with the exact name
        return super(Projects, self).by_name(name, archived=archived,
                                             limit=limit, page=page)
1353368
def print
      list.each do |entry|
        entry.headline ? print_headline(entry) : print_task_description(entry)
      end
    end