zrb 1.0.0a16__py3-none-any.whl → 1.0.0a20__py3-none-any.whl

zrb/runner/web_controller/static/session/event.js

@@ -0,0 +1,120 @@
+window.addEventListener("load", async function () {
+    // Get current session
+    if (cfg.SESSION_NAME != "") {
+        CURRENT_SESSION.pollCurrentSession();
+    }
+    // set maxStartDate to today
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);  // Move to the next day
+    tomorrow.setHours(0, 0, 0, 0);
+    const formattedTomorrow = UTIL.toLocalDateInputValue(tomorrow);
+    const maxStartAtInput = document.getElementById("max-start-at-input");
+    maxStartAtInput.value = formattedTomorrow;
+    // set minStartDate to yesterday
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);  // Set time to 00:00:00
+    const formattedToday = UTIL.toLocalDateInputValue(today);
+    const minStartAtInput = document.getElementById("min-start-at-input");
+    minStartAtInput.value = formattedToday;
+    // Update session
+    PAST_SESSION.pollPastSession();
+});
+
+
+const submitTaskForm = document.getElementById("submit-task-form");
+submitTaskForm.addEventListener("input", async function(event) {
+    const currentInput = event.target;
+    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name]"));
+    const inputMap = {};
+    const fixedInputNames = [];
+    for (const input of inputs) {
+        fixedInputNames.push(input.name);
+        if (input === currentInput) {
+            inputMap[input.name] = currentInput.value;
+            break;
+        } else {
+            inputMap[input.name] = input.value;
+        }
+    }
+    const queryString = new URLSearchParams(
+        {query: JSON.stringify(inputMap)}
+    ).toString();
+    try {
+        // Send the AJAX request
+        const response = await fetch(`${cfg.INPUT_API_URL}?${queryString}`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json"
+            },
+        });
+        if (response.ok) {
+            const data = await response.json();
+            // Update the values of all subsequent inputs based on the response
+            Object.entries(data).forEach(([key, value]) => {
+                if (fixedInputNames.includes(key)) {
+                    return;
+                }
+                const input = submitTaskForm.querySelector(`[name="${key}"]`);
+                input.value = value;
+            });
+        } else {
+            console.error("Failed to fetch updated values:", response.statusText);
+        }
+    } catch (error) {
+        console.error("Error during fetch:", error);
+    }
+})
+
+
+function openPastSessionDialog(event) {
+    event.preventDefault();
+    const dialog = document.getElementById("past-session-dialog")
+    dialog.showModal();
+}
+
+
+function closePastSessionDialog(event) {
+    event.preventDefault();
+    const dialog = document.getElementById("past-session-dialog")
+    dialog.close();
+}
+
+
+async function submitNewSessionForm(event) {
+    // Prevent the form from submitting the traditional way
+    event.preventDefault();
+    // Select the form
+    const form = document.getElementById("submit-task-form");
+    // Initialize an empty object to hold form data
+    const formData = {};
+    // Iterate through each input in the form
+    Array.from(form.elements).forEach(element => {
+        // Only include inputs with a name attribute and ignore buttons
+        if (element.name && (element.type !== "button" && element.type !== "submit")) {
+            formData[element.name] = element.value;
+        }
+    });
+    // Convert formData to JSON
+    const jsonData = JSON.stringify(formData);
+    try {
+        // Send the AJAX request
+        const response = await fetch(cfg.SESSION_API_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: jsonData
+        });
+        if (response.ok) {
+            const data = await response.json();
+            cfg.SESSION_NAME = data.session_name;
+            history.pushState(null, "", `${cfg.CURRENT_URL}${cfg.SESSION_NAME}`);
+            await PAST_SESSION.getAndRenderPastSession(0);
+            await CURRENT_SESSION.pollCurrentSession();
+        } else {
+            console.error("Error:", response);
+        }
+    } catch (error) {
+        console.error("Error:", error);
+    }
+}

zrb/runner/web_controller/static/session/past-session.js

@@ -0,0 +1,138 @@
+const PAST_SESSION = {
+
+    async pollPastSession() {
+        while (true) {
+            await this.getAndRenderPastSession(cfg.PAGE);
+            await UTIL.delay(5000);
+        }
+    },
+
+    async getAndRenderPastSession(page) {
+        cfg.PAGE=page
+        const minStartAtInput = document.getElementById("min-start-at-input");
+        const minStartAt = UTIL.formatDate(minStartAtInput.value);
+        const maxStartAtInput = document.getElementById("max-start-at-input");
+        const maxStartAt = UTIL.formatDate(maxStartAtInput.value);
+        const queryString = new URLSearchParams({
+            page: page,
+            from: minStartAt,
+            to: maxStartAt,
+        }).toString();
+        try {
+            // Send the AJAX request
+            const response = await fetch(`${cfg.SESSION_API_URL}list?${queryString}`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+            });
+            if (response.ok) {
+                const {total, data} = await response.json();
+                this.showPastSession(page, total, data);
+            } else {
+                console.error("Error:", response);
+            }
+        } catch (error) {
+            console.error("Error:", error);
+        }
+    },
+
+    showPastSession(page, total, data) {
+        const ul = document.getElementById("past-session-ul");
+        ul.innerHTML = '';  // Clear existing content
+        data.forEach(item => {
+            const taskStatus = item.task_status[item.main_task_name];
+            const finalStatus = UTIL.getFinalTaskStatus(taskStatus);
+            const finalColor = UTIL.getFinalColor(finalStatus);
+            const taskHistories = taskStatus.history;
+            const taskStartTime = taskHistories.length > 0 ? taskHistories[0].time : ""
+            const li = document.createElement('li');
+            const a = document.createElement('a');
+            const dateSpan = document.createElement('span');
+            const statusSpan = document.createElement('span');
+            a.textContent = item.name;
+            a.target = '_blank';
+            a.href = `${cfg.UI_URL}${item.name}`;
+            li.appendChild(a);
+            statusSpan.style.marginLeft = "10px";
+            statusSpan.style.display = 'inline-block';
+            statusSpan.style.width = '15px';
+            statusSpan.style.height = '15px';
+            statusSpan.style.borderRadius = '50%';
+            statusSpan.style.border = '2px solid black';
+            statusSpan.style.backgroundColor = finalColor;
+            li.appendChild(statusSpan);
+            dateSpan.style.marginLeft = "10px";
+            dateSpan.textContent = taskStartTime;
+            li.appendChild(dateSpan);
+            ul.appendChild(li);
+        }); 
+        const paginationUl = document.getElementById("past-session-pagination-ul");
+        paginationUl.innerHTML = '';  // Clear previous pagination
+
+        const totalPages = Math.ceil(total / 10);  // Calculate total pages based on page size
+        const maxPagesToShow = 5;  // Number of pages to display around the current page
+        const halfMaxPages = Math.floor(maxPagesToShow / 2);
+        
+        // Add first page and previous controls
+        if (page > 0) {
+            paginationUl.appendChild(this.createPageLink("⟪", 0));  // Go to first page
+            paginationUl.appendChild(this.createPageLink("⟨", page - 1));  // Go to previous page
+        }
+
+        let startPage = Math.max(0, page - halfMaxPages);
+        let endPage = Math.min(totalPages - 1, page + halfMaxPages);
+
+        if (page <= halfMaxPages) {
+            endPage = Math.min(totalPages - 1, maxPagesToShow - 1);
+        } else if (page + halfMaxPages >= totalPages) {
+            startPage = Math.max(0, totalPages - maxPagesToShow);
+        }
+
+        if (startPage > 1) {
+            paginationUl.appendChild(this.createEllipsis());
+        }
+
+        // Add page links within the calculated range
+        for (let i = startPage; i <= endPage; i++) {
+            if (i === page) {
+                const pageLi = document.createElement('li');
+                pageLi.textContent = i + 1;
+                paginationUl.append(pageLi)
+            } else {
+                paginationUl.appendChild(this.createPageLink(i + 1, i))
+            }
+        }
+
+        // Add ellipsis after the end page if needed
+        if (endPage < totalPages - 2) {
+            paginationUl.appendChild(this.createEllipsis());
+        }
+
+        // Add next and last page controls
+        if (page < totalPages - 1) {
+            paginationUl.appendChild(this.createPageLink("⟩", page + 1));  // Go to next page
+            paginationUl.appendChild(this.createPageLink("⟫", totalPages - 1));  // Go to last page
+        }    
+    },
+
+    createPageLink(text, page) {
+        const li = document.createElement('li');
+        const link = document.createElement('a');
+        link.textContent = text;
+        link.href = '#';
+        link.onclick = (e) => {
+            e.preventDefault();
+            this.getAndRenderPastSession(page);
+        };
+        li.appendChild(link);
+        return li;
+    },
+
+    createEllipsis() {
+        const li = document.createElement('li');
+        li.textContent = '...';
+        return li;
+    },
+
+}

zrb/runner/web_util.py

@@ -1,5 +1,10 @@
 from pydantic import BaseModel
 
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config import User
+from zrb.task.any_task import AnyTask
+from zrb.util.group import get_non_empty_subgroups, get_subtasks
+
 
 class NewSessionResponse(BaseModel):
     session_name: str
@@ -14,3 +19,51 @@ def node_path_to_url(args: list[str]) -> str:
     pruned_args = [part for part in args if part.strip() != ""]
     stripped_url = "/".join(pruned_args)
     return f"/{stripped_url}/"
+
+
+def get_html_auth_link(user: User) -> str:
+    if user.is_guest and user.is_super_admin:
+        return f"Hi, {user.username}"
+    if user.is_guest:
+        return f'Hi, {user.username} <a href="/login">Login 🔑</a>'
+    return f'Hi, {user.username} <a href="/logout">Logout 🚪</a>'
+
+
+def get_html_subtask_info(user: User, parent_url: str, parent_group: AnyGroup) -> str:
+    subtasks = get_subtasks(parent_group, web_only=True)
+    task_li = "\n".join(
+        [
+            get_html_task_li(parent_url, alias, subtask)
+            for alias, subtask in subtasks.items()
+            if user.can_access_task(subtask)
+        ]
+    )
+    if task_li.strip() == "":
+        return ""
+    return f"<h5>Tasks</h5><ul>{task_li}</ul>"
+
+
+def get_html_task_li(parent_url: str, alias: str, task: AnyTask) -> str:
+    if not parent_url.endswith("/"):
+        parent_url += "/"
+    return f'<li><a href="{parent_url}{alias}">{alias}</a> {task.description}</li>'
+
+
+def get_html_subgroup_info(user: User, parent_url: str, parent_group: AnyGroup) -> str:
+    subgroups = get_non_empty_subgroups(parent_group, web_only=True)
+    group_li = "\n".join(
+        [
+            get_html_group_li(parent_url, alias, subgroup)
+            for alias, subgroup in subgroups.items()
+            if user.can_access_group(subgroup)
+        ]
+    )
+    if group_li.strip() == "":
+        return ""
+    return f"<h5>Groups</h5><ul>{group_li}</ul>"
+
+
+def get_html_group_li(parent_url: str, alias: str, group: AnyGroup) -> str:
+    if not parent_url.endswith("/"):
+        parent_url += "/"
+    return f'<li><a href="{parent_url}{alias}">{alias}</a> {group.description}</li>'

zrb/session_state_logger/any_session_state_logger.py

@@ -5,7 +5,6 @@ from zrb.session_state_log.session_state_log import SessionStateLog, SessionStat
 
 
 class AnySessionStateLogger(ABC):
-
     @abstractmethod
     def write(self, session_log: SessionStateLog):
         pass

zrb/session_state_logger/file_session_state_logger.py

@@ -3,10 +3,10 @@ import os
 
 from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
+from zrb.util.file import read_file, write_file
 
 
 class FileSessionStateLogger(AnySessionStateLogger):
-
     def __init__(self, session_log_dir: str):
         self._session_log_dir = session_log_dir
 
@@ -15,20 +15,16 @@ class FileSessionStateLogger(AnySessionStateLogger):
         session_dir_path = os.path.dirname(session_file_path)
         if not os.path.isdir(session_dir_path):
             os.makedirs(session_dir_path, exist_ok=True)
-        with open(session_file_path, "w") as f:
-            f.write(session_log.model_dump_json())
+        write_file(session_file_path, session_log.model_dump_json())
         start_time = session_log.start_time
         if start_time == "":
             return
         timeline_dir_path = self._get_timeline_dir_path(session_log)
-        os.makedirs(timeline_dir_path, exist_ok=True)
-        with open(os.path.join(timeline_dir_path, session_log.name), "w"):
-            pass
+        write_file(os.path.join(timeline_dir_path, session_log.name), "")
 
     def read(self, session_name: str) -> SessionStateLog:
         session_file_path = self._get_session_file_path(session_name)
-        with open(session_file_path, "r") as f:
-            return SessionStateLog.model_validate_json(f.read())
+        return SessionStateLog.model_validate_json(read_file(session_file_path))
 
     def list(
         self,

zrb/task/base_trigger.py

@@ -19,7 +19,6 @@ from zrb.xcom.xcom import Xcom
 
 
 class BaseTrigger(BaseTask):
-
     def __init__(
         self,
         name: str,

zrb/task/cmd_task.py

@@ -132,7 +132,7 @@ class CmdTask(BaseTask):
         if return_code != 0:
             ctx.log_error(f"Exit status: {return_code}")
             raise Exception(
-                f"Process {self._name} exited ({return_code}): {cmd_result.stderr}"
+                f"Process {self._name} exited ({return_code}): {cmd_result.error}"
             )
         ctx.log_info(f"Exit status: {return_code}")
         return cmd_result

zrb/task/llm_task.py

@@ -15,6 +15,7 @@ from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
 from zrb.util.attr import get_str_attr
 from zrb.util.cli.style import stylize_faint
+from zrb.util.file import read_file, write_file
 from zrb.util.llm.tool import callable_to_tool_schema
 
 ListOfDict = list[dict[str, Any]]
@@ -32,7 +33,6 @@ def scratchpad(thought: str) -> str:
 
 
 class LLMTask(BaseTask):
-
     def __init__(
         self,
         name: str,
@@ -171,9 +171,7 @@ class LLMTask(BaseTask):
                     messages.append(tool_call_message)
                 continue
             if history_file != "":
-                os.makedirs(os.path.dirname(history_file), exist_ok=True)
-                with open(history_file, "w") as f:
-                    f.write(json.dumps(messages, indent=2))
+                write_file(history_file, json.dumps(messages, indent=2))
             return response_message.content
 
     def _get_model(self, ctx: AnyContext) -> str:
@@ -211,8 +209,7 @@ class LLMTask(BaseTask):
             and history_file != ""
             and os.path.isfile(history_file)
         ):
-            with open(history_file, "r") as f:
-                return json.loads(f.read())
+            return json.loads(read_file(history_file))
         return self._history
 
     def _get_history_file(self, ctx: AnyContext) -> str:

zrb/task/make_task.py

@@ -32,7 +32,6 @@ def make_task(
     group: AnyGroup | None = None,
     alias: str | None = None,
 ) -> Callable[[Callable[[AnyContext], Any]], AnyTask]:
-
     def _make_task(fn: Callable[[AnyContext], Any]) -> BaseTask:
         task = BaseTask(
             name=name,

zrb/task/scaffolder.py

@@ -30,9 +30,11 @@ class Scaffolder(BaseTask):
         destination_path: StrAttr | None = None,
         render_destination_path: bool = True,
         transform_path: TransformConfig = {},
+        render_transform_path: bool = True,
         transform_content: (
             list[AnyContentTransformer] | AnyContentTransformer | TransformConfig
         ) = [],
+        render_transform_content: bool = True,
         execute_condition: BoolAttr = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -70,7 +72,9 @@ class Scaffolder(BaseTask):
         self._destination_path = destination_path
         self._render_destination_path = render_destination_path
         self._content_transformers = transform_content
+        self._render_content_transformers = render_transform_content
         self._path_transformer = transform_path
+        self._render_path_transformer = render_transform_path
 
     def _get_source_path(self, ctx: AnyContext) -> str:
         return get_str_attr(ctx, self._source_path, "", auto_render=True)
@@ -80,9 +84,17 @@ class Scaffolder(BaseTask):
 
     def _get_content_transformers(self) -> list[AnyContentTransformer]:
         if callable(self._content_transformers):
-            return [ContentTransformer(match="*", transform=self._content_transformers)]
+            return [
+                ContentTransformer(match=".*", transform=self._content_transformers)
+            ]
         if isinstance(self._content_transformers, dict):
-            return [ContentTransformer(match="*", transform=self._content_transformers)]
+            return [
+                ContentTransformer(
+                    match=".*",
+                    transform=self._content_transformers,
+                    auto_render=self._render_content_transformers,
+                )
+            ]
         if isinstance(self._content_transformers, AnyContentTransformer):
             return [self._content_transformers]
         return self._content_transformers
@@ -117,17 +129,19 @@ class Scaffolder(BaseTask):
                     dest_file = os.path.join(
                         dest_dir, self._transform_path(ctx, file_name)
                     )
+                    ctx.log_info(f"Copying {src_file} to {dest_file}")
                     shutil.copy2(src_file, dest_file)
-                    ctx.log_info(f"Copied {src_file} to {dest_file}")
         else:
+            ctx.log_info(f"Copying {source_path} to {destination_path}")
             shutil.copy2(source_path, destination_path)
-            ctx.log_info(f"Copied {source_path} to {destination_path}")
 
     def _transform_path(self, ctx: AnyContext, file_path: str):
         if callable(self._path_transformer):
             return self._path_transformer(ctx, file_path)
         new_file_path = file_path
         for keyword, replacement in self._path_transformer.items():
+            if self._render_path_transformer:
+                replacement = ctx.render(replacement)
             new_file_path = new_file_path.replace(keyword, replacement)
         return new_file_path
 

zrb/task/scheduler.py

@@ -16,7 +16,6 @@ from zrb.xcom.xcom import Xcom
 
 
 class Scheduler(BaseTrigger):
-
     def __init__(
         self,
         name: str,

zrb/util/cmd/command.py

@@ -47,7 +47,6 @@ async def run_command(
     max_output_line: int = 1000,
     max_error_line: int = 1000,
 ) -> tuple[CmdResult, int]:
-
     async def __read_stream(
         stream, log_method: Callable[..., None], max_lines: int
     ) -> str:

zrb/util/codemod/{add_code_to_class.py → append_code_to_class.py}

@@ -4,7 +4,7 @@ import libcst as cst
 class ClassCodeAdder(cst.CSTTransformer):
     def __init__(self, class_name: str, new_code: str):
         self.class_name = class_name
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.class_found = False
 
     def leave_ClassDef(
@@ -15,17 +15,17 @@ class ClassCodeAdder(cst.CSTTransformer):
             self.class_found = True
             # Add the method to the class body
             new_body = updated_node.body.with_changes(
-                body=updated_node.body.body + (self.new_code,)
+                body=updated_node.body.body + tuple(self.new_code)
             )
             return updated_node.with_changes(body=new_body)
         return updated_node
 
 
-def add_code_to_class(original_code: str, class_name: str, method_code: str) -> str:
+def append_code_to_class(original_code: str, class_name: str, new_code: str) -> str:
     # Parse the original code into a module
     module = cst.parse_module(original_code)
     # Initialize transformer with the class name and method code
-    transformer = ClassCodeAdder(class_name, method_code)
+    transformer = ClassCodeAdder(class_name, new_code)
     # Apply the transformation
     modified_module = module.visit(transformer)
     # Check if the class was found

zrb/util/codemod/{add_code_to_function.py → append_code_to_function.py}

@@ -5,7 +5,7 @@ class FunctionCodeAdder(cst.CSTTransformer):
     def __init__(self, function_name: str, new_code: str):
         self.function_name = function_name
         # Use parse_module to handle multiple statements
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.function_found = False
 
     def leave_FunctionDef(
@@ -16,13 +16,15 @@ class FunctionCodeAdder(cst.CSTTransformer):
             self.function_found = True
             # Add the method to the class body
             new_body = updated_node.body.with_changes(
-                body=updated_node.body.body + (self.new_code,)
+                body=updated_node.body.body + tuple(self.new_code)
             )
             return updated_node.with_changes(body=new_body)
         return updated_node
 
 
-def add_code_to_function(original_code: str, function_name: str, new_code: str) -> str:
+def append_code_to_function(
+    original_code: str, function_name: str, new_code: str
+) -> str:
     # Parse the original code into a module
     module = cst.parse_module(original_code)
     # Initialize the transformer with the necessary information

zrb/util/codemod/{add_code_to_method.py → append_code_to_method.py}

@@ -6,7 +6,7 @@ class MethodCodeAdder(cst.CSTTransformer):
         self.class_name = class_name
         self.method_name = method_name
         # Use parse_module to handle multiple statements
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.class_found = False
         self.method_found = False
 
@@ -27,7 +27,7 @@ class MethodCodeAdder(cst.CSTTransformer):
                 ):
                     # Modify the target function by adding the new code
                     body_with_new_code = item.body.with_changes(
-                        body=item.body.body + (self.new_code,)  # Add the new code
+                        body=item.body.body + tuple(self.new_code)  # Add the new code
                     )
                     new_body.append(item.with_changes(body=body_with_new_code))
                     self.method_found = True
@@ -37,7 +37,7 @@ class MethodCodeAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_code_to_method(
+def append_code_to_method(
     original_code: str, class_name: str, function_name: str, new_code: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_key_to_dict.py → append_key_to_dict.py}

@@ -33,7 +33,7 @@ class DictionaryModifier(cst.CSTTransformer):
         return updated_node
 
 
-def add_key_to_dict(
+def append_key_to_dict(
     original_code: str, dictionary_name: str, new_key: str, new_value: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_param_to_function_call.py → append_param_to_function_call.py}

@@ -21,7 +21,7 @@ class FunctionCallParamAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_param_to_function_call(
+def append_param_to_function_call(
     original_code: str, func_name: str, new_param: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_code_to_module.py → prepend_code_to_module.py}

@@ -1,5 +1,5 @@
-def add_code_to_module(source_code: str, new_code: str) -> str:
-    lines = source_code.splitlines()
+def prepend_code_to_module(original_code: str, new_code: str) -> str:
+    lines = original_code.splitlines()
     last_import_index = -1
     for i, line in enumerate(lines):
         stripped_line = line.strip()

zrb/util/codemod/{add_parent_to_class.py → prepend_parent_to_class.py}

@@ -22,7 +22,7 @@ class ParentClassAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_parent_to_class(
+def prepend_parent_class(
     original_code: str, class_name: str, parent_class_name: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_property_to_class.py → prepend_property_to_class.py}

@@ -33,7 +33,7 @@ class ClassPropertyAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_property_to_class(
+def prepend_property_to_class(
     original_code: str,
     class_name: str,
     property_name: str,

zrb/util/file.py

@@ -0,0 +1,18 @@
+import os
+
+
+def read_file(file_path: str, replace_map: dict[str, str] = {}) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    for key, val in replace_map.items():
+        content = content.replace(key, val)
+    return content
+
+
+def write_file(file_path: str, content: str | list[str]):
+    if isinstance(content, list):
+        content = "\n".join([line for line in content if line is not None])
+    dir_path = os.path.dirname(file_path)
+    os.makedirs(dir_path, exist_ok=True)
+    with open(file_path, "w") as f:
+        f.write(content.strip())