qubesync 0.1.0__py3-none-any.whl

qubesync/__init__.py

@@ -0,0 +1,58 @@
+"""
+QubeSync - Python library for QuickBooks integration via QubeSync API
+
+This package provides:
+- QubeSync: Main API client for interacting with QubeSync service
+- RequestBuilder: DSL for building QuickBooks XML requests
+- Exception classes for error handling
+
+Usage:
+    from qubesync import QubeSync, RequestBuilder
+    
+    # API operations
+    connection = QubeSync.create_connection(options)
+    
+    # Request building
+    request = RequestBuilder(version="16.0")
+    with request as r:
+        with r.QBXML() as qbxml:
+            # ... build request
+"""
+
+# Import main classes for convenient access
+from .client import (
+    QubeSync,
+    QubeSyncError,
+    StaleWebhookError, 
+    InvalidWebhookSignatureError,
+    ConfigError
+)
+
+from .request_builder import (
+    RequestBuilder,
+    RequestElement,
+    FluentRequestBuilder
+)
+
+# Version info
+__version__ = "0.1.0"
+
+# Public API
+__all__ = [
+    # Main API client
+    "QubeSync",
+    
+    # Request builders
+    "RequestBuilder", 
+    "RequestElement",
+    "FluentRequestBuilder",
+    
+    # Exceptions
+    "QubeSyncError",
+    "StaleWebhookError",
+    "InvalidWebhookSignatureError", 
+    "ConfigError",
+    
+    # Version
+    "__version__"
+]

qubesync/client.py

@@ -0,0 +1,134 @@
+import os
+import json
+import requests
+import hmac
+import hashlib
+import time
+
+class QubeSyncError(Exception): pass
+class StaleWebhookError(QubeSyncError): pass
+class InvalidWebhookSignatureError(QubeSyncError): pass
+class ConfigError(QubeSyncError): pass
+
+class QubeSync:
+    EXPECTED_SIGNATURE_SCHEMES = ["v1"]
+
+    def base_url():
+        return os.getenv("QUBE_URL", "https://qubesync.com/api/v1")
+
+    def default_headers():
+        return {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    def api_key():
+        try:
+            return os.environ["QUBE_API_KEY"]
+        except KeyError:
+            raise ConfigError("QUBE_API_KEY not set in environment.")
+
+    def api_secret():
+        try:
+            return os.environ["QUBE_WEBHOOK_SECRET"]
+        except KeyError:
+            raise ConfigError("QUBE_WEBHOOK_SECRET not set in environment.")
+
+    def connection():
+        session = requests.Session()
+        session.auth = (QubeSync.api_key(), "")
+        return session
+
+    def get(url, headers={}):
+        resp = QubeSync.connection().get(f"{QubeSync.base_url()}/{url}", headers={**QubeSync.default_headers(), **headers})
+        if resp.status_code >= 200 and resp.status_code < 300:
+            return resp.json()
+        raise QubeSyncError(f"Unexpected response: {resp.status_code}\n{resp.text}")
+
+    def post(url, body=None, headers={}):
+        resp = QubeSync.connection().post(f"{QubeSync.base_url()}/{url}", headers={**QubeSync.default_headers(), **headers}, json=body)
+        if resp.status_code >= 200 and resp.status_code < 300:
+            return resp.json()
+        raise QubeSyncError(f"Unexpected response: {resp.status_code}\n{resp.text}")
+
+    def delete(url, headers={}):
+        resp = QubeSync.connection().delete(f"{QubeSync.base_url()}/{url}", headers={**QubeSync.default_headers(), **headers})
+        if resp.status_code >= 200 and resp.status_code < 300:
+            return True
+        raise QubeSyncError(f"Unexpected response: {resp.status_code}\n{resp.text}")
+
+    def create_connection(options={}):
+        resp = QubeSync.post("connections", body=options)
+        conn = resp.get("data", {})
+        if not conn.get("id"):
+            raise QubeSyncError(f"Could not create connection: {resp}")
+        return conn
+
+    def delete_connection(id):
+        return QubeSync.delete(f"connections/{id}")
+
+    def get_connection(id):
+        return QubeSync.get(f"connections/{id}").get("data")
+
+    def queue_request(connection_id, request):
+        if not (request.get("request_xml") or request.get("request_json")):
+            raise ValueError("must have either request_xml or request_json")
+        if not request.get("webhook_url"):
+            print("Warning: no webhook_url provided")
+        return QubeSync.post(f"connections/{connection_id}/queued_requests", {"queued_request": request}).get("data")
+
+    def get_request(id):
+        return QubeSync.get(f"queued_requests/{id}").get("data")
+
+    def get_requests(connection_id):
+        return QubeSync.get(f"connections/{connection_id}/queued_requests").get("data")
+
+    def delete_request(id):
+        return QubeSync.delete(f"queued_requests/{id}")
+
+    def get_qwc(connection_id):
+        return QubeSync.post(f"connections/{connection_id}/qwc").get("qwc")
+
+    def generate_password(connection_id):
+        resp = QubeSync.post(f"connections/{connection_id}/password")
+        password = resp.get("data", {}).get("password")
+        if not password:
+            raise QubeSyncError(f"Password not found: {resp}")
+        return password
+
+    def extract_signature_meta(header, expected_schemes=["v1"]):
+        # Example header: t=timestamp,v1=signature1,v1=signature2
+        # note: signatures may include '=' characters
+        parts = header.split(',')
+        timestamp = None
+        signatures = []
+        for part in parts:
+            k, v = part.split('=', 1)
+            if k == 't':
+                timestamp = int(v)
+            elif k in expected_schemes:
+                signatures.append(v)
+        if timestamp is None or not signatures:
+            raise InvalidWebhookSignatureError("Invalid signature header format.")
+        return timestamp, signatures
+
+    def sign_payload(payload):
+        return hmac.new(
+            QubeSync.api_secret().encode("utf-8"), 
+            payload.encode("utf-8"), 
+            hashlib.sha256
+        ).hexdigest()
+
+    def verify_and_build_webhook(body, signature, max_age=500):
+        timestamp, signatures = QubeSync.extract_signature_meta(signature, QubeSync.EXPECTED_SIGNATURE_SCHEMES)
+
+        # print for debugging
+        print(f"Timestamp: {timestamp}, Signatures: {signatures}")
+        if timestamp < time.time() - max_age:
+            raise StaleWebhookError(f"Timestamp more than {max_age} seconds old.")
+        
+        signed_payload = QubeSync.sign_payload(str(timestamp) + '.' + body)
+        if any(hmac.compare_digest(signed_payload, sig) for sig in signatures):
+            return json.loads(body)
+        
+        raise InvalidWebhookSignatureError("Webhook signature mismatch")

qubesync/request_builder.py

@@ -0,0 +1,194 @@
+"""
+RequestBuilder - A Python DSL for building QuickBooks XML requests
+
+This module provides a fluent interface for constructing QBXML requests
+in a JSON format for API consumption. QuBeSync API will clean the data of any special 
+characters that cause QuickBooks errors and then convert this JSON back into 
+QBXML when sending requests to QuickBooks.
+
+Example usage:
+    from qubesync import RequestBuilder
+    
+    request = RequestBuilder(version="16.0") 
+    with request as r:
+        with r.QBXML() as qbxml:
+            with qbxml.QBXMLMsgsRq(onError='stopOnError') as msgs:
+                with msgs.CustomerQueryRq(requestID='asdf1234', iterator='Start') as query:
+                    query.MaxReturned(20)
+                    query.IncludeRetElement('ListID')
+                    query.IncludeRetElement('Name')
+                    query.IncludeRetElement('FullName')
+                    query.IncludeRetElement('IsActive')
+    
+    json_data = request.as_json()
+"""
+
+
+class RequestElement:
+    """Represents a single element in the request structure."""
+    
+    def __init__(self, name, attributes=None, text=None, parent=None):
+        self.name = name
+        self.attributes = attributes or {}
+        self.text = text
+        self.children = []
+        self.parent = parent
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+    
+    def __getattr__(self, name):
+        """Create a new child element with the given name."""
+        def element_creator(*args, **kwargs):
+            # Handle text content as first positional argument
+            text = args[0] if args else None
+            
+            # Convert kwargs to attributes, handling Python reserved words
+            attributes = {}
+            for key, value in kwargs.items():
+                # Convert snake_case to camelCase if needed, but preserve exact case for QB fields
+                if key.endswith('_'):
+                    key = key[:-1]  # Remove trailing underscore for reserved words
+                attributes[key] = value
+            
+            child = RequestElement(name, attributes, text, self)
+            self.children.append(child)
+            return child
+        
+        return element_creator
+    
+    def as_dict(self):
+        """Convert this element to a dictionary representation."""
+        result = {"name": self.name}
+        
+        if self.attributes:
+            result["attributes"] = self.attributes
+        
+        if self.text is not None:
+            result["text"] = self.text
+        
+        if self.children:
+            result["children"] = [child.as_dict() for child in self.children]
+        
+        return result
+
+
+class RequestBuilder:
+    """A fluent interface for building QuickBooks XML requests."""
+    
+    def __init__(self, version="16.0"):
+        self.version = version
+        self.root_elements = []
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+    
+    def __getattr__(self, name):
+        """Create a new root element with the given name."""
+        def element_creator(*args, **kwargs):
+            # Handle text content as first positional argument
+            text = args[0] if args else None
+            
+            # Convert kwargs to attributes
+            attributes = {}
+            for key, value in kwargs.items():
+                # Handle Python reserved words by removing trailing underscore
+                if key.endswith('_'):
+                    key = key[:-1]
+                attributes[key] = value
+            
+            element = RequestElement(name, attributes, text)
+            self.root_elements.append(element)
+            return element
+        
+        return element_creator
+    
+    def as_json(self):
+        """Convert the request to JSON format."""
+        return {
+            "version": self.version,
+            "request": [element.as_dict() for element in self.root_elements]
+        }
+    
+    def as_dict(self):
+        """Alias for as_json() for consistency."""
+        return self.as_json()
+
+
+class FluentRequestBuilder(RequestBuilder):
+    """
+    Alternative builder with method chaining support for a more Ruby-like feel.
+    
+    Example:
+        request = FluentRequestBuilder(version="16.0")
+        request.QBXML().QBXMLMsgsRq(onError='stopOnError').CustomerQueryRq(
+            requestID='asdf1234', iterator='Start'
+        ).add_children([
+            ('MaxReturned', 20),
+            ('IncludeRetElement', 'ListID'),
+            ('IncludeRetElement', 'Name'),
+            ('IncludeRetElement', 'FullName'),
+            ('IncludeRetElement', 'IsActive')
+        ])
+    """
+    
+    def __init__(self, version="16.0"):
+        super().__init__(version)
+        self._current_element = None
+    
+    def __getattr__(self, name):
+        """Create a new element and return self for chaining."""
+        def element_creator(*args, **kwargs):
+            text = args[0] if args else None
+            attributes = {k.rstrip('_'): v for k, v in kwargs.items()}
+            
+            if self._current_element is None:
+                # Creating root element
+                element = RequestElement(name, attributes, text)
+                self.root_elements.append(element)
+                self._current_element = element
+            else:
+                # Creating child element
+                element = RequestElement(name, attributes, text, self._current_element)
+                self._current_element.children.append(element)
+                self._current_element = element
+            
+            return self
+        
+        return element_creator
+    
+    def add_children(self, children_data):
+        """Add multiple children to the current element."""
+        if self._current_element is None:
+            raise ValueError("No current element to add children to")
+        
+        for child_data in children_data:
+            if isinstance(child_data, tuple) and len(child_data) == 2:
+                name, text = child_data
+                child = RequestElement(name, text=text, parent=self._current_element)
+                self._current_element.children.append(child)
+            elif isinstance(child_data, dict):
+                name = child_data.get('name')
+                attributes = child_data.get('attributes', {})
+                text = child_data.get('text')
+                child = RequestElement(name, attributes, text, self._current_element)
+                self._current_element.children.append(child)
+        
+        return self
+    
+    def parent(self):
+        """Move back to the parent element for continued chaining."""
+        if self._current_element and self._current_element.parent:
+            self._current_element = self._current_element.parent
+        return self
+    
+    def root(self):
+        """Return to the root level."""
+        self._current_element = None
+        return self

qubesync-0.1.0.dist-info/METADATA

@@ -0,0 +1,388 @@
+Metadata-Version: 2.4
+Name: qubesync
+Version: 0.1.0
+Summary: A Python library for QuickBooks Desktop / Enterprise integration via QubeSync API with intuitive DSL for building QBXML requests.
+Author-email: QubeSync <support@qubesync.com>
+License: MIT
+Project-URL: Homepage, https://github.com/qubeintegrations/qube_sync_py
+Project-URL: Documentation, https://docs.qubesync.com
+Project-URL: Repository, https://github.com/qubeintegrations/qube_sync_py
+Project-URL: Issues, https://github.com/qubeintegrations/qube_sync_py/issues
+Keywords: quickbooks,qbxml,accounting,integration,api,dsl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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 :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: license-file
+
+# QubeSync Python Library
+
+A Python library for seamless QuickBooks integration via the QubeSync API. This library provides both a robust API client for QubeSync operations and a powerful DSL (Domain Specific Language) for building QuickBooks XML requests.
+
+## Features
+
+- 🔌 **Complete QubeSync API client** - Connect, queue requests, handle webhooks
+- 🏗️ **Intuitive Request Builder DSL** - Build QBXML requests with Python syntax
+- 🔒 **Webhook security** - Built-in signature verification for webhooks
+- 🚀 **Multiple syntax styles** - Context managers, fluent chaining, or Ruby-like syntax
+- ✅ **Fully tested** - comprehensive tests ensuring reliability
+- 📦 **Clean imports** - Simple `from qubesync import ...` syntax
+
+## Installation
+
+```bash
+pip install qubesync
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/qubeintegrations/qube_sync_py
+cd qube_sync_py
+pip install -e .
+```
+
+## Quick Start
+
+### Environment Setup
+
+Set your QubeSync credentials:
+
+```bash
+export QUBE_API_KEY="your_api_key_here"
+export QUBE_WEBHOOK_SECRET="your_webhook_secret_here"
+export QUBE_URL="https://qubesync.com/api/v1"  # Optional, defaults to this
+```
+
+### Basic Usage
+
+```python
+from qubesync import QubeSync, RequestBuilder
+
+# 1. Create a connection
+connection = QubeSync.create_connection({
+    "name": "My Customer Inc.", # optional (will populate from QuickBooks on first sync if blank)
+    "redirect_url": "https://your-app.com/qbd-setup/callback"
+})
+
+# 2. Build a request using the DSL
+request = RequestBuilder(version="16.0")
+with request as r:
+    with r.QBXML() as qbxml:
+        with qbxml.QBXMLMsgsRq(onError='stopOnError') as msgs:
+            with msgs.CustomerQueryRq(requestID='customer_123', iterator='Start') as query:
+                query.MaxReturned(50)
+                query.IncludeRetElement('ListID')
+                query.IncludeRetElement('Name')
+                query.IncludeRetElement('Email')
+
+# 3. Queue the request
+response = QubeSync.queue_request(connection['id'], {
+    'request_json': request.as_json(),
+    'webhook_url': 'https://your-app.com/webhooks/qb_response'
+})
+
+print(f"Request queued with ID: {response['id']}")
+```
+
+## API Client Reference
+
+### Connection Management
+
+```python
+from qubesync import QubeSync
+
+# Create a new connection
+connection = QubeSync.create_connection({
+    "name": "My Customer Inc.", # optional (will populate from QuickBooks on first sync if blank)
+    "redirect_url": "https://your-app.com/qbd-setup/callback"
+})
+
+# Get connection details
+connection = QubeSync.get_connection(connection_id)
+
+# Delete a connection
+QubeSync.delete_connection(connection_id)
+
+# Generate QWC file for QuickBooks
+qwc_content = QubeSync.get_qwc(connection_id)
+
+# Generate password for QuickBooks connection
+password = QubeSync.generate_password(connection_id)
+```
+
+### Request Management
+
+```python
+# Queue a request
+request_data = {
+    'request_json': {...},  # Built using RequestBuilder
+    'webhook_url': 'https://your-app.com/webhook'
+}
+response = QubeSync.queue_request(connection_id, request_data)
+
+# Get request status
+request = QubeSync.get_request(request_id)
+
+# Get all requests for a connection
+requests = QubeSync.get_requests(connection_id)
+
+# Delete a request
+QubeSync.delete_request(request_id)
+```
+
+### Webhook Handling
+
+```python
+# Verify and parse webhook payload
+def handle_webhook(request):
+    signature = request.headers.get('X-Qube-Signature')
+    body = request.body.decode('utf-8')
+    
+    try:
+        webhook_data = QubeSync.verify_and_build_webhook(body, signature)
+        # Process the verified webhook data in the background
+        # to ensure a quick response
+        print(f"Received response for request: {webhook_data['request_id']}")
+        return {"status": "success"}
+    except (StaleWebhookError, InvalidWebhookSignatureError) as e:
+        print(f"Webhook verification failed: {e}")
+        return {"status": "error"}, 400
+```
+
+## RequestBuilder DSL
+
+The RequestBuilder provides an intuitive Python DSL for constructing QBXML requests that get converted to JSON format for the QubeSync API.
+
+### Context Manager Style (Recommended)
+
+```python
+from qubesync import RequestBuilder
+
+request = RequestBuilder(version="16.0")
+with request as r:
+    with r.QBXML() as qbxml:
+        with qbxml.QBXMLMsgsRq(onError='stopOnError') as msgs:
+            with msgs.InvoiceQueryRq(requestID='inv_query_123') as query:
+                query.MaxReturned(25)
+                query.IncludeRetElement('TxnID')
+                query.IncludeRetElement('TxnNumber')
+                query.IncludeRetElement('CustomerRef')
+                query.IncludeRetElement('TxnDate')
+                query.IncludeRetElement('DueDate')
+                query.IncludeRetElement('BalanceRemaining')
+
+json_data = request.as_json()
+```
+
+### Fluent Chaining Style
+
+```python
+from qubesync import FluentRequestBuilder
+
+request = FluentRequestBuilder(version="16.0")
+request.QBXML().QBXMLMsgsRq(onError='stopOnError').ItemQueryRq(
+    requestID='item_query_456'
+).add_children([
+    ('MaxReturned', 100),
+    ('IncludeRetElement', 'ListID'),
+    ('IncludeRetElement', 'Name'),
+    ('IncludeRetElement', 'Type'),
+    ('IncludeRetElement', 'SalePrice')
+])
+
+json_data = request.as_json()
+```
+
+### Ruby-like Style
+
+```python
+from qubesync import RequestBuilder
+
+request = RequestBuilder(version="16.0")
+qbxml = request.QBXML()
+msgs = qbxml.QBXMLMsgsRq(onError='stopOnError')
+query = msgs.CustomerQueryRq(requestID='customer_789', iterator='Start')
+query.MaxReturned(30)
+query.IncludeRetElement('ListID')
+query.IncludeRetElement('Name')
+query.IncludeRetElement('CompanyName')
+
+json_data = request.as_json()
+```
+
+### Handling Python Reserved Words
+
+Use trailing underscores for Python reserved words:
+
+```python
+request = RequestBuilder(version="16.0")
+with request as r:
+    with r.QBXML() as qbxml:
+        with qbxml.QBXMLMsgsRq(onError='stopOnError') as msgs:
+            # Use trailing underscore for 'class', 'for', 'if', etc.
+            with msgs.CustomQueryRq(class_='invoice', for_='reports') as query:
+                query.MaxReturned(100)
+```
+
+### Complex Nested Structures
+
+```python
+request = RequestBuilder(version="16.0")
+with request as r:
+    with r.QBXML() as qbxml:
+        with qbxml.QBXMLMsgsRq(onError='stopOnError') as msgs:
+            with msgs.InvoiceAddRq(requestID='invoice_add_999') as add_req:
+                with add_req.InvoiceAdd() as invoice:
+                    with invoice.CustomerRef() as customer_ref:
+                        customer_ref.ListID('80000001-1234567890')
+                    
+                    invoice.TxnDate('2024-01-15')
+                    invoice.RefNumber('INV-2024-001')
+                    
+                    with invoice.InvoiceLineAdd() as line:
+                        with line.ItemRef() as item_ref:
+                            item_ref.ListID('80000002-1234567890')
+                        line.Desc('Professional Services')
+                        line.Quantity(10)
+                        line.Rate(150.00)
+```
+
+## Example Output
+
+The RequestBuilder generates clean JSON that the QubeSync API processes:
+
+```json
+{
+  "version": "16.0",
+  "request": [
+    {
+      "name": "QBXML",
+      "children": [
+        {
+          "name": "QBXMLMsgsRq",
+          "attributes": {"onError": "stopOnError"},
+          "children": [
+            {
+              "name": "CustomerQueryRq",
+              "attributes": {"requestID": "customer_123", "iterator": "Start"},
+              "children": [
+                {"name": "MaxReturned", "text": 50},
+                {"name": "IncludeRetElement", "text": "ListID"},
+                {"name": "IncludeRetElement", "text": "Name"},
+                {"name": "IncludeRetElement", "text": "Email"}
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Error Handling
+
+```python
+from qubesync import (
+    QubeSync, 
+    QubeSyncError, 
+    ConfigError, 
+    StaleWebhookError, 
+    InvalidWebhookSignatureError
+)
+
+try:
+    connection = QubeSync.create_connection({"name": "Test"})
+except ConfigError as e:
+    print(f"Configuration error: {e}")
+except QubeSyncError as e:
+    print(f"API error: {e}")
+
+# Webhook verification
+try:
+    webhook_data = QubeSync.verify_and_build_webhook(body, signature)
+except StaleWebhookError:
+    print("Webhook is too old")
+except InvalidWebhookSignatureError:
+    print("Invalid webhook signature")
+```
+
+## Available Classes
+
+### API Client
+- `QubeSync` - Main API client for all QubeSync operations
+- `QubeSyncError` - Base exception class
+- `ConfigError` - Configuration/environment variable errors
+- `StaleWebhookError` - Webhook timestamp too old
+- `InvalidWebhookSignatureError` - Webhook signature verification failed
+
+### Request Building
+- `RequestBuilder` - Context manager style DSL (recommended)
+- `FluentRequestBuilder` - Method chaining style DSL
+- `RequestElement` - Individual request element (advanced usage)
+
+## Development
+
+### Running Tests
+
+```bash
+# Run all tests
+python run_tests.py
+
+# Run with verbose output
+python run_tests.py --verbose
+
+# Run specific test file
+python run_tests.py tests/test_request_builder.py
+```
+
+### Running Examples
+
+```bash
+# Run all examples
+python examples.py
+
+# Use virtual environment
+./bin/python examples.py
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Run tests (`python run_tests.py`)
+5. Commit your changes (`git commit -m 'Add amazing feature'`)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+- 📧 Email: support@qubesync.com
+- 📖 Documentation: [QubeSync Docs](https://docs.qubesync.com)
+- 🐛 Issues: [GitHub Issues](https://github.com/qubeintegrations/qube_sync_py/issues)
+
+## Changelog
+
+### v0.1.0
+- Initial release
+- Complete QubeSync API client
+- RequestBuilder DSL with multiple syntax styles
+- Comprehensive test suite
+- Webhook security verification
+- Clean module structure with intuitive imports

qubesync-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+qubesync/__init__.py,sha256=lTF0dXZlrvBB0swsDQRZGP5NWpsf_x1rznlM2a_3W6Q,1205
+qubesync/client.py,sha256=mBZJZ9mO7rVdJVNJkoWZ4ktGKagR4VT1LfIOCVcUbBY,5128
+qubesync/request_builder.py,sha256=ONxD2KQ7EWinnajE5fyy0JP_PDtF-rJmtjjic-MnHO4,6987
+qubesync-0.1.0.dist-info/licenses/LICENSE,sha256=8JPn8nIUYBRz5p6R6QACgOXQHYRYRYctC2kV7hzS5jQ,1065
+qubesync-0.1.0.dist-info/METADATA,sha256=O_P5ZQcwJT_6scCBSCcezHJnbW4uX4FlmEeN25QxGA4,11412
+qubesync-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qubesync-0.1.0.dist-info/top_level.txt,sha256=9iCcZOQbm8qaIUhIqiPo7G9hYVJCP6M2H50Rtie_8Vo,9
+qubesync-0.1.0.dist-info/RECORD,,

qubesync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qubesync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 QubeSync
+
+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.

qubesync-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qubesync