chore: Fix code formatting in example code in user documentation (#3058)

BulkBeing · web-flow · commit e37e98122f6b · 2025-11-03T09:16:03.000+05:30
Signed-off-by: Sreekanth &lt;prsreekanth920@gmail.com&gt;
diff --git a/docs/user-guide/sources/transformer/overview.md b/docs/user-guide/sources/transformer/overview.md
@@ -70,29 +70,28 @@ Check the links below to see another transformer example in various programming
 
 	```python
 	def my_handler(keys: list[str], datum: Datum) -> Messages:
-    val = datum.value
-    event_time = datum.event_time
-    messages = Messages()
-
-    if event_time < january_first_2022:
-        logging.info("Got event time:%s, it is before 2022, so dropping", event_time)
-        messages.append(Message.to_drop(event_time))
-    elif event_time < january_first_2023:
-        logging.info(
-            "Got event time:%s, it is within year 2022, so forwarding to within_year_2022",
-            event_time,
-        )
-        messages.append(
-            Message(value=val, event_time=january_first_2022, tags=["within_year_2022"])
-        )
-    else:
-        logging.info(
-            "Got event time:%s, it is after year 2022, so forwarding to after_year_2022", event_time
-        )
-        messages.append(Message(value=val, event_time=january_first_2023, tags=["after_year_2022"]))
-
-    return messages
-	
+		val = datum.value
+		event_time = datum.event_time
+		messages = Messages()
+
+		if event_time < january_first_2022:
+			logging.info("Got event time:%s, it is before 2022, so dropping", event_time)
+			messages.append(Message.to_drop(event_time))
+		elif event_time < january_first_2023:
+			logging.info(
+				"Got event time:%s, it is within year 2022, so forwarding to within_year_2022",
+				event_time,
+			)
+			messages.append(
+				Message(value=val, event_time=january_first_2022, tags=["within_year_2022"])
+			)
+		else:
+			logging.info(
+				"Got event time:%s, it is after year 2022, so forwarding to after_year_2022", event_time
+			)
+			messages.append(Message(value=val, event_time=january_first_2023, tags=["after_year_2022"]))
+
+		return messages
 	```
 	- [Python full example on numaflow-python on Github](https://github.com/numaproj/numaflow-python/blob/main/packages/pynumaflow/examples/sourcetransform/event_time_filter/example.py)
 
diff --git a/docs/user-guide/user-defined-functions/reduce/windowing/accumulator.md b/docs/user-guide/user-defined-functions/reduce/windowing/accumulator.md
@@ -1,23 +1,23 @@
 # Accumulator
 
-Accumulator is a special kind of window similar to a [Session Window](session.md) designed for complex operations like 
+Accumulator is a special kind of window similar to a [Session Window](session.md) designed for complex operations like
 reordering, custom triggering, and joining multiple ordered streams. Like other windowing strategies (fixed,
-sliding, or session windows), the Accumulator window maintains state for each key, but unlike others, it allows for 
-manipulation of the `Datum` and emitting them based on custom rules (e.g., sorting) . Accumulator solves is a different 
-type of problem outside both `map`/`flatmap` (one to ~one) and `reduce` (many to ~one) and instead of `Message`, we 
+sliding, or session windows), the Accumulator window maintains state for each key, but unlike others, it allows for
+manipulation of the `Datum` and emitting them based on custom rules (e.g., sorting) . Accumulator solves is a different
+type of problem outside both `map`/`flatmap` (one to ~one) and `reduce` (many to ~one) and instead of `Message`, we
 have to emit back the "manipulated" `Datum`.
 
 ![plot](../../../../assets/accumulator.png)
 
-Another difference between the Accumulator and the Session windows is that in Accumulator, there is no concept of 
+Another difference between the Accumulator and the Session windows is that in Accumulator, there is no concept of
 [window merge](./session.md#window-merge).
 
 ## Why Accumulator?
 
 Accumulator is a powerful concept that lets you tap into the raw Datum stream and manipulate not just the order but the
 Datum stream itself. It has a powerful semantics where the input and output is a stream of `Datum` creating a
 Global Window. It opens up the possibility of very advanced use cases like custom triggers (e.g., count based triggers
-combined with windowing strategies). 
+combined with windowing strategies).
 
 === "Go"
 
@@ -70,30 +70,30 @@ combined with windowing strategies).
 === "Rust"
 
     ```rust
-          struct Accumulator {
-          state: OrderedList<Datum>,
-      }
+    struct Accumulator {
+        state: OrderedList<Datum>,
+    }
 
-      impl Accumulator {
-          fn new() -> Self {
-              Self {
-                  state: OrderedList::new(),
-              }
-          }
+    impl Accumulator {
+        fn new() -> Self {
+            Self {
+                state: OrderedList::new(),
+            }
+        }
+
+        fn process(&mut self, input_stream: &[Datum], output_stream: &mut Vec<Datum>) {
+            for i in input_stream {
+                // Check if the watermark has progressed
+                if WatermarkProgressed(i) {
+                    // Pop all sorted elements and write to output stream
+                    let popped = self.state.pop_all();
+                    output_stream.extend(popped);
+                }
+                self.state.insert(i.clone());
+            }
+        }
+    }
 
-          fn process(&mut self, input_stream: &[Datum], output_stream: &mut Vec<Datum>) {
-              for i in input_stream {
-                  // Check if the watermark has progressed
-                  if WatermarkProgressed(i) {
-                      // Pop all sorted elements and write to output stream
-                      let popped = self.state.pop_all();
-                      output_stream.extend(popped);
-                  }
-                  self.state.insert(i.clone());
-              }
-          }
-      }
- 
     ```
 
 === "Java"
@@ -125,12 +125,12 @@ combined with windowing strategies).
 
 ### Considerations
 
-The Accumulator window is powerful but should be used carefully as it can cause pipeline stalling if not configured 
+The Accumulator window is powerful but should be used carefully as it can cause pipeline stalling if not configured
 properly.
 
 #### Factors to consider
 
-Please consider the following factors when using the Accumulator window (not comprehensive): 
+Please consider the following factors when using the Accumulator window (not comprehensive):
 
 1. For high-throughput scenarios, ensure adequate storage is provisioned
 2. The timeout should be set based on the expected data arrival patterns and latency requirements
@@ -173,7 +173,7 @@ such as "300ms", "1.5h" or "2h45m". Valid time units are "ns", "us" (or "µs"),
 
 ### timeout
 
-The `timeout` is the duration of inactivity (no data flowing in for a particular key) after which the accumulator state 
+The `timeout` is the duration of inactivity (no data flowing in for a particular key) after which the accumulator state
 is removed. This helps prevent memory leaks by cleaning up state for keys that are no longer active.
 
 ## How It Works
@@ -185,13 +185,13 @@ The Accumulator window works by:
 3. New elements are inserted into the ordered list based on their event time
 4. If no new data arrives for a key within the specified timeout period, the window is closed
 
-Unlike both `map` or `reduce` operations, where `Datum` is consumed and `Message` is returned, for reordering with the 
+Unlike both `map` or `reduce` operations, where `Datum` is consumed and `Message` is returned, for reordering with the
 Accumulator, the `Datum` is kept intact.
 
 
 ## Example
 
-Here's an [example](https://github.com/numaproj/numaflow/blob/main/examples/13-accumulator-window.yaml) of using an 
+Here's an [example](https://github.com/numaproj/numaflow/blob/main/examples/13-accumulator-window.yaml) of using an
 Accumulator window to join and sort two HTTP sources:
 
 ```yaml
@@ -268,13 +268,13 @@ Check out the snippets below to see the UDF examples for different languages:
                     return
                 }
                 log.Println("Received datum with event time: ", datum.EventTime().UnixMilli())
-                
+
                 // watermark has moved, let's flush
                 if datum.Watermark().After(s.latestWm) {
                     s.latestWm = datum.Watermark()
                     s.flushBuffer(output)
                 }
-                
+
                 // store the data into the internal buffer
                 s.insertSorted(datum)
             }
@@ -291,7 +291,7 @@ Check out the snippets below to see the UDF examples for different languages:
           _LOGGER.info("StreamSorter initialized")
           self.latest_wm = datetime.fromtimestamp(-1)
           self.sorted_buffer: list[Datum] = []
-  
+
       async def handler(
           self,
           datums: AsyncIterable[Datum],
@@ -304,15 +304,15 @@ Check out the snippets below to see the UDF examples for different languages:
                   f"Current latest watermark: {self.latest_wm}, "
                   f"Datum watermark: {datum.watermark}"
               )
-  
+
               # If watermark has moved forward
               if datum.watermark and datum.watermark > self.latest_wm:
                   self.latest_wm = datum.watermark
                   _LOGGER.info(f"Watermark updated: {self.latest_wm}")
                   await self.flush_buffer(output)
-  
+
               self.insert_sorted(datum)
-  
+
           _LOGGER.info("Timeout reached")
           await self.flush_buffer(output, flush_all=True)
     ```
@@ -398,5 +398,4 @@ Check out the snippets below to see the UDF examples for different languages:
       }
     ```
     [View the full example in numaflow-java Github](https://github.com/numaproj/numaflow-java/blob/38734c04df9e2182c0dadf2c7a4d83997ea7c2ad/examples/src/main/java/io/numaproj/numaflow/examples/accumulator/sorter/StreamSorterFactory.java)
-    
-   
+
