pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/pyppeteer/pyppeteer/connection/__init__.py

@@ -1,242 +0,0 @@
-import asyncio
-import json
-import logging
-import sys
-from typing import Any, Awaitable, Dict
-
-import websockets
-from pyee import AsyncIOEventEmitter
-
-from biolib.pyppeteer.pyppeteer.errors import NetworkError
-from biolib.pyppeteer.pyppeteer.events import Events
-from biolib.pyppeteer.pyppeteer.websocket_transport import WebsocketTransport
-
-if sys.version_info < (3, 8):
-    from typing_extensions import TypedDict
-else:
-    from typing import TypedDict
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
-logger_connection = logging.getLogger(__name__ + '.Connection')
-
-
-class TargetInfo(TypedDict, total=False):
-    type: str
-
-
-class MessageParams(TypedDict, total=False):
-    targetInfo: TargetInfo
-    sessionId: str
-
-
-class MessageError(TypedDict, total=False):
-    message: str
-    data: Any
-
-
-class Message(TypedDict, total=False):
-    method: str
-    id: int
-    params: MessageParams
-    error: MessageError
-    result: Any
-
-
-class Connection(AsyncIOEventEmitter):
-    """Connection management class."""
-
-    def __init__(
-        self, url: str, transport: WebsocketTransport, delay: float = 0, loop: asyncio.AbstractEventLoop = None,
-    ) -> None:
-        """Make connection.
-
-        :arg str url: WebSocket url to connect devtool.
-        :arg int delay: delay to wait before processing received messages.
-        """
-        super().__init__()
-        self._url = url
-        self._lastId = 0
-        self._callbacks: Dict[int, asyncio.Future] = {}
-        self._delay = delay / 1000
-
-        self._transport = transport
-
-        self.loop = loop or asyncio.get_event_loop()
-        self._sessions: Dict[str, CDPSession] = {}
-        self._connected = False
-        self._closed = False
-        self.loop.create_task(self._recv_loop())
-
-    @staticmethod
-    def fromSession(session: 'CDPSession') -> 'Connection':
-        return session._connection
-
-    def session(self, sessionId) -> 'CDPSession':
-        return self._sessions.get(sessionId)
-
-    @property
-    def url(self) -> str:
-        """Get connected WebSocket url."""
-        return self._url
-
-    async def _recv_loop(self) -> None:
-        try:
-            self._connected = True
-            self.connection = self._transport
-            self.connection.onmessage = lambda msg: self._onMessage(msg)
-            self.connection.onclose = self._onClose
-            while self._connected:
-                try:
-                    await self.connection.recv()
-                except (websockets.ConnectionClosed, ConnectionResetError) as excpt:
-                    logger.warning(f'Transport connection closed: {excpt}')
-                    break
-                # wait 1 async loop frame, no other data will be accessible in between frames
-                await asyncio.sleep(0)
-        except Exception as excpt:
-            await self.dispose(reason=str(excpt))
-            raise excpt
-        await self.dispose(reason=None)
-
-    async def _async_send(self, msg: Message) -> None:
-        while not self._connected:
-            await asyncio.sleep(self._delay)
-        try:
-            remove_none_items_inplace(msg)
-            msg_to_send = json.dumps(msg)
-            await self.connection.send(msg_to_send)
-            logger_connection.debug(f'SEND ▶ {msg_to_send}')
-        except websockets.ConnectionClosed:
-            logger.error('connection unexpectedly closed')
-            callback = self._callbacks.get(msg['id'], None)
-            if callback and not callback.done():
-                callback.set_result(None)
-                await self.dispose()
-
-    def send(self, method: str, params: dict = None) -> Awaitable:
-        """Send message via the connection."""
-        # Detect connection availability from the second transmission
-        if self._lastId and not self._connected:
-            raise ConnectionError('Connection is closed')
-        id_ = self._rawSend({'method': method, 'params': params or {}})
-        callback = self.loop.create_future()
-        callback.error: Exception = NetworkError()  # type: ignore
-        callback.method: str = method  # type: ignore
-        self._callbacks[id_] = callback
-        return callback
-
-    def _rawSend(self, message: Message) -> int:
-        self._lastId += 1
-        id_ = self._lastId
-        message['id'] = id_
-        self.loop.create_task(self._async_send(message))
-        return id_
-
-    async def _onMessage(self, msg: str) -> None:
-        loaded_msg: Message = json.loads(msg)
-        if self._delay:
-            await asyncio.sleep(self._delay)
-        logger_connection.debug(f'◀ RECV {loaded_msg}')
-
-        # Handle Target attach/detach methods
-        if loaded_msg.get('method') == 'Target.attachedToTarget':
-            sessionId = loaded_msg['params']['sessionId']
-            self._sessions[sessionId] = CDPSession(
-                connection=self,
-                targetType=loaded_msg['params']['targetInfo']['type'],
-                sessionId=sessionId,
-                loop=self.loop,
-            )
-        elif loaded_msg.get('method') == 'Target.detachedFromTarget':
-            session = self._sessions.get(loaded_msg['params']['sessionId'])
-            if session:
-                session._onClosed()
-                del self._sessions[loaded_msg['params']['sessionId']]
-
-        if loaded_msg.get('sessionId'):
-            session = self._sessions.get(loaded_msg['sessionId'])
-            if session:
-                session._onMessage(loaded_msg)
-        elif loaded_msg.get('id'):
-            # Callbacks could be all rejected if someone has called `.dispose()`
-            callback = self._callbacks.get(loaded_msg['id'])
-            if callback:
-                if loaded_msg.get('error'):
-                    callback.set_exception(createProtocolError(callback.error, callback.method, loaded_msg))
-                else:
-                    callback.set_result(loaded_msg.get('result'))
-                del self._callbacks[loaded_msg['id']]
-        else:
-            self.emit(loaded_msg['method'], loaded_msg['params'])
-
-    async def _onClose(self) -> None:
-        if self._closed:
-            return
-        self._closed = True
-        self._transport.onmessage = None
-        self._transport.onclose = None
-
-        for cb in self._callbacks.values():
-            cb.set_exception(
-                rewriteError(
-                    cb.error,  # type: ignore
-                    f'Protocol error {cb.method}: Target closed.',  # type: ignore
-                )
-            )
-        self._callbacks.clear()
-
-        for session in self._sessions.values():
-            session._onClosed()
-        self._sessions.clear()
-
-        # close connection
-        if hasattr(self, 'connection'):  # may not have connection
-            await self.connection.close()
-        self._sessions.clear()
-        self.emit(Events.Connection.Disconnected)
-
-    async def dispose(self, code: int = 1000, reason: str = None) -> None:
-        """Close all connection."""
-        self._connected = False
-        await self._onClose()
-        await self._transport.close(code=code, reason=str(reason))
-
-    async def createSession(self, targetInfo: Dict) -> 'CDPSession':
-        """Create new session."""
-        resp = await self.send('Target.attachToTarget', {'targetId': targetInfo['targetId'], 'flatten': True})
-        sessionId = resp.get('sessionId')
-        return self._sessions[sessionId]
-
-
-def createProtocolError(error: Exception, method: str, obj: Dict) -> Exception:
-    message = f'Protocol error ({method}): {obj["error"]["message"]}'
-    if 'data' in obj['error']:
-        message += f' {obj["error"]["data"]}'
-    return rewriteError(error, message)
-
-
-def rewriteError(error: Exception, message: str) -> Exception:
-    error.args = (message,)
-    return error
-
-
-def remove_none_items_inplace(o: Dict[str, Any]) -> None:
-    """
-    Removes items that have a value of None. There are instances in puppeteer where a object (dict) is sent which has
-    undefined values, which are then omitted from the resulting json. This function emulates such behaviour, removing
-    all k:v pairs where v = None
-    :param o:
-    :return Dict[str, Any]: dict without any None values
-    """
-    none_keys = []
-    for key, value in o.items():
-        if isinstance(value, dict):
-            remove_none_items_inplace(value)
-        if value is None:
-            none_keys.append(key)
-    for key in none_keys:
-        del o[key]
-
-
-from biolib.pyppeteer.pyppeteer.connection.cdpsession import CDPSession  # isort:skip

biolib/pyppeteer/pyppeteer/connection/cdpsession.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Connection/Session management module."""
-
-import asyncio
-from typing import Awaitable, Dict, Union
-
-from pyee import AsyncIOEventEmitter
-
-from biolib.pyppeteer.pyppeteer.connection import Connection, Message, createProtocolError, rewriteError
-from biolib.pyppeteer.pyppeteer.errors import NetworkError
-from biolib.pyppeteer.pyppeteer.events import Events
-
-
-class CDPSession(AsyncIOEventEmitter):
-    """Chrome Devtools Protocol Session.
-
-    The :class:`CDPSession` instances are used to talk raw Chrome Devtools
-    Protocol:
-
-    * protocol methods can be called with :meth:`send` method.
-    * protocol events can be subscribed to with :meth:`on` method.
-
-    Documentation on DevTools Protocol can be found
-    `here <https://chromedevtools.github.io/devtools-protocol/>`__.
-    """
-
-    def __init__(
-        self,
-        connection: Union[Connection, 'CDPSession'],
-        targetType: str,
-        sessionId: str,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
-        """Make new session."""
-        super().__init__()
-        self._callbacks: Dict[int, asyncio.Future] = {}
-        self._connection = connection
-        self._targetType = targetType
-        self._sessionId = sessionId
-        self.loop = loop
-
-    def send(self, method: str, params: dict = None) -> Awaitable:
-        """Send message to the connected session.
-
-        :arg str method: Protocol method name.
-        :arg dict params: Optional method parameters.
-        """
-        if not self._connection:
-            raise NetworkError(
-                f'Protocol Error ({method}): Session closed. Most likely the {self._targetType} has been closed.'
-            )
-        id_ = self._connection._rawSend({'sessionId': self._sessionId, 'method': method, 'params': params or {},})
-        callback = self.loop.create_future()
-        callback.method = method
-        callback.error = NetworkError()
-        self._callbacks[id_] = callback
-        return callback
-
-    def _onMessage(self, msg: Message) -> None:
-        id_ = msg.get('id')
-        callback = self._callbacks.get(id_)
-        if id_ and id_ in self._callbacks:
-            if msg.get('error'):
-                callback.set_exception(
-                    createProtocolError(
-                        callback.error,  # type: ignore
-                        callback.method,  # type: ignore
-                        msg,
-                    )
-                )
-            else:
-                callback.set_result(msg.get('result'))
-            del self._callbacks[id_]
-        else:
-            if msg.get('id'):
-                raise ConnectionError(f'Received unexpected message with no callback: {msg}')
-            self.emit(msg.get('method'), msg.get('params'))
-
-    async def detach(self) -> None:
-        """Detach session from target.
-
-        Once detached, session won't emit any events and can't be used to send
-        messages.
-        """
-        if not self._connection:
-            raise NetworkError('Session already detached. Most likelythe {self._targetType} has been closed')
-        await self._connection.send('Target.detachFromTarget', {'sessionId': self._sessionId})
-
-    def _onClosed(self) -> None:
-        for cb in self._callbacks.values():
-            cb.set_exception(
-                rewriteError(
-                    cb.error,  # type: ignore
-                    f'Protocol error {cb.method}: Target closed.',  # type: ignore
-                )
-            )
-        self._callbacks.clear()
-        self._connection = None
-        self.emit(Events.CDPSession.Disconnected)

biolib/pyppeteer/pyppeteer/coverage.py

@@ -1,346 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Coverage module."""
-import asyncio
-import logging
-from functools import cmp_to_key
-from typing import Dict, List
-
-from biolib.pyppeteer.pyppeteer import helpers
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-from biolib.pyppeteer.pyppeteer.errors import PageError
-from biolib.pyppeteer.pyppeteer.execution_context import EVALUATION_SCRIPT_URL
-from biolib.pyppeteer.pyppeteer.models import CoverageResult, NestedRangeItemInput, NestedRangeItem, Protocol
-
-
-logger = logging.getLogger(__name__)
-
-
-class Coverage:
-    """Coverage class.
-
-    Coverage gathers information about parts of JavaScript and CSS that were
-    used by the page.
-
-    An example of using JavaScript and CSS coverage to get percentage of
-    initially executed code::
-
-        # Enable both JavaScript and CSS coverage
-        await page.coverage.startJSCoverage()
-        await page.coverage.startCSSCoverage()
-
-        # Navigate to page
-        await page.goto('https://example.com')
-        # Disable JS and CSS coverage and get results
-        jsCoverage = await page.coverage.stopJSCoverage()
-        cssCoverage = await page.coverage.stopCSSCoverage()
-        totalBytes = 0
-        usedBytes = 0
-        coverage = jsCoverage + cssCoverage
-        for entry in coverage:
-            totalBytes += len(entry['text'])
-            for range in entry['ranges']:
-                usedBytes += range['end'] - range['start'] - 1
-
-        print('Bytes used: {}%'.format(usedBytes / totalBytes * 100))
-    """
-
-    def __init__(self, client: CDPSession) -> None:
-        self._jsCoverage = JSCoverage(client)
-        self._cssCoverage = CSSCoverage(client)
-
-    async def startJSCoverage(self, resetOnNavigation: bool = True, reportAnonymousScripts: bool = False,) -> None:
-        """Start JS coverage measurement.
-
-        :param resetOnNavigation: Whether to reset coverage on every
-          navigation.
-        :param reportAnonymousScripts: Whether anonymous script generated
-          by the page should be reported.
-
-        .. note::
-            Anonymous scripts are ones that don't have an associated url. These
-            are scripts that are dynamically created on the page using ``eval``
-            of ``new Function``. If ``reportAnonymousScript`` is set to
-            ``True``, anonymous scripts will have
-            ``__pyppeteer_evaluation_script__`` as their url.
-        """
-        await self._jsCoverage.start(
-            resetOnNavigation=resetOnNavigation, reportAnonymousScripts=reportAnonymousScripts,
-        )
-
-    async def stopJSCoverage(self) -> List:
-        """Stop JS coverage measurement and get result.
-
-        Return list of coverage reports for all scripts. Each report includes:
-
-        * ``url`` (str): Script url.
-        * ``text`` (str): Script content.
-        * ``ranges`` (List[Dict]): Script ranges that were executed. Ranges are
-          sorted and non-overlapping.
-
-          * ``start`` (int): A start offset in text, inclusive.
-          * ``end`` (int): An end offset in text, exclusive.
-
-        .. note::
-           JavaScript coverage doesn't include anonymous scripts by default.
-           However, scripts with sourceURLs are reported.
-        """
-        return await self._jsCoverage.stop()
-
-    async def startCSSCoverage(self, resetOnNavigation: bool = True) -> None:
-        """Start CSS coverage measurement.
-
-
-        :param resetOnNavigation: Whether to reset coverage on every
-          navigation.
-        """
-        await self._cssCoverage.start(resetOnNavigation=resetOnNavigation)
-
-    async def stopCSSCoverage(self) -> List:
-        """Stop CSS coverage measurement and get result.
-
-        Return list of coverage reports for all non-anonymous scripts. Each
-        report includes:
-
-        * ``url`` (str): StyleSheet url.
-        * ``text`` (str): StyleSheet content.
-        * ``ranges`` (List[Dict]): StyleSheet ranges that were executed. Ranges
-          are sorted and non-overlapping.
-
-          * ``start`` (int): A start offset in text, inclusive.
-          * ``end`` (int): An end offset in text, exclusive.
-
-        .. note::
-           CSS coverage doesn't include dynamically injected style tags without
-           sourceURLs (but currently includes... to be fixed).
-        """
-        return await self._cssCoverage.stop()
-
-
-class JSCoverage:
-    """JavaScript Coverage class."""
-
-    def __init__(self, client: CDPSession) -> None:
-        self._client = client
-        self._enabled = False
-        self._scriptURLs = {}
-        self._scriptSources = {}
-        self._eventListeners = []
-        self._resetOnNavigation = False
-
-    async def start(self, resetOnNavigation: bool = True, reportAnonymousScripts: bool = False,) -> None:
-        """Start coverage measurement."""
-        if self._enabled:
-            raise PageError('JSCoverage is already enabled.')
-        self._resetOnNavigation = resetOnNavigation
-        self._reportAnonymousScript = reportAnonymousScripts
-        self._enabled = True
-        self._scriptURLs.clear()
-        self._scriptSources.clear()
-        self._eventListeners = [
-            helpers.addEventListener(
-                self._client, 'Debugger.scriptParsed', lambda e: self._onScriptParsed(e)
-            ),
-            helpers.addEventListener(
-                self._client, 'Runtime.executionContextsCleared', self._onExecutionContextsCleared
-            ),
-        ]
-        await asyncio.gather(
-            self._client.send('Profiler.enable'),
-            self._client.send('Profiler.startPreciseCoverage', {'callCount': False, 'detailed': True}),
-            self._client.send('Debugger.enable'),
-            self._client.send('Debugger.setSkipAllPauses', {'skip': True}),
-        )
-
-    def _onExecutionContextsCleared(self, event: Dict) -> None:
-        if not self._resetOnNavigation:
-            return
-        self._scriptURLs.clear()
-        self._scriptSources.clear()
-
-    async def _onScriptParsed(self, event: Protocol.Debugger.scriptParsedPayload) -> None:
-        # Ignore pyppeteer-injected scripts
-        if event.get('url') == EVALUATION_SCRIPT_URL:
-            return
-        # Ignore other anonymous scripts unless the reportAnonymousScript
-        # option is True
-        if not event.get('url') and not self._reportAnonymousScript:
-            return
-
-        scriptId = event.get('scriptId')
-        url = event.get('url')
-        try:
-            response = await self._client.send('Debugger.getScriptSource', {'scriptId': scriptId})
-            self._scriptURLs[scriptId] = url
-            self._scriptSources[scriptId] = response.get('scriptSource')
-        except Exception as e:
-            logger.error(f'An exception occurred during _onScriptParsed handling: {e}'
-                         f'\nThis might happen if the page has already navigated away.')
-
-    async def stop(self) -> List:
-        """Stop coverage measurement and return results."""
-        if not self._enabled:
-            raise PageError('JSCoverage is not enabled')
-        self._enabled = False
-
-        result, *_ = await asyncio.gather(
-            self._client.send('Profiler.takePreciseCoverage'),
-            self._client.send('Profiler.stopPreciseCoverage'),
-            self._client.send('Profiler.disable'),
-            self._client.send('Debugger.disable'),
-        )
-        helpers.removeEventListeners(self._eventListeners)
-
-        coverage = []
-        for entry in result.get('result', []):
-            scriptId = entry.get('scriptId')
-            url = self._scriptURLs.get(scriptId)
-            if not url and self._reportAnonymousScript:
-                url = f'debugger://VM{scriptId}'
-            text = self._scriptSources.get(scriptId)
-            if text is None or url is None:
-                continue
-            flattenRanges = []
-            for func in entry.get('functions', []):
-                flattenRanges.extend(func.get('ranges', []))
-            ranges = convertToDisjointRanges(flattenRanges)
-            coverage.append({'url': url, 'ranges': ranges, 'text': text})
-        return coverage
-
-
-class CSSCoverage:
-    """CSS Coverage class."""
-
-    def __init__(self, client: CDPSession) -> None:
-        self._client = client
-        self._enabled = False
-        self._stylesheetURLs: Dict = {}
-        self._stylesheetSources: Dict = {}
-        self._eventListeners: List = []
-        self._resetOnNavigation = False
-
-    async def start(self, resetOnNavigation: bool = True) -> None:
-        """Start coverage measurement."""
-        if self._enabled:
-            raise PageError('CSSCoverage is already enabled.')
-        self._resetOnNavigation = resetOnNavigation
-        self._enabled = True
-        self._stylesheetURLs.clear()
-        self._stylesheetSources.clear()
-        self._eventListeners = [
-            helpers.addEventListener(
-                self._client, 'CSS.styleSheetAdded', lambda e: self._client.loop.create_task(self._onStyleSheet(e))
-            ),
-            helpers.addEventListener(
-                self._client, 'Runtime.executionContextsCleared', self._onExecutionContextsCleared
-            ),
-        ]
-        await asyncio.gather(
-            self._client.send('DOM.enable'),
-            self._client.send('CSS.enable'),
-            self._client.send('CSS.startRuleUsageTracking'),
-        )
-
-    def _onExecutionContextsCleared(self, event: Dict) -> None:
-        if not self._resetOnNavigation:
-            return
-        self._stylesheetURLs.clear()
-        self._stylesheetSources.clear()
-
-    async def _onStyleSheet(self, event: Dict) -> None:
-        header = event.get('header', {})
-        # Ignore anonymous scripts
-        if not header.get('sourceURL'):
-            return
-        try:
-            response = await self._client.send('CSS.getStyleSheetText', {'styleSheetId': header['styleSheetId']})
-            self._stylesheetURLs[header['styleSheetId']] = header['sourceURL']
-            self._stylesheetSources[header['styleSheetId']] = response['text']
-        except Exception as e:
-            # This might happen if the page has already navigated away.
-            logger.error(f'An exception occurred: {e}')
-
-    async def stop(self) -> List[CoverageResult]:
-        """Stop coverage measurement and return results."""
-        if not self._enabled:
-            raise PageError('CSSCoverage is not enabled.')
-        self._enabled = False
-        ruleTrackingResponse = await self._client.send('CSS.stopRuleUsageTracking')
-        await asyncio.gather(self._client.send('CSS.disable'), self._client.send('DOM.disable'))
-        helpers.removeEventListeners(self._eventListeners)
-
-        # aggregate by styleSheetId
-        styleSheetIdToCoverage: Dict[str, List[Dict[str, str]]] = {}
-        for entry in ruleTrackingResponse['ruleUsage']:
-            ranges = styleSheetIdToCoverage.get(entry['styleSheetId'])
-            if not ranges:
-                ranges = []
-                styleSheetIdToCoverage[entry['styleSheetId']] = ranges
-            ranges.append(
-                {
-                    'startOffset': entry['startOffset'],
-                    'endOffset': entry['endOffset'],
-                    'count': 1 if entry['used'] else 0,
-                }
-            )
-
-        coverage = []
-        for styleSheetId in self._stylesheetURLs:
-            url = self._stylesheetURLs.get(styleSheetId)
-            text = self._stylesheetSources.get(styleSheetId)
-            ranges = convertToDisjointRanges(styleSheetIdToCoverage.get(styleSheetId, []))
-            coverage.append({'url': url, 'ranges': ranges, 'text': text})
-
-        return coverage
-
-
-def convertToDisjointRanges(nestedRanges: List[NestedRangeItemInput]) -> List[NestedRangeItem]:
-    """
-    Convert ranges.
-    NestedRange members support keys:
-        * startOffset: float
-        * endOffset: float
-        * count: int
-    """
-    points: List = []
-    for nested_range in nestedRanges:
-        points.append({'offset': nested_range['startOffset'], 'type': 0, 'range': nested_range})
-        points.append({'offset': nested_range['endOffset'], 'type': 1, 'range': nested_range})
-
-    # Sort points to form a valid parenthesis sequence.
-    def _sort_func(a: Dict, b: Dict) -> int:
-        # Sort with increasing offsets.
-        if a['offset'] != b['offset']:
-            return a['offset'] - b['offset']
-        # All "end" points should go before "start" points.
-        if a['type'] != b['type']:
-            return b['type'] - a['type']
-        aLength = a['range']['endOffset'] - a['range']['startOffset']
-        bLength = b['range']['endOffset'] - b['range']['startOffset']
-        # For two "start" points, the one with longer range goes first.
-        if a['type'] == 0:
-            return bLength - aLength
-        # For two "end" points, the one with shorter range goes first.
-        return aLength - bLength
-
-    points.sort(key=cmp_to_key(_sort_func))
-
-    hitCountStack = []
-    results = []
-    lastOffset = 0
-    # Run scanning line to intersect all ranges.
-    for point in points:
-        if hitCountStack and lastOffset < point['offset'] and hitCountStack[len(hitCountStack) - 1] > 0:
-            lastResult = results[-1] if results else None
-            if lastResult and lastResult['end'] == lastOffset:
-                lastResult['end'] = point['offset']
-            else:
-                results.append({'start': lastOffset, 'end': point['offset']})
-        lastOffset = point['offset']
-        if point['type'] == 0:
-            hitCountStack.append(point['range']['count'])
-        else:
-            hitCountStack.pop()
-    # Filter out empty ranges.
-    return [range for range in results if range['end'] - range['start'] > 1]