remove deprecated pkg_resources (still required by ctranslate2)

import os

import importlib

import subprocess

import pkg_resources

from platform import platform

BRANCH = 'dev'

    sys.exit(app.exec())

def prepare_environment():

    try:

        import packaging

    except ModuleNotFoundError:

        run_pip(f"install packaging", "install packaging")

    from utils.package import check_req_file, check_reqs

    if getattr(sys, 'frozen', False):

        print('Running as app, skip dependency installation')

        return

    req_updated = False

    if sys.platform == 'win32':

        for req in REQ_WIN:

            try:

                pkg_resources.require(req)

            except Exception:

            if not check_reqs([req]):

                run_pip(f"install {req}", req)

                req_updated = True

    torch_command = os.environ.get('TORCH_COMMAND', "pip install torch==2.2.2 torchvision==0.17.2 --index-url https://download.pytorch.org/whl/cu118 --disable-pip-version-check")

    torch_command = os.environ.get('TORCH_COMMAND', "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128 --disable-pip-version-check")

    if args.reinstall_torch or not is_installed("torch") or not is_installed("torchvision"):

        run(f'"{python}" -m {torch_command}', "Installing torch and torchvision", "Couldn't install torch", live=True)

        req_updated = True

    try:

        pkg_resources.require(open(args.requirements,mode='r', encoding='utf8'))

    except Exception as e:

        print(e)

    if not check_req_file(args.requirements):

        run_pip(f"install -r {args.requirements}", "requirements")

        req_updated = True

import torch.nn as nn

from PIL import Image

from .yolov5_utils import make_divisible, initialize_weights, check_anchor_order, check_version, fuse_conv_and_bn

from .yolov5_utils import make_divisible, initialize_weights, check_anchor_order, fuse_conv_and_bn

def autopad(k, p=None):  # kernel, padding

    # Pad to 'same'

from operator import mod

from cv2 import imshow

from packaging.version import parse as package_version_parse

from .yolov5_utils import scale_img

from copy import deepcopy

from .common import *

    def _make_grid(self, nx=20, ny=20, i=0):

        d = self.anchors[i].device

        if check_version(torch.__version__, '1.10.0'):  # torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility

        if package_version_parse(torch.__version__) >= package_version_parse('1.10.0'):  # torch>=1.10.0 meshgrid workaround for torch>=0.7 compatibility

            yv, xv = torch.meshgrid([torch.arange(ny, device=d), torch.arange(nx, device=d)], indexing='ij')

        else:

            yv, xv = torch.meshgrid([torch.arange(ny, device=d), torch.arange(nx, device=d)])

import math

import torch

import torch.nn as nn

import pkg_resources as pkg

import torch.nn.functional as F

import cv2

import numpy as np

    # Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values

    return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}

def check_version(current='0.0.0', minimum='0.0.0', name='version ', pinned=False, hard=False):

    # Check version vs. required version

    current, minimum = (pkg.parse_version(x) for x in (current, minimum))

    result = (current == minimum) if pinned else (current >= minimum)  # bool

    if hard:  # assert min requirements met

        assert result, f'{name}{minimum} required by YOLOv5, but {name}{current} is currently installed'

    else:

        return result

class Colors:

    # Ultralytics color palette https://ultralytics.com/

class MyClient(Client64):

    def __init__(self, engine_path, engine_type: Literal['J2K', 'K2J'], dat_path):

        super(MyClient, self).__init__(module32=str(os.path.dirname(os.path.realpath(__file__))) + '\module_eztrans32.py',

        super(MyClient, self).__init__(module32=str(os.path.dirname(os.path.realpath(__file__))) + '/module_eztrans32.py',

                                       engine_path=engine_path,

                                       engine_type=engine_type,

                                       dat_path=dat_path)