$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?>$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?>$lang['tuto'] = "ਟਿ utorial ਟੋਰਿਅਲਸ"; ?> ਗਾਈਡ: ਗਿੱਟ ਅਤੇ ਪਾਈਥਨ

ਗਾਈਡ: ਗਿੱਟ ਅਤੇ ਪਾਈਥਨ ਨਾਲ ਆਟੋਮੇਟ ਵਰਜਨਿੰਗ

Lucas Simon
ਸੋਮਵਾਰ, 20 ਮਈ 2024 9:25:51 ਪੂ.ਦੁ.
Python Script

Git ਅਤੇ Python ਨਾਲ ਇੱਕ ਵਰਜਨਿੰਗ ਸਿਸਟਮ ਬਣਾਉਣਾ

ਇੱਕ ਸੰਗਠਿਤ ਅਤੇ ਕੁਸ਼ਲ ਵਿਕਾਸ ਵਰਕਫਲੋ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਤੁਹਾਡੀਆਂ ਪ੍ਰੋਜੈਕਟ ਫਾਈਲਾਂ ਦੇ ਸੰਸਕਰਣ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। 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])

ਸੰਸਕਰਣ ਵਾਧੇ ਲਈ ਗਿੱਟ ਹੁੱਕ ਸੈਟ ਅਪ ਕਰਨਾ

ਸ਼ੈੱਲ ਵਿੱਚ ਗਿੱਟ ਹੁੱਕ ਸਕ੍ਰਿਪਟ

#!/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 ਦੇ ਪ੍ਰੀ-ਪੁਸ਼ ਹੁੱਕ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹਰ ਇੱਕ ਕਮਿਟ ਦੇ ਨਾਲ ਇੱਕ ਵਰਜਨ ਫਾਈਲ ਨੂੰ ਆਟੋਮੈਟਿਕਲੀ ਅਪਡੇਟ ਕਰਨ ਲਈ. ਇਸ ਵਿਧੀ ਵਿੱਚ ਪ੍ਰਤੀਬੱਧ ਸੰਦੇਸ਼ਾਂ ਅਤੇ ਹੈਸ਼ ਮੁੱਲਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ, ਜੋ ਕਿ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਅਤੇ ਕੋਡਬੇਸ ਦੇ ਇਤਿਹਾਸਕ ਰਿਕਾਰਡ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹਨ।

ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਵਾਪਸ ਕਰਨ ਦੀ ਯੋਗਤਾ। ਇੱਕ ਅੱਪ-ਟੂ-ਡੇਟ ਸੰਸਕਰਣ ਫਾਈਲ ਦੇ ਨਾਲ, ਡਿਵੈਲਪਰ ਕਿਸੇ ਵੀ ਦਿੱਤੇ ਗਏ ਸੰਸਕਰਣ 'ਤੇ ਪ੍ਰੋਜੈਕਟ ਦੀ ਸਹੀ ਸਥਿਤੀ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹਨ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਅਤੇ ਤੈਨਾਤੀ (CI/CD) ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ, ਜਿੱਥੇ ਆਟੋਮੇਸ਼ਨ ਕੁੰਜੀ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਵਰਜਨ ਫਾਈਲ ਨੂੰ ਹਰੇਕ ਪ੍ਰਤੀਬੱਧਤਾ ਨਾਲ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਮਜ਼ਬੂਤ ​​ਤੈਨਾਤੀ ਪਾਈਪਲਾਈਨ ਨੂੰ ਬਣਾਈ ਰੱਖਣ, ਮੈਨੂਅਲ ਗਲਤੀਆਂ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਰੀਲੀਜ਼ਾਂ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

  1. ਮੈਂ ਆਪਣੀ Git ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸੰਸਕਰਣ ਨੂੰ ਕਿਵੇਂ ਸਵੈਚਲਿਤ ਕਰ ਸਕਦਾ ਹਾਂ?
  2. ਤੁਸੀਂ ਗੀਟ ਹੁੱਕਸ, ਜਿਵੇਂ ਕਿ ਪ੍ਰੀ-ਪੁਸ਼ ਹੁੱਕ, ਅਤੇ ਹਰੇਕ ਕਮਿਟ 'ਤੇ ਇੱਕ ਵਰਜਨ ਫਾਈਲ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੰਸਕਰਣ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰ ਸਕਦੇ ਹੋ।
  3. ਪ੍ਰੀ-ਪੁਸ਼ ਹੁੱਕ ਕੀ ਹੈ?
  4. ਇੱਕ ਪ੍ਰੀ-ਪੁਸ਼ ਹੁੱਕ ਇੱਕ ਗਿੱਟ ਹੁੱਕ ਹੈ ਜੋ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਧੱਕੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਇਹ ਵਰਜਨ ਫਾਈਲ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਵਰਗੇ ਕੰਮਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
  5. ਮੈਂ ਗਿੱਟ ਹੁੱਕ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਪ੍ਰਤੀਬੱਧ ਸੰਦੇਸ਼ ਨੂੰ ਕਿਵੇਂ ਐਕਸੈਸ ਕਰਾਂ?
  6. ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਲਈ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਪਾਸ ਕੀਤੀ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹ ਕੇ ਪ੍ਰਤੀਬੱਧ ਸੰਦੇਸ਼ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ, ਆਮ ਤੌਰ 'ਤੇ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪਾਈਥਨ ਵਿੱਚ ਜਾਂ ਇੱਕ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ.
  7. ਕਿਹੜੀ ਕਮਾਂਡ ਨਵੀਨਤਮ ਗਿੱਟ ਕਮਿਟ ਹੈਸ਼ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ?
  8. ਹੁਕਮ ਇੱਕ Git ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਨਵੀਨਤਮ ਕਮਿਟ ਹੈਸ਼ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।
  9. ਮੈਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਵਰਜਨ ਨੰਬਰ ਨੂੰ ਕਿਵੇਂ ਵਧਾਵਾਂ?
  10. ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ, ਪੈਚ ਨੰਬਰ ਵਧਾਉਣ, ਅਤੇ ਸੰਸਕਰਣ ਫਾਈਲ ਨੂੰ ਨਵੇਂ ਸੰਸਕਰਣ ਨੰਬਰ ਨਾਲ ਦੁਬਾਰਾ ਲਿਖਣ ਲਈ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।
  11. ਕੀ ਮੈਂ ਲਗਾਤਾਰ ਏਕੀਕਰਣ ਸਾਧਨਾਂ ਨਾਲ ਇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?
  12. ਹਾਂ, ਬਿਲਡਾਂ ਅਤੇ ਤੈਨਾਤੀਆਂ ਵਿੱਚ ਸੰਸਕਰਣ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਗਿੱਟ ਹੁੱਕਾਂ ਦੇ ਨਾਲ ਸਵੈਚਲਿਤ ਸੰਸਕਰਣ ਨੂੰ CI/CD ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
  13. ਸਵੈਚਲਿਤ ਸੰਸਕਰਣ ਦੇ ਕੀ ਫਾਇਦੇ ਹਨ?
  14. ਸਵੈਚਲਿਤ ਸੰਸਕਰਣ ਮੈਨੂਅਲ ਗਲਤੀਆਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਇਕਸਾਰ ਸੰਸਕਰਣ ਟਰੈਕਿੰਗ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਵਿਕਾਸ ਅਤੇ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਂਦਾ ਹੈ।
  15. ਮੈਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾਵਾਂ ਕਿ ਸੰਸਕਰਣ ਫਾਈਲ ਅਗਲੀ ਕਮਿਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਹੈ?
  16. ਵਰਤੋ ਸਕ੍ਰਿਪਟ ਦੁਆਰਾ ਅੱਪਡੇਟ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਵਰਜਨ ਫਾਈਲ ਨੂੰ ਪੜਾਅ ਦੇਣ ਲਈ।
  17. ਜੇਕਰ ਵਰਜਨ ਫਾਈਲ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?
  18. ਜੇਕਰ ਵਰਜਨ ਫਾਈਲ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਇਸਨੂੰ ਸ਼ੁਰੂਆਤੀ ਸੰਸਕਰਣ ਨੰਬਰ ਨਾਲ ਬਣਾ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ 0.0.1।
  19. ਕੀ ਗਿਟ ਹੁੱਕਾਂ ਲਈ ਹੋਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ?
  20. ਹਾਂ, ਤੁਸੀਂ ਆਪਣੀ ਤਰਜੀਹ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਲੋੜਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ, ਜਿਵੇਂ ਕਿ ਪਾਈਥਨ, ਬੈਸ਼, ਜਾਂ ਪਰਲ ਵਿੱਚ ਗਿੱਟ ਹੁੱਕ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖ ਸਕਦੇ ਹੋ।

ਆਟੋਮੇਟਿਡ ਵਰਜਨਿੰਗ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਹਰੇਕ ਗਿੱਟ ਪੁਸ਼ ਨਾਲ ਇੱਕ version.py ਫਾਈਲ ਦੇ ਅਪਡੇਟ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨਾ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਸਹੀ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਇੱਕ ਵਿਹਾਰਕ ਹੱਲ ਹੈ। ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ ਗਿੱਟ ਹੁੱਕਾਂ ਅਤੇ ਪਾਈਥਨ ਦਾ ਲਾਭ ਉਠਾਉਂਦੀਆਂ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ ਕਿ ਹਰੇਕ ਪ੍ਰਤੀਬੱਧਤਾ ਨੂੰ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤੇ ਸੰਸਕਰਣ ਨੰਬਰ, ਕਮਿਟ ਸੰਦੇਸ਼, ਅਤੇ ਹੈਸ਼ ਨਾਲ ਟਰੈਕ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਨੂੰ ਬਹੁਤ ਵਧਾ ਸਕਦਾ ਹੈ, ਇਸ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਮਨੁੱਖੀ ਗਲਤੀ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ। ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ਾਂ ਅਤੇ ਉਦਾਹਰਣਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਸਵੈਚਲਿਤ ਸੰਸਕਰਣ ਨੂੰ ਆਪਣੇ ਖੁਦ ਦੇ ਵਿਕਾਸ ਅਭਿਆਸਾਂ ਵਿੱਚ ਜੋੜ ਸਕਦੇ ਹੋ।