Mercurial > libervia-backend
annotate libervia/cli/base.py @ 4247:4aa62767f501
plugin app manager: various improvements:
- Generated password must now be named and are stored, so they are re-used on following
restarts. Password size can now be specified.
- New `not` filter for `!libervia_param` to inverse a boolean value.
- Former `front_url` field has been renamed to `web_url_path` as it is the URL path used
for web frontend. All Web frontend related field are prefixed with `web_`.
- `front_url` is now used to specify a whole front URL (notably useful if an app uses its
own domain). A list can be used to retrieve a key, like for `url_prefix`, and `https`
scheme is added if no scheme is specified.
- An abstract class is now used for App Managers.
- Last application start time is stored in persistent data.
| author | Goffi <goffi@goffi.org> |
|---|---|
| date | Fri, 31 May 2024 11:08:14 +0200 |
| parents | d01b8d002619 |
| children | 5115976e1e3d |
| rev | line source |
|---|---|
|
3043
3df611adb598
jp: handle dbus bridge with asyncio:
Goffi <goffi@goffi.org>
parents:
3040
diff
changeset
|
1 #!/usr/bin/env python3 |
| 0 | 2 |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
3 # Libervia CLI |
| 3479 | 4 # Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org) |
| 0 | 5 |
|
609
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
6 # This program is free software: you can redistribute it and/or modify |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
7 # it under the terms of the GNU Affero General Public License as published by |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
8 # the Free Software Foundation, either version 3 of the License, or |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
9 # (at your option) any later version. |
| 0 | 10 |
|
609
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
11 # This program is distributed in the hope that it will be useful, |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
14 # GNU Affero General Public License for more details. |
| 0 | 15 |
|
609
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
16 # You should have received a copy of the GNU Affero General Public License |
|
84a6e83157c2
fixed licences in docstrings (they are now in comments)
Goffi <goffi@goffi.org>
parents:
601
diff
changeset
|
17 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 0 | 18 |
| 3040 | 19 import asyncio |
|
4071
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
20 from libervia.backend.core.i18n import _ |
|
402
f03688bdb858
jp: use with statement to open fifo
Goffi <goffi@goffi.org>
parents:
401
diff
changeset
|
21 |
| 0 | 22 ### logging ### |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
23 import logging as log |
| 3040 | 24 log.basicConfig(level=log.WARNING, |
| 25 format='[%(name)s] %(message)s') | |
| 0 | 26 ### |
| 27 | |
| 28 import sys | |
| 3040 | 29 import os |
| 817 | 30 import os.path |
| 31 import argparse | |
| 3040 | 32 import inspect |
| 3046 | 33 import tty |
| 34 import termios | |
| 3040 | 35 from pathlib import Path |
| 817 | 36 from glob import iglob |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
37 from typing import Optional, Set, Union |
| 817 | 38 from importlib import import_module |
|
4074
26b7ed2817da
refactoring: rename `sat_frontends` to `libervia.frontends`
Goffi <goffi@goffi.org>
parents:
4071
diff
changeset
|
39 from libervia.frontends.tools.jid import JID |
|
4071
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
40 from libervia.backend.tools import config |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
41 from libervia.backend.tools.common import dynamic_import |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
42 from libervia.backend.tools.common import uri |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
43 from libervia.backend.tools.common import date_utils |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
44 from libervia.backend.tools.common import utils |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
45 from libervia.backend.tools.common import data_format |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
46 from libervia.backend.tools.common.ansi import ANSI as A |
|
4b842c1fb686
refactoring: renamed `sat` package to `libervia.backend`
Goffi <goffi@goffi.org>
parents:
4042
diff
changeset
|
47 from libervia.backend.core import exceptions |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
48 import libervia.cli |
|
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
49 from libervia.cli.loops import QuitException, get_libervia_cli_loop |
|
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
50 from libervia.cli.constants import Const as C |
|
4074
26b7ed2817da
refactoring: rename `sat_frontends` to `libervia.frontends`
Goffi <goffi@goffi.org>
parents:
4071
diff
changeset
|
51 from libervia.frontends.bridge.bridge_frontend import BridgeException |
|
4142
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
52 from libervia.frontends.tools import aio, misc |
|
1840
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
53 import xml.etree.ElementTree as ET # FIXME: used temporarily to manage XMLUI |
| 1950 | 54 from collections import OrderedDict |
| 4129 | 55 from rich import console |
|
1872
df1ca137b0cb
jp (blog/edit): editor arguments can now be specified on sat.conf, and default on are applied for known editors:
Goffi <goffi@goffi.org>
parents:
1869
diff
changeset
|
56 |
|
2098
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
57 ## bridge handling |
|
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
58 # we get bridge name from conf and initialise the right class accordingly |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
59 main_config = config.parse_main_conf() |
|
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
60 bridge_name = config.config_get(main_config, '', 'bridge', 'dbus') |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
61 LiberviaCLILoop = get_libervia_cli_loop(bridge_name) |
|
2098
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
62 |
|
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
63 |
| 0 | 64 try: |
| 817 | 65 import progressbar |
| 66 except ImportError: | |
| 3040 | 67 msg = (_('ProgressBar not available, please download it at ' |
| 68 'http://pypi.python.org/pypi/progressbar\n' | |
| 69 'Progress bar deactivated\n--\n')) | |
| 70 print(msg, file=sys.stderr) | |
| 817 | 71 progressbar=None |
| 72 | |
| 73 #consts | |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
74 DESCRIPTION = """This software is a command line tool for XMPP. |
|
970
2e052998c7eb
jp: using C.APP_URL for application url
Goffi <goffi@goffi.org>
parents:
965
diff
changeset
|
75 Get the latest version at """ + C.APP_URL |
| 817 | 76 |
|
4233
d01b8d002619
cli (call, file), frontends: implement webRTC data channel transfer:
Goffi <goffi@goffi.org>
parents:
4224
diff
changeset
|
77 COPYLEFT = """Copyright (C) 2009-2024 Jérôme Poisson, Adrien Cossa |
| 817 | 78 This program comes with ABSOLUTELY NO WARRANTY; |
| 79 This is free software, and you are welcome to redistribute it under certain conditions. | |
| 80 """ | |
| 0 | 81 |
| 3040 | 82 PROGRESS_DELAY = 0.1 # the progression will be checked every PROGRESS_DELAY s |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
83 |
| 0 | 84 |
|
2704
ab37d1c7c38c
jp (base): new date_decoder to specify dates in arguments
Goffi <goffi@goffi.org>
parents:
2692
diff
changeset
|
85 def date_decoder(arg): |
|
ab37d1c7c38c
jp (base): new date_decoder to specify dates in arguments
Goffi <goffi@goffi.org>
parents:
2692
diff
changeset
|
86 return date_utils.date_parse_ext(arg, default_tz=date_utils.TZ_LOCAL) |
|
ab37d1c7c38c
jp (base): new date_decoder to specify dates in arguments
Goffi <goffi@goffi.org>
parents:
2692
diff
changeset
|
87 |
|
ab37d1c7c38c
jp (base): new date_decoder to specify dates in arguments
Goffi <goffi@goffi.org>
parents:
2692
diff
changeset
|
88 |
|
3481
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
89 class LiberviaCli: |
| 814 | 90 """ |
| 91 This class can be use to establish a connection with the | |
| 92 bridge. Moreover, it should manage a main loop. | |
| 93 | |
| 94 To use it, you mainly have to redefine the method run to perform | |
| 95 specify what kind of operation you want to perform. | |
| 96 | |
| 97 """ | |
| 817 | 98 def __init__(self): |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
99 """ |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
100 |
| 3040 | 101 @attribute quit_on_progress_end (bool): set to False if you manage yourself |
| 102 exiting, or if you want the user to stop by himself | |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
103 @attribute progress_success(callable): method to call when progress just started |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
104 by default display a message |
| 3040 | 105 @attribute progress_success(callable): method to call when progress is |
| 106 successfully finished by default display a message | |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
107 @attribute progress_failure(callable): method to call when progress failed |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
108 by default display a message |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
109 """ |
| 4129 | 110 self.console = console.Console(theme=C.THEME_DEFAULT) |
| 3046 | 111 self.sat_conf = main_config |
| 112 self.set_color_theme() | |
|
4074
26b7ed2817da
refactoring: rename `sat_frontends` to `libervia.frontends`
Goffi <goffi@goffi.org>
parents:
4071
diff
changeset
|
113 bridge_module = dynamic_import.bridge(bridge_name, 'libervia.frontends.bridge') |
|
2098
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
114 if bridge_module is None: |
| 3028 | 115 log.error("Can't import {} bridge".format(bridge_name)) |
|
165
8a2053de6f8c
Frontends: management of unlaunched SàT Backend (information message and exit)
Goffi <goffi@goffi.org>
parents:
156
diff
changeset
|
116 sys.exit(1) |
| 814 | 117 |
| 3040 | 118 self.bridge = bridge_module.AIOBridge() |
|
4133
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
119 self._on_quit_callbacks = [] |
|
2098
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
120 |
|
3555
53fec6309fa3
cli: update constants to use new name
Goffi <goffi@goffi.org>
parents:
3547
diff
changeset
|
121 def get_config(self, name, section=C.CONFIG_SECTION, default=None): |
| 3046 | 122 """Retrieve a setting value from sat.conf""" |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
123 return config.config_get(self.sat_conf, section, name, default=default) |
| 3046 | 124 |
| 125 def guess_background(self): | |
|
3704
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
126 # cf. https://unix.stackexchange.com/a/245568 (thanks!) |
| 3046 | 127 try: |
|
3704
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
128 # for VTE based terminals |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
129 vte_version = int(os.getenv("VTE_VERSION", 0)) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
130 except ValueError: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
131 vte_version = 0 |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
132 |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
133 color_fg_bg = os.getenv("COLORFGBG") |
| 3046 | 134 |
|
3704
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
135 if ((sys.stdin.isatty() and sys.stdout.isatty() |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
136 and ( |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
137 # XTerm |
|
3706
5131ed9163c0
cli (base): use `XTERM_VERSION` to detect XTerm:
Goffi <goffi@goffi.org>
parents:
3705
diff
changeset
|
138 os.getenv("XTERM_VERSION") |
|
3704
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
139 # Konsole |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
140 or os.getenv("KONSOLE_VERSION") |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
141 # All VTE based terminals |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
142 or vte_version >= 3502 |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
143 ))): |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
144 # ANSI escape sequence |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
145 stdin_fd = sys.stdin.fileno() |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
146 old_settings = termios.tcgetattr(stdin_fd) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
147 try: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
148 tty.setraw(sys.stdin.fileno()) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
149 # we request background color |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
150 sys.stdout.write("\033]11;?\a") |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
151 sys.stdout.flush() |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
152 expected = "\033]11;rgb:" |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
153 for c in expected: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
154 ch = sys.stdin.read(1) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
155 if ch != c: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
156 # background id is not supported, we default to "dark" |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
157 # TODO: log something? |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
158 return 'dark' |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
159 red, green, blue = [ |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
160 int(c, 16)/65535 for c in sys.stdin.read(14).split('/') |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
161 ] |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
162 # '\a' is the last character |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
163 sys.stdin.read(1) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
164 finally: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
165 termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_settings) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
166 |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
167 lum = utils.per_luminance(red, green, blue) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
168 if lum <= 0.5: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
169 return 'dark' |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
170 else: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
171 return 'light' |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
172 elif color_fg_bg: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
173 # no luck with ANSI escape sequence, we try COLORFGBG environment variable |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
174 try: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
175 bg = int(color_fg_bg.split(";")[-1]) |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
176 except ValueError: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
177 return "dark" |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
178 if bg in list(range(7)) + [8]: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
179 return "dark" |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
180 else: |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
181 return "light" |
| 3046 | 182 else: |
|
3704
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
183 # no autodetection method found |
|
c143e7f35074
cli (base): better background detection:
Goffi <goffi@goffi.org>
parents:
3636
diff
changeset
|
184 return "dark" |
| 3046 | 185 |
| 186 def set_color_theme(self): | |
| 187 background = self.get_config('background', default='auto') | |
| 188 if background == 'auto': | |
| 189 background = self.guess_background() | |
| 190 if background not in ('dark', 'light'): | |
| 191 raise exceptions.ConfigError(_( | |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
192 'Invalid value set for "background" ({background}), please check ' |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
193 'your settings in libervia.conf').format( |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
194 background=repr(background) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
195 )) |
|
3705
691dbd78981c
cli (debug/theme): display currently used background
Goffi <goffi@goffi.org>
parents:
3704
diff
changeset
|
196 self.background = background |
| 3046 | 197 if background == 'light': |
| 198 C.A_HEADER = A.FG_MAGENTA | |
| 199 C.A_SUBHEADER = A.BOLD + A.FG_RED | |
| 200 C.A_LEVEL_COLORS = (C.A_HEADER, A.BOLD + A.FG_BLUE, A.FG_MAGENTA, A.FG_CYAN) | |
| 201 C.A_SUCCESS = A.FG_GREEN | |
| 202 C.A_FAILURE = A.BOLD + A.FG_RED | |
| 203 C.A_WARNING = A.FG_RED | |
| 204 C.A_PROMPT_PATH = A.FG_BLUE | |
| 205 C.A_PROMPT_SUF = A.BOLD | |
| 206 C.A_DIRECTORY = A.BOLD + A.FG_MAGENTA | |
| 207 C.A_FILE = A.FG_BLACK | |
| 208 | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
209 def _bridge_connected(self): |
| 3040 | 210 self.parser = argparse.ArgumentParser( |
| 211 formatter_class=argparse.RawDescriptionHelpFormatter, description=DESCRIPTION) | |
| 817 | 212 self._make_parents() |
| 213 self.add_parser_options() | |
| 3040 | 214 self.subparsers = self.parser.add_subparsers( |
| 215 title=_('Available commands'), dest='command', required=True) | |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
216 |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
217 # progress attributes |
| 817 | 218 self._progress_id = None # TODO: manage several progress ids |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
219 self.quit_on_progress_end = True |
| 817 | 220 |
| 1950 | 221 # outputs |
| 222 self._outputs = {} | |
| 223 for type_ in C.OUTPUT_TYPES: | |
| 224 self._outputs[type_] = OrderedDict() | |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
225 self.default_output = {} |
| 1950 | 226 |
|
2705
0bb811aaf11d
jp (base): new own_jid host attribute:
Goffi <goffi@goffi.org>
parents:
2704
diff
changeset
|
227 self.own_jid = None # must be filled at runtime if needed |
|
0bb811aaf11d
jp (base): new own_jid host attribute:
Goffi <goffi@goffi.org>
parents:
2704
diff
changeset
|
228 |
| 817 | 229 @property |
| 230 def progress_id(self): | |
| 231 return self._progress_id | |
| 232 | |
| 3040 | 233 async def set_progress_id(self, progress_id): |
| 234 # because we use async, we need an explicit setter | |
| 235 self._progress_id = progress_id | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
236 await self.replay_cache('progress_ids_cache') |
| 817 | 237 |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
238 @property |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
239 def watch_progress(self): |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
240 try: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
241 self.pbar |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
242 except AttributeError: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
243 return False |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
244 else: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
245 return True |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
246 |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
247 @watch_progress.setter |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
248 def watch_progress(self, watch_progress): |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
249 if watch_progress: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
250 self.pbar = None |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
251 |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
252 @property |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
253 def verbosity(self): |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
254 try: |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
255 return self.args.verbose |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
256 except AttributeError: |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
257 return 0 |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
258 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
259 async def replay_cache(self, cache_attribute): |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
260 """Replay cached signals |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
261 |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
262 @param cache_attribute(str): name of the attribute containing the cache |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
263 if the attribute doesn't exist, there is no cache and the call is ignored |
| 3040 | 264 else the cache must be a list of tuples containing the replay callback as |
| 265 first item, then the arguments to use | |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
266 """ |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
267 try: |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
268 cache = getattr(self, cache_attribute) |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
269 except AttributeError: |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
270 pass |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
271 else: |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
272 for cache_data in cache: |
| 3040 | 273 await cache_data[0](*cache_data[1:]) |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
274 |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
275 def disp(self, msg, verbosity=0, error=False, end='\n'): |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
276 """Print a message to user |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
277 |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
278 @param msg(unicode): message to print |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
279 @param verbosity(int): minimal verbosity to display the message |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
280 @param error(bool): if True, print to stderr instead of stdout |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
281 @param end(str): string appended after the last value, default a newline |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
282 """ |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
283 if self.verbosity >= verbosity: |
|
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
284 if error: |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
285 print(msg, end=end, file=sys.stderr) |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
286 else: |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
287 print(msg, end=end) |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
288 |
| 3040 | 289 async def output(self, type_, name, extra_outputs, data): |
| 2155 | 290 if name in extra_outputs: |
| 3040 | 291 method = extra_outputs[name] |
| 2155 | 292 else: |
| 3040 | 293 method = self._outputs[type_][name]['callback'] |
| 294 | |
| 295 ret = method(data) | |
| 296 if inspect.isawaitable(ret): | |
| 297 await ret | |
| 1950 | 298 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
299 def add_on_quit_callback(self, callback, *args, **kwargs): |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
300 """Add a callback which will be called on quit command |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
301 |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
302 @param callback(callback): method to call |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
303 """ |
|
4133
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
304 self._on_quit_callbacks.append((callback, args, kwargs)) |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
305 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
306 def get_output_choices(self, output_type): |
| 1950 | 307 """Return valid output filters for output_type |
| 308 | |
| 309 @param output_type: True for default, | |
| 310 else can be any registered type | |
| 311 """ | |
| 3028 | 312 return list(self._outputs[output_type].keys()) |
| 1950 | 313 |
| 817 | 314 def _make_parents(self): |
| 315 self.parents = {} | |
| 316 | |
| 3040 | 317 # we have a special case here as the start-session option is present only if |
| 318 # connection is not needed, so we create two similar parents, one with the | |
| 319 # option, the other one without it | |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
320 for parent_name in ('profile', 'profile_session'): |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
321 parent = self.parents[parent_name] = argparse.ArgumentParser(add_help=False) |
| 3040 | 322 parent.add_argument( |
| 323 "-p", "--profile", action="store", type=str, default='@DEFAULT@', | |
| 324 help=_("Use PROFILE profile key (default: %(default)s)")) | |
| 325 parent.add_argument( | |
|
3049
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
326 "--pwd", action="store", metavar='PASSWORD', |
| 3040 | 327 help=_("Password used to connect profile, if necessary")) |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
328 |
| 3040 | 329 profile_parent, profile_session_parent = (self.parents['profile'], |
| 330 self.parents['profile_session']) | |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
331 |
| 3040 | 332 connect_short, connect_long, connect_action, connect_help = ( |
| 333 "-c", "--connect", "store_true", | |
| 334 _("Connect the profile before doing anything else") | |
| 335 ) | |
| 336 profile_parent.add_argument( | |
| 337 connect_short, connect_long, action=connect_action, help=connect_help) | |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
338 |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
339 profile_session_connect_group = profile_session_parent.add_mutually_exclusive_group() |
| 3040 | 340 profile_session_connect_group.add_argument( |
| 341 connect_short, connect_long, action=connect_action, help=connect_help) | |
| 342 profile_session_connect_group.add_argument( | |
| 343 "--start-session", action="store_true", | |
| 344 help=_("Start a profile session without connecting")) | |
| 817 | 345 |
| 3040 | 346 progress_parent = self.parents['progress'] = argparse.ArgumentParser( |
| 347 add_help=False) | |
| 817 | 348 if progressbar: |
| 3040 | 349 progress_parent.add_argument( |
| 350 "-P", "--progress", action="store_true", help=_("Show progress bar")) | |
| 0 | 351 |
| 1600 | 352 verbose_parent = self.parents['verbose'] = argparse.ArgumentParser(add_help=False) |
| 3040 | 353 verbose_parent.add_argument( |
| 354 '--verbose', '-v', action='count', default=0, | |
| 355 help=_("Add a verbosity level (can be used multiple times)")) | |
| 1600 | 356 |
|
3412
7b4ae3dbc041
jp (base, pubsub/set): new `--quiet` argument:
Goffi <goffi@goffi.org>
parents:
3409
diff
changeset
|
357 quiet_parent = self.parents['quiet'] = argparse.ArgumentParser(add_help=False) |
|
7b4ae3dbc041
jp (base, pubsub/set): new `--quiet` argument:
Goffi <goffi@goffi.org>
parents:
3409
diff
changeset
|
358 quiet_parent.add_argument( |
|
7b4ae3dbc041
jp (base, pubsub/set): new `--quiet` argument:
Goffi <goffi@goffi.org>
parents:
3409
diff
changeset
|
359 '--quiet', '-q', action='store_true', |
|
7b4ae3dbc041
jp (base, pubsub/set): new `--quiet` argument:
Goffi <goffi@goffi.org>
parents:
3409
diff
changeset
|
360 help=_("be quiet (only output machine readable data)")) |
|
7b4ae3dbc041
jp (base, pubsub/set): new `--quiet` argument:
Goffi <goffi@goffi.org>
parents:
3409
diff
changeset
|
361 |
| 2532 | 362 draft_parent = self.parents['draft'] = argparse.ArgumentParser(add_help=False) |
| 363 draft_group = draft_parent.add_argument_group(_('draft handling')) | |
| 3040 | 364 draft_group.add_argument( |
| 365 "-D", "--current", action="store_true", help=_("load current draft")) | |
| 366 draft_group.add_argument( | |
| 367 "-F", "--draft-path", type=Path, help=_("path to a draft file to retrieve")) | |
| 2532 | 368 |
| 369 | |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
370 def make_pubsub_group(self, flags, defaults): |
|
3600
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
371 """Generate pubsub options according to flags |
| 2532 | 372 |
| 373 @param flags(iterable[unicode]): see [CommandBase.__init__] | |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
374 @param defaults(dict[unicode, unicode]): help text for default value |
|
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
375 key can be "service" or "node" |
|
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
376 value will be set in " (DEFAULT: {value})", or can be None to remove DEFAULT |
| 2532 | 377 @return (ArgumentParser): parser to add |
| 378 """ | |
| 379 flags = misc.FlagsHandler(flags) | |
| 380 parent = argparse.ArgumentParser(add_help=False) | |
| 381 pubsub_group = parent.add_argument_group('pubsub') | |
| 3028 | 382 pubsub_group.add_argument("-u", "--pubsub-url", |
| 383 help=_("Pubsub URL (xmpp or http)")) | |
| 2532 | 384 |
| 3028 | 385 service_help = _("JID of the PubSub service") |
| 2532 | 386 if not flags.service: |
| 3028 | 387 default = defaults.pop('service', _('PEP service')) |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
388 if default is not None: |
| 3028 | 389 service_help += _(" (DEFAULT: {default})".format(default=default)) |
| 390 pubsub_group.add_argument("-s", "--service", default='', | |
| 2532 | 391 help=service_help) |
| 392 | |
| 3028 | 393 node_help = _("node to request") |
| 2532 | 394 if not flags.node: |
| 3028 | 395 default = defaults.pop('node', _('standard node')) |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
396 if default is not None: |
| 3028 | 397 node_help += _(" (DEFAULT: {default})".format(default=default)) |
| 398 pubsub_group.add_argument("-n", "--node", default='', help=node_help) | |
| 2532 | 399 |
| 400 if flags.single_item: | |
| 3028 | 401 item_help = ("item to retrieve") |
|
2552
38e1e29c48e9
jp (base): added C.ITEM pubsub flag when --item is required
Goffi <goffi@goffi.org>
parents:
2550
diff
changeset
|
402 if not flags.item: |
| 3028 | 403 default = defaults.pop('item', _('last item')) |
|
2552
38e1e29c48e9
jp (base): added C.ITEM pubsub flag when --item is required
Goffi <goffi@goffi.org>
parents:
2550
diff
changeset
|
404 if default is not None: |
| 3028 | 405 item_help += _(" (DEFAULT: {default})".format(default=default)) |
| 406 pubsub_group.add_argument("-i", "--item", default='', | |
|
2910
b2f323237fce
jp, plugin merge-requests: used u'' as default for item id in pubsub arguments + fixed some required arguments:
Goffi <goffi@goffi.org>
parents:
2775
diff
changeset
|
407 help=item_help) |
| 3040 | 408 pubsub_group.add_argument( |
| 409 "-L", "--last-item", action='store_true', help=_('retrieve last item')) | |
| 2532 | 410 elif flags.multi_items: |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
411 # mutiple items, this activate several features: max-items, RSM, MAM |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
412 # and Orbder-by |
| 3040 | 413 pubsub_group.add_argument( |
| 414 "-i", "--item", action='append', dest='items', default=[], | |
| 415 help=_("items to retrieve (DEFAULT: all)")) | |
| 2539 | 416 if not flags.no_max: |
|
2775
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
417 max_group = pubsub_group.add_mutually_exclusive_group() |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
418 # XXX: defaut value for --max-items or --max is set in parse_pubsub_args |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
419 max_group.add_argument( |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
420 "-M", "--max-items", dest="max", type=int, |
| 3028 | 421 help=_("maximum number of items to get ({no_limit} to get all items)" |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
422 .format(no_limit=C.NO_LIMIT))) |
|
2775
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
423 # FIXME: it could be possible to no duplicate max (between pubsub |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
424 # max-items and RSM max)should not be duplicated, RSM could be |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
425 # used when available and pubsub max otherwise |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
426 max_group.add_argument( |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
427 "-m", "--max", dest="rsm_max", type=int, |
| 3028 | 428 help=_("maximum number of items to get per page (DEFAULT: 10)")) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
429 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
430 # RSM |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
431 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
432 rsm_page_group = pubsub_group.add_mutually_exclusive_group() |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
433 rsm_page_group.add_argument( |
| 3028 | 434 "-a", "--after", dest="rsm_after", |
| 435 help=_("find page after this item"), metavar='ITEM_ID') | |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
436 rsm_page_group.add_argument( |
| 3028 | 437 "-b", "--before", dest="rsm_before", |
| 438 help=_("find page before this item"), metavar='ITEM_ID') | |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
439 rsm_page_group.add_argument( |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
440 "--index", dest="rsm_index", type=int, |
|
3600
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
441 help=_("index of the first item to retrieve")) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
442 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
443 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
444 # MAM |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
445 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
446 pubsub_group.add_argument( |
| 3028 | 447 "-f", "--filter", dest='mam_filters', nargs=2, |
| 448 action='append', default=[], help=_("MAM filters to use"), | |
| 449 metavar=("FILTER_NAME", "VALUE") | |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
450 ) |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
451 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
452 # Order-By |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
453 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
454 # TODO: order-by should be a list to handle several levels of ordering |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
455 # but this is not yet done in SàT (and not really useful with |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
456 # current specifications, as only "creation" and "modification" are |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
457 # available) |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
458 pubsub_group.add_argument( |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
459 "-o", "--order-by", choices=[C.ORDER_BY_CREATION, |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
460 C.ORDER_BY_MODIFICATION], |
| 3028 | 461 help=_("how items should be ordered")) |
| 2532 | 462 |
|
3600
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
463 if flags[C.CACHE]: |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
464 pubsub_group.add_argument( |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
465 "-C", "--no-cache", dest="use_cache", action='store_false', |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
466 help=_("don't use Pubsub cache") |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
467 ) |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
468 |
|
2615
b4ecbcc2fd08
tools (misc): do not remove flags while using them anymore, instead added "all_used" and "unused" properties in FlagsHandler
Goffi <goffi@goffi.org>
parents:
2614
diff
changeset
|
469 if not flags.all_used: |
| 3040 | 470 raise exceptions.InternalError('unknown flags: {flags}'.format( |
| 471 flags=', '.join(flags.unused))) | |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
472 if defaults: |
| 3040 | 473 raise exceptions.InternalError(f'unused defaults: {defaults}') |
| 2532 | 474 |
| 475 return parent | |
|
2235
4db836386641
jp: added use_pubsub and use_pubsub_node_req arguments to CommandBase
Goffi <goffi@goffi.org>
parents:
2213
diff
changeset
|
476 |
| 817 | 477 def add_parser_options(self): |
| 3040 | 478 self.parser.add_argument( |
| 479 '--version', | |
| 480 action='version', | |
| 481 version=("{name} {version} {copyleft}".format( | |
|
3555
53fec6309fa3
cli: update constants to use new name
Goffi <goffi@goffi.org>
parents:
3547
diff
changeset
|
482 name = C.APP_NAME, |
| 3040 | 483 version = self.version, |
| 484 copyleft = COPYLEFT)) | |
| 485 ) | |
| 817 | 486 |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
487 def register_output(self, type_, name, callback, description="", default=False): |
| 1950 | 488 if type_ not in C.OUTPUT_TYPES: |
| 3028 | 489 log.error("Invalid output type {}".format(type_)) |
| 1950 | 490 return |
| 491 self._outputs[type_][name] = {'callback': callback, | |
| 492 'description': description | |
| 493 } | |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
494 if default: |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
495 if type_ in self.default_output: |
| 3040 | 496 self.disp( |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
497 _('there is already a default output for {type}, ignoring new one') |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
498 .format(type=type_) |
| 3040 | 499 ) |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
500 else: |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
501 self.default_output[type_] = name |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
502 |
| 1950 | 503 |
|
2187
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
504 def parse_output_options(self): |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
505 options = self.command.args.output_opts |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
506 options_dict = {} |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
507 for option in options: |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
508 try: |
| 3028 | 509 key, value = option.split('=', 1) |
|
2187
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
510 except ValueError: |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
511 key, value = option, None |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
512 options_dict[key.strip()] = value.strip() if value is not None else None |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
513 return options_dict |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
514 |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
515 def check_output_options(self, accepted_set, options): |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
516 if not accepted_set.issuperset(options): |
| 3040 | 517 self.disp( |
| 518 _("The following output options are invalid: {invalid_options}").format( | |
| 3028 | 519 invalid_options = ', '.join(set(options).difference(accepted_set))), |
|
2187
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
520 error=True) |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
521 self.quit(C.EXIT_BAD_ARG) |
|
4ec72927a222
jp (outputs): moved output options parsing and checking to base methods
Goffi <goffi@goffi.org>
parents:
2178
diff
changeset
|
522 |
| 1950 | 523 def import_plugins(self): |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
524 """Automaticaly import commands and outputs in CLI frontend |
| 1950 | 525 |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
526 looks from modules names cmd_*.py in CLI frontend path and import them |
| 817 | 527 """ |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
528 path = os.path.dirname(libervia.cli.__file__) |
| 1950 | 529 # XXX: outputs must be imported before commands as they are used for arguments |
| 3040 | 530 for type_, pattern in ((C.PLUGIN_OUTPUT, 'output_*.py'), |
| 531 (C.PLUGIN_CMD, 'cmd_*.py')): | |
| 532 modules = ( | |
| 533 os.path.splitext(module)[0] | |
| 534 for module in map(os.path.basename, iglob(os.path.join(path, pattern)))) | |
| 1950 | 535 for module_name in modules: |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
536 module_path = "libervia.cli." + module_name |
| 1950 | 537 try: |
|
2162
c9a67eb5bf72
jp (base): improved module import:
Goffi <goffi@goffi.org>
parents:
2161
diff
changeset
|
538 module = import_module(module_path) |
| 1950 | 539 self.import_plugin_module(module, type_) |
|
2178
b9bfc45cea22
jp (base): added generic errback to CommandBase + show error message on plugin ImportError
Goffi <goffi@goffi.org>
parents:
2168
diff
changeset
|
540 except ImportError as e: |
| 3040 | 541 self.disp( |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
542 _("Can't import {module_path} plugin, ignoring it: {e}") |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
543 .format(module_path=module_path, e=e), |
| 3040 | 544 error=True) |
|
2162
c9a67eb5bf72
jp (base): improved module import:
Goffi <goffi@goffi.org>
parents:
2161
diff
changeset
|
545 except exceptions.CancelError: |
| 1950 | 546 continue |
|
2162
c9a67eb5bf72
jp (base): improved module import:
Goffi <goffi@goffi.org>
parents:
2161
diff
changeset
|
547 except exceptions.MissingModule as e: |
| 3028 | 548 self.disp(_("Missing module for plugin {name}: {missing}".format( |
|
2162
c9a67eb5bf72
jp (base): improved module import:
Goffi <goffi@goffi.org>
parents:
2161
diff
changeset
|
549 name = module_path, |
|
2188
052d560d0dce
jp (base): replaced log.warning by stderr prints
Goffi <goffi@goffi.org>
parents:
2187
diff
changeset
|
550 missing = e)), error=True) |
|
2162
c9a67eb5bf72
jp (base): improved module import:
Goffi <goffi@goffi.org>
parents:
2161
diff
changeset
|
551 |
| 0 | 552 |
| 1950 | 553 def import_plugin_module(self, module, type_): |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
554 """add commands or outpus from a module to CLI frontend |
| 817 | 555 |
| 1950 | 556 @param module: module containing commands or outputs |
| 557 @param type_(str): one of C_PLUGIN_* | |
| 817 | 558 """ |
| 559 try: | |
| 1950 | 560 class_names = getattr(module, '__{}__'.format(type_)) |
| 817 | 561 except AttributeError: |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
562 log.disp( |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
563 _("Invalid plugin module [{type}] {module}") |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
564 .format(type=type_, module=module), |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
565 error=True) |
| 817 | 566 raise ImportError |
| 1950 | 567 else: |
| 568 for class_name in class_names: | |
| 569 cls = getattr(module, class_name) | |
| 570 cls(self) | |
| 817 | 571 |
| 2532 | 572 def get_xmpp_uri_from_http(self, http_url): |
| 573 """parse HTML page at http(s) URL, and looks for xmpp: uri""" | |
| 574 if http_url.startswith('https'): | |
| 3028 | 575 scheme = 'https' |
| 2532 | 576 elif http_url.startswith('http'): |
| 3028 | 577 scheme = 'http' |
| 2532 | 578 else: |
| 3028 | 579 raise exceptions.InternalError('An HTTP scheme is expected in this method') |
| 3040 | 580 self.disp(f"{scheme.upper()} URL found, trying to find associated xmpp: URI", 1) |
| 2532 | 581 # HTTP URL, we try to find xmpp: links |
| 582 try: | |
| 583 from lxml import etree | |
| 584 except ImportError: | |
| 3040 | 585 self.disp( |
| 586 "lxml module must be installed to use http(s) scheme, please install it " | |
| 587 "with \"pip install lxml\"", | |
| 588 error=True) | |
| 2672 | 589 self.quit(1) |
| 3028 | 590 import urllib.request, urllib.error, urllib.parse |
| 2532 | 591 parser = etree.HTMLParser() |
| 592 try: | |
| 3028 | 593 root = etree.parse(urllib.request.urlopen(http_url), parser) |
| 2532 | 594 except etree.XMLSyntaxError as e: |
| 3028 | 595 self.disp(_("Can't parse HTML page : {msg}").format(msg=e)) |
| 2532 | 596 links = [] |
| 597 else: | |
| 598 links = root.xpath("//link[@rel='alternate' and starts-with(@href, 'xmpp:')]") | |
| 599 if not links: | |
| 3040 | 600 self.disp( |
| 601 _('Could not find alternate "xmpp:" URI, can\'t find associated XMPP ' | |
| 602 'PubSub node/item'), | |
| 603 error=True) | |
| 2672 | 604 self.quit(1) |
| 2532 | 605 xmpp_uri = links[0].get('href') |
| 606 return xmpp_uri | |
| 607 | |
| 608 def parse_pubsub_args(self): | |
| 609 if self.args.pubsub_url is not None: | |
| 610 url = self.args.pubsub_url | |
| 611 | |
| 612 if url.startswith('http'): | |
| 613 # http(s) URL, we try to retrieve xmpp one from there | |
| 614 url = self.get_xmpp_uri_from_http(url) | |
| 615 | |
| 616 try: | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
617 uri_data = uri.parse_xmpp_uri(url) |
| 2532 | 618 except ValueError: |
| 3028 | 619 self.parser.error(_('invalid XMPP URL: {url}').format(url=url)) |
| 2532 | 620 else: |
| 3028 | 621 if uri_data['type'] == 'pubsub': |
| 2532 | 622 # URL is alright, we only set data not already set by other options |
| 623 if not self.args.service: | |
| 3028 | 624 self.args.service = uri_data['path'] |
| 2532 | 625 if not self.args.node: |
| 3028 | 626 self.args.node = uri_data['node'] |
| 627 uri_item = uri_data.get('item') | |
| 2532 | 628 if uri_item: |
|
2556
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
629 # there is an item in URI |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
630 # we use it only if item is not already set |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
631 # and item_last is not used either |
| 2532 | 632 try: |
|
2556
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
633 item = self.args.item |
| 2532 | 634 except AttributeError: |
|
2609
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
635 try: |
|
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
636 items = self.args.items |
|
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
637 except AttributeError: |
| 3040 | 638 self.disp( |
| 639 _("item specified in URL but not needed in command, " | |
| 640 "ignoring it"), | |
| 641 error=True) | |
|
2609
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
642 else: |
|
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
643 if not items: |
|
75d2ac872965
jp (base): do not crash when item is specified (e.g. in URL) but not needed in command, but display a message on stderr.
Goffi <goffi@goffi.org>
parents:
2588
diff
changeset
|
644 self.args.items = [uri_item] |
| 2532 | 645 else: |
|
2556
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
646 if not item: |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
647 try: |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
648 item_last = self.args.item_last |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
649 except AttributeError: |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
650 item_last = False |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
651 if not item_last: |
|
340128e0b354
jp (base): fixed URI's item with use_pubsub
Goffi <goffi@goffi.org>
parents:
2552
diff
changeset
|
652 self.args.item = uri_item |
| 2532 | 653 else: |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
654 self.parser.error( |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
655 _('XMPP URL is not a pubsub one: {url}').format(url=url) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
656 ) |
| 2532 | 657 flags = self.args._cmd._pubsub_flags |
| 658 # we check required arguments here instead of using add_arguments' required option | |
| 659 # because the required argument can be set in URL | |
| 660 if C.SERVICE in flags and not self.args.service: | |
| 3028 | 661 self.parser.error(_("argument -s/--service is required")) |
| 2532 | 662 if C.NODE in flags and not self.args.node: |
| 3028 | 663 self.parser.error(_("argument -n/--node is required")) |
|
2552
38e1e29c48e9
jp (base): added C.ITEM pubsub flag when --item is required
Goffi <goffi@goffi.org>
parents:
2550
diff
changeset
|
664 if C.ITEM in flags and not self.args.item: |
| 3028 | 665 self.parser.error(_("argument -i/--item is required")) |
| 2532 | 666 |
| 667 # FIXME: mutually groups can't be nested in a group and don't support title | |
| 668 # so we check conflict here. This may be fixed in Python 3, to be checked | |
| 669 try: | |
| 670 if self.args.item and self.args.item_last: | |
| 3040 | 671 self.parser.error( |
| 672 _("--item and --item-last can't be used at the same time")) | |
| 2532 | 673 except AttributeError: |
| 674 pass | |
| 675 | |
|
2775
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
676 try: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
677 max_items = self.args.max |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
678 rsm_max = self.args.rsm_max |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
679 except AttributeError: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
680 pass |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
681 else: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
682 # we need to set a default value for max, but we need to know if we want |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
683 # to use pubsub's max or RSM's max. The later is used if any RSM or MAM |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
684 # argument is set |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
685 if max_items is None and rsm_max is None: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
686 to_check = ('mam_filters', 'rsm_max', 'rsm_after', 'rsm_before', |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
687 'rsm_index') |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
688 if any((getattr(self.args, name) for name in to_check)): |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
689 # we use RSM |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
690 self.args.rsm_max = 10 |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
691 else: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
692 # we use pubsub without RSM |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
693 self.args.max = 10 |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
694 if self.args.max is None: |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
695 self.args.max = C.NO_LIMIT |
|
2dfd5b1d39df
jp (base): fixed default values for --max-items and --max when using pubsub
Goffi <goffi@goffi.org>
parents:
2771
diff
changeset
|
696 |
| 3040 | 697 async def main(self, args, namespace): |
|
1884
0fe69871b71f
jp: moved KeyboardInterrupt catch one level higher, so it is also catched if the loop is not started
Goffi <goffi@goffi.org>
parents:
1872
diff
changeset
|
698 try: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
699 await self.bridge.bridge_connect() |
| 3040 | 700 except Exception as e: |
| 701 if isinstance(e, exceptions.BridgeExceptionNoService): | |
|
3834
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
702 print( |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
703 _("Can't connect to Libervia backend, are you sure that it's " |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
704 "launched ?") |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
705 ) |
|
3490
509f7a1c67dc
frontends: use new EXIT_BACKEND_NOT_FOUND exit code:
Goffi <goffi@goffi.org>
parents:
3486
diff
changeset
|
706 self.quit(C.EXIT_BACKEND_NOT_FOUND, raise_exc=False) |
| 3040 | 707 elif isinstance(e, exceptions.BridgeInitError): |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
708 print(_("Can't init bridge")) |
|
3490
509f7a1c67dc
frontends: use new EXIT_BACKEND_NOT_FOUND exit code:
Goffi <goffi@goffi.org>
parents:
3486
diff
changeset
|
709 self.quit(C.EXIT_BRIDGE_ERROR, raise_exc=False) |
| 3040 | 710 else: |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
711 print( |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
712 _("Error while initialising bridge: {e}").format(e=e) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
713 ) |
|
3490
509f7a1c67dc
frontends: use new EXIT_BACKEND_NOT_FOUND exit code:
Goffi <goffi@goffi.org>
parents:
3486
diff
changeset
|
714 self.quit(C.EXIT_BRIDGE_ERROR, raise_exc=False) |
| 3040 | 715 return |
|
4193
730f542e4ad0
core: add new `init_script_path` option:
Goffi <goffi@goffi.org>
parents:
4142
diff
changeset
|
716 # we wait on init_pre_script instead of ready_get, so the CLI frontend can be used |
|
730f542e4ad0
core: add new `init_script_path` option:
Goffi <goffi@goffi.org>
parents:
4142
diff
changeset
|
717 # in init script. |
|
730f542e4ad0
core: add new `init_script_path` option:
Goffi <goffi@goffi.org>
parents:
4142
diff
changeset
|
718 await self.bridge.init_pre_script() |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
719 self.version = await self.bridge.version_get() |
|
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
720 self._bridge_connected() |
| 3040 | 721 self.import_plugins() |
| 722 try: | |
| 723 self.args = self.parser.parse_args(args, namespace=None) | |
| 724 if self.args._cmd._use_pubsub: | |
| 725 self.parse_pubsub_args() | |
| 726 await self.args._cmd.run() | |
| 727 except SystemExit as e: | |
| 728 self.quit(e.code, raise_exc=False) | |
| 729 return | |
| 730 except QuitException: | |
| 731 return | |
| 817 | 732 |
|
3481
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
733 def _run(self, args=None, namespace=None): |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
734 self.loop = LiberviaCLILoop() |
|
4133
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
735 try: |
|
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
736 self.loop.run(self, args, namespace) |
|
4224
8499b3ad5edb
cli (base): fix exit code transmission when `SystemExit` is catched.
Goffi <goffi@goffi.org>
parents:
4193
diff
changeset
|
737 except SystemExit as e: |
|
4142
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
738 # The loop is stopped, but we execute it one more time to call `a_quit` which |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
739 # will call any cleaning method including async ones. |
|
4224
8499b3ad5edb
cli (base): fix exit code transmission when `SystemExit` is catched.
Goffi <goffi@goffi.org>
parents:
4193
diff
changeset
|
740 asyncio.get_event_loop().run_until_complete(self.a_quit(e.code)) |
| 0 | 741 |
|
3481
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
742 @classmethod |
|
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
743 def run(cls): |
|
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
744 cls()._run() |
|
7892585b7e17
core (setup), jp, primitivus: update console scripts + classifiers:
Goffi <goffi@goffi.org>
parents:
3479
diff
changeset
|
745 |
| 4129 | 746 |
| 3040 | 747 def _read_stdin(self, stdin_fut): |
| 748 """Callback called by ainput to read stdin""" | |
| 749 line = sys.stdin.readline() | |
| 750 if line: | |
| 751 stdin_fut.set_result(line.rstrip(os.linesep)) | |
| 752 else: | |
| 753 stdin_fut.set_exception(EOFError()) | |
|
587
952322b1d490
Remove trailing whitespaces.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
572
diff
changeset
|
754 |
| 3040 | 755 async def ainput(self, msg=''): |
| 756 """Asynchronous version of buildin "input" function""" | |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
757 self.disp(msg, end=' ') |
| 3040 | 758 sys.stdout.flush() |
| 759 loop = asyncio.get_running_loop() | |
| 760 stdin_fut = loop.create_future() | |
| 761 loop.add_reader(sys.stdin, self._read_stdin, stdin_fut) | |
| 762 return await stdin_fut | |
| 763 | |
| 3409 | 764 async def confirm(self, message): |
| 765 """Request user to confirm action, return answer as boolean""" | |
| 766 res = await self.ainput(f"{message} (y/N)? ") | |
| 767 return res in ("y", "Y") | |
| 768 | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
769 async def confirm_or_quit(self, message, cancel_message=_("action cancelled by user")): |
|
2550
1d754bc14381
jp (base): new confirmOrQuit helper method to ask confirmation to user, and quit if he cancel
Goffi <goffi@goffi.org>
parents:
2547
diff
changeset
|
770 """Request user to confirm action, and quit if he doesn't""" |
| 3409 | 771 confirmed = await self.confirm(message) |
| 772 if not confirmed: | |
|
2550
1d754bc14381
jp (base): new confirmOrQuit helper method to ask confirmation to user, and quit if he cancel
Goffi <goffi@goffi.org>
parents:
2547
diff
changeset
|
773 self.disp(cancel_message) |
|
1d754bc14381
jp (base): new confirmOrQuit helper method to ask confirmation to user, and quit if he cancel
Goffi <goffi@goffi.org>
parents:
2547
diff
changeset
|
774 self.quit(C.EXIT_USER_CANCELLED) |
|
1d754bc14381
jp (base): new confirmOrQuit helper method to ask confirmation to user, and quit if he cancel
Goffi <goffi@goffi.org>
parents:
2547
diff
changeset
|
775 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
776 def quit_from_signal(self, exit_code=0): |
| 3040 | 777 r"""Same as self.quit, but from a signal handler |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
778 |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
779 /!\: return must be used after calling this method ! |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
780 """ |
|
1918
01d56efd488b
jp: fixed traceback shown on a normal quit when a progression is finished
Goffi <goffi@goffi.org>
parents:
1884
diff
changeset
|
781 # XXX: python-dbus will show a traceback if we exit in a signal handler |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
782 # so we use this little timeout trick to avoid it |
| 3040 | 783 self.loop.call_later(0, self.quit, exit_code) |
| 784 | |
| 785 def quit(self, exit_code=0, raise_exc=True): | |
| 786 """Terminate the execution with specified exit_code | |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
787 |
| 3040 | 788 This will stop the loop. |
| 789 @param exit_code(int): code to return when quitting the program | |
| 790 @param raise_exp(boolean): if True raise a QuitException to stop code execution | |
| 791 The default value should be used most of time. | |
| 792 """ | |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
793 # first the onQuitCallbacks |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
794 try: |
|
4133
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
795 callbacks_list = self._on_quit_callbacks |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
796 except AttributeError: |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
797 pass |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
798 else: |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
799 for callback, args, kwargs in callbacks_list: |
|
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
800 callback(*args, **kwargs) |
|
4133
33fd658d9d00
cli (base): catch `SystemExit` to do a proper `quit` when `Ctrl-C` is pressed.
Goffi <goffi@goffi.org>
parents:
4129
diff
changeset
|
801 callbacks_list.clear() |
|
1604
9ac78437000d
jp (base): added quitFromSignal method to quit from signal handler with errcode without traceback, and addOnQuitCallback to manage cleaning callbacks
Goffi <goffi@goffi.org>
parents:
1600
diff
changeset
|
802 |
| 3040 | 803 self.loop.quit(exit_code) |
| 804 if raise_exc: | |
| 805 raise QuitException | |
|
587
952322b1d490
Remove trailing whitespaces.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
572
diff
changeset
|
806 |
|
4224
8499b3ad5edb
cli (base): fix exit code transmission when `SystemExit` is catched.
Goffi <goffi@goffi.org>
parents:
4193
diff
changeset
|
807 async def a_quit(self, exit_code: int=0, raise_exc=True): |
|
4142
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
808 """Execute async quit callback before actually quitting |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
809 |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
810 This method should be prefered to ``quit``, as it executes async quit callbacks |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
811 which may be necessary for proper cleaning of session. |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
812 """ |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
813 try: |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
814 callbacks_list = self._on_quit_callbacks |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
815 except AttributeError: |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
816 pass |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
817 else: |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
818 for callback, args, kwargs in callbacks_list: |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
819 await aio.maybe_async(callback(*args, **kwargs)) |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
820 callbacks_list.clear() |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
821 self.quit(exit_code, raise_exc) |
|
783bbdbf8567
cli (base): new `a_quit` method to run async cleaning methods:
Goffi <goffi@goffi.org>
parents:
4133
diff
changeset
|
822 |
| 3040 | 823 async def check_jids(self, jids): |
| 814 | 824 """Check jids validity, transform roster name to corresponding jids |
|
110
cb904fa7de3c
jp: profile management (new option: --profile)
Goffi <goffi@goffi.org>
parents:
70
diff
changeset
|
825 |
| 817 | 826 @param profile: profile name |
| 827 @param jids: list of jids | |
| 828 @return: List of jids | |
| 829 | |
| 814 | 830 """ |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
831 names2jid = {} |
|
493
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
832 nodes2jid = {} |
| 393 | 833 |
|
3765
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
834 try: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
835 contacts = await self.bridge.contacts_get(self.profile) |
|
3765
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
836 except BridgeException as e: |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
837 if e.classname == "AttributeError": |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
838 # we may get an AttributeError if we use a component profile |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
839 # as components don't have roster |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
840 contacts = [] |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
841 else: |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
842 raise e |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
843 |
|
ea204216a505
CLI: don't fail when calling `getContacts` with a component profile
Goffi <goffi@goffi.org>
parents:
3709
diff
changeset
|
844 for contact in contacts: |
|
1395
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
845 jid_s, attr, groups = contact |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
846 _jid = JID(jid_s) |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
847 try: |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
848 names2jid[attr["name"].lower()] = jid_s |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
849 except KeyError: |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
850 pass |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
851 |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
852 if _jid.node: |
|
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
853 nodes2jid[_jid.node.lower()] = jid_s |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
854 |
| 817 | 855 def expand_jid(jid): |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
856 _jid = jid.lower() |
|
493
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
857 if _jid in names2jid: |
|
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
858 expanded = names2jid[_jid] |
|
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
859 elif _jid in nodes2jid: |
|
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
860 expanded = nodes2jid[_jid] |
|
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
861 else: |
|
b7c4bb2c0668
jp: - better expandJid: roster's jids' nodes are used after names to expand jid
Goffi <goffi@goffi.org>
parents:
480
diff
changeset
|
862 expanded = jid |
| 2588 | 863 return expanded |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
864 |
|
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
865 def check(jid): |
|
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
866 if not jid.is_valid: |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
867 log.error (_("%s is not a valid JID !"), jid) |
| 817 | 868 self.quit(1) |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
869 |
| 814 | 870 dest_jids=[] |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
871 try: |
| 814 | 872 for i in range(len(jids)): |
| 817 | 873 dest_jids.append(expand_jid(jids[i])) |
| 814 | 874 check(dest_jids[i]) |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
875 except AttributeError: |
|
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
876 pass |
| 0 | 877 |
| 814 | 878 return dest_jids |
| 0 | 879 |
|
3049
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
880 async def a_pwd_input(self, msg=''): |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
881 """Like ainput but with echo disabled (useful for passwords)""" |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
882 # we disable echo, code adapted from getpass standard module which has been |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
883 # written by Piers Lauder (original), Guido van Rossum (Windows support and |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
884 # cleanup) and Gregory P. Smith (tty support & GetPassWarning), a big thanks |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
885 # to them (and for all the amazing work on Python). |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
886 stdin_fd = sys.stdin.fileno() |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
887 old = termios.tcgetattr(sys.stdin) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
888 new = old[:] |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
889 new[3] &= ~termios.ECHO |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
890 tcsetattr_flags = termios.TCSAFLUSH |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
891 if hasattr(termios, 'TCSASOFT'): |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
892 tcsetattr_flags |= termios.TCSASOFT |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
893 try: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
894 termios.tcsetattr(stdin_fd, tcsetattr_flags, new) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
895 pwd = await self.ainput(msg=msg) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
896 finally: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
897 termios.tcsetattr(stdin_fd, tcsetattr_flags, old) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
898 sys.stderr.flush() |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
899 self.disp('') |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
900 return pwd |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
901 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
902 async def connect_or_prompt(self, method, err_msg=None): |
|
3049
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
903 """Try to connect/start profile session and prompt for password if needed |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
904 |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
905 @param method(callable): bridge method to either connect or start profile session |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
906 It will be called with password as sole argument, use lambda to do the call |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
907 properly |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
908 @param err_msg(str): message to show if connection fail |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
909 """ |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
910 password = self.args.pwd |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
911 while True: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
912 try: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
913 await method(password or '') |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
914 except Exception as e: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
915 if ((isinstance(e, BridgeException) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
916 and e.classname == 'PasswordError' |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
917 and self.args.pwd is None)): |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
918 if password is not None: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
919 self.disp(A.color(C.A_WARNING, _("invalid password"))) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
920 password = await self.a_pwd_input( |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
921 _("please enter profile password:")) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
922 else: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
923 self.disp(err_msg.format(profile=self.profile, e=e), error=True) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
924 self.quit(C.EXIT_ERROR) |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
925 else: |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
926 break |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
927 |
| 3040 | 928 async def connect_profile(self): |
| 929 """Check if the profile is connected and do it if requested | |
|
1401
265ff2bd8d67
jp: fixed crash on commands using profile without "connect" option
Goffi <goffi@goffi.org>
parents:
1396
diff
changeset
|
930 |
| 817 | 931 @exit: - 1 when profile is not connected and --connect is not set |
| 932 - 1 when the profile doesn't exists | |
| 933 - 1 when there is a connection error | |
| 934 """ | |
| 935 # FIXME: need better exit codes | |
| 936 | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
937 self.profile = await self.bridge.profile_name_get(self.args.profile) |
| 0 | 938 |
| 817 | 939 if not self.profile: |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
940 log.error( |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
941 _("The profile [{profile}] doesn't exist") |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
942 .format(profile=self.args.profile) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
943 ) |
| 3040 | 944 self.quit(C.EXIT_ERROR) |
| 817 | 945 |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
946 try: |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
947 start_session = self.args.start_session |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
948 except AttributeError: |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
949 pass |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
950 else: |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
951 if start_session: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
952 await self.connect_or_prompt( |
|
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
953 lambda pwd: self.bridge.profile_start_session(pwd, self.profile), |
|
3049
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
954 err_msg="Can't start {profile}'s session: {e}" |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
955 ) |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
956 return |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
957 elif not await self.bridge.profile_is_session_started(self.profile): |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
958 if not self.args.connect: |
| 3040 | 959 self.disp(_( |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
960 "Session for [{profile}] is not started, please start it " |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
961 "before using libervia-cli, or use either --start-session or " |
|
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
962 "--connect option" |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
963 .format(profile=self.profile) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
964 ), error=True) |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
965 self.quit(1) |
|
2692
7d4679ee7ded
jp (base): fixed connection when start_session arg exists but is False
Goffi <goffi@goffi.org>
parents:
2672
diff
changeset
|
966 elif not getattr(self.args, "connect", False): |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
967 return |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
968 |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
969 |
|
1401
265ff2bd8d67
jp: fixed crash on commands using profile without "connect" option
Goffi <goffi@goffi.org>
parents:
1396
diff
changeset
|
970 if not hasattr(self.args, 'connect'): |
| 3040 | 971 # a profile can be present without connect option (e.g. on profile |
| 972 # creation/deletion) | |
|
1401
265ff2bd8d67
jp: fixed crash on commands using profile without "connect" option
Goffi <goffi@goffi.org>
parents:
1396
diff
changeset
|
973 return |
|
1588
823a385235ef
jp: fixed bad --connect option check
Goffi <goffi@goffi.org>
parents:
1544
diff
changeset
|
974 elif self.args.connect is True: # if connection is asked, we connect the profile |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
975 await self.connect_or_prompt( |
|
3049
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
976 lambda pwd: self.bridge.connect(self.profile, pwd, {}), |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
977 err_msg = 'Can\'t connect profile "{profile!s}": {e}' |
|
9839ce068140
jp: password is now prompted if needed:
Goffi <goffi@goffi.org>
parents:
3046
diff
changeset
|
978 ) |
| 814 | 979 return |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
980 else: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
981 if not await self.bridge.is_connected(self.profile): |
| 3040 | 982 log.error( |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
983 _("Profile [{profile}] is not connected, please connect it " |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
984 "before using libervia-cli, or use --connect option") |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
985 .format(profile=self.profile) |
|
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
986 ) |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
987 self.quit(1) |
| 0 | 988 |
| 3040 | 989 async def get_full_jid(self, param_jid): |
|
1290
faa1129559b8
core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit):
Goffi <goffi@goffi.org>
parents:
1139
diff
changeset
|
990 """Return the full jid if possible (add main resource when find a bare jid)""" |
|
3408
19bc03743aeb
jp (file/send): don't add main resource to bare jid anymore:
Goffi <goffi@goffi.org>
parents:
3407
diff
changeset
|
991 # TODO: to be removed, bare jid should work with all commands, notably for file |
|
19bc03743aeb
jp (file/send): don't add main resource to bare jid anymore:
Goffi <goffi@goffi.org>
parents:
3407
diff
changeset
|
992 # as backend now handle jingles message initiation |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
993 _jid = JID(param_jid) |
|
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
994 if not _jid.resource: |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
995 #if the resource is not given, we try to add the main resource |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
996 main_resource = await self.bridge.main_resource_get(param_jid, self.profile) |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
997 if main_resource: |
| 3040 | 998 return f"{_jid.bare}/{main_resource}" |
|
401
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
999 return param_jid |
|
b2caa2615c4c
jp roster name manegement + Pipe transfer
Goffi <goffi@goffi.org>
parents:
393
diff
changeset
|
1000 |
|
3834
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1001 async def get_profile_jid(self): |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1002 """Retrieve current profile bare JID if possible""" |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1003 full_jid = await self.bridge.param_get_a_async( |
|
3834
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1004 "JabberID", "Connection", profile_key=self.profile |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1005 ) |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1006 return full_jid.rsplit("/", 1)[0] |
|
3260401fdb98
cli: helper method to retrieve profile's jid:
Goffi <goffi@goffi.org>
parents:
3765
diff
changeset
|
1007 |
| 814 | 1008 |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1009 class CommandBase: |
| 814 | 1010 |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1011 def __init__( |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1012 self, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1013 host: LiberviaCli, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1014 name: str, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1015 use_profile: bool = True, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1016 use_output: Union[bool, str] = False, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1017 extra_outputs: Optional[dict] = None, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1018 need_connect: Optional[bool] = None, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1019 help: Optional[str] = None, |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1020 **kwargs |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1021 ): |
|
2098
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
1022 """Initialise CommandBase |
|
e0066920a661
primitivus, jp: dynamic bridge + fixed D-Bus bridge:
Goffi <goffi@goffi.org>
parents:
2086
diff
changeset
|
1023 |
|
4075
47401850dec6
refactoring: rename `libervia.frontends.jp` to `libervia.cli`
Goffi <goffi@goffi.org>
parents:
4074
diff
changeset
|
1024 @param host: LiberviaCli instance |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1025 @param name: name of the new command |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1026 @param use_profile: if True, add profile selection/connection commands |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1027 @param use_output: if not False, add --output option |
|
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1028 @param extra_outputs: list of command specific outputs: |
| 2155 | 1029 key is output name ("default" to use as main output) |
| 3040 | 1030 value is a callable which will format the output (data will be used as only |
| 1031 argument) | |
| 2155 | 1032 if a key already exists with normal outputs, the extra one will be used |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1033 @param need_connect: True if profile connection is needed |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1034 False else (profile session must still be started) |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1035 None to set auto value (i.e. True if use_profile is set) |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1036 Can't be set if use_profile is False |
|
3938
6939594ba77e
cli (pubsub/get): add `--no-decrypt` flag to disable automatic decryption:
Goffi <goffi@goffi.org>
parents:
3893
diff
changeset
|
1037 @param help: help message to display |
| 817 | 1038 @param **kwargs: args passed to ArgumentParser |
| 1950 | 1039 use_* are handled directly, they can be: |
| 1040 - use_progress(bool): if True, add progress bar activation option | |
| 1041 progress* signals will be handled | |
| 1042 - use_verbose(bool): if True, add verbosity option | |
| 2532 | 1043 - use_pubsub(bool): if True, add pubsub options |
| 1044 mandatory arguments are controlled by pubsub_req | |
| 1045 - use_draft(bool): if True, add draft handling options | |
| 1046 ** other arguments ** | |
| 3040 | 1047 - pubsub_flags(iterable[unicode]): tuple of flags to set pubsub options, |
| 1048 can be: | |
| 2532 | 1049 C.SERVICE: service is required |
| 1050 C.NODE: node is required | |
|
2614
a5b96950b81a
jp (event): fixed crash on missing item in get and inviteeGet by making it mandatory.
Goffi <goffi@goffi.org>
parents:
2609
diff
changeset
|
1051 C.ITEM: item is required |
| 2532 | 1052 C.SINGLE_ITEM: only one item is allowed |
| 814 | 1053 """ |
| 817 | 1054 try: # If we have subcommands, host is a CommandBase and we need to use host.host |
| 1055 self.host = host.host | |
| 1056 except AttributeError: | |
| 1057 self.host = host | |
| 1058 | |
| 1950 | 1059 # --profile option |
| 817 | 1060 parents = kwargs.setdefault('parents', set()) |
| 1061 if use_profile: | |
| 3040 | 1062 # self.host.parents['profile'] is an ArgumentParser with profile connection |
| 1063 # arguments | |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1064 if need_connect is None: |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1065 need_connect = True |
| 3040 | 1066 parents.add( |
| 1067 self.host.parents['profile' if need_connect else 'profile_session']) | |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1068 else: |
|
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1069 assert need_connect is None |
|
1860
afc7f6328394
jp (base): use need_connect attribue to detect if connection is needed instead of self.args.profile, as profile argument can be used by any command even if use_profile is False
Goffi <goffi@goffi.org>
parents:
1840
diff
changeset
|
1070 self.need_connect = need_connect |
|
afc7f6328394
jp (base): use need_connect attribue to detect if connection is needed instead of self.args.profile, as profile argument can be used by any command even if use_profile is False
Goffi <goffi@goffi.org>
parents:
1840
diff
changeset
|
1071 # from this point, self.need_connect is None if connection is not needed at all |
|
afc7f6328394
jp (base): use need_connect attribue to detect if connection is needed instead of self.args.profile, as profile argument can be used by any command even if use_profile is False
Goffi <goffi@goffi.org>
parents:
1840
diff
changeset
|
1072 # False if session starting is needed, and True if full connection is needed |
|
1594
313f2bb7841b
jp: profile session can now be started without connection:
Goffi <goffi@goffi.org>
parents:
1588
diff
changeset
|
1073 |
| 1950 | 1074 # --output option |
| 1075 if use_output: | |
| 2155 | 1076 if extra_outputs is None: |
| 1077 extra_outputs = {} | |
| 1078 self.extra_outputs = extra_outputs | |
| 1950 | 1079 if use_output == True: |
| 1080 use_output = C.OUTPUT_TEXT | |
| 1081 assert use_output in C.OUTPUT_TYPES | |
| 1082 self._output_type = use_output | |
| 1083 output_parent = argparse.ArgumentParser(add_help=False) | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1084 choices = set(self.host.get_output_choices(use_output)) |
| 2155 | 1085 choices.update(extra_outputs) |
| 1950 | 1086 if not choices: |
| 3040 | 1087 raise exceptions.InternalError( |
| 1088 "No choice found for {} output type".format(use_output)) | |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
1089 try: |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
1090 default = self.host.default_output[use_output] |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
1091 except KeyError: |
| 3028 | 1092 if 'default' in choices: |
| 1093 default = 'default' | |
| 1094 elif 'simple' in choices: | |
| 1095 default = 'simple' | |
|
2189
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
1096 else: |
|
a25a256688e2
jp (base): output can now specify a default when registering
Goffi <goffi@goffi.org>
parents:
2188
diff
changeset
|
1097 default = list(choices)[0] |
| 3040 | 1098 output_parent.add_argument( |
| 1099 '--output', '-O', choices=sorted(choices), default=default, | |
| 1100 help=_("select output format (default: {})".format(default))) | |
| 1101 output_parent.add_argument( | |
| 1102 '--output-option', '--oo', action="append", dest='output_opts', | |
| 1103 default=[], help=_("output specific option")) | |
| 1950 | 1104 parents.add(output_parent) |
| 2155 | 1105 else: |
| 1106 assert extra_outputs is None | |
| 817 | 1107 |
| 2532 | 1108 self._use_pubsub = kwargs.pop('use_pubsub', False) |
| 1109 if self._use_pubsub: | |
|
2538
0a22dc80d671
jp (base): fixed use_pubsub when pubsub_flags is not needed
Goffi <goffi@goffi.org>
parents:
2532
diff
changeset
|
1110 flags = kwargs.pop('pubsub_flags', []) |
|
2547
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
1111 defaults = kwargs.pop('pubsub_defaults', {}) |
|
2d69a0afe039
jp: new argument pubsub_default can be used in Commands to replace default value in help string
Goffi <goffi@goffi.org>
parents:
2539
diff
changeset
|
1112 parents.add(self.host.make_pubsub_group(flags, defaults)) |
| 2532 | 1113 self._pubsub_flags = flags |
|
2235
4db836386641
jp: added use_pubsub and use_pubsub_node_req arguments to CommandBase
Goffi <goffi@goffi.org>
parents:
2213
diff
changeset
|
1114 |
| 1950 | 1115 # other common options |
| 3028 | 1116 use_opts = {k:v for k,v in kwargs.items() if k.startswith('use_')} |
| 1117 for param, do_use in use_opts.items(): | |
| 1950 | 1118 opt=param[4:] # if param is use_verbose, opt is verbose |
| 1119 if opt not in self.host.parents: | |
| 3028 | 1120 raise exceptions.InternalError("Unknown parent option {}".format(opt)) |
| 1950 | 1121 del kwargs[param] |
| 1122 if do_use: | |
| 1123 parents.add(self.host.parents[opt]) | |
| 1600 | 1124 |
| 817 | 1125 self.parser = host.subparsers.add_parser(name, help=help, **kwargs) |
| 1126 if hasattr(self, "subcommands"): | |
| 3040 | 1127 self.subparsers = self.parser.add_subparsers(dest='subcommand', required=True) |
| 817 | 1128 else: |
| 2532 | 1129 self.parser.set_defaults(_cmd=self) |
| 817 | 1130 self.add_parser_options() |
| 1131 | |
| 1132 @property | |
| 3046 | 1133 def sat_conf(self): |
| 1134 return self.host.sat_conf | |
| 1135 | |
| 1136 @property | |
| 817 | 1137 def args(self): |
| 1138 return self.host.args | |
| 1139 | |
| 1140 @property | |
| 1141 def profile(self): | |
| 1142 return self.host.profile | |
| 1143 | |
| 1144 @property | |
|
2490
b4bf282d6354
jp (base): added verbosity property to CommandBase
Goffi <goffi@goffi.org>
parents:
2486
diff
changeset
|
1145 def verbosity(self): |
|
b4bf282d6354
jp (base): added verbosity property to CommandBase
Goffi <goffi@goffi.org>
parents:
2486
diff
changeset
|
1146 return self.host.verbosity |
|
b4bf282d6354
jp (base): added verbosity property to CommandBase
Goffi <goffi@goffi.org>
parents:
2486
diff
changeset
|
1147 |
|
b4bf282d6354
jp (base): added verbosity property to CommandBase
Goffi <goffi@goffi.org>
parents:
2486
diff
changeset
|
1148 @property |
| 817 | 1149 def progress_id(self): |
| 1150 return self.host.progress_id | |
| 814 | 1151 |
| 4129 | 1152 @property |
| 1153 def console(self): | |
| 1154 return self.host.console | |
| 1155 | |
| 1156 def print(self, *args, **kwargs): | |
| 1157 self.host.console.print(*args, **kwargs) | |
| 1158 | |
| 3040 | 1159 async def set_progress_id(self, progress_id): |
| 1160 return await self.host.set_progress_id(progress_id) | |
| 817 | 1161 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1162 async def progress_started_handler(self, uid, metadata, profile): |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1163 if profile != self.profile: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1164 return |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1165 if self.progress_id is None: |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1166 # the progress started message can be received before the id |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1167 # so we keep progress_started signals in cache to replay they |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1168 # when the progress_id is received |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1169 cache_data = (self.progress_started_handler, uid, metadata, profile) |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1170 try: |
| 3040 | 1171 cache = self.host.progress_ids_cache |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1172 except AttributeError: |
| 3040 | 1173 cache = self.host.progress_ids_cache = [] |
| 1174 cache.append(cache_data) | |
|
1642
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1175 else: |
|
7ec7ce9cdc4c
jp (base): progressStarted signals are cached until progress_id is known, this avoid missing the progression if we have the signal before the id.
Goffi <goffi@goffi.org>
parents:
1641
diff
changeset
|
1176 if self.host.watch_progress and uid == self.progress_id: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1177 await self.on_progress_started(metadata) |
| 3040 | 1178 while True: |
| 1179 await asyncio.sleep(PROGRESS_DELAY) | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1180 cont = await self.progress_update() |
| 3040 | 1181 if not cont: |
| 1182 break | |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1183 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1184 async def progress_finished_handler(self, uid, metadata, profile): |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1185 if profile != self.profile: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1186 return |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1187 if uid == self.progress_id: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1188 try: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1189 self.host.pbar.finish() |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1190 except AttributeError: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1191 pass |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1192 await self.on_progress_finished(metadata) |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1193 if self.host.quit_on_progress_end: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1194 self.host.quit_from_signal() |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1195 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1196 async def progress_error_handler(self, uid, message, profile): |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1197 if profile != self.profile: |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1198 return |
|
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1199 if uid == self.progress_id: |
|
1641
44a14f83e64b
jp (base): fixed verbose option + there is a new line on ProgressErrorHandler only if the progress bar is actually displayed
Goffi <goffi@goffi.org>
parents:
1627
diff
changeset
|
1200 if self.args.progress: |
|
44a14f83e64b
jp (base): fixed verbose option + there is a new line on ProgressErrorHandler only if the progress bar is actually displayed
Goffi <goffi@goffi.org>
parents:
1627
diff
changeset
|
1201 self.disp('') # progress is not finished, so we skip a line |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1202 if self.host.quit_on_progress_end: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1203 await self.on_progress_error(message) |
|
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1204 self.host.quit_from_signal(C.EXIT_ERROR) |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1205 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1206 async def progress_update(self): |
| 3040 | 1207 """This method is continualy called to update the progress bar |
| 1208 | |
| 1209 @return (bool): False to stop being called | |
| 1210 """ | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1211 data = await self.host.bridge.progress_get(self.progress_id, self.profile) |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1212 if data: |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1213 try: |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1214 size = data['size'] |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1215 except KeyError: |
| 3040 | 1216 self.disp(_("file size is not known, we can't show a progress bar"), 1, |
| 1217 error=True) | |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1218 return False |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1219 if self.host.pbar is None: |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1220 #first answer, we must construct the bar |
| 3040 | 1221 |
| 1222 # if the instance has a pbar_template attribute, it is used has model, | |
| 1223 # else default one is used | |
| 1224 # template is a list of part, where part can be either a str to show directly | |
| 1225 # or a list where first argument is a name of a progressbar widget, and others | |
| 1226 # are used as widget arguments | |
| 1227 try: | |
| 1228 template = self.pbar_template | |
| 1229 except AttributeError: | |
| 1230 template = [ | |
| 1231 _("Progress: "), ["Percentage"], " ", ["Bar"], " ", | |
| 1232 ["FileTransferSpeed"], " ", ["ETA"] | |
| 1233 ] | |
| 1234 | |
| 1235 widgets = [] | |
| 1236 for part in template: | |
| 1237 if isinstance(part, str): | |
| 1238 widgets.append(part) | |
| 1239 else: | |
| 1240 widget = getattr(progressbar, part.pop(0)) | |
| 1241 widgets.append(widget(*part)) | |
| 1242 | |
| 1243 self.host.pbar = progressbar.ProgressBar(max_value=int(size), widgets=widgets) | |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1244 self.host.pbar.start() |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1245 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1246 self.host.pbar.update(int(data['position'])) |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1247 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1248 elif self.host.pbar is not None: |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1249 return False |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1250 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1251 await self.on_progress_update(data) |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1252 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1253 return True |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1254 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1255 async def on_progress_started(self, metadata): |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1256 """Called when progress has just started |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1257 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1258 can be overidden by a command |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1259 @param metadata(dict): metadata as sent by bridge.progress_started |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1260 """ |
| 3028 | 1261 self.disp(_("Operation started"), 2) |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1262 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1263 async def on_progress_update(self, metadata): |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1264 """Method called on each progress updata |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1265 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1266 can be overidden by a command to handle progress metadata |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1267 @para metadata(dict): metadata as returned by bridge.progress_get |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1268 """ |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1269 pass |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1270 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1271 async def on_progress_finished(self, metadata): |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1272 """Called when progress has just finished |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1273 |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1274 can be overidden by a command |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1275 @param metadata(dict): metadata as sent by bridge.progress_finished |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1276 """ |
| 3028 | 1277 self.disp(_("Operation successfully finished"), 2) |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1278 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1279 async def on_progress_error(self, e): |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1280 """Called when a progress failed |
|
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1281 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1282 @param error_msg(unicode): error message as sent by bridge.progress_error |
|
1832
39545dc527a1
jp: an onProgressUpdate method is now called on each progress update, allowing to handle metadata
Goffi <goffi@goffi.org>
parents:
1766
diff
changeset
|
1283 """ |
|
3568
04283582966f
core, frontends: fix invalid translatable strings.
Goffi <goffi@goffi.org>
parents:
3555
diff
changeset
|
1284 self.disp(_("Error while doing operation: {e}").format(e=e), error=True) |
|
1627
5a641e7b858a
jp (base, file): use of new progress API. Progress callbacks are managed through CommandBase.onProgress* method instead of host attributes.
Goffi <goffi@goffi.org>
parents:
1623
diff
changeset
|
1285 |
|
3407
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
1286 def disp(self, msg, verbosity=0, error=False, end='\n'): |
|
2f0be2b7de68
jp: replace `no_lf` argument by `end` in `disp` (same as in `print`)
Goffi <goffi@goffi.org>
parents:
3378
diff
changeset
|
1287 return self.host.disp(msg, verbosity, error, end) |
|
1605
0aded9648c5c
jp (base): added a self.disp method which manage verbosity and stderr + verbosity property
Goffi <goffi@goffi.org>
parents:
1604
diff
changeset
|
1288 |
| 1950 | 1289 def output(self, data): |
|
2193
33b82250eadd
jp (base): raise InternalError if output is used when use_output is not declared
Goffi <goffi@goffi.org>
parents:
2189
diff
changeset
|
1290 try: |
|
33b82250eadd
jp (base): raise InternalError if output is used when use_output is not declared
Goffi <goffi@goffi.org>
parents:
2189
diff
changeset
|
1291 output_type = self._output_type |
|
33b82250eadd
jp (base): raise InternalError if output is used when use_output is not declared
Goffi <goffi@goffi.org>
parents:
2189
diff
changeset
|
1292 except AttributeError: |
| 3040 | 1293 raise exceptions.InternalError( |
| 1294 _('trying to use output when use_output has not been set')) | |
|
2193
33b82250eadd
jp (base): raise InternalError if output is used when use_output is not declared
Goffi <goffi@goffi.org>
parents:
2189
diff
changeset
|
1295 return self.host.output(output_type, self.args.output, self.extra_outputs, data) |
| 1950 | 1296 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1297 def get_pubsub_extra(self, extra: Optional[dict] = None) -> str: |
|
2761
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1298 """Helper method to compute extra data from pubsub arguments |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1299 |
|
3586
5f65f4e9f8cb
plugin XEP-0060: getItems extra is now serialised dict
Goffi <goffi@goffi.org>
parents:
3568
diff
changeset
|
1300 @param extra: base extra dict, or None to generate a new one |
|
3893
045af0eeda3f
core, CLI (base), tools (common/data_format): typing/core readability
Goffi <goffi@goffi.org>
parents:
3866
diff
changeset
|
1301 @return: serialised dict which can be used directly in the bridge for pubsub |
|
2761
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1302 """ |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1303 if extra is None: |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1304 extra = {} |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1305 else: |
| 3028 | 1306 intersection = {C.KEY_ORDER_BY}.intersection(list(extra.keys())) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1307 if intersection: |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1308 raise exceptions.ConflictError( |
| 3028 | 1309 "given extra dict has conflicting keys with pubsub keys " |
| 1310 "{intersection}".format(intersection=intersection)) | |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1311 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1312 # RSM |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1313 |
| 3028 | 1314 for attribute in ('max', 'after', 'before', 'index'): |
| 1315 key = 'rsm_' + attribute | |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1316 if key in extra: |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1317 raise exceptions.ConflictError( |
| 3028 | 1318 "This key already exists in extra: u{key}".format(key=key)) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1319 value = getattr(self.args, key, None) |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1320 if value is not None: |
| 3028 | 1321 extra[key] = str(value) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1322 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1323 # MAM |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1324 |
| 3028 | 1325 if hasattr(self.args, 'mam_filters'): |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1326 for key, value in self.args.mam_filters: |
| 3028 | 1327 key = 'filter_' + key |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1328 if key in extra: |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1329 raise exceptions.ConflictError( |
| 3028 | 1330 "This key already exists in extra: u{key}".format(key=key)) |
|
2764
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1331 extra[key] = value |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1332 |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1333 # Order-By |
|
92af49cde255
jp (base): MAM and RSM arguments can now be used for pubsub commands:
Goffi <goffi@goffi.org>
parents:
2761
diff
changeset
|
1334 |
|
2761
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1335 try: |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1336 order_by = self.args.order_by |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1337 except AttributeError: |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1338 pass |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1339 else: |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1340 if order_by is not None: |
|
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1341 extra[C.KEY_ORDER_BY] = self.args.order_by |
|
3600
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1342 |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1343 # Cache |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1344 try: |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1345 use_cache = self.args.use_cache |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1346 except AttributeError: |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1347 pass |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1348 else: |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1349 if not use_cache: |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1350 extra[C.KEY_USE_CACHE] = use_cache |
|
1709f0a78f50
jp (base): add flag for `use_pubsub` to add cache skipping option
Goffi <goffi@goffi.org>
parents:
3586
diff
changeset
|
1351 |
|
3586
5f65f4e9f8cb
plugin XEP-0060: getItems extra is now serialised dict
Goffi <goffi@goffi.org>
parents:
3568
diff
changeset
|
1352 return data_format.serialise(extra) |
|
2761
4b693ea24d5f
jp (base, pubsub, ticket): handle order-by:
Goffi <goffi@goffi.org>
parents:
2706
diff
changeset
|
1353 |
| 817 | 1354 def add_parser_options(self): |
| 1355 try: | |
| 1356 subcommands = self.subcommands | |
| 1357 except AttributeError: | |
| 1358 # We don't have subcommands, the class need to implements add_parser_options | |
| 1359 raise NotImplementedError | |
| 1360 | |
| 1361 # now we add subcommands to ourself | |
| 1362 for cls in subcommands: | |
| 1363 cls(self) | |
| 814 | 1364 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1365 def override_pubsub_flags(self, new_flags: Set[str]) -> None: |
|
3866
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1366 """Replace pubsub_flags given in __init__ |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1367 |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1368 useful when a command is extending an other command (e.g. blog command which does |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1369 the same as pubsub command, but with a default node) |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1370 """ |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1371 self._pubsub_flags = new_flags |
|
915fb230cb28
cli (blog, pubsub): new `attachments` subcommands:
Goffi <goffi@goffi.org>
parents:
3834
diff
changeset
|
1372 |
| 3040 | 1373 async def run(self): |
|
1862
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1374 """this method is called when a command is actually run |
|
1395
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
1375 |
|
1862
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1376 It set stuff like progression callbacks and profile connection |
|
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1377 You should not overide this method: you should call self.start instead |
|
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1378 """ |
| 2155 | 1379 # we keep a reference to run command, it may be useful e.g. for outputs |
| 1380 self.host.command = self | |
|
1863
b2ddd7f5dcdf
jp (base): refactored need_loop so it is set only when the command is run. It can now be set in __init__ methods of commands classes
Goffi <goffi@goffi.org>
parents:
1862
diff
changeset
|
1381 |
| 817 | 1382 try: |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1383 show_progress = self.args.progress |
| 817 | 1384 except AttributeError: |
| 1385 # the command doesn't use progress bar | |
| 1386 pass | |
|
1395
1ae9aa94c351
jp: fixed bad try/except hidding errors + fixed bad management of jids without node
Goffi <goffi@goffi.org>
parents:
1290
diff
changeset
|
1387 else: |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1388 if show_progress: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1389 self.host.watch_progress = True |
| 3040 | 1390 # we need to register the following signal even if we don't display the |
| 1391 # progress bar | |
| 1392 self.host.bridge.register_signal( | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1393 "progress_started", self.progress_started_handler) |
| 3040 | 1394 self.host.bridge.register_signal( |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1395 "progress_finished", self.progress_finished_handler) |
| 3040 | 1396 self.host.bridge.register_signal( |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1397 "progress_error", self.progress_error_handler) |
| 817 | 1398 |
|
1862
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1399 if self.need_connect is not None: |
| 3040 | 1400 await self.host.connect_profile() |
| 1401 await self.start() | |
|
1862
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1402 |
| 3040 | 1403 async def start(self): |
| 1404 """This is the starting point of the command, this method must be overriden | |
|
1862
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1405 |
|
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1406 at this point, profile are connected if needed |
|
6d9c87bdc452
jp (base): added a CommandBase.start method which is called by run or connected, so subclasses can implement it (this is for simplicity sake, as it's not always clear if run or connected must be used)
Goffi <goffi@goffi.org>
parents:
1860
diff
changeset
|
1407 """ |
| 3040 | 1408 raise NotImplementedError |
| 817 | 1409 |
| 1410 | |
| 1411 class CommandAnswering(CommandBase): | |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1412 """Specialised commands which answer to specific actions |
| 817 | 1413 |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1414 to manage action_types answer, |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1415 """ |
|
2409
d2ff5ff3de77
jp (ad-hoc): new "list" and "run" commands:
Goffi <goffi@goffi.org>
parents:
2368
diff
changeset
|
1416 action_callbacks = {} # XXX: set managed action types in a dict here: |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1417 # key is the action_type, value is the callable |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1418 # which will manage the answer. profile filtering is |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1419 # already managed when callback is called |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1420 |
|
2486
031aa3cc67ac
jp (base): fixed assertion error when using CommandAnswering
Goffi <goffi@goffi.org>
parents:
2483
diff
changeset
|
1421 def __init__(self, *args, **kwargs): |
|
031aa3cc67ac
jp (base): fixed assertion error when using CommandAnswering
Goffi <goffi@goffi.org>
parents:
2483
diff
changeset
|
1422 super(CommandAnswering, self).__init__(*args, **kwargs) |
|
031aa3cc67ac
jp (base): fixed assertion error when using CommandAnswering
Goffi <goffi@goffi.org>
parents:
2483
diff
changeset
|
1423 |
|
4041
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1424 async def on_action_new( |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1425 self, |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1426 action_data_s: str, |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1427 action_id: str, |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1428 security_limit: int, |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1429 profile: str |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1430 ) -> None: |
|
538
2c4016921403
core, frontends, bridgen plugins: fixed methods which were unproperly managing multi-profiles
Goffi <goffi@goffi.org>
parents:
493
diff
changeset
|
1431 if profile != self.profile: |
|
2c4016921403
core, frontends, bridgen plugins: fixed methods which were unproperly managing multi-profiles
Goffi <goffi@goffi.org>
parents:
493
diff
changeset
|
1432 return |
|
4041
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1433 action_data = data_format.deserialise(action_data_s) |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1434 try: |
|
4042
877145b4ba01
core: don't use `meta_` prefix anymore for `action_extra` in `action_new` signal.
Goffi <goffi@goffi.org>
parents:
4041
diff
changeset
|
1435 action_type = action_data['type'] |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1436 except KeyError: |
|
1840
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1437 try: |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1438 xml_ui = action_data["xmlui"] |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1439 except KeyError: |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1440 pass |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1441 else: |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1442 self.on_xmlui(xml_ui) |
|
1606
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1443 else: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1444 try: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1445 callback = self.action_callbacks[action_type] |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1446 except KeyError: |
|
de785fcf9a7b
jp (base, file): file command and progress fixes and adaptation to new API:
Goffi <goffi@goffi.org>
parents:
1605
diff
changeset
|
1447 pass |
| 0 | 1448 else: |
| 3040 | 1449 await callback(action_data, action_id, security_limit, profile) |
|
587
952322b1d490
Remove trailing whitespaces.
Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
parents:
572
diff
changeset
|
1450 |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1451 def on_xmlui(self, xml_ui): |
|
1840
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1452 """Display a dialog received from the backend. |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1453 |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1454 @param xml_ui (unicode): dialog XML representation |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1455 """ |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1456 # FIXME: we temporarily use ElementTree, but a real XMLUI managing module |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1457 # should be available in the future |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1458 # TODO: XMLUI module |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1459 ui = ET.fromstring(xml_ui.encode('utf-8')) |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1460 dialog = ui.find("dialog") |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1461 if dialog is not None: |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1462 self.disp(dialog.findtext("message"), error=dialog.get("level") == "error") |
|
9eabf7fadfdd
frontends (jp): onActionNew displays xmlui message if no meta_type is defined and xmlui is defined
souliane <souliane@mailoo.org>
parents:
1832
diff
changeset
|
1463 |
| 3040 | 1464 async def start_answering(self): |
| 1465 """Auto reply to confirmation requests""" | |
|
4037
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1466 self.host.bridge.register_signal("action_new", self.on_action_new) |
|
524856bd7b19
massive refactoring to switch from camelCase to snake_case:
Goffi <goffi@goffi.org>
parents:
3938
diff
changeset
|
1467 actions = await self.host.bridge.actions_get(self.profile) |
|
4041
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1468 for action_data_s, action_id, security_limit in actions: |
|
2594e1951cf7
core (bridge): `action_new` now use serialised dict for extra data.
Goffi <goffi@goffi.org>
parents:
4037
diff
changeset
|
1469 await self.on_action_new(action_data_s, action_id, security_limit, self.profile) |