qubership-pipelines-common-library 0.2.6__tar.gz → 2.0.1__tar.gz

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubership-pipelines-common-library
-Version: 0.2.6
+Version: 2.0.1
 Summary: Qubership Pipelines common library
 License: Apache-2.0
 License-File: LICENSE
@@ -24,6 +24,7 @@ Requires-Dist: python-gitlab (>=4.13.0,<5.0.0)
 Requires-Dist: python-jenkins (>=1.8.2,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
 Requires-Dist: urllib3 (>=2.2.3,<3.0.0)
 Requires-Dist: webexpythonsdk (==2.0.1)
 Description-Content-Type: text/markdown
@@ -37,7 +38,7 @@ Description-Content-Type: text/markdown
 
 Open-source python library of clients used by Qubership pipelines/modules.
 
-Library provides easy-to-use clients and wrappers for common devops services (e.g. Jenkins, MiniO, GitLab Pipelines)
+Library provides easy-to-use clients and wrappers for common DevOps services (e.g. Jenkins, MiniO, GitLab Pipelines)
 
 ## Sample implementation
 
@@ -49,7 +50,7 @@ It includes reference python implementation along with the [Development Guide](h
 
 Library is presented as a set of clients with predefined operations
 
-Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library) 
+Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library/mkdocs)
 
 ## Installation
 
@@ -61,6 +62,7 @@ Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages]
   ```
 
 - Or you can install it via `pip`:
+
   ```bash
   pip install qubership-pipelines-common-library
   ```

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/README.md

@@ -7,7 +7,7 @@
 
 Open-source python library of clients used by Qubership pipelines/modules.
 
-Library provides easy-to-use clients and wrappers for common devops services (e.g. Jenkins, MiniO, GitLab Pipelines)
+Library provides easy-to-use clients and wrappers for common DevOps services (e.g. Jenkins, MiniO, GitLab Pipelines)
 
 ## Sample implementation
 
@@ -19,7 +19,7 @@ It includes reference python implementation along with the [Development Guide](h
 
 Library is presented as a set of clients with predefined operations
 
-Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library) 
+Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages](https://netcracker.github.io/qubership-pipelines-common-python-library/mkdocs)
 
 ## Installation
 
@@ -31,6 +31,7 @@ Auto-generated reference (via mkdocs) is available on [this repo's GitHub Pages]
   ```
 
 - Or you can install it via `pip`:
+
   ```bash
   pip install qubership-pipelines-common-library
   ```

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qubership-pipelines-common-library"
-version = "0.2.6"
+version = "2.0.1"
 description = "Qubership Pipelines common library"
 authors = ["Qubership"]
 readme = "README.md"
@@ -23,6 +23,8 @@ webexpythonsdk = "2.0.1"
 ghapi = "^1.0.6"
 boto3 = "^1.39.4"
 google-cloud-artifact-registry = "^1.16.1"
+rich = "^14.2.0"
+# jira = "3.10.5"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^6.0.0"

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/__init__.py

@@ -14,4 +14,4 @@
 
 import sys, os
 current_path = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, current_path)
+sys.path.insert(0, current_path)

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/artifactory_client.py

@@ -84,7 +84,7 @@ class ArtifactoryAPI:
     def get_files_list(self, artifact_path: str):
         try:
             response = self._get(f"{self.api_url}/api/storage/{artifact_path}?list&deep=1&listFolders=1").json()
-            return [ArtifactListEntry(uri=f['uri'], size=int(f['size']), folder=f['folder'] == True) for f in
+            return [ArtifactListEntry(uri=f['uri'], size=int(f['size']), folder=(f['folder'] is True)) for f in
                     response['files']]
         except requests.exceptions.HTTPError as error:
             raise ArtifactoryError from error

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/execution/exec_command.py

@@ -15,9 +15,11 @@
 import logging
 import sys
 import traceback
+from abc import ABC, abstractmethod
 
 from qubership_pipelines_common_library.v1.execution.exec_context import ExecutionContext
 from qubership_pipelines_common_library.v1.utils.utils_context import create_execution_context
+from qubership_pipelines_common_library.v2.utils.crypto_utils import CryptoUtils
 
 
 class ExecutionCommand:
@@ -26,7 +28,9 @@ class ExecutionCommand:
     FAILURE_MSG = "Status: FAILURE"
 
     def __init__(self, context_path: str = None, input_params: dict = None, input_params_secure: dict = None,
-                 folder_path: str = None, parent_context_to_reuse: ExecutionContext = None):
+                 folder_path: str = None, parent_context_to_reuse: ExecutionContext = None,
+                 pre_execute_actions: list['ExecutionCommandExtension'] = None,
+                 post_execute_actions: list['ExecutionCommandExtension'] = None):
         """
         Extendable interface intended to simplify working with input/output params and passing them between commands in different Pipeline Executors
 
@@ -40,30 +44,66 @@ class ExecutionCommand:
             input_params_secure (dict): Secure parameters that will be merged into dynamically created params
             folder_path (str): Folder path where dynamically-created context will be stored. Optional, will create new temp folder if missing.
             parent_context_to_reuse (ExecutionContext): Optional, existing context to propagate input params from.
+            pre_execute_actions: Optional, list of actions, implementing ExecutionCommandExtension, to be executed before command
+            post_execute_actions: Optional, list of actions, implementing ExecutionCommandExtension, to be executed after command
         """
         if not context_path:
             context_path = create_execution_context(input_params=input_params, input_params_secure=input_params_secure,
                                                     folder_path=folder_path, parent_context_to_reuse=parent_context_to_reuse)
         self.context = ExecutionContext(context_path)
+        self._pre_execute_actions = []
+        if pre_execute_actions:
+            self._pre_execute_actions.extend(pre_execute_actions)
+        self._post_execute_actions = []
+        if post_execute_actions:
+            self._post_execute_actions.extend(post_execute_actions)
 
     def run(self):
         """Runs command following its lifecycle"""
         try:
+            self._log_command_class_name()
+            self._log_border_line()
+            self._log_input_params()
             if not self._validate():
                 logging.error(ExecutionCommand.FAILURE_MSG)
                 self._exit(False, ExecutionCommand.FAILURE_MSG)
+            self._pre_execute()
             self._execute()
+            self._post_execute()
             self._exit(True, ExecutionCommand.SUCCESS_MSG)
-        except Exception as e:
+        except Exception:
             logging.error(traceback.format_exc())
             self._exit(False, ExecutionCommand.FAILURE_MSG)
+        finally:
+            self._log_border_line()
+
+    def _log_command_class_name(self):
+        self.context.logger.info("command_class_name = %s", type(self).__name__)
+
+    def _log_border_line(self):
+        self.context.logger.info("=" * 60)
+
+    def _log_input_params(self):
+        self.context.logger.info(
+            "Input context parameters:\n%s\n%s",
+            CryptoUtils.get_parameters_for_print(self.context.input_params_secure.content, True),
+            CryptoUtils.get_parameters_for_print(self.context.input_params.content, False)
+        )
 
     def _validate(self):
         return self.context.validate(["paths.input.params"])
 
+    def _pre_execute(self):
+        for action in self._pre_execute_actions:
+            action.with_command(self).execute()
+
     def _execute(self):
         logging.info("Status: SKIPPED")
 
+    def _post_execute(self):
+        for action in self._post_execute_actions:
+            action.with_command(self).execute()
+
     def _exit(self, success: bool, message: str):
         if success:
             self.context.logger.info(message)
@@ -71,3 +111,24 @@ class ExecutionCommand:
         else:
             self.context.logger.error(message)
             sys.exit(1)
+
+
+class ExecutionCommandExtension(ABC):
+    """
+    Base interface used in ExecutionCommand pre_execute and post_execute actions
+    Can be extended by users to perform custom extension logic before and after execution
+    """
+
+    def __init__(self):
+        self.context = None
+        self.command = None
+
+    def with_command(self, command: ExecutionCommand) -> 'ExecutionCommandExtension':
+        self.command = command
+        self.context = command.context
+        return self
+
+    @abstractmethod
+    def execute(self) -> None:
+        """Implements custom extension logic"""
+        pass

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/execution/exec_context.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, logging
+import os
 
 from pathlib import Path
 from qubership_pipelines_common_library.v1.utils.utils_file import UtilsFile
@@ -40,7 +40,7 @@ class ExecutionContext:
         self.__init_temp_folder()
         self.__init_logger()
         # load context from files
-        logging.info(f"""Execution context params:
+        self.logger.debug(f"""Execution context params:
             paths.logs: {self.context.get("paths.logs")}
             paths.temp: {self.context.get("paths.temp")}
             paths.input.params: {self.context.get("paths.input.params")}
@@ -55,10 +55,10 @@ class ExecutionContext:
     def output_params_save(self):
         """Stores output_param files to disk"""
         if self.context.get("paths.output.params"):
-            logging.info(f"Writing insecure param file '{self.context.get('paths.output.params')}'")
+            self.logger.info(f"Writing insecure param file '{self.context.get('paths.output.params')}'")
             self.output_params.save(self.context.get("paths.output.params"))
         if self.context.get("paths.output.params_secure"):
-            logging.info(f"Writing secure param file '{self.context.get('paths.output.params_secure')}'")
+            self.logger.info(f"Writing secure param file '{self.context.get('paths.output.params_secure')}'")
             self.output_params_secure.save(self.context.get("paths.output.params_secure"))
 
     def input_param_get(self, path, def_value=None):
@@ -85,13 +85,13 @@ class ExecutionContext:
             if not self.__validate_param(key):
                 valid = False
                 if not silent:
-                    logging.error(f"Parameter '{key}' is mandatory but not defined")
+                    self.logger.error(f"Parameter '{key}' is mandatory but not defined")
         return valid
 
     def __validate_param(self, name):
         try:
             return self.context.get(name) or self.input_param_get(name)  # or self.__dict__.get(name)
-        except:
+        except Exception:
             return False
 
     def __input_params_load(self):

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/execution/exec_context_file.py

@@ -141,7 +141,7 @@ class ExecutionContextFile:
                 logging.error(f"Incorrect apiVersion value: {self.content['apiVersion']} in file '{full_path}'. "
                               f"Only '{ExecutionContextFile.SUPPORTED_API_VERSIONS}' are supported")
                 self.init_empty()
-        except FileNotFoundError as e:
+        except FileNotFoundError:
             self.init_empty()
 
     def save(self, path):

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/execution/exec_info.py

@@ -108,3 +108,7 @@ class ExecutionInfo:
     def with_params(self, params: dict):
         self.params = params
         return self
+
+    def __str__(self):
+        return (f"ExecutionInfo(id='{self.id}', url='{self.url}', status='{self.status}', "
+                f"time_start={self.time_start.isoformat()})")

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/execution/exec_logger.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging, os
+import logging
+import os
 
 
 class ExecutionLogger:
@@ -20,7 +21,8 @@ class ExecutionLogger:
     FILE_NAME_FULL = "full.log"
     EXECUTION_LOG_LEVEL = logging.INFO
     FULL_LOG_LEVEL = logging.DEBUG
-    DEFAULT_FORMAT = u'[%(asctime)s] [%(levelname)-5s] [class=%(filename)s:%(lineno)-3s] %(message)s'
+    DEFAULT_FORMAT = u'[%(asctime)s] [%(levelname)-7s] [class=%(filename)s:%(lineno)-3s] %(message)s'
+    LEVELNAME_COLORED_FORMAT = u'[%(asctime)s] [%(levelname_color_open_tag)s%(levelname)-7s%(levelname_color_close_tag)s] \\[class=%(filename)s:%(lineno)-3s] %(message)s'
 
     def __init__(self, path_logs):
         """
@@ -34,7 +36,9 @@ class ExecutionLogger:
         #  Also, file handlers are never removed
         self.path_logs = path_logs
         self.logger = logging.getLogger("execution_logger")
-        self.logger.setLevel(logging.DEBUG) # set to the lowest level to allow handlers to capture anything
+        self.logger.setLevel(logging.DEBUG)  # set to the lowest level to allow handlers to capture anything
+        self.logger.propagate = True
+
         if path_logs:
             # execution logs - only in local logger
             handler_exec = logging.FileHandler(os.path.join(path_logs, ExecutionLogger.FILE_NAME_EXECUTION))
@@ -46,9 +50,7 @@ class ExecutionLogger:
             handler_full = logging.FileHandler(os.path.join(path_logs, ExecutionLogger.FILE_NAME_FULL))
             handler_full.setLevel(ExecutionLogger.FULL_LOG_LEVEL)
             handler_full.setFormatter(logging.Formatter(ExecutionLogger.DEFAULT_FORMAT))
-            logging.getLogger().propagate = False
             logging.getLogger().addHandler(handler_full)
-        self.logger.propagate = True
 
     def info(self, msg, *args, **kwargs):
         self.logger.info(msg, *args, **kwargs)

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/github_client.py

@@ -51,11 +51,20 @@ class GithubClient:
 
     def __init__(self, token: str = None, api_url: str = None, **kwargs):
         """
+        This class is deprecated and will be removed in v3.0.0. Use class from v2 module instead.
         Arguments:
             token (str): Token used in auth request
             api_url (str): Optional Github Enterprise API URL, leave empty if using github.com
             **kwargs (Any): will be passed into Github API constructor
         """
+        if self.__class__ == GithubClient:
+            import warnings
+            warnings.warn(
+                "v1.github_client.GithubClient is deprecated since v2.0.0 and will be removed in v3.0.0. "
+                "Use v2.github.github_client.GithubClient instead.",
+                DeprecationWarning,
+                stacklevel=2
+            )
         self.gh = GhApi(token=token, gh_host=api_url, **kwargs)
         logging.info("Github Client configured")
 
@@ -143,7 +152,7 @@ class GithubClient:
                     logging.info(f"Workflow Run status: '{run.status}' is present in input break statuses list. Stop waiting.")
                     execution.stop()
                     break
-            except:
+            except Exception:
                 pass
             timeout += wait_seconds
             logging.info(f"Waiting workflow run execution timeout {wait_seconds} seconds")

{qubership_pipelines_common_library-0.2.6 → qubership_pipelines_common_library-2.0.1}/qubership_pipelines_common_library/v1/gitlab_client.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging, gitlab
-from time import sleep
+import logging, gitlab, time
+from pathlib import Path
+
 from gitlab import GitlabGetError
 from qubership_pipelines_common_library.v1.execution.exec_info import ExecutionInfo
 
@@ -36,6 +37,7 @@ class GitlabClient:
 
     def __init__(self, host: str, username: str, password: str, email: str = None, **kwargs):
         """
+        This class is deprecated and will be removed in v3.0.0. Use class from v2 module instead.
         Arguments:
             host (str): Gitlab instance URL
             username (str): User used in auth request, might be empty string if no auth is required
@@ -43,6 +45,14 @@ class GitlabClient:
             email (str): Email used when committing changes using API
             **kwargs (Any): will be passed into Gitlab API constructor
         """
+        if self.__class__ == GitlabClient:
+            import warnings
+            warnings.warn(
+                "v1.gitlab_client.GitlabClient is deprecated since v2.0.0 and will be removed in v3.0.0. "
+                "Use v2.gitlab.gitlab_client.GitlabClient instead.",
+                DeprecationWarning,
+                stacklevel=2
+            )
         self.host = host.rstrip("/")
         self.username = username
         self.email = email
@@ -120,7 +130,7 @@ class GitlabClient:
         while counter < timeout:
             counter += 1
             logging.info("Waiting pipeline execution timeout 1 second")
-            sleep(1)
+            time.sleep(1)
             continue
         pipeline.cancel()
         return execution.stop(ExecutionInfo.STATUS_ABORTED)
@@ -136,14 +146,17 @@ class GitlabClient:
             logging.error("Can't get pipeline status")
         return execution
 
-    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float = 10.0,
+    def wait_pipeline_execution(self, execution: ExecutionInfo, timeout_seconds: float = 180.0,
                                 break_status_list: list = None, wait_seconds: float = 1.0):
         """"""
         if break_status_list is None:
             break_status_list = self.BREAK_STATUS_LIST
-        timeout = 0
+        count_seconds = 0
+        last_log_time = time.perf_counter()
+        estimated_max_attempts = timeout_seconds // wait_seconds
+        retries = 0
         execution.with_status(execution.get_status())
-        while timeout < timeout_seconds:
+        while count_seconds < timeout_seconds:
             try:
                 project = self.gl.projects.get(execution.get_name(), lazy=True)
                 pipeline = project.pipelines.get(execution.get_id())
@@ -152,12 +165,15 @@ class GitlabClient:
                     logging.info(f"Pipeline status: '{pipeline.status}' contains in input break status list. Stop waiting.")
                     execution.stop()
                     break
-            except:
+            except Exception:
                 pass
-            timeout += wait_seconds
-            logging.info(f"Waiting pipeline execution timeout {wait_seconds} seconds")
-            sleep(wait_seconds)
-            continue
+            now = time.perf_counter()
+            retries += 1
+            if now - last_log_time >= 10.0:
+                logging.info(f"Made [{retries} of {estimated_max_attempts}] retries. Waiting pipeline execution {count_seconds} of {timeout_seconds}")
+                last_log_time = now
+            count_seconds += wait_seconds
+            time.sleep(wait_seconds)
         return execution
 
     @staticmethod
@@ -170,6 +186,69 @@ class GitlabClient:
                 return {"repo": url[:pos1], "branch": url[pos1 + len(part):pos2], "path": url[pos2 + 1:]}
         return None
 
+    def get_default_branch(self, project_id: str) -> str:
+        return self.gl.projects.get(project_id).default_branch
+
+    def get_latest_pipeline_id(self, project_id: str, ref: str) -> int | str:
+        project = self.gl.projects.get(project_id, lazy=True)
+        return project.pipelines.latest(ref=ref).get_id()
+
+    def get_latest_job(self, project_id: str, pipeline_id: str):
+        project = self.gl.projects.get(project_id, lazy=True)
+        pipeline = project.pipelines.get(pipeline_id, lazy=True)
+
+        jobs = pipeline.jobs.list(get_all=True)
+        logging.debug(f"All jobs from the pipeline: {jobs}")
+
+        # get jobs from downstream pipelines
+        bridges = pipeline.bridges.list(get_all=True)
+        logging.debug(f"Bridges: {bridges}")
+        for bridge in bridges:
+            downstream_pipeline_data = bridge.downstream_pipeline
+            downstream_project = self.gl.projects.get(downstream_pipeline_data.get('project_id'), lazy=True)
+            logging.debug(f"Getting jobs from a downstream pipeline: {downstream_pipeline_data.get('id')}...")
+            downstream_pipeline = downstream_project.pipelines.get(downstream_pipeline_data.get('id'))
+            jobs.extend(downstream_pipeline.jobs.list(get_all=True))
+
+        # get jobs from child pipelines
+        child_pipelines = project.pipelines.list(ref=f"downstream/{pipeline_id}", source="pipeline", all=True)
+        logging.debug(f"Child pipelines: {child_pipelines}")
+        for child_pipeline in child_pipelines:
+            logging.debug(f"Getting jobs from a child pipeline: {child_pipeline.id}...")
+            child_jobs = child_pipeline.jobs.list(get_all=True)
+            jobs.extend(child_jobs)
+
+        logging.debug(f"All jobs (+ jobs from downstream pipelines): {jobs}")
+        jobs = [j for j in jobs if j.started_at]
+        jobs = sorted(jobs, key=lambda j: j.started_at, reverse=True)
+        return jobs[0] if jobs else None
+
+    def download_job_artifacts(self, project_id, job_id, local_dir):
+        project = self.gl.projects.get(project_id, lazy=True)
+        job = project.jobs.get(job_id, lazy=True)
+        local_file = Path(local_dir, f"{job_id}.zip")
+        with local_file.open('wb') as f:
+            try:
+                job.artifacts(streamed=True, action=f.write)
+            except gitlab.GitlabGetError as e:
+                if e.response_code == 404:
+                    logging.warning(f"No artifacts for job {job_id}")
+                    return None
+                else:
+                    raise
+        logging.info(f"Artifacts downloaded to {local_file}")
+        return local_file
+
+    @staticmethod
+    def _cast_to_string(value) -> str:
+        if isinstance(value, str):
+            return value
+        if value is None:
+            return ''
+        if isinstance(value, bool):
+            return 'true' if value else 'false'
+        return str(value)
+
     def _map_status(self, git_status: str, default_status: str):
         result = default_status
         if git_status in (GitlabClient.STATUS_CREATED, GitlabClient.STATUS_WAITING,
@@ -186,3 +265,88 @@ class GitlabClient:
         elif git_status == GitlabClient.STATUS_MANUAL:
             result = ExecutionInfo.STATUS_MANUAL
         return result
+
+    # Related static methods, with direct REST access
+    @staticmethod
+    def is_gitlab_project_exist(gitlab_url, gitlab_project, gitlab_token):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token}
+        request = f"{gitlab_url}/api/v4/projects/{requests.utils.quote(gitlab_project, safe='')}"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.get(request, headers=headers)
+        if response.status_code == 200:
+            return True
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+        return False
+
+    @staticmethod
+    def search_group_id(gitlab_url, gitlab_project, gitlab_token):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token}
+        request = f"{gitlab_url}/api/v4/groups?search={gitlab_project}"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.get(request, headers=headers)
+        if response.status_code == 200:
+            groups = response.json()
+            for group in groups:
+                if group.get("full_path") == gitlab_project:
+                    return group["id"]
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+
+    @staticmethod
+    def create_internal_gitlab_project(gitlab_url, gitlab_token, group_id, repo_name, repo_branch, visibility="internal"):
+        """"""
+        import requests
+        headers = {"PRIVATE-TOKEN": gitlab_token, "Content-Type": "application/json"}
+        data = {
+            "name": repo_name,
+            "namespace_id": group_id,
+            "visibility": visibility,
+            "default_branch": repo_branch
+        }
+        request = f"{gitlab_url}/api/v4/projects"
+        logging.debug(f"Sending '{request}' request...")
+        response = requests.post(request, headers=headers, json=data)
+        if response.status_code == 201:
+            response_json = response.json()
+            logging.info(f"Gitlab project was created. Url: '{response_json['web_url']}'")
+            GitlabClient.make_first_commit_to_gitlab_project(
+                gitlab_url=gitlab_url,
+                gitlab_token=gitlab_token,
+                project_id=response_json['id'],
+                repo_branch=repo_branch
+            )
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")
+
+    @staticmethod
+    def make_first_commit_to_gitlab_project(gitlab_url, gitlab_token, project_id, repo_branch):
+        """"""
+        import requests
+        logging.debug("Making first commit...")
+        headers = {"PRIVATE-TOKEN": gitlab_token, "Content-Type": "application/json"}
+        commit_payload = {
+            "branch": repo_branch,
+            "commit_message": "Initial commit",
+            "actions": [
+                {
+                    "action": "create",
+                    "file_path": "README.md",
+                    "content": "# This is an automatically created project"
+                }
+            ]
+        }
+
+        response = requests.post(
+            f"{gitlab_url}/api/v4/projects/{project_id}/repository/commits",
+            headers=headers,
+            json=commit_payload
+        )
+        if response.status_code == 201:
+            logging.info("Commit successfull")
+        else:
+            logging.error(f"Error {response.status_code}: {response.text}")