Returns: classes.PageXml
484645
public function CreatePage() 
	{
		parent::CreatePage();
		
		$onlyGroup = ($this->_context->get("onlygroup") != "");
		$urlXml = "module:Xmlnuke.Admin.ManageXML";
		$urlGrp = "module:Xmlnuke.Admin.ManageGroup";

		$this->myWords = $this->WordCollection();
		$this->setTitlePage($this->myWords->Value("TITLE"));
		$this->setHelp($this->myWords->Value("DESCRIPTION"));
		
		if (!$onlyGroup)
		{
			$this->addMenuOption($this->myWords->Value("EDITALLXML"), $urlXml."?id=_all");
			$this->addMenuOption($this->myWords->Value("NEWXML"), $urlXml);
		}
		$this->addMenuOption($this->myWords->Value("NEWGROUP"), $urlGrp);
		
		// Open Index File
		$indexFile = new XMLFilenameProcessor("index");
		//XmlDocument 
		
		$index = $this->_context->getXMLDataBase()->getDocument($indexFile->FullQualifiedName(),null);

		$groupList = XmlUtil::SelectNodes($index->documentElement,"group");
		$table = new XmlTableCollection();
		foreach( $groupList as $node )					
		{				
			
			$groupText = XmlUtil::SelectSingleNode($node,"title")->nodeValue;
			$groupId = XmlUtil::SelectSingleNode($node,"id")->nodeValue;
			
			$row = new XmlTableRowCollection();

			$col = new XmlTableColumnCollection();
			$anchor = new XmlAnchorCollection($urlGrp."?id=".$groupId, "");
			$anchor->addXmlnukeObject(new XmlnukeText($this->myWords->Value("TXT_EDIT"), true, false, false));
			$col->addXmlnukeObject($anchor);
			$row->addXmlnukeObject($col);
			
			$col = new XmlTableColumnCollection();
			$anchor = new XmlAnchorCollection($urlGrp."?id=".$groupId."&action=delete", "");
			$anchor->addXmlnukeObject(new XmlnukeText($this->myWords->Value("TXT_DELETE"), true, false, false));
			$col->addXmlnukeObject($anchor);
			$row->addXmlnukeObject($col);

			$col = new XmlTableColumnCollection();
			$col->addXmlnukeObject(new XmlnukeText($groupText, true, false, false));
			$row->addXmlnukeObject($col);
			$table->addXmlnukeObject($row);

			if (!$onlyGroup)
			{
				$fileList = XmlUtil::SelectNodes($index->documentElement,"group[id='".$groupId."']/page");
				foreach( $fileList as $nodeFile )
				{
					$fileText = XmlUtil::SelectSingleNode($nodeFile,"title")->nodeValue;
					$fileId = XmlUtil::SelectSingleNode($nodeFile,"id")->nodeValue;
					$fileAbstract = XmlUtil::SelectSingleNode($nodeFile,"summary")->nodeValue;

					$row = new XmlTableRowCollection();
					
					$col = new XmlTableColumnCollection();
					$anchor = new XmlAnchorCollection($urlXml."?id=".$fileId, "");
					$anchor->addXmlnukeObject(new XmlnukeText($this->myWords->Value("TXT_EDIT")));
					$col->addXmlnukeObject($anchor);
					$row->addXmlnukeObject($col);
					
					$col = new XmlTableColumnCollection();
					$anchor = new XmlAnchorCollection($urlXml."?id=".$fileId."&action=delete", "");
					$anchor->addXmlnukeObject(new XmlnukeText($this->myWords->Value("TXT_DELETE")));
					$col->addXmlnukeObject($anchor);
					$row->addXmlnukeObject($col);
	
					$col = new XmlTableColumnCollection();
					$col->addXmlnukeObject(new XmlnukeText($fileText));
					$col->addXmlnukeObject(new XmlnukeBreakLine());
					$col->addXmlnukeObject(new XmlnukeText($fileAbstract, false, true, false));
					$row->addXmlnukeObject($col);
					$table->addXmlnukeObject($row);

				}
			}
		
		}
		
		$block = new XmlBlockCollection($this->myWords->Value("WORKINGAREA"), BlockPosition::Center );

		$paragraph = new XmlParagraphCollection();
		$paragraph->addXmlnukeObject($table);
		$block->addXmlnukeObject($paragraph);
		$this->defaultXmlnukeDocument->addXmlnukeObject($block);
		
		return $this->defaultXmlnukeDocument->generatePage();
	}
1180604
def page(self, value):
        

        instance = copy(self)

        instance._filters.append({
            'page': value
        })
        return instance
518487
def xpath_page(request, uuid, version):
    """"""
    xpath_string = request.params.get('q')
    return execute_xpath(xpath_string, 'xpath-module', uuid, version)
92536
def extract_data(self, page):
        """"""
        response_keys = set(page.keys())
        uncommon_keys = response_keys - self.common_keys

        for possible_data_key in uncommon_keys:
            element = page[possible_data_key]
            if isinstance(element, dict):
                return [self.representation(self.client, self.service_name,
                                            element)]
            if isinstance(element, list):
                return [self.representation(self.client, self.service_name, x)
                        for x in element]
385662
def get_queryset(self):
        '''
        
        '''
        queryset = super(PageList, self).get_queryset()
        if hasattr(self.request, 'site_id'):
            queryset = queryset.filter(site_id=self.request.site_id)
        return queryset
1260503
def get_page_children_dict(self, page_qs=None):
        
        children_dict = defaultdict(list)
        for page in page_qs or self.pages_for_display:
            children_dict[page.path[:-page.steplen]].append(page)
        return children_dict
866767
private List getXmlPages() {

        boolean isRecursive = Boolean.valueOf(getParamRecursive()).booleanValue();
        // filter definition to read only the required resources
        int xmlPageId;
        try {
            xmlPageId = OpenCms.getResourceManager().getResourceType(
                CmsResourceTypeXmlPage.getStaticTypeName()).getTypeId();
        } catch (CmsLoaderException e1) {
            xmlPageId = CmsResourceTypeXmlPage.getStaticTypeId();
        }
        CmsResourceFilter filter = CmsResourceFilter.IGNORE_EXPIRATION.addRequireType(xmlPageId);
        // trying to read the resources
        List xmlPages = null;

        try {
            xmlPages = getCms().readResources(getParamResource(), filter, isRecursive);
        } catch (CmsException e) {
            if (LOG.isErrorEnabled()) {
                LOG.error(e.getLocalizedMessage(), e);
            }
        }

        return xmlPages;
    }
1136683
def xpath(self, xpath_str):
        
        return super(BaseOxmlElement, self).xpath(
            xpath_str, namespaces=nsmap
        )
360212
def page(content, pagecallback=prompt):
    
    width = getwidth()
    height = getheight()
    pagenum = 1

    try:
        try:
            line = content.next().rstrip("\r\n")
        except AttributeError:
            # Python 3 compatibility
            line = content.__next__().rstrip("\r\n")
    except StopIteration:
        pagecallback(pagenum)
        return

    while True:     # page cycle
        linesleft = height-1 # leave the last line for the prompt callback
        while linesleft:
            linelist = [line[i:i+width] for i in range(0, len(line), width)]
            if not linelist:
                linelist = ['']
            lines2print = min(len(linelist), linesleft)
            for i in range(lines2print):
                if WINDOWS and len(line) == width:
                    # avoid extra blank line by skipping linefeed print
                    echo(linelist[i])
                else:
                    print((linelist[i]))
            linesleft -= lines2print
            linelist = linelist[lines2print:]

            if linelist: # prepare symbols left on the line for the next iteration
                line = ''.join(linelist)
                continue
            else:
                try:
                    try:
                        line = content.next().rstrip("\r\n")
                    except AttributeError:
                        # Python 3 compatibility
                        line = content.__next__().rstrip("\r\n")
                except StopIteration:
                    pagecallback(pagenum)
                    return
        if pagecallback(pagenum) == False:
            return
        pagenum += 1
1208974
def get_pages(self):
        
        resp = self._client._call('GetProxies', proto.GetProxiesRequest())
        return {i.route: ProxiedPage(i.route, i.target,
                                     i.link_name if i.link_name else None,
                                     self.address, self.proxy_prefix)
                for i in resp.proxy}
473343
def _get_bookmarks(self):
        
        res = yield from self._private_xml.get_private_xml(
            bookmark_xso.Storage()
        )

        return res.registered_payload.bookmarks
625184
def getXML(self):
        
        s = ''
        for element in self._svgElements:
            s += element.getXML()
        return s
185788
def getLinks(page):
    

    CheckParent(page)
    ln = page.firstLink
    links = []
    while ln:
        nl = getLinkDict(ln)
        if nl["kind"] == LINK_GOTO:
            if type(nl["to"]) is Point and nl["page"] >= 0:
                doc = page.parent
                target_page = doc[nl["page"]]
                ctm = target_page._getTransformation()
                point = nl["to"] * ctm
                nl["to"] = point
        links.append(nl)
        ln = ln.next
    if len(links) > 0:
        linkxrefs = page._getLinkXrefs()
        if len(linkxrefs) == len(links):
            for i in range(len(linkxrefs)):
                links[i]["xref"] = linkxrefs[i]
    return links
60547
def pq(self) -> PyQuery:
        
        if self._pq is None:
            self._pq = PyQuery(self.lxml)

        return self._pq
604908
def toString(self):
        
        xprofile = self.toXml()
        projex.text.xmlindent(xprofile)
        return ElementTree.tostring(xprofile)
1129009
def toxml(self):
        
        chxmlstr = ''

        for with_ in self.withs:
            chxmlstr += with_.toxml()

        for event_connection in self.event_connections:
            chxmlstr += event_connection.toxml()

        for child_instance in self.child_instances:
            chxmlstr += child_instance.toxml()

        for multi_instantiate in self.multi_instantiates:
            chxmlstr += multi_instantiate.toxml()

        for for_each in self.for_eachs:
            chxmlstr += for_each.toxml()

        if chxmlstr:
            xmlstr = '<Structure>' + chxmlstr + '</Structure>'
        else:
            xmlstr = ''

        return xmlstr
434873
def models_for_pages(*args):
    
    from warnings import warn
    warn("template tag models_for_pages is deprectaed, use "
        "PageAdmin.get_content_models instead")
    from yacms.pages.admin import PageAdmin
    return PageAdmin.get_content_models()