Fix/cross platform path handling 944

.github/workflows/path-audit.yml

@@ -0,0 +1,58 @@
+name: Cross-Platform Path Handling Audit
+
+on:
+  pull_request:
+    paths:
+      - "**/*.py"
+      - "scripts/audit_paths.py"
+      - ".github/workflows/path-audit.yml"
+  push:
+    branches:
+      - main
+    paths:
+      - "**/*.py"
+      - "scripts/audit_paths.py"
+      - ".github/workflows/path-audit.yml"
+
+jobs:
+  path-audit:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .
+
+      - name: Run path handling audit
+        run: |
+          echo "🔍 Running cross-platform path handling audit..."
+          python scripts/audit_paths.py --output path_audit_report.md
+
+          # Check if there are any high-priority issues (P0 or P1)
+          if grep -q "🔴 P0\|🟡 P1" path_audit_report.md; then
+            echo "❌ High-priority path handling issues found!"
+            echo "Please review the audit report and fix the issues."
+            cat path_audit_report.md
+            exit 1
+          else
+            echo "✅ No high-priority path handling issues found."
+            cat path_audit_report.md
+          fi
+
+      - name: Upload audit report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: path-audit-report-${{ matrix.python-version }}
+          path: path_audit_report.md

.pre-commit-config.yaml

@@ -49,3 +49,11 @@ repos:
         language: system
         always_run: true
         pass_filenames: false
+  - repo: local
+    hooks:
+      - id: path-audit
+        name: Run cross-platform path handling audit
+        entry: python scripts/audit_paths.py --summary-only
+        language: system
+        always_run: true
+        pass_filenames: false

docs/conf.py

@@ -13,9 +13,9 @@
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
+# sys.path.insert(0, str(Path('.').absolute()))
 
 import doctest
-import os
 import sys
 
 sys.path.insert(0, os.path.abspath('..'))
@@ -28,7 +28,9 @@
     import tomli as tomllib  # type: ignore (In case of >3.11 Pyrefly doesnt find tomli , which is right but a false flag)
 
 # Path to pyproject.toml (assuming conf.py is in a 'docs' subdirectory)
-pyproject_path = os.path.join(os.path.dirname(__file__), "..", "pyproject.toml")
+from libp2p.utils.paths import get_script_dir, join_paths
+
+pyproject_path = join_paths(get_script_dir(__file__), "..", "pyproject.toml")
 
 with open(pyproject_path, "rb") as f:
     pyproject_data = tomllib.load(f)

docs/contributing.rst

@@ -231,6 +231,36 @@ This library uses type hints, which are enforced by the ``mypy`` tool (part of t
 ``pre-commit`` checks). All new code is required to land with type hints, with the
 exception of code within the ``tests`` directory.
 
+Cross-Platform Path Handling
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To ensure compatibility across Windows, macOS, and Linux, we use standardized path
+utilities from ``libp2p.utils.paths`` instead of direct ``os.path`` operations.
+
+**Required practices:**
+
+- Use ``join_paths()`` instead of ``os.path.join()``
+- Use ``get_script_dir()`` instead of ``os.path.dirname(os.path.abspath(__file__))``
+- Use ``get_temp_dir()`` or ``create_temp_file()`` instead of hard-coded temp paths
+- Use ``Path`` objects for path manipulation instead of string concatenation
+
+**Examples:**
+
+.. code:: python
+
+    # ❌ Don't do this
+    import os
+    config_path = os.path.join(os.path.dirname(__file__), "config", "settings.json")
+    temp_file = "/tmp/my_app.log"
+
+    # ✅ Do this instead
+    from libp2p.utils.paths import join_paths, get_script_dir, create_temp_file
+    config_path = join_paths(get_script_dir(__file__), "config", "settings.json")
+    temp_file = create_temp_file(prefix="my_app_", suffix=".log")
+
+The pre-commit hooks include a path audit that will catch non-cross-platform path
+handling patterns. Run ``python scripts/audit_paths.py`` to check for issues.
+
 Documentation
 ~~~~~~~~~~~~~
 

libp2p/pubsub/gossipsub.py

@@ -108,6 +108,7 @@ def __init__(
         time_to_live: int = 60,
         gossip_window: int = 3,
         gossip_history: int = 5,
+        flood_publish: bool = False,
         heartbeat_initial_delay: float = 0.1,
         heartbeat_interval: int = 120,
         direct_connect_initial_delay: float = 0.1,
@@ -138,6 +139,17 @@ def __init__(
         # Create message cache
         self.mcache = MessageCache(gossip_window, gossip_history)
 
+        # Whether to flood publish to all peers instead of following gossipsub
+        # mesh/fanout logic when acting as the original publisher.
+        # When enabled, this behaves as a hybrid between FloodSub and GossipSub:
+        # - When this node is the original publisher: Message is sent to ALL peers
+        #   who are subscribed to the topic (flood publishing behavior)
+        # - When this node is forwarding a message: Regular GossipSub behavior is used
+        # This provides better reliability at publication time with a reasonable
+        # bandwidth cost since it only affects the original publisher.
+        # Default is False.
+        self.flood_publish = flood_publish
+
         # Create heartbeat timer
         self.heartbeat_initial_delay = heartbeat_initial_delay
         self.heartbeat_interval = heartbeat_interval
@@ -300,43 +312,52 @@ def _get_peers_to_send(
             if topic not in self.pubsub.peer_topics:
                 continue
 
-            # direct peers
-            _direct_peers: set[ID] = {_peer for _peer in self.direct_peers}
-            send_to.update(_direct_peers)
-
-            # floodsub peers
-            floodsub_peers: set[ID] = {
-                peer_id
-                for peer_id in self.pubsub.peer_topics[topic]
-                if peer_id in self.peer_protocol
-                and self.peer_protocol[peer_id] == floodsub.PROTOCOL_ID
-            }
-            send_to.update(floodsub_peers)
-
-            # gossipsub peers
-            gossipsub_peers: set[ID] = set()
-            if topic in self.mesh:
-                gossipsub_peers = self.mesh[topic]
+            # If flood_publish is enabled and we are the original publisher,
+            # send to all peers in the topic (flood publishing behavior)
+            if self.flood_publish and msg_forwarder == self.pubsub.my_id:
+                for peer in self.pubsub.peer_topics[topic]:
+                    # TODO: add score threshold check when peer scoring is implemented
+                    # if direct peer then skip score check
+                    send_to.add(peer)
             else:
-                # When we publish to a topic that we have not subscribe to, we randomly
-                # pick `self.degree` number of peers who have subscribed to the topic
-                # and add them as our `fanout` peers.
-                topic_in_fanout: bool = topic in self.fanout
-                fanout_peers: set[ID] = self.fanout[topic] if topic_in_fanout else set()
-                fanout_size = len(fanout_peers)
-                if not topic_in_fanout or (
-                    topic_in_fanout and fanout_size < self.degree
-                ):
-                    if topic in self.pubsub.peer_topics:
-                        # Combine fanout peers with selected peers
-                        fanout_peers.update(
-                            self._get_in_topic_gossipsub_peers_from_minus(
-                                topic, self.degree - fanout_size, fanout_peers
+                # Regular GossipSub routing logic
+                # direct peers
+                _direct_peers: set[ID] = {_peer for _peer in self.direct_peers}
+                send_to.update(_direct_peers)
+
+                # floodsub peers
+                floodsub_peers: set[ID] = {
+                    peer_id
+                    for peer_id in self.pubsub.peer_topics[topic]
+                    if peer_id in self.peer_protocol
+                    and self.peer_protocol[peer_id] == floodsub.PROTOCOL_ID
+                }
+                send_to.update(floodsub_peers)
+
+                # gossipsub peers
+                gossipsub_peers: set[ID] = set()
+                if topic in self.mesh:
+                    gossipsub_peers = self.mesh[topic]
+                else:
+                    # When we publish to a topic that we have not subscribe to, we randomly
+                    # pick `self.degree` number of peers who have subscribed to the topic
+                    # and add them as our `fanout` peers.
+                    topic_in_fanout: bool = topic in self.fanout
+                    fanout_peers: set[ID] = self.fanout[topic] if topic_in_fanout else set()
+                    fanout_size = len(fanout_peers)
+                    if not topic_in_fanout or (
+                        topic_in_fanout and fanout_size < self.degree
+                    ):
+                        if topic in self.pubsub.peer_topics:
+                            # Combine fanout peers with selected peers
+                            fanout_peers.update(
+                                self._get_in_topic_gossipsub_peers_from_minus(
+                                    topic, self.degree - fanout_size, fanout_peers
+                                )
                             )
-                        )
-                self.fanout[topic] = fanout_peers
-                gossipsub_peers = fanout_peers
-            send_to.update(gossipsub_peers)
+                    self.fanout[topic] = fanout_peers
+                    gossipsub_peers = fanout_peers
+                send_to.update(gossipsub_peers)
         # Excludes `msg_forwarder` and `origin`
         yield from send_to.difference([msg_forwarder, origin])
 

libp2p/tools/constants.py

@@ -72,6 +72,7 @@ class GossipsubParams(NamedTuple):
     px_peers_count: int = 16
     prune_back_off: int = 60
     unsubscribe_back_off: int = 10
+    flood_publish: bool = False
 
 
 GOSSIPSUB_PARAMS = GossipsubParams()

libp2p/utils/paths.py

@@ -216,7 +216,7 @@ def find_executable(name: str) -> Path | None:
 
     """
     # Check if name already contains path
-    if os.path.dirname(name):
+    if Path(name).parent != Path("."):
         path = Path(name)
         if path.exists() and os.access(path, os.X_OK):
             return path

newsfragments/713.feature.rst

@@ -0,0 +1 @@
+Added flood publishing.

scripts/audit_paths.py

@@ -117,7 +117,7 @@ def generate_migration_suggestions(issues: dict[str, list[dict[str, Any]]]) -> s
                 suggestions.append("# Suggested fix:")
                 suggestions.append("from libp2p.utils.paths import join_paths")
                 suggestions.append(
-                    "# Replace os.path.join(a, b, c) with join_paths(a, b, c)"
+                    "# Replace os.path.join with join_paths function"
                 )
                 suggestions.append("```")
             elif issue_type == "temp_hardcode":
@@ -137,8 +137,7 @@ def generate_migration_suggestions(issues: dict[str, list[dict[str, Any]]]) -> s
                 suggestions.append("# Suggested fix:")
                 suggestions.append("from libp2p.utils.paths import get_script_dir")
                 script_dir_fix_msg = (
-                    "# Replace os.path.dirname(os.path.abspath(__file__)) with "
-                    "get_script_dir(__file__)"
+                    "# Replace dirname and abspath with get_script_dir function"
                 )
                 suggestions.append(script_dir_fix_msg)
                 suggestions.append("```")

tests/core/kad_dht/test_unit_provider_store.py

@@ -725,7 +725,8 @@ def test_unicode_key_handling(self):
 
         for i, key in enumerate(unicode_keys):
             # Generate valid Base58 peer IDs
-            peer_id = ID.from_base58(f"QmPeer{i + 1}" + "1" * 42)  # Valid base58
+            peer_id_str = f"QmPeer{i + 1}{'1' * 42}"  # Valid base58
+            peer_id = ID.from_base58(peer_id_str)
             provider = PeerInfo(peer_id, [])
             store.add_provider(key, provider)