पायथन में पीडीएफ को डॉक्स में कैसे बदलें

जानें कि आप pdf2docx लाइब्रेरी का उपयोग कैसे कर सकते हैं ताकि आप पीडीएफ फाइलों को पायथन में docx वर्ड फाइल में बदल सकें

इस ट्यूटोरियल में, हम देखेंगे कि कैसे हम पीडीएफ फाइलों को docx एक्सटेंशन में बदलने के लिए pdf2docx लाइब्रेरी का उपयोग कर सकते हैं ।

इस ट्यूटोरियल का लक्ष्य एक फ़ोल्डर के भीतर स्थित पीडीएफ फाइलों के एक या संग्रह को परिवर्तित करने के लिए पाइथन पारिस्थितिकी तंत्र के बाहर बाहरी उपयोगिताओं पर भरोसा किए बिना पाइथन-आधारित मॉड्यूल के माध्यम से हल्के कमांड-लाइन-आधारित उपयोगिता विकसित करना है।

pdf2docx , PyMuPDF के साथ PDF से डेटा निकालने , नियमों के साथ लेआउट को पार्स करने और python-docx के साथ docx फ़ाइल जेनरेट करने के लिए एक पायथन लाइब्रेरी है । python-docx एक अन्य पुस्तकालय है जिसका उपयोग pdf2docx द्वारा Microsoft Word (.docx) फ़ाइलों को बनाने और अद्यतन करने के लिए किया जाता है ।

आवश्यकताओं में जा रहे हैं:

$ pip install pdf2docx==0.5.1

आइए मॉड्यूल आयात करके शुरू करें:

# Import Libraries
from pdf2docx import parse
from typing import Tuple

आइए पीडीएफ को डॉक्स में बदलने के लिए जिम्मेदार फ़ंक्शन को परिभाषित करें:

def convert_pdf2docx(input_file: str, output_file: str, pages: Tuple = None):
    """Converts pdf to docx"""
    if pages:
        pages = [int(i) for i in list(pages) if i.isnumeric()]
    result = parse(pdf_file=input_file,
                   docx_with_path=output_file, pages=pages)
    summary = {
        "File": input_file, "Pages": str(pages), "Output File": output_file
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return result

convert_pdf2docx()समारोह में यह एक Docx फ़ाइल में एक पीडीएफ फाइल में कनवर्ट करता है और अंत में रूपांतरण प्रक्रिया का सारांश प्रिंट, आप कन्वर्ट करने के लिए पृष्ठों की एक श्रेणी निर्दिष्ट करने की अनुमति देता है।

आइए अब इसका इस्तेमाल करें:

if __name__ == "__main__":
    import sys
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    convert_pdf2docx(input_file, output_file)

कमांड-लाइन तर्कों से इनपुट और आउटपुट फ़ाइल नाम प्राप्त करने के लिए हम केवल पायथन के अंतर्निहित sys मॉड्यूल का उपयोग करते हैं। आइए एक नमूना पीडीएफ फाइल को कन्वर्ट करने का प्रयास करें (इसे यहां प्राप्त करें ):

$ python convert_pdf2docx.py letter.pdf letter.docx

letter.docxवर्तमान निर्देशिका में एक नई फ़ाइल दिखाई देगी, और आउटपुट इस तरह होगा:

Parsing Page 1: 1/1...
Creating Page 1: 1/1...
--------------------------------------------------
Terminated in 0.10869679999999998s.
## Summary ########################################################
File:letter.pdf
Pages:None
Output File:letter.docx
###################################################################

आप convert_pdf2docx()फ़ंक्शन में इच्छित पृष्ठ भी निर्दिष्ट कर सकते हैं ।

मुझे आशा है कि आपको यह संक्षिप्त ट्यूटोरियल पसंद आया होगा और आपको यह कनवर्टर उपयोगी लगा होगा।

#python

What is GEEK

Buddha Community

पायथन में पीडीएफ को डॉक्स में कैसे बदलें

Khaitan

1634545297

पायथन में पीडीएफ को डॉक्स में कैसे बदलें

जानें कि आप pdf2docx लाइब्रेरी का उपयोग कैसे कर सकते हैं ताकि आप पीडीएफ फाइलों को पायथन में docx वर्ड फाइल में बदल सकें

आवश्यकताओं में जा रहे हैं:

$ pip install pdf2docx==0.5.1

आइए मॉड्यूल आयात करके शुरू करें:

# Import Libraries
from pdf2docx import parse
from typing import Tuple

आइए पीडीएफ को डॉक्स में बदलने के लिए जिम्मेदार फ़ंक्शन को परिभाषित करें:

def convert_pdf2docx(input_file: str, output_file: str, pages: Tuple = None):
    """Converts pdf to docx"""
    if pages:
        pages = [int(i) for i in list(pages) if i.isnumeric()]
    result = parse(pdf_file=input_file,
                   docx_with_path=output_file, pages=pages)
    summary = {
        "File": input_file, "Pages": str(pages), "Output File": output_file
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return result

आइए अब इसका इस्तेमाल करें:

if __name__ == "__main__":
    import sys
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    convert_pdf2docx(input_file, output_file)

$ python convert_pdf2docx.py letter.pdf letter.docx

letter.docxवर्तमान निर्देशिका में एक नई फ़ाइल दिखाई देगी, और आउटपुट इस तरह होगा:

Parsing Page 1: 1/1...
Creating Page 1: 1/1...
--------------------------------------------------
Terminated in 0.10869679999999998s.
## Summary ########################################################
File:letter.pdf
Pages:None
Output File:letter.docx
###################################################################

आप convert_pdf2docx()फ़ंक्शन में इच्छित पृष्ठ भी निर्दिष्ट कर सकते हैं ।

#python

Khaitan

1633944819

पायथन में पीडीएफ को इमेज में कैसे बदलें

पाइथन में प्रति पृष्ठ अलग-अलग छवियों में पीडीएफ फाइलों को परिवर्तित करने के लिए PyMuPDF लाइब्रेरी का उपयोग करना सीखें।

इस ट्यूटोरियल का उद्देश्य पीडीएफ फाइलों को छवियों में बदलने के लिए पायथन में एक हल्का कमांड-लाइन टूल विकसित करना है।

हम PyMuPDF का उपयोग करेंगे , एक अत्यधिक बहुमुखी, अनुकूलन योग्य PDF, XPS, और eBook दुभाषिया समाधान जिसका उपयोग PDF रेंडरर, व्यूअर, या टूलकिट जैसे अनुप्रयोगों की एक विस्तृत श्रृंखला में किया जा सकता है।

सबसे पहले, आवश्यक पुस्तकालय स्थापित करें:

$ pip install PyMuPDF==1.18.9

पुस्तकालयों का आयात:

import fitz

from typing import Tuple
import os

आइए हमारे मुख्य उपयोगिता फ़ंक्शन को परिभाषित करें:

def convert_pdf2img(input_file: str, pages: Tuple = None):
    """Converts pdf to image and generates a file by page"""
    # Open the document
    pdfIn = fitz.open(input_file)
    output_files = []
    # Iterate throughout the pages
    for pg in range(pdfIn.pageCount):
        if str(pages) != str(None):
            if str(pg) not in str(pages):
                continue
        # Select a page
        page = pdfIn[pg]
        rotate = int(0)
        # PDF Page is converted into a whole picture 1056*816 and then for each picture a screenshot is taken.
        # zoom = 1.33333333 -----> Image size = 1056*816
        # zoom = 2 ---> 2 * Default Resolution (text is clear, image text is hard to read)    = filesize small / Image size = 1584*1224
        # zoom = 4 ---> 4 * Default Resolution (text is clear, image text is barely readable) = filesize large
        # zoom = 8 ---> 8 * Default Resolution (text is clear, image text is readable) = filesize large
        zoom_x = 2
        zoom_y = 2
        # The zoom factor is equal to 2 in order to make text clear
        # Pre-rotate is to rotate if needed.
        mat = fitz.Matrix(zoom_x, zoom_y).preRotate(rotate)
        pix = page.getPixmap(matrix=mat, alpha=False)
        output_file = f"{os.path.splitext(os.path.basename(input_file))[0]}_page{pg+1}.png"
        pix.writePNG(output_file)
        output_files.append(output_file)
    pdfIn.close()
    summary = {
        "File": input_file, "Pages": str(pages), "Output File(s)": str(output_files)
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return output_files

उपरोक्त फ़ंक्शन एक पीडीएफ फाइल को इमेज फाइलों की एक श्रृंखला में परिवर्तित करता है। यह चयनित पृष्ठों के माध्यम से पुनरावृति करता है (डिफ़ॉल्ट उनमें से सभी है), वर्तमान पृष्ठ का एक स्क्रीनशॉट लेता है, और writePNG()विधि का उपयोग करके एक छवि फ़ाइल बनाता है ।

आप ज़ूम फ़ैक्टर को बदलने zoom_xऔर zoom_yबदलने के लिए, rotateअपनी आवश्यकताओं के अनुरूप इन मापदंडों और चर को बदलने के लिए स्वतंत्र महसूस कर सकते हैं।

आइए अब इस फ़ंक्शन का उपयोग करें:

if __name__ == "__main__":
    import sys
    input_file = sys.argv[1]
    convert_pdf2img(input_file)

आइए एक बहु-पृष्ठ पीडीएफ फाइल पर स्क्रिप्ट का परीक्षण करें (इसे यहां प्राप्त करें ):

$ python convert_pdf2image.py bert-paper.pdf

आउटपुट निम्न के रूप में होगा:

## Summary ########################################################
File:bert-paper.pdf
Pages:None
Output File(s):['bert-paper_page1.png', 'bert-paper_page2.png', 'bert-paper_page3.png', 'bert-paper_page4.png', 'bert-paper_page5.png', 'bert-paper_page6.png', 'bert-paper_page7.png', 'bert-paper_page8.png', 'bert-paper_page9.png', 'bert-paper_page10.png', 'bert-paper_page11.png', 'bert-paper_page12.png', 'bert-paper_page13.png', 'bert-paper_page14.png', 'bert-paper_page15.png', 'bert-paper_page16.png']
###################################################################

और वास्तव में, छवियों को सफलतापूर्वक उत्पन्न किया गया था:

निष्कर्ष

हम आशा करते हैं कि आपको यह ट्यूटोरियल आपकी आवश्यकताओं के लिए उपयोगी लगेगा

#python #pdf

Khaitan

1634559306

पायथन में पीडीएफ फाइलों को वॉटरमार्क कैसे करें

पायथन में PyPDF4 और रिपोर्टलैब पुस्तकालयों के साथ पीडीएफ फाइलों में/से वॉटरमार्क जोड़ने और हटाने का तरीका जानें।

पोर्टेबल दस्तावेज़ प्रारूप (पीडीएफ) , आईएसओ 32000 के रूप में मानकीकृत, एक फ़ाइल प्रारूप है जिसे एडोब द्वारा 1993 में विकसित किया गया था, जिसमें टेक्स्ट फ़ॉर्मेटिंग और छवियों सहित दस्तावेज़ प्रस्तुत करने के लिए, एप्लिकेशन सॉफ़्टवेयर, हार्डवेयर और ऑपरेटिंग सिस्टम से स्वतंत्र तरीके से प्रस्तुत किया गया था।

पोस्टस्क्रिप्ट भाषा के आधार पर , प्रत्येक पीडीएफ फाइल एक निश्चित-लेआउट फ्लैट दस्तावेज़ का पूरा विवरण समाहित करती है, जिसमें टेक्स्ट, फोंट, वेक्टर ग्राफिक्स, रैस्टर इमेज और इसे प्रदर्शित करने के लिए आवश्यक अन्य जानकारी शामिल है।

पीडीएफ की परिचितता ने इसे डिजिटल संग्रह के क्षेत्र में समाधान के रूप में तेजी से और व्यापक रूप से अपनाया। चूंकि PDF अन्य फ़ाइल स्वरूपों की तुलना में अधिक बहुमुखी हैं, इसलिए उनके द्वारा प्रदर्शित की जाने वाली जानकारी लगभग किसी भी ऑपरेटिंग सिस्टम या डिवाइस से आसानी से देखी जा सकती है।

इस ट्यूटोरियल में, आप सीखेंगे कि कैसे एक पीडीएफ फाइल या एक फोल्डर को वॉटरमार्क किया जाए जिसमें PyPDF4 और पायथन में रिपोर्टलैब का उपयोग करके पीडीएफ फाइलों का संग्रह हो ।

सबसे पहले, आइए आवश्यक पुस्तकालय स्थापित करें:

$ pip install PyPDF4==1.27.0 reportlab==3.5.59

कोड से शुरू करते हुए, आइए पुस्तकालयों को आयात करें और कुछ कॉन्फ़िगरेशन को परिभाषित करें जिनकी हमें आवश्यकता होगी:

from PyPDF4 import PdfFileReader, PdfFileWriter
from PyPDF4.pdf import ContentStream
from PyPDF4.generic import TextStringObject, NameObject
from PyPDF4.utils import b_
import os
import argparse
from io import BytesIO
from typing import Tuple
# Import the reportlab library
from reportlab.pdfgen import canvas
# The size of the page supposedly A4
from reportlab.lib.pagesizes import A4
# The color of the watermark
from reportlab.lib import colors

PAGESIZE = A4
FONTNAME = 'Helvetica-Bold'
FONTSIZE = 40
# using colors module
# COLOR = colors.lightgrey
# or simply RGB
# COLOR = (190, 190, 190)
COLOR = colors.red
# The position attributes of the watermark
X = 250
Y = 10
# The rotation angle in order to display the watermark diagonally if needed
ROTATION_ANGLE = 45

अगला, हमारे पहले उपयोगिता फ़ंक्शन को परिभाषित करना:

def get_info(input_file: str):
    """
    Extracting the file info
    """
    # If PDF is encrypted the file metadata cannot be extracted
    with open(input_file, 'rb') as pdf_file:
        pdf_reader = PdfFileReader(pdf_file, strict=False)
        output = {
            "File": input_file, "Encrypted": ("True" if pdf_reader.isEncrypted else "False")
        }
        if not pdf_reader.isEncrypted:
            info = pdf_reader.getDocumentInfo()
            num_pages = pdf_reader.getNumPages()
            output["Author"] = info.author
            output["Creator"] = info.creator
            output["Producer"] = info.producer
            output["Subject"] = info.subject
            output["Title"] = info.title
            output["Number of pages"] = num_pages
    # To Display collected metadata
    print("## File Information ##################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in output.items()))
    print("######################################################################")
    return True, output

get_info()समारोह एक इनपुट पीडीएफ फाइल के मेटाडाटा को एकत्र करता है, निम्न विशेषताओं निकाला जा सकता है: लेखक, निर्माता, निर्माता, विषय, शीर्षक, और पृष्ठों की संख्या।

यह ध्यान देने योग्य है कि आप एन्क्रिप्टेड पीडीएफ फाइल के लिए इन विशेषताओं को नहीं निकाल सकते।

def get_output_file(input_file: str, output_file: str):
    """
    Check whether a temporary output file is needed or not
    """
    input_path = os.path.dirname(input_file)
    input_filename = os.path.basename(input_file)
    # If output file is empty -> generate a temporary output file
    # If output file is equal to input_file -> generate a temporary output file
    if not output_file or input_file == output_file:
        tmp_file = os.path.join(input_path, 'tmp_' + input_filename)
        return True, tmp_file
    return False, output_file

जब कोई आउटपुट फ़ाइल निर्दिष्ट नहीं होती है, या इनपुट और आउटपुट फ़ाइलों के पथ समान होते हैं, तो उपरोक्त फ़ंक्शन अस्थायी आउटपुट फ़ाइल के लिए पथ देता है।

def create_watermark(wm_text: str):
    """
    Creates a watermark template.
    """
    if wm_text:
        # Generate the output to a memory buffer
        output_buffer = BytesIO()
        # Default Page Size = A4
        c = canvas.Canvas(output_buffer, pagesize=PAGESIZE)
        # you can also add image instead of text
        # c.drawImage("logo.png", X, Y, 160, 160)
        # Set the size and type of the font
        c.setFont(FONTNAME, FONTSIZE)
        # Set the color
        if isinstance(COLOR, tuple):
            color = (c/255 for c in COLOR)
            c.setFillColorRGB(*color)
        else:
            c.setFillColor(COLOR)
        # Rotate according to the configured parameter
        c.rotate(ROTATION_ANGLE)
        # Position according to the configured parameter
        c.drawString(X, Y, wm_text)
        c.save()
        return True, output_buffer
    return False, None

यह फ़ंक्शन निम्न कार्य करता है:

वॉटरमार्क फ़ाइल बनाता है और इसे मेमोरी में स्टोर करता है।
रिपोर्टलैब का उपयोग करके हमारे बनाए गए कैनवास पर पहले परिभाषित मापदंडों को लागू करें ।

ध्यान दें कि आप drawString()पाठ लिखने के लिए विधि का उपयोग करने के बजाय , आप drawImage()एक छवि बनाने के लिए उपयोग कर सकते हैं , जैसा कि उपरोक्त फ़ंक्शन में एक टिप्पणी के रूप में लिखा गया है।

def save_watermark(wm_buffer, output_file):
    """
    Saves the generated watermark template to disk
    """
    with open(output_file, mode='wb') as f:
        f.write(wm_buffer.getbuffer())
    f.close()
    return True

save_watermark() उत्पन्न वॉटरमार्क टेम्पलेट को भौतिक फ़ाइल में सहेजता है यदि आपको इसकी कल्पना करने की आवश्यकता है।

अब उस फ़ंक्शन को लिखते हैं जो किसी दिए गए पीडीएफ फाइल में वॉटरमार्क जोड़ने के लिए जिम्मेदार है:

def watermark_pdf(input_file: str, wm_text: str, pages: Tuple = None):
    """
    Adds watermark to a pdf file.
    """
    result, wm_buffer = create_watermark(wm_text)
    if result:
        wm_reader = PdfFileReader(wm_buffer)
        pdf_reader = PdfFileReader(open(input_file, 'rb'), strict=False)
        pdf_writer = PdfFileWriter()
        try:
            for page in range(pdf_reader.getNumPages()):
                # If required to watermark specific pages not all the document pages
                if pages:
                    if str(page) not in pages:
                        continue
                page = pdf_reader.getPage(page)
                page.mergePage(wm_reader.getPage(0))
                pdf_writer.addPage(page)
        except Exception as e:
            print("Exception = ", e)
            return False, None, None
        return True, pdf_reader, pdf_writer

इस फ़ंक्शन का उद्देश्य इनपुट की गई पीडीएफ फाइल को जेनरेट किए गए वॉटरमार्क के साथ मर्ज करना है। यह निम्नलिखित मापदंडों को स्वीकार करता है:

input_file: वॉटरमार्क के लिए पीडीएफ फाइल का पथ।
wm_text: वॉटरमार्क के रूप में सेट किया जाने वाला टेक्स्ट।
pages: वॉटरमार्क के लिए पेज।

यह निम्नलिखित कार्य करता है:

वॉटरमार्क बनाता है और इसे मेमोरी बफर में स्टोर करता है।
इनपुट फ़ाइल के सभी पृष्ठों में पुनरावृति करता है और पहले से जेनरेट किए गए वॉटरमार्क के साथ प्रत्येक चयनित पृष्ठ को मर्ज करता है। वॉटरमार्क पृष्ठ के शीर्ष पर एक ओवरले की तरह कार्य करता है।
परिणामी पृष्ठ को pdf_writerऑब्जेक्ट में जोड़ता है ।

def unwatermark_pdf(input_file: str, wm_text: str, pages: Tuple = None):
    """
    Removes watermark from the pdf file.
    """
    pdf_reader = PdfFileReader(open(input_file, 'rb'), strict=False)
    pdf_writer = PdfFileWriter()
    for page in range(pdf_reader.getNumPages()):
        # If required for specific pages
        if pages:
            if str(page) not in pages:
                continue
        page = pdf_reader.getPage(page)
        # Get the page content
        content_object = page["/Contents"].getObject()
        content = ContentStream(content_object, pdf_reader)
        # Loop through all the elements page elements
        for operands, operator in content.operations:
            # Checks the TJ operator and replaces the corresponding string operand (Watermark text) with ''
            if operator == b_("Tj"):
                text = operands[0]
                if isinstance(text, str) and text.startswith(wm_text):
                    operands[0] = TextStringObject('')
        page.__setitem__(NameObject('/Contents'), content)
        pdf_writer.addPage(page)
    return True, pdf_reader, pdf_writer

इस फ़ंक्शन का उद्देश्य पीडीएफ फाइल से वॉटरमार्क टेक्स्ट को हटाना है। यह निम्नलिखित मापदंडों को स्वीकार करता है:

input_file: वॉटरमार्क के लिए पीडीएफ फाइल का पथ।
wm_text: वॉटरमार्क के रूप में सेट किया जाने वाला टेक्स्ट।
pages: वॉटरमार्क के लिए पेज।

यह निम्नलिखित कार्य करता है:

इनपुट फ़ाइल के सभी पृष्ठों में पुनरावृति करता है और प्रत्येक पृष्ठ की सामग्री को पकड़ लेता है।
पकड़ी गई सामग्री का उपयोग करके, यह ऑपरेटर को ढूंढता है TJऔर इस ऑपरेटर के बाद स्ट्रिंग (वॉटरमार्क टेक्स्ट) को बदल देता है।
pdf_writerऑब्जेक्ट में मर्ज के बाद परिणामी पेज जोड़ता है ।

def watermark_unwatermark_file(**kwargs):
    input_file = kwargs.get('input_file')
    wm_text = kwargs.get('wm_text')
    # watermark   -> Watermark
    # unwatermark -> Unwatermark
    action = kwargs.get('action')
    # HDD -> Temporary files are saved on the Hard Disk Drive and then deleted
    # RAM -> Temporary files are saved in memory and then deleted.
    mode = kwargs.get('mode')
    pages = kwargs.get('pages')
    temporary, output_file = get_output_file(
        input_file, kwargs.get('output_file'))
    if action == "watermark":
        result, pdf_reader, pdf_writer = watermark_pdf(
            input_file=input_file, wm_text=wm_text, pages=pages)
    elif action == "unwatermark":
        result, pdf_reader, pdf_writer = unwatermark_pdf(
            input_file=input_file, wm_text=wm_text, pages=pages)
    # Completed successfully
    if result:
        # Generate to memory
        if mode == "RAM":
            output_buffer = BytesIO()
            pdf_writer.write(output_buffer)
            pdf_reader.stream.close()
            # No need to create a temporary file in RAM Mode
            if temporary:
                output_file = input_file
            with open(output_file, mode='wb') as f:
                f.write(output_buffer.getbuffer())
            f.close()
        elif mode == "HDD":
            # Generate to a new file on the hard disk
            with open(output_file, 'wb') as pdf_output_file:
                pdf_writer.write(pdf_output_file)
            pdf_output_file.close()
            pdf_reader.stream.close()
            if temporary:
                if os.path.isfile(input_file):
                    os.replace(output_file, input_file)
                output_file = input_file

उपरोक्त फ़ंक्शन कई मापदंडों को स्वीकार करता है:

input_file: वॉटरमार्क के लिए पीडीएफ फाइल का पथ।
wm_text: वॉटरमार्क के रूप में सेट किया जाने वाला टेक्स्ट।
action: वॉटरमार्क करने के लिए या अन-वॉटरमार्क फ़ाइल को निष्पादित करने की क्रिया।
mode: अस्थायी फ़ाइल का स्थान चाहे वह मेमोरी हो या हार्ड डिस्क।
pages: वॉटरमार्क के लिए पेज।

watermark_unwatermark_file()फ़ंक्शन पहले से परिभाषित कार्यों को कॉल करता है watermark_pdf()या unwatermark_pdf()चुने हुए पर निर्भर करता है action।

चयनित के आधार पर mode, और अगर आउटपुट फ़ाइल इनपुट फ़ाइल या कोई आउटपुट फ़ाइल के रूप में एक समान पथ निर्दिष्ट किया गया है, तो एक अस्थायी फ़ाइल मामले में चयनित बनाया जाएगा modeहै HDD(हार्ड डिस्क ड्राइव)।

इसके बाद, कई पीडीएफ फाइलों वाले फ़ोल्डर से वॉटरमार्क जोड़ने या हटाने की क्षमता जोड़ते हैं:

def watermark_unwatermark_folder(**kwargs):
    """
    Watermarks all PDF Files within a specified path
    Unwatermarks all PDF Files within a specified path
    """
    input_folder = kwargs.get('input_folder')
    wm_text = kwargs.get('wm_text')
    # Run in recursive mode
    recursive = kwargs.get('recursive')
    # watermark   -> Watermark
    # unwatermark -> Unwatermark
    action = kwargs.get('action')
    # HDD -> Temporary files are saved on the Hard Disk Drive and then deleted
    # RAM -> Temporary files are saved in memory and then deleted.
    mode = kwargs.get('mode')
    pages = kwargs.get('pages')
    # Loop though the files within the input folder.
    for foldername, dirs, filenames in os.walk(input_folder):
        for filename in filenames:
            # Check if pdf file
            if not filename.endswith('.pdf'):
                continue
            # PDF File found
            inp_pdf_file = os.path.join(foldername, filename)
            print("Processing file:", inp_pdf_file)
            watermark_unwatermark_file(input_file=inp_pdf_file, output_file=None,
                                       wm_text=wm_text, action=action, mode=mode, pages=pages)
        if not recursive:
            break

यह फ़ंक्शन निर्दिष्ट फ़ोल्डर की फ़ाइलों में या तो पुनरावर्ती रूप से लूप करता है या recursiveपैरामीटर के मान के आधार पर नहीं , और इन फ़ाइलों को एक-एक करके संसाधित करता है।

अगला, यह जांचने के लिए एक उपयोगिता फ़ंक्शन बनाते हैं कि पथ एक फ़ाइल पथ है या निर्देशिका पथ है:

def is_valid_path(path):
    """
    Validates the path inputted and checks whether it is a file path or a folder path
    """
    if not path:
        raise ValueError(f"Invalid Path")
    if os.path.isfile(path):
        return path
    elif os.path.isdir(path):
        return path
    else:
        raise ValueError(f"Invalid Path {path}")

अब जब हमारे पास इस ट्यूटोरियल के लिए आवश्यक सभी कार्य हैं, तो आइए कमांड-लाइन तर्कों को पार्स करने के लिए एक अंतिम कार्य करें:

def parse_args():
    """
    Get user command line parameters
    """
    parser = argparse.ArgumentParser(description="Available Options")
    parser.add_argument('-i', '--input_path', dest='input_path', type=is_valid_path,
                        required=True, help="Enter the path of the file or the folder to process")
    parser.add_argument('-a', '--action', dest='action', choices=[
                        'watermark', 'unwatermark'], type=str, default='watermark',
                        help="Choose whether to watermark or to unwatermark")
    parser.add_argument('-m', '--mode', dest='mode', choices=['RAM', 'HDD'], type=str,
                        default='RAM', help="Choose whether to process on the hard disk drive or in memory")
    parser.add_argument('-w', '--watermark_text', dest='watermark_text',
                        type=str, required=True, help="Enter a valid watermark text")
    parser.add_argument('-p', '--pages', dest='pages', type=tuple,
                        help="Enter the pages to consider e.g.: [2,4]")
    path = parser.parse_known_args()[0].input_path
    if os.path.isfile(path):
        parser.add_argument('-o', '--output_file', dest='output_file',
                            type=str, help="Enter a valid output file")
    if os.path.isdir(path):
        parser.add_argument('-r', '--recursive', dest='recursive', default=False, type=lambda x: (
            str(x).lower() in ['true', '1', 'yes']), help="Process Recursively or Non-Recursively")
    # To Porse The Command Line Arguments
    args = vars(parser.parse_args())
    # To Display The Command Line Arguments
    print("## Command Arguments #################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in args.items()))
    print("######################################################################")
    return args

नीचे परिभाषित तर्क हैं:

input_path: फ़ाइल या फ़ोल्डर को संसाधित करने के पथ को इनपुट करने के लिए एक आवश्यक पैरामीटर, यह पैरामीटर is_valid_path()पहले परिभाषित फ़ंक्शन से जुड़ा हुआ है।
action: निष्पादित करने की क्रिया, जो watermarkया unwatermarkतो पीडीएफ फाइल है, डिफ़ॉल्ट रूप से वॉटरमार्क है।
mode: उत्पन्न अस्थायी फ़ाइल के गंतव्य को निर्दिष्ट करने के लिए, चाहे वह मेमोरी हो या हार्ड डिस्क।
watermark_text: वॉटरमार्क के रूप में सेट करने के लिए स्ट्रिंग।
pages: वॉटरमार्क वाले पेज (उदाहरण के लिए पहला पेज है [0], दूसरा पेज है और चौथा पेज है [1, 3], आदि)। यदि निर्दिष्ट नहीं है, तो सभी पृष्ठ।
output_file: आउटपुट फ़ाइल का पथ।
recursive: क्या किसी फ़ोल्डर को पुनरावर्ती रूप से संसाधित करना है।

अब जब हमारे पास सब कुछ है, तो पास किए गए मापदंडों के आधार पर निष्पादित करने के लिए मुख्य कोड लिखें:

if __name__ == '__main__':
    # Parsing command line arguments entered by user
    args = parse_args()
    # If File Path
    if os.path.isfile(args['input_path']):
        # Extracting File Info
        get_info(input_file=args['input_path'])
        # Encrypting or Decrypting a File
        watermark_unwatermark_file(
            input_file=args['input_path'], wm_text=args['watermark_text'], action=args[
                'action'], mode=args['mode'], output_file=args['output_file'], pages=args['pages']
        )
    # If Folder Path
    elif os.path.isdir(args['input_path']):
        # Encrypting or Decrypting a Folder
        watermark_unwatermark_folder(
            input_folder=args['input_path'], wm_text=args['watermark_text'],
            action=args['action'], mode=args['mode'], recursive=args['recursive'], pages=args['pages']
        )

यदि आप एक टर्मिनल विंडो खोलते हैं और टाइप करते हैं, तो अब हमारे प्रोग्राम का परीक्षण करें:

$ python pdf_watermarker.py --help

यह परिभाषित पैरामीटर और उनके संबंधित विवरण दिखाएगा:

usage: pdf_watermarker.py [-h] -i INPUT_PATH [-a {watermark,unwatermark}] [-m {RAM,HDD}] -w WATERMARK_TEXT [-p PAGES]

Available Options

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT_PATH, --input_path INPUT_PATH
                        Enter the path of the file or the folder to process
  -a {watermark,unwatermark}, --action {watermark,unwatermark}
                        Choose whether to watermark or to unwatermark
  -m {RAM,HDD}, --mode {RAM,HDD}
                        Choose whether to process on the hard disk drive or in memory
  -w WATERMARK_TEXT, --watermark_text WATERMARK_TEXT
                        Enter a valid watermark text
  -p PAGES, --pages PAGES
                        Enter the pages to consider e.g.: [2,4]

अब एक उदाहरण के रूप में मेरे सीवी को वॉटरमार्क करते हैं:

$ python pdf_watermarker.py -a watermark -i "CV Bassem Marji_Eng.pdf" -w "CONFIDENTIAL" -o CV_watermark.pdf

निम्नलिखित आउटपुट का उत्पादन किया जाएगा:

## Command Arguments #################################################
input_path:CV Bassem Marji_Eng.pdf
action:watermark
mode:RAM
watermark_text:CONFIDENTIAL
pages:None
output_file:CV_watermark.pdf
######################################################################
## File Information ##################################################
File:CV Bassem Marji_Eng.pdf
Encrypted:False
Author:TMS User
Creator:Microsoft® Word 2013
Producer:Microsoft® Word 2013
Subject:None
Title:None
Number of pages:1
######################################################################

और इस CV_watermark.pdfतरह आउटपुट फ़ाइल इस तरह दिखती है:

पायथन के साथ वॉटरमार्क पीडीएफ

अब जोड़े गए वॉटरमार्क को हटा दें:

$ python pdf_watermarker.py -a unwatermark -i "CV_watermark.pdf" -w "CONFIDENTIAL" -o CV.pdf

इस बार वॉटरमार्क हटा दिया जाएगा और एक नई पीडीएफ फाइल में सहेजा जाएगा CV.pdf।

आप क्रमशः मोड और पृष्ठों के लिए -mऔर के -pलिए भी सेट कर सकते हैं। आप किसी विशिष्ट पथ के अंतर्गत स्थित PDF फ़ाइलों की सूची को वॉटरमार्क भी कर सकते हैं:

$ python pdf_watermarker.py -i "C:\Scripts\Test" -a "watermark" -w "CONFIDENTIAL" -r False

या पीडीएफ फाइलों के एक समूह से वॉटरमार्क हटाना:

$ python pdf_watermarker.py -i "C:\Scripts\Test" -a "unwatermark" -w "CONFIDENTIAL" -m HDD -p[0] -r False

निष्कर्ष

इस ट्यूटोरियल में, आपने पाइथन में रिपोर्टलैब और पीपीडीएफ4 लाइब्रेरी का उपयोग करके पीडीएफ फाइलों से वॉटरमार्क जोड़ने और हटाने का तरीका सीखा है। मुझे उम्मीद है कि इस लेख ने आपको इस शानदार विशेषता को आत्मसात करने में मदद की है।

#python

Khaitan

1633696993

पायथन में पीडीएफ फाइलों को कैसे कंप्रेस करें

पीडीएफट्रॉन एसडीके के रैपर का उपयोग करके पायथन में पीडीएफ फाइलों को संपीड़ित करना सीखें।

पीडीएफ को संपीड़ित करने से आप उस पीडीएफ फाइल में मीडिया की गुणवत्ता को बनाए रखते हुए फ़ाइल का आकार जितना संभव हो उतना छोटा कर सकते हैं। नतीजतन, यह प्रभावशीलता और साझा करने की क्षमता में काफी वृद्धि करता है।

इस ट्यूटोरियल में, आप सीखेंगे कि आप पायथन में पीडीएफट्रॉन लाइब्रेरी का उपयोग करके पीडीएफ फाइलों को कैसे कंप्रेस कर सकते हैं।

PDFNetPython3 PDFTron SDK के लिए एक आवरण है । PDFTron घटकों के साथ आप विश्वसनीय और तेज़ एप्लिकेशन बना सकते हैं जो विभिन्न ऑपरेटिंग सिस्टम में PDF को देख, बना सकते हैं, प्रिंट कर सकते हैं, संपादित कर सकते हैं और एनोटेट कर सकते हैं। डेवलपर PDF विनिर्देशों के सभी प्रकाशित संस्करणों (नवीनतम ISO32000 सहित ) के साथ संगत PDF दस्तावेज़ों को पढ़ने, लिखने और संपादित करने के लिए PDFTron SDK का उपयोग करते हैं ।

PDFTron फ्रीवेयर नहीं है यह 2 प्रकार के लाइसेंस प्रदान करता है जो इस पर निर्भर करता है कि आप बाहरी/वाणिज्यिक उत्पाद विकसित कर रहे हैं या आंतरिक समाधान।

इस ट्यूटोरियल के प्रयोजन के लिए, हम इस SDK के निःशुल्क परीक्षण संस्करण का उपयोग करेंगे। इस ट्यूटोरियल का लक्ष्य पाइथन-आधारित मॉड्यूल के माध्यम से पाइथन पारिस्थितिकी तंत्र (जैसे घोस्टस्क्रिप्ट ) के बाहर बाहरी उपयोगिताओं पर भरोसा किए बिना हल्के कमांड-लाइन-आधारित उपयोगिता को विकसित करना है , ताकि पीडीएफ फाइलों को संपीड़ित किया जा सके।

आरंभ करने के लिए, आइए पाइप का उपयोग करके पायथन रैपर स्थापित करें:

$ pip install PDFNetPython3==8.1.0

एक नई पायथन फ़ाइल खोलें और आवश्यक मॉड्यूल आयात करें:

# Import Libraries
import os
import sys
from PDFNetPython3.PDFNetPython import PDFDoc, Optimizer, SDFDoc, PDFNet

इसके बाद, आइए एक फ़ंक्शन को परिभाषित करें जो फ़ाइल आकार को उपयुक्त प्रारूप में प्रिंट करता है ( इस ट्यूटोरियल से लिया गया ):

def get_size_format(b, factor=1024, suffix="B"):
    """
    Scale bytes to its proper byte format
    e.g:
        1253656 => '1.20MB'
        1253656678 => '1.17GB'
    """
    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
        if b < factor:
            return f"{b:.2f}{unit}{suffix}"
        b /= factor
    return f"{b:.2f}Y{suffix}"

अब हमारे मुख्य कार्य को परिभाषित करते हैं:

def compress_file(input_file: str, output_file: str):
    """Compress PDF file"""
    if not output_file:
        output_file = input_file
    initial_size = os.path.getsize(input_file)
    try:
        # Initialize the library
        PDFNet.Initialize()
        doc = PDFDoc(input_file)
        # Optimize PDF with the default settings
        doc.InitSecurityHandler()
        # Reduce PDF size by removing redundant information and compressing data streams
        Optimizer.Optimize(doc)
        doc.Save(output_file, SDFDoc.e_linearized)
        doc.Close()
    except Exception as e:
        print("Error compress_file=", e)
        doc.Close()
        return False
    compressed_size = os.path.getsize(output_file)
    ratio = 1 - (compressed_size / initial_size)
    summary = {
        "Input File": input_file, "Initial Size": get_size_format(initial_size),
        "Output File": output_file, f"Compressed Size": get_size_format(compressed_size),
        "Compression Ratio": "{0:.3%}.".format(ratio)
    }
    # Printing Summary
    print("## Summary ########################################################")
    print("\n".join("{}:{}".format(i, j) for i, j in summary.items()))
    print("###################################################################")
    return True

यह फ़ंक्शन अनावश्यक जानकारी को हटाकर और डेटा स्ट्रीम को संपीड़ित करके एक पीडीएफ फाइल को संपीड़ित करता है, फिर यह संपीड़न अनुपात और संपीड़न के बाद फ़ाइल के आकार को दिखाते हुए एक सारांश प्रिंट करता है। यह पीडीएफ लेता है input_fileऔर संपीड़ित पीडीएफ का उत्पादन करता है output_file।

अब हमारे मुख्य कोड को परिभाषित करते हैं:

if __name__ == "__main__":
    # Parsing command line arguments entered by user
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    compress_file(input_file, output_file)

हम केवल कमांड-लाइन तर्कों से इनपुट और आउटपुट फाइल प्राप्त करते हैं और फिर compress_file()पीडीएफ फाइल को संपीड़ित करने के लिए हमारे परिभाषित फ़ंक्शन का उपयोग करते हैं ।

आइए इसका परीक्षण करें:

$ python pdf_compressor.py bert-paper.pdf bert-paper-min.pdf

निम्नलिखित आउटपुट है:

PDFNet is running in demo mode.
Permission: read     
Permission: optimizer
Permission: write
## Summary ########################################################
Input File:bert-paper.pdf
Initial Size:757.00KB
Output File:bert-paper-min.pdf
Compressed Size:498.33KB
Compression Ratio:34.171%.
###################################################################

जैसा कि आप देख सकते हैं, के 498KBबजाय के आकार के साथ एक नई संपीड़ित पीडीएफ फाइल, इसे देखें 757KB:

निष्कर्ष

मुझे आशा है कि आपने ट्यूटोरियल का आनंद लिया और यह पीडीएफ कंप्रेसर आपके कार्यों के लिए उपयोगी पाया।

#python

Khaitan

1633660595

पायथन में पीडीएफ मेटाडेटा कैसे निकालें

पायथन में पीडीएफ फाइलों से उपयोगी जानकारी निकालने के लिए पाइकपीडीएफ लाइब्रेरी का उपयोग करना सीखें।

पीडीएफ में मेटाडेटा पीडीएफ दस्तावेज़ के बारे में उपयोगी जानकारी है, इसमें दस्तावेज़ का शीर्षक, लेखक, अंतिम संशोधन तिथि, निर्माण तिथि, विषय और बहुत कुछ शामिल है। कुछ पीडीएफ फाइलों को दूसरों की तुलना में अधिक जानकारी मिली, और इस ट्यूटोरियल में, आप सीखेंगे कि पायथन में पीडीएफ मेटाडेटा कैसे निकाला जाए।

एक ही चीज़ को पूरा करने के लिए पायथन में बहुत सारे पुस्तकालय और उपयोगिताएँ हैं, लेकिन मुझे pikepdf का उपयोग करना पसंद है , क्योंकि यह एक सक्रिय और अनुरक्षित पुस्तकालय है। आइए इसे स्थापित करें:

$ pip install pikepdf

Pikepdf C++ QPDF लाइब्रेरी के चारों ओर एक पाइथोनिक आवरण है । आइए इसे अपनी स्क्रिप्ट में आयात करें:

import pikepdf
import sys

हम कमांड-लाइन तर्कों से फ़ाइल नाम प्राप्त करने के लिए sys मॉड्यूल का भी उपयोग करेंगे :

# get the target pdf file from the command-line arguments
pdf_filename = sys.argv[1]

आइए लाइब्रेरी का उपयोग करके पीडीएफ फाइल लोड करें, और मेटाडेटा प्राप्त करें:

# read the pdf file
pdf = pikepdf.Pdf.open(pdf_filename)
docinfo = pdf.docinfo
for key, value in docinfo.items():
    print(key, ":", value)

docinfoविशेषता दस्तावेज़ के मेटाडाटा का एक शब्दकोश में शामिल है। यहाँ एक उदाहरण निष्पादन है:

$ python extract_pdf_metadata_simple.py bert-paper.pdf

आउटपुट:

/Author : 
/CreationDate : D:20190528000751Z
/Creator : LaTeX with hyperref package
/Keywords :
/ModDate : D:20190528000751Z
/PTEX.Fullbanner : This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016) kpathsea version 6.2.2
/Producer : pdfTeX-1.40.17
/Subject :
/Title :
/Trapped : /False

यहाँ एक और पीडीएफ फाइल है:

$ python extract_pdf_metadata_simple.py python_cheat_sheet.pdf

आउटपुट:

/CreationDate : D:20201002181301Z
/Creator : wkhtmltopdf 0.12.5
/Producer : Qt 4.8.7
/Title : Markdown To PDF

जैसा कि आप देख सकते हैं, सभी दस्तावेज़ों में समान फ़ील्ड नहीं होते हैं, कुछ में बहुत कम जानकारी होती है।

सूचना है कि /ModDateऔर /CreationDateपीडीएफ datetime स्वरूप में अंतिम संशोधन दिनांक और निर्माण तिथि क्रमशः रहे हैं। यदि आप इस प्रारूप को पायथन डेटाटाइम प्रारूप में बदलना चाहते हैं, तो मैंने इस कोड को स्टैक ओवरफ्लो से कॉपी किया है और इसे पायथन 3 पर चलाने के लिए थोड़ा संपादित किया है:

import pikepdf
import datetime
import re
from dateutil.tz import tzutc, tzoffset
import sys

pdf_date_pattern = re.compile(''.join([
    r"(D:)?",
    r"(?P<year>\d\d\d\d)",
    r"(?P<month>\d\d)",
    r"(?P<day>\d\d)",
    r"(?P<hour>\d\d)",
    r"(?P<minute>\d\d)",
    r"(?P<second>\d\d)",
    r"(?P<tz_offset>[+-zZ])?",
    r"(?P<tz_hour>\d\d)?",
    r"'?(?P<tz_minute>\d\d)?'?"]))

def transform_date(date_str):
    """
    Convert a pdf date such as "D:20120321183444+07'00'" into a usable datetime
    http://www.verypdf.com/pdfinfoeditor/pdf-date-format.htm
    (D:YYYYMMDDHHmmSSOHH'mm')
    :param date_str: pdf date string
    :return: datetime object
    """
    global pdf_date_pattern
    match = re.match(pdf_date_pattern, date_str)
    if match:
        date_info = match.groupdict()

        for k, v in date_info.items():  # transform values
            if v is None:
                pass
            elif k == 'tz_offset':
                date_info[k] = v.lower()  # so we can treat Z as z
            else:
                date_info[k] = int(v)

        if date_info['tz_offset'] in ('z', None):  # UTC
            date_info['tzinfo'] = tzutc()
        else:
            multiplier = 1 if date_info['tz_offset'] == '+' else -1
            date_info['tzinfo'] = tzoffset(None, multiplier*(3600 * date_info['tz_hour'] + 60 * date_info['tz_minute']))

        for k in ('tz_offset', 'tz_hour', 'tz_minute'):  # no longer needed
            del date_info[k]

        return datetime.datetime(**date_info)

# get the target pdf file from the command-line arguments
pdf_filename = sys.argv[1]
# read the pdf file
pdf = pikepdf.Pdf.open(pdf_filename)
docinfo = pdf.docinfo
for key, value in docinfo.items():
    if str(value).startswith("D:"):
        # pdf datetime format, convert to python datetime
        value = transform_date(str(pdf.docinfo["/CreationDate"]))
    print(key, ":", value)

यहां पहले जैसा ही आउटपुट है, लेकिन डेटाटाइम प्रारूपों को पायथन डेटाटाइम ऑब्जेक्ट्स में परिवर्तित कर दिया गया है:

/Author : 
/CreationDate : 2019-05-28 00:07:51+00:00
/Creator : LaTeX with hyperref package
/Keywords :
/ModDate : 2019-05-28 00:07:51+00:00
/PTEX.Fullbanner : This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016) kpathsea version 6.2.2
/Producer : pdfTeX-1.40.17
/Subject :
/Title :
/Trapped : /False

ज्यादा बेहतर। मुझे उम्मीद है कि इस त्वरित ट्यूटोरियल ने आपको Python के साथ PDF दस्तावेज़ों का मेटाडेटा प्राप्त करने में मदद की है।

यहां पूरा कोड देखें ।

#python #pdf