Updated versions

Update TextUI.py

nomadnet/Conversation.py

@@ -102,7 +102,7 @@ class Conversation:
                         unread = True
 
                     if display_name == None and app_data:
-                        display_name = app_data.decode("utf-8")
+                        display_name = LXMF.display_name_from_app_data(app_data)
 
                     if display_name == None:
                         sort_name = ""
@@ -216,6 +216,10 @@ class Conversation:
             if self.app.directory.preferred_delivery(dest.hash) == DirectoryEntry.PROPAGATED:
                 if self.app.message_router.get_outbound_propagation_node() != None:
                     desired_method = LXMF.LXMessage.PROPAGATED
+            else:
+                if not self.app.message_router.delivery_link_available(dest.hash) and RNS.Identity.current_ratchet_id(dest.hash) != None:
+                    RNS.log(f"Have ratchet for {RNS.prettyhexrep(dest.hash)}, requesting opportunistic delivery of message", RNS.LOG_DEBUG)
+                    desired_method = LXMF.LXMessage.OPPORTUNISTIC
 
             dest_is_trusted = False
             if self.app.directory.trust_level(dest.hash) == DirectoryEntry.TRUSTED:

nomadnet/Node.py

@@ -1,4 +1,6 @@
 import os
+import sys
+
 import RNS
 import time
 import threading
@@ -159,7 +161,7 @@ class Node:
         try:
             if request_allowed:
                 RNS.log("Serving page: "+file_path, RNS.LOG_VERBOSE)
-                if os.access(file_path, os.X_OK):
+                if not RNS.vendor.platformutils.is_windows() and os.access(file_path, os.X_OK):
                     env_map = {}
                     if "PATH" in os.environ:
                         env_map["PATH"] = os.environ["PATH"]

nomadnet/NomadNetworkApp.py

@@ -290,9 +290,20 @@ class NomadNetworkApp:
 
         self.directory = nomadnet.Directory(self)
 
+        static_peers = []
+        for static_peer in self.static_peers:
+            try:
+                dh = bytes.fromhex(static_peer)
+                if len(dh) != RNS.Reticulum.TRUNCATED_HASHLENGTH//8:
+                    raise ValueError("Invalid destination length")
+                static_peers.append(dh)
+            except Exception as e:
+                RNS.log(f"Could not decode static peer destination hash {static_peer}: {e}", RNS.LOG_ERROR)
+
         self.message_router = LXMF.LXMRouter(
             identity = self.identity, storagepath = self.storagepath, autopeer = True,
             propagation_limit = self.lxmf_max_propagation_size, delivery_limit = self.lxmf_max_incoming_size,
+            max_peers = self.max_peers, static_peers = static_peers,
         )
 
         self.message_router.register_delivery_callback(self.lxmf_delivery)
@@ -746,7 +757,7 @@ class NomadNetworkApp:
                         self.lxmf_sync_limit = None
 
                 if option == "required_stamp_cost":
-                    value = self.config["node"]["node_name"]
+                    value = self.config["client"][option]
                     if value.lower() == "none":
                         self.required_stamp_cost = None
                     else:
@@ -920,6 +931,19 @@ class NomadNetworkApp:
             else:
                 self.prioritised_lxmf_destinations = []
 
+            if "static_peers" in self.config["node"]:
+                self.static_peers = self.config["node"].as_list("static_peers")
+            else:
+                self.static_peers = []
+                
+            if not "max_peers" in self.config["node"]:
+                self.max_peers = None
+            else:
+                value = self.config["node"].as_int("max_peers")
+                if value < 0:
+                    value = 0
+                self.max_peers = value
+
             if not "message_storage_limit" in self.config["node"]:
                 self.message_storage_limit = 2000
             else:
@@ -1136,13 +1160,15 @@ announce_interval = 360
 # Whether to announce when the node starts.
 announce_at_start = Yes
 
-# By default, when Nomad Network is hosting a
+# When Nomad Network is hosting a page-serving
-# node, it will also act as an LXMF propagation
+# node, it can also act as an LXMF propagation
 # node. If there is already a large amount of
 # propagation nodes on the network, or you
 # simply want to run a pageserving-only node,
 # you can disable running a propagation node.
-# disable_propagation = False
+# Due to lots of propagation nodes being
+# available, this is currently the default.
+disable_propagation = Yes
 
 # The maximum amount of storage to use for
 # the LXMF Propagation Node message store,
@@ -1176,9 +1202,16 @@ max_transfer_size = 256
 # and generally you do not need to use it.
 # prioritise_destinations = 41d20c727598a3fbbdf9106133a3a0ed, d924b81822ca24e68e2effea99bcb8cf
 
-# Automatic rescan interval of the pages directory in minutes.
+# You can configure the maximum number of other
-# Default: int = 0 (no rescan)
+# propagation nodes that this node will peer
-page_refresh_interval = 0
+# with automatically. The default is 50.
+# max_peers = 25
+
+# You can configure a list of static propagation
+# node peers, that this node will always be
+# peered with, by specifying a list of
+# destination hashes.
+# static_peers = e17f833c4ddf8890dd3a79a6fea8161d, 5a2d0029b6e5ec87020abaea0d746da4
 
 # You can specify the interval in minutes for
 # rescanning the hosted pages path. By default,

nomadnet/_version.py

@@ -1 +1 @@
-__version__ = "0.5.2"
+__version__ = "0.6.0"

nomadnet/examples/various/input_fields.py

@@ -17,6 +17,8 @@ The following section contains a simple set of fields, and a few different links
 
 -=
 
+
+>>>Text Fields
 An input field    : `B444`<username`Entered data>`b
 
 An masked field   : `B444`<!|password`Value of Field>`b
@@ -27,7 +29,24 @@ Two fields        : `B444`<8|one`One>`b `B444`<8|two`Two>`b
 
 The data can be `!`[submitted`:/page/input_fields.mu`username|two]`!.
 
-You can `!`[submit`:/page/input_fields.mu`one|password|small]`! other fields, or just `!`[a single one`:/page/input_fields.mu`username]`!
+>> Checkbox Fields
+
+`B444`<?|sign_up|1|*`>`b Sign me up 
+
+>> Radio group
+
+Select your favorite color:
+
+`B900`<^|color|Red`>`b  Red
+
+`B090`<^|color|Green`>`b Green
+
+`B009`<^|color|Blue`>`b Blue
+
+
+>>> Submitting data
+
+You can `!`[submit`:/page/input_fields.mu`one|password|small|color]`! other fields, or just `!`[a single one`:/page/input_fields.mu`username]`!
 
 Or simply `!`[submit them all`:/page/input_fields.mu`*]`!.
 

nomadnet/ui/textui/Browser.py

@@ -1,4 +1,5 @@
 import RNS
+import LXMF
 import os
 import time
 import urwid
@@ -180,7 +181,6 @@ class Browser:
                     link_fields.append(e)
 
                 def recurse_down(w):
-                target = None
                     if isinstance(w, list):
                         for t in w:
                             recurse_down(t)
@@ -195,7 +195,32 @@ class Browser:
                         recurse_down(w._original_widget)
                     else:
                         if hasattr(w, "field_name") and (all_fields or w.field_name in link_fields):
-                        request_data["field_"+w.field_name] = w.get_edit_text()
+                            field_key = "field_" + w.field_name
+                            if isinstance(w, urwid.Edit):
+                                request_data[field_key] = w.edit_text
+                            elif isinstance(w, urwid.RadioButton):
+                                if w.state:
+                                    user_data = getattr(w, "field_value", None)  
+                                    if user_data is not None:
+                                        request_data[field_key] = user_data
+                            elif isinstance(w, urwid.CheckBox):
+                                user_data = getattr(w, "field_value", "1")
+                                if w.state:
+                                    existing_value = request_data.get(field_key, '')
+                                    if existing_value:
+                                        # Concatenate the new value with the existing one
+                                        request_data[field_key] = existing_value + ',' + user_data
+                                    else:
+                                        # Initialize the field with the current value
+                                        request_data[field_key] = user_data
+                                else:
+                                    pass  # do nothing if checkbox is not check
+
+
+
+
+                        
+
                 
             recurse_down(self.attr_maps)
             RNS.log("Including request data: "+str(request_data), RNS.LOG_DEBUG)
@@ -252,7 +277,7 @@ class Browser:
 
             display_name = None
             if display_name_data != None:
-                display_name = display_name_data.decode("utf-8")
+                display_name = LXMF.display_name_from_app_data(display_name_data)
 
             if not source_hash_text in [c[0] for c in existing_conversations]:
                 entry = DirectoryEntry(bytes.fromhex(source_hash_text), display_name=display_name)

nomadnet/ui/textui/Guide.py

@@ -666,9 +666,9 @@ Determines the interval in minutes for rescanning the hosted files path. By defa
 <
 
 >>>
-`!disable_propagation = no`!
+`!disable_propagation = yes`!
 >>>>
-By default, when Nomad Network is hosting a node, it will also run an LXMF propagation node. If there is already a large amount of propagation nodes on the network, or you simply want to run a pageserving-only node, you can disable running a propagation node.
+When Nomad Network is hosting a node, it can also run an LXMF propagation node. If there is already a large amount of propagation nodes on the network, or you simply want to run a pageserving-only node, you can disable running a propagation node.
 <
 
 >>>
@@ -689,6 +689,18 @@ The maximum accepted transfer size per incoming propagation transfer, in kilobyt
 Configures the LXMF Propagation Node to prioritise storing messages for certain destinations. If the message store reaches the specified limit, LXMF will prioritise keeping messages for destinations specified with this option. This setting is optional, and generally you do not need to use it.
 <
 
+>>>
+`!max_peers = 25`!
+>>>>
+Configures the maximum number of other nodes the LXMF Propagation Node will automatically peer with. The default is 50, but can be lowered or increased according to available resources.
+<
+
+>>>
+`!static_peers = e17f833c4ddf8890dd3a79a6fea8161d, 5a2d0029b6e5ec87020abaea0d746da4`!
+>>>>
+Configures the LXMF Propagation Node to always maintain propagation node peering with the specified list of destination hashes.
+<
+
 >> Printing Section
 
 This section holds configuration directives related to printing. It is delimited by the `![printing]`! header in the configuration file. Available directives, along with example values, are as follows:
@@ -1152,6 +1164,47 @@ A sized input field:  `B444`<16|with_size`>`B333
 A masked input field: `B444`<!|masked_demo`hidden text>`B333
 
 Full control: `B444`<!32|all_options`hidden text>`B333
+`b
+>>> Checkboxes
+
+In addition to text fields, Checkboxes are another way of submitting data. They allow the user to make a single selection or select multiple options. 
+
+`Faaa
+`=
+`<?|field_name|value`>`b Label Text`
+`=
+When the checkbox is checked, it's field will be set to the provided value. If there are multiple checkboxes that share the same field name, the checked values will be concatenated when they are sent to the node by a comma.
+``
+
+`B444`<?|sign_up|1`>`b Sign me up`
+
+You can also pre-check both checkboxes and radio groups by appending a |* after the field value.
+
+`B444`<?|checkbox|1|*`>`b Pre-checked checkbox`
+
+>>> Radio groups
+
+Radio groups are another input that lets the user chose from a set of options. Unlike checkboxes, radio buttons with the same field name are mutually exclusive.
+
+Example:
+
+`=
+`B900`<^|color|Red`>`b  Red
+
+`B090`<^|color|Green`>`b Green
+
+`B009`<^|color|Blue`>`b Blue
+`=
+
+will render:
+
+`B900`<^|color|Red`>`b  Red
+
+`B090`<^|color|Green`>`b Green
+
+`B009`<^|color|Blue`>`b Blue
+
+In this example, when the data is submitted, `B444` field_color`b will be set to whichever value from the list was selected.
 
 ``
 

nomadnet/ui/textui/MicronParser.py

@@ -160,7 +160,6 @@ def parse_line(line, state, url_delegate):
                             tw.in_columns = True
                         else:
                             tw = urwid.Text(o, align=state["align"])
-                        
                         widgets.append((urwid.PACK, tw))
                     else:
                         if o["type"] == "field":
@@ -173,6 +172,36 @@ def parse_line(line, state, url_delegate):
                             f.field_name = fn
                             fa = urwid.AttrMap(f, fs)
                             widgets.append((fw, fa))
+                        elif o["type"] == "checkbox":
+                            fn = o["name"]
+                            fv = o["value"]
+                            flabel = o["label"]
+                            fs = o["style"]
+                            fprechecked = o.get("prechecked", False)  
+                            f = urwid.CheckBox(flabel, state=fprechecked)
+                            f.field_name = fn
+                            f.field_value = fv
+                            fa = urwid.AttrMap(f, fs)
+                            widgets.append((urwid.PACK, fa))
+                        elif o["type"] == "radio":
+                            fn = o["name"]
+                            fv = o["value"]
+                            flabel = o["label"]
+                            fs = o["style"]
+                            fprechecked = o.get("prechecked", False)  
+                            if "radio_groups" not in state:
+                                state["radio_groups"] = {}
+                            if fn not in state["radio_groups"]:
+                                state["radio_groups"][fn] = []
+                            group = state["radio_groups"][fn]
+                            f = urwid.RadioButton(group, flabel, state=fprechecked, user_data=fv)
+                            f.field_name = fn
+                            f.field_value = fv
+                            fa = urwid.AttrMap(f, fs)
+                            widgets.append((urwid.PACK, fa))
+
+
+
 
                 columns_widget = urwid.Columns(widgets, dividechars=0)
                 text_widget = columns_widget
@@ -458,43 +487,87 @@ def make_output(state, line, url_delegate):
                     elif c == "a":
                         state["align"] = state["default_align"]
 
-                    elif c == "<":
+                    elif c == '<':
+                        if len(part) > 0:
+                            output.append(make_part(state, part))
+                            part = ""
                         try:
-                            field_name = None
+                            field_start = i + 1  # position after '<'
-                            field_name_end = line[i:].find("`")
+                            backtick_pos = line.find('`', field_start)
-                            if field_name_end == -1:
+                            if backtick_pos == -1:
-                                pass
+                                pass  # No '`', invalid field
                             else:
-                                field_name = line[i+1:i+field_name_end]
+                                field_content = line[field_start:backtick_pos]
-                                field_name_skip = len(field_name)
                                 field_masked = False
                                 field_width = 24
+                                field_type = "field"
+                                field_name = field_content
+                                field_value = ""
+                                field_data = ""
+                                field_prechecked = False  
 
-                                if "|" in field_name:
+                                # check if field_content contains '|'
-                                    f_components = field_name.split("|")
+                                if '|' in field_content:
+                                    f_components = field_content.split('|')
                                     field_flags = f_components[0]
                                     field_name = f_components[1]
-                                    if "!" in field_flags:
+
+                                    # handle field type indicators
+                                    if '^' in field_flags:
+                                        field_type = "radio"
+                                        field_flags = field_flags.replace("^", "")
+                                    elif '?' in field_flags:
+                                        field_type = "checkbox"
+                                        field_flags = field_flags.replace("?", "")
+                                    elif '!' in field_flags:
                                         field_flags = field_flags.replace("!", "")
                                         field_masked = True
+
+                                    # Handle field width
                                     if len(field_flags) > 0:
+                                        try:
                                             field_width = min(int(field_flags), 256)
+                                        except ValueError:
+                                            pass  # Ignore invalid width
 
-                                def sr():
+                                    # Check for value and pre-checked flag
-                                    return "@{"+str(random.randint(1000,9999))+"}"
+                                    if len(f_components) > 2:
-                                rsg = sr()
+                                        field_value = f_components[2]
-                                while rsg in line[i+field_name_end:]:
+                                    else:
-                                    rsg = sr()
+                                        field_value = ""
-                                lr = line[i+field_name_end:].replace("\\>", rsg)
+                                    if len(f_components) > 3:
-                                endpos = lr.find(">")
+                                        if f_components[3] == '*':
-                                
+                                            field_prechecked = True
-                                if endpos == -1:
-                                    pass
 
                                 else:
-                                    field_data = lr[1:endpos].replace(rsg, "\\>")
+                                    # No '|', so field_name is field_content
-                                    skip = len(field_data)+field_name_skip+2
+                                    field_name = field_content
-                                    field_data = field_data.replace("\\>", ">")
+                                    field_type = "field"
+                                    field_masked = False
+                                    field_width = 24
+                                    field_value = ""
+                                    field_prechecked = False
+
+                                # Find the closing '>' character
+                                field_end = line.find('>', backtick_pos)
+                                if field_end == -1:
+                                    pass  # No closing '>', invalid field
+                                else:
+                                    field_data = line[backtick_pos+1:field_end]
+
+                                    # Now, we have all field data
+                                    if field_type in ["checkbox", "radio"]:
+                                        # for checkboxes and radios, field_data is the label
+                                        output.append({
+                                            "type": field_type,
+                                            "name": field_name,
+                                            "value": field_value if field_value else field_data,
+                                            "label": field_data,
+                                            "prechecked": field_prechecked,
+                                            "style": make_style(state)
+                                        })
+                                    else:
+                                        # For text fields field_data is the initial text
                                         output.append({
                                             "type": "field",
                                             "name": field_name,
@@ -503,9 +576,11 @@ def make_output(state, line, url_delegate):
                                             "data": field_data,
                                             "style": make_style(state)
                                         })
+                                    skip = field_end - i
                         except Exception as e:
                             pass
 
+                    
                     elif c == "[":
                         endpos = line[i:].find("]")
                         if endpos == -1:

nomadnet/ui/textui/Network.py

@@ -1594,10 +1594,10 @@ class NetworkDisplay():
         if self.list_display == 1:
             parent = self.app.ui.main_display.sub_displays.network_display
             selected_node_entry = parent.known_nodes_display.ilb.get_selected_item()
-            if selected_node_entry != None:
+            if selected_node_entry is not None:
-                selected_node_hash = selected_node_entry._get_base_widget().display_widget.source_hash
+                selected_node_hash = selected_node_entry.base_widget.display_widget.source_hash
                 
-                if selected_node_hash != None:
+                if selected_node_hash is not None:
                     info_widget = KnownNodeInfo(selected_node_hash)
                     options = parent.left_pile.options(height_type=urwid.WEIGHT, height_amount=1)
                     parent.left_pile.contents[0] = (info_widget, options)
@@ -1753,7 +1753,7 @@ class LXMFPeers(urwid.WidgetWrap):
 
     def make_peer_widgets(self):
         widget_list = []
-        sorted_peers = sorted(self.peer_list, key=lambda pid: (self.app.directory.pn_trust_level(pid), self.peer_list[pid].link_establishment_rate), reverse=True)
+        sorted_peers = sorted(self.peer_list, key=lambda pid: (self.app.directory.pn_trust_level(pid), self.peer_list[pid].sync_transfer_rate), reverse=True)
         for peer_id in sorted_peers:
             peer = self.peer_list[peer_id]
             trust_level = self.app.directory.pn_trust_level(peer_id)
@@ -1797,7 +1797,15 @@ class LXMFPeerEntry(urwid.WidgetWrap):
                 style = "list_unresponsive"
                 focus_style = "list_focus_unresponsive"
 
-        widget = ListEntry(sym+" "+display_str+"\n  "+alive_string+", last heard "+pretty_date(int(peer.last_heard))+"\n  "+str(len(peer.unhandled_messages))+" unhandled LXMs, "+RNS.prettysize(peer.link_establishment_rate/8, "b")+"/s LER")
+        if peer.propagation_transfer_limit:
+            txfer_limit = RNS.prettysize(peer.propagation_transfer_limit*1000)
+        else:
+            txfer_limit = "No"
+        peer_info_str  = sym+" "+display_str+"\n  "+alive_string+", last heard "+pretty_date(int(peer.last_heard))
+        peer_info_str += "\n  "+str(peer.unhandled_message_count)+f" unhandled LXMs, {txfer_limit} sync limit\n"
+        peer_info_str += f"  {RNS.prettyspeed(peer.sync_transfer_rate)} STR, "
+        peer_info_str += f"{RNS.prettyspeed(peer.link_establishment_rate)} LER\n"
+        widget = ListEntry(peer_info_str)
         self.display_widget = urwid.AttrMap(widget, style, focus_style)
         self.display_widget.destination_hash = destination_hash
         super().__init__(self.display_widget)

setup.py

@@ -30,6 +30,6 @@ setuptools.setup(
     entry_points= {
         'console_scripts': ['nomadnet=nomadnet.nomadnet:main']
     },
-    install_requires=["rns>=0.7.7", "lxmf>=0.5.1", "urwid>=2.4.4", "qrcode"],
+    install_requires=["rns>=0.9.1", "lxmf>=0.6.1", "urwid>=2.6.16", "qrcode"],
-    python_requires=">=3.6",
+    python_requires=">=3.7",
 )