fetchxml 0.1.0__tar.gz

fetchxml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saurabh Kumar Agarwal
+
+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.

fetchxml-0.1.0/PKG-INFO

@@ -0,0 +1,356 @@
+Metadata-Version: 2.4
+Name: fetchxml
+Version: 0.1.0
+Summary: Lightweight session-based XML fetcher with browser-like behavior.
+Author: Your Name
+Project-URL: Homepage, https://github.com/yourusername/fetchxml
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+Here is a complete, production-quality **README.md** for your open-source package **fetchxml**.
+
+You can paste this directly into `README.md`.
+
+---
+
+# 📦 fetchxml
+
+Lightweight, session-based XML fetcher for Python.
+
+`fetchxml` provides a clean, reusable way to fetch XML from web endpoints that require:
+
+* Browser-like headers
+* Session initialization
+* Cookie handling
+* Referer validation
+* Basic anti-bot protection handling
+
+It abstracts session bootstrapping and retry logic into a simple interface.
+
+---
+
+## 🚀 Why fetchxml?
+
+Some websites block simple HTTP requests and require:
+
+* A session cookie
+* Proper User-Agent
+* Referer header
+* Basic browser simulation
+
+`fetchxml` handles this automatically.
+
+Instead of writing repetitive session logic every time, you can do:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+xml = client.fetch("https://example.com/file.xml")
+
+print(xml)
+```
+
+---
+
+# 📥 Installation
+
+## Option 1 – Install from local project
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+For development mode:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Option 2 – Install from PyPI (after publishing)
+
+```bash
+pip install fetchxml
+```
+
+---
+
+# 🧠 Basic Usage
+
+## 1️⃣ Simple XML Fetch
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml[:500])
+```
+
+Use this when the target site does NOT require session bootstrap.
+
+---
+
+## 2️⃣ Fetch XML With Session Bootstrap
+
+Some sites require hitting their homepage first to establish cookies.
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml)
+```
+
+`base_url` triggers automatic session initialization.
+
+---
+
+## 3️⃣ Fetch With Custom Referer
+
+If a specific referer header is required:
+
+```python
+xml = client.fetch(
+    "https://example.com/sample.xml",
+    referer="https://example.com/dashboard"
+)
+```
+
+---
+
+# ⚙️ Configuration Options
+
+When initializing:
+
+```python
+client = FetchXML(
+    base_url="https://example.com",  # optional
+    delay=0.5,                       # delay between requests (seconds)
+    timeout=15                       # request timeout (seconds)
+)
+```
+
+### Parameters
+
+| Parameter  | Description                                   |
+| ---------- | --------------------------------------------- |
+| `base_url` | URL used to bootstrap session cookies         |
+| `delay`    | Sleep time before each request (default 0.5s) |
+| `timeout`  | Request timeout in seconds (default 15s)      |
+
+---
+
+# 🔁 Automatic Retry Behavior
+
+If a request returns **HTTP 403**, `fetchxml` will:
+
+1. Attempt to re-bootstrap session (if `base_url` provided)
+2. Retry the request once
+
+If it still fails → exception is raised.
+
+---
+
+# ❗ Exception Handling
+
+All errors raise:
+
+```python
+FetchXMLError
+```
+
+Import it like:
+
+```python
+from fetchxml import FetchXMLError
+```
+
+Example:
+
+```python
+from fetchxml import FetchXML, FetchXMLError
+
+client = FetchXML(base_url="https://example.com")
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print(xml)
+except FetchXMLError as e:
+    print("Failed to fetch XML:", str(e))
+```
+
+---
+
+# 🔍 What Triggers FetchXMLError?
+
+* Session bootstrap failure
+* Non-200 HTTP response
+* Timeout
+* Connection error
+* Persistent 403 after retry
+
+---
+
+# 🛡️ Rate Limiting
+
+`delay` ensures a pause before each request:
+
+```python
+client = FetchXML(delay=1.5)
+```
+
+Recommended for:
+
+* Bulk XML downloads
+* Respecting server load
+* Avoiding bot detection
+
+---
+
+# 📁 Example: Download and Save XML
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+url = "https://example.com/sample.xml"
+xml = client.fetch(url)
+
+with open("sample.xml", "w", encoding="utf-8") as f:
+    f.write(xml)
+
+print("Saved successfully.")
+```
+
+---
+
+# 🔧 Advanced: Reusing One Client for Multiple Files
+
+Best practice for bulk downloads:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+urls = [
+    "https://example.com/file1.xml",
+    "https://example.com/file2.xml",
+    "https://example.com/file3.xml"
+]
+
+for url in urls:
+    xml = client.fetch(url)
+    print(f"Downloaded {url}")
+```
+
+This reuses the same session and cookies.
+
+---
+
+# 🧪 Testing Connectivity
+
+You can quickly test a URL:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print("Success")
+except Exception as e:
+    print("Error:", e)
+```
+
+---
+
+# 🏗️ Project Structure
+
+```
+fetchxml/
+│
+├── fetchxml/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+---
+
+# 📜 License
+
+MIT License
+
+See `LICENSE` file for full text.
+
+---
+
+# ⚠️ Disclaimer
+
+`fetchxml` does not bypass authentication systems or CAPTCHAs.
+
+It simply mimics normal browser session behavior using:
+
+* Session cookies
+* Proper headers
+* Referer validation
+
+Users are responsible for complying with website terms of service.
+
+---
+
+# 💡 When To Use fetchxml
+
+Use it when:
+
+* A site blocks naive `requests.get()`
+* Cookies must be initialized first
+* Referer headers are required
+* You want clean, reusable XML fetching logic
+
+Do NOT use it for:
+
+* Circumventing login walls
+* Bypassing paywalls
+* Evading legal restrictions
+
+---
+
+# 🧩 Roadmap (Optional Future Enhancements)
+
+* Async version
+* Disk caching layer
+* Proxy support
+* Built-in XML validation
+* Exponential backoff strategy
+* Logging integration
+
+---
+
+# 👤 Author
+
+Saurabh Kumar Agarwal
+2026
+
+---
+

fetchxml-0.1.0/README.md

@@ -0,0 +1,344 @@
+Here is a complete, production-quality **README.md** for your open-source package **fetchxml**.
+
+You can paste this directly into `README.md`.
+
+---
+
+# 📦 fetchxml
+
+Lightweight, session-based XML fetcher for Python.
+
+`fetchxml` provides a clean, reusable way to fetch XML from web endpoints that require:
+
+* Browser-like headers
+* Session initialization
+* Cookie handling
+* Referer validation
+* Basic anti-bot protection handling
+
+It abstracts session bootstrapping and retry logic into a simple interface.
+
+---
+
+## 🚀 Why fetchxml?
+
+Some websites block simple HTTP requests and require:
+
+* A session cookie
+* Proper User-Agent
+* Referer header
+* Basic browser simulation
+
+`fetchxml` handles this automatically.
+
+Instead of writing repetitive session logic every time, you can do:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+xml = client.fetch("https://example.com/file.xml")
+
+print(xml)
+```
+
+---
+
+# 📥 Installation
+
+## Option 1 – Install from local project
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+For development mode:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Option 2 – Install from PyPI (after publishing)
+
+```bash
+pip install fetchxml
+```
+
+---
+
+# 🧠 Basic Usage
+
+## 1️⃣ Simple XML Fetch
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml[:500])
+```
+
+Use this when the target site does NOT require session bootstrap.
+
+---
+
+## 2️⃣ Fetch XML With Session Bootstrap
+
+Some sites require hitting their homepage first to establish cookies.
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml)
+```
+
+`base_url` triggers automatic session initialization.
+
+---
+
+## 3️⃣ Fetch With Custom Referer
+
+If a specific referer header is required:
+
+```python
+xml = client.fetch(
+    "https://example.com/sample.xml",
+    referer="https://example.com/dashboard"
+)
+```
+
+---
+
+# ⚙️ Configuration Options
+
+When initializing:
+
+```python
+client = FetchXML(
+    base_url="https://example.com",  # optional
+    delay=0.5,                       # delay between requests (seconds)
+    timeout=15                       # request timeout (seconds)
+)
+```
+
+### Parameters
+
+| Parameter  | Description                                   |
+| ---------- | --------------------------------------------- |
+| `base_url` | URL used to bootstrap session cookies         |
+| `delay`    | Sleep time before each request (default 0.5s) |
+| `timeout`  | Request timeout in seconds (default 15s)      |
+
+---
+
+# 🔁 Automatic Retry Behavior
+
+If a request returns **HTTP 403**, `fetchxml` will:
+
+1. Attempt to re-bootstrap session (if `base_url` provided)
+2. Retry the request once
+
+If it still fails → exception is raised.
+
+---
+
+# ❗ Exception Handling
+
+All errors raise:
+
+```python
+FetchXMLError
+```
+
+Import it like:
+
+```python
+from fetchxml import FetchXMLError
+```
+
+Example:
+
+```python
+from fetchxml import FetchXML, FetchXMLError
+
+client = FetchXML(base_url="https://example.com")
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print(xml)
+except FetchXMLError as e:
+    print("Failed to fetch XML:", str(e))
+```
+
+---
+
+# 🔍 What Triggers FetchXMLError?
+
+* Session bootstrap failure
+* Non-200 HTTP response
+* Timeout
+* Connection error
+* Persistent 403 after retry
+
+---
+
+# 🛡️ Rate Limiting
+
+`delay` ensures a pause before each request:
+
+```python
+client = FetchXML(delay=1.5)
+```
+
+Recommended for:
+
+* Bulk XML downloads
+* Respecting server load
+* Avoiding bot detection
+
+---
+
+# 📁 Example: Download and Save XML
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+url = "https://example.com/sample.xml"
+xml = client.fetch(url)
+
+with open("sample.xml", "w", encoding="utf-8") as f:
+    f.write(xml)
+
+print("Saved successfully.")
+```
+
+---
+
+# 🔧 Advanced: Reusing One Client for Multiple Files
+
+Best practice for bulk downloads:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+urls = [
+    "https://example.com/file1.xml",
+    "https://example.com/file2.xml",
+    "https://example.com/file3.xml"
+]
+
+for url in urls:
+    xml = client.fetch(url)
+    print(f"Downloaded {url}")
+```
+
+This reuses the same session and cookies.
+
+---
+
+# 🧪 Testing Connectivity
+
+You can quickly test a URL:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print("Success")
+except Exception as e:
+    print("Error:", e)
+```
+
+---
+
+# 🏗️ Project Structure
+
+```
+fetchxml/
+│
+├── fetchxml/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+---
+
+# 📜 License
+
+MIT License
+
+See `LICENSE` file for full text.
+
+---
+
+# ⚠️ Disclaimer
+
+`fetchxml` does not bypass authentication systems or CAPTCHAs.
+
+It simply mimics normal browser session behavior using:
+
+* Session cookies
+* Proper headers
+* Referer validation
+
+Users are responsible for complying with website terms of service.
+
+---
+
+# 💡 When To Use fetchxml
+
+Use it when:
+
+* A site blocks naive `requests.get()`
+* Cookies must be initialized first
+* Referer headers are required
+* You want clean, reusable XML fetching logic
+
+Do NOT use it for:
+
+* Circumventing login walls
+* Bypassing paywalls
+* Evading legal restrictions
+
+---
+
+# 🧩 Roadmap (Optional Future Enhancements)
+
+* Async version
+* Disk caching layer
+* Proxy support
+* Built-in XML validation
+* Exponential backoff strategy
+* Logging integration
+
+---
+
+# 👤 Author
+
+Saurabh Kumar Agarwal
+2026
+
+---
+

fetchxml-0.1.0/fetchxml/__init__.py

@@ -0,0 +1,4 @@
+from .client import FetchXML
+from .exceptions import FetchXMLError
+
+__all__ = ["FetchXML", "FetchXMLError"]

fetchxml-0.1.0/fetchxml/client.py

@@ -0,0 +1,70 @@
+import requests
+import time
+from .exceptions import FetchXMLError
+
+
+class FetchXML:
+    def __init__(self, base_url=None, delay=0.5, timeout=15):
+        self.base_url = base_url
+        self.delay = delay
+        self.timeout = timeout
+        self.session = requests.Session()
+        self._init_headers()
+        if base_url:
+            self._bootstrap_session()
+
+    def _init_headers(self):
+        self.session.headers.update({
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/122.0.0.0 Safari/537.36"
+            ),
+            "Accept-Language": "en-US,en;q=0.9",
+            "Connection": "keep-alive",
+        })
+
+    def _bootstrap_session(self):
+        try:
+            r = self.session.get(self.base_url, timeout=self.timeout)
+            if r.status_code != 200:
+                raise FetchXMLError(
+                    f"Failed to initialize session. Status {r.status_code}"
+                )
+        except Exception as e:
+            raise FetchXMLError(f"Session bootstrap failed: {str(e)}")
+
+    def fetch(self, url, referer=None):
+        headers = {
+            "Accept": "application/xml,text/xml,*/*;q=0.1",
+        }
+
+        if referer:
+            headers["Referer"] = referer
+        elif self.base_url:
+            headers["Referer"] = self.base_url
+
+        time.sleep(self.delay)
+
+        response = self.session.get(
+            url,
+            headers=headers,
+            timeout=self.timeout
+        )
+
+        if response.status_code == 403:
+            # Attempt session refresh once
+            if self.base_url:
+                self._bootstrap_session()
+                response = self.session.get(
+                    url,
+                    headers=headers,
+                    timeout=self.timeout
+                )
+
+        if response.status_code != 200:
+            raise FetchXMLError(
+                f"Failed to fetch XML. Status {response.status_code}"
+            )
+
+        return response.text

fetchxml-0.1.0/fetchxml/exceptions.py

@@ -0,0 +1,3 @@
+class FetchXMLError(Exception):
+    """Custom exception for fetchxml errors."""
+    pass

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

@@ -0,0 +1,356 @@
+Metadata-Version: 2.4
+Name: fetchxml
+Version: 0.1.0
+Summary: Lightweight session-based XML fetcher with browser-like behavior.
+Author: Your Name
+Project-URL: Homepage, https://github.com/yourusername/fetchxml
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+Here is a complete, production-quality **README.md** for your open-source package **fetchxml**.
+
+You can paste this directly into `README.md`.
+
+---
+
+# 📦 fetchxml
+
+Lightweight, session-based XML fetcher for Python.
+
+`fetchxml` provides a clean, reusable way to fetch XML from web endpoints that require:
+
+* Browser-like headers
+* Session initialization
+* Cookie handling
+* Referer validation
+* Basic anti-bot protection handling
+
+It abstracts session bootstrapping and retry logic into a simple interface.
+
+---
+
+## 🚀 Why fetchxml?
+
+Some websites block simple HTTP requests and require:
+
+* A session cookie
+* Proper User-Agent
+* Referer header
+* Basic browser simulation
+
+`fetchxml` handles this automatically.
+
+Instead of writing repetitive session logic every time, you can do:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+xml = client.fetch("https://example.com/file.xml")
+
+print(xml)
+```
+
+---
+
+# 📥 Installation
+
+## Option 1 – Install from local project
+
+From the project root (where `pyproject.toml` is located):
+
+```bash
+pip install .
+```
+
+For development mode:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Option 2 – Install from PyPI (after publishing)
+
+```bash
+pip install fetchxml
+```
+
+---
+
+# 🧠 Basic Usage
+
+## 1️⃣ Simple XML Fetch
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml[:500])
+```
+
+Use this when the target site does NOT require session bootstrap.
+
+---
+
+## 2️⃣ Fetch XML With Session Bootstrap
+
+Some sites require hitting their homepage first to establish cookies.
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+xml = client.fetch("https://example.com/sample.xml")
+
+print(xml)
+```
+
+`base_url` triggers automatic session initialization.
+
+---
+
+## 3️⃣ Fetch With Custom Referer
+
+If a specific referer header is required:
+
+```python
+xml = client.fetch(
+    "https://example.com/sample.xml",
+    referer="https://example.com/dashboard"
+)
+```
+
+---
+
+# ⚙️ Configuration Options
+
+When initializing:
+
+```python
+client = FetchXML(
+    base_url="https://example.com",  # optional
+    delay=0.5,                       # delay between requests (seconds)
+    timeout=15                       # request timeout (seconds)
+)
+```
+
+### Parameters
+
+| Parameter  | Description                                   |
+| ---------- | --------------------------------------------- |
+| `base_url` | URL used to bootstrap session cookies         |
+| `delay`    | Sleep time before each request (default 0.5s) |
+| `timeout`  | Request timeout in seconds (default 15s)      |
+
+---
+
+# 🔁 Automatic Retry Behavior
+
+If a request returns **HTTP 403**, `fetchxml` will:
+
+1. Attempt to re-bootstrap session (if `base_url` provided)
+2. Retry the request once
+
+If it still fails → exception is raised.
+
+---
+
+# ❗ Exception Handling
+
+All errors raise:
+
+```python
+FetchXMLError
+```
+
+Import it like:
+
+```python
+from fetchxml import FetchXMLError
+```
+
+Example:
+
+```python
+from fetchxml import FetchXML, FetchXMLError
+
+client = FetchXML(base_url="https://example.com")
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print(xml)
+except FetchXMLError as e:
+    print("Failed to fetch XML:", str(e))
+```
+
+---
+
+# 🔍 What Triggers FetchXMLError?
+
+* Session bootstrap failure
+* Non-200 HTTP response
+* Timeout
+* Connection error
+* Persistent 403 after retry
+
+---
+
+# 🛡️ Rate Limiting
+
+`delay` ensures a pause before each request:
+
+```python
+client = FetchXML(delay=1.5)
+```
+
+Recommended for:
+
+* Bulk XML downloads
+* Respecting server load
+* Avoiding bot detection
+
+---
+
+# 📁 Example: Download and Save XML
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+url = "https://example.com/sample.xml"
+xml = client.fetch(url)
+
+with open("sample.xml", "w", encoding="utf-8") as f:
+    f.write(xml)
+
+print("Saved successfully.")
+```
+
+---
+
+# 🔧 Advanced: Reusing One Client for Multiple Files
+
+Best practice for bulk downloads:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML(base_url="https://example.com")
+
+urls = [
+    "https://example.com/file1.xml",
+    "https://example.com/file2.xml",
+    "https://example.com/file3.xml"
+]
+
+for url in urls:
+    xml = client.fetch(url)
+    print(f"Downloaded {url}")
+```
+
+This reuses the same session and cookies.
+
+---
+
+# 🧪 Testing Connectivity
+
+You can quickly test a URL:
+
+```python
+from fetchxml import FetchXML
+
+client = FetchXML()
+
+try:
+    xml = client.fetch("https://example.com/sample.xml")
+    print("Success")
+except Exception as e:
+    print("Error:", e)
+```
+
+---
+
+# 🏗️ Project Structure
+
+```
+fetchxml/
+│
+├── fetchxml/
+│   ├── __init__.py
+│   ├── client.py
+│   ├── exceptions.py
+│
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+---
+
+# 📜 License
+
+MIT License
+
+See `LICENSE` file for full text.
+
+---
+
+# ⚠️ Disclaimer
+
+`fetchxml` does not bypass authentication systems or CAPTCHAs.
+
+It simply mimics normal browser session behavior using:
+
+* Session cookies
+* Proper headers
+* Referer validation
+
+Users are responsible for complying with website terms of service.
+
+---
+
+# 💡 When To Use fetchxml
+
+Use it when:
+
+* A site blocks naive `requests.get()`
+* Cookies must be initialized first
+* Referer headers are required
+* You want clean, reusable XML fetching logic
+
+Do NOT use it for:
+
+* Circumventing login walls
+* Bypassing paywalls
+* Evading legal restrictions
+
+---
+
+# 🧩 Roadmap (Optional Future Enhancements)
+
+* Async version
+* Disk caching layer
+* Proxy support
+* Built-in XML validation
+* Exponential backoff strategy
+* Logging integration
+
+---
+
+# 👤 Author
+
+Saurabh Kumar Agarwal
+2026
+
+---
+

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+fetchxml/__init__.py
+fetchxml/client.py
+fetchxml/exceptions.py
+fetchxml.egg-info/PKG-INFO
+fetchxml.egg-info/SOURCES.txt
+fetchxml.egg-info/dependency_links.txt
+fetchxml.egg-info/requires.txt
+fetchxml.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+requests

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

@@ -0,0 +1 @@
+fetchxml

fetchxml-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fetchxml"
+version = "0.1.0"
+description = "Lightweight session-based XML fetcher with browser-like behavior."
+authors = [
+    { name="Your Name" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "requests"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/yourusername/fetchxml"

fetchxml-0.1.0/setup.cfg

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