pushing and pulling

[oceanblue42]

I create a project in vs code on local machine. I create a blank repo on github. I push my project to github. I make that repo a template. Another user then makes a repo from that template. from that repo he creates a codingspace. user adds two remotes to codigspace. 1) origin which points to his repo 2) template which points to my repo.

User needs to be able to pull from the template and push and pull to origin. We are trying to automate the process.

heres what devcontainer contains:

devcontainer.json

here's what .git/config contains on startup:

[core]
repositoryformatversion = 0
filemode = false
bare = false
logallrefupdates = true
ignorecase = true
[user]
name = Bob
email = rle@gmail.com
[remote "template"]
url = https://github.com/oceanblue42/python_class
fetch = +refs/heads/:refs/remotes/template/
[branch "master"]
remote = template
merge = refs/heads/master

I wanted to use rebase for the template pulls and merge for push and pull from/to origin. I keep getting divergent branches.

we just want to be able to pull from template and push/pull from origin using the UI in codingrooms.

the template (oceanblue42/python_class is know in advanced. The name of the other repo is not and will need to added through the ui. Is there a way to update "postCreateCommand": "git config --local commit.gpgsign false && git config --local branch.master.mergeOptions '--allow-unrelated-histories' && bash ./.devcontainer/setup.sh"

in the devcontainer to take care of the rest and once and forall resolve divergent path issue. the following should then work in the ui:

1. pull from template
2. pull from origin
3. push to origin

syncronize changes should work and not try to push back onto template

[SepehrAkbari]

Yeah you need to properly configure git pull behavior for the template remote and ensure that origin remains the default push destination. Here’s how to do it in postCreateCommand:

1. Rebase from Template

• Ensure pulling from template always rebases to avoid divergent branches.
• Set pull.rebase=true for template.

2. Merge for Origin

• Keep origin as the push/pull default.
• Ensure git pull from origin uses merge instead of rebase.

3. Set Upstream Correctly

• Ensure the default upstream branch is origin, not template.
• Allow unrelated histories if needed for the first merge.

Here is what you need to modify in devcontainer.json:

"postCreateCommand": "
    git config --local commit.gpgsign false &&
    git config --local pull.rebase true &&
    git config --local branch.master.rebase true &&
    git config --local branch.master.remote origin &&
    git config --local branch.master.merge refs/heads/master &&
    git config --local remote.template.fetch '+refs/heads/*:refs/remotes/template/*' &&
    git fetch template &&
    git rebase template/master &&
    git push origin master --force-with-lease &&
    echo 'Git setup complete!'"

So from now on, follow this:

1. Pull from Template (Rebase): git pull template master --rebase
2. Pull from Origin (Merge): git pull origin master
3. Push to Origin: git push origin master

Please mark this as helpful answer if this works!

[ghostinhershell]

Hey @oceanblue42, how's it going? Did @SepehrAkbari's response here answer your question?

[oceanblue42]

I was able to automate most of it with the following:

#!/usr/bin/env python3
import subprocess
import os
import sys
import json
import logging
import shutil

==============================================================================

SETUP LOGGING

==============================================================================

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

==============================================================================

CONFIGURATION CONSTANTS

==============================================================================

Define the folder structure for the project.

The main subfolders inside the project are: .devcontainer, classes, labs, and sanbox.

In addition, inside "classes" we want subfolders for each week (week00 to week12),

and inside "labs" we want subfolders for each lab (lab1 to lab5).

MAIN_SUBFOLDERS = [".devcontainer", "classes", "labs", "sandbox"]

SANDBOX_FOLDER = MAIN_SUBFOLDERS[-1]

Define subfolders for the "classes" folder (week folders).

(If you only want week01 to week12, change the range to start at 1.)

CLASSES_SUBFOLDERS = [f"classes/week{i:02}" for i in range(1, 13)] # week01 to week12

Define subfolders for the "labs" folder.

LABS_SUBFOLDERS = [f"labs/lab{i}" for i in range(1, 6)] # lab1 to lab5

Files to create in the project root

FILES_TO_CREATE = [".gitignore", "install_extensions.ps1", "read.md", "requirements.txt"]

Contents for the files

GITIGNORE_CONTENT = """

Virtual environment

venv/

Python cache files

pycache/
*.pyc

VS Code settings

.vscode/

Other

*.log
"""

REQUIREMENTS_NOTE = """

Python, VS Code, and Git need to be installed manually.

To install the recommended VS Code extensions, run:

./install_extensions.ps1

"""

INSTALL_EXTENSIONS_SCRIPT = """

VS Code extensions to install

$extensions = @(
"bierner.emojisense",
"michaelCurrin.auto-commit-msg",
"ms-python.black-formatter",
"github.codespaces",
"github.vscode-pull-request-github",
"github.github-vscode-theme",
"ms-toolsai.jupyter",
"esbenp.prettier-vscode",
"ms-python.python",
"ms-python.debugpy",
"ericsia.pythonsnippets3",
"ms-vscode.remote-repositories",
"emmanuelbeziat.vscode-great-icons"
)
foreach ($extension in $extensions) {
code --install-extension $extension
}
"""

Devcontainer configuration content for containerized development.

DEVCONTAINER_JSON_CONTENT = {
"name": "Python Dev Environment",
"image": "mcr.microsoft.com/devcontainers/python:3.10",
"features": {
"github-cli": "latest",
"ghcr.io/devcontainers/features/powershell:1": {}
},
"customizations": {
"vscode": {
"extensions": [
"bierner.emojisense",
"michaelCurrin.auto-commit-msg",
"ms-python.black-formatter",
"github.codespaces",
"github.vscode-pull-request-github",
"github.github-vscode-theme",
"ms-toolsai.jupyter",
"esbenp.prettier-vscode",
"ms-python.python",
"ms-python.debugpy",
"ericsia.pythonsnippets3",
"ms-vscode.cpptools",
"ms-vscode.cmake-tools",
"clangd.clangd",
"hashicorp.terraform",
"ms-vscode.azure-arm",
"hashicorp.terraform-docs",
"ms-vscode.powershell"
],
"settings": {
"python.defaultInterpreterPath": "${workspaceFolder}/venv/Scripts/python.exe",
"python.terminal.activateEnvironment": True,
"terminal.integrated.profiles.windows": {
"PowerShell": {
"path": "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe",
"args": [
"-NoExit",
"-Command",
"& { ${workspaceFolder}\venv\Scripts\Activate.ps1; Import-Module PSReadLine; Clear-Host }"
]
}
},
"terminal.integrated.defaultProfile.windows": "PowerShell"
}
}
},
# Use a relative path so that the setup script is found correctly.
"postCreateCommand": (
"git config --local commit.gpgsign false && "
"git config --local branch.master.mergeOptions '--allow-unrelated-histories' && "
"bash ./.devcontainer/setup.sh"
)
}

SETUP_SH_CONTENT = """#!/bin/bash

Exit immediately if any command fails

set -e

Create and activate a Python virtual environment

python -m venv venv
source venv/bin/activate

Install dependencies

pip install -r requirements.txt

Set up PowerShell profile for VS Code (if needed)

mkdir -p /home/vscode/.config/powershell
PROFILE="/home/vscode/.config/powershell/Microsoft.PowerShell_profile.ps1"
touch "$PROFILE"
echo "if (Test-Path venv/bin/Activate.ps1) { . venv/bin/Activate.ps1 }" >> "$PROFILE"
"""

==============================================================================

UTILITY FUNCTIONS

==============================================================================

def run_subprocess(command, cwd=None):
"""
Run a shell command and log its output.
"""
try:
logging.info(f"Running command: {command} (cwd={cwd})")
result = subprocess.run(
command, cwd=cwd, shell=True, text=True, check=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
if result.stdout.strip():
logging.info(f"Output: {result.stdout.strip()}")
if result.stderr.strip():
logging.warning(f"Error output: {result.stderr.strip()}")
except subprocess.CalledProcessError as e:
logging.error(f"Command '{command}' failed with code {e.returncode}")
logging.error(f"Error output: {e.stderr.strip()}")
sys.exit(e.returncode)

def get_project_folder():
"""
Prompt the user for a project folder name.
If nothing is provided, default to 'python_class'.
Returns the full path for the project folder.
"""
current_dir = os.getcwd()
logging.info(f"Current directory: {current_dir}")
name = input("Enter project folder name (all files will be contained in this folder; default 'python_class'): ").strip()
if not name:
name = "python_class"
logging.info("No project name provided. Using default: 'python_class'")
return os.path.join(current_dir, name)

def delete_existing_project_folder(project_folder):
"""
If the project folder exists, prompt the user to delete it.
"""
if os.path.exists(project_folder):
response = input(f"The folder '{project_folder}' already exists. Do you want to delete it? (y/n): ").strip().lower()
if response == 'y':
try:
shutil.rmtree(project_folder)
logging.info(f"Deleted existing folder: {project_folder}")
except Exception as e:
logging.error(f"Could not delete folder {project_folder}: {e}")
sys.exit(1)
else:
logging.info("Folder not deleted. Exiting to avoid overwriting files.")
sys.exit(0)

def create_folder_structure(project_root):
"""
Create the project folder and the defined subfolders inside it.
"""
os.makedirs(project_root, exist_ok=True)
logging.info(f"Created project folder: {project_root}")

# Create main subfolders (.devcontainer, classes, labs, sanbox)
for folder in MAIN_SUBFOLDERS:
    folder_path = os.path.join(project_root, folder)
    os.makedirs(folder_path, exist_ok=True)
    logging.info(f"Created subfolder: {folder_path}")

# Create subfolders for classes (week01 to week12)
for folder in CLASSES_SUBFOLDERS:
    folder_path = os.path.join(project_root, folder)
    os.makedirs(folder_path, exist_ok=True)
    # Create an empty file (.gitkeep) in each classes/weekXX folder
    open(os.path.join(folder_path, ".gitkeep"), "a").close()
    logging.info(f"Created classes subfolder with empty file: {folder_path}")

# Create subfolders for labs (lab1 to lab5)
for folder in LABS_SUBFOLDERS:
    folder_path = os.path.join(project_root, folder)
    os.makedirs(folder_path, exist_ok=True)
    # Create an empty file (.gitkeep) in each labs/labX folder
    open(os.path.join(folder_path, ".gitkeep"), "a").close()
    logging.info(f"Created labs subfolder with empty file: {folder_path}")
    
# Create empty file for sandbox folder
folder_path = os.path.join(project_root, SANDBOX_FOLDER)            
# Create an empty file (.gitkeep) in each labs/labX folder
open(os.path.join(folder_path, ".gitkeep"), "a").close()
logging.info(f"Created labs subfolder with empty file: {folder_path}")

def create_project_files(project_root):
"""
Create project files (.gitignore, install_extensions.ps1, read.md, requirements.txt)
in the project folder.
"""
for filename in FILES_TO_CREATE:
file_path = os.path.join(project_root, filename)
with open(file_path, "w") as f:
if filename == ".gitignore":
f.write(GITIGNORE_CONTENT)
elif filename == "requirements.txt":
f.write(REQUIREMENTS_NOTE)
elif filename == "install_extensions.ps1":
f.write(INSTALL_EXTENSIONS_SCRIPT)
elif filename == "read.md":
f.write("# Readme\n")
logging.info(f"Created file: {file_path}")

def create_workspace_file(project_root):
"""
Create a VS Code workspace file in the project folder.
The file name is based on the project folder name.
"""
basename = os.path.basename(project_root)
workspace_filename = f"{basename}.code-workspace"
workspace_path = os.path.join(project_root, workspace_filename)
workspace_content = {
"folders": [{"path": "."}],
"settings": {
"python.defaultInterpreterPath": "${workspaceFolder}/venv/Scripts/python.exe",
"python.terminal.activateEnvironment": True,
"terminal.integrated.profiles.windows": {
"PowerShell": {
"path": "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe",
"args": [
"-NoExit",
"-Command",
"& { ${workspaceFolder}\venv\Scripts\Activate.ps1; Import-Module PSReadLine; Clear-Host }"
]
}
},
"terminal.integrated.defaultProfile.windows": "PowerShell"
}
}
with open(workspace_path, "w") as f:
json.dump(workspace_content, f, indent=4)
logging.info(f"Created workspace file: {workspace_path}")

def create_devcontainer_config(project_root):
"""
Create the .devcontainer folder with devcontainer.json and setup.sh inside the project folder.
"""
devcontainer_dir = os.path.join(project_root, ".devcontainer")
os.makedirs(devcontainer_dir, exist_ok=True)
logging.info(f"Created .devcontainer folder: {devcontainer_dir}")

devcontainer_file = os.path.join(devcontainer_dir, "devcontainer.json")
with open(devcontainer_file, "w") as f:
    json.dump(DEVCONTAINER_JSON_CONTENT, f, indent=4)
logging.info(f"Created devcontainer.json file: {devcontainer_file}")

setup_file = os.path.join(devcontainer_dir, "setup.sh")
with open(setup_file, "w") as f:
    f.write(SETUP_SH_CONTENT)
os.chmod(setup_file, 0o775)
logging.info(f"Created and made executable: {setup_file}")

def initialize_git(project_root):
"""
Initialize a Git repository in the project folder.
"""
run_subprocess("git init", cwd=project_root)
logging.info("Initialized Git repository.")

def setup_virtual_environment(project_root):
"""
Create a Python virtual environment in the project folder.
"""
venv_path = os.path.join(project_root, "venv")
run_subprocess(f"{sys.executable} -m venv {venv_path}", cwd=project_root)
logging.info("Created Python virtual environment.")

def git_config_file(project_root):
import os, stat
logging.info("ENTERED sh()")

# Use the absolute path for the .devcontainer folder.
folder = os.path.join(project_root, ".devcontainer")

# Create the folder if it doesn't exist.
if not os.path.exists(folder):
    os.makedirs(folder)
    print(f"Created folder: {folder}")

file_path = os.path.join(folder, "setup2.ps1")

ps_script_content = r'''# .\devcontainer\setup2.ps1

Write-Host "Starting configuration..."

Retrieve the current branch name and trim whitespace.

$currentBranch = (git rev-parse --abbrev-ref HEAD).Trim()
Write-Host "Current branch: $currentBranch"
try {
$originUrl = git remote get-url origin 2>$null
if (-not $originUrl) {
Write-Error "ERROR: 'origin' remote not defined. Please add it."
exit 1
}
} catch {
Write-Error "ERROR: 'origin' remote not defined. Please add it."
exit 1
}
try {
$templateUrl = git remote get-url template 2>$null
if (-not $templateUrl) {
Write-Error "ERROR: 'template' remote not defined. Please add it."
exit 1
}
} catch {
Write-Error "ERROR: 'template' remote not defined. Please add it."
exit 1
}
Write-Host "Configuring branch '$currentBranch' to track origin/$currentBranch..."
git branch --unset-upstream $currentBranch 2>$null || $null
git branch --set-upstream-to=origin/$currentBranch $currentBranch

Write-Host "Setting up alias 'pull-template' to fetch and rebase from template/$currentBranch..."
git config --local alias.pull-template "!git fetch template && git rebase template/$currentBranch"

Write-Host "Setting pull strategy to use rebase by default..."
git config --local pull.rebase true

Write-Host "Configuration complete."
exit 0
'''

with open(file_path, "w", encoding="utf-8") as f:
    f.write(ps_script_content)
    print(f"Created file: {file_path}")

# On POSIX, set executable; on Windows it's not needed.
if os.name == "posix":
    st = os.stat(file_path)
    os.chmod(file_path, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
    print("Set executable permissions on setup2.ps1")

print("Setup script creation complete!")

def setup_project():
"""
Orchestrate the full project setup:
1. Get the project folder name.
2. Create the project folder (if needed) and all files/folders within it.
3. Set up the virtual environment.
4. Initialize a Git repository.
"""
project_root = get_project_folder()
logging.info(f"Setting up project in folder: {project_root}")

delete_existing_project_folder(project_root)
create_folder_structure(project_root)
create_project_files(project_root)
create_workspace_file(project_root)
create_devcontainer_config(project_root)

git_config_file(project_root)

setup_virtual_environment(project_root)
initialize_git(project_root)

logging.info("Project setup complete. All files and folders are contained within the project folder.")

==============================================================================

MAIN EXECUTION

==============================================================================

def main():
setup_project()

if name == "main":
main()