$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?> வழிகாட்டி: Git மற்றும்

வழிகாட்டி: Git மற்றும் Python உடன் பதிப்புகளை தானியங்குபடுத்துங்கள்

Lucas Simon
திங்கள், 20 மே, 2024 ’அன்று’ முற்பகல் 9:34:05
Python Script

Git மற்றும் Python உடன் ஒரு பதிப்பு அமைப்பை உருவாக்குதல்

உங்கள் திட்டக் கோப்புகளின் பதிப்பை தானியக்கமாக்குவது, ஒழுங்கமைக்கப்பட்ட மற்றும் திறமையான மேம்பாட்டுப் பணிப்பாய்வுகளைப் பராமரிக்க மிகவும் முக்கியமானது. Git மற்றும் Python ஐப் பயன்படுத்துவதன் மூலம், ஒவ்வொரு உறுதிப்பாட்டிலும் பதிப்பு.py கோப்பைப் புதுப்பிக்கும் அமைப்பை நீங்கள் உருவாக்கலாம். உங்கள் திட்டப் பதிப்பு எப்போதும் துல்லியமாக இருப்பதையும், உங்கள் கோட்பேஸில் செய்யப்பட்ட சமீபத்திய மாற்றங்களைப் பிரதிபலிக்கிறது என்பதையும் இது உறுதி செய்கிறது.

இந்த வழிகாட்டியில், உங்கள் Git களஞ்சியத்திற்குத் தள்ளப்படும் ஒவ்வொரு முறையும் பதிப்பு.py கோப்பைத் தானாகவே புதுப்பிக்கும் முறையை நாங்கள் ஆராய்வோம். கமிட் விவரங்களைப் பிடிக்கும், பதிப்பு எண்ணை அதிகரிக்கும் மற்றும் உங்கள் Git பணிப்பாய்வுகளுடன் தடையின்றி ஒருங்கிணைக்கும் ஸ்கிரிப்டை செயல்படுத்துவது பற்றி நாங்கள் விவாதிப்போம்.

ஜிட் ஹூக்ஸைப் பயன்படுத்தி பைத்தானில் பதிப்பை தானியக்கமாக்குகிறது

முன் புஷ் ஹூக்கிற்கான பைதான் ஸ்கிரிப்ட்

#!/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])

பதிப்பு அதிகரிப்புக்கு Git Hook ஐ அமைத்தல்

ஷெல்லில் கிட் ஹூக் ஸ்கிரிப்ட்

#!/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) சூழல்களில் இது மிகவும் பயனுள்ளதாக இருக்கும். பதிப்புக் கோப்பு நம்பகமான முறையில் புதுப்பிக்கப்படுவதை உறுதிசெய்வது, ஒரு வலுவான வரிசைப்படுத்தல் பைப்லைனைப் பராமரிக்க உதவுகிறது, கையேடு பிழைகளைக் குறைக்கிறது மற்றும் வெளியீடுகளை ஒழுங்குபடுத்துகிறது.

  1. எனது Git களஞ்சியத்தில் பதிப்பை எவ்வாறு தானியங்குபடுத்துவது?
  2. ப்ரீ-புஷ் ஹூக் போன்ற Git ஹூக்குகள் மற்றும் ஒவ்வொரு கமிட்டிலும் ஒரு பதிப்பு கோப்பைப் புதுப்பிக்க ஸ்கிரிப்ட்களைப் பயன்படுத்தி நீங்கள் பதிப்பை தானியக்கமாக்கலாம்.
  3. முன் புஷ் ஹூக் என்றால் என்ன?
  4. ப்ரீ-புஷ் ஹூக் என்பது ஒரு ஜிட் ஹூக் ஆகும், இது மாற்றங்கள் ரிமோட் ரிபோசிட்டரிக்கு தள்ளப்படும் முன் ஸ்கிரிப்ட்களை இயக்கும். பதிப்புக் கோப்பைப் புதுப்பித்தல் போன்ற பணிகளைத் தானியக்கமாக்க இது பயன்படும்.
  5. ஜிட் ஹூக் ஸ்கிரிப்ட்டில் உள்ள கமிட் மெசேஜை எப்படி அணுகுவது?
  6. வழக்கமாகப் பயன்படுத்தி, ஸ்கிரிப்ட்டுக்கு ஒரு வாதமாக அனுப்பப்பட்ட கோப்பைப் படிப்பதன் மூலம் நீங்கள் கமிட் செய்தியை அணுகலாம் பைத்தானில் அல்லது ஷெல் ஸ்கிரிப்ட்டில்.
  7. சமீபத்திய Git கமிட் ஹாஷை எந்த கட்டளை மீட்டெடுக்கிறது?
  8. கட்டளை Git களஞ்சியத்தில் சமீபத்திய கமிட் ஹாஷை மீட்டெடுக்கிறது.
  9. ஸ்கிரிப்ட்டில் பதிப்பு எண்ணை எவ்வாறு அதிகரிப்பது?
  10. தற்போதைய பதிப்பைப் பிரித்தெடுக்க வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தவும், பேட்ச் எண்ணை அதிகரிக்கவும், புதிய பதிப்பு எண்ணுடன் பதிப்புக் கோப்பை மீண்டும் எழுதவும்.
  11. தொடர்ச்சியான ஒருங்கிணைப்பு கருவிகளுடன் இந்த முறையைப் பயன்படுத்தலாமா?
  12. ஆம், பில்ட்கள் மற்றும் வரிசைப்படுத்துதல்கள் முழுவதும் பதிப்பு நிலைத்தன்மையை உறுதிசெய்ய, ஜிட் ஹூக்குகள் மூலம் பதிப்பை தானியக்கமாக்குவது CI/CD பைப்லைன்களில் ஒருங்கிணைக்கப்படலாம்.
  13. தானியங்கி பதிப்பின் நன்மைகள் என்ன?
  14. தானியங்கு பதிப்பு கையேடு பிழைகளை குறைக்கிறது, நிலையான பதிப்பு கண்காணிப்பை உறுதி செய்கிறது மற்றும் மேம்பாடு மற்றும் வரிசைப்படுத்தல் செயல்முறையை ஒழுங்குபடுத்துகிறது.
  15. பதிப்புக் கோப்பு அடுத்த கமிட்டில் சேர்க்கப்பட்டுள்ளதை எவ்வாறு உறுதி செய்வது?
  16. பயன்படுத்தவும் பதிப்பு கோப்பை ஸ்கிரிப்ட் மூலம் புதுப்பிக்கப்பட்ட பிறகு அதை நிலைநிறுத்த.
  17. பதிப்பு கோப்பு இல்லை என்றால் என்ன நடக்கும்?
  18. பதிப்பு கோப்பு இல்லை என்றால், ஸ்கிரிப்ட் அதை 0.0.1 போன்ற ஆரம்ப பதிப்பு எண்ணுடன் உருவாக்கலாம்.
  19. Git hookகளுக்கு பிற நிரலாக்க மொழிகளைப் பயன்படுத்த முடியுமா?
  20. ஆம், உங்கள் விருப்பம் மற்றும் திட்டத் தேவைகளைப் பொறுத்து, பைதான், பாஷ் அல்லது பெர்ல் போன்ற பல்வேறு நிரலாக்க மொழிகளில் Git hook ஸ்கிரிப்ட்களை எழுதலாம்.

தானியங்கு பதிப்பு பற்றிய இறுதி எண்ணங்கள்

ஒவ்வொரு Git புஷ் மூலம் version.py கோப்பின் புதுப்பிப்பை தானியங்குபடுத்துவது உங்கள் திட்டப்பணிகளில் துல்லியமான பதிப்புக் கட்டுப்பாட்டைப் பராமரிப்பதற்கான நடைமுறை தீர்வாகும். வழங்கப்பட்ட ஸ்கிரிப்ட்கள் Git hooks மற்றும் Python ஐ இந்த செயல்முறையை தானியக்கமாக்குகின்றன, ஒவ்வொரு உறுதியும் புதுப்பிக்கப்பட்ட பதிப்பு எண், கமிட் செய்தி மற்றும் ஹாஷ் மூலம் கண்காணிக்கப்படுவதை உறுதி செய்கிறது. இந்த முறையைச் செயல்படுத்துவது உங்கள் பணிப்பாய்வுகளை பெரிதும் மேம்படுத்தலாம், மேலும் இது மிகவும் திறமையானது மற்றும் மனித பிழையின் வாய்ப்புகளைக் குறைக்கும். வழங்கப்பட்ட வழிகாட்டுதல்கள் மற்றும் எடுத்துக்காட்டுகளைப் பின்பற்றுவதன் மூலம், உங்கள் சொந்த மேம்பாட்டு நடைமுறைகளில் தானியங்கி பதிப்பை எளிதாக ஒருங்கிணைக்கலாம்.