pdfgate 0.0.2__py3-none-any.whl

pdfgate/url_builder.py

@@ -0,0 +1,81 @@
+"""URL construction for PDFGate API endpoints."""
+
+
+class URLBuilder:
+    """Helper class to build URLs for the PDFGate API."""
+
+    def __init__(self, domain: str):
+        """Create a URL builder using the provided API domain."""
+        self.domain = domain
+
+    def get_document_url(self, document_id: str) -> str:
+        """Build the URL for accessing a document.
+
+        Args:
+            document_id:
+                ID of the document.
+
+        Returns:
+            Full URL to access the document.
+        """
+        return f"{self.domain}/document/{document_id}"
+
+    def get_file_url(self, document_id: str) -> str:
+        """Build the URL for downloading a document.
+
+        Args:
+            document_id:
+                ID of the document.
+
+        Returns:
+            Full URL to download the document.
+        """
+        return f"{self.domain}/file/{document_id}"
+
+    def generate_pdf_url(self) -> str:
+        """Build the URL for generating a PDF.
+
+        Returns:
+            Full URL to generate a PDF.
+        """
+        return f"{self.domain}/v1/generate/pdf"
+
+    def flatten_pdf_url(self) -> str:
+        """Build the URL for flattening a PDF.
+
+        Returns:
+            Full URL to flatten a PDF.
+        """
+        return f"{self.domain}/forms/flatten"
+
+    def extract_pdf_form_data_url(self) -> str:
+        """Build the URL for extracting PDF form data.
+
+        Returns:
+            Full URL to extract PDF form data.
+        """
+        return f"{self.domain}/forms/extract-data"
+
+    def protect_pdf_url(self) -> str:
+        """Build the URL for encrypting a PDF.
+
+        Returns:
+            Full URL to encrypt a PDF.
+        """
+        return f"{self.domain}/protect/pdf"
+
+    def compress_pdf_url(self) -> str:
+        """Build the URL for compressing a PDF.
+
+        Returns:
+            Full URL to compress a PDF.
+        """
+        return f"{self.domain}/compress/pdf"
+
+    def watermark_pdf_url(self) -> str:
+        """Build the URL for watermarking a PDF.
+
+        Returns:
+            Full URL to watermark a PDF.
+        """
+        return f"{self.domain}/watermark/pdf"

pdfgate-0.0.2.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: pdfgate
+Version: 0.0.2
+Summary: PDFGate's official Python SDK
+Project-URL: Documentation, https://github.com/pdfgate/pdfgate-sdk-python#readme
+Project-URL: Issues, https://github.com/pdfgate/pdfgate-sdk-python/issues
+Project-URL: Source, https://github.com/pdfgate/pdfgate-sdk-python
+Author-email: Fernando Gasperi <fgasperijabalera@gmail.com>, Demetra Theodorou <demtra@pdfgate.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.9
+Requires-Dist: httpx
+Description-Content-Type: text/markdown
+
+# PDFGate's official Python SDK
+
+PDFGate lets you generate, process, and secure PDFs via a simple API:
+
+- HTML or URL to PDF
+- Fillable forms
+- Flatten, compress, watermark, protect PDFs
+- Extract PDF form data
+
+📘 Documentation: https://pdfgate.com/documentation<br>
+🔑 Dashboard & API keys: https://dashboard.pdfgate.com
+
+## pdfgate-sdk-python
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pdfgate-sdk-python.svg)](https://pypi.org/project/pdfgate-sdk-python)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pdfgate-sdk-python.svg)](https://pypi.org/project/pdfgate-sdk-python)
+
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Sync & Async](#sync--async)
+- [Responses](#responses)
+- [Examples](#examples)
+- [Development](#development)
+- [Support](#support)
+- [License](#license)
+
+# Installation
+
+```sh
+pip install pdfgate
+```
+
+# Quick start
+
+```python
+import os
+
+from pdfgate import PDFGate, GeneratePDFParams
+
+
+client = PDFGate(api_key=os.getenv("PDFGATE_API_KEY"))
+params = GeneratePDFParams(url="https://example.com")
+pdf = client.generate_pdf(params)
+
+with open("output.pdf", "wb") as f:
+  f.write(pdf)
+```
+
+# Sync & Async
+
+There are sync and async versions of all methods, the only difference is that the method name has an `async` suffix:
+
+```python
+document_response = client.get_document(GetDocumentParams(document_id=document_id))
+
+# VS
+
+document_response = await client.get_document_async(GetDocumentParams(document_id=document_id))
+```
+
+Other than that, nothing changes and the interfaces are the same.
+
+# Responses
+
+The two response types for most endpoints are either the raw bytes of the
+PDF file or the documents metadata that you can use to query or download later:
+
+- file: this is represented by `bytes` and it can be saved directly into a file.
+- `PDFGateDocument`: this is a `TypedDict` that holds all the metadata of the file including its `id`,  and a `file_url` to download it if it was requested by specifying `pre_signed_url_expires_in` in the request.
+
+# Examples
+
+## Generate PDF
+
+```python
+params = GeneratePDFParams(html="<h1>Hello from PDFGate!</h1>")
+pdf = client.generate_pdf(params)
+
+with open("output.pdf", "wb") as f:
+  f.write(pdf)
+```
+
+## Get document metadata
+
+```python
+document_response = client.get_document(GetDocumentParams(document_id=document_id))
+
+assert document_response = {
+    "id" : "6642381c5c61"
+    "status" : DocumentStatus.COMPLETED
+    "type" : DocumentType.FROM_HTML,
+    "file_url" : "https://api.pdfgate.com/file/open/:preSignedUrlToken"
+    "size" : 1620006
+    "createdAt" : datetime(2024,02,13, 15, 56, 12, 607)"
+}
+```
+
+## Download a stored PDF file
+
+```python
+file_content = client.get_file(GetFileParams(document_id=document_id))
+
+with open("output.pdf", "wb") as f:
+  f.write(pdf)
+```
+
+## Flatten a PDF (make form-fields non-editable)
+
+```python
+flatten_pdf_params = FlattenPDFDocumentParams(
+    document_id=document_id, json_response=True
+)
+flattened_document = client.flatten_pdf(flatten_pdf_params)
+```
+
+## Compress a PDF
+
+```python
+compress_pdf_params = CompressPDFByDocumentIdParams(
+    document_id=document_id, json_response=True
+)
+response = client.compress_pdf(compress_pdf_params)
+```
+
+## Watermark a PDF
+
+```python
+watermark_pdf_params = WatermarkPDFByFileParams(
+    file=FileParam(name="input.pdf", data=pdf_file),
+    type=WatermarkType.IMAGE,
+    watermark=FileParam(name="watermark.jpg", data=jpg_file),
+)
+watermarked_pdf = cast(PDFGateDocument, client.watermark_pdf(watermark_pdf_params))
+```
+
+## Protect (encrypt) a PDF
+
+```python
+protect_pdf_params = ProtectPDFByDocumentIdParams(
+    document_id=document_id,
+    user_password=str(uuid.uuid4()),
+    owner_password=str(uuid.uuid4()),
+    json_response=True,
+)
+response = client.protect_pdf(protect_pdf_params)
+```
+
+## Extract PDF form fields values
+
+```python
+html_form = """
+    <form>
+        <input type='text' name='first_name' value='John'/>
+        <input type='text' name='last_name' value='Doe'/>
+    </form>
+    """
+generate_pdf_params = GeneratePDFParams(
+    html=html_form, enable_form_fields=True, json_response=True
+)
+document_response = cast(PDFGateDocument, client.generate_pdf(generate_pdf_params))
+document_id = cast(str, document_response.get("id"))
+
+extract_form_params = ExtractPDFFormDataByDocumentIdParams(document_id=document_id)
+response = cast(dict[str, Any], client.extract_pdf_form_data(extract_form_params))
+```
+
+# Development
+
+Before doing anything, install [pre-commit](https://pre-commit.com/) by running:
+
+```sh
+hatch run dev:pre-commit install
+```
+
+This will run several checks every time you try to `git commit` including:
+
+- linting and formatting with `Ruff`
+- type checking with `mypy`
+
+If you are on VS Code, it's recommended to install the `Ruff` extension so you'll get formatting on the fly.
+
+Hatch is used as a build system and for dependency management, so all main actions are configured to be run with Hatch.
+
+## Tests
+
+Unit tests:
+```sh
+hatch run test:test
+```
+
+Acceptance tests hit the PDFGate API so they are slower, and require an API key that is expected to be set as an env var named `PDFGATE_API_KEY`. You can set it on your Bash/zsh/fish profile or inline as in:
+
+```sh
+PDFGATE_API_KEY="test_123" hatch run test:test_acceptance
+```
+
+## Manually run Ruff
+
+Linting:
+```sh
+hatch run dev:lint
+```
+
+Formatting:
+```sh
+hatch run dev:ruff format .
+```
+
+## Type checking
+
+Manually mypy for type checking:
+
+```sh
+hatch run dev:check
+```
+
+## Docs
+
+Docs are build using [MkDocs](https://www.mkdocs.org/), they live in the `docs/` folder, and in the code. If you make any changes, and would like to see them live before publishing them, spin up a server locally with:
+
+```sh
+hatch run docs:serve
+```
+
+Changes to `docs/**` and `mkdocs.yml` trigger a new deployment of the docs site. If you change the code's documentation and want to manually update the docs site you can do it from the _Actions_ tab of the repo or by running:
+
+```sh
+hatch run docs:mkdocs gh-deploy
+```
+
+# Support
+
+📧 Email: support@pdfgate.com<br>
+📘 Docs: https://pdfgate.com/documentation
+
+## License
+
+`pdfgate-sdk-python` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

pdfgate-0.0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+pdfgate/__about__.py,sha256=8ouC2JLRB99qLhOJNCPFJNs8b_GZcT_k2vXBVBYt6ug,177
+pdfgate/__init__.py,sha256=3UuE7DAAJk49eLFXyDmlHJ20tyRlewWiWDfZs2BttLo,2025
+pdfgate/config.py,sha256=C0p2DIon6NUW76aBLZIQ3ZRmzBnBdxS0doxhyNPo31E,572
+pdfgate/dict_keys_converter.py,sha256=_-c737ohvEKNDbsB6lp9KqDt16ZTjIIkJ7EBcTSru-E,2105
+pdfgate/errors.py,sha256=1xhp5gdDQeH3Lt0jweDSN8Z9vi118jS0knQCUwReYVs,233
+pdfgate/http_client.py,sha256=0eemoVeSHwHTUFm7BKe2rG8xnGf9zxYLX1fjKuw15Jg,2764
+pdfgate/params.py,sha256=EAmBnJIP7XbwjVD8bCDF-0Cig6Ro7hRiLamQIUgYHy8,7800
+pdfgate/pdfgate.py,sha256=F-FkisFLkFKdPQdIDTnelSEro6WspnrEZzCbwNIblUU,15613
+pdfgate/request_builder.py,sha256=byRy_VfuqpYiWXhvLjNZ9IumxBI_Zfa-UcFH35kpkxs,9797
+pdfgate/response_builder.py,sha256=_3SkGziM0mrW5H-nG2iTMXtwaPFUEuLy-4bJmqF4vCc,715
+pdfgate/responses.py,sha256=IeP_EYgkzzW97DX9YooffXWAoQz9Z15Vk83DmoZQVrw,893
+pdfgate/url_builder.py,sha256=F_Joc8igsoYxmL7mdy7vxVnVrWJb1ekVUE1NGlD6anI,2134
+pdfgate-0.0.2.dist-info/METADATA,sha256=nuX2NUcgmd5bC59vxey8avDE62n1Mp4BpmKEQlCEY9g,7254
+pdfgate-0.0.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pdfgate-0.0.2.dist-info/licenses/LICENSE,sha256=bbmVqXq9fdjy9HgXnraS3rnPZQh7vZCLBWyUME3mkfY,1064
+pdfgate-0.0.2.dist-info/RECORD,,

pdfgate-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pdfgate-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PDFGate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.