MP4MDL 0.1.0__tar.gz

MP4MDL-0.1.0/MP4MDL.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: MP4MDL
+Version: 0.1.0
+Summary: Un outil pour télécharger et gérer des vidéos MP4
+Home-page: https://git.maddoxserv.com/maddox/MP4MDL
+Author: Maddox
+Author-email: maddoxtes@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Description 
+
+This project is a library that allows you to download MP4 files with video links.
+
+# Website Supported
+
+- ✅ video.sibnet.ru
+- ✅ vidmoly.to
+- ✅ oneupload.to
+- ✅ sendvid.com

MP4MDL-0.1.0/MP4MDL.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+setup.py
+MP4MDL.egg-info/PKG-INFO
+MP4MDL.egg-info/SOURCES.txt
+MP4MDL.egg-info/dependency_links.txt
+MP4MDL.egg-info/entry_points.txt
+MP4MDL.egg-info/requires.txt
+MP4MDL.egg-info/top_level.txt
+mp4mdl/__init__.py
+mp4mdl/mp4mdl.py
+mp4mdl/download/__init__.py
+mp4mdl/download/mp4_downloader.py
+mp4mdl/download/segment_downloader.py
+mp4mdl/lecteur/__init__.py
+mp4mdl/lecteur/oneupload.py
+mp4mdl/lecteur/sendvid.py
+mp4mdl/lecteur/sibnet.py
+mp4mdl/lecteur/vidmoly.py
+mp4mdl/scrap/__init__.py
+mp4mdl/scrap/get_best_qualite_url.py
+mp4mdl/scrap/get_m3u8_url.py
+mp4mdl/scrap/get_mp4_url.py

MP4MDL-0.1.0/MP4MDL.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

MP4MDL-0.1.0/MP4MDL.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mp4mdl = mp4mdl.main:main

MP4MDL-0.1.0/MP4MDL.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests
+beautifulsoup4
+ffmpeg-python

MP4MDL-0.1.0/MP4MDL.egg-info/top_level.txt

@@ -0,0 +1 @@
+mp4mdl

MP4MDL-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: MP4MDL
+Version: 0.1.0
+Summary: Un outil pour télécharger et gérer des vidéos MP4
+Home-page: https://git.maddoxserv.com/maddox/MP4MDL
+Author: Maddox
+Author-email: maddoxtes@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Description 
+
+This project is a library that allows you to download MP4 files with video links.
+
+# Website Supported
+
+- ✅ video.sibnet.ru
+- ✅ vidmoly.to
+- ✅ oneupload.to
+- ✅ sendvid.com

MP4MDL-0.1.0/mp4mdl/__init__.py

@@ -0,0 +1,7 @@
+"""
+MP4MDL - Un outil pour télécharger et gérer des vidéos MP4
+"""
+
+__version__ = "0.1.0"
+
+from .mp4mdl import mp4mdl

MP4MDL-0.1.0/mp4mdl/download/__init__.py

@@ -0,0 +1,2 @@
+from .mp4_downloader import mp4_downloader
+from .segment_downloader import segment_downloader

MP4MDL-0.1.0/mp4mdl/download/mp4_downloader.py

@@ -0,0 +1,58 @@
+import logging
+import urllib3
+import time
+
+class mp4_downloader:
+    def __init__(self, headers, url, file_name, logger):
+        self.headers = headers
+        self.url = url
+        self.file_name = file_name
+        self.logger = logger
+
+    def download(self):
+        urllib3_logger = logging.getLogger("urllib3")
+        urllib3_logger.setLevel(logging.WARNING)
+        
+        try:
+            http = urllib3.PoolManager()
+            response = http.request('GET', self.url, headers=self.headers, preload_content=False)
+            
+            if response.status == 403:
+                self.logger.error(f"Erreur 403 : {self.url} <-- si url est sibnet ses normal tu est banni pendant 2-5 jours")
+                return False
+            elif response.status != 200:
+                self.logger.error(f"Erreur lors du téléchargement: {response.status}")
+                return False
+            
+            with open(self.file_name, 'wb') as f:
+                chunk_size = 512 * 1024
+
+                total_downloaded = 0
+                start_time = time.time()
+                
+                for data in response.stream(chunk_size):
+                    f.write(data)
+                    total_downloaded += len(data)
+                    
+                    # Ajuster la taille du chunk en fonction de la vitesse
+                    elapsed = time.time() - start_time
+                    if elapsed >= 1:  # Ajuster toutes les secondes
+                        speed = total_downloaded / elapsed  # octets/seconde
+                        
+                        # Augmenter/diminuer chunk_size selon la vitesse
+                        if speed > 1024*1024:  # Si > 1 MB/s
+                            chunk_size = min(chunk_size * 2, 5*1024*1024)  # Max 5MB
+                        elif speed < 512*1024:  # Si < 512 KB/s
+                            chunk_size = max(chunk_size // 2, 4096)  # Min 4KB
+
+                        total_downloaded = 0
+                        start_time = time.time()
+                            
+            response.release_conn()
+            self.logger.debug(f"Téléchargement réussi : {self.file_name}")
+            return True
+            
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Erreur lors du téléchargement: {str(e)}")
+            return False

MP4MDL-0.1.0/mp4mdl/download/segment_downloader.py

@@ -0,0 +1,41 @@
+import os
+import ffmpeg
+
+class segment_downloader:
+    def __init__(self, best_qualite_url, headers_dict, file_name, logger):
+        self.best_qualite_url = best_qualite_url
+        self.file_name = file_name
+        self.logger = logger
+        self.headers_dict = headers_dict
+
+    def download_segments(self):
+        try:
+            if os.path.exists(self.file_name):
+                os.remove(self.file_name)
+            
+            # Créer le stream d'entrée avec les headers
+            input_stream = ffmpeg.input(
+                self.best_qualite_url,
+                protocol_whitelist="file,https,http,tls,tcp",
+                headers=self.headers_dict
+            )
+            
+            # Configurer le stream de sortie
+            output_stream = ffmpeg.output(
+                input_stream,
+                self.file_name,
+                c='copy'  # Copier les streams sans ré-encoder
+            )
+            
+            # Exécuter la commande
+            ffmpeg.run(output_stream, capture_stdout=True, capture_stderr=True)
+            
+            self.logger.debug(f"Téléchargement des segments réussi : {self.file_name}")
+            return True
+            
+        except ffmpeg.Error as e:
+            self.logger.error(f"Erreur ffmpeg : {e.stderr.decode()}")
+            return False
+        except Exception as e:
+            self.logger.error(f"Erreur lors du téléchargement des segments : {e}")
+            return False

MP4MDL-0.1.0/mp4mdl/lecteur/__init__.py

@@ -0,0 +1,4 @@
+from .sibnet import sibnet as sibnet
+from .vidmoly import vidmoly as vidmoly
+from .oneupload import oneupload as oneupload
+from .sendvid import sendvid as sendvid

MP4MDL-0.1.0/mp4mdl/lecteur/oneupload.py

@@ -0,0 +1,21 @@
+from ..scrap import get_m3u8_url, get_best_qualite_url
+from ..download import segment_downloader
+
+def oneupload(url, file_name, logger):
+    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',"Referer": "https://oneupload.net/", "Origin": "https://oneupload.net"}
+    headers_dict = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+    'Referer': 'https://oneupload.net/',
+    'Origin': 'https://oneupload.net'
+    }
+    match = r'file:"(https?://[^"]+\.m3u8[^"]*)"'
+    m3u8_url = get_m3u8_url(url=url, headers=headers, match=match, logger=logger)
+    if not m3u8_url:
+        return False
+
+    best_qualite_url = get_best_qualite_url(m3u8_url=m3u8_url, headers=headers, logger=logger)
+
+    downloader = segment_downloader(best_qualite_url=best_qualite_url, headers_dict=headers_dict, file_name=file_name, logger=logger)
+    status = downloader.download_segments()
+    return status
+

MP4MDL-0.1.0/mp4mdl/lecteur/sendvid.py

@@ -0,0 +1,18 @@
+from ..scrap import get_mp4_url
+from ..download import mp4_downloader
+
+
+def sendvid(url, file_name, logger):
+    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Encoding": "gzip, deflate, br", "Connection": "keep-alive", "Upgrade-Insecure-Requests": "1"}
+    meta = 'og:video'
+    video_url = get_mp4_url(url, headers, meta=meta, logger=logger)
+    if not video_url:
+        return False
+
+    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36", "Referer": f"https://video.sibnet.ru"}
+    downloader = mp4_downloader(headers, video_url, file_name, logger)
+    status = downloader.download()
+    return status
+
+
+

MP4MDL-0.1.0/mp4mdl/lecteur/sibnet.py

@@ -0,0 +1,16 @@
+from ..scrap import get_mp4_url
+from ..download import mp4_downloader
+
+def sibnet(url, file_name, logger):
+    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "Accept-Encoding": "gzip, deflate, br", "Connection": "keep-alive", "Upgrade-Insecure-Requests": "1"}
+    match = r'player\.src\(\[\{src: "(.*?)"'
+    video_url = get_mp4_url(url, headers, match=match, logger=logger)
+    if not video_url:
+        return False
+        
+    mp4_url = f"https://video.sibnet.ru{video_url}"
+    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36", "Referer": f"https://video.sibnet.ru"}
+    downloader = mp4_downloader(headers, mp4_url, file_name, logger)
+    status = downloader.download()
+    return status
+

MP4MDL-0.1.0/mp4mdl/lecteur/vidmoly.py

@@ -0,0 +1,25 @@
+from ..scrap import get_m3u8_url, get_best_qualite_url
+from ..download import segment_downloader
+
+
+def vidmoly(url, file_name, logger):
+    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',"Referer": "https://vidmoly.to/","Origin": "https://vidmoly.to"}
+    headers_dict = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+    'Referer': 'https://vidmoly.to/',
+    'Origin': 'https://vidmoly.to'
+    }
+
+    match = [r'(https?://[^\s]+/master\.m3u8\?[^\s"]+)', r'(https?://[^\s]+/master\.m3u8)']
+    
+    m3u8_url = get_m3u8_url(url=url, headers=headers, match= match, list_match=True, logger=logger)
+    if not m3u8_url:
+        return False
+
+    best_qualite_url = get_best_qualite_url(m3u8_url=m3u8_url, headers=headers, logger=logger)
+
+    downloader = segment_downloader(best_qualite_url=best_qualite_url, headers_dict=headers_dict,file_name=file_name, logger=logger)
+    status = downloader.download_segments()
+    return status
+
+    

MP4MDL-0.1.0/mp4mdl/mp4mdl.py

@@ -0,0 +1,89 @@
+import logging
+import os
+import uuid
+from urllib.parse import urlparse
+import shutil
+
+from .lecteur import *
+
+class mp4mdl:
+    """
+    Classe pour télécharger des vidéos depuis différents sites.
+    
+    Args:
+        download_path (str): Chemin où télécharger temporairement les fichiers
+        final_path (str): Chemin final où déplacer les fichiers
+        url (str): URL de la vidéo à télécharger
+        logger (logging.Logger, optional): Logger personnalisé (par défaut, "MP4mdl" avec le titre "MP4mdl-{title})
+        title (str, optional): Titre pour le logger seulement si logger est None 
+    """
+    
+    SUPPORTED_SITES = {
+        "video.sibnet.ru": (sibnet, ["url", "file_name", "logger"]),
+        "vidmoly.to": (vidmoly, ["url", "file_name", "logger"]),
+        "oneupload.to": (oneupload, ["url", "file_name", "logger"]),
+        "sendvid.com": (sendvid, ["url", "file_name", "logger"])
+    }
+    
+    def __init__(self, download_path, final_path, url, logger=None, title=None):
+        # Validation des entrées
+        if not all([download_path, final_path, url]):
+            raise ValueError("Tous les paramètres sont requis")
+            
+        # Initialisation du logger
+        if title:
+            self.logger = logger or logging.getLogger(f"MP4mdl-{title}")
+        else:
+            self.logger = logger or logging.getLogger(f"MP4mdl")
+        
+        # Normalisation des chemins
+        self.download_path = os.path.normpath(download_path)
+        self.final_path = os.path.normpath(final_path)
+        self.url = url
+        
+        # Création du dossier temporaire
+        self._setup_temp_directory()
+
+    def download(self):
+        site = self.SUPPORTED_SITES
+        parsed_url = urlparse(self.url)
+        base_name = parsed_url.netloc
+
+        downloaded = False
+        if base_name in site:
+            # Préparer les arguments pour la fonction
+            handler, param_names = site[base_name]
+            args = {param: getattr(self, param) for param in param_names}
+
+            self.logger.debug(f"call de la function {handler.__name__} avec les arguments {args}")
+            # Appeler la fonction avec les bons arguments
+            status = handler(**args)
+            self.logger.debug(f"status: {status}")
+            if status:
+                try:
+                    if os.path.exists(self.file_name):
+                        shutil.move(self.file_name, self.final_path)
+                        downloaded = True
+                    else:
+                        self.logger.error(f"Le fichier source n'existe pas: {self.file_name}")
+                        downloaded = False
+                except Exception as e:
+                    self.logger.error(f"Erreur lors du déplacement du fichier: {e}")
+                    downloaded = False
+        else:
+            self.logger.error(f"Le site {base_name} n'est pas supporté")
+            downloaded = False
+        try:
+            if os.path.exists(self.temp_path):
+                shutil.rmtree(self.temp_path)
+        except Exception as e:
+            self.logger.error(f"Erreur lors de la suppression du dossier temporaire: {e}")
+        return downloaded
+
+    def _setup_temp_directory(self):
+        self.temp_name = str(uuid.uuid5(uuid.NAMESPACE_URL, self.url))
+        self.temp_path = os.path.join(self.download_path, self.temp_name)
+        os.makedirs(self.temp_path, exist_ok=True)
+        self.file_name = os.path.join(self.temp_path, f"{self.temp_name}.mp4")
+
+        

MP4MDL-0.1.0/mp4mdl/scrap/__init__.py

@@ -0,0 +1,4 @@
+from .get_mp4_url import get_mp4_url
+from .get_best_qualite_url import get_best_qualite_url
+from .get_m3u8_url import get_m3u8_url
+

MP4MDL-0.1.0/mp4mdl/scrap/get_best_qualite_url.py

@@ -0,0 +1,34 @@
+import requests
+from bs4 import BeautifulSoup
+
+
+def get_best_qualite_url(m3u8_url, headers, logger):
+    try:
+        response = requests.get(m3u8_url, headers=headers)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération de l'URL m3u8: {e}")
+        return None
+    
+    lines = response.text.splitlines()
+    best_url = None
+    best_resolution = (0, 0)
+
+    for i, line in enumerate(lines):
+        if line.startswith("#EXT-X-STREAM-INF"):
+            # Extraire les informations de la ligne
+            parts = line.split(",")
+            
+            # Récupérer la résolution
+            resolution_str = next((part.split("=")[1] for part in parts 
+                                if part.startswith("RESOLUTION=")), None) 
+
+            if resolution_str and i + 1 < len(lines):
+                width, height = map(int, resolution_str.split("x"))
+                
+                # Mettre à jour si meilleure résolution trouvée
+                if (width, height) > best_resolution:
+                    best_url = lines[i + 1]
+
+    return best_url

MP4MDL-0.1.0/mp4mdl/scrap/get_m3u8_url.py

@@ -0,0 +1,41 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+
+def get_m3u8_url(url, headers, match, logger, list_match=False):
+    if not match:
+        logger.error("match non definis")
+        return None
+    
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération de l'URL m3u8: {e}")
+        return None
+    
+    if list_match: 
+        for m in match:
+            m3u8_url = find_match(soup, m, logger)
+            if m3u8_url:
+                return m3u8_url
+        return None
+    else:
+        return find_match(soup, match, logger)
+
+
+def find_match(soup, match, logger):
+    if match:
+        scripts = soup.find_all('script')
+        for script in scripts:
+            script_content = script.string
+            if script_content:
+                matchs = re.search(match, script_content)
+                if matchs:
+                    m3u8_url = matchs.group(1)
+                    if not m3u8_url:
+                        logger.error("m3u8 URL non trouvée dans le script")
+                        return None
+                    else:
+                        return m3u8_url

MP4MDL-0.1.0/mp4mdl/scrap/get_mp4_url.py

@@ -0,0 +1,57 @@
+import requests
+import logging
+from bs4 import BeautifulSoup
+import re
+
+
+def get_mp4_url(url, headers, logger, match=None, meta=None):
+    if not match and not meta:
+        logger.error("match ou meta non definis")
+        return None
+    
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+    except requests.RequestException as e:
+        logger.error(f"Erreur lors de la requête HTTP: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Erreur inattendue: {e}")
+        return None
+    
+    if match:
+        scripts = soup.find_all('script', type="text/javascript")
+        
+        if not scripts:
+            logger.error("Aucun script JavaScript trouvé dans la page")
+            return None
+        
+        for script in scripts:
+            script_content = script.string
+            if script_content:
+                matchs = re.search(match, script_content)
+                if matchs:
+                    video_url = matchs.group(1)
+                    if not video_url:
+                        logger.error("URL de la vidéo non trouvée dans le script")
+                        return None
+                    else:
+                        return video_url
+    elif meta:
+        meta_tag = soup.find("meta", property=meta)
+
+        if not meta_tag:
+            logger.error("Aucune vidéo trouvée dans la page")
+            return None
+        
+        video_url = meta_tag['content']
+        if not video_url:
+            logger.error("URL de la vidéo non trouvée")
+            return None
+            
+        return video_url
+    else:
+        logger.error("Aucun match ou meta trouvé")
+        return None
+                    

MP4MDL-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

MP4MDL-0.1.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="MP4MDL",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "requests",
+        "beautifulsoup4",
+        "ffmpeg-python",
+    ],
+    author="Maddox",
+    author_email="maddoxtes@gmail.com",
+    description="Un outil pour télécharger et gérer des vidéos MP4",
+    long_description=open("readme.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://git.maddoxserv.com/maddox/MP4MDL",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.11",
+    entry_points={
+        "console_scripts": [
+            "mp4mdl=mp4mdl.main:main",
+        ],
+    },
+)