Convertir batchfile .bat pour démarer python avec ses librairies en un équivalent qui serait accepté par MAC

Pour lancer une application python j'utilise Visual Studio sans environnement particulier.
Ceci fonctionne.
J’appelle alors dans le code pour installer les librairies manquantes ( si le 1er paramètre du soft n'est pas "NICO_BAT_Mode"):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
…
 
    N = len(sys.argv)
    #print ('N  :',N, sys.argv[0])# C:\...\main_ML.py
    if N > 1:
        A=sys.argv[1]
        #print ('A  :',A)# C:\...\main_ML.py
        if A == 'NICO_BAT_Mode':  # first choosed argument in batch file
            General_ML.From_BAT_File =  True # in that case don't install libreries in main python area
 
 
    if not General_ML.From_BAT_File:
        from    pip_version_checker   import  main_PIP_CHECK
        from    requirements_checker  import check_and_install_requirements
        print('main_PIP_CHECK')
        main_PIP_CHECK()
        print('Done')
 
        print('check_and_install_requirements')
        check_and_install_requirements()
        print('Done')

Avec pour la mise à jour de pip:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# pip_version_checker.py (Fixed)
"""
Pip Version Checker - Utility to check and update pip to latest version
"""
#=> inform you must run this script with python 3 or above
#!/usr/bin/python3
#=> inform we are usige an UTF-8 code ( otherwhise some chars such as é, è, .. could be wrongly displayed) 
# -*- coding: utf-8 -*-
 
import subprocess
import sys
import re
import General_ML
 
def PR(st):
    General_ML.Preliminary_info.append(st)
    print(st)
 
class PipVersionChecker:
    def __init__(self):
        self.current_version = None
        self.latest_version = None
 
    def get_current_pip_version(self):
        """Get currently installed pip version"""
        try:
            result = subprocess.run([sys.executable, "-m", "pip", "--version"], 
                                  capture_output=True, text=True, check=True)
 
            # Extract version from output like "pip 21.3.1 from ..."
            match = re.search(r'pip\s+([\d.]+)', result.stdout)
            if match:
                self.current_version = match.group(1)
                return self.current_version
            else:
                return None
 
        except (subprocess.CalledProcessError, FileNotFoundError):
            return None
 
    def get_latest_pip_version(self):
        """Get latest available pip version from PyPI"""
        try:
            # Use pip index versions to get available versions
            result = subprocess.run([sys.executable, "-m", "pip", "index", "versions", "pip"], 
                                  capture_output=True, text=True)
 
            if result.returncode == 0:
                # Parse output to find latest version
                for line in result.stdout.split('\n'):
                    if 'LATEST:' in line:
                        match = re.search(r'LATEST:\s+([\d.]+)', line)
                        if match:
                            self.latest_version = match.group(1)
                            return self.latest_version
 
            # Fallback: try the old method
            result = subprocess.run([sys.executable, "-m", "pip", "install", "pip==999.0.0"], 
                                  capture_output=True, text=True)
 
            # Extract latest version from error message
            for line in result.stderr.split('\n'):
                if 'from versions:' in line:
                    versions_text = line.split('from versions:')[-1].split(')')[0]
                    versions = [v.strip() for v in versions_text.split(',')]
                    if versions:
                        self.latest_version = versions[-1]  # Last version is usually latest
                        return self.latest_version
 
            return None
 
        except subprocess.CalledProcessError:
            return None
 
    def compare_versions(self, v1, v2):
        """Simple version comparison without external dependencies"""
        def parse_version(v):
            return [int(x) for x in v.split('.')]
 
        try:
            v1_parts = parse_version(v1)
            v2_parts = parse_version(v2)
 
            # Pad with zeros if different length
            max_len = max(len(v1_parts), len(v2_parts))
            v1_parts.extend([0] * (max_len - len(v1_parts)))
            v2_parts.extend([0] * (max_len - len(v2_parts)))
 
            return v1_parts < v2_parts
        except:
            return False
 
    def is_update_needed(self):
        """Check if pip update is needed"""
        current = self.get_current_pip_version()
        latest = self.get_latest_pip_version()
 
        if not current or not latest:
            return False, latest
 
        return self.compare_versions(current, latest), latest
 
    def update_pip(self):
        """Update pip to latest version"""
        try:
            PR("Updating pip to latest version...")
            subprocess.run([sys.executable, "-m", "pip", "install", "--upgrade", "pip"], 
                         check=True, capture_output=True)
            PR("pip updated successfully!")
            return True
        except subprocess.CalledProcessError as e:
            PR(f"Failed to update pip: {e}")
            return False
 
    def check_and_update(self):
        """Main method to check and update pip if needed"""
        PR("Checking pip version...")
 
        current = self.get_current_pip_version()
        if not current:
            PR("Could not determine current pip version")
            return False
 
        PR(f"Current pip version: {current}")
 
        '''
        
        latest = self.get_latest_pip_version()
        if not latest:
            PR("Could not determine latest pip version")
            return False
            
        PR(f"Latest pip version: {latest}")
        '''
        OK, latest = self.is_update_needed()
        if OK:
            PR(f"Update available: {current} -> {latest}")
            return self.update_pip()
        else:
            PR(f"Latest pip version: {latest}")
            PR("Your pip is already up to date!")
            return True
 
def main_PIP_CHECK():  # renomé. Main un peu dangereux. Il peut y avoir des risques de confusion
    """Standalone pip version checker"""
    checker = PipVersionChecker()
    checker.check_and_update()

Et pour la mise à jour des librairies

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# requirements_checker.py (New - Simple dependency checker)
"""
Simple requirements checker without external dependencies
"""
#=> inform you must run this script with python 3 or above
#!/usr/bin/python3
#=> inform we are usige an UTF-8 code ( otherwhise some chars such as é, è, .. could be wrongly displayed) 
# -*- coding: utf-8 -*-
 
import      subprocess
import      sys
import      os
import      General_ML
 
def check_and_install_requirements():
    """Check and install required packages"""
    requirements = {
        'yfinance': 'yfinance',
        'pandas': 'pandas', 
        'fpdf':'fpdf',
        'numpy': 'numpy',
        'scipy': 'scipy',
        'matplotlib': 'matplotlib',
        'sklearn': 'sklearn',
        #'scikit-learn': 'scikit-learn',
        'plotly': 'plotly',
        'seaborn': 'seaborn',# jamais Utilisé???
        'tkinter': 'tkinter'  # Usually comes with Python     pip install scikit-learn
 
    }
    '''
        Le module shutil fait partie de la bibliothèque standard de Python, 
        ce qui signifie qu'il est inclus par défaut lors de l'installation de Python . =>
        inutile de le mettre dans la liste ci-dessus
    '''
 
    General_ML.Preliminary_info.append("Checking dependencies...")
 
    General_ML.Preliminary_info.append("Checking dependencies...")
    SAP = os.getenv('SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL')
 
    os.environ["SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL"] = 'True'
 
 
    for package, install_name in requirements.items():
        try:
            if package == 'tkinter':
                # tkinter is usually bundled with Python
                #import tkinter
                General_ML.Preliminary_info.append(f"✓ {package} is available")
            else:
                __import__(package)
                General_ML.Preliminary_info.append(f"✓ {package} is available")
        except ImportError:
            if install_name:
                General_ML.Preliminary_info.append(f"✗ {package} not found. Installing...")
                try:
                    subprocess.check_call([sys.executable, "-m", "pip", "install",  install_name ])
                    General_ML.Preliminary_info.append(f"✓ {package} installed successfully")
                    General_ML.Must_Restart            =  True
                except subprocess.CalledProcessError:
                    General_ML.Preliminary_info.append(f"✗ Failed to install {package}")
                # end if install_name
            else:
                General_ML.Preliminary_info.append(f"✗ {package} is required but cannot be installed via pip")
            #end except ImportError:
        # end for package, install_name in requirements.items():
 
    #python -m pip show scikit-learn > scikitlearn.jpm123
    result = subprocess.run([sys.executable, "-m", "pip","show" ,"scikit-learn"], capture_output=True, text=True)
 
    a=len(result.stdout)
 
    if a < 1:
        subprocess.check_call([sys.executable, "-m", "pip", "install",  'scikit-learn' ])
        General_ML.Must_Restart            =  True
 
    if SAP==None:
        os.environ.pop('SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL')
    else:
        os.environ["SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL"] = SAP
    #end check_and_install_requirements

Bien entendu cela installe les librairies souhaitées dans l’environnement général de python.
Pour utiliser un environnement dédicacé, sous window, j’utiles alors la batch file (NICO.bat) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
python -m venv Nicola__env
cd Nicola__env
cd scripts
call activate.bat
cd..
cd..
pip3 install scipy
pip3 install seaborn
pip3 install python-dateutil
pip3 install matplotlib
pip3 install scikit-learn
pip3 install fpdf
pip3 install pandas
pip3 install yfinance
pip3 install tk
pip3 install plotly
pip3 install seaborn
python main_ml.py NICO_BAT_Mode
cd Nicola__env
cd scripts
call deactivate.bat
cd..
cd..

Ici le passage du paramètre « NICO_BAT_Mode » au programme permet de ne plus installer les librairies dans l’environnement général. Cela fonctionne sans problème (apparent!)

Maintenant j’aurais besoin de créer l’équivalent de NICO.bat si on lance un script (.sh ? .bash ? autre ?) pour pouvoir exécuter la série de commande sur un MAC et non plus un PC-Window.
Après avoir passé pas mal de temps, peut-être mal ciblé, je n'ai pas réussi à trouvrer une solution concluante.

Ce que j'ai pu faire avec les infos trouvées est: (NICO . sh)

Code:

1
2
3
4
5
6
7
8
9
 
#!/bin/bash
python3 -m venv Nicola__env
source Nicola__env/bin/activate
rem ou pip3 ?
pip install scipy seaborn python-dateutil matplotlib scikit-learn fpdf pandas yfinance tk plotly
python main_ml.py NICO_BAT_Mode
deactivate
rm -rf Nicola__env

Mais je n'ai aucun moyen de vérifier avant de transmettre,

Je serais donc infiniment reconnaissant à toutes personnes pouvant m’aider à effectuer une conversion de code pouvant fonctionner sur un MAC.

Merci d’avance pour toute réponse et suggestion.