promnesia 1.1.20230129__py3-none-any.whl → 1.2.20240810__py3-none-any.whl

promnesia/tests/test_indexer.py

@@ -0,0 +1,245 @@
+from collections import Counter
+from pathlib import Path
+from subprocess import check_call, Popen
+
+from ..__main__ import do_index, read_example_config
+from ..common import DbVisit, _is_windows
+from ..database.load import get_all_db_visits
+
+import pytest
+
+from .common import get_testdata, promnesia_bin, reset_filters, write_config
+
+
+def get_stats(tmp_path: Path) -> Counter:
+    visits = get_all_db_visits(tmp_path / 'promnesia.sqlite')
+    return Counter(v.src for v in visits)
+
+
+@pytest.mark.parametrize('mode', ['update', 'overwrite'])
+def test_indexing_mode(tmp_path: Path, mode: str) -> None:
+    # ugh. we modify the config very fast during tests
+    # and pycache distinguishes identical filenames based on int mtime in seconds
+    # so best to use different names to prevent undesired caching
+    # https://github.com/python/cpython/blob/fb202af4470d6051a69bb9d2f44d7e8a1c99eb4f/Lib/importlib/_bootstrap_external.py#L714-L739
+    # TODO could probably relax that if we switch from importlib config loading to exec()?
+
+    def cfg1() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [
+            Source(demo.index, count=10, base_dt='2000-01-01', delta=30, name='demo1'),
+            Source(demo.index, count=20, base_dt='2001-01-01', delta=30, name='demo2'),
+        ]
+
+    cfg_path = tmp_path / 'config1.py'
+    write_config(cfg_path, cfg1)
+    do_index(cfg_path)
+
+    stats = get_stats(tmp_path)
+    assert stats == {'demo1': 10, 'demo2': 20}
+
+    def cfg2() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [
+            Source(demo.index, count=30, base_dt='2005-01-01', delta=30, name='demo2'),
+            Source(demo.index, count=40, base_dt='2010-01-01', delta=30, name='demo3'),
+        ]
+
+    cfg_path = tmp_path / 'config2.py'
+    write_config(cfg_path, cfg2)
+    do_index(cfg_path, overwrite_db={'overwrite': True, 'update': False}[mode])
+    # TODO use some sort of test helper?
+    stats = get_stats(tmp_path)
+
+    if mode == 'update':
+        # should keep the original visits too!
+        assert stats == {'demo1': 10, 'demo2': 30, 'demo3': 40}
+    else:
+        # should overwrite with newly indexed visits
+        assert stats == {'demo2': 30, 'demo3': 40}
+
+
+# TODO check both modes?
+def test_concurrent_indexing(tmp_path: Path) -> None:
+    def cfg_fast() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, count=10)]
+
+    cfg_fast_path = tmp_path / 'cfg_fast.py'
+    write_config(cfg_fast_path, cfg_fast)
+
+    def cfg_slow() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, count=100_000)]
+
+    cfg_slow_path = tmp_path / 'cfg_slow.py'
+    write_config(cfg_slow_path, cfg_slow)
+
+    # init it first, to create the database
+    # TODO ideally this shouldn't be necessary but it's reasonable that people would already have the index
+    # otherwise it would fail at db creation point.. which is kinda annoying to work around
+    # todo in principle can work around same way as in cachew, by having a loop around PRAGMA WAL command?
+    check_call(promnesia_bin('index', '--config', cfg_fast_path, '--overwrite'))
+
+    total_runs = 0
+    # run in the background
+    with Popen(promnesia_bin('index', '--config', cfg_slow_path, '--overwrite')) as slow_indexer:
+        while slow_indexer.poll() is None:
+            # create a bunch of 'smaller' indexers running in parallel
+            fasts = [
+                Popen(promnesia_bin('index', '--config', cfg_fast_path, '--overwrite'))
+                for _ in range(10)
+            ]
+            for fast in fasts:
+                assert fast.wait() == 0, fast  # should succeed
+                total_runs += 1
+        assert slow_indexer.poll() == 0, slow_indexer
+
+    # FIXME ok, need to uncomment this once proper concurrent indexing is supported
+    # if not, slow indexer is too fast, so crank up the count in it
+    # assert total_runs > 20
+
+
+def test_filter(tmp_path: Path, reset_filters) -> None:
+    domain_to_filter = 'some-weird-domain.xyz'
+    testdata = get_testdata('custom')
+    assert any(domain_to_filter in p.read_text() for p in testdata.glob('*.txt'))  # precondition
+
+    def cfg(testdata, domain_to_filter) -> None:
+        from promnesia.common import Source
+        from promnesia.sources import shellcmd
+        from promnesia.sources.plaintext import extract_from_path
+
+        FILTERS = [
+            domain_to_filter,
+        ]
+
+        SOURCES = [Source(shellcmd.index, extract_from_path(testdata))]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg, testdata=testdata, domain_to_filter=domain_to_filter)
+    do_index(cfg_path)
+
+    visits = get_all_db_visits(tmp_path / 'promnesia.sqlite')
+    urls = {v.orig_url for v in visits}
+    assert not any(domain_to_filter in u for u in urls), urls
+    assert len(visits) == 4  # just in case
+
+
+def test_weird_urls(tmp_path: Path) -> None:
+    # specifically test this here (rather than in cannon)
+    # to make sure it's not messed up when we insert/extract from sqlite
+
+    def cfg(testdata: str) -> None:
+        from promnesia.common import Source
+        from promnesia.sources import shellcmd
+        from promnesia.sources.plaintext import extract_from_path
+
+        SOURCES = [Source(shellcmd.index, extract_from_path(testdata))]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg, testdata=get_testdata('weird.txt'))
+    do_index(cfg_path)
+
+    [v1, v2] = get_all_db_visits(tmp_path / 'promnesia.sqlite')
+
+    assert v1.norm_url == "urbandictionary.com/define.php?term=Belgian%20Whistle"
+
+    assert v2.norm_url == "en.wikipedia.org/wiki/Dinic%27s_algorithm"
+    assert v2.locator.title.endswith('weird.txt:2')
+    assert v2.context == 'right, so https://en.wikipedia.org/wiki/Dinic%27s_algorithm can be used for max flow'
+
+
+def test_errors_during_indexing(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        def indexer1():
+            visits = list(demo.index(count=10))
+            yield from visits[:5]
+            yield RuntimeError("some error during visits extraction")
+            yield from visits[5:]
+
+        def indexer2():
+            raise RuntimeError("in this case indexer itself crashed")
+
+        SOURCES = [Source(indexer1), Source(indexer2)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    stats = get_stats(tmp_path)
+    assert stats == {
+        'error': 2,
+        'config': 10,
+    }
+
+
+def test_hook(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, count=7, name='somename')]
+
+        from typing import cast, Iterator
+        from promnesia.common import DbVisit, Loc, Res
+        from promnesia.sources import demo
+
+        def HOOK(visit: Res[DbVisit]) -> Iterator[Res[DbVisit]]:
+            visit = cast(DbVisit, visit)
+
+            # NOTE: might be a good idea to check that the visit is an exception first and yield it intact?
+            nurl = visit.norm_url
+            if 'page1' in nurl:
+                yield visit._replace(norm_url='patched.com')
+            elif 'page2' in nurl:
+                raise Exception('boom')  # deliberately crash
+            elif 'page3' in nurl:
+                # just don't yield anything! it will be omitted
+                pass
+            elif 'page4' in nurl:
+                # can emit multiple!
+                yield visit
+                yield visit
+            elif 'page6' in nurl:
+                # patch locator
+                yield visit._replace(locator=Loc.make(title='some custom timte', href='/can/replace/original/path'))
+            else:
+                yield visit
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    [p0, p1, e2, p41, p42, p5, p6] = get_all_db_visits(tmp_path / 'promnesia.sqlite')
+    assert p0.norm_url == 'demo.com/page0.html'
+    assert p1.norm_url == 'patched.com'
+    assert e2.norm_url == '<error>'
+    assert p41 == p42
+    assert isinstance(p6, DbVisit)
+    assert p6.locator is not None
+
+
+def test_example_config(tmp_path: Path) -> None:
+    if _is_windows:
+        pytest.skip("doesn't work on Windows: example config references /usr/include paths")
+
+    config = read_example_config() + '\n' + f'OUTPUT_DIR = "{str(tmp_path)}"'
+    cfg_path = tmp_path / 'example_config.py'
+    cfg_path.write_text(config)
+
+    do_index(cfg_path)
+
+    visits = [v for v in get_all_db_visits(tmp_path / 'promnesia.sqlite') if v.src != 'error']
+    assert len(visits) > 50  # random sanity check

promnesia/tests/test_server.py

@@ -0,0 +1,292 @@
+from datetime import datetime
+from pathlib import Path
+from subprocess import Popen
+
+import pytest
+
+from ..__main__ import do_index
+
+from .common import promnesia_bin, write_config
+from .server_helper import run_server
+
+
+def test_status_error() -> None:
+    """
+    If DB doesn't exist, server should handle it gracefully and respond with error
+    """
+    with run_server(db='/does/not/exist') as server:
+        response = server.post('/status')
+
+        # TODO ugh currently returns 200? maybe should return proper error, but need to handle in extension
+        # assert response.status_code == 404
+
+        body = response.json()
+
+        version = body['version']
+        assert version is not None
+        assert len(version.split('.')) >= 2  # random check..
+
+        assert 'ERROR' in body['db']  # defensive, it doesn't exist
+
+
+def test_status_ok(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, count=10)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    db_path = tmp_path / 'promnesia.sqlite'
+    with run_server(db=db_path, timezone='America/New_York') as server:
+        r = server.post('/status').json()
+        version = r['version']
+        assert version is not None
+        assert len(version.split('.')) >= 2  # random check..
+
+        assert r['db'] == str(db_path)
+
+        assert r['stats'] == {'total_visits': 10}
+
+
+def test_visits(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, base_dt='2000-01-01', delta=30 * 60)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    # force timezone here, otherwise dependeing on the test env response varies
+    with run_server(db=tmp_path / 'promnesia.sqlite', timezone='America/New_York') as server:
+        r = server.post('/visits', json={'url': 'whatever'}).json()
+        assert r['visits'] == []
+
+        r = server.post('/visits', json={'url': 'https://demo.com/page0.html'})
+        rj = r.json()
+        assert rj['normalised_url'] == 'demo.com/page0.html'
+        [v] = rj['visits']
+        assert v['src'] == 'demo'
+        assert v['locator']['title'] == 'demo'
+
+        assert v['dt'] == '01 Jan 2000 00:00:00 -0500'
+
+
+def test_visits_hierarchy(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from datetime import datetime
+
+        from promnesia.common import Source, Visit, Loc
+        from promnesia.sources import demo
+
+        def indexer():
+            visits = list(demo.index(count=6))
+            yield Visit(
+                url='https://reddit.com/post1',
+                dt=datetime.fromisoformat('2023-12-04'),
+                locator=Loc.make('reddit'),
+            )
+            yield Visit(
+                url='https://reddit.com/post1/comment2',
+                dt=datetime.fromisoformat('2023-12-02'),
+                locator=Loc.make('reddit'),
+                context='I am comment 2',
+            )
+            yield from visits[:3]
+            yield Visit(
+                url='https://reddit.com/post2',
+                dt=datetime.fromisoformat('2023-12-05'),
+                locator=Loc.make('reddit'),
+            )
+            yield from visits[3:]
+            yield Visit(
+                url='https://reddit.com/post1/ihavenocontext',
+                dt=datetime.fromisoformat('2023-12-06'),
+                locator=Loc.make('reddit'),
+            )
+            yield Visit(
+                url='https://reddit.com/post1/comment1',
+                dt=datetime.fromisoformat('2023-12-06'),
+                locator=Loc.make('reddit'),
+                context='I am comment 1',
+            )
+
+        SOURCES = [Source(indexer)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    # force timezone here, otherwise dependeing on the test env response varies
+    with run_server(db=tmp_path / 'promnesia.sqlite', timezone='America/New_York') as server:
+        r = server.post('/visits', json={'url': 'https://reddit.com/post1'}).json()
+        # retuns exact match + 'child' visits that are interesting (e.g. have context)
+        assert {v['original_url'] for v in r['visits']} == {
+            'https://reddit.com/post1',
+            'https://reddit.com/post1/comment1',
+            'https://reddit.com/post1/comment2',
+        }
+
+
+def test_visited(tmp_path: Path) -> None:
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        SOURCES = [Source(demo.index, base_dt='2000-01-01', delta=30 * 60)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    test_url = 'https://demo.com/page5.html'
+
+    # force timezone here, otherwise dependeing on the test env response varies
+    with run_server(db=tmp_path / 'promnesia.sqlite', timezone='America/New_York') as server:
+        r = server.post('/visited', json={'urls': []}).json()
+        assert r == []
+
+        r = server.post('/visited', json={'urls': [test_url, 'http://badurl.org']}).json()
+        [r1, r2] = r
+        assert r1['original_url'] == test_url
+        assert r2 is None
+
+
+def test_search(tmp_path: Path) -> None:
+    # TODO not sure if should index at all here or just insert DbVisits directly?
+    def cfg() -> None:
+        from datetime import datetime
+
+        from promnesia.common import Source, Visit, Loc
+        from promnesia.sources import demo
+
+        def indexer():
+            visits = list(demo.index(count=6))
+            yield Visit(
+                url='https://someone.org/something',
+                dt=datetime.fromisoformat('2023-12-04T11:12:13+03:00'),
+                locator=Loc.make('whatever'),
+            )
+            yield from visits[:3]
+            yield Visit(
+                url='https://wiki.termux.com/wiki/Termux-setup-storage',
+                locator=Loc.make(
+                    title='Reddit comment',
+                    href='https://reddit.com/r/termux/comments/m4qrxt/cant_open_storageshared_in_termux/gso0kak/',
+                ),
+                dt=datetime.fromisoformat('2023-12-02'),
+                context='perhaps it will help someone else https://wiki.termux.com/wiki/Termux-setup-storage',
+            )
+            yield from visits[3:]
+
+        SOURCES = [Source(indexer)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    with run_server(db=tmp_path / 'promnesia.sqlite', timezone='America/New_York') as server:
+        # FIXME 'url' is actually kinda misleading -- it can be any text
+        rj = server.post('/search', json={'url': 'someone'}).json()
+        # TODO maybe return in chronological order or something? not sure
+        [v1, v2] = sorted(rj['visits'], key=lambda j: j['dt'])
+
+        assert v1['context'] == 'perhaps it will help someone else https://wiki.termux.com/wiki/Termux-setup-storage'
+        assert v1['dt'] == '02 Dec 2023 00:00:00 -0500'  # uses server timezone (original visit didn't have it)
+
+        assert v2['normalised_url'] == 'someone.org/something'
+        assert v2['dt'] == '04 Dec 2023 11:12:13 +0300'  # uses original visit timezone
+
+        rj = server.post('/search', json={'url': 'comment'}).json()
+        [v] = rj['visits']
+        assert v['context'] == 'perhaps it will help someone else https://wiki.termux.com/wiki/Termux-setup-storage'
+
+
+def test_search_around(tmp_path: Path) -> None:
+    # this should return visits up to 3 hours in the past
+    def cfg() -> None:
+        from promnesia.common import Source
+        from promnesia.sources import demo
+
+        # generates 60 visits within 10 mins of each other -- so spanning over 10 hours
+        SOURCES = [Source(demo.index, count=60, base_dt='2000-01-01T00:00:00+03:00', delta=10 * 60)]
+
+    cfg_path = tmp_path / 'config.py'
+    write_config(cfg_path, cfg)
+    do_index(cfg_path)
+
+    # TODO hmm. perhaps it makes more sense to run query in different process and server in main process for testing??
+    with run_server(db=tmp_path / 'promnesia.sqlite') as server:
+        rj = server.post(
+            '/search_around',
+            json={'timestamp': datetime.fromisoformat('2005-01-01T00:00:00+06:00').timestamp()},
+        ).json()
+        assert rj['visits'] == []
+
+        rj = server.post(
+            '/search_around',
+            json={'timestamp': datetime.fromisoformat('2000-01-01T07:55:00+06:00').timestamp()},
+        ).json()
+        visits = rj['visits']
+        assert len(visits) == 18  # 6 per hour * 3
+        assert visits[0 ]['dt'] == '01 Jan 2000 02:00:00 +0300'
+        assert visits[-1]['dt'] == '01 Jan 2000 04:50:00 +0300'
+
+
+@pytest.mark.parametrize('mode', ['update', 'overwrite'])
+def test_query_while_indexing(tmp_path: Path, mode: str) -> None:
+    overwrite = mode == 'overwrite'
+    moverwrite = ['--overwrite'] if overwrite else []
+
+    def _index(run_id: str) -> Popen:
+        def cfg(run_id: str) -> None:
+            from promnesia.common import Source
+            from promnesia.sources import demo
+
+            SOURCES = [Source(demo.index, count=1_000, name=run_id)]
+
+        cfg_path = tmp_path / f'config{run_id}.py'
+        write_config(cfg_path, cfg, run_id=run_id)
+
+        return Popen(promnesia_bin('index', '--config', cfg_path, *moverwrite))
+
+    # trigger initial indexing
+    with _index(run_id='0'):
+        pass
+
+    with run_server(db=tmp_path / 'promnesia.sqlite') as server:
+        rj = server.post(
+            '/search_around',
+            json={'timestamp': datetime.fromisoformat('2005-01-01T00:00:00+06:00').timestamp()},
+        ).json()
+        assert rj['visits'] == []
+
+        for run_id in range(1, 5):
+            with _index(run_id=str(run_id)) as indexer:
+                # hammer the backend to increase likelihood of race condition
+                while indexer.poll() is None:
+                    stats = server.post('/status').json()['stats']
+                    total_visits = stats['total_visits']
+                    if overwrite:
+                        assert total_visits >= 1_000
+                    else:
+                        assert total_visits >= 1_000 * run_id
+
+
+# TODO also could check server methods directly?
+# via something like this... but not sure if really makes much difference
+# import promnesia.server as S
+# S.EnvConfig.set(S.ServerConfig(
+#     # TODO populate with test db and benchmark properly...
+#     db=Path('/todo'),
+#     timezone=pytz.utc,
+# ))
+# links = [f'https://reddit.com/whatever{i}.html' for i in range(count)]
+# res = S.visited(links)
+# assert len(res) == len(links)

promnesia/tests/test_traverse.py

@@ -0,0 +1,41 @@
+from unittest.mock import patch
+
+from ..common import traverse
+
+from .common import get_testdata
+
+
+testDataPath = get_testdata('traverse')
+
+
+# Patch shutil.which so it always returns false (when trying to which fdfind, etc)
+# so that it falls back to find
+@patch('promnesia.common.shutil.which', return_value=False)
+def test_traverse_ignore_find(patched) -> None:
+    '''
+    traverse() with `find` but ignore some stuff
+    '''
+    paths = set(traverse(testDataPath, ignore=['ignoreme.txt', 'ignoreme2']))
+
+    assert paths == {testDataPath / 'imhere2/real.txt', testDataPath / 'imhere.txt'}
+
+
+def test_traverse_ignore_fdfind():
+    '''
+    traverse() with `fdfind` but ignore some stuff
+    '''
+    paths = set(traverse(testDataPath, ignore=['ignoreme.txt', 'ignoreme2']))
+
+    assert paths == {testDataPath / 'imhere.txt', testDataPath / 'imhere2/real.txt'}
+
+
+# TODO: It would be nice to test the implementation directly without having to do this
+# weird patching in the future
+@patch('promnesia.common._is_windows', new_callable=lambda: True)
+def test_traverse_ignore_windows(patched) -> None:
+    '''
+    traverse() with python when _is_windows is true but ignore some stuff
+    '''
+    paths = set(traverse(testDataPath, ignore=['ignoreme.txt', 'ignoreme2']))
+
+    assert paths == {testDataPath / 'imhere.txt', testDataPath / 'imhere2/real.txt'}

promnesia/tests/utils.py

@@ -0,0 +1,35 @@
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Mapping, Optional, Sequence, Tuple, Union
+
+from ..common import Source, Loc, Visit
+from ..database.dump import visits_to_sqlite
+from ..extract import extract_visits
+
+
+# TODO a bit shit... why did I make it dict at first??
+Urls = Union[
+           Mapping[str, Optional[str]],
+    Sequence[Tuple[str, Optional[str]]],
+]
+
+
+def index_urls(urls: Urls, *, source_name: str = 'test'):
+    uuu = list(urls.items()) if isinstance(urls, dict) else urls
+
+    def idx(tmp_path: Path) -> None:
+        def indexer():
+            for i, (url, ctx) in enumerate(uuu):
+                yield Visit(
+                    url=url,
+                    dt=datetime.min + timedelta(days=5000) + timedelta(hours=i),
+                    locator=Loc.make('test'),
+                    context=ctx,
+                )
+
+        db_visits = extract_visits(source=Source(indexer), src=source_name)
+        errors = visits_to_sqlite(vit=db_visits, overwrite_db=True, _db_path=tmp_path / 'promnesia.sqlite')
+
+        assert len(errors) == 0, errors
+
+    return idx

{promnesia-1.1.20230129.dist-info → promnesia-1.2.20240810.dist-info}/METADATA

@@ -1,19 +1,17 @@
 Metadata-Version: 2.1
 Name: promnesia
-Version: 1.1.20230129
+Version: 1.2.20240810
 Summary: Enhancement of your browsing history
 Home-page: https://github.com/karlicoss/promnesia
 Author: Dmitrii Gerasimov
 Author-email: karlicoss@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Requires-Python: >=3.7
+Requires-Python: >=3.8
+License-File: LICENSE
 Requires-Dist: appdirs
 Requires-Dist: tzlocal
 Requires-Dist: more-itertools
 Requires-Dist: pytz
-Requires-Dist: sqlalchemy
-Requires-Dist: cachew (>=0.8.0)
+Requires-Dist: sqlalchemy >=2.0
 Requires-Dist: urlextract
 Requires-Dist: fastapi
 Requires-Dist: uvicorn[standard]
@@ -26,34 +24,31 @@ Requires-Dist: HPI ; extra == 'all'
 Requires-Dist: beautifulsoup4 ; extra == 'all'
 Requires-Dist: lxml ; extra == 'all'
 Requires-Dist: mistletoe ; extra == 'all'
-Requires-Dist: orgparse (>=0.3.0) ; extra == 'all'
-Requires-Dist: dataset ; extra == 'all'
+Requires-Dist: orgparse >=0.3.0 ; extra == 'all'
 Provides-Extra: html
 Requires-Dist: beautifulsoup4 ; extra == 'html'
 Requires-Dist: lxml ; extra == 'html'
-Provides-Extra: linting
-Requires-Dist: pytest ; extra == 'linting'
-Requires-Dist: mypy ; extra == 'linting'
-Requires-Dist: lxml ; extra == 'linting'
 Provides-Extra: markdown
 Requires-Dist: mistletoe ; extra == 'markdown'
 Provides-Extra: optional
 Requires-Dist: logzero ; extra == 'optional'
 Requires-Dist: python-magic ; extra == 'optional'
 Provides-Extra: org
-Requires-Dist: orgparse (>=0.3.0) ; extra == 'org'
+Requires-Dist: orgparse >=0.3.0 ; extra == 'org'
 Provides-Extra: telegram
-Requires-Dist: dataset ; extra == 'telegram'
 Provides-Extra: testing
 Requires-Dist: pytest ; extra == 'testing'
 Requires-Dist: pytest-timeout ; extra == 'testing'
 Requires-Dist: pytest-xdist ; extra == 'testing'
+Requires-Dist: hypothesis ; extra == 'testing'
 Requires-Dist: psutil ; extra == 'testing'
-Requires-Dist: httpie ; extra == 'testing'
+Requires-Dist: requests ; extra == 'testing'
 Requires-Dist: selenium ; extra == 'testing'
 Requires-Dist: click ; extra == 'testing'
-Requires-Dist: pyautogui ; extra == 'testing'
-
-UNKNOWN
-
+Requires-Dist: ruff ; extra == 'testing'
+Requires-Dist: mypy ; extra == 'testing'
+Requires-Dist: lxml ; extra == 'testing'
+Requires-Dist: loguru ; extra == 'testing'
+Provides-Extra: testing-gui
+Requires-Dist: pyautogui ; extra == 'testing-gui'