feat: add entry point

library_generation/cli/entry_point.py

@@ -0,0 +1,141 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+
+import click as click
+from library_generation.generate_pr_description import generate_pr_descriptions
+from library_generation.generate_repo import generate_from_yaml
+from library_generation.model.generation_config import from_yaml
+from library_generation.utils.generation_config_comparator import compare_config
+
+
+@click.group(invoke_without_command=False)
+@click.pass_context
+@click.version_option(message="%(version)s")
+def main(ctx):
+    pass
+
+
+@main.command()
+@click.option(
+    "--baseline-generation-config",
+    required=False,
+    default=None,
+    type=str,
+    help="""
+    Absolute or relative path to a generation_config.yaml.
+    This config file is used for commit history generation, not library
+    generation.
+    """,
+)
+@click.option(
+    "--current-generation-config",
+    required=False,
+    default=None,
+    type=str,
+    help="""
+    Absolute or relative path to a generation_config.yaml that contains the
+    metadata about library generation.
+    """,
+)
+@click.option(
+    "--repository-path",
+    type=str,
+    default=".",
+    show_default=True,
+    help="""
+    The repository path to which the generated files
+    will be sent.
+    If not specified, the repository will be generated to the current working
+    directory.
+    """,
+)
+def generate(
+    baseline_generation_config: str,
+    current_generation_config: str,
+    repository_path: str,
+):
+    """
+    Compare baseline generation config and current generation config and
+    generate changed libraries based on current generation config with commit
+    history.
+
+    If baseline generation config is not specified but current generation
+    config is specified, generate all libraries based on current generation
+    config without commit history.
+
+    If current generation config is not specified but baseline generation
+    config is specified, raise FileNotFoundError because current generation
+    config should be the source of truth of library generation.
+
+    If both baseline generation config and current generation config are not
+    specified, generate all libraries based on the default generation config,
+    which is generation_config.yaml in the current working directory. Raise
+    FileNotFoundError if the default config does not exist.
+
+    The commit history, if generated, will be available in
+    repository_path/pr_description.txt.
+    """
+    default_generation_config = f"{os.getcwd()}/generation_config.yaml"
+
+    if baseline_generation_config is None and current_generation_config is None:
+        if not os.path.isfile(default_generation_config):
+            raise FileNotFoundError(
+                f"{default_generation_config} does not exist. "
+                "A valid generation config has to be passed in as "
+                "current_generation_config or exist in the current working "
+                "directory."
+            )
+        current_generation_config = default_generation_config
+    elif current_generation_config is None:
+        raise FileNotFoundError(
+            "current_generation_config is not specified when "
+            "baseline_generation_config is specified. "
+            "current_generation_config should be the source of truth of "
+            "library generation."
+        )
+
+    current_generation_config = os.path.abspath(current_generation_config)
+    repository_path = os.path.abspath(repository_path)
+    if not baseline_generation_config:
+        # Execute full generation based on current_generation_config if
+        # baseline_generation_config is not specified.
+        # Do not generate pull request description.
+        generate_from_yaml(
+            config=from_yaml(current_generation_config),
+            repository_path=repository_path,
+        )
+        return
+
+    # Compare two generation configs and only generate changed libraries.
+    # Generate pull request description.
+    baseline_generation_config = os.path.abspath(baseline_generation_config)
+    config_change = compare_config(
+        baseline_config=from_yaml(baseline_generation_config),
+        current_config=from_yaml(current_generation_config),
+    )
+    generate_from_yaml(
+        config=config_change.current_config,
+        repository_path=repository_path,
+        target_library_names=config_change.get_changed_libraries(),
+    )
+    generate_pr_descriptions(
+        config=config_change.current_config,
+        baseline_commit=config_change.baseline_config.googleapis_commitish,
+        description_path=repository_path,
+    )
+
+
+if __name__ == "__main__":
+    main()

library_generation/generate_pr_description.py

@@ -12,13 +12,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import calendar
 import os
 import shutil
+import click as click
 from typing import Dict
-
-import click
 from git import Commit, Repo
-from library_generation.model.generation_config import from_yaml
+from library_generation.model.generation_config import GenerationConfig, from_yaml
 from library_generation.utils.proto_path_utils import find_versioned_proto_path
 from library_generation.utils.commit_message_formatter import format_commit_message
 from library_generation.utils.commit_message_formatter import wrap_override_commit
@@ -53,51 +53,61 @@ def main(ctx):
     This commit should be an ancestor of googleapis commit in configuration.
     """,
 )
-@click.option(
-    "--repo-url",
-    type=str,
-    default="https://github.com/googleapis/googleapis.git",
-    show_default=True,
-    help="""
-    GitHub repository URL.
-    """,
-)
 def generate(
     generation_config_yaml: str,
-    repo_url: str,
     baseline_commit: str,
-) -> str:
-    description = generate_pr_descriptions(
-        generation_config_yaml=generation_config_yaml,
-        repo_url=repo_url,
-        baseline_commit=baseline_commit,
-    )
+) -> None:
     idx = generation_config_yaml.rfind("/")
     config_path = generation_config_yaml[:idx]
-    with open(f"{config_path}/pr_description.txt", "w+") as f:
-        f.write(description)
-    return description
+    generate_pr_descriptions(
+        config=from_yaml(generation_config_yaml),
+        baseline_commit=baseline_commit,
+        description_path=config_path,
+    )
 
 
 def generate_pr_descriptions(
-    generation_config_yaml: str,
-    repo_url: str,
+    config: GenerationConfig,
     baseline_commit: str,
-) -> str:
-    config = from_yaml(generation_config_yaml)
+    description_path: str,
+    repo_url: str = "https://github.com/googleapis/googleapis.git",
+) -> None:
+    """
+    Generate pull request description from baseline_commit (exclusive) to the
+    googleapis commit (inclusive) in the given generation config.
+
+    The pull request description will be generated into
+    description_path/pr_description.txt.
+
+    :param config: a GenerationConfig object. The googleapis commit in this
+    configuration is the latest commit, inclusively, from which the commit
+    message is considered.
+    :param baseline_commit: The baseline (oldest) commit, exclusively, from
+    which the commit message is considered. This commit should be an ancestor
+    of googleapis commit in configuration.
+    :param description_path: the path to which the pull request description
+    file goes.
+    :param repo_url: the GitHub repository from which retrieves the commit
+    history.
+    """
     paths = config.get_proto_path_to_library_name()
-    return __get_commit_messages(
+    description = get_commit_messages(
         repo_url=repo_url,
-        latest_commit=config.googleapis_commitish,
+        current_commit=config.googleapis_commitish,
         baseline_commit=baseline_commit,
         paths=paths,
         is_monorepo=config.is_monorepo,
     )
 
+    description_file = f"{description_path}/pr_description.txt"
+    print(f"Writing pull request description to {description_file}")
+    with open(description_file, "w+") as f:
+        f.write(description)
+
 
-def __get_commit_messages(
+def get_commit_messages(
     repo_url: str,
-    latest_commit: str,
+    current_commit: str,
     baseline_commit: str,
     paths: Dict[str, str],
     is_monorepo: bool,
@@ -109,7 +119,7 @@ def __get_commit_messages(
     Note that baseline_commit should be an ancestor of latest_commit.
 
     :param repo_url: the url of the repository.
-    :param latest_commit: the newest commit to be considered in
+    :param current_commit: the newest commit to be considered in
     selecting commit message.
     :param baseline_commit: the oldest commit to be considered in
     selecting commit message. This commit should be an ancestor of
@@ -121,7 +131,15 @@ def __get_commit_messages(
     shutil.rmtree(tmp_dir, ignore_errors=True)
     os.mkdir(tmp_dir)
     repo = Repo.clone_from(repo_url, tmp_dir)
-    commit = repo.commit(latest_commit)
+    commit = repo.commit(current_commit)
+    current_commit_time = __get_commit_timestamp(commit)
+    baseline_commit_time = __get_commit_timestamp(repo.commit(baseline_commit))
+    if current_commit_time <= baseline_commit_time:
+        raise ValueError(
+            f"current_commit ({current_commit[:7]}, committed on "
+            f"{current_commit_time}) should be newer than baseline_commit "
+            f"({baseline_commit[:7]}, committed on {baseline_commit_time})."
+        )
     qualified_commits = {}
     while str(commit.hexsha) != baseline_commit:
         commit_and_name = __filter_qualified_commit(paths=paths, commit=commit)
@@ -133,7 +151,7 @@ def __get_commit_messages(
         commit = commit_parents[0]
     shutil.rmtree(tmp_dir, ignore_errors=True)
     return __combine_commit_messages(
-        latest_commit=latest_commit,
+        current_commit=current_commit,
         baseline_commit=baseline_commit,
         commits=qualified_commits,
         is_monorepo=is_monorepo,
@@ -159,13 +177,13 @@ def __filter_qualified_commit(paths: Dict[str, str], commit: Commit) -> (Commit,
 
 
 def __combine_commit_messages(
-    latest_commit: str,
+    current_commit: str,
     baseline_commit: str,
     commits: Dict[Commit, str],
     is_monorepo: bool,
 ) -> str:
     messages = [
-        f"This pull request is generated with proto changes between googleapis commit {baseline_commit} (exclusive) and {latest_commit} (inclusive).",
+        f"This pull request is generated with proto changes between googleapis commit {baseline_commit} (exclusive) and {current_commit} (inclusive).",
         "Qualified commits are:",
     ]
     for commit in commits:
@@ -183,5 +201,16 @@ def __combine_commit_messages(
     return "\n".join(messages)
 
 
+def __get_commit_timestamp(commit: Commit) -> int:
+    """
+    # Convert datetime to UTC timestamp. For more info:
+    # https://stackoverflow.com/questions/5067218/get-utc-timestamp-in-python-with-datetime
+
+    :param commit: a Commit object
+    :return: the timestamp of the commit
+    """
+    return calendar.timegm(commit.committed_datetime.utctimetuple())
+
+
 if __name__ == "__main__":
     main()

library_generation/generate_repo.py

@@ -12,13 +12,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import click as click
 import library_generation.utils.utilities as util
-import click
-import os
 from library_generation.generate_composed_library import generate_composed_library
-from library_generation.model.generation_config import GenerationConfig
-from library_generation.model.generation_config import from_yaml
+from library_generation.model.generation_config import GenerationConfig, from_yaml
 from library_generation.model.library_config import LibraryConfig
 from library_generation.utils.monorepo_postprocessor import monorepo_postprocessing
 
@@ -75,8 +72,9 @@ def generate(
     target_library_names: str,
     repository_path: str,
 ):
+    config = from_yaml(generation_config_yaml)
     generate_from_yaml(
-        generation_config_yaml=generation_config_yaml,
+        config=config,
         repository_path=repository_path,
         target_library_names=target_library_names.split(",")
         if target_library_names is not None
@@ -85,30 +83,23 @@ def generate(
 
 
 def generate_from_yaml(
-    generation_config_yaml: str,
+    config: GenerationConfig,
     repository_path: str,
     target_library_names: list[str] = None,
 ) -> None:
     """
-    Parses a config yaml and generates libraries via
+    Based on the generation config, generates libraries via
     generate_composed_library.py
-    :param generation_config_yaml: Path to generation_config.yaml that contains
-    the metadata about library generation
-    :param repository_path: If specified, the generated files will be sent to
-    this location. If not specified, the repository will be generated to the
-    current working directory.
+
+    :param config: a GenerationConfig object.
+    :param repository_path: The repository path to which the generated files
+    will be sent.
     :param target_library_names: a list of libraries to be generated.
-    If specified, only the library whose library_name is in
-    target-library-names will be generated.
+    If specified, only the library whose library_name is in target_library_names
+    will be generated.
     If specified with an empty list, then no library will be generated.
     If not specified, all libraries in the configuration yaml will be generated.
     """
-    # convert paths to absolute paths, so they can be correctly referenced in
-    # downstream scripts
-    generation_config_yaml = os.path.abspath(generation_config_yaml)
-    repository_path = os.path.abspath(repository_path)
-
-    config = from_yaml(generation_config_yaml)
     target_libraries = get_target_libraries(
         config=config, target_library_names=target_library_names
     )
@@ -117,7 +108,7 @@ def generate_from_yaml(
     )
 
     for library_path, library in repo_config.libraries.items():
-        print(f"generating library {library.api_shortname}")
+        print(f"generating library {library.get_library_name()}")
 
         generate_composed_library(
             config=config,