codeplain 0.1.0__py3-none-any.whl

file_utils.py

@@ -0,0 +1,316 @@
+import os
+import shutil
+from pathlib import Path
+
+from liquid2 import Environment, FileSystemLoader, StrictUndefined
+from liquid2.exceptions import UndefinedError
+
+import plain_spec
+from plain2code_nodes import Plain2CodeIncludeTag, Plain2CodeLoaderMixin
+
+BINARY_FILE_EXTENSIONS = [".pyc"]
+
+# Dictionary mapping of file extensions to type names
+FILE_EXTENSION_MAPPING = {
+    "": "plaintext",
+    ".py": "python",
+    ".txt": "plaintext",
+    ".md": "markdown",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".scss": "SASS/SCSS",
+    ".java": "java",
+    ".cpp": "C++",
+    ".c": "C",
+    ".cs": "C#",
+    ".php": "PHP",
+    ".rb": "Ruby",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".swift": "Swift",
+    ".kt": "Kotlin",
+    ".sql": "SQL",
+    ".json": "JSON",
+    ".xml": "XML",
+    ".yaml": "YAML",
+    ".yml": "YAML",  # YAML has two common extensions
+    ".sh": "Shell Script",
+    ".bat": "Batch File",
+}
+
+
+def get_file_type(file_name):
+
+    # Extract the file extension
+    ext = Path(file_name).suffix.lower()  # Convert to lowercase to handle case-insensitive matching
+
+    # Use the dictionary to get the file type, defaulting to 'unknown' if the extension is not found
+    return FILE_EXTENSION_MAPPING.get(ext, "unknown")
+
+
+def list_all_text_files(directory):
+    all_files = []
+    for root, dirs, files in os.walk(directory, topdown=True):
+        # Skip .git directory
+        if ".git" in dirs:
+            dirs.remove(".git")
+
+        modified_root = os.path.relpath(root, directory)
+        if modified_root == ".":
+            modified_root = ""
+
+        for filename in files:
+            if not any(filename.endswith(ending) for ending in BINARY_FILE_EXTENSIONS):
+                try:
+                    with open(os.path.join(root, filename), "rb") as f:
+                        f.read().decode("utf-8")
+                except UnicodeDecodeError:
+                    print(f"WARNING! Not listing {filename} in {root}. File is not a text file. Skipping it.")
+                    continue
+
+                all_files.append(os.path.join(modified_root, filename))
+
+    return all_files
+
+
+def list_folders_in_directory(directory):
+    # List all items in the directory
+    items = os.listdir(directory)
+
+    # Filter out the folders
+    folders = [item for item in items if os.path.isdir(os.path.join(directory, item))]
+
+    return folders
+
+
+# delete a folder and all its subfolders and files
+def delete_folder(folder_name):
+    if os.path.exists(folder_name):
+        shutil.rmtree(folder_name)
+
+
+def delete_files_and_subfolders(directory):
+    total_files_deleted = 0
+    total_folders_deleted = 0
+
+    # Walk the directory in reverse order (bottom-up)
+    for root, dirs, files in os.walk(directory, topdown=False):
+        # Delete files
+        for file in files:
+            file_path = os.path.join(root, file)
+            os.remove(file_path)
+            total_files_deleted += 1
+
+        # Delete directories
+        for dir_ in dirs:
+            dir_path = os.path.join(root, dir_)
+            os.rmdir(dir_path)
+            total_folders_deleted += 1
+
+
+def copy_file(source_path, destination_path):
+    # Ensure the destination directory exists
+    os.makedirs(os.path.dirname(destination_path), exist_ok=True)
+
+    # Open the source file in read-binary ('rb') mode
+    with open(source_path, "rb") as source_file:
+        # Open the destination file in write-binary ('wb') mode
+        with open(destination_path, "wb") as destination_file:
+            # Copy the content from source to destination
+            while True:
+                # Read a chunk of the source file
+                chunk = source_file.read(4096)  # Reading in chunks of 4KB
+                if not chunk:
+                    break  # End of file reached
+                # Write the chunk to the destination file
+                destination_file.write(chunk)
+
+
+def add_current_path_if_no_path(filename):
+    # Extract the base name of the file (ignoring any path information)
+    basename = os.path.basename(filename)
+
+    # Compare the basename to the original filename
+    # If they are the same, there was no path information in the filename
+    if basename == filename:
+        # Prepend the current working directory
+        return os.path.join(os.getcwd(), filename)
+    # If the basename and the original filename differ, path information was present
+    return filename
+
+
+def get_existing_files_content(build_folder, existing_files):
+    existing_files_content = {}
+    for file_name in existing_files:
+        with open(os.path.join(build_folder, file_name), "rb") as f:
+            content = f.read()
+            try:
+                existing_files_content[file_name] = content.decode("utf-8")
+            except UnicodeDecodeError:
+                print(f"WARNING! Error loading {file_name}. File is not a text file. Skipping it.")
+
+    return existing_files_content
+
+
+def store_response_files(target_folder, response_files, existing_files):
+    for file_name in response_files:
+        full_file_name = os.path.join(target_folder, file_name)
+
+        if response_files[file_name] is None:
+            # None content indicates that the file should be deleted.
+            if os.path.exists(full_file_name):
+                os.remove(full_file_name)
+                existing_files.remove(file_name)
+            else:
+                print(f"WARNING! Cannot delete file! File {full_file_name} does not exist.")
+
+            continue
+
+        os.makedirs(os.path.dirname(full_file_name), exist_ok=True)
+
+        with open(full_file_name, "w") as f:
+            f.write(response_files[file_name])
+
+        if file_name not in existing_files:
+            existing_files.append(file_name)
+
+    return existing_files
+
+
+def load_linked_resources(template_dirs: list[str], resources_list):
+    linked_resources = {}
+
+    for resource in resources_list:
+        resource_found = False
+        for template_dir in template_dirs:
+            file_name = resource["target"]
+            if file_name in linked_resources:
+                continue
+
+            full_file_name = os.path.join(template_dir, file_name)
+            if not os.path.isfile(full_file_name):
+                continue
+
+            with open(full_file_name, "rb") as f:
+                content = f.read()
+                try:
+                    linked_resources[file_name] = content.decode("utf-8")
+                except UnicodeDecodeError:
+                    print(
+                        f"WARNING! Error loading {resource['text']} ({resource['target']}). File is not a text file. Skipping it."
+                    )
+                resource_found = True
+        if not resource_found:
+            raise FileNotFoundError(
+                f"""
+                Resource file {resource['target']} not found. Resource files are searched in the following order (highest to lowest precedence):
+
+                1. The directory containing your .plain file
+                2. The directory specified by --template-dir (if provided)
+                3. The built-in 'standard_template_library' directory
+
+                Please ensure that the resource exists in one of these locations, or specify the correct --template-dir if using custom templates.
+                """
+            )
+
+    return linked_resources
+
+
+class TrackingFileSystemLoader(Plain2CodeLoaderMixin, FileSystemLoader):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.loaded_templates = {}
+
+    def get_source(self, environment, template_name, **kwargs):
+        source = super().get_source(environment, template_name, **kwargs)
+        self.loaded_templates[template_name] = source.source
+        return source
+
+
+def get_loaded_templates(source_path, plain_source):
+    # Render the plain source with Liquid templating engine
+    # to identify the templates that are being loaded
+
+    liquid_loader = TrackingFileSystemLoader(source_path)
+    liquid_env = Environment(loader=liquid_loader, undefined=StrictUndefined)
+    liquid_env.tags["include"] = Plain2CodeIncludeTag(liquid_env)
+
+    liquid_env.filters["code_variable"] = plain_spec.code_variable_liquid_filter
+    liquid_env.filters["prohibited_chars"] = plain_spec.prohibited_chars_liquid_filter
+
+    plain_source_template = liquid_env.from_string(plain_source)
+    try:
+        plain_source = plain_source_template.render()
+    except UndefinedError as e:
+        raise Exception(f"Undefined liquid variable: {str(e)}")
+
+    return plain_source, liquid_loader.loaded_templates
+
+
+def update_build_folder_with_rendered_files(build_folder, existing_files, response_files):
+    changed_files = set()
+    changed_files.update(response_files.keys())
+
+    existing_files = store_response_files(build_folder, response_files, existing_files)
+
+    return existing_files, changed_files
+
+
+def copy_folder_content(source_folder, destination_folder, ignore_folders=None):
+    """
+    Recursively copy all files and folders from source_folder to destination_folder.
+    Uses shutil.copytree which handles all edge cases including permissions and symlinks.
+
+    Args:
+        source_folder: Source directory to copy from
+        destination_folder: Destination directory to copy to
+        ignore_folders: List of folder names to ignore during copy (default: empty list)
+    """
+    if ignore_folders is None:
+        ignore_folders = []
+
+    ignore_func = (
+        (lambda dir, files: [f for f in files if f in ignore_folders]) if ignore_folders else None  # noqa: U100,U101
+    )
+    shutil.copytree(source_folder, destination_folder, dirs_exist_ok=True, ignore=ignore_func)
+
+
+def get_template_directories(plain_file_path, custom_template_dir=None, default_template_dir=None) -> list[str]:
+    """Set up template search directories with specific precedence order.
+
+    The order of directories in the returned list determines template loading precedence.
+    Earlier indices (lower numbers) have higher precedence - the first matching template found will be used.
+
+    Precedence order (highest to lowest):
+    1. Directory containing the plain file - for project-specific template overrides
+    2. Custom template directory (if provided) - for shared custom templates
+    3. Default template directory - for standard/fallback templates
+    """
+    template_dirs = [
+        os.path.dirname(plain_file_path),  # Highest precedence - directory containing plain file
+    ]
+
+    if custom_template_dir:
+        template_dirs.append(os.path.abspath(custom_template_dir))  # Second highest - custom template dir
+
+    if default_template_dir:
+        # Add standard template directory last - lowest precedence
+        template_dirs.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), default_template_dir))
+
+    return template_dirs
+
+
+def copy_folder_to_output(source_folder, output_folder):
+    """Copy source folder contents directly to the specified output folder."""
+    # Create output folder if it doesn't exist
+    os.makedirs(output_folder, exist_ok=True)
+
+    # If output folder exists, clean it first to ensure clean copy
+    if os.path.exists(output_folder):
+        delete_files_and_subfolders(output_folder)
+
+    # Copy source folder contents directly to output folder (excluding .git)
+    copy_folder_content(source_folder, output_folder, ignore_folders=[".git"])

git_utils.py

@@ -0,0 +1,304 @@
+import os
+from typing import Optional, Union
+
+from git import Repo
+
+import file_utils
+
+FUNCTIONAL_REQUIREMENT_IMPLEMENTED_COMMIT_MESSAGE = (
+    "[Codeplain] Implemented code and unit tests for functional requirement {}"
+)
+REFACTORED_CODE_COMMIT_MESSAGE = "[Codeplain] Refactored code after implementing functional requirement {}"
+CONFORMANCE_TESTS_PASSED_COMMIT_MESSAGE = (
+    "[Codeplain] Fixed issues in the implementation code identified during conformance testing"
+)
+
+# Following messages are used as checkpoints in the git history
+# Changing them will break backwards compatibility so change them with care
+FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE = "[Codeplain] Functional requirement ID (FRID):{} fully implemented"
+INITIAL_COMMIT_MESSAGE = "[Codeplain] Initial commit"
+BASE_FOLDER_COMMIT_MESSAGE = "[Codeplain] Initialize build with Base Folder content"
+
+
+RENDERED_FRID_MESSAGE = "Changes related to Functional requirement ID (FRID): {}"
+RENDER_ID_MESSAGE = "Render ID: {}"
+
+
+class InvalidGitRepositoryError(Exception):
+    """Raised when the git repository is in an invalid state."""
+
+    pass
+
+
+def init_git_repo(path_to_repo: Union[str, os.PathLike]) -> Repo:
+    """
+    Initializes a new git repository in the given path.
+    If folder does not exist, it creates it.
+    If the folder already exists, it deletes the content of the folder.
+    """
+    if os.path.isdir(path_to_repo):
+        file_utils.delete_files_and_subfolders(path_to_repo)
+    else:
+        os.makedirs(path_to_repo)
+
+    repo = Repo.init(path_to_repo)
+    repo.git.commit("--allow-empty", "-m", INITIAL_COMMIT_MESSAGE)
+
+    return repo
+
+
+def is_dirty(repo_path: Union[str, os.PathLike]) -> bool:
+    """Checks if the repository is dirty."""
+    repo = Repo(repo_path)
+    return repo.is_dirty(untracked_files=True)
+
+
+def add_all_files_and_commit(
+    repo_path: Union[str, os.PathLike], commit_message: str, frid: Optional[str] = None, render_id: Optional[str] = None
+) -> Repo:
+    """Adds all files to the git repository and commits them."""
+    repo = Repo(repo_path)
+    repo.git.add(".")
+
+    message = f"{commit_message}"
+
+    if frid or render_id:
+        message += "\n\n" + "-" * 80
+
+    if frid:
+        message += f"\n\n{RENDERED_FRID_MESSAGE.format(frid)}"
+    if render_id:
+        message += f"\n\n{RENDER_ID_MESSAGE.format(render_id)}"
+
+    # Check if there are any changes to commit
+    if not repo.is_dirty(untracked_files=True):
+        repo.git.commit("--allow-empty", "-m", message)
+    else:
+        repo.git.commit("-m", message)
+
+    return repo
+
+
+def revert_changes(repo_path: Union[str, os.PathLike]) -> Repo:
+    """Reverts all changes made since the last commit."""
+    repo = Repo(repo_path)
+    repo.git.reset("--hard")
+    repo.git.clean("-xdf")
+    return repo
+
+
+def revert_to_commit_with_frid(repo_path: Union[str, os.PathLike], frid: Optional[str] = None) -> Repo:
+    """
+    Finds commit with given frid mentioned in the commit message and reverts the branch to it.
+
+    If frid argument is not provided (None), repo is reverted to the initial state. In case the base folder doesn't exist,
+    code is reverted to the initial repo commit. Otherwise, the repo is reverted to the base folder commit.
+
+    It is expected that the repo has at least one commit related to provided frid if frid is not None.
+    In case the frid related commit is not found, an exception is raised.
+    """
+    repo = Repo(repo_path)
+
+    commit = _get_commit(repo, frid)
+
+    if not commit:
+        raise InvalidGitRepositoryError("Git repository is in an invalid state. Relevant commit could not be found.")
+
+    repo.git.reset("--hard", commit)
+    repo.git.clean("-xdf")
+    return repo
+
+
+def checkout_commit_with_frid(repo_path: Union[str, os.PathLike], frid: Optional[str] = None) -> Repo:
+    """
+    Finds commit with given frid mentioned in the commit message and checks out that commit.
+
+    If frid argument is not provided (None), repo is checked out to the initial state. In case the base folder doesn't exist,
+    code is checked out to the initial repo commit. Otherwise, the repo is checked out to the base folder commit.
+
+    It is expected that the repo has at least one commit related to provided frid if frid is not None.
+    In case the frid related commit is not found, an exception is raised.
+    """
+    repo = Repo(repo_path)
+
+    commit = _get_commit(repo, frid)
+
+    if not commit:
+        raise InvalidGitRepositoryError("Git repository is in an invalid state. Relevant commit could not be found.")
+
+    repo.git.checkout(commit)
+    return repo
+
+
+def checkout_previous_branch(repo_path: Union[str, os.PathLike]) -> Repo:
+    """
+    Checks out the previous branch using 'git checkout -'.
+
+    Args:
+        repo_path (str | os.PathLike): Path to the git repository
+
+    Returns:
+        Repo: The git repository object
+    """
+    repo = Repo(repo_path)
+    repo.git.checkout("-")
+    return repo
+
+
+def _get_diff_dict(diff_output: str) -> dict:
+    diff_dict = {}
+    current_file = None
+    current_diff_lines = []
+
+    lines = diff_output.split("\n")
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        if line.startswith("diff --git"):
+            # Save previous file's diff if exists
+            if current_file and current_diff_lines:
+                diff_dict[current_file] = "\n".join(current_diff_lines)
+
+            # Extract file name from diff --git line
+            parts = line.split(" ")
+            if len(parts) >= 4:
+                # Get the b/ path (new file path)
+                current_file = parts[3][2:] if parts[3].startswith("b/") else parts[3]
+            current_diff_lines = []
+
+            # Skip the diff --git line
+            i += 1
+
+            # Skip the index line if it exists
+            while i < len(lines) and (
+                lines[i].startswith("index ")
+                or lines[i].startswith("new file mode ")
+                or lines[i].startswith("deleted file mode ")
+            ):
+                i += 1
+
+            continue
+
+        # Add all other lines to current diff
+        if current_file is not None:
+            current_diff_lines.append(line)
+
+        i += 1
+
+    # Don't forget the last file
+    if current_file and current_diff_lines:
+        diff_dict[current_file] = "\n".join(current_diff_lines)
+
+    return diff_dict
+
+
+def diff(repo_path: Union[str, os.PathLike], previous_frid: str = None) -> dict:
+    """
+    Get the git diff between the current code state and the previous frid using git's native diff command.
+    If previous_frid is not provided, we try to find the commit related to the copy of the base folder.
+    Removes the 'diff --git' and 'index' lines to get clean unified diff format.
+
+
+    Args:
+        repo_path (str | os.PathLike): Path to the git repository
+        previous_frid (str): Functional requirement ID (FRID) of the previous commit
+
+    Returns:
+        dict: Dictionary with file names as keys and their clean diff strings as values
+    """
+    repo = Repo(repo_path)
+
+    commit = _get_commit(repo, previous_frid)
+
+    # Add all files to the index to get a clean diff
+    repo.git.add("-N", ".")
+
+    # Get the raw git diff output, excluding .pyc files
+    diff_output = repo.git.diff(commit, "--text", ":!*.pyc")
+
+    if not diff_output:
+        return {}
+
+    return _get_diff_dict(diff_output)
+
+
+def _get_commit(repo: Repo, frid: Optional[str]) -> str:
+    if frid:
+        commit = _get_commit_with_frid(repo, frid)
+    else:
+        commit = _get_base_folder_commit(repo)
+        if not commit:
+            commit = _get_initial_commit(repo)
+
+    return commit
+
+
+def _get_commit_with_frid(repo: Repo, frid: str) -> str:
+    """Finds commit with given frid mentioned in the commit message."""
+    commit = _get_commit_with_message(repo, FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE.format(frid))
+    if not commit:
+        raise InvalidGitRepositoryError(f"No commit with frid {frid} found.")
+    return commit
+
+
+def _get_base_folder_commit(repo: Repo) -> str:
+    """Finds commit related to copy of the base folder."""
+    return _get_commit_with_message(repo, BASE_FOLDER_COMMIT_MESSAGE)
+
+
+def _get_initial_commit(repo: Repo) -> str:
+    """Finds initial commit."""
+    return _get_commit_with_message(repo, INITIAL_COMMIT_MESSAGE)
+
+
+def _get_commit_with_message(repo: Repo, message: str) -> str:
+    """Finds commit with given message."""
+    escaped_message = message.replace("[", "\\[").replace("]", "\\]")
+
+    return repo.git.rev_list(repo.active_branch.name, "--grep", escaped_message, "-n", "1")
+
+
+def get_implementation_code_diff(repo_path: Union[str, os.PathLike], frid: str, previous_frid: str) -> dict:
+    repo = Repo(repo_path)
+
+    implementation_commit = _get_commit_with_message(repo, REFACTORED_CODE_COMMIT_MESSAGE.format(frid))
+    if not implementation_commit:
+        implementation_commit = _get_commit_with_message(
+            repo, FUNCTIONAL_REQUIREMENT_IMPLEMENTED_COMMIT_MESSAGE.format(frid)
+        )
+
+    previous_frid_commit = _get_commit(repo, previous_frid)
+
+    # Get the raw git diff output, excluding .pyc files
+    diff_output = repo.git.diff(previous_frid_commit, implementation_commit, "--text", ":!*.pyc")
+
+    if not diff_output:
+        return {}
+
+    return _get_diff_dict(diff_output)
+
+
+def get_fixed_implementation_code_diff(repo_path: Union[str, os.PathLike], frid: str) -> dict:
+    repo = Repo(repo_path)
+
+    implementation_commit = _get_commit_with_message(repo, REFACTORED_CODE_COMMIT_MESSAGE.format(frid))
+    if not implementation_commit:
+        implementation_commit = _get_commit_with_message(
+            repo, FUNCTIONAL_REQUIREMENT_IMPLEMENTED_COMMIT_MESSAGE.format(frid)
+        )
+
+    conformance_tests_passed_commit = _get_commit_with_message(
+        repo, CONFORMANCE_TESTS_PASSED_COMMIT_MESSAGE.format(frid)
+    )
+    if not conformance_tests_passed_commit:
+        return None
+
+    # Get the raw git diff output, excluding .pyc files
+    diff_output = repo.git.diff(implementation_commit, conformance_tests_passed_commit, "--text", ":!*.pyc")
+
+    if not diff_output:
+        return {}
+
+    return _get_diff_dict(diff_output)

hash_key.py

@@ -0,0 +1,29 @@
+import hashlib
+import sys
+
+
+def hash_api_key(api_key):
+    """Hash the provided API key using SHA-256 and return the hash as a hex string."""
+    try:
+        hash_object = hashlib.sha256(api_key.encode())
+        hex_dig = hash_object.hexdigest()
+        return hex_dig
+    except Exception as e:
+        error_message = f"An error occurred while hashing the API key: {str(e)}"
+        raise Exception(error_message)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Error: Exactly one argument must be provided for the API key.")
+        print(f"Usage: python {sys.argv[0]} <api_key>")
+        sys.exit(1)
+
+    api_key = sys.argv[1]
+
+    try:
+        hashed_key = hash_api_key(api_key)
+        print(f"Hashed API Key: {hashed_key}")
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        sys.exit(1)