coauthor 0.0.5__py3-none-any.whl

coauthor/utils/config.py

@@ -0,0 +1,73 @@
+import yaml
+import os
+
+
+def read_config(file_path, logger=None):
+    if logger:
+        logger.info(f"Reading configuration from {file_path}")
+    with open(file_path, "r") as file:
+        return yaml.safe_load(file)
+
+
+def get_config_path(config_filename=".coauthor.yml", search_dir=os.getcwd()):
+    # Search current directory and traverse upwards to all parent directories
+    traversed_paths = []
+    while True:
+        potential_path = os.path.join(search_dir, config_filename)
+        if os.path.exists(potential_path):
+            return potential_path, traversed_paths
+        # Append to traversed paths for logging purposes
+        traversed_paths.append(search_dir)
+        # Move up one directory
+        parent_dir = os.path.dirname(search_dir)
+        if parent_dir == search_dir:  # If reached the root directory
+            break
+        search_dir = parent_dir
+
+    # Check in user's home directory
+    home_dir = os.path.expanduser("~")
+    home_path = os.path.join(home_dir, config_filename)
+    if os.path.exists(home_path):
+        traversed_paths.append(home_dir)
+        return home_path, traversed_paths
+
+    # If no config file is found, return None and the paths checked
+    return None, traversed_paths
+
+
+def get_config(path=None, logger=None, config_filename=".coauthor.yml", search_dir=os.getcwd(), args=None):
+    config = {}
+    config_path = None
+    if args and "config_path" in args:
+        config_path = args.config_path
+    if not config_path:
+        if path:
+            # config_path = read_config(path, logger)
+            config_path = path
+        else:
+            config_path, searched_paths = get_config_path(config_filename, search_dir)
+            if not config_path:
+                if logger:
+                    logger.warning(f"Configuration file not found. Searched directories: {', '.join(searched_paths)}")
+    if config_path:
+        config = read_config(config_path, logger)
+    if "watch_directory" not in config:
+        config["watch_directory"] = os.getcwd()
+    if "callback" not in config and "callbacks" not in config:
+        config["callback"] = "process_file_with_openai_agent"
+    if "agent" not in config or config["agent"] is None:
+        config["agent"] = {}
+    if not "api_key_var" in config["agent"]:
+        config["agent"]["api_key_var"] = "OPENAI_API_KEY"
+    if not "api_url_var" in config["agent"]:
+        config["agent"]["api_url_var"] = "OPENAI_API_URL"
+    if not "model" in config["agent"]:
+        config["agent"]["model"] = "openai/gpt-4o"
+    return config
+
+
+def get_jinja_config(config):
+    if "jinja" in config:
+        return config["jinja"]
+    config_jinja = {"search_path": ".coauthor/templates"}
+    return config_jinja

coauthor/utils/git.py

@@ -0,0 +1,47 @@
+import subprocess
+import os
+
+
+def get_git_diff(file_path):
+    """
+    Given the path of a file, this function checks if the file is part of a Git repository.
+    If it is, the function returns the diff of the file showing outstanding changes.
+    If the file is not in a Git repository, it returns None.
+
+    :param file_path: The path to the file.
+    :return: The diff of the file or None if not in a Git repository.
+    """
+
+    # Check if the file is part of a git repository
+    # try:
+    # `git rev-parse --is-inside-work-tree` returns `true` if inside repository
+    result = subprocess.run(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        cwd=os.path.dirname(file_path),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    # if result.returncode != 0 or result.stdout.strip() != b"true":
+    #     # Not a git repository
+    #     return ""
+
+    # Get the diff of the file
+    diff_result = subprocess.run(
+        ["git", "diff", file_path], cwd=os.path.dirname(file_path), stdout=subprocess.PIPE, stderr=subprocess.PIPE
+    )
+
+    # if diff_result.returncode != 0:
+    #     # Could not get a diff, possibly an error occurred
+    #     return ""
+
+    return diff_result.stdout.decode("utf-8")
+
+    # except Exception as e:
+    #     # Handle unexpected errors, possibly log this
+    #     return ""
+
+
+# Example usage:
+# diff = get_git_diff('/path/to/your/file')
+# print(diff)

coauthor/utils/jinja.py

@@ -0,0 +1,101 @@
+import jinja2
+import os
+from coauthor.utils.config import get_jinja_config
+from coauthor.utils.git import get_git_diff
+from coauthor.utils.jinja_filters import select_task, get_task_attribute
+
+
+def render_template_to_file(task, template, path, config, logger):
+    content = render_template(task, template, config, logger)
+    with open(path, "w", encoding="utf-8") as file:
+        file.write(content)
+
+
+def search_path_directories(search_path):
+    # Return a list of directory search_path and all its subdirectories
+    directories = []
+    for root, dirs, files in os.walk(search_path):
+        directories.append(root)
+    return directories
+
+
+def template_exists(task, template, config, logger):
+    config = get_jinja_config(config)
+    search_paths = search_path_directories(config["search_path"])
+    template_loader = jinja2.FileSystemLoader(searchpath=search_paths)
+    templates = template_loader.list_templates()
+    if template in templates:
+        return True
+    logger.debug(f"Template {template} not found!")
+    return False
+
+
+def render_template(task, template_path, config, logger):
+    logger.debug(f"Render template {template_path} for task {task['id']}")
+    jinja_config = get_jinja_config(config)
+    search_paths = search_path_directories(jinja_config["search_path"])
+    template_loader = jinja2.FileSystemLoader(searchpath=search_paths)
+    templates = template_loader.list_templates()
+    logger.debug(f"templates: {templates}")
+    if "custom_delimiters" in jinja_config:
+        logger.debug("Creating Jinja environment using custom delimiters")
+        custom_delimiters = jinja_config["custom_delimiters"]
+        template_env = jinja2.Environment(
+            loader=template_loader,
+            block_start_string=custom_delimiters.get("block_start_string", "{%"),
+            block_end_string=custom_delimiters.get("block_end_string", "%}"),
+            variable_start_string=custom_delimiters.get("variable_start_string", "{{"),
+            variable_end_string=custom_delimiters.get("variable_end_string", "}}"),
+            comment_start_string=custom_delimiters.get("comment_start_string", "{#"),
+            comment_end_string=custom_delimiters.get("comment_end_string", "#}"),
+        )
+    else:
+        template_env = jinja2.Environment(loader=template_loader)
+    template_env.filters["include_file_content"] = include_file_content
+    template_env.filters["get_git_diff"] = get_git_diff
+    template_env.filters["file_exists"] = file_exists
+    template_env.filters["select_task"] = select_task
+    template_env.filters["get_task_attribute"] = get_task_attribute
+
+    logger.debug(f"Get Jinja template: {template_path}")
+    template = template_env.get_template(template_path)
+    context = {"config": config, "task": task, "workflow": config["current-workflow"]}
+    return template.render(context)
+
+
+def render_content(task, template_string, config, logger):
+    logger.debug(f"Render content for task {task['id']}")
+    jinja_config = get_jinja_config(config)
+
+    if "custom_delimiters" in jinja_config:
+        logger.debug("Creating Jinja environment using custom delimiters")
+        custom_delimiters = jinja_config["custom_delimiters"]
+        template_env = jinja2.Environment(
+            block_start_string=custom_delimiters.get("block_start_string", "{%"),
+            block_end_string=custom_delimiters.get("block_end_string", "%}"),
+            variable_start_string=custom_delimiters.get("variable_start_string", "{{"),
+            variable_end_string=custom_delimiters.get("variable_end_string", "}}"),
+            comment_start_string=custom_delimiters.get("comment_start_string", "{#"),
+            comment_end_string=custom_delimiters.get("comment_end_string", "#}"),
+        )
+    else:
+        template_env = jinja2.Environment()
+
+    template_env.filters["include_file_content"] = include_file_content
+    template_env.filters["get_git_diff"] = get_git_diff
+    template_env.filters["file_exists"] = file_exists
+    template_env.filters["select_task"] = select_task
+    template_env.filters["get_task_attribute"] = get_task_attribute
+
+    template = template_env.from_string(template_string)
+    context = {"config": config}
+    return template.render(context)
+
+
+def include_file_content(path):
+    with open(path, "r", encoding="utf-8") as file:
+        return file.read()
+
+
+def file_exists(path):
+    return os.path.exists(path)

coauthor/utils/jinja_filters.py

@@ -0,0 +1,53 @@
+import logging
+from coauthor.utils.logger import Logger
+import os
+
+
+class TaskNotFoundError(Exception):
+    """Exception raised when a task with the specified ID is not found."""
+
+    def __init__(self, task_id):
+        self.task_id = task_id
+        super().__init__(f"Task with ID {self.task_id} not found.")
+
+
+class AttributeNotFoundError(Exception):
+    """Exception raised when a specified attribute is not found in a task."""
+
+    def __init__(self, attribute):
+        self.attribute = attribute
+        super().__init__(f"Attribute '{self.attribute}' not found in task.")
+
+
+def select_task(config, task_id):
+    """
+    Select and return a task from a list of tasks based on its id.
+
+    :param tasks: a list of task dictionaries
+    :param id: the id of the task to find
+    :return: The task dictionary with the matching id
+    :raises TaskNotFoundError: If no task with the given id is found
+    """
+    workflow = config["current-workflow"]
+    for task in workflow["tasks"]:
+        if task.get("id") == task_id:
+            return task
+    raise TaskNotFoundError(task_id)
+
+
+def get_task_attribute(config, id, attribute):
+    """
+    Get a specific attribute from a task identified by id.
+
+    :param tasks: a list of task dictionaries
+    :param id: the id of the task from which to get the attribute
+    :param attribute: the attribute to retrieve from the task
+    :return: The value of the specified attribute in the task
+    :raises TaskNotFoundError: If no task with the given id is found
+    :raises AttributeNotFoundError: If the attribute does not exist in the task
+    """
+    task = select_task(config, id)
+    if attribute in task:
+        return task[attribute]
+    else:
+        raise AttributeNotFoundError(attribute)

coauthor/utils/logger.py

@@ -0,0 +1,43 @@
+import logging
+import os
+
+
+class Logger:
+    def __init__(self, name, level=logging.INFO, log_file=None):
+        if not log_file:
+            log_file = os.path.join(os.getcwd(), "coauthor.log")
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+        self.log_file = log_file
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(level)
+        file_handler.setFormatter(formatter)
+        self.logger.addHandler(file_handler)
+
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(formatter)
+        self.logger.addHandler(console_handler)
+
+    def clean_log_file(self):
+        if self.log_file and os.path.exists(self.log_file):
+            os.remove(self.log_file)
+            print(f"Log file '{self.log_file}' has been removed.")
+
+    def debug(self, msg):
+        self.logger.debug(msg)
+
+    def info(self, msg):
+        self.logger.info(msg)
+
+    def warning(self, msg):
+        self.logger.warning(msg)
+
+    def error(self, msg):
+        self.logger.error(msg)
+
+    # def exception(self, msg):
+    #     self.logger.exception(msg)

coauthor/utils/match_utils.py

@@ -0,0 +1,127 @@
+import os
+import re
+
+
+def file_submit_to_ai(config, logger):
+    """
+    Return the content of the file if it requires AI processing based on path and content matching criteria.
+
+    Parameters:
+    - path (str): The path of the file to be processed.
+    - task (dict): Configuration dictionary which contains optional keys 'regex_path' and
+      'regex_content' for path and content validation respectively.
+
+    Returns:
+    - str: The content of the file if both path and content match the specified regex patterns in
+      the task.
+    - None: If the content doesn't meet the regex requirements.
+
+    The function checks if the file path and content match the given regex patterns in the task.
+    """
+    path = config["current-task"]["path-modify-event"]
+    path_match = file_path_match(config, logger)
+    content_match = file_content_match(config, logger)
+    content = None
+    if path_match:
+        if content_match:
+            with open(path, "r", encoding="utf-8") as file1:
+                content = file1.read()
+    logger.debug(f"file_submit_to_ai: path_match: {path_match}, content_match: {content_match}")
+    return content
+
+
+def regex_content_match(content, regex, logger):
+    """
+    Determine if the given content matches any provided regex pattern.
+
+    Parameters:
+    - content (str): The content to be validated against the regex.
+    - regex (str or list): A single regex pattern or list of regex patterns to match against the content.
+
+    Returns:
+    - bool: True if the content matches any of the regex patterns, otherwise False.
+
+    The function checks the content against each regex pattern for a match.
+    """
+    if isinstance(regex, list):
+        for pattern in regex:
+            if isinstance(pattern, list):
+                sub_patterns_all_match = True
+                for sub_pattern in pattern:
+                    if not re.match(sub_pattern, content, re.IGNORECASE | re.DOTALL):
+                        logger.debug(f"regex_content_match: sub_patterns_all_match: False")
+                        sub_patterns_all_match = False
+                if sub_patterns_all_match:
+                    logger.debug(f"regex_content_match: match True for pattern: {pattern}, content: {content}")
+                    return True
+            else:
+                if re.match(pattern, content, re.IGNORECASE | re.DOTALL):  # TypeError: unhashable type: 'list'
+                    logger.debug(f"regex_content_match: match: True for pattern: {pattern}, content: {content}")
+                    return True
+    elif isinstance(regex, str):
+        if re.match(regex, content, re.IGNORECASE | re.DOTALL):
+            logger.debug(f"regex_content_match: match: True for regex: {regex}, content: {content}")
+            return True
+    return False
+
+
+def file_path_match(config, logger):
+    """
+    Check if the file path matches the regex pattern specified in the workflow.
+
+    Parameters:
+    - path (str): The file path to validate.
+    - workflow (dict): Configuration dictionary containing the 'path_patterns' for validation.
+
+    Returns:
+    - bool: True if the path matches the regex or if no 'path_patterns' is specified, otherwise False.
+    """
+    workflow = config["current-workflow"]
+    path = config["current-task"]["path-modify-event"]
+    if "path_patterns" in workflow:
+        return regex_content_match(path, workflow["path_patterns"], logger)
+    return True
+
+
+def file_content_match(config, logger):
+    """
+    Check if the file content matches the regex pattern specified in the workflow configuration.
+
+    Parameters:
+    - path (str): The path of the file whose content is to be validated.
+    - workflow (dict): Configuration dictionary containing the 'content_patterns' for content validation.
+
+    Returns:
+    - bool: True if the content matches the regex, otherwise False.
+    """
+    workflow = config["current-workflow"]
+    path = config["current-task"]["path-modify-event"]
+    if not os.path.exists(path):
+        logger.warning(f"file_content_match: path {path} does not exist!")
+        return False
+
+    if "content_patterns" in workflow:
+        logger.debug(f"file_content_match: content_patterns: {workflow['content_patterns']}")
+        with open(path, "r", encoding="utf-8") as file:
+            content = file.read()
+        if regex_content_match(content, workflow["content_patterns"], logger):
+            return True
+    else:
+        logger.warning(f"file_content_match: workflow has no content_patterns! So content match is false! ")
+        logger.debug(f"workflow: {workflow}")
+    return False
+
+
+def path_new_replace(path, search, replace):
+    """
+    Replace a portion of the path with a new string.
+
+    Parameters:
+    - path (str): The original path string.
+    - search (str): The substring to search for in the path.
+    - replace (str): The string to replace the search substring with.
+
+    Returns:
+    - str: The modified path with the substitutions made.
+    """
+    return path.replace(search, replace)

coauthor/utils/workflow_utils.py

@@ -0,0 +1,35 @@
+def get_all_watch_directories_from_workflows(config, logger):
+    return get_all_directories_from_workflows(config, logger, "watch")
+
+
+def get_all_scan_directories_from_workflows(config, logger):
+    return get_all_directories_from_workflows(config, logger, "scan")
+
+
+def get_all_directories_from_workflows(config, logger, watch_or_scan_key):
+    dirs = set()  # Use a set to ensure that directories are unique
+    for workflow in config["workflows"]:
+        if "filesystem" in workflow[watch_or_scan_key]:
+            dirs.update(workflow[watch_or_scan_key]["filesystem"]["paths"])
+    return list(dirs)  # Convert the set back to a list for the return value
+
+
+def get_workflows_that_watch(config, logger):
+    wtw = []
+    workflows = config["workflows"]
+    for workflow in workflows:
+        if "watch" in workflow:
+            wtw.append(workflow)
+    logger.debug(f"get_workflows_that_watch: workflows_that_watch: {wtw}")
+    return wtw
+
+
+def get_workflows_that_scan(config, logger):
+    workflows_that_scan = []
+    workflows = config["workflows"]
+
+    for workflow in workflows:
+        if "scan" in workflow:
+            workflows_that_scan.append(workflow)
+    logger.debug(f"get_workflows_that_scan: workflows_that_scan: {workflows_that_scan}")
+    return workflows_that_scan

coauthor-0.0.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE