additional parameters added

Author: alelom

README.md

@@ -34,10 +34,64 @@ Simple usage:
 
 ```python
 foo = 123
-print(nameof(foo))  # Output: 'foo'
+nameof(foo)  # Output: 'foo'
 ```
 
-It supports string interpolation, so it's easier to reference variable names when logging,
+### Additional Parameters
+
+The `nameof` function supports two optional parameters for formatting the output:
+
+- `wrap_in_chars`: Wraps the variable name with the specified string at the start and end.
+- `replace_with_whitespace`: Removes all occurrences of the specified character(s) from the variable name and replaces them with a whitespace. Accepts a string or a list of strings.
+
+These are especially useful if you are logging to markdown format (printing messages as Markdown), to format variable names as code or to remove underscores for readability.
+
+
+```python
+some_param = 1
+
+# Combine both: wrap in backticks and remove underscores
+nameof(some_param, "`", "_")  # Output: '`some param`'
+
+```
+
+This is useful when generating Markdown documentation or error messages:
+
+```python
+def validate(some_param):
+    if some_param < 0:
+        # Prints: The parameter `someparam` must be positive.
+        print(f"The parameter {nameof(some_param, wrap_in_chars='`', replace_with_whitespace='_')} must be positive.")
+```
+
+
+### Multiple assignments
+
+If a variable is assigned twice, only the first name is returned.
+
+```python
+a = b = 1
+
+nameof(a) # returns "a"
+nameof(b) # returns "b"
+
+nameof(1) # raises ValueError (see next section below)
+```
+
+### Error Handling
+
+If you pass a value or an expression that is not a variable or attribute, `nameof` raises a `ValueError`:
+
+```python
+nameof(42)            # Raises ValueError
+nameof("foo.bar")     # Raises ValueError
+nameof("nameof(bar)") # Raises ValueError
+```
+
+
+## More usage examples
+
+`nameof()` supports string interpolation, so it's easier to reference variable names when logging,
 allowing for easier refactoring.  
 In the example below, refactoring the name of second_param will propagate to the printed message without having to manually do it.
 
@@ -54,8 +108,8 @@ It works for class attributes and instance variables.
 class Bar:
     attr = 99
 bar = Bar()
-print(nameof(Bar.attr))      # Output: 'attr'
-print(nameof(bar.attr))      # Output: 'attr'
+nameof(Bar.attr)      # Output: 'attr'
+nameof(bar.attr)      # Output: 'attr'
 ```
 
 It works also for nested classes.
@@ -71,28 +125,7 @@ class Outer:
         self.inner = Inner()
 
 outer = Outer()
-print(nameof(outer.inner.value))  # Output: 'value'
-```
-
-## Multiple assignments
-
-If a variable is assigned twice, only the first name is returned.
-
-```python
-a = b = 1
-
-nameof(a) # returns "a"
-nameof(b) # returns "b"
-
-nameof(1) # raises ValueError (see next section below)
+nameof(outer.inner.value)  # Output: 'value'
 ```
 
-## Error Handling
 
-If you pass a value or an expression that is not a variable or attribute, `nameof` raises a `ValueError`:
-
-```python
-nameof(42)            # Raises ValueError
-nameof("foo.bar")     # Raises ValueError
-nameof("nameof(bar)") # Raises ValueError
-```

nameof/__init__.py

@@ -0,0 +1 @@
+from .nameof import nameof

nameof/nameof.py

@@ -3,7 +3,21 @@
 from typing import Any
 import os
 
-def nameof(var: Any):
+def nameof(var: Any, wrap_in_chars: str = "", replace_with_whitespace: str | list[str] = [] ) -> str:
+    """
+    Returns the name of the variable or attribute passed as the first argument.
+    
+    Args:
+        var: The variable whose name should be returned.
+        wrap_in_chars: Optional string to wrap the result with (added to start and end).
+        replace_with_whitespace: Optional string or list of strings to replace with whitespace in the result.
+    
+    Returns:
+        str: The name of the variable, possibly wrapped and/or with specified characters replaced by whitespace.
+    
+    Raises:
+        ValueError: If the variable name cannot be determined.
+    """
     # Try to extract the argument expression from the caller's source code
     frame = inspect.currentframe()
     code_context = None
@@ -21,10 +35,25 @@ def nameof(var: Any):
                     if node.args:
                         arg = node.args[0]
                         if isinstance(arg, ast.Name):
-                            return arg.id
+                            result = arg.id
                         # Support attribute access, e.g., nameof(obj.attr)
-                        if isinstance(arg, ast.Attribute):
-                            return arg.attr
+                        elif isinstance(arg, ast.Attribute):
+                            result = arg.attr
+                        else:
+                            continue
+
+                        # Replace specified characters with whitespace
+                        if replace_with_whitespace:
+                            if isinstance(replace_with_whitespace, str):
+                                chars_list = [replace_with_whitespace]
+                            else:
+                                chars_list = replace_with_whitespace
+                            for ch in chars_list:
+                                result = result.replace(ch, " ")
+                        # Wrap in specified characters
+                        if wrap_in_chars:
+                            result = f"{wrap_in_chars}{result}{wrap_in_chars}"
+                        return result
 
     except Exception as e:
         if os.environ.get("nameof_test") or os.environ.get("nameof_test_debug"):

tests/nameof_additional_params_test.py

@@ -0,0 +1,58 @@
+if True:
+    import sys, os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+    os.environ["nameof_test"] = "True"
+    
+from nameof import nameof
+import pytest
+
+def test_wrap_in_chars():
+    my_var = 123
+    assert nameof(my_var, wrap_in_chars='"') == '"my_var"'
+    assert nameof(my_var, wrap_in_chars='*') == '*my_var*'
+    assert nameof(my_var, wrap_in_chars='[]') == '[]my_var[]'
+    assert nameof(my_var, wrap_in_chars='`') == '`my_var`'
+
+def test_replace_with_whitespace_str():
+    my_var = 123
+    assert nameof(my_var, replace_with_whitespace='_') == 'my var'
+    assert nameof(my_var, replace_with_whitespace='a') == 'my_v r'
+    assert nameof(my_var, replace_with_whitespace='m') == ' y_var'
+
+def test_replace_with_whitespace_list():
+    my_var = 123
+    assert nameof(my_var, replace_with_whitespace=['_']) == 'my var'
+    assert nameof(my_var, replace_with_whitespace=['a', 'v']) == 'my_  r'
+
+def test_wrap_and_remove():
+    my_var = 123
+    assert nameof(my_var, wrap_in_chars='`', replace_with_whitespace='_') == '`my var`'
+    assert nameof(my_var, '`', '_') == '`my var`'
+    assert nameof(my_var, wrap_in_chars='"', replace_with_whitespace='a') == '"my_v r"'
+
+def test_attribute_access():
+    class Dummy:
+        attr_name = 1
+    d = Dummy()
+    assert nameof(d.attr_name, replace_with_whitespace='_') == 'attr name'
+    assert nameof(d.attr_name, wrap_in_chars='`', replace_with_whitespace='_') == '`attr name`'
+    assert nameof(d.attr_name, replace_with_whitespace='*') == 'attr_name'
+    assert nameof(d.attr_name, replace_with_whitespace='a') == ' ttr_n me'
+    assert nameof(d.attr_name, wrap_in_chars='`', replace_with_whitespace=['a', '_']) == "` ttr n me`"
+    
+    
+def run_all_tests():
+    current_module = sys.modules[__name__]
+    test_functions = [
+        getattr(current_module, name)
+        for name in dir(current_module)
+        if name.startswith("test_") and callable(getattr(current_module, name))
+    ]
+    for test_func in test_functions:
+        test_func()
+        
+    print("All tests passed.")
+
+
+if __name__ == "__main__":
+    run_all_tests()

tests/nameof_test.py

@@ -1,5 +1,8 @@
 if True:
-    import os; os.environ["nameof_test"] = "True"
+    import sys, os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+    os.environ["nameof_test"] = "True"
+    
 from nameof import nameof
 import sys