$lang['tuto'] = "ಟ್ಯುಟೋರಿಯಲ್"; ?>$lang['tuto'] = "ಟ್ಯುಟೋರಿಯಲ್"; ?>$lang['tuto'] = "ಟ್ಯುಟೋರಿಯಲ್"; ?> ಮಾರ್ಗದರ್ಶಿ: Git ಮತ್ತು

ಮಾರ್ಗದರ್ಶಿ: Git ಮತ್ತು ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತ ಆವೃತ್ತಿ

Lucas Simon
ಸೋಮವಾರ, ಮೇ 20, 2024 09:15:31 ಪೂರ್ವಾಹ್ನ
Python Script

Git ಮತ್ತು ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಆವೃತ್ತಿ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವುದು

ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳ ಆವೃತ್ತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ಸಂಘಟಿತ ಮತ್ತು ದಕ್ಷ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವನ್ನು ನಿರ್ವಹಿಸಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ. Git ಮತ್ತು Python ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಪ್ರತಿ ಕಮಿಟ್‌ನೊಂದಿಗೆ version.py ಫೈಲ್ ಅನ್ನು ನವೀಕರಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸಬಹುದು. ಇದು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಆವೃತ್ತಿಯು ಯಾವಾಗಲೂ ನಿಖರವಾಗಿರುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ಗೆ ಮಾಡಿದ ಇತ್ತೀಚಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ನಿಮ್ಮ Git ರೆಪೊಸಿಟರಿಗೆ ಪ್ರತಿ ಪುಶ್ ಆದ ಮೇಲೆ version.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 ಹುಕ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಶೆಲ್‌ನಲ್ಲಿ ಜಿಟ್ ಹುಕ್ ಸ್ಕ್ರಿಪ್ಟ್

#!/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. ಪ್ರಿ-ಪುಶ್ ಹುಕ್ ಎನ್ನುವುದು Git ಹುಕ್ ಆಗಿದ್ದು, ಬದಲಾವಣೆಗಳನ್ನು ರಿಮೋಟ್ ರೆಪೊಸಿಟರಿಗೆ ತಳ್ಳುವ ಮೊದಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಆವೃತ್ತಿಯ ಫೈಲ್ ಅನ್ನು ನವೀಕರಿಸುವಂತಹ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.
  5. Git ಹುಕ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬದ್ಧತೆಯ ಸಂದೇಶವನ್ನು ನಾನು ಹೇಗೆ ಪ್ರವೇಶಿಸುವುದು?
  6. ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸಲಾದ ಫೈಲ್ ಅನ್ನು ಓದುವ ಮೂಲಕ ನೀವು ಕಮಿಟ್ ಸಂದೇಶವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಅಥವಾ ಶೆಲ್ ಲಿಪಿಯಲ್ಲಿ.
  7. ಇತ್ತೀಚಿನ Git ಕಮಿಟ್ ಹ್ಯಾಶ್ ಅನ್ನು ಯಾವ ಆಜ್ಞೆಯು ಹಿಂಪಡೆಯುತ್ತದೆ?
  8. ಆಜ್ಞೆ Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇತ್ತೀಚಿನ ಕಮಿಟ್ ಹ್ಯಾಶ್ ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ.
  9. ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯನ್ನು ನಾನು ಹೇಗೆ ಹೆಚ್ಚಿಸುವುದು?
  10. ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಯನ್ನು ಹೊರತೆಗೆಯಲು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸಿ, ಪ್ಯಾಚ್ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸಿ ಮತ್ತು ಹೊಸ ಆವೃತ್ತಿಯ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಆವೃತ್ತಿ ಫೈಲ್ ಅನ್ನು ಪುನಃ ಬರೆಯಿರಿ.
  11. ನಿರಂತರ ಏಕೀಕರಣ ಸಾಧನಗಳೊಂದಿಗೆ ನಾನು ಈ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದೇ?
  12. ಹೌದು, ಬಿಲ್ಡ್‌ಗಳು ಮತ್ತು ನಿಯೋಜನೆಗಳಾದ್ಯಂತ ಆವೃತ್ತಿಯ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು Git ಹುಕ್‌ಗಳೊಂದಿಗೆ ಆವೃತ್ತಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದನ್ನು CI/CD ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ ಸಂಯೋಜಿಸಬಹುದು.
  13. ಸ್ವಯಂಚಾಲಿತ ಆವೃತ್ತಿಯ ಪ್ರಯೋಜನಗಳೇನು?
  14. ಸ್ವಯಂಚಾಲಿತ ಆವೃತ್ತಿಯು ಹಸ್ತಚಾಲಿತ ದೋಷಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಸ್ಥಿರ ಆವೃತ್ತಿಯ ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಮತ್ತು ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.
  15. ಆವೃತ್ತಿಯ ಫೈಲ್ ಅನ್ನು ಮುಂದಿನ ಕಮಿಟ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ ಎಂದು ನಾನು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು?
  16. ಬಳಸಿ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ನವೀಕರಿಸಿದ ನಂತರ ಆವೃತ್ತಿಯ ಫೈಲ್ ಅನ್ನು ಹಂತಕ್ಕೆ ತರಲು.
  17. ಆವೃತ್ತಿ ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಏನಾಗುತ್ತದೆ?
  18. ಆವೃತ್ತಿಯ ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು 0.0.1 ನಂತಹ ಆರಂಭಿಕ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ರಚಿಸಬಹುದು.
  19. Git ಹುಕ್‌ಗಳಿಗಾಗಿ ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವೇ?
  20. ಹೌದು, ನಿಮ್ಮ ಆದ್ಯತೆ ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಪೈಥಾನ್, ಬ್ಯಾಷ್ ಅಥವಾ ಪರ್ಲ್‌ನಂತಹ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ನೀವು Git ಹುಕ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು.

ಸ್ವಯಂಚಾಲಿತ ಆವೃತ್ತಿಯ ಅಂತಿಮ ಆಲೋಚನೆಗಳು

ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ನಿಖರವಾದ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣವನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರತಿ Git ಪುಶ್‌ನೊಂದಿಗೆ version.py ಫೈಲ್‌ನ ನವೀಕರಣವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ಪ್ರಾಯೋಗಿಕ ಪರಿಹಾರವಾಗಿದೆ. ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು Git ಹುಕ್ಸ್ ಮತ್ತು ಪೈಥಾನ್ ಅನ್ನು ನಿಯಂತ್ರಿಸುತ್ತವೆ, ಪ್ರತಿ ಕಮಿಟ್ ಅನ್ನು ನವೀಕರಿಸಿದ ಆವೃತ್ತಿ ಸಂಖ್ಯೆ, ಕಮಿಟ್ ಸಂದೇಶ ಮತ್ತು ಹ್ಯಾಶ್‌ನೊಂದಿಗೆ ಟ್ರ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದರಿಂದ ನಿಮ್ಮ ಕೆಲಸದ ಹರಿವನ್ನು ಹೆಚ್ಚು ಹೆಚ್ಚಿಸಬಹುದು, ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ ಮತ್ತು ಮಾನವ ದೋಷದ ಸಾಧ್ಯತೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಒದಗಿಸಿದ ಮಾರ್ಗಸೂಚಿಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಸ್ವಂತ ಅಭಿವೃದ್ಧಿ ಅಭ್ಯಾಸಗಳಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತ ಆವೃತ್ತಿಯನ್ನು ನೀವು ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು.