Add add-maintainer.py script
v2 cover Add add-maintainer.py script
When pushing patches to upstream, the get_maintainer.pl script is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.
The add-maintainer.py script adds maintainers (and mailing lists) to a patch, editing it in-place.
Thanks to Bjorn for being a sounding board to this idea and for his valuable suggestions.
Please try out this script with --verbosity debug for verifying that it's doing "the right thing". I've tested this with a patch series from various subsystems to ensure variety of maintainers and lists output and found it to be doing what it is supposed to do.
I referred to the following links during development of this script:
- https://stackoverflow.com/questions/4427542/how-to-do-sed-like-text-replace-with-python
- https://stackoverflow.com/questions/4146009/python-get-list-indexes-using-regular-expression
- https://stackoverflow.com/questions/10507230/insert-line-at-middle-of-file-with-python
v1 -> v2:
- Added set-union logic based on Pavan's comments [1] and Bjorn's early suggestion
- Expanded audience and added more mailing lists to get more review comments and feedback
[1] https://lore.kernel.org/lkml/[email protected]/
Guru Das Srinagesh (1):
scripts: Add add-maintainer.py
scripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100755 scripts/add-maintainer.py
Signature · 7 lines
2.40.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v2 1/1 scripts: Add add-maintainer.py
This script runs get_maintainer.py on a given patch file and adds its output to the patch file in place with the appropriate email headers "To: " or "Cc: " as the case may be. These new headers are added after the "From: " line in the patch.
Currently, for a single patch, maintainers are added as "To: ", mailing lists and all other roles are addded as "Cc: ".
For a series of patches, however, a set-union scheme is employed in order to solve the all-too-common problem of sending subsets of a patch series to some lists, which results in important pieces of context such as the cover letter being dropped. This scheme is as follows:
- Create set-union of all mailing lists corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all other roles corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all maintainers from all patches and use this to do the following per patch:
- add only that specific patch's maintainers as "To: ", and
- the other maintainers from the other patches as "Cc: "
Please note that patch files that don't have any "Maintainer"s explicitly listed in their get_maintainer.pl output will not have any "To: " entries added to them; developers are expected to manually make edits to the added entries in such cases to convert some "Cc: " entries to "To: " as desired.
The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
--- scripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100755 scripts/add-maintainer.py
scripts/add-maintainer.py new file +113 -0
@@ -0,0 +1,113 @@ +#! /usr/bin/env python3 + +import argparse +import logging +import os +import sys +import subprocess +import re + +def gather_maintainers_of_file(patch_file): + all_entities_of_patch = dict() + + # Run get_maintainer.pl on patch file + logging.info("GET: Patch: {}".format(os.path.basename(patch_file))) + cmd = ['scripts/get_maintainer.pl'] + cmd.extend([patch_file]) + p = subprocess.run(cmd, stdout=subprocess.PIPE, check=True) + logging.debug("\n{}".format(p.stdout.decode())) + + entries = p.stdout.decode().splitlines() + + maintainers = [] + lists = [] + others = [] + + for entry in entries: + entity = entry.split('(')[0].strip() + if "maintainer" in entry: + maintainers.append(entity) + elif "list" in entry: + lists.append(entity) + else: + others.append(entity) + + all_entities_of_patch["maintainers"] = set(maintainers) + all_entities_of_patch["lists"] = set(lists) + all_entities_of_patch["others"] = set(others) + + return all_entities_of_patch + +def add_maintainers_to_file(patch_file, entities_per_file, all_entities_union): + logging.info("ADD: Patch: {}".format(os.path.basename(patch_file))) + + # For each patch: + # - Add all lists from all patches in series as Cc: + # - Add all others from all patches in series as Cc: + # - Add only maintainers of that patch as To: + # - Add maintainers of other patches in series as Cc: + + lists = list(all_entities_union["all_lists"]) + others = list(all_entities_union["all_others"]) + file_maintainers = all_entities_union["all_maintainers"].intersection(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + other_maintainers = all_entities_union["all_maintainers"].difference(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + + # Specify email headers appropriately + cc_lists = ["Cc: " + l for l in lists] + cc_others = ["Cc: " + o for o in others] + to_maintainers = ["To: " + m for m in file_maintainers] + cc_maintainers = ["Cc: " + om for om in other_maintainers] + logging.debug("Cc Lists:\n{}".format('\n'.join(cc_lists))) + logging.debug("Cc Others:\n{}".format('\n'.join(cc_others))) + logging.debug("Cc Maintainers:\n{}".format('\n'.join(cc_maintainers) or None)) + logging.debug("To Maintainers:\n{}\n".format('\n'.join(to_maintainers) or None)) + + # Edit patch file in place to add maintainers + with open(patch_file, "r") as pf: + lines = pf.readlines() + + from_line = [i for i, line in enumerate(lines) if re.search("From: ", line)] + if len(from_line) > 1: + logging.error("Only one From: line is allowed in a patch file") + sys.exit(1) + + next_line_after_from = from_line[0] + 1 + + for o in cc_others: + lines.insert(next_line_after_from, o + "\n") + for l in cc_lists: + lines.insert(next_line_after_from, l + "\n") + for om in cc_maintainers: + lines.insert(next_line_after_from, om + "\n") + for m in to_maintainers: + lines.insert(next_line_after_from, m + "\n") + + with open(patch_file, "w") as pf: + pf.writelines(lines) + +def main(): + parser = argparse.ArgumentParser(description='Add the respective maintainers and mailing lists to patch files') + parser.add_argument('patches', nargs='*', help="One or more patch files") + parser.add_argument('--verbosity', choices=['debug', 'info', 'error'], default='error', help="Verbosity level of script output") + args = parser.parse_args() + + logging.basicConfig(level=args.verbosity.upper(), format='%(levelname)s: %(message)s') + + entities_per_file = dict() + + for patch in args.patches: + entities_per_file[os.path.basename(patch)] = gather_maintainers_of_file(patch) + + all_entities_union = {"all_maintainers": set(), "all_lists": set(), "all_others": set()} + for patch in args.patches: + all_entities_union["all_maintainers"] = all_entities_union["all_maintainers"].union(entities_per_file[os.path.basename(patch)].get("maintainers")) + all_entities_union["all_lists"] = all_entities_union["all_lists"].union(entities_per_file[os.path.basename(patch)].get("lists")) + all_entities_union["all_others"] = all_entities_union["all_others"].union(entities_per_file[os.path.basename(patch)].get("others")) + + for patch in args.patches: + add_maintainers_to_file(patch, entities_per_file, all_entities_union) + + logging.info("Maintainers added to all patch files successfully") + +if __name__ == "__main__": + main()
Signature · 7 lines
2.40.0 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
Quoted 8 lines · Guru Das Srinagesh
This script runs
get_maintainer.pyon a given patch file and adds its output to the patch file in place with the appropriate email headers "To: " or "Cc: " as the case may be. These new headers are added after the "From: " line in the patch.Currently, for a single patch, maintainers are added as "To: ", mailing lists and all other roles are addded as "Cc: ".
Quoted 13 lines
For a series of patches, however, a set-union scheme is employed in order to solve the all-too-common problem of sending subsets of a patch series to some lists, which results in important pieces of context such as the cover letter being dropped. This scheme is as follows:
- Create set-union of all mailing lists corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all other roles corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all maintainers from all patches and use this to do the following per patch:
- add only that specific patch's maintainers as "To: ", and
- the other maintainers from the other patches as "Cc: "
Thanks. I have tested this logic by running this script on two patches from different subsystems. It does what it says.
Quoted 6 lines
Please note that patch files that don't have any "Maintainer"s explicitly listed in their
get_maintainer.ploutput will not have any "To: " entries added to them; developers are expected to manually make edits to the added entries in such cases to convert some "Cc: " entries to "To: " as desired.
Quoted 9 lines
The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
Signed-off-by Guru Das Srinagesh <[email protected]>--- scripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100755 scripts/add-maintainer.py
Do you need to update MAINTAINERS file?
Quoted 69 lines
scripts/add-maintainer.py new file +63
-0@@ -0,0 +1,113 @@ +#! /usr/bin/env python3 + +import argparse +import logging +import os +import sys +import subprocess +import re + +def gather_maintainers_of_file(patch_file): + all_entities_of_patch = dict() + + # Run get_maintainer.pl on patch file + logging.info("GET: Patch: {}".format(os.path.basename(patch_file))) + cmd = ['scripts/get_maintainer.pl'] + cmd.extend([patch_file]) + p = subprocess.run(cmd, stdout=subprocess.PIPE, check=True) + logging.debug("\n{}".format(p.stdout.decode())) + + entries = p.stdout.decode().splitlines() + + maintainers = [] + lists = [] + others = [] + + for entry in entries: + entity = entry.split('(')[0].strip() + if "maintainer" in entry: + maintainers.append(entity) + elif "list" in entry: + lists.append(entity) + else: + others.append(entity) + + all_entities_of_patch["maintainers"] = set(maintainers) + all_entities_of_patch["lists"] = set(lists) + all_entities_of_patch["others"] = set(others) + + return all_entities_of_patch + +def add_maintainers_to_file(patch_file, entities_per_file, all_entities_union): + logging.info("ADD: Patch: {}".format(os.path.basename(patch_file))) + + # For each patch: + # - Add all lists from all patches in series as Cc: + # - Add all others from all patches in series as Cc: + # - Add only maintainers of that patch as To: + # - Add maintainers of other patches in series as Cc: + + lists = list(all_entities_union["all_lists"]) + others = list(all_entities_union["all_others"]) + file_maintainers = all_entities_union["all_maintainers"].intersection(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + other_maintainers = all_entities_union["all_maintainers"].difference(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + + # Specify email headers appropriately + cc_lists = ["Cc: " + l for l in lists] + cc_others = ["Cc: " + o for o in others] + to_maintainers = ["To: " + m for m in file_maintainers] + cc_maintainers = ["Cc: " + om for om in other_maintainers] + logging.debug("Cc Lists:\n{}".format('\n'.join(cc_lists))) + logging.debug("Cc Others:\n{}".format('\n'.join(cc_others))) + logging.debug("Cc Maintainers:\n{}".format('\n'.join(cc_maintainers) or None)) + logging.debug("To Maintainers:\n{}\n".format('\n'.join(to_maintainers) or None))
scripts/add-maintainer.py line 73
Quoted 10 lines
scripts/add-maintainer.py new file +10
-0+ + # Edit patch file in place to add maintainers + with open(patch_file, "r") as pf: + lines = pf.readlines() + + from_line = [i for i, line in enumerate(lines) if re.search("From: ", line)] + if len(from_line) > 1: + logging.error("Only one From: line is allowed in a patch file") + sys.exit(1) +
Few minor issues from my limited testing:
- It is very unlikely, but for whatever reason if "From:" is present in the patch (commit description), this script bails out. Pls try running this script on the current patch. May be you should also look for a proper email address on this line.
- When this script is run on a file (get_maintainer.pl allows this), it throws a runtime warning. may be good to bail out much earlier.
- When this script runs on a non-existent file, it does not bail out early.
Thanks,
Pavan
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
Quoted 23 lines · Pavan Kondeti
Quoted 8 lines · Guru Das Srinagesh
This script runs
get_maintainer.pyon a given patch file and adds its output to the patch file in place with the appropriate email headers "To: " or "Cc: " as the case may be. These new headers are added after the "From: " line in the patch.Currently, for a single patch, maintainers are added as "To: ", mailing lists and all other roles are addded as "Cc: ".
Quoted 13 lines
For a series of patches, however, a set-union scheme is employed in order to solve the all-too-common problem of sending subsets of a patch series to some lists, which results in important pieces of context such as the cover letter being dropped. This scheme is as follows:
- Create set-union of all mailing lists corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all other roles corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all maintainers from all patches and use this to do the following per patch:
- add only that specific patch's maintainers as "To: ", and
- the other maintainers from the other patches as "Cc: "
Quoted 2 lines
Thanks. I have tested this logic by running this script on two patches from different subsystems. It does what it says.
Thanks for testing this v2!
Quoted 10 lines
Quoted 10 lines
Please note that patch files that don't have any "Maintainer"s explicitly listed in their
get_maintainer.ploutput will not have any "To: " entries added to them; developers are expected to manually make edits to the added entries in such cases to convert some "Cc: " entries to "To: " as desired.The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
Quoted 8 lines
Quoted 6 lines
Signed-off-by Guru Das Srinagesh <[email protected]>--- scripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100755 scripts/add-maintainer.pyDo you need to update
MAINTAINERSfile?
Noted.
Quoted 1 line
[...]
Quoted 8 lines
Few minor issues from my limited testing:
- It is very unlikely, but for whatever reason if "From:" is present in the patch (commit description), this script bails out. Pls try running this script on the current patch. May be you should also look for a proper email address on this line.
Quoted 5 lines
- When this script is run on a file (get_maintainer.pl allows this), it throws a runtime warning. may be good to bail out much earlier.
- When this script runs on a non-existent file, it does not bail out early.
Will fix these.
Thank you.
Guru Das.
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
In reply to Guru Das SrinageshHi Guru,
thanks for your patch! I really to appreciate the discussion about how to lower the burden for first-time contributors; might you consider cc-ing [email protected] when sending v3?
Some additional thoughts to the feedback from Pavan:
Quoted 7 lines · On Thu, Aug 03, 2023 at 01:23:16AM -0700 Guru Das Srinagesh wrote:
This script runs
get_maintainer.pyon a given patch file and adds its output to the patch file in place with the appropriate email headers "To: " or "Cc: " as the case may be. These new headers are added after the "From: " line in the patch.Currently, for a single patch, maintainers are added as "To: ", mailing lists and all other roles are addded as "Cc: ".
typo: addded -> added
Quoted 14 lines
For a series of patches, however, a set-union scheme is employed in order to solve the all-too-common problem of sending subsets of a patch series to some lists, which results in important pieces of context such as the cover letter being dropped. This scheme is as follows:
- Create set-union of all mailing lists corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all other roles corresponding to all patches and add this to all patches as "Cc: "
- Create set-union of all maintainers from all patches and use this to do the following per patch:
- add only that specific patch's maintainers as "To: ", and
- the other maintainers from the other patches as "Cc: "
Quoted 8 lines
Please note that patch files that don't have any "Maintainer"s explicitly listed in their
get_maintainer.ploutput will not have any "To: " entries added to them; developers are expected to manually make edits to the added entries in such cases to convert some "Cc: " entries to "To: " as desired.The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
IMO, it would be nice to see which addresses are effectively added, e.g. comparable to the output of git send-email. Perhaps somehing like:
$ scripts/add-maintainer.py *.patch 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'To: Guru Das Srinagesh <[email protected]>' (maintainer) 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'Cc: [email protected]' (list)
Perhaps verbosity should then be configurable.
Quoted 72 lines
Signed-off-by Guru Das Srinagesh <[email protected]>--- scripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100755 scripts/add-maintainer.pyscripts/add-maintainer.py new file +59
-0@@ -0,0 +1,113 @@ +#! /usr/bin/env python3 + +import argparse +import logging +import os +import sys +import subprocess +import re + +def gather_maintainers_of_file(patch_file): + all_entities_of_patch = dict() + + # Run get_maintainer.pl on patch file + logging.info("GET: Patch: {}".format(os.path.basename(patch_file))) + cmd = ['scripts/get_maintainer.pl'] + cmd.extend([patch_file]) + p = subprocess.run(cmd, stdout=subprocess.PIPE, check=True) + logging.debug("\n{}".format(p.stdout.decode())) + + entries = p.stdout.decode().splitlines() + + maintainers = [] + lists = [] + others = [] + + for entry in entries: + entity = entry.split('(')[0].strip() + if "maintainer" in entry: + maintainers.append(entity) + elif "list" in entry: + lists.append(entity) + else: + others.append(entity) + + all_entities_of_patch["maintainers"] = set(maintainers) + all_entities_of_patch["lists"] = set(lists) + all_entities_of_patch["others"] = set(others) + + return all_entities_of_patch + +def add_maintainers_to_file(patch_file, entities_per_file, all_entities_union): + logging.info("ADD: Patch: {}".format(os.path.basename(patch_file))) + + # For each patch: + # - Add all lists from all patches in series as Cc: + # - Add all others from all patches in series as Cc: + # - Add only maintainers of that patch as To: + # - Add maintainers of other patches in series as Cc: + + lists = list(all_entities_union["all_lists"]) + others = list(all_entities_union["all_others"]) + file_maintainers = all_entities_union["all_maintainers"].intersection(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + other_maintainers = all_entities_union["all_maintainers"].difference(entities_per_file[os.path.basename(patch_file)].get("maintainers")) + + # Specify email headers appropriately + cc_lists = ["Cc: " + l for l in lists] + cc_others = ["Cc: " + o for o in others] + to_maintainers = ["To: " + m for m in file_maintainers] + cc_maintainers = ["Cc: " + om for om in other_maintainers]
scripts/add-maintainer.py line 69
Quoted 10 lines
scripts/add-maintainer.py new file +10
-0+ logging.debug("Cc Lists:\n{}".format('\n'.join(cc_lists))) + logging.debug("Cc Others:\n{}".format('\n'.join(cc_others))) + logging.debug("Cc Maintainers:\n{}".format('\n'.join(cc_maintainers) or None)) + logging.debug("To Maintainers:\n{}\n".format('\n'.join(to_maintainers) or None)) + + # Edit patch file in place to add maintainers + with open(patch_file, "r") as pf: + lines = pf.readlines() + + from_line = [i for i, line in enumerate(lines) if re.search("From: ", line)]
(extending Pavan comment on "From:" handling:)
Please use something like line.startswith("From:"), otherwise this catches any "From: " in the whole file (that's the reason why add-maintainer.py fails on this very patch). Actually, you only want to search through the patch (mail) header block, not through the whole commit msg and the patch body.
Quoted 11 lines
scripts/add-maintainer.py new file +11
-0+ if len(from_line) > 1: + logging.error("Only one From: line is allowed in a patch file") + sys.exit(1) + + next_line_after_from = from_line[0] + 1 + + for o in cc_others: + lines.insert(next_line_after_from, o + "\n") + for l in cc_lists: + lines.insert(next_line_after_from, l + "\n") + for om in cc_maintainers:
scripts/add-maintainer.py line 90
Quoted 10 lines
scripts/add-maintainer.py new file +10
-0+ lines.insert(next_line_after_from, om + "\n") + for m in to_maintainers: + lines.insert(next_line_after_from, m + "\n") + + with open(patch_file, "w") as pf: + pf.writelines(lines) + +def main(): + parser = argparse.ArgumentParser(description='Add the respective maintainers and mailing lists to patch files') + parser.add_argument('patches', nargs='*', help="One or more patch files")
nargs='+' is one or more
nargs='*' is zero, one or more
Quoted 25 lines
scripts/add-maintainer.py new file +23
-0+ parser.add_argument('--verbosity', choices=['debug', 'info', 'error'], default='error', help="Verbosity level of script output") + args = parser.parse_args() + + logging.basicConfig(level=args.verbosity.upper(), format='%(levelname)s: %(message)s') + + entities_per_file = dict() + + for patch in args.patches: + entities_per_file[os.path.basename(patch)] = gather_maintainers_of_file(patch) + + all_entities_union = {"all_maintainers": set(), "all_lists": set(), "all_others": set()} + for patch in args.patches: + all_entities_union["all_maintainers"] = all_entities_union["all_maintainers"].union(entities_per_file[os.path.basename(patch)].get("maintainers")) + all_entities_union["all_lists"] = all_entities_union["all_lists"].union(entities_per_file[os.path.basename(patch)].get("lists")) + all_entities_union["all_others"] = all_entities_union["all_others"].union(entities_per_file[os.path.basename(patch)].get("others")) + + for patch in args.patches: + add_maintainers_to_file(patch, entities_per_file, all_entities_union) + + logging.info("Maintainers added to all patch files successfully") + +if __name__ == "__main__": + main()Signature · 1 line
2.40.0
While testing, I thought that adding addresses without filtering-out duplicates was odd; but as git-send-email does the unique filtering, it doesn't matter.
For my own workflow, I would rather prefer a git-send-email wrapper, similiar to the shell alias Krzysztof shared (but I like 'b4' even more). Do you have some thoughts about a "smoother" workflow integration? The best one I could come up with is
ln -sr scripts/add-maintainer.py .git/hooks/sendemail-validate git config --add --local sendemail.validate true
.
Kind regards,
Nicolas
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
Hi Nicolas,
Thank you so much for reviewing this script!
Quoted 5 lines · Nicolas Schier
Hi Guru,
thanks for your patch! I really to appreciate the discussion about how to lower the burden for first-time contributors; might you consider cc-ing [email protected] when sending v3?
Certainly, will do. The archives for this list are very interesting to read!
[...]
Quoted 8 lines
Some additional thoughts to the feedback from Pavan:
Quoted 5 lines · On Thu, Aug 03, 2023 at 01:23:16AM -0700 Guru Das Srinagesh wrote:
This script runs
get_maintainer.pyon a given patch file and adds its output to the patch file in place with the appropriate email headers "To: " or "Cc: " as the case may be. These new headers are added after the "From: " line in the patch.
Quoted 4 lines
Quoted 2 lines
Currently, for a single patch, maintainers are added as "To: ", mailing lists and all other roles are addded as "Cc: ".
typo: addded -> added
Done.
Quoted 11 lines
Quoted 2 lines
The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
IMO, it would be nice to see which addresses are effectively added, e.g. comparable to the output of git send-email. Perhaps somehing like:
$ scripts/add-maintainer.py *.patch 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'To: Guru Das Srinagesh <[email protected]>' (maintainer) 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'Cc: [email protected]' (list)Perhaps verbosity should then be configurable.
Yes, this is already implemented - you just need to pass "--verbosity debug" to the script. Example based on commit 8648aeb5d7b7 ("power: supply: add Qualcomm PMI8998 SMB2 Charger driver") converted to a patch:
$ ./scripts/add-maintainer.py --verbosity debug $u/upstream/patches/test2/0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch
INFO: GET: Patch: 0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch
DEBUG:
Sebastian Reichel <[email protected]> (maintainer:POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS)
Andy Gross <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT)
Bjorn Andersson <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT)
Konrad Dybcio <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT)
Nathan Chancellor <[email protected]> (supporter:CLANG/LLVM BUILD SUPPORT)
Nick Desaulniers <[email protected]> (supporter:CLANG/LLVM BUILD SUPPORT)
Tom Rix <[email protected]> (reviewer:CLANG/LLVM BUILD SUPPORT)
[email protected] (open list)
[email protected] (open list:POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS)
[email protected] (open list:ARM/QUALCOMM SUPPORT)
[email protected] (open list:CLANG/LLVM BUILD SUPPORT) INFO: ADD: Patch: 0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch
DEBUG: Cc Lists:
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
DEBUG: Cc Others:
Cc: Tom Rix <[email protected]>
Cc: Nick Desaulniers <[email protected]>
Cc: Nathan Chancellor <[email protected]>
DEBUG: Cc Maintainers:
None
DEBUG: To Maintainers:
To: Sebastian Reichel <[email protected]>
To: Andy Gross <[email protected]>
To: Bjorn Andersson <[email protected]>
To: Konrad Dybcio <[email protected]>
INFO: Maintainers added to all patch files successfully
The first "GET:" output prints the output of get_maintainer.pl verbatim, and the "ADD:" output shows what exactly is getting added to that patch. Hope this is what you were expecting. Please let me know if you'd prefer any other modifications to this debug output.
[...]
Quoted 10 lines
scripts/add-maintainer.py line 69
Quoted 7 lines
scripts/add-maintainer.py new file +7
-0+def add_maintainers_to_file(patch_file, entities_per_file, all_entities_union): + logging.info("ADD: Patch: {}".format(os.path.basename(patch_file))) + # Edit patch file in place to add maintainers + with open(patch_file, "r") as pf: + lines = pf.readlines() + + from_line = [i for i, line in enumerate(lines) if re.search("From: ", line)](extending Pavan comment on "From:" handling:)
Quoted 4 lines
Please use something like
line.startswith("From:"), otherwise this catches any "From: " in the whole file (that's the reason whyadd-maintainer.pyfails on this very patch). Actually, you only want to search through the patch (mail) header block, not through the whole commit msg and the patch body.
I see the issue. I will use a simple regex to search for the first occurrence of a valid "From: <email address>" and stop there.
[...]
Quoted 6 lines
scripts/add-maintainer.py line 90
Quoted 3 lines
scripts/add-maintainer.py new file +3
-0+def main(): + parser = argparse.ArgumentParser(description='Add the respective maintainers and mailing lists to patch files') + parser.add_argument('patches', nargs='*', help="One or more patch files")nargs='+' is one or more
nargs='*' is zero, one or more
Thank you - fixed.
Quoted 2 lines
While testing, I thought that adding addresses without filtering-out duplicates was odd; but as git-send-email does the unique filtering, it doesn't matter.
Since I'm using set() in this script, the uniqueness is guaranteed here as well - there won't be any duplicates.
Quoted 7 lines
For my own workflow, I would rather prefer a git-send-email wrapper, similiar to the shell alias Krzysztof shared (but I like 'b4' even more). Do you have some thoughts about a "smoother" workflow integration? The best one I could come up with is
ln -sr
scripts/add-maintainer.py.git/hooks/sendemail-validate git config --add --local sendemail.validate true
This looks really useful! I haven't explored git hooks enough to comment on this though, sorry.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
On Thu 24 Aug 2023 14:44:36 GMT, Guru Das Srinagesh wrote:
[...]
Quoted 49 lines
Quoted 11 lines
Quoted 2 lines
The script is quiet by default (only prints errors) and its verbosity can be adjusted via an optional parameter.
IMO, it would be nice to see which addresses are effectively added, e.g. comparable to the output of git send-email. Perhaps somehing like:
$ scripts/add-maintainer.py *.patch 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'To: Guru Das Srinagesh <[email protected]>' (maintainer) 0001-fixup-scripts-Add-add-maintainer.py.patch: Adding 'Cc: [email protected]' (list)Perhaps verbosity should then be configurable.
Yes, this is already implemented - you just need to pass "--verbosity debug" to the script. Example based on commit
8648aeb5d7b7("power: supply: add Qualcomm PMI8998 SMB2 Charger driver") converted to a patch:$ ./scripts/add-maintainer.py --verbosity debug $u/upstream/patches/test2/0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch INFO: GET: Patch: 0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch DEBUG: Sebastian Reichel <[email protected]> (maintainer:POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS) Andy Gross <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT) Bjorn Andersson <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT) Konrad Dybcio <[email protected]> (maintainer:ARM/QUALCOMM SUPPORT) Nathan Chancellor <[email protected]> (supporter:CLANG/LLVM BUILD SUPPORT) Nick Desaulniers <[email protected]> (supporter:CLANG/LLVM BUILD SUPPORT) Tom Rix <[email protected]> (reviewer:CLANG/LLVM BUILD SUPPORT) [email protected] (open list) [email protected] (open list:POWER SUPPLY CLASS/SUBSYSTEM and DRIVERS) [email protected] (open list:ARM/QUALCOMM SUPPORT) [email protected] (open list:CLANG/LLVM BUILD SUPPORT)INFO: ADD: Patch: 0001-power-supply-add-Qualcomm-PMI8998-SMB2-Charger-drive.patch
DEBUG: Cc Lists:
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
DEBUG: Cc Others:
Cc: Tom Rix <[email protected]>
Cc: Nick Desaulniers <[email protected]>
Cc: Nathan Chancellor <[email protected]>
DEBUG: Cc Maintainers:
None
DEBUG: To Maintainers:
To: Sebastian Reichel <[email protected]>
To: Andy Gross <[email protected]>
To: Bjorn Andersson <[email protected]>
To: Konrad Dybcio <[email protected]>
Quoted 6 lines
INFO: Maintainers added to all patch files successfully
The first "GET:" output prints the output of
get_maintainer.plverbatim, and the "ADD:" output shows what exactly is getting added to that patch. Hope this is what you were expecting. Please let me know if you'd prefer any other modifications to this debug output.
ups. I tested with --verbosity=info but not with =debug, therefore I missed it. Sorry for the noise.
[...]
Quoted 5 lines
Quoted 2 lines
While testing, I thought that adding addresses without filtering-out duplicates was odd; but as git-send-email does the unique filtering, it doesn't matter.
Since I'm using
set()in this script, the uniqueness is guaranteed here as well - there won't be any duplicates.
I thought about patch files that already have 'To/Cc' headers (e.g. 'git format-patch --to=... --cc=...' or by running add-maintainer.py multiple times for updating the lists of recipients. The result is a patch file with possible duplicated lines; but as written: it does matter, effectively.
Kind regards,
Nicolas
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
Quoted 4 lines · Nicolas Schier
Quoted 3 lines · Guru Das Srinagesh
Quoted 2 lines
While testing, I thought that adding addresses without filtering-out duplicates was odd; but as git-send-email does the unique filtering, it doesn't matter.
Quoted 8 lines
Quoted 2 lines
Since I'm using
set()in this script, the uniqueness is guaranteed here as well - there won't be any duplicates.I thought about patch files that already have 'To/Cc' headers (e.g. 'git format-patch --to=... --cc=...' or by running
add-maintainer.pymultiple times for updating the lists of recipients. The result is a patch file with possible duplicated lines; but as written: it does matter, effectively.
Sorry, did you mean "does" or "does *not*"?
I'll make sure to test v3 of this script out on patches that have To/Cc already included and also run it multiple times on the same patch (effectively the same thing).
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH v2 1/1] scripts: Add add-maintainer.py
Quoted 8 lines · On Fri, Aug 25, 2023 at 10:00:01AM -0700 Guru Das Srinagesh wrote:
Quoted 7 lines · Nicolas Schier
Quoted 5 lines · Guru Das Srinagesh
Quoted 2 lines
While testing, I thought that adding addresses without filtering-out duplicates was odd; but as git-send-email does the unique filtering, it doesn't matter.
Since I'm using
set()in this script, the uniqueness is guaranteed here as well - there won't be any duplicates.
Quoted 7 lines
Quoted 5 lines
I thought about patch files that already have 'To/Cc' headers (e.g. 'git format-patch --to=... --cc=...' or by running
add-maintainer.pymultiple times for updating the lists of recipients. The result is a patch file with possible duplicated lines; but as written: it does matter, effectively.Sorry, did you mean "does" or "does *not*"?
I'm sorry, "it doe not matter".
Nicolas
Quoted 7 lines
I'll make sure to test v3 of this script out on patches that have To/Cc already included and also run it multiple times on the same patch (effectively the same thing).
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Hi,
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.
FYI the b4 prep command does this:
https://github.com/mricon/b4/blob/e8045d1353165cc065b2f1b180bf1b0846af510e/b4/ez.py#L2055
Perhaps it could be useful to make sure the output is similar ?
So far I've been very satisfied by the output of b4 auto_to_cc.
Thanks,
Neil
Quoted 27 lines
Thanks to Bjorn for being a sounding board to this idea and for his valuable suggestions.
Please try out this script with
--verbosity debugfor verifying that it's doing "the right thing". I've tested this with a patch series from various subsystems to ensure variety of maintainers and lists output and found it to be doing what it is supposed to do.I referred to the following links during development of this script:
- https://stackoverflow.com/questions/4427542/how-to-do-sed-like-text-replace-with-python
- https://stackoverflow.com/questions/4146009/python-get-list-indexes-using-regular-expression
- https://stackoverflow.com/questions/10507230/insert-line-at-middle-of-file-with-pythonv1 -> v2:
- Added set-union logic based on Pavan's comments [1] and Bjorn's early suggestion
- Expanded audience and added more mailing lists to get more review comments and feedback[1] https://lore.kernel.org/lkml/[email protected]/
Guru Das Srinagesh (1):
scripts: Addadd-maintainer.pyscripts/add-maintainer.py | 113 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+)create mode 100755
scripts/add-maintainer.py
Quoted 10 lines · Neil Armstrong
Hi,
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.
Quoted 6 lines
FYI the b4 prep command does this:
https://github.com/mricon/b4/blob/e8045d1353165cc065b2f1b180bf1b0846af510e/b4/ez.py#L2055Perhaps it could be useful to make sure the output is similar ?
So far I've been very satisfied by the output of b4
auto_to_cc.
Thank you - let me check this tool out.
Guru Das.
Quoted 11 lines · Guru Das Srinagesh
Quoted 10 lines · Neil Armstrong
Hi,
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.
Quoted 8 lines
Quoted 6 lines
FYI the b4 prep command does this:
https://github.com/mricon/b4/blob/e8045d1353165cc065b2f1b180bf1b0846af510e/b4/ez.py#L2055Perhaps it could be useful to make sure the output is similar ?
So far I've been very satisfied by the output of b4
auto_to_cc.Thank you - let me check this tool out.
I gave b4 a spin and specifically compared the results of b4 prep --auto-to-cc vs this script. I notice from the code that b4 calls get_maintainer.pl with the following flags:
--nogit --nogit-fallback --nogit-chief-penguins
I can add these to this script too.
And it collects maintainers and lists by passing, respectively, --nol and --nom in two separate calls whereas this script parses the actual roles by making only one call. b4's approach seems cleaner.
The perl script also can provide just the reviewers by passing --nol --nom.
b4 and this script both do:
- Create set-union of all maintainers and all lists from all patches in a series.
- Apply the same addresses to all patches in a series.
The main thing b4 doesn't do (which this script does) is:
- add only that specific patch's maintainers as "To: ", and
- the other maintainers from the other patches as "Cc: "
Overall, b4 seems like a fantastic feature-rich tool for managing and sending patches.
Thank you for sharing the link to the actual code - it was very instructive.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.
Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the b4 tool obviates the need for such a script.
Thank you.
Guru Das.
Quoted 11 lines · Guru Das Srinagesh
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the
b4tool obviates the need for such a script.
I send a bit of patches but I use very simple workflow. It is really simple, so simple, that I was always surprised how people can make their life difficult with some complicated process to send patches... and then obviously skip some maintainers, because of that process.
I almost always feed git send-email with addresses from scripts/get_maintainers.pl. This tool would not bring any benefits to my simple workflow.
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
This tool depends on the command line and shell interface of scripts/get_maintainers.pl which is another reason why it might not be a good idea.
Best regards,
Krzysztof
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Thanks for the comments, Krzysztof.
Quoted 9 lines · Krzysztof Kozlowski
Quoted 8 lines · Guru Das Srinagesh
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.
Quoted 8 lines
Quoted 3 lines
Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the
b4tool obviates the need for such a script.I send a bit of patches but I use very simple workflow. It is really simple, so simple, that I was always surprised how people can make their life difficult with some complicated process to send patches... and then obviously skip some maintainers, because of that process.
Exactly - this script aims to solve precisely that problem. It fills the gap between running get_maintainers.pl and having to manually edit its output to add "To: " and "Cc: " and somehow incorporate it in the body of the patch(es).
With this script, the workflow would be as simple as:
1. Generate patches using git format-patch
2. Run add-maintainer.py on the above patches
3. git send-email the patches.
That's it - no need to manually work with email addresses.
Quoted 3 lines
I almost always feed git send-email with addresses from
scripts/get_maintainers.pl. This tool would not bring any benefits to my simple workflow.
In the light of the 3-step workflow I've envisioned above, could you please elaborate why not? If anything, it will only save a developer's time.
Quoted 4 lines
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
You've mentioned a "simple workflow" many times - could you please share more details on the steps you follow in your workflow for sending patches?
Quoted 3 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.
Could you please elaborate on why depending on the output of get_maintainer.pl is a bad idea? It's what everyone uses, no?
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 48 lines · Guru Das Srinagesh
Thanks for the comments, Krzysztof.
Quoted 9 lines · Krzysztof Kozlowski
Quoted 8 lines · Guru Das Srinagesh
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.Quoted 8 lines
Quoted 3 lines
Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the
b4tool obviates the need for such a script.I send a bit of patches but I use very simple workflow. It is really simple, so simple, that I was always surprised how people can make their life difficult with some complicated process to send patches... and then obviously skip some maintainers, because of that process.
Exactly - this script aims to solve precisely that problem. It fills the gap between running
get_maintainers.pland having to manually edit its output to add "To: " and "Cc: " and somehow incorporate it in the body of the patch(es).With this script, the workflow would be as simple as:
1. Generate patches using
git format-patch
2. Runadd-maintainer.pyon the above patches
3.git send-emailthe patches.That's it - no need to manually work with email addresses.
Quoted 3 lines
I almost always feed git send-email with addresses from
scripts/get_maintainers.pl. This tool would not bring any benefits to my simple workflow.In the light of the 3-step workflow I've envisioned above, could you please elaborate why not? If anything, it will only save a developer's time.
Quoted 4 lines
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
You've mentioned a "simple workflow" many times - could you please share more details on the steps you follow in your workflow for sending patches?
Quoted 6 lines
Quoted 3 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.Could you please elaborate on why depending on the output of
get_maintainer.plis a bad idea? It's what everyone uses, no?
My opinion is that it would be a better idea to add a new output mode to scripts/get_maintainer.pl than adding another script on top of it.
Or document somewhere how to use get_maintainer.pl with git-format-patch without any additional scripts.
Neil
Quoted 4 lines
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 2 lines · Neil Armstrong
My opinion is that it would be a better idea to add a new output mode to
scripts/get_maintainer.plthan adding another script on top of it.
Sorry, I don't follow. The problem that this script is solving is getting the output of get_maintainer.pl neatly into a patch according to this scheme:
1. Generate patches using git format-patch
2. Run add-maintainer.py on the above patches
3. git send-email the patches.
Not sure how adding a new output mode to get_maintainer.pl fits in this problem space.
Unless you mean to add a switch to it so that it automatically edits the patch in-place (like add-maintainer.py does) and adds all the addresses directly to the patch - in which case, that would be feature creep.
Quoted 2 lines
Or document somewhere how to use get_maintainer.pl with git-format-patch without any additional scripts.
IMHO, Documentation/process/submitting-patches.rst should be updated with at least one or two options addressing how to get from the aforementioned step #1 -> step #3 addressing the problem that is being solved by step #2. In this vacuum, every developer and maintainer appears to have their own solution that works for them.
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 16 lines · Guru Das Srinagesh
Thanks for the comments, Krzysztof.
Quoted 13 lines · Krzysztof Kozlowski
Quoted 11 lines · Guru Das Srinagesh
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the
b4tool obviates the need for such a script.
Quoted 8 lines
Quoted 4 lines
I send a bit of patches but I use very simple workflow. It is really simple, so simple, that I was always surprised how people can make their life difficult with some complicated process to send patches... and then obviously skip some maintainers, because of that process.
Exactly - this script aims to solve precisely that problem. It fills the gap between running
get_maintainers.pland having to manually edit its output to add "To: " and "Cc: " and somehow incorporate it in the body of the patch(es).
Why would anyone need to manually update it? Just some simple bash function or git send-email identity.
Quoted 6 lines
With this script, the workflow would be as simple as:
1. Generate patches using
git format-patch
2. Runadd-maintainer.pyon the above patches
3.git send-emailthe patches.
So one more unnecessary step (2). I don't think it is easier than my workflow.
I just do only 1 and 3 and that's it. The simplest way ever.
Quoted 2 lines
That's it - no need to manually work with email addresses.
No one suggested it...
Quoted 7 lines
Quoted 4 lines
I almost always feed git send-email with addresses from
scripts/get_maintainers.pl. This tool would not bring any benefits to my simple workflow.In the light of the 3-step workflow I've envisioned above, could you please elaborate why not? If anything, it will only save a developer's time.
Because of unnecessary step 2? One more tool to remember to run?
Quoted 8 lines
Quoted 5 lines
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
You've mentioned a "simple workflow" many times - could you please share more details on the steps you follow in your workflow for sending patches?
I shared it on LKML few times already (and Rob's git send-email identity is also on LKML), so one more time:
https://github.com/krzk/tools/blob/master/linux/.bash_aliases_linux#L91
Quoted 7 lines
Quoted 4 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.Could you please elaborate on why depending on the output of
get_maintainer.plis a bad idea? It's what everyone uses, no?
No, because if interface changes you need to update two tools.
Best regards,
Krzysztof
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 22 lines · Krzysztof Kozlowski
Quoted 21 lines · Guru Das Srinagesh
Thanks for the comments, Krzysztof.
Quoted 17 lines · Krzysztof Kozlowski
Quoted 11 lines · Guru Das Srinagesh
Quoted 6 lines · Guru Das Srinagesh
When pushing patches to upstream, the
get_maintainer.plscript is used to determine whom to send the patches to. Instead of having to manually process the output of the script, add a wrapper script to do that for you.The
add-maintainer.pyscript adds maintainers (and mailing lists) to a patch, editing it in-place.Could I request reviews from the other maintainers as well, please? Just to see if I should continue working on this script or if the
b4tool obviates the need for such a script.I send a bit of patches but I use very simple workflow. It is really simple, so simple, that I was always surprised how people can make their life difficult with some complicated process to send patches... and then obviously skip some maintainers, because of that process.
Quoted 7 lines
Quoted 3 lines
Exactly - this script aims to solve precisely that problem. It fills the gap between running
get_maintainers.pland having to manually edit its output to add "To: " and "Cc: " and somehow incorporate it in the body of the patch(es).Why would anyone need to manually update it? Just some simple bash function or git send-email identity.
I do this all the time, either to add additional, or remove unnecessary, recipients from what's provided by get_maintainers.pl.
Quoted 12 lines
Quoted 6 lines
With this script, the workflow would be as simple as:
1. Generate patches using
git format-patch
2. Runadd-maintainer.pyon the above patches
3.git send-emailthe patches.So one more unnecessary step (2). I don't think it is easier than my workflow.
I just do only 1 and 3 and that's it. The simplest way ever.
There's no get_maintainer.pl in either 1, or 3, so obviously this isn't the only thing you do.
Thanks for the link to your alias below, it's now clear that you don't need an extra step in the procedure, if you only have your extra wrapper around step 3.
I now also understand why you never ever have a cover-letter, something Guru's proposed flow handles quite nicely.
That said, b4 prep and b4 send seems like a better suggestion to those who doesn't already have a workflow in place.
[..]
Quoted 10 lines
Quoted 7 lines
Quoted 4 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.Could you please elaborate on why depending on the output of
get_maintainer.plis a bad idea? It's what everyone uses, no?No, because if interface changes you need to update two tools.
This is a valid objection, but I've heard that "the simplest way ever" also depends on exactly this output...
Regards,
Bjorn
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 16 lines · Bjorn Andersson
Quoted 12 lines
Quoted 6 lines
With this script, the workflow would be as simple as:
1. Generate patches using
git format-patch
2. Runadd-maintainer.pyon the above patches
3.git send-emailthe patches.So one more unnecessary step (2). I don't think it is easier than my workflow.
I just do only 1 and 3 and that's it. The simplest way ever.
There's no get_maintainer.pl in either 1, or 3, so obviously this isn't the only thing you do.
Quoted 7 lines
Thanks for the link to your alias below, it's now clear that you don't need an extra step in the procedure, if you only have your extra wrapper around step 3.
I now also understand why you never ever have a cover-letter, something Guru's proposed flow handles quite nicely.
It's not related. I usually don't create cover letter from laziness, but pretty often I create them as well and my script/alias works there perfectly. Cover letter is just one more step:
1. git branch --edit-description
2. git format-patch --cover-letter (with format.coverFromDescription = subject in gitconfig)
3. git_send_email 0*
No need to run any other tool, no need to add any maintainer entries (unless touching defconfig and specific soc@ stuff, but this is always the case regardless of tools).
Really, that script proposed here is the unnecessary step.
Rob's approach with git send-email identity required some work for cover-letter, but it was also running get_maintainer.pl per each patch, so recipients did not receive everything. Unless patchset is big, I prefer to send everything to everyone.
Quoted 4 lines
That said, b4 prep and b4 send seems like a better suggestion to those who doesn't already have a workflow in place.
Yes.
Best regards,
Krzysztof
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 5 lines · Krzysztof Kozlowski
Quoted 5 lines
Quoted 4 lines
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
Quoted 7 lines
Quoted 2 lines
You've mentioned a "simple workflow" many times - could you please share more details on the steps you follow in your workflow for sending patches?
I shared it on LKML few times already (and Rob's git send-email identity is also on LKML), so one more time:
https://github.com/krzk/tools/blob/master/linux/.bash_aliases_linux#L91
Thank you for sharing this - it is really neat indeed and you certainly don't need a step #2 with this method.
However, I see areas for improvement in the alias:
- Subsystem-specific mailing lists, maintainers, reviewers, and other roles are all marked as "To: " sans distinction via the alias whereas add-maintainer.py and b4 both provide marking of lists as "Cc: " which seems aesthetically and semantically more pleasing.
- Only add-maintainer.py allows for maintainers to be selectively in "To: " and "Cc: " for patches in a series depending on whether they are the maintainers for that particular patch or not.
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.Could you please elaborate on why depending on the output of
get_maintainer.plis a bad idea? It's what everyone uses, no?No, because if interface changes you need to update two tools.
But b4 prep --auto-to-cc also uses get_maintainer.pl!
Also, in your previous email you said to "just use b4", which also depends on the command line and shell interface of get_maintainers.pl. Depending on get_maintainer.pl is therefore perfectly okay - there is no need to reinvent it or disregard it for whatever reasons.
Thank you.
Guru Das.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 14 lines · Guru Das Srinagesh
Quoted 5 lines · Krzysztof Kozlowski
Quoted 5 lines
Quoted 4 lines
For newcomers, OTOH, I would either recommend simple workflow or just use b4. Why? Because if you cannot use git-send-email, then it means your email setup will make your life difficult and adding maintainers to existing patch won't help you.
Quoted 7 lines
Quoted 2 lines
You've mentioned a "simple workflow" many times - could you please share more details on the steps you follow in your workflow for sending patches?
I shared it on LKML few times already (and Rob's git send-email identity is also on LKML), so one more time:
https://github.com/krzk/tools/blob/master/linux/.bash_aliases_linux#L91
Quoted 8 lines
Thank you for sharing this - it is really neat indeed and you certainly don't need a step #2 with this method.
However, I see areas for improvement in the alias:
- Subsystem-specific mailing lists, maintainers, reviewers, and other roles are all marked as "To: " sans distinction via the alias whereasadd-maintainer.pyandb4both provide marking of lists as "Cc: " which seems aesthetically and semantically more pleasing.
To or Cc does not matter.
Quoted 3 lines
- Only
add-maintainer.pyallows for maintainers to be selectively in "To: " and "Cc: " for patches in a series depending on whether they are the maintainers for that particular patch or not.
It's intentional to CC everyone. If I wanted to Cc/To maintainer-per-patch, I would use Rob's send-email identity.
Quoted 11 lines
Quoted 9 lines
Quoted 7 lines
Quoted 4 lines
This tool depends on the command line and shell interface of
scripts/get_maintainers.plwhich is another reason why it might not be a good idea.Could you please elaborate on why depending on the output of
get_maintainer.plis a bad idea? It's what everyone uses, no?No, because if interface changes you need to update two tools.
But
b4 prep --auto-to-ccalso usesget_maintainer.pl!
Yep, and it's Konstantin's headache to keep it updated. :)
Quoted 5 lines
Also, in your previous email you said to "just use b4", which also depends on the command line and shell interface of
get_maintainers.pl. Depending onget_maintainer.plis therefore perfectly okay - there is no need to reinvent it or disregard it for whatever reasons.
True, it is okay, but adding more tools to depend on it is more work. b4 is awesome tool, thus I feel it is justified to depend on that interface. I don't see the need for more tools doing exactly the same.
Best regards,
Krzysztof
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel