Philipp Hörist pushed to branch master at gajim / gajim

Commits:

6 changed files:

Changes:

  • gajim/common/configpaths.py
    ... ... @@ -24,10 +24,12 @@
    24 24 
     from typing import Generator
    25 25 
     from typing import Optional  # pylint: disable=unused-import
    26 26 
     from typing import Tuple
    27 
    +from typing import cast
    27 28
    28 29 
     import os
    29 30 
     import sys
    30 31 
     import tempfile
    32 
    +import importlib.resources
    31 33 
     from pathlib import Path
    32 34
    33 35 
     from gi.repository import GLib
    ... ... @@ -118,12 +120,7 @@ def __init__(self) -> None:
    118 120 
                 self.cache_root = Path(GLib.get_user_cache_dir()) / 'gajim'
    119 121 
                 self.data_root = Path(GLib.get_user_data_dir()) / 'gajim'
    120 122
    121 
    -        if sys.version_info < (3, 9):
    122 
    -            import pkg_resources
    123 
    -            basedir = Path(pkg_resources.resource_filename("gajim", "."))
    124 
    -        else:
    125 
    -            import importlib.resources
    126 
    -            basedir = importlib.resources.files('gajim')
    123 
    +        basedir = cast(Path, importlib.resources.files('gajim'))
    127 124
    128 125 
             source_paths = [
    129 126 
                 ('DATA', basedir / 'data'),

  • gajim/common/modules/bookmarks.py
    ... ... @@ -21,16 +21,19 @@
    21 21 
     from typing import Tuple
    22 22 
     from typing import Union
    23 23 
     from typing import Optional
    24 
    +from typing import cast
    24 25
    25 26 
     import functools
    26 27
    27 28 
     from nbxmpp.namespaces import Namespace
    28 29 
     from nbxmpp.protocol import JID
    29 30 
     from nbxmpp.structs import BookmarkData
    31 
    +from nbxmpp.task import Task
    30 32 
     from gi.repository import GLib
    31 33
    32 34 
     from gajim.common import app
    33 35 
     from gajim.common.nec import NetworkEvent
    36 
    +from gajim.common.types import BookmarksDict
    34 37 
     from gajim.common.modules.base import BaseModule
    35 38 
     from gajim.common.modules.util import event_node
    36 39
    ... ... @@ -47,8 +50,8 @@ def __init__(self, con):
    47 50 
             self._compat = False
    48 51 
             self._compat_pep = False
    49 52 
             self._node_max = False
    50 
    -        self._bookmarks = {}
    51 
    -        self._join_timeouts = []
    53 
    +        self._bookmarks: BookmarksDict = {}
    54 
    +        self._join_timeouts: List[int] = []
    52 55 
             self._request_in_progress = True
    53 56
    54 57 
         @property
    ... ... @@ -65,7 +68,7 @@ def compat_pep(self) -> bool:
    65 68
    66 69 
         @property
    67 70 
         def bookmarks(self) -> List[BookmarkData]:
    68 
    -        return self._bookmarks.values()
    71 
    +        return list(self._bookmarks.values())
    69 72
    70 73 
         @property
    71 74 
         def pep_bookmarks_used(self) -> bool:
    ... ... @@ -125,11 +128,11 @@ def _bookmark_1_event_received(self, _con, _stanza, properties):
    125 128 
                 self._log.info('Retract: %s', jid)
    126 129 
                 bookmark = self._bookmarks.get(jid)
    127 130 
                 if bookmark is not None:
    128 
    -                self._bookmarks.pop(bookmark, None)
    131 
    +                self._bookmarks.pop(jid, None)
    129 132
    130 133 
             else:
    131 
    -            new_bookmark = properties.pubsub_event.data
    132 
    -            self._bookmarks[new_bookmark.jid] = properties.pubsub_event.data
    134 
    +            new_bookmark: BookmarkData = properties.pubsub_event.data
    135 
    +            self._bookmarks[new_bookmark.jid] = new_bookmark
    133 136
    134 137 
             self._act_on_changed_bookmarks(old_bookmarks)
    135 138 
             app.nec.push_incoming_event(
    ... ... @@ -156,20 +159,18 @@ def _bookmark_module(self):
    156 159 
                 return 'PEPBookmarks'
    157 160 
             return 'PrivateBookmarks'
    158 161
    159 
    -    def _act_on_changed_bookmarks(
    160 
    -            self, old_bookmarks: Dict[str, BookmarkData]) -> None:
    161 
    -
    162 
    +    def _act_on_changed_bookmarks(self, current_bookmarks: BookmarksDict) -> None:
    162 163 
             new_bookmarks = self._convert_to_set(self._bookmarks)
    163 
    -        old_bookmarks = self._convert_to_set(old_bookmarks)
    164 
    +        old_bookmarks = self._convert_to_set(current_bookmarks)
    164 165 
             changed = new_bookmarks - old_bookmarks
    165 166 
             if not changed:
    166 167 
                 return
    167 168
    168 169 
             join = [jid for jid, autojoin in changed if autojoin]
    169 
    -        bookmarks = []
    170 
    +        bookmarks: List[BookmarkData] = []
    170 171 
             for jid in join:
    171 172 
                 self._log.info('Schedule autojoin in 10s for: %s', jid)
    172 
    -            bookmarks.append(self._bookmarks.get(jid))
    173 
    +            bookmarks.append(cast(BookmarkData, self._bookmarks.get(jid)))
    173 174 
             # If another client creates a MUC, the MUC is locked until the
    174 175 
             # configuration is finished. Give the user some time to finish
    175 176 
             # the configuration.
    ... ... @@ -181,26 +182,24 @@ def _act_on_changed_bookmarks(
    181 182 
             # leave = [jid for jid, autojoin in changed if not autojoin]
    182 183
    183 184 
         @staticmethod
    184 
    -    def _convert_to_set(
    185 
    -            bookmarks: Dict[str, BookmarkData]) -> Set[Tuple[str, bool]]:
    186 
    -
    187 
    -        set_ = set()
    185 
    +    def _convert_to_set(bookmarks: BookmarksDict) -> Set[Tuple[JID, bool]]:
    186 
    +        set_: Set[Tuple[JID, bool]] = set()
    188 187 
             for jid, bookmark in bookmarks.items():
    189 188 
                 set_.add((jid, bookmark.autojoin))
    190 189 
             return set_
    191 190
    192 191 
         @staticmethod
    193 
    -    def _convert_to_dict(bookmarks: List) -> Dict[str, BookmarkData]:
    194 
    -        _dict = {}  # type: Dict[str, BookmarkData]
    195 
    -        if bookmarks is None:
    192 
    +    def _convert_to_dict(bookmarks: Optional[List[BookmarkData]]) -> BookmarksDict:
    193 
    +        _dict: BookmarksDict = {}
    194 
    +        if not bookmarks:
    196 195 
                 return _dict
    197 196
    198 197 
             for bookmark in bookmarks:
    199 198 
                 _dict[bookmark.jid] = bookmark
    200 199 
             return _dict
    201 200
    202 
    -    def get_bookmark(self, jid: Union[str, JID]) -> BookmarkData:
    203 
    -        return self._bookmarks.get(jid)
    201 
    +    def get_bookmark(self, jid: Union[str, JID]) -> Optional[BookmarkData]:
    202 
    +        return self._bookmarks.get(cast(JID, jid))
    204 203
    205 204 
         def request_bookmarks(self) -> None:
    206 205 
             if not app.account_is_available(self._account):
    ... ... @@ -210,40 +209,36 @@ def request_bookmarks(self) -> None:
    210 209 
             self._nbxmpp(self._bookmark_module()).request_bookmarks(
    211 210 
                 callback=self._bookmarks_received)
    212 211
    213 
    -    def _bookmarks_received(self, task: Any) -> None:
    212 
    +    def _bookmarks_received(self, task: Task) -> None:
    214 213 
             try:
    215 
    -            bookmarks = task.finish()
    214 
    +            bookmarks: List[BookmarkData] = task.finish()
    216 215 
             except Exception as error:
    217 216 
                 self._log.warning(error)
    218 
    -            bookmarks = None
    217 
    +            bookmarks = []
    219 218
    220 219 
             self._request_in_progress = False
    221 220 
             self._bookmarks = self._convert_to_dict(bookmarks)
    222 
    -        self.auto_join_bookmarks()
    221 
    +        self.auto_join_bookmarks(self.bookmarks)
    223 222 
             app.nec.push_incoming_event(
    224 223 
                 NetworkEvent('bookmarks-received', account=self._account))
    225 224
    226 
    -    def store_bookmarks(self, bookmarks: list = None) -> None:
    225 
    +    def store_bookmarks(self, bookmarks: List[BookmarkData]) -> None:
    227 226 
             if not app.account_is_available(self._account):
    228 227 
                 return
    229 228
    230 
    -        if bookmarks is None or not self.nativ_bookmarks_used:
    231 
    -            bookmarks = self._bookmarks.values()
    229 
    +        if not self.nativ_bookmarks_used:
    230 
    +            bookmarks = self.bookmarks
    232 231
    233 232 
             self._nbxmpp(self._bookmark_module()).store_bookmarks(bookmarks)
    234 233
    235 234 
             app.nec.push_incoming_event(
    236 235 
                 NetworkEvent('bookmarks-received', account=self._account))
    237 236
    238 
    -    def _join_with_timeout(self, bookmarks: List[Any]) -> None:
    237 
    +    def _join_with_timeout(self, bookmarks: List[BookmarkData]) -> None:
    239 238 
             self._join_timeouts.pop(0)
    240 239 
             self.auto_join_bookmarks(bookmarks)
    241 240
    242 
    -    def auto_join_bookmarks(self,
    243 
    -                            bookmarks: Optional[List[Any]] = None) -> None:
    244 
    -        if bookmarks is None:
    245 
    -            bookmarks = self._bookmarks.values()
    246 
    -
    241 
    +    def auto_join_bookmarks(self, bookmarks: List[BookmarkData]) -> None:
    247 242 
             for bookmark in bookmarks:
    248 243 
                 if bookmark.autojoin:
    249 244 
                     # Only join non-opened groupchats. Opened one are already
    ... ... @@ -259,7 +254,7 @@ def auto_join_bookmarks(self,
    259 254 
                                                      str(bookmark.jid),
    260 255 
                                                      minimized=minimize)
    261 256
    262 
    -    def modify(self, jid: str, **kwargs: Dict[str, str]) -> None:
    257 
    +    def modify(self, jid: JID, **kwargs: Any) -> None:
    263 258 
             bookmark = self._bookmarks.get(jid)
    264 259 
             if bookmark is None:
    265 260 
                 return
    ... ... @@ -273,7 +268,7 @@ def modify(self, jid: str, **kwargs: Dict[str, str]) -> None:
    273 268
    274 269 
             self.store_bookmarks([new_bookmark])
    275 270
    276 
    -    def add_or_modify(self, jid: str, **kwargs: Dict[str, str]) -> None:
    271 
    +    def add_or_modify(self, jid: JID, **kwargs: Any) -> None:
    277 272 
             bookmark = self._bookmarks.get(jid)
    278 273 
             if bookmark is not None:
    279 274 
                 self.modify(jid, **kwargs)
    ... ... @@ -291,17 +286,17 @@ def remove(self, jid: JID, publish: bool = True) -> None:
    291 286 
                 return
    292 287 
             if publish:
    293 288 
                 if self.nativ_bookmarks_used:
    294 
    -                self._nbxmpp('NativeBookmarks').retract_bookmark(str(jid))
    289 
    +                self._nbxmpp('NativeBookmarks').retract_bookmark(jid)
    295 290 
                 else:
    296 
    -                self.store_bookmarks()
    291 
    +                self.store_bookmarks(self.bookmarks)
    297 292
    298 
    -    def get_name_from_bookmark(self, jid: str) -> str:
    299 
    -        bookmark = self._bookmarks.get(jid)
    293 
    +    def get_name_from_bookmark(self, jid: Union[str, JID]) -> Optional[str]:
    294 
    +        bookmark = self._bookmarks.get(cast(JID, jid))
    300 295 
             if bookmark is None:
    301 
    -            return ''
    296 
    +            return bookmark
    302 297 
             return bookmark.name
    303 298
    304 
    -    def is_bookmark(self, jid: str) -> bool:
    299 
    +    def is_bookmark(self, jid: Union[str, JID]) -> bool:
    305 300 
             return jid in self._bookmarks
    306 301
    307 302 
         def _remove_timeouts(self):

  • gajim/common/settings.py
    ... ... @@ -28,6 +28,7 @@
    28 28 
     from collections import defaultdict
    29 29
    30 30 
     from gi.repository import GLib
    31 
    +from nbxmpp.protocol import JID
    31 32
    32 33 
     from gajim import IS_PORTABLE
    33 34 
     from gajim.common import app
    ... ... @@ -600,7 +601,7 @@ def set_account_setting(self,
    600 601
    601 602 
         def get_group_chat_setting(self,
    602 603 
                                    account: str,
    603 
    -                               jid: str,
    604 
    +                               jid: Union[str, JID],
    604 605 
                                    setting: str) -> SETTING_TYPE:
    605 606
    606 607 
             if account not in self._account_settings:

  • gajim/common/types.py
    ... ... @@ -24,6 +24,8 @@
    24 24
    25 25 
     from pathlib import Path
    26 26 
     import nbxmpp
    27 
    +from nbxmpp.protocol import JID
    28 
    +from nbxmpp.structs import BookmarkData
    27 29
    28 30 
     from gajim.common.const import PathType, PathLocation
    29 31
    ... ... @@ -63,3 +65,5 @@
    63 65 
     PluginEvents = List['NetworkEvent']
    64 66
    65 67 
     SettingsT = Union['Settings']
    68 
    +
    69 
    +BookmarksDict = Dict[JID, BookmarkData]

  • mypy.ini
    1 1 
     [mypy]
    2 
    -python_version = 3.7
    2 
    +python_version = 3.9
    3 3 
     warn_unused_configs = True
    4 4 
     disallow_incomplete_defs = True
    5 5 
     allow_redefinition = True

  • pyrightconfig.json
    1 
    +{
    2 
    +    "ignore": [
    3 
    +        "setup.py",
    4 
    +        "test",
    5 
    +        ".gitlab"
    6 
    +        "data",
    7 
    +        "flatpak",
    8 
    +        "mac",
    9 
    +        "scripts",
    10 
    +        "win",
    11 
    +    ],
    12 
    +    "typeCheckingMode": "strict",
    13 
    +}

    • —
    View it on GitLab.
    You're receiving this email because of your account on dev.gajim.org. If you'd like to receive fewer emails, you can adjust your notification settings.