पाइथन के साथ HTML को मार्कडाउन में बदलना: एक व्यापक मार्गदर्शिका

pip install html2text

import html2text

# कन्वर्टर इंस्टेंस बनाएं
h = html2text.HTML2Text()

# विकल्प कॉन्फ़िगर करें
h.ignore_links = False
h.ignore_images = False
h.ignore_emphasis = False
h.body_width = 0  # पंक्तियों को नहीं लपेटें

html_content = """
<h1>वेब स्क्रैपिंग में आपका स्वागत है</h1>
<p>यह सामग्री निकालने का एक **विस्तृत मार्गदर्शिका** है।</p>
<ul>
    <li>आसान उपयोग</li>
    <li>बैटल-टेस्टेड</li>
    <li>वैद्युत रूप से अपनाया गया</li>
</ul>
<a href="https://example.com">अधिक जानें</a>
"""

markdown = h.handle(html_content)
print(markdown)

# वेब स्क्रैपिंग में आपका स्वागत है

यह सामग्री निकालने का एक **विस्तृत मार्गदर्शिका** है।

  * आसान उपयोग
  * बैटल-टेस्टेड
  * वैद्युत रूप से अपनाया गया

[अधिक जानें](https://example.com)

import html2text

h = html2text.HTML2Text()

# विशिष्ट तत्वों को छोड़ें
h.ignore_links = True
h.ignore_images = True

# फॉर्मेटिंग को नियंत्रित करें
h.body_width = 80  # 80 अक्षरों पर लपेटें
h.unicode_snob = True  # यूनिकोड अक्षरों का उपयोग करें
h.emphasis_mark = '*'  # _ के बजाय * का उपयोग करें जोर के लिए
h.strong_mark = '**'

# टेबल्स का सामना करें
h.ignore_tables = False

# प्री-फॉर्मेटेड टेक्स्ट की रक्षा करें
h.protect_links = True

pip install markdownify

from markdownify import markdownify as md

html = """
<article>
    <h2>आधुनिक वेब विकास</h2>
    <p>बनाना <code>Python</code> और <em>आधुनिक फ्रेमवर्क</em> के साथ।</p>
    <blockquote>
        <p>सादगी अंतिम परिपक्वता है।</p>
    </blockquote>
</article>
"""

markdown = md(html)
print(markdown)

from markdownify import MarkdownConverter

class CustomConverter(MarkdownConverter):
    """
    विशिष्ट टैग हैंडलिंग के साथ कस्टम कन्वर्टर बनाना
    """
    def convert_img(self, el, text, convert_as_inline):
        """अल्ट टेक्स्ट के साथ कस्टम इमेज हैंडलर"""
        alt = el.get('alt', '')
        src = el.get('src', '')
        title = el.get('title', '')

        if title:
            return f'![{alt}]({src} "{title}")'
        return f'![{alt}]({src})'

    def convert_pre(self, el, text, convert_as_inline):
        """भाषा पता लगाने के साथ बढ़ी हुई कोड ब्लॉक हैंडलिंग"""
        code = el.find('code')
        if code:
            # क्लास एट्रिब्यूट से भाषा निकालना (उदाहरण के लिए, 'language-python')
            classes = code.get('class', [''])
            language = classes[0].replace('language-', '') if classes else ''
            return f'\n```{language}\n{code.get_text()}\n```\n'
        return f'\n```\n{text}\n```\n'

# कस्टम कन्वर्टर का उपयोग करना
html = '<pre><code class="language-python">def hello():\n    print("world")</code></pre>'
markdown = CustomConverter().convert(html)
print(markdown)

from markdownify import markdownify as md

# कुछ टैग को पूरी तरह से हटाना
markdown = md(html, strip=['script', 'style', 'nav'])

# केवल कुछ टैग को कन्वर्ट करना
markdown = md(
    html,
    heading_style="ATX",  # हेडिंग्स के लिए # का उपयोग करना
    bullets="-",  # बुलेट्स के लिए - का उपयोग करना
    strong_em_symbol="*",  # जोर के लिए * का उपयोग करना
)

pip install html-to-markdown

from html_to_markdown import convert

html = """
<article>
    <h1>तकनीकी दस्तावेज़ीकरण</h1>
    <table>
        <thead>
            <tr>
                <th>फीचर</th>
                <th>समर्थन</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>HTML5</td>
                <td>✓</td>
            </tr>
            <tr>
                <td>टेबल्स</td>
                <td>✓</td>
            </tr>
        </tbody>
    </table>
</article>
"""

markdown = convert(html)
print(markdown)

from html_to_markdown import convert, Options

# कस्टम विकल्प बनाना
options = Options(
    heading_style="ATX",
    bullet_style="-",
    code_language_default="python",
    strip_tags=["script", "style"],
    escape_special_chars=True,
    table_style="pipe",  # टेबल्स के लिए | का उपयोग करना
    preserve_whitespace=False,
    extract_metadata=True,  # मेटा टैग्स निकालना
)

markdown = convert(html, options=options)

# एकल फाइल कन्वर्ट करना
html-to-markdown input.html -o output.md

# विकल्पों के साथ कन्वर्ट करना
html-to-markdown input.html \
    --heading-style atx \
    --strip-tags script,style \
    --extract-metadata

# बैच कन्वर्जन
find ./html_files -name "*.html" -exec html-to-markdown {} -o ./markdown_files/{}.md \;

pip install trafilatura

import trafilatura

# URL से डाउनलोड और एक्सट्रैक्ट करना
url = "https://example.com/article"
downloaded = trafilatura.fetch_url(url)
markdown = trafilatura.extract(downloaded, output_format='markdown')
print(markdown)

import trafilatura
from trafilatura.settings import use_config

# कस्टम कॉन्फ़िगरेशन बनाना
config = use_config()
config.set("DEFAULT", "EXTRACTION_TIMEOUT", "30")

html = """
<html>
<head><title>Article Title</title></head>
<body>
    <nav>Navigation menu</nav>
    <article>
        <h1>Main Article</h1>
        <p>Important content here.</p>
    </article>
    <aside>Advertisement</aside>
    <footer>Footer content</footer>
</body>
</html>
"""

# केवल मुख्य सामग्री निकालना
markdown = trafilatura.extract(
    html,
    output_format='markdown',
    include_comments=False,
    include_tables=True,
    include_images=True,
    include_links=True,
    config=config
)

# मेटाडेटा के साथ निकालना
result = trafilatura.extract(
    html,
    output_format='markdown',
    with_metadata=True
)

if result:
    print(f"Title: {result.get('title', 'N/A')}")
    print(f"Author: {result.get('author', 'N/A')}")
    print(f"Date: {result.get('date', 'N/A')}")
    print(f"\nContent:\n{result.get('text', '')}")

import trafilatura
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

def process_url(url):
    """URL से मार्कडाउन निकालना"""
    downloaded = trafilatura.fetch_url(url)
    if downloaded:
        return trafilatura.extract(
            downloaded,
            output_format='markdown',
            include_links=True,
            include_images=True
        )
    return None

# कई URL को समानांतर में प्रोसेस करना
urls = [
    "https://example.com/article1",
    "https://example.com/article2",
    "https://example.com/article3",
]

with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(process_url, urls))

for i, markdown in enumerate(results):
    if markdown:
        Path(f"article_{i}.md").write_text(markdown, encoding='utf-8')

pip install domscribe

from domscribe import html_to_markdown

html = """
<article>
    <header>
        <h1>सेमांटिक HTML को समझना</h1>
        <time datetime="2024-10-24">24 अक्टूबर, 2024</time>
    </header>
    <section>
        <h2>परिचय</h2>
        <p>सेमांटिक HTML सामग्री को <mark>अर्थ</mark> प्रदान करता है।</p>
    </section>
    <aside>
        <h3>संबंधित विषय</h3>
        <ul>
            <li>सुलभता</li>
            <li>SEO</li>
        </ul>
    </aside>
</article>
"""

markdown = html_to_markdown(html)
print(markdown)

from domscribe import html_to_markdown, MarkdownOptions

options = MarkdownOptions(
    preserve_semantic_structure=True,
    include_aria_labels=True,
    strip_empty_elements=True
)

markdown = html_to_markdown(html, options=options)

pip install html2md

# पूरे डायरेक्टरी कन्वर्ट करना
m1f-html2md convert ./website -o ./docs

# कस्टम सेटिंग्स के साथ
m1f-html2md convert ./website -o ./docs \
    --remove-tags nav,footer \
    --heading-offset 1 \
    --detect-language

# एकल फाइल कन्वर्ट करना
m1f-html2md convert index.html -o readme.md

import asyncio
from html2md import convert_html

async def convert_files():
    """एसिंक्रोनस बैच कन्वर्जन"""
    html_files = [
        'page1.html',
        'page2.html',
        'page3.html'
    ]

    tasks = [convert_html(file) for file in html_files]
    results = await asyncio.gather(*tasks)
    return results

# कन्वर्जन चलाना
results = asyncio.run(convert_files())

import time
import html2text
from markdownify import markdownify
from html_to_markdown import convert
import trafilatura

def benchmark(html_content, iterations=100):
    """बेंचमार्क कन्वर्जन स्पीड"""

    # html2text
    start = time.time()
    h = html2text.HTML2Text()
    for _ in range(iterations):
        _ = h.handle(html_content)
    html2text_time = time.time() - start

    # markdownify
    start = time.time()
    for _ in range(iterations):
        _ = markdownify(html_content)
    markdownify_time = time.time() - start

    # html-to-markdown
    start = time.time()
    for _ in range(iterations):
        _ = convert(html_content)
    html_to_markdown_time = time.time() - start

    # trafilatura
    start = time.time()
    for _ in range(iterations):
        _ = trafilatura.extract(html_content, output_format='markdown')
    trafilatura_time = time.time() - start

    return {
        'html2text': html2text_time,
        'markdownify': markdownify_time,
        'html-to-markdown': html_to_markdown_time,
        'trafilatura': trafilatura_time
    }

import trafilatura
from pathlib import Path
from concurrent.futures import ProcessPoolExecutor

def process_html_file(html_path):
    """HTML फाइल को मार्कडाउन में कन्वर्ट करें"""
    html = Path(html_path).read_text(encoding='utf-8')
    markdown = trafilatura.extract(
        html,
        output_format='markdown',
        include_links=False,  # साफ प्रशिक्षण डेटा के लिए हटाएं
        include_images=False,
        include_comments=False
    )

    if markdown:
        output_path = html_path.replace('.html', '.md')
        Path(output_path).write_text(markdown, encoding='utf-8')
        return len(markdown)
    return 0

# 10,000 फाइलों को पैरालेल में प्रोसेस करें
html_files = list(Path('./docs').rglob('*.html'))

with ProcessPoolExecutor(max_workers=8) as executor:
    token_counts = list(executor.map(process_html_file, html_files))

print(f"{len(html_files)} फाइलों को प्रोसेस किया गया")
print(f"कुल अक्षर: {sum(token_counts):,}")

# सभी पोस्ट्स को फ्रंटमैटर के साथ कन्वर्ट करें
m1f-html2md convert ./wordpress-export \
    -o ./hugo/content/posts \
    --generate-frontmatter \
    --heading-offset 0 \
    --remove-tags script,style,nav,footer

from html_to_markdown import convert, Options
from pathlib import Path
import yaml

def migrate_post(html_file):
    """वर्डप्रेस HTML को ह्यूगो मार्कडाउन में कन्वर्ट करें"""
    html = Path(html_file).read_text()

    # HTML से शीर्षक और तारीख निकालें
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(html, 'html.parser')
    title = soup.find('h1').get_text() if soup.find('h1') else 'Untitled'

    # मार्कडाउन में कन्वर्ट करें
    options = Options(strip_tags=['script', 'style', 'nav', 'footer'])
    markdown = convert(html, options=options)

    # ह्यूगो फ्रंटमैटर जोड़ें
    frontmatter = {
        'title': title,
        'date': '2024-10-24',
        'draft': False,
        'tags': []
    }

    output = f"---\n{yaml.dump(frontmatter)}---\n\n{markdown}"

    # सेव करें
    output_file = html_file.replace('.html', '.md')
    Path(output_file).write_text(output, encoding='utf-8')

# सभी पोस्ट्स प्रोसेस करें
for html_file in Path('./wordpress-export').glob('*.html'):
    migrate_post(html_file)

from markdownify import MarkdownConverter
import requests

class DocsConverter(MarkdownConverter):
    """तकनीकी दस्तावेज़ के लिए कस्टम कन्वर्टर"""

    def convert_pre(self, el, text, convert_as_inline):
        """सिंटैक्स हाइलाइटिंग के साथ एन्हांस्ड कोड ब्लॉक"""
        code = el.find('code')
        if code:
            # क्लास से भाषा निकालें
            classes = code.get('class', [])
            language = next(
                (c.replace('language-', '') for c in classes if c.startswith('language-')),
                'text'
            )
            return f'\n```{language}\n{code.get_text()}\n```\n'
        return super().convert_pre(el, text, convert_as_inline)

    def convert_div(self, el, text, convert_as_inline):
        """विशेष दस्तावेज़ ब्लॉक्स हैंडल करें"""
        classes = el.get('class', [])

        # चेतावनी ब्लॉक्स
        if 'warning' in classes:
            return f'\n> ⚠️ **चेतावनी**: {text}\n'

        # जानकारी ब्लॉक्स
        if 'info' in classes or 'note' in classes:
            return f'\n> 💡 **नोट**: {text}\n'

        return text

def scrape_docs(url):
    """डॉक्यूमेंटेशन पेज स्क्रेप और कन्वर्ट करें"""
    response = requests.get(url)
    markdown = DocsConverter().convert(response.text)
    return markdown

# उपयोग करें
docs_url = "https://docs.example.com/api-reference"
markdown = scrape_docs(docs_url)
Path('api-reference.md').write_text(markdown)

import html2text
import email
from pathlib import Path

def convert_newsletter(email_file):
    """HTML ईमेल को मार्कडाउन में कन्वर्ट करें"""
    # ईमेल पार्स करें
    with open(email_file, 'r') as f:
        msg = email.message_from_file(f)

    # HTML पार्ट प्राप्त करें
    html_content = None
    for part in msg.walk():
        if part.get_content_type() == 'text/html':
            html_content = part.get_payload(decode=True).decode('utf-8')
            break

    if not html_content:
        return None

    # कन्वर्टर कॉन्फ़िगर करें
    h = html2text.HTML2Text()
    h.ignore_images = False
    h.images_to_alt = True
    h.body_width = 0
    h.protect_links = True
    h.unicode_snob = True

    # कन्वर्ट करें
    markdown = h.handle(html_content)

    # मेटाडेटा जोड़ें
    subject = msg.get('Subject', 'No Subject')
    date = msg.get('Date', '')

    output = f"# {subject}\n\n*तारीख: {date}*\n\n---\n\n{markdown}"

    return output

# न्यूज़लेटर आर्काइव प्रोसेस करें
for email_file in Path('./newsletters').glob('*.eml'):
    markdown = convert_newsletter(email_file)
    if markdown:
        output_file = email_file.with_suffix('.md')
        output_file.write_text(markdown, encoding='utf-8')

from bs4 import BeautifulSoup
import trafilatura

def clean_and_convert(html):
    """कन्वर्ट करने से पहले अनचाहे तत्वों को हटाएं"""
    soup = BeautifulSoup(html, 'html.parser')

    # अनचाहे तत्वों को हटाएं
    for element in soup(['script', 'style', 'nav', 'footer', 'header', 'aside']):
        element.decompose()

    # विज्ञापन और ट्रैकिंग को हटाएं
    for element in soup.find_all(class_=['ad', 'advertisement', 'tracking']):
        element.decompose()

    # साफ HTML को कन्वर्ट करें
    markdown = trafilatura.extract(
        str(soup),
        output_format='markdown'
    )

    return markdown

import re

def normalize_markdown(markdown):
    """मार्कडाउन स्पेसिंग को साफ करें"""
    # कई खाली पंक्तियों को हटाएं
    markdown = re.sub(r'\n{3,}', '\n\n', markdown)

    # अंतिम व्हाइटस्पेस को हटाएं
    markdown = '\n'.join(line.rstrip() for line in markdown.split('\n'))

    # अंत में एकल न्यूलाइन सुनिश्चित करें
    markdown = markdown.rstrip() + '\n'

    return markdown

def validate_markdown(markdown):
    """मार्कडाउन गुणवत्ता का वैलिडेशन करें"""
    issues = []

    # HTML अवशेषों की जांच करें
    if '<' in markdown and '>' in markdown:
        issues.append("HTML टैग पाए गए")

    # टूटे हुए लिंक्स की जांच करें
    if '[' in markdown and ']()' in markdown:
        issues.append("खाली लिंक पाया गया")

    # अधिक कोड ब्लॉक्स की जांच करें
    code_block_count = markdown.count('```')
    if code_block_count % 2 != 0:
        issues.append("बंद नहीं हुआ कोड ब्लॉक")

    return len(issues) == 0, issues

from pathlib import Path
from concurrent.futures import ProcessPoolExecutor
import trafilatura
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def process_file(html_path):
    """एकल HTML फाइल को प्रोसेस करें"""
    try:
        html = Path(html_path).read_text(encoding='utf-8')
        markdown = trafilatura.extract(
            html,
            output_format='markdown',
            include_links=True,
            include_images=False
        )

        if markdown:
            # सामान्यीकृत करें
            markdown = normalize_markdown(markdown)

            # वैलिडेट करें
            is_valid, issues = validate_markdown(markdown)
            if not is_valid:
                logger.warning(f"{html_path}: {', '.join(issues)}")

            # सेव करें
            output_path = Path(str(html_path).replace('.html', '.md'))
            output_path.write_text(markdown, encoding='utf-8')

            return True

        return False

    except Exception as e:
        logger.error(f"Error processing {html_path}: {e}")
        return False

def batch_convert(input_dir, max_workers=4):
    """डायरेक्टरी में सभी HTML फाइलों को कन्वर्ट करें"""
    html_files = list(Path(input_dir).rglob('*.html'))
    logger.info(f"Found {len(html_files)} HTML files")

    with ProcessPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(process_file, html_files))

    success_count = sum(results)
    logger.info(f"Successfully converted {success_count}/{len(html_files)} files")

# Usage
batch_convert('./html_docs', max_workers=8)