GitHub ਮਰਜ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਲਈ PyGithub ਦੇ ਨਾਲ ਨਿਯਮਾਂ ਅਤੇ ਸ਼ਾਖਾ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ

GitHub ਨਾਲ ਮਰਜ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸੁਚਾਰੂ ਬਣਾਉਣਾ: ਮਰਜ ਕਤਾਰਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਇੱਕ ਗਾਈਡ

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

ਹਾਲਾਂਕਿ, ਮਰਜ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਅਤੇ ਕੌਂਫਿਗਰ ਕਰਨਾ ਇੱਕ ਸਵਿੱਚ ਨੂੰ ਫਲਿਪ ਕਰਨ ਜਿੰਨਾ ਸਿੱਧਾ ਨਹੀਂ ਹੈ। ਇਸ ਨੂੰ ਸਹੀ ਸੈੱਟਅੱਪ ਲਈ GitHub GraphQL API ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਨਿਯਮਾਂ ਰਾਹੀਂ। ਡਿਵੈਲਪਰ, ਮੇਰੇ ਵਰਗੇ, ਪੈਮਾਨੇ 'ਤੇ ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਅਕਸਰ ਚੁਣੌਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਸੈਂਕੜੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹੋ। ਮੈਨੂੰ ਯਾਦ ਹੈ GitHub ਚਰਚਾਵਾਂ ਵਿੱਚ ਡੂੰਘੀ ਗੋਤਾਖੋਰੀ ਕਰਨਾ ਅਤੇ ਵਿਲੀਨ ਕਤਾਰਾਂ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਮਦਦਗਾਰ ਪਰ ਅਜੇ ਵੀ ਗੁੰਝਲਦਾਰ ਸਪੱਸ਼ਟੀਕਰਨਾਂ 'ਤੇ ਠੋਕਰ. ਪਰ ਅਸਲ ਚਾਲ ਇਹ ਸਮਝ ਰਹੀ ਹੈ ਕਿ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸਮਰੱਥ ਕਰਨ ਲਈ ਸਹੀ ਗ੍ਰਾਫਿਕਯੂਐਲ ਪਰਿਵਰਤਨ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ। 🤔

ਸ਼ਾਖਾ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਦੇ ਨਾਲ ਮੇਰਾ ਪਹਿਲਾ ਅਨੁਭਵ ਥੋੜਾ ਇੱਕ ਬੁਝਾਰਤ ਵਰਗਾ ਸੀ। ਮੈਂ GraphQL ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਫਲਤਾਪੂਰਵਕ ਸ਼ਾਖਾਵਾਂ ਦੀ ਰੱਖਿਆ ਕਰਨ ਦੇ ਯੋਗ ਸੀ, ਪਰ ਵਿਲੀਨ ਕਤਾਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਵਧੇਰੇ ਖਾਸ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਗਾਈਡ ਦਾ ਟੀਚਾ ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣਾ ਹੈ ਕਿ ਤੁਹਾਡੀਆਂ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਵਿਲੀਨ ਕਤਾਰ ਨੂੰ ਕਿਵੇਂ ਸਮਰੱਥ ਕਰਨਾ ਹੈ, ਰਸਤੇ ਵਿੱਚ ਕੁਝ ਆਮ ਰੁਕਾਵਟਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ, ਅਤੇ ਇਹ ਦੱਸਣਾ ਹੈ ਕਿ ਕਿਵੇਂ PyGithub ਇਹਨਾਂ ਕਾਰਜਾਂ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਵਿੱਚ ਮੁੱਖ ਭੂਮਿਕਾ ਨਿਭਾ ਸਕਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਨਿਯਮਾਂ ਨੂੰ ਜੋੜਨ ਬਾਰੇ ਨਹੀਂ ਹੈ, ਇਹ ਉਹਨਾਂ ਨੂੰ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਇਕੱਠੇ ਕੰਮ ਕਰਨ ਬਾਰੇ ਹੈ। 💻

ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ GraphQL APIs ਅਤੇ ਨਿਯਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਮਰਜ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ API ਕਾਲਾਂ ਨਾਲ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਨੂੰ ਕਿਵੇਂ ਸਵੈਚਲਿਤ ਕਰਨਾ ਹੈ, ਅਤੇ ਭਾਵੇਂ ਤੁਸੀਂ ਪਰਿਵਰਤਨ ਨਾਲ ਚੁਣੌਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰ ਰਹੇ ਹੋ, ਇਹ ਗਾਈਡ ਸਪਸ਼ਟਤਾ ਪ੍ਰਦਾਨ ਕਰੇਗੀ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਵਿਕਲਪਾਂ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇਕਰ ਤੁਸੀਂ GraphQL ਨਾਲ ਸਿੱਧੇ ਕੰਮ ਕਰਨ ਦੀ ਬਜਾਏ PyGithub ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਹੋਰ ਹੈਂਡ-ਆਨ ਪਹੁੰਚ ਦੀ ਭਾਲ ਕਰ ਰਹੇ ਹੋ। ਵਿਹਾਰਕ ਉਦਾਹਰਣਾਂ ਅਤੇ ਕੁਝ ਸਮੱਸਿਆ-ਨਿਪਟਾਰਾ ਕਰਨ ਵਾਲੇ ਸੁਝਾਵਾਂ ਦੇ ਨਾਲ, ਅਸੀਂ ਤੁਹਾਡੇ GitHub ਅਨੁਭਵ ਨੂੰ ਹੋਰ ਕੁਸ਼ਲ ਬਣਾਉਣ ਦਾ ਟੀਚਾ ਰੱਖਦੇ ਹਾਂ। 🔧

ਸਕ੍ਰਿਪਟ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਕਿਸ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ

ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਟੀਚਾ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਲਈ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ GitHub ਦੇ GraphQL API ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਇੱਕ GraphQL ਪੁੱਛਗਿੱਛ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਰਿਪੋਜ਼ਟਰੀ ID ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ GitHub ਦੇ API ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਭੇਜ ਕੇ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ। ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਆਈਡੀ ਨੂੰ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਜਾਂ ਵਿਲੀਨ ਕਤਾਰਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਵਰਗੇ ਕਿਸੇ ਵੀ ਬਦਲਾਅ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਲੋੜੀਂਦਾ ਹੈ। `get_repository_id()` ਫੰਕਸ਼ਨ ਵਿੱਚ, ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਨਾਮ ਅਤੇ ਮਾਲਕ ਦੇ ਨਾਲ ਇੱਕ ਬੇਨਤੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਵਿਲੱਖਣ ID ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। API ਇਸ ID ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਸਾਨੂੰ ਸੁਰੱਖਿਆ ਨਿਯਮ ਬਣਾਉਣ ਦੇ ਨਾਲ ਅੱਗੇ ਵਧਣ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲਦੀ ਹੈ।

ਅਗਲਾ ਕਦਮ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਰਿਪੋਜ਼ਟਰੀ ID ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। `create_branch_protection_rule()` ਫੰਕਸ਼ਨ ਇੱਕ ਸ਼ਾਖਾ ਲਈ ਸੁਰੱਖਿਆ ਸੈੱਟ ਕਰਨ ਲਈ ਇੱਕ GraphQL ਮਿਊਟੇਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸੁਰੱਖਿਅਤ ਕੀਤੀ ਜਾਣ ਵਾਲੀ ਸ਼ਾਖਾ ਨੂੰ `BRANCH_PATTERN` ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਵਿੱਚ ਸਮੀਖਿਆਵਾਂ ਨੂੰ ਮਨਜ਼ੂਰੀ ਦੇਣ, ਸਥਿਤੀ ਜਾਂਚਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ, ਅਤੇ ਪ੍ਰਬੰਧਕ ਅਨੁਮਤੀਆਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਰਗੀਆਂ ਲੋੜਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਸੈਟਿੰਗਾਂ ਰਿਪੋਜ਼ਟਰੀ ਦੀਆਂ ਲੋੜਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਅਨੁਕੂਲਿਤ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਸਿਰਫ਼ ਪਾਸ ਕਰਨ ਵਾਲੇ ਬਿਲਡਾਂ ਨੂੰ ਮਿਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਸਖ਼ਤ ਮਨਜ਼ੂਰੀ ਵਾਲੇ ਵਰਕਫਲੋਜ਼ ਨੂੰ ਲਾਗੂ ਕਰਨਾ।

ਇੱਕ ਵਾਰ ਮਿਊਟੇਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਸਕ੍ਰਿਪਟ `requests.post` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ GitHub ਦੇ GraphQL API ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਭੇਜਦੀ ਹੈ। ਇਹ ਮਿਊਟੇਸ਼ਨ ਪੁੱਛਗਿੱਛ ਅਤੇ ਸੰਬੰਧਿਤ ਮਾਪਦੰਡਾਂ ਦੇ ਨਾਲ ਇੱਕ ਪੋਸਟ ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ। ਜੇਕਰ ਬੇਨਤੀ ਸਫਲ ਹੁੰਦੀ ਹੈ, ਤਾਂ API ਬਣਾਏ ਗਏ ਸੁਰੱਖਿਆ ਨਿਯਮ ਦੇ ਵੇਰਵੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। 'response.status_code' ਦੀ ਜਾਂਚ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਓਪਰੇਸ਼ਨ ਸਫਲ ਸੀ, ਅਤੇ ਜੇਕਰ ਕੋਈ ਤਰੁੱਟੀ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਇੱਕ ਅਪਵਾਦ ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਕਿ ਜੇਕਰ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਉਪਯੋਗਕਰਤਾ ਨੂੰ ਇੱਕ ਮਦਦਗਾਰ ਗਲਤੀ ਸੁਨੇਹੇ ਨਾਲ ਸੁਚੇਤ ਕਰ ਸਕਦੀ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਸਕ੍ਰਿਪਟ ਨੂੰ ਮਾਡਿਊਲਰ ਅਤੇ ਮਲਟੀਪਲ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਤੁਸੀਂ 'REPOSITORY_OWNER' ਅਤੇ 'REPOSITORY_NAME' ਵਰਗੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਕੇ ਇਸਨੂੰ ਆਸਾਨੀ ਨਾਲ 100 ਰਿਪੋਜ਼ਟਰੀਆਂ ਤੱਕ ਸਕੇਲ ਕਰ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਈ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਇੱਕੋ ਸੁਰੱਖਿਆ ਨਿਯਮਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਸਿਰਫ਼ ਇਨਪੁਟ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲ ਕੇ ਲਚਕਤਾ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ ਕਿ ਇਹ ਆਸਾਨੀ ਨਾਲ ਵੱਡੇ ਆਟੋਮੇਸ਼ਨ ਵਰਕਫਲੋਜ਼ ਵਿੱਚ ਏਕੀਕ੍ਰਿਤ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ CI/CD ਪਾਈਪਲਾਈਨਾਂ, ਜਿੱਥੇ ਸ਼ਾਖਾਵਾਂ ਦੀ ਰੱਖਿਆ ਕਰਨਾ ਜਾਂ ਇੱਕ ਅਭੇਦ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣਾ ਕਈ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਇਕਸਾਰ ਕੋਡ ਗੁਣਵੱਤਾ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। 🚀

import requests
GITHUB_API_URL = 'https://api.github.com/graphql'
TOKEN = 'your_token_here'
headers = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json"
}
# Repository and Branch details
REPOSITORY_OWNER = "your_owner_name"
REPOSITORY_NAME = "your_repo_name"
BRANCH_PATTERN = "main"
# GraphQL mutation for creating a merge queue rule
mutation = """
mutation($repositoryId: ID!, $branchPattern: String!) {
  createMergeQueueRule(input: {
    repositoryId: $repositoryId,
    pattern: $branchPattern,
    requiresStatusChecks: true,
    allowsMergeQueue: true,
  }) {
    mergeQueueRule {
      id
      pattern
      requiresStatusChecks
      allowsMergeQueue
    }
  }
}"""
# Query to fetch repository ID
repository_query = """
query($owner: String!, $name: String!) {
  repository(owner: $owner, name: $name) {
    id
  }
}"""
def get_repository_id():
    variables = {"owner": REPOSITORY_OWNER, "name": REPOSITORY_NAME}
    response = requests.post(
        GITHUB_API_URL,
        json={"query": repository_query, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        return response.json()["data"]["repository"]["id"]
    else:
        raise Exception(f"Failed to fetch repository ID: {response.json()}")
def enable_merge_queue(repository_id):
    variables = {
        "repositoryId": repository_id,
        "branchPattern": BRANCH_PATTERN,
    }
    response = requests.post(
        GITHUB_API_URL,
        json={"query": mutation, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        print("Merge queue rule created:", response.json()["data"]["createMergeQueueRule"]["mergeQueueRule"])
    else:
        raise Exception(f"Failed to create merge queue rule: {response.json()}")
# Execute
try:
    repository_id = get_repository_id()
    enable_merge_queue(repository_id)
except Exception as e:
    print("Error:", e)

from github import Github
import os
# GitHub access token and repository details
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
g = Github(GITHUB_TOKEN)
# Define the repository and branch pattern
repo_name = "your_repo_name"
branch_name = "main"
# Get the repository object
repo = g.get_repo(repo_name)
# Fetch the branch protection rule
branch = repo.get_branch(branch_name)
protection = branch.get_protection()
# Update branch protection to enable merge queue
protection.update(
    required_status_checks={"strict": True, "contexts": []},
    enforce_admins=True,
    allow_force_pushes=False,
    dismiss_stale_reviews=True,
    required_pull_request_reviews={"dismissal_restrictions": {}, "require_code_owner_reviews": True},
    merge_queue_enabled=True
)
# Display status
print(f"Merge queue enabled for branch {branch_name}")

GitHub ਦੇ GraphQL API ਅਤੇ ਨਿਯਮਾਂ ਦੇ ਨਾਲ ਮਰਜ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ

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

ਹਾਲਾਂਕਿ, ਮਲਟੀਪਲ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ GitHub ਦੇ GraphQL API ਦੀ ਇੱਕ ਠੋਸ ਸਮਝ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜੋ ਕਿ ਵਿਲੀਨ ਕਤਾਰ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਸਮੇਤ, ਰਿਪੋਜ਼ਟਰੀ ਸੈਟਿੰਗਾਂ 'ਤੇ ਵਧੇਰੇ ਦਾਣੇਦਾਰ ਨਿਯੰਤਰਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਕਿ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਨਿਯਮ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ GraphQL ਮਿਊਟੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁਕਾਬਲਤਨ ਸਿੱਧੀ ਹੈ, ਮਰਜ ਕਤਾਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਨਿਯਮਾਂ ਵਿੱਚ ਡੂੰਘੇ ਡੁਬਕੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਨਿਯਮ ਸੈੱਟ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ GitHub ਦੇ GraphQL API ਦੇ ਅੰਦਰ ਇੱਕ ਸੰਰਚਨਾ ਟੂਲ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਪੁੱਲ ਬੇਨਤੀ ਅਭੇਦ ਲਈ ਗੁੰਝਲਦਾਰ ਸ਼ਰਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ, ਜਿਸ ਵਿੱਚ ਤੁਹਾਡੇ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਮਾਪਦੰਡਾਂ ਦੇ ਅਧਾਰ ਤੇ PRs ਦੀ ਆਟੋਮੈਟਿਕ ਕਤਾਰ ਸ਼ਾਮਲ ਹੈ।

ਵਿਲੀਨ ਕਤਾਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੇ ਨਾਲ ਨਿਯਮਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਏਕੀਕਰਣ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸੰਭਾਵੀ ਰੁਕਾਵਟਾਂ ਜਾਂ ਤਰੁੱਟੀਆਂ ਤੋਂ ਬਚਦੇ ਹੋਏ, ਹਰੇਕ ਪੁੱਲ ਬੇਨਤੀ ਨੂੰ ਇੱਕ ਕ੍ਰਮਬੱਧ ਢੰਗ ਨਾਲ ਸੰਭਾਲਿਆ ਗਿਆ ਹੈ। ਇਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖ ਕੇ ਕਈ ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ GitHub ਦੇ GraphQL API ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਆਪਣੇ ਸੰਗਠਨ ਵਿੱਚ ਸੈਂਕੜੇ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ ਇਹਨਾਂ ਸੈਟਿੰਗਾਂ ਦੇ ਲਾਗੂਕਰਨ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਵਿਲੀਨ ਕਤਾਰ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਸਮਰੱਥ ਕਰਨ ਦੀ ਕੁੰਜੀ API ਦੇ ਮਿਊਟੇਸ਼ਨਾਂ ਦੀ ਸਹੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਅਭੇਦ ਕਤਾਰ ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਵਿਲੀਨ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਵੱਖ-ਵੱਖ ਕਿਨਾਰਿਆਂ ਦੇ ਮਾਮਲਿਆਂ ਨੂੰ ਸੰਭਾਲਣਾ ਹੈ। 🚀