Updated dependencies

Add Checkbox and Radio Group fields to Micron

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,8 +216,16 @@ 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
 
-            lxm = LXMF.LXMessage(dest, source, content, title=title, desired_method=desired_method)
+            dest_is_trusted = False
+            if self.app.directory.trust_level(dest.hash) == DirectoryEntry.TRUSTED:
+                dest_is_trusted = True
+
+            lxm = LXMF.LXMessage(dest, source, content, title=title, desired_method=desired_method, include_ticket=dest_is_trusted)
             lxm.register_delivery_callback(self.message_notification)
             lxm.register_failed_callback(self.message_notification)
 

nomadnet/NomadNetworkApp.py

@@ -135,6 +135,10 @@ class NomadNetworkApp:
         self.lxmf_sync_limit    = 8
         self.compact_stream     = False
         
+        self.required_stamp_cost   = None
+        self.accept_invalid_stamps = False
+
+
         if not os.path.isdir(self.storagepath):
             os.makedirs(self.storagepath)
 
@@ -296,8 +300,9 @@ class NomadNetworkApp:
         for destination_hash in self.ignored_list:
             self.message_router.ignore_destination(destination_hash)
 
-        self.lxmf_destination = self.message_router.register_delivery_identity(self.identity, display_name=self.peer_settings["display_name"])
+        self.lxmf_destination = self.message_router.register_delivery_identity(self.identity, display_name=self.peer_settings["display_name"], stamp_cost=self.required_stamp_cost)
-        self.lxmf_destination.set_default_app_data(self.get_display_name_bytes)
+        if not self.accept_invalid_stamps:
+            self.message_router.enforce_stamps()
 
         RNS.Identity.remember(
             packet_hash=None,
@@ -492,7 +497,9 @@ class NomadNetworkApp:
             self.message_router.cancel_propagation_node_requests()
 
     def announce_now(self):
-        self.lxmf_destination.announce()
+        self.message_router.set_inbound_stamp_cost(self.lxmf_destination.hash, self.required_stamp_cost)
+        self.lxmf_destination.display_name = self.peer_settings["display_name"]
+        self.message_router.announce(self.lxmf_destination.hash)
         self.peer_settings["last_announce"] = time.time()
         self.save_peer_settings()
 
@@ -738,6 +745,24 @@ class NomadNetworkApp:
                     else:
                         self.lxmf_sync_limit = None
 
+                if option == "required_stamp_cost":
+                    value = self.config["client"][option]
+                    if value.lower() == "none":
+                        self.required_stamp_cost = None
+                    else:
+                        value = self.config["client"].as_int(option)
+
+                        if value > 0:
+                            if value > 255:
+                                value = 255
+                            self.required_stamp_cost = value
+                        else:
+                            self.required_stamp_cost = None
+
+                if option == "accept_invalid_stamps":
+                    value = self.config["client"].as_bool(option)
+                    self.accept_invalid_stamps = value
+
                 if option == "max_accepted_size":
                     value = self.config["client"].as_float(option)    
 
@@ -1017,6 +1042,24 @@ lxmf_sync_interval = 360
 # the limit, and download everything every time.
 lxmf_sync_limit = 8
 
+# You can specify a required stamp cost for
+# inbound messages to be accepted. Specifying
+# a stamp cost will require untrusted senders
+# that message you to include a cryptographic
+# stamp in their messages. Performing this
+# operation takes the sender an amount of time
+# proportional to the stamp cost. As a rough
+# estimate, a stamp cost of 8 will take less
+# than a second to compute, and a stamp cost
+# of 20 could take several minutes, even on
+# a fast computer.
+required_stamp_cost = None
+
+# You can signal stamp requirements to senders,
+# but still accept messages with invalid stamps
+# by setting this option to True.
+accept_invalid_stamps = False
+
 # The maximum accepted unpacked size for mes-
 # sages received directly from other peers,
 # specified in kilobytes. Messages larger than

nomadnet/_version.py

@@ -1 +1 @@
-__version__ = "0.5.1"
+__version__ = "0.5.6"

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

@@ -521,6 +521,18 @@ The number of minutes between each automatic sync. The default is equal to 6 hou
 On low-bandwidth networks, it can be useful to limit the amount of messages downloaded in each sync. The default is 8. Set to 0 to download all available messages every time a sync occurs.
 <
 
+>>>
+`!required_stamp_cost = None`!
+>>>>
+You can specify a required stamp cost for inbound messages to be accepted. Specifying a stamp cost will require untrusted senders that message you to include a cryptographic stamp in their messages. Performing this operation takes the sender an amount of time proportional to the stamp cost. As a rough estimate, a stamp cost of 8 will take less than a second to compute, and a stamp cost of 20 could take several minutes, even on a fast computer.
+<
+
+>>>
+`!accept_invalid_stamps = False`!
+>>>>
+You can signal stamp requirements to senders, but still accept messages with invalid stamps by setting this option to True.
+<
+
 >>>
 `!max_accepted_size = 500`!
 >>>>
@@ -739,12 +751,11 @@ If you have Internet access, and just want to get started experimenting, you are
 The Testnet also runs the latest version of Reticulum, often even a short while before it is publicly released, which means strange behaviour might occur. If none of that scares you, add the following interface to your Reticulum configuration file to join:
 
 >>
-[[RNS Testnet Zurich]]
+[[RNS Testnet Dublin]]
   type = TCPClientInterface
-  interface_enabled = yes
+  enabled = yes
-  outgoing = True
+  target_host = dublin.connect.reticulum.network
-  target_host = zurich.connect.reticulum.network
+  target_port = 4965
-  target_port = 4242
 <
 
 If you connect to the testnet, you can leave nomadnet running for a while and wait for it to receive announces from other nodes on the network that host pages or services, or you can try connecting directly to some nodes listed here:
@@ -1141,6 +1152,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,54 +487,100 @@ 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": 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,
                                             "width": field_width,
                                             "masked": field_masked,
                                             "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:

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.0", "urwid>=2.4.4", "qrcode"],
+    install_requires=["rns>=0.8.8", "lxmf>=0.5.8", "urwid>=2.4.4", "qrcode"],
     python_requires=">=3.6",
 )