Programmer Humor @lemmy.ml raldone01 @lemmy.world 1w ago

Using comments as arguments in python.

Python allows programmers to pass additional arguments to functions via comments. Now armed with this knowledge head out and spread it to all code bases.

Feel free to use the code I wrote in your projects.

Link to the source code: https://github.com/raldone01/python_lessons_py/blob/v2.0.0/lesson_0_comments.ipynb

Image transcription:

# First we have to import comment_arguments from arglib
# Sadly arglib is not yet a standard library.
from arglib import comment_arguments


def add(*args, **kwargs):
    c_args, c_kwargs = comment_arguments()
    return sum([int(i) for i in args + c_args])


# Go ahead and change the comments.
# See how they are used as arguments.

result = add()  # 1, 2
print(result)
# comment arguments can be combined with normal function arguments
result = add(1, 2)  # 3, 4
print(result)

Output:

3
10

This is version v2.0.0 of the post: https://github.com/raldone01/python_lessons_py/tree/v2.0.0

Note:

v1.0.0 of the post can be found here: https://github.com/raldone01/python_lessons_py/tree/v1.0.0

Choosing lib as the name for my module was a bit devious. I did it because I thought if I am creating something cursed why not go all the way?

Regarding misinformation:

I thought simply posting this in programmer humor was enough. Anyways, the techniques shown here are not yet regarded best practice. Decide carefully if you want to apply the shown concepts in your own code bases.

93 comments

Thanks, I hate it.
Why is this a thing
- Because whoever wrote this went to great lengths to make it work. It's by no means a feature of python. It's a feature of their code.
This is an affront to nature. Comments shouldn't even make it past the scanner.
This is heresy.
I assume the people freaking out about how dumb python is didn't bother to read the code and have never coded in python in their life, because the behavior here is totally reasonable. Python doesn't parse comments normally, which is what you'd expect, but if you tell it to read the raw source code and then parse the raw source code for the comments specifically, of course it does.

You would never, ever accidentally do this.

...you'd also never, ever do it on purpose.
- yeah frankly this post is borderline misinformation, they specifically import a library to read comments as arguments, it's like redefining keywords in C and complaining about C being dumb
  
  I'm going to say it just is misinformation, if that's what "lib" is here.
I fucking hate this, thanks OP
- How do I delete this part of the python documentation?
I hate this shit being routinely used in PHP. Symfony uses those functional comments for routing, essentially scanning every controller file as text on every visit, to gather the url patterns above functions. Laravel uses Reflection, which is functionally the same thing, to provide arguments to controller functions. Also, kind of related, the project I'm working now has few functions that use backtrace to return different results based on where they are called from. It is indeed very cursed and I'm ripping out any usages of them whenever I see one.
- Comment Annotations were a nessecary thing as php did not support a native way to do it. However, since php 8, there is now native attributes.
They chose violence.
bro what we are devolving
This is some javascript level shit
- It's actually kind of nice to see this as a JS developer.
  
  Not like, "Oh wow this is neat!"
  
  But like, "Finally the golden child, Python, also has some fucked up shit"
The best language is complete, succinct, orderly and clear. And never adds a single goddamn thing ever.
That's quite cool. But I'm not sure what's the use case for it.
- To make bugs less traceable, I guess.
TMI 😢
IMO comments should never ever be parsed under any circumstances but I probably don't know enough to really speak on this
- Can we just clarify that you mean that comments should never be parsed by the language engine. There are valid annotation systems, but the goal is alway to ensure that one passable can never impact the other.
  
  Imagine if here a comment could create a syntax error! This is even worse for runtime scripting languages like python.
  
  Sure, but let's just clarify that this is someone going out of their way to create this problem, using Python's ability to read it's own code.
  
  Basically, you can load any text file, including a source code file, and do whatever you want with it.
  
  So, a function can be written that finds out whatever's calling it, reads that file, parses the comments, and uses them as values. This can also be done with introspection, using the same mechanism that displays tracebacks.
- This isn't standard python. lib is not in the standard library. Python also doesn't have any special variables where it stores comments, other than __doc__ which stores a docstring. If I had to guess, add is reading the file/REPL via __file__.
  
  Is __doc__ storing a comment or just a text string?
- Comments should be removed before shipping.
  
  Python is an interpreted language but for a compiled language absolutely (and obviously).
  
  Well now that causes breakage two dependencies down the line. Good luck with that. 😅
- Ignoring lint issues comes to mind as an at least somewhat reasonable use case.
- One case where I find it useful, tho it operates in a more limited way, is code in block blocks within code comments in Rust, which are also printed out in the generated documentation. They essentially get ran as part of your unit tests. This is great for making sure that, eg, your examples left in code comments actually work, especially if they’re written in a way that functions like a unit test.
- +1 to that!
- Some languages use the comments to generate documentation. Something like
  
  // function to add two numbers func Add(num1 int, num2 int)
- No, your intuition is correct, this is extremely cursed.
- Seen in a code review (paraphrased):
  
  "Why does this break when you add comments in the middle?"
  
  Why would python even expose the current line number? What’s it useful for?
  
  That's horrible. Every sane person would filter out lines containing comments to find the correct index.
- The add function in the example above probably traverses the call stack to see what line of the script is currently being executed by the interpreter, then reads in that line in the original script, parses the comment, and subs in the values in the function call.
  
  This functionality exists so when you get a traceback you can see what line of code triggered it in the error message
- It's quite useful to parse comments and generate documentation from them, either as plain old hypertext or in your editor with LSP.
  
  That sounds fine if you have something reading the file independently. But the actual executable code should not be able to access its own comments.
That's disgusting
checks the community to make sure I'm in programmer humor

Yeah that checks out
- You know that this is acutally working right??? 😊
  
  Yup, just one of those posts that could of course work in either
Thank you, I hate it
Implementation of the add() function is here: https://github.com/raldone01/python_lessons_py/blob/main/lib.py
- It is now directly in the notebook in the latest version: https://github.com/raldone01/python_lessons_py/blob/v2.0.0/lesson_0_comments.ipynb
- Yup, the function actually goes and finds the code that calls it and parses the comment.
  
  Disgusting.
This does not actually work, right? Right?
- they have to import a separate library to do this, it's not a part of standard python, and this post is basically just misinformation
- The add() function (that is available in the source code) basically uses some built in debugging tools to find out where in the code the function is called, and then parses the comment from the file and uses it for adding stuff.
  
  I’ve never tried (becuse why would you…) but something similar can probably be built in any interpreted language
  
  It’s not something Python does by design
  
  Thanks :) ! Could you tell me what use case/purpose such function can have from a dev perspective?
- Anakin:
  
  Anakin:
Every day further from god's light etc...
As if I needed more reasons to start away from python
- You can so stupid shit in any language. I admit Python doesn't exactly make it difficult. A bit like JS, but different.
- Do you stay away from C++ too? You can do this there too
  
  https://en.cppreference.com/w/cpp/utility/source_location/line
  
  Being able to get the line number is very different from comments being parsed.
  
  Edit: didn't realize this was custom code built to be cursed.
I feel sick
What? There is no lib module.

$ python3.13 -c 'import lib' Traceback (most recent call last): File "<string>", line 1, in <module> import lib ModuleNotFoundError: No module named 'lib' $
- I have updated the repository. Just clone it.
  
  The lib module was written by me. Actual implementation code is here: https://github.com/raldone01/python_lessons_py/blob/v2.0.0/arglib.py
- OP wrote this add() function and has provided their own lib module in the source code.
  
  Oh, so it’s not Python that’s cursed.
  
  One of Python’s design philosophies is—or at least was—“we are all consenting adults here.” If you really want to turn Python into Brainfuck, the interpreter isn’t going to stop you.
Why, just why
- because OP wanted upvotes, this isn't actually part of python in any way, it's using a custom library to do it.
  
  Yeah. This post was made to show off something cursed I created.
  
  I have already updated the repo to make it more obvious this is not standard Python. I will do the same with the post.

Hmm, works in php as well!

function add(): float
{
    $trace = debug_backtrace();
    $file = $trace[0]['file'];
    $line = $trace[0]['line'];

    $content = file($file);
    $lineContent = trim($content[$line - 1]);
    $ast = token_get_all("<?php\n{$lineContent}");

    $args = [];
    foreach ($ast as $token) {
        if (!is_array($token)) {
            continue;
        }
        if ($token[0] !== T_COMMENT) {
            continue;
        }

        $commentContent = $token[1];
        if (str_starts_with($commentContent, '#')) {
            $commentContent = substr($commentContent, 1);
        } else {
            $commentContent = substr($commentContent, 2);
        }
        $commentContent = trim($commentContent);
        $commentContent = preg_replace("@\s+@", " ", $commentContent);
        $args = explode(" ", $commentContent);
        $args = array_map(function (string $arg) {
            if (!is_numeric($arg)) {
                throw new InvalidArgumentException('Argument must be a number');
            }

            return str_contains($arg, '.') ? (float) $arg : (int) $arg;
        }, $args);
        break;
    }

    return array_sum($args);
}


echo add(); // 1 2 3
echo add(); // 7 8 9

Love this. I am toying with an idea of how to accomplish this in rust.

use std::fs;

fn add_from_comment(file: &str, line: u32) -> f64 {
    let source = fs::read_to_string(file).expect("Failed to read source file");

    let source_line = source.lines().nth((line - 1) as usize).expect("Line not found");

    if let Some(comment_start) = source_line.find("//") {
        let comment = &source_line[comment_start + 2..].trim();
        let numbers: Vec<f64> = comment
            .split_whitespace()
            .map(|num| num.parse::<f64>().expect("Invalid number in comment"))
            .collect();

        return numbers.iter().sum();
    }

    0.0
}

macro_rules! add {
    () => {
        add_from_comment(file!(), line!())
    };
}

fn main() {
    let result = add!(); // 7 8 9
    println!("{}", result); // Outputs: 24
    
    let result2 = add!(); // 1 4 3
    println!("{}", result2); // outputs 8
}

Makes sence if u think about it. We use comments as docstrings that the interpreter has an understanding of. Python lets u fuck with its internals (at least in an immutable manner) so why not fuck with comments.

93 comments