hape 0.2.0__py3-none-any.whl

hape/bootstrap.py

@@ -0,0 +1,18 @@
+from hape.logging import logger
+from hape.config import Config
+from hape.models.deployment_cost_model import DeploymentCost
+
+def bootstrap_application():
+    logger.info("Checking configurations.")
+    Config.check_variables()
+
+    session = Config.get_db_session()
+    try:
+        DeploymentCost.initialize_from_sqlalchemy(DeploymentCost)
+        logger.info("Database initialized successfully!")
+    except Exception as e:
+        logger.error(f"Error initializing database: {e}")
+    finally:
+        session.close()
+
+    logger.info("Application started!")

hape/cli.py

@@ -0,0 +1,19 @@
+from hape.bootstrap import bootstrap_application
+from hape.argument_parsers.main_argument_parser import MainArgumentParser
+
+class CLI:
+    
+    @classmethod
+    def main():
+        bootstrap_application()
+        
+        main_parser = MainArgumentParser()
+        
+        parser = main_parser.create_parser()
+        args = parser.parse_args()
+
+        if args.command is None:
+            parser.print_help()
+            return
+
+        main_parser.run_action(args)

hape/config.py

@@ -0,0 +1,89 @@
+import os
+import json
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.sql import text
+from hape.logging import logger
+
+
+
+class Config:
+    _env_loaded = False
+    _db_session = None
+    _required_env_variables = ["HAPE_GITLAB_TOKEN", "HAPE_GITLAB_DOMAIN", "HAPE_MARIADB_HOST", "HAPE_MARIADB_USERNAME", "HAPE_MARIADB_PASSWORD", "HAPE_MARIADB_DATABASE"]
+
+    @staticmethod
+    def check_variables():
+        for variable in Config._required_env_variables:
+            Config._get_env_value(variable)
+
+    @staticmethod
+    def _load_environment():
+        if not Config._env_loaded:
+            if os.path.exists(".env"):
+                load_dotenv()
+            Config._env_loaded = True
+
+    @staticmethod
+    def _get_env_value(env):
+        Config._load_environment()
+        env_value = os.getenv(env)
+        
+        if not env_value and env in Config._required_env_variables:
+            logger.error(f"""One or more of the required environment variables is missing.
+
+To set the value of the environment variable run:
+$ export ENV_VARIABLE_NAME="value"
+
+The following environment variables are required:
+{json.dumps(Config._required_env_variables, indent=4)}
+""")
+            exit(1)
+        return env_value
+
+    @staticmethod
+    def get_db_url():
+        return f"mysql+pymysql://{Config.get_mysql_username()}:{Config.get_mysql_password()}@{Config.get_mysql_host()}/{Config.get_mysql_database()}"
+
+    @staticmethod
+    def get_db_session() -> sessionmaker:
+        if not Config._db_session:
+            try:
+                DATABASE_URL = Config.get_db_url()
+                engine = create_engine(DATABASE_URL, echo=True)
+                with engine.connect() as connection:
+                    connection.execute(text("SELECT 1"))
+
+                Config._db_session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+                logger.info("Database seassion created successfully.")
+            except OperationalError:
+                logger.error("Error: Unable to connect to the database. Please check the configuration.")
+                raise
+
+        return Config._db_session()
+
+    @staticmethod
+    def get_gitlab_token():
+        return Config._get_env_value("HAPE_GITLAB_TOKEN")
+    
+    @staticmethod
+    def get_gitlab_domain():
+        return Config._get_env_value("HAPE_GITLAB_DOMAIN")
+    
+    @staticmethod
+    def get_mysql_host():
+        return Config._get_env_value("HAPE_MARIADB_HOST")
+
+    @staticmethod
+    def get_mysql_username():
+        return Config._get_env_value("HAPE_MARIADB_USERNAME")
+
+    @staticmethod
+    def get_mysql_password():
+        return Config._get_env_value("HAPE_MARIADB_PASSWORD")
+
+    @staticmethod
+    def get_mysql_database():
+        return Config._get_env_value("HAPE_MARIADB_DATABASE")

hape/controllers/deployment_cost_controller.py

@@ -0,0 +1,7 @@
+from hape.base.model_controller import ModelController
+from hape.models.deployment_cost_model import DeploymentCost
+
+class DeploymentCostController(ModelController):
+    
+    def __init__(self):
+        super().__init__(DeploymentCost)

hape/controllers/git_controller.py

@@ -0,0 +1,39 @@
+class GitController:
+    def __init__(self):
+        self.git_model = GitModel()
+    
+    def clone_project_in_group(self, dir, group_id):
+        return self.git_model.clone_project_in_group(dir, group_id)
+    
+    def commit_projects(self, dir, message, prefix):
+        repos = self.git_model.get_repositories(dir, prefix)
+        
+        print("The following projects will be committed and pushed:")
+        print(json.dumps(repos, indent=2))
+        print(f"Total number of affected projects: {len(repos)}")
+        
+        user_input = input("Do you want to continue? (y/n): ").strip().lower()
+        if user_input != "y":
+            print("Aborting task...")
+            return
+        
+        for repo in repos:
+            print("==============================")
+            print(f"Directory: {repo}")
+            if self.git_model.commit_and_push(repo, message):
+                print("Changes committed and pushed successfully.")
+            else:
+                print("No changes to commit.")
+    
+    def pull_projects(self, dir, prefix):
+        repos = self.git_model.get_repositories(dir, prefix)
+        
+        print("The following projects will be pulled:")
+        print(json.dumps(repos, indent=2))
+        print(f"Total number of affected projects: {len(repos)}")
+        
+        for repo in repos:
+            print("==============================")
+            print(f"Directory: {repo}")
+            self.git_model.pull_project(repo)
+            print("Repository updated successfully.")

hape/enums/kube_context_enum.py

@@ -0,0 +1,6 @@
+import enum
+
+class KubeContextEnum(enum.Enum):
+    dev = "dev"
+    test = "test"
+    prod = "prod"

hape/hape_cli/argument_parsers/init_argument_parser.py

@@ -0,0 +1,21 @@
+from hape.hape_cli.controllers.init_controller import InitController
+
+class InitArgumentParser:
+    def __init__(self):
+        self.COMMAND = "init"
+
+    def create_subparser(self, subparsers):    
+        init_parser = subparsers.add_parser(self.COMMAND, help="Commands related to initializing the workspace")
+        init_parser_subparser = init_parser.add_subparsers(dest="action")
+
+        project_parser = init_parser_subparser.add_parser("project", help="Initializes a new project")
+        project_parser.add_argument("-n", "--name", required=True, help="Name of the project")
+
+    def run_action(self, args):
+        if args.command != self.COMMAND:
+            return
+        if args.action == "project":
+            InitController(args.name).init_project()
+        else:
+            print(f"Error: Invalid {args.command} action. Use `hape {args.command} --help` for more details.")
+            exit(1)

hape/hape_cli/argument_parsers/main_argument_parser.py

@@ -0,0 +1,28 @@
+import argparse
+from importlib.metadata import version
+
+from hape.hape_cli.argument_parsers.init_argument_parser import InitArgumentParser
+
+class MainArgumentParser:
+
+    def create_parser(self):
+        parser = argparse.ArgumentParser(description="HAPE Framework CLI")
+
+        try:
+            parser.add_argument("-v", "--version", action="version", version=version("hape"))
+        except:
+            parser.add_argument("-v", "--version", action="version", version="0.0.0")
+        
+        subparsers = parser.add_subparsers(dest="command")
+        
+        InitArgumentParser().create_subparser(subparsers)
+
+        return parser
+
+    def run_action(self, args):
+
+        if args.command == "init":
+            InitArgumentParser().run_action(args)
+        else:
+            print(f"Error: Invalid command {args.command}")
+            exit(1)

hape/hape_cli/cli.py

@@ -0,0 +1,19 @@
+from hape.bootstrap import bootstrap_application
+from hape.hape_cli.argument_parsers.main_argument_parser import MainArgumentParser
+
+class CLI:
+    
+    @classmethod
+    def main(cls):
+        bootstrap_application()
+        
+        main_parser = MainArgumentParser()
+        
+        parser = main_parser.create_parser()
+        args = parser.parse_args()
+
+        if args.command is None:
+            parser.print_help()
+            return
+
+        main_parser.run_action(args)

hape/hape_cli/controllers/init_controller.py

@@ -0,0 +1,11 @@
+from hape.hape_cli.models.init_model import Init
+import re
+
+class InitController:
+
+    def __init__(self, name):
+        self.__init = Init(name)
+        self.__init.validate()
+    
+    def init_project(self):
+        self.__init.init_project()

hape/hape_cli/models/init_model.py

@@ -0,0 +1,107 @@
+import os
+import re
+import sys
+from hape.logging import logger
+from hape.services.file_service import FileService
+
+class Init:
+
+    def __init__(self, name: str):
+        self.name = name
+        self.name_underscore = name.replace("-", "_")
+        self.file_service = FileService()
+        self.hape_framework_path = os.path.dirname(os.path.abspath(sys.argv[0]))
+        self.hape_files = [
+            ".dockerignore",
+            ".env.example",
+            ".gitignore",
+            "alembic.ini",
+            "main.py",
+            "Makefile",
+            "requirements-dev.txt",
+            "setup.py"
+        ]
+        self.hape_dirs = [
+            "dockerfiles",
+            "scripts",
+        ]
+
+        self.PROJECT_STRUCTURE = {
+            ".dockerignore": None,
+            ".env.example": None,
+            ".gitignore": None,
+            "alembic.ini": None,
+            "main.py": None,
+            "Makefile": None,
+            "README.md": None,
+            "requirements-dev.txt": None,
+            "setup.py": None,
+            "dockerfiles": [],
+            "scripts": [],
+            self.name_underscore: {
+                "argument_parsers": [".gitkeep"],
+                "cli.py": None,
+                "controllers": ["__init__.py"],
+                "enums": ["__init__.py"],
+                "migrations": ["README", "env.py", "script.py.mako"],
+                "migrations/versions": [".gitkeep"],
+                "models": ["__init__.py"],
+                "services": ["__init__.py"],
+            }
+        }
+
+    def __copy_hape_files(self):
+        for file in self.hape_files:
+            src_file = os.path.join(self.hape_framework_path, file)
+            dest_file = os.path.join(self.name, file)
+            logger.debug(f'Copying file: {src_file} -> {dest_file}')
+            self.file_service.copy_file(src_file, dest_file, overwrite=True)
+
+        for directory in self.hape_dirs:
+            src_dir = os.path.join(self.hape_framework_path, directory)
+            dest_dir = os.path.join(self.name, directory)
+            logger.debug(f'Copying directory: {src_dir} -> {dest_dir}')
+            self.file_service.copy_directory(src_dir, dest_dir)
+
+    def __init_project_structure_process_dictionary(self, dictionary: dict, root_path: str):
+        for key, value in dictionary.items():
+            sub_path = os.path.join(root_path, key)
+            if value is None:
+                logger.debug(f'Creating file: {sub_path}')
+                self.file_service.write_file(sub_path, "")
+            elif isinstance(value, str):
+                logger.debug(f'Creating file: {sub_path}')
+                self.file_service.write_file(sub_path, value)
+            elif isinstance(value, list):
+                logger.debug(f'Creating directory: {sub_path}')
+                self.file_service.create_directory(sub_path)
+                for file in value:
+                    logger.debug(f'Creating file: {sub_path}')
+                    self.file_service.write_file(os.path.join(sub_path, file), "")
+            elif isinstance(value, dict):
+                self.__init_project_structure_process_dictionary(value, sub_path)
+
+    def __init_project_structure(self):
+        logger.debug(f'Creating directory: {self.name}')
+        if self.file_service.path_exists(self.name):
+            logger.error(f"Error: directory '{self.name}' already exists.")
+            sys.exit(1)
+        self.file_service.create_directory(self.name)
+        self.__init_project_structure_process_dictionary(self.PROJECT_STRUCTURE, self.name)
+
+        readme_path = os.path.join(self.name, "README.md")
+        logger.debug(f'Creating file: {readme_path}')
+        self.file_service.write_file(readme_path, f"# {self.name}\n")
+
+    def validate(self):
+        name = self.name.strip()
+        logger.debug(f'Validating project name: {self.name}')
+        if not re.match(r'^[a-z0-9]+(-[a-z0-9]+)*$', name):
+            logger.error(f"Error: Project name '{name}' must contain only lowercase letters, numbers, and use '-' as a separator.")
+            sys.exit(1)
+        logger.debug(f'Valid project name.')
+
+    def init_project(self):
+        self.__init_project_structure()
+        self.__copy_hape_files()
+        logger.info(f'Project {self.name} has been successfully initialized!')

hape/logging.py

@@ -0,0 +1,59 @@
+import logging
+import logging.config
+import os
+from pythonjsonlogger import jsonlogger
+
+LOG_DIR = "logs"
+LOG_FILE = os.path.join(LOG_DIR, "app.log")
+
+if not os.path.exists(LOG_DIR):
+    os.makedirs(LOG_DIR)
+
+class CustomJsonFormatter(jsonlogger.JsonFormatter):
+    def parse(self):
+        return ["timestamp", "level", "name", "message", "module", "funcName", "lineno"]
+
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "standard": {
+            "format": "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+        },
+        "json": {
+            "()": CustomJsonFormatter,
+            "fmt": "%(timestamp)s %(level)s %(name)s %(message)s %(module)s %(funcName)s %(lineno)d"
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "standard",
+            "level": "DEBUG"
+        },
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "formatter": "json",
+            "level": "INFO",
+            "filename": LOG_FILE,
+            "maxBytes": 10485760,
+            "backupCount": 5
+        }
+    },
+    "loggers": {
+        "": {
+            "handlers": ["console", "file"],
+            "level": "DEBUG",
+            "propagate": False
+        },
+        "uvicorn": {
+            "handlers": ["console", "file"],
+            "level": "INFO",
+            "propagate": False
+        }
+    }
+}
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("global_logger")
+logger.info("Global logger initialized.")

hape/models/deployment_cost_model.py

@@ -0,0 +1,26 @@
+from sqlalchemy import Column, Integer, String, Float, Boolean, BigInteger
+from datetime import datetime
+from hape.base.model import Model
+
+class DeploymentCost(Model):
+    __tablename__ = 'deployment_costs'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    created_at = Column(BigInteger, default=lambda: int(datetime.utcnow().timestamp()), nullable=False)
+    service_name = Column(String(255), nullable=False)
+    pod_cpu = Column(String(50), nullable=False)
+    pod_ram = Column(String(50), nullable=False)
+    autoscaling = Column(Boolean, nullable=False)
+    min_replicas = Column(Integer, nullable=True)
+    max_replicas = Column(Integer, nullable=True)
+    current_replicas = Column(Integer, nullable=False)
+    pod_cost = Column(Float, nullable=False)
+    number_of_pods = Column(Integer, nullable=False)
+    total_cost = Column(Float, nullable=False)
+    cost_unit = Column(String(50), nullable=False)
+
+    def __init__(self, **kwargs):
+        filtered_kwargs = {key: kwargs[key] for key in self.__table__.columns.keys() if key in kwargs}
+        super().__init__(**filtered_kwargs)
+        for key, value in filtered_kwargs.items():
+            setattr(self, key, value)

hape/models/git_model.py

@@ -0,0 +1,31 @@
+from hape.services.git_service import GitService
+
+class GitModel:
+    def __init__(self):
+        self._git_service = GitService()
+    
+    def clone_project_in_group(self, dir, group_id):
+        self._git_service.clone_all_projects(group_id, dir)
+    
+    def get_repositories(self, dir, prefix):
+        return self._git_service.get_git_repositories(dir, prefix)
+    
+    def git_has_changes(self, repo):
+        return self._git_service.git_has_changes(repo)
+    
+    def git_branch_name(self, repo):
+        return self._git_service.git_branch_name(repo)
+    
+    def commit_and_push(self, repo, message):
+        if self.git_has_changes(repo):
+            branch_name = self.git_branch_name(repo)
+            self._git_service.git_pull(repo, branch_name)
+            self._git_service.git_add(repo)
+            self._git_service.git_commit(repo, message)
+            self._git_service.git_push(repo, branch_name)
+            return True
+        return False
+    
+    def pull_project(self, repo):
+        branch_name = self.git_branch_name(repo)
+        self._git_service.git_pull(repo, branch_name)

hape/models/gitlab_model.py

@@ -0,0 +1,61 @@
+import re
+from typing import List, Optional
+from datetime import datetime
+from gitlab import Gitlab
+from gitlab.v4.objects import Group, Project, GroupProject, ProjectCommit
+from hape.config import Config
+from hape.services.file_service import FileService
+
+class GitlabService:
+    def __init__(self):
+        gitlab_domain = Config.get_gitlab_domain()
+        gitlab_token = Config.get_gitlab_token()
+        self.client = Gitlab(f"https://{gitlab_domain}", private_token=gitlab_token)
+        self._per_page = 100
+    
+    def _get_project(self, id: int) -> Project:
+        return self.client.projects.get(id)
+    
+    def _get_projects(self, ids: list[int]) -> List[Project]:
+        return [self.client.projects.get(id) for id in ids]
+    
+    def _get_group_projects(self, group_id: int, recursive: bool = False, search: Optional[str] = None) -> List[GroupProject]:
+        group: Group = self.client.groups.get(group_id)
+        return group.projects.list(get_all=True, per_page=self._per_page, include_subgroups=recursive, search=search)        
+    
+    def _get_project_commits(self, project: Project, start_date: Optional[datetime] = None, end_date: Optional[datetime] = None) -> List[ProjectCommit]:
+        params = {"get_all": True}
+        if start_date:
+            params["since"] = start_date.isoformat()
+        if end_date:
+            params["until"] = end_date.isoformat()
+        
+        return project.commits.list(**params)
+    
+    def generate_csv_changes_in_cicd_repos(self, group_id: int, output_file: str, start_date: Optional[datetime] = None, end_date: Optional[datetime] = None, file_regex: Optional[str] = None):
+        
+        group_projects = self._get_group_projects(group_id, recursive=True, search="cicd-")
+        project_ids = [project.id for project in group_projects]
+        projects = self._get_projects(project_ids)
+
+        all_commits = []
+        for project in projects:
+            project_path = project.path.replace("cicd-", "")
+            commits = self._get_project_commits(project, start_date, end_date)
+            for commit in commits:
+                if commit.author_name == f"{project_path}-ci":
+                    continue
+
+                diff = commit.diff()
+                for change in diff:
+                    if file_regex and re.match(file_regex, change['new_path']):
+                        all_commits.append({
+                            "project_name": project.name,
+                            "commit_date": commit.committed_date,
+                            "commit_author": commit.author_name,
+                            "commit": commit.id,
+                            "web_url": commit.web_url
+                        })
+
+        FileService().write_csv_file(output_file, all_commits)
+        print(f"CSV report generated: {output_file}")

hape/playground.py

@@ -0,0 +1,72 @@
+import json
+from datetime import datetime
+from hape.models.deployment_cost_model import DeploymentCost
+from hape.controllers.deployment_cost_controller import DeploymentCostController
+from hape.services.gitlab_service import GitlabService
+from hape.services.file_service import FileService
+
+class Playground:
+
+    deployment_cost_controller = DeploymentCostController()
+
+    @classmethod
+    def main(self):
+        playground = Playground()
+        playground.play()
+        
+    def get_all_deployment_costs(self):
+        deployment_costs = DeploymentCost.get_all()
+        print(DeploymentCost.list_to_json(deployment_costs))
+
+    def save_deployment_cost(self):
+        deployment_cost = DeploymentCost(
+            service_name="Test Service",
+            pod_cpu="2",
+            pod_ram="4Gi",
+            autoscaling=True,
+            min_replicas=1,
+            max_replicas=5,
+            current_replicas=3,
+            pod_cost=0.10,
+            number_of_pods=3,
+            total_cost=0.30,
+            cost_unit="$"
+        )
+        if self.deployment_cost_controller.save(deployment_cost):
+            print('-----saved successfully-----')
+        else:
+            print('-----saving failed-----')
+        
+        print(deployment_cost.json())
+
+    def delete_deployment_cost(self):
+        deployment_cost = DeploymentCost.get(id=2)
+        if not deployment_cost:
+            print("Object id=2 does not exist!")
+            return
+        print(deployment_cost.json())
+        deployment_cost.delete()
+
+    def delete_all_deployment_cost(self):
+        print("delete all where id in [1,4] and service_name='Test Service'")
+        DeploymentCost.delete_all(id=["1", "4"], service_name="Test Service")
+
+    def generate_gitlab_changes_report(self):
+        gitlab = GitlaService()
+        start_date = datetime(2025, 2, 3)
+        end_date = datetime(2025, 2, 5)
+        gitlab.generate_csv_changes_in_cicd_repos(
+            group_id=178,
+            start_date=start_date,
+            end_date=end_date,
+            output_file="/Users/hazemataya/Desktop/workspace/innodp/playground/test.csv",
+            file_regex=r".*values.*.yaml"
+        )
+
+    def play(self):
+        Playground().save_deployment_cost()
+        Playground().get_all_deployment_costs()
+        Playground().delete_deployment_cost()
+        Playground().delete_all_deployment_cost()
+        Playground().generate_gitlab_changes_report()
+        pass