Try to get the pageSize value on runtime.
505880
def pageSize(cls):
        
        try:
            try:
                pageSize = win32.GetSystemInfo().dwPageSize
            except WindowsError:
                pageSize = 0x1000
        except NameError:
            pageSize = 0x1000
        cls.pageSize = pageSize     # now this function won't be called again
        return pageSize
1069630
public function getSinglePageResourceUri( $pagenum = null, $pagesize=null)
    {
        if( is_null($pagenum) ) $pagenum  =$this->pagenum;
        if( is_null($pagesize)) $pagesize =$this->pagesize;
        
        //rebuild query string from already parsed _GET superglobal but do not override it.
        $vars = $_GET;
        $o=$this->ns(self::LOCAL);
        $vars[$o->getValue('plabel')]   = $pagenum;
        $vars[$o->getValue('pslabel')]  = $pagesize;
        
        return $this->getQueryStrippedUri() . '?'. http_build_query($vars);
    }
712082
def get_size(self):
        """"""
        attr = self._get_console_info()
        cols = attr['window']['right'] - attr['window']['left'] + 1
        lines = attr['window']['bottom'] - attr['window']['top'] + 1
        return cols, lines
811005
def _getitem(self, key, validate=False):
        """"""
        key = int(key)
        pages = self.pages

        if key < 0:
            key %= len(self)
        elif self._indexed and key >= len(pages):
            raise IndexError('index out of range')

        if key < len(pages):
            page = pages[key]
            if self._cache:
                if not isinstance(page, inttypes):
                    if validate and validate != page.hash:
                        raise RuntimeError('page hash mismatch')
                    return page
            elif isinstance(page, (TiffPage, self._tiffpage)):
                if validate and validate != page.hash:
                    raise RuntimeError('page hash mismatch')
                return page

        self._seek(key)
        page = self._tiffpage(self.parent, index=key, keyframe=self._keyframe)
        if validate and validate != page.hash:
            raise RuntimeError('page hash mismatch')
        if self._cache:
            pages[key] = page
        return page
1045107
def validate_page_size(ctx, param, value):
    """"""
    # pylint: disable=unused-argument
    if value == 0:
        raise click.BadParameter("Page size must be non-zero or unset.", param=param)
    return value
1295214
private int calculatePageSize()
    {
        int meanColumnCount = hintStore.getMeanColumns();
        if (meanColumnCount <= 0)
            return PAGE_SIZE;

        int averageColumnSize = (int) (hintStore.getMeanRowSize() / meanColumnCount);
        if (averageColumnSize <= 0)
            return PAGE_SIZE;

        // page size of 1 does not allow actual paging b/c of >= behavior on startColumn
        return Math.max(2, Math.min(PAGE_SIZE, 4 * 1024 * 1024 / averageColumnSize));
    }
462740
def get_size(self, value=None):
        """"""
        if isinstance(value, ActionHeader):
            return value.get_size()
        elif value is None:
            current_size = super().get_size()
            return ceil(current_size / 8) * 8
        raise ValueError(f'Invalid value "{value}" for Action*.get_size()')
124547
def _get_pages(page_size, total_records):
        
        pages = total_records/page_size+bool(total_records%page_size)
        return range(1, pages+1)
503531
def availablePageSizes(self):
		

		sizes = [x for x in dir(QPagedPaintDevice)
		         if type(getattr(QPagedPaintDevice, x)) == QPagedPaintDevice.PageSize]
		return sizes
512302
def get_runtime_value(self, resourceid: int):
        
        payload = """<getRuntimeValue1 xmlns="utcs">{id}</getRuntimeValue1>
                  """.format(id=resourceid)
        xdoc = self.connection.soap_action('/ws/ResourceInteractionService',
                                           'getResourceValue',
                                           payload)
        if not xdoc:
            return False
        boolresult = xdoc.find(
            './SOAP-ENV:Body/ns1:getRuntimeValue2/ns1:value/ns2:value',
            IHCSoapClient.ihcns)
        if boolresult is not None:
            return boolresult.text == "true"
        intresult = xdoc.find(
            './SOAP-ENV:Body/ns1:getRuntimeValue2/ns1:value/ns2:integer',
            IHCSoapClient.ihcns)
        if intresult is not None:
            return int(intresult.text)
        floatresult = xdoc.find(
            ('./SOAP-ENV:Body/ns1:getRuntimeValue2/'
             'ns1:value/ns2:floatingPointValue'),
            IHCSoapClient.ihcns)
        if floatresult is not None:
            return float(floatresult.text)
        enumNameResut = xdoc.find(
            ('./SOAP-ENV:Body/ns1:getRuntimeValue2/'
             'ns1:value/ns2:enumName'),
            IHCSoapClient.ihcns)
        if enumNameResut is not None:
            return enumNameResut.text
        return False
870159
def dump(self):
        
        print("pagesize=%08x, reccount=%08x, pagecount=%08x" % (self.pagesize, self.reccount, self.pagecount))
        self.dumpfree()
        self.dumptree(self.firstindex)
1081573
def get_size(self):
        """"""
        self.curses.setupterm()
        return self.curses.tigetnum('cols'), self.curses.tigetnum('lines')
189217
def get_value(self):
        """"""
        from spyder.utils.system import memory_usage
        text = '%d%%' % memory_usage()
        return 'Mem ' + text.rjust(3)
1044198
def get_page_square_dpi(pageinfo, options):
    ""
    xres = pageinfo.xres or 0
    yres = pageinfo.yres or 0
    userunit = pageinfo.userunit or 1
    return float(
        max(
            (xres * userunit) or VECTOR_PAGE_DPI,
            (yres * userunit) or VECTOR_PAGE_DPI,
            VECTOR_PAGE_DPI if pageinfo.has_vector else 0,
            options.oversample or 0,
        )
    )
1113213
private List<Integer> getPageSizes() {

        final String pageSizes = parseOptionalStringValue(XML_ELEMENT_PAGESIZE);
        if (pageSizes != null) {
            String[] pageSizesArray = pageSizes.split("-");
            if (pageSizesArray.length > 0) {
                try {
                    List<Integer> result = new ArrayList<>(pageSizesArray.length);
                    for (int i = 0; i < pageSizesArray.length; i++) {
                        result.add(Integer.valueOf(pageSizesArray[i]));
                    }
                    return result;
                } catch (NumberFormatException e) {
                    LOG.warn(Messages.get().getBundle().key(Messages.LOG_PARSING_PAGE_SIZES_FAILED_1, pageSizes), e);
                }
            }
        }
        return null;
    }
1305540
public function getData($pageSize = 10, $pageNo = null)
    {
        if (empty($pageNo) && isset($_GET[$this->getPageVar()])) {
            $pageNo = intval($_GET[$this->getPageVar()]);
        }
        $pageNo = empty($pageNo) ? 1 : $pageNo;
        return [
            'pageSize' => $pageSize,
            'pageNo' => $pageNo,
            'totalCount' => $this->_dbInstance->getTotalCount(),
            'result' => $this->_dbInstance->getData($pageSize, $pageNo),
        ];
    }
538698
public static int size(String size, int defaultValue) {
        int parseInt = NumUtils.intVal(size, defaultValue);
        return parseInt <= 0 ? defaultValue
                : (parseInt > DEFAULT_MAX_PAGE_SIZE ? DEFAULT_MAX_PAGE_SIZE : parseInt);
    }