ഗൈഡ്: Git, Python എന്നിവ

Lucas Simon

2024, മേയ് 20, തിങ്കളാഴ്‌ച 9:20:47 AM

Git, Python എന്നിവ ഉപയോഗിച്ച് ഒരു വേർഷനിംഗ് സിസ്റ്റം ഉണ്ടാക്കുന്നു

നിങ്ങളുടെ പ്രോജക്റ്റ് ഫയലുകളുടെ പതിപ്പ് ഓട്ടോമേറ്റ് ചെയ്യുന്നത് സംഘടിതവും കാര്യക്ഷമവുമായ വികസന വർക്ക്ഫ്ലോ നിലനിർത്തുന്നതിന് നിർണായകമാണ്. Git, Python എന്നിവ ഉപയോഗിക്കുന്നതിലൂടെ, ഓരോ കമ്മിറ്റിലും ഒരു version.py ഫയൽ അപ്ഡേറ്റ് ചെയ്യുന്ന ഒരു സിസ്റ്റം നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും. ഇത് നിങ്ങളുടെ പ്രോജക്റ്റ് പതിപ്പ് എല്ലായ്പ്പോഴും കൃത്യമാണെന്നും നിങ്ങളുടെ കോഡ്ബേസിൽ വരുത്തിയ ഏറ്റവും പുതിയ മാറ്റങ്ങൾ പ്രതിഫലിപ്പിക്കുന്നുവെന്നും ഉറപ്പാക്കുന്നു.

ഈ ഗൈഡിൽ, നിങ്ങളുടെ Git റിപ്പോസിറ്ററിയിലേക്ക് ഓരോ പുഷ് ചെയ്യുമ്പോഴും ഒരു version.py ഫയൽ സ്വയമേവ അപ്ഡേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു രീതി ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. കമ്മിറ്റ് വിശദാംശങ്ങൾ ക്യാപ്‌ചർ ചെയ്യുന്നതും പതിപ്പ് നമ്പർ വർദ്ധിപ്പിക്കുന്നതും നിങ്ങളുടെ Git വർക്ക്ഫ്ലോയുമായി തടസ്സമില്ലാതെ സംയോജിപ്പിക്കുന്നതുമായ ഒരു സ്‌ക്രിപ്റ്റ് നടപ്പിലാക്കുന്നതിനെക്കുറിച്ച് ഞങ്ങൾ ചർച്ച ചെയ്യും.

Git Hooks ഉപയോഗിച്ച് പൈത്തണിൽ പതിപ്പ് ഓട്ടോമേറ്റ് ചെയ്യുന്നു

പ്രീ-പുഷ് ഹുക്കിനുള്ള പൈത്തൺ സ്ക്രിപ്റ്റ്

#!/usr/bin/env /usr/bin/python
import os
import subprocess
import re
import sys

commit_msg_file = sys.argv[1]
with open(commit_msg_file, 'r') as file:
    commit_msg = file.read().strip()

version_file = os.path.abspath('version.py')
hashed_code = subprocess.check_output(['git', 'rev-parse', 'HEAD']).strip().decode('utf-8')

if os.path.exists(version_file):
    print(f'Reading previous {version_file}')
    with open(version_file, 'r') as f:
        content = f.read()
        major, minor, patch = map(int, re.search(r'version = "(\d+)\.(\d+)\.(\d+)"', content).groups())
    patch += 1
else:
    print(f'Creating new {version_file}')
    major, minor, patch = 0, 0, 1

print(f'Writing contents of {version_file} with "{commit_msg}"')
with open(version_file, 'w') as f:
    f.write(f'''# This file is created by the pre-push script
class Version:
    comment = "{commit_msg}"
    hash = "{hashed_code}"
    version = "{major}.{minor}.{patch}"

if __name__ == "__main__":
    print(Version.version)
''')

subprocess.call(['git', 'add', version_file])

പതിപ്പ് വർദ്ധനയ്ക്കായി ജിറ്റ് ഹുക്ക് സജ്ജീകരിക്കുന്നു

ഷെല്ലിലെ ജിറ്റ് ഹുക്ക് സ്ക്രിപ്റ്റ്

#!/bin/sh

VERSION_PY="version.py"

# Get the commit message file from the arguments
COMMIT_MSG_FILE=$1

# Extract the commit message
COMMIT_MSG=$(cat $COMMIT_MSG_FILE)

# Get the latest commit hash
GIT_HASH=$(git rev-parse HEAD)

if [ -f "$VERSION_PY" ]; then
  VERSION=$(grep -oP '(?<=version = ")(\d+\.\d+\.\d+)' $VERSION_PY)
  IFS='.' read -r -a VERSION_PARTS <<< "$VERSION"
  VERSION_PARTS[2]=$((VERSION_PARTS[2] + 1))
  NEW_VERSION="${VERSION_PARTS[0]}.${VERSION_PARTS[1]}.${VERSION_PARTS[2]}"
else
  NEW_VERSION="0.0.1"
fi

echo "# This file is created by the pre-push script" > $VERSION_PY
echo "class Version:" >> $VERSION_PY
echo "    comment = \"$COMMIT_MSG\"" >> $VERSION_PY
echo "    hash = \"$GIT_HASH\"" >> $VERSION_PY
echo "    version = \"$NEW_VERSION\"" >> $VERSION_PY

git add $VERSION_PY

ഓട്ടോമേറ്റഡ് വേർഷനിംഗ് ഉപയോഗിച്ച് Git വർക്ക്ഫ്ലോ മെച്ചപ്പെടുത്തുന്നു

ഒരു Git വർക്ക്ഫ്ലോയ്ക്കുള്ളിലെ പതിപ്പിംഗ് ഓട്ടോമേറ്റ് ചെയ്യുന്നത് സ്ഥിരത ഉറപ്പാക്കുക മാത്രമല്ല, സോഫ്റ്റ്വെയർ പ്രോജക്റ്റുകളിൽ കണ്ടെത്താനുള്ള കഴിവ് മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. പതിപ്പ് മാനേജുമെൻ്റ് നേരിട്ട് Git ഹുക്കുകളിലേക്ക് സംയോജിപ്പിക്കുന്നതിലൂടെ, ഡവലപ്പർമാർക്ക് തടസ്സമില്ലാത്തതും കാര്യക്ഷമവുമായ ഒരു പ്രക്രിയ നിലനിർത്താൻ കഴിയും. ഓരോ കമ്മിറ്റിലും ഒരു പതിപ്പ് ഫയൽ സ്വയമേവ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് Git-ൻ്റെ പ്രീ-പുഷ് ഹുക്ക് ഉപയോഗിക്കുക എന്നതാണ് ഒരു സമീപനം. മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നതിനും കോഡ്‌ബേസിൻ്റെ ചരിത്രപരമായ റെക്കോർഡ് നിലനിർത്തുന്നതിനും ആവശ്യമായ കമ്മിറ്റ് സന്ദേശങ്ങളും ഹാഷ് മൂല്യങ്ങളും ക്യാപ്‌ചർ ചെയ്യുന്നത് ഈ രീതിയിൽ ഉൾപ്പെടുന്നു.

മാറ്റങ്ങൾ കൃത്യമായി പഴയപടിയാക്കാനുള്ള കഴിവാണ് മറ്റൊരു നിർണായക വശം. കാലികമായ ഒരു പതിപ്പ് ഫയൽ ഉപയോഗിച്ച്, ഡെവലപ്പർമാർക്ക് ഏത് പതിപ്പിലും പ്രോജക്റ്റിൻ്റെ കൃത്യമായ അവസ്ഥ കൃത്യമായി കണ്ടെത്താനാകും. ഓട്ടോമേഷൻ പ്രധാനമായ തുടർച്ചയായ സംയോജനത്തിലും വിന്യാസത്തിലും (CI/CD) പരിതസ്ഥിതികളിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഓരോ കമ്മിറ്റിലും പതിപ്പ് ഫയൽ വിശ്വസനീയമായി അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുന്നത് ശക്തമായ വിന്യാസ പൈപ്പ്‌ലൈൻ നിലനിർത്താനും മാനുവൽ പിശകുകൾ കുറയ്ക്കാനും റിലീസുകൾ കാര്യക്ഷമമാക്കാനും സഹായിക്കുന്നു.

Git, Python എന്നിവ ഉപയോഗിച്ച് ഓട്ടോമേറ്റ് ചെയ്യുന്ന പതിപ്പിനെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ

എൻ്റെ Git റിപ്പോസിറ്ററിയിൽ എനിക്ക് എങ്ങനെ പതിപ്പിംഗ് ഓട്ടോമേറ്റ് ചെയ്യാം?
പ്രീ-പുഷ് ഹുക്ക് പോലുള്ള Git ഹുക്കുകളും ഓരോ കമ്മിറ്റിലും ഒരു പതിപ്പ് ഫയൽ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുള്ള സ്‌ക്രിപ്‌റ്റുകളും ഉപയോഗിച്ച് നിങ്ങൾക്ക് പതിപ്പിംഗ് ഓട്ടോമേറ്റ് ചെയ്യാം.
എന്താണ് പ്രീ-പുഷ് ഹുക്ക്?
മാറ്റങ്ങൾ ഒരു റിമോട്ട് റിപ്പോസിറ്ററിയിലേക്ക് തള്ളുന്നതിന് മുമ്പ് സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്ന ഒരു Git ഹുക്ക് ആണ് പ്രീ-പുഷ് ഹുക്ക്. ഒരു പതിപ്പ് ഫയൽ അപ്‌ഡേറ്റ് ചെയ്യുന്നത് പോലുള്ള ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം.
ഒരു Git ഹുക്ക് സ്‌ക്രിപ്റ്റിലെ കമ്മിറ്റ് മെസേജ് എങ്ങനെ ആക്‌സസ് ചെയ്യാം?
സാധാരണയായി ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റിലേക്ക് ഒരു ആർഗ്യുമെൻ്റായി കൈമാറിയ ഫയൽ വായിച്ചുകൊണ്ട് നിങ്ങൾക്ക് കമ്മിറ്റ് സന്ദേശം ആക്സസ് ചെയ്യാൻ കഴിയും sys.argv പൈത്തണിൽ അല്ലെങ്കിൽ $1 ഒരു ഷെൽ സ്ക്രിപ്റ്റിൽ.
ഏറ്റവും പുതിയ Git കമ്മിറ്റ് ഹാഷ് വീണ്ടെടുക്കുന്ന കമാൻഡ് ഏതാണ്?
ആജ്ഞ git rev-parse HEAD Git റിപ്പോസിറ്ററിയിലെ ഏറ്റവും പുതിയ കമ്മിറ്റ് ഹാഷ് വീണ്ടെടുക്കുന്നു.
ഒരു സ്ക്രിപ്റ്റിലെ പതിപ്പ് നമ്പർ എങ്ങനെ വർദ്ധിപ്പിക്കും?
നിലവിലെ പതിപ്പ് എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാനും പാച്ച് നമ്പർ വർദ്ധിപ്പിക്കാനും പുതിയ പതിപ്പ് നമ്പർ ഉപയോഗിച്ച് പതിപ്പ് ഫയൽ വീണ്ടും എഴുതാനും പതിവ് എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കുക.
തുടർച്ചയായ ഇൻ്റഗ്രേഷൻ ടൂളുകൾ ഉപയോഗിച്ച് എനിക്ക് ഈ രീതി ഉപയോഗിക്കാമോ?
അതെ, ബിൽഡുകളിലും വിന്യാസങ്ങളിലും ഉടനീളം പതിപ്പ് സ്ഥിരത ഉറപ്പാക്കാൻ ജിറ്റ് ഹുക്കുകൾ ഉപയോഗിച്ചുള്ള പതിപ്പിംഗ് ഓട്ടോമേറ്റ് ചെയ്യുന്നത് സിഐ/സിഡി പൈപ്പ്ലൈനുകളിലേക്ക് സംയോജിപ്പിക്കാം.
ഓട്ടോമേറ്റഡ് പതിപ്പിംഗിൻ്റെ പ്രയോജനങ്ങൾ എന്തൊക്കെയാണ്?
സ്വയമേവയുള്ള പതിപ്പിംഗ് മാനുവൽ പിശകുകൾ കുറയ്ക്കുകയും സ്ഥിരമായ പതിപ്പ് ട്രാക്കിംഗ് ഉറപ്പാക്കുകയും വികസനവും വിന്യാസ പ്രക്രിയയും കാര്യക്ഷമമാക്കുകയും ചെയ്യുന്നു.
അടുത്ത കമ്മിറ്റിൽ പതിപ്പ് ഫയൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ടെന്ന് ഞാൻ എങ്ങനെ ഉറപ്പാക്കും?
ഉപയോഗിക്കുക git add സ്ക്രിപ്റ്റ് അപ്ഡേറ്റ് ചെയ്ത ശേഷം പതിപ്പ് ഫയൽ സ്റ്റേജ് ചെയ്യാൻ.
പതിപ്പ് ഫയൽ നിലവിലില്ലെങ്കിൽ എന്ത് സംഭവിക്കും?
പതിപ്പ് ഫയൽ നിലവിലില്ലെങ്കിൽ, സ്ക്രിപ്റ്റിന് 0.0.1 പോലെയുള്ള ഒരു പ്രാരംഭ പതിപ്പ് നമ്പർ ഉപയോഗിച്ച് അത് സൃഷ്ടിക്കാൻ കഴിയും.
Git ഹുക്കുകൾക്കായി മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉപയോഗിക്കാൻ കഴിയുമോ?
അതെ, നിങ്ങളുടെ മുൻഗണനയും പ്രോജക്റ്റ് ആവശ്യകതകളും അനുസരിച്ച് പൈത്തൺ, ബാഷ് അല്ലെങ്കിൽ പേൾ പോലുള്ള വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിങ്ങൾക്ക് Git ഹുക്ക് സ്ക്രിപ്റ്റുകൾ എഴുതാം.

ഓട്ടോമേറ്റഡ് വേർഷനിംഗിനെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ

നിങ്ങളുടെ പ്രോജക്റ്റുകളിൽ കൃത്യമായ പതിപ്പ് നിയന്ത്രണം നിലനിർത്തുന്നതിനുള്ള ഒരു പ്രായോഗിക പരിഹാരമാണ് ഓരോ Git പുഷ് ഉപയോഗിച്ചും ഒരു version.py ഫയലിൻ്റെ അപ്‌ഡേറ്റ് ഓട്ടോമേറ്റ് ചെയ്യുന്നത്. നൽകിയിരിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ ഈ പ്രക്രിയ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിന് Git ഹുക്കുകളും പൈത്തണും പ്രയോജനപ്പെടുത്തുന്നു, ഓരോ കമ്മിറ്റും ഒരു അപ്‌ഡേറ്റ് ചെയ്‌ത പതിപ്പ് നമ്പർ, കമ്മിറ്റ് സന്ദേശം, ഹാഷ് എന്നിവ ഉപയോഗിച്ച് ട്രാക്ക് ചെയ്യപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഈ രീതി നടപ്പിലാക്കുന്നത് നിങ്ങളുടെ വർക്ക്ഫ്ലോയെ വളരെയധികം വർദ്ധിപ്പിക്കുകയും ഇത് കൂടുതൽ കാര്യക്ഷമമാക്കുകയും മനുഷ്യ പിശകുകളുടെ സാധ്യത കുറയ്ക്കുകയും ചെയ്യും. നൽകിയിരിക്കുന്ന മാർഗ്ഗനിർദ്ദേശങ്ങളും ഉദാഹരണങ്ങളും പിന്തുടരുന്നതിലൂടെ, നിങ്ങളുടെ സ്വന്തം വികസന രീതികളിലേക്ക് നിങ്ങൾക്ക് സ്വയമേവയുള്ള പതിപ്പ് എളുപ്പത്തിൽ സമന്വയിപ്പിക്കാനാകും.

ഗൈഡ്: Git, Python എന്നിവ ഉപയോഗിച്ച് ഓട്ടോമേറ്റ് വേർഷനിംഗ്