magicfeedback 1.0.19__py3-none-any.whl

deepdots_sdk/__init__.py

@@ -0,0 +1,12 @@
+"""Deepdots Python SDK.
+
+``Deepdots`` is the current name of the company formerly called MagicFeedback.
+This package is the forward-looking import name; the implementation still lives
+in :mod:`magicfeedback_sdk` and is re-exported here module by module, so both
+import paths expose the very same objects. Existing code importing
+``magicfeedback_sdk`` keeps working unchanged.
+"""
+
+from magicfeedback_sdk.client import Deepdots, MagicFeedback
+
+__all__ = ["Deepdots", "MagicFeedback"]

deepdots_sdk/api/campaigns.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.campaigns` under the Deepdots name."""
+
+from magicfeedback_sdk.api.campaigns import CampaignsAPI
+
+__all__ = ['CampaignsAPI']

deepdots_sdk/api/companies.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.companies` under the Deepdots name."""
+
+from magicfeedback_sdk.api.companies import CompaniesAPI
+
+__all__ = ['CompaniesAPI']

deepdots_sdk/api/contacts.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.contacts` under the Deepdots name."""
+
+from magicfeedback_sdk.api.contacts import ContactsAPI
+
+__all__ = ['ContactsAPI']

deepdots_sdk/api/feedback.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.feedback` under the Deepdots name."""
+
+from magicfeedback_sdk.api.feedback import FeedbackAPI
+
+__all__ = ['FeedbackAPI']

deepdots_sdk/api/integrations_questions.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.integrations_questions` under the Deepdots name."""
+
+from magicfeedback_sdk.api.integrations_questions import IntegrationsQuestionsAPI
+
+__all__ = ['IntegrationsQuestionsAPI']

deepdots_sdk/api/metrics.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.metrics` under the Deepdots name."""
+
+from magicfeedback_sdk.api.metrics import MetricsAPI
+
+__all__ = ['MetricsAPI']

deepdots_sdk/api/products.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.products` under the Deepdots name."""
+
+from magicfeedback_sdk.api.products import ProductsAPI
+
+__all__ = ['ProductsAPI']

deepdots_sdk/api/reports.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.reports` under the Deepdots name."""
+
+from magicfeedback_sdk.api.reports import ReportsAPI
+
+__all__ = ['ReportsAPI']

deepdots_sdk/api/requests.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.requests` under the Deepdots name."""
+
+from magicfeedback_sdk.api.requests import build_done_message, RequestsAPI
+
+__all__ = ['build_done_message', 'RequestsAPI']

deepdots_sdk/api/signals.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.api.signals` under the Deepdots name."""
+
+from magicfeedback_sdk.api.signals import SignalsAPI
+
+__all__ = ['SignalsAPI']

deepdots_sdk/auth.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.auth` under the Deepdots name."""
+
+from magicfeedback_sdk.auth import AuthManager
+
+__all__ = ["AuthManager"]

deepdots_sdk/client.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.client` under the Deepdots name."""
+
+from magicfeedback_sdk.client import Deepdots, MagicFeedback
+
+__all__ = ["Deepdots", "MagicFeedback"]

deepdots_sdk/logging_config.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.logging_config` under the Deepdots name."""
+
+from magicfeedback_sdk.logging_config import configure_logger
+
+__all__ = ["configure_logger"]

deepdots_sdk/utils/request.py

@@ -0,0 +1,5 @@
+"""Re-export of :mod:`magicfeedback_sdk.utils.request` under the Deepdots name."""
+
+from magicfeedback_sdk.utils.request import make_request
+
+__all__ = ["make_request"]

magicfeedback-1.0.19.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: magicfeedback
+Version: 1.0.19
+Summary: SDK for the Deepdots API (formerly MagicFeedback)
+Home-page: https://github.com/MagicFeedback/magicfeedback_python_sdk
+Author: Francisco Arias
+Author-email: Francisco Arias <farias@magicfeedback.io>
+Project-URL: Homepage, https://github.com/MagicFeedback/magicfeedback_python_sdk
+Project-URL: Issues, https://github.com/MagicFeedback/magicfeedback_python_sdk/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: requests>=2.0.0
+Requires-Dist: google-cloud-pubsub>=2.0.0
+Requires-Dist: google-cloud-datastore>=2.16.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Deepdots Python SDK
+
+Python SDK for the Deepdots API (the company was formerly called MagicFeedback).
+
+## Installation
+
+```bash
+pip install deepdots
+```
+
+The original distribution is still published and still works:
+
+```bash
+pip install magicfeedback
+```
+
+## Naming
+
+MagicFeedback was renamed **Deepdots**. Both sets of names work and refer to the
+*same* objects, so **no existing code needs to change**:
+
+| | Current name | Original name |
+|---|---|---|
+| PyPI distribution | `deepdots` | `magicfeedback` |
+| Import package | `deepdots_sdk` | `magicfeedback_sdk` |
+| Client class | `Deepdots` | `MagicFeedback` |
+
+Distribution names are written lowercase throughout — that is the packaging
+convention, and PyPI treats names case-insensitively anyway, so
+`pip install MagicFeedback` keeps working for anyone who has it written that way.
+
+`deepdots_sdk` re-exports `magicfeedback_sdk` module by module, and `Deepdots`
+is the same class object as `MagicFeedback` — `MagicFeedback is Deepdots` is
+`True`, so `isinstance()` checks and subclasses behave identically. Submodule
+imports work under either name (`from deepdots_sdk.api.feedback import
+FeedbackAPI`). New code should prefer the Deepdots names.
+
+## Usage
+
+```python
+from deepdots_sdk import Deepdots
+
+client = Deepdots("email", "password")
+```
+
+The original names remain fully supported:
+
+```python
+from magicfeedback_sdk import MagicFeedback
+
+client = MagicFeedback("email", "password")
+```
+
+## Authentication
+
+The bearer token is resolved from one of two sources, selected with
+`auth_source`:
+
+- `"datastore"` **(default)** — read the token cached in Google Cloud Datastore
+  by the `update-token` job (kind `token-storage`, email
+  `robot@magicfeedback.io`, database `shared`). This avoids an Identity Platform
+  login on every use. If the cached token is missing, stale (older than
+  `token_max_age_min`, default 50 min) or Datastore is unreachable, the client
+  falls back to Identity Platform using `email`/`password`.
+- `"identity"` — always log in via Identity Platform (`signInWithPassword`), the
+  original behaviour, with no Datastore lookup.
+
+```python
+# Datastore-cached token (default), with Identity Platform fallback.
+# email/password are only needed for the fallback.
+client = MagicFeedback("email", "password")
+
+# Tune the Datastore lookup (all optional; shown with their defaults):
+client = MagicFeedback(
+    "email", "password",
+    auth_source="datastore",
+    gcp_project_id=None,             # None => inferred from Application Default Credentials
+    datastore_database_id="shared",
+    token_kind="token-storage",
+    token_email="robot@magicfeedback.io",
+    token_max_age_min=50,
+    datastore_timeout_s=5.0,         # cap the lookup so the fallback stays fast
+)
+
+# Original behaviour — always mint a fresh token via Identity Platform:
+client = MagicFeedback("email", "password", auth_source="identity")
+```
+
+The Datastore lookup is bounded by `datastore_timeout_s` (default 5s): if the
+cache is unreachable or the credentials are stale, the client falls back to
+Identity Platform within that budget instead of blocking on the Datastore
+client's default ~60s retry deadline.
+
+The Datastore path needs the `google-cloud-datastore` package (installed as a
+dependency) and Google Application Default Credentials with read access to the
+token entity (`gcloud auth application-default login` or
+`GOOGLE_APPLICATION_CREDENTIALS`).
+
+Helper methods:
+
+- `client.refresh_token()` — re-resolve the token (same `auth_source`) and
+  update the auth header in place across all sub-API clients. Useful for
+  long-lived clients whose token has expired.
+- `client.auth.get_token_from_datastore(allow_stale=False)` — read the cached
+  token directly; returns `None` when missing, stale or unreachable.
+
+## API Reference
+
+### `client.feedbacks`
+- `create(feedback)` — creates a new feedback item. Required fields: `name`, `type`, `identity`, `integrationId`, `companyId`, `productId`.
+- `get(filter=None)` — lists feedback items.
+- `get_id(feedback_id, filter=None)` — retrieves a specific feedback item.
+- `update(feedback_id, feedback)` — updates a feedback item.
+- `delete(feedback_id)` — deletes a feedback item.
+- `upload_attachment(feedback_id, file_path, filename=None, extra_data=None)` — uploads a file and attaches it to a feedback.
+
+### `client.contacts`
+- `create(contact)`, `get(filter=None)`, `update(contact_id, contact)`, `delete(contact_id)`
+
+### `client.campaigns`
+- `create(campaign)`, `get(filter=None)`
+- `create_session(campaign_id, session)`, `get_sessions(campaign_id, filter=None)`, `get_sessions_feedbacks(campaign_id, filter=None)`
+
+### `client.metrics`
+- `get(filter=None)`
+
+### `client.products`
+- `get(filter=None)`
+
+### `client.companies`
+- `get(filter=None)`, `get_id(id, filter=None)`
+
+### `client.integrations_questions`
+- `get(integration_id, filter=None)`
+
+### `client.reports`
+- `get(filter=None)`, `get_newsletter(filter=None)`, `update(report_id, report)`
+
+### `client.requests`
+- `get(filter=None)`, `get_id(request_id, filter=None)`, `update(request_id, request)`
+
+To mark a request DONE/ERROR asynchronously, publish a completion event to the
+`request-done` Pub/Sub topic (project `magicfeedback-prod-api`, topic
+`request-done`); the `request-done` Cloud Function consumes it and PATCHes the
+request. The SDK does not publish this itself — build the envelope with
+`build_done_message` and publish it directly. See
+[`examples/mark_request_done.py`](examples/mark_request_done.py).
+
+## Examples
+
+```python
+# Create a feedback
+client.feedbacks.create({
+    "name": "Test Feedback",
+    "type": "APP",
+    "identity": "MAGICFORM",
+    "integrationId": "your-integration-id",
+    "companyId": "YOUR_COMPANY",
+    "productId": "YOUR_PRODUCT",
+    "answers": [
+        {"key": "score", "value": "4"},
+        {"key": "comment", "value": "Great service!"},
+    ],
+})
+
+# Get a feedback with its attachments
+client.feedbacks.get_id(
+    "<feedback_id>",
+    filter={"include": [{"relation": "feedbackAttachments"}]}
+)
+
+# Upload a file attachment
+client.feedbacks.upload_attachment(
+    "<feedback_id>",
+    file_path="/path/to/file.pdf",
+    filename="report.pdf",          # optional, defaults to file name
+    extra_data={"source": "crm"}    # optional, any JSON-serialisable dict
+)
+
+# Mark a request DONE via the request-done Pub/Sub topic.
+# The SDK builds the envelope; the producer publishes it directly.
+import json
+from google.cloud import pubsub_v1
+from magicfeedback_sdk.api.requests import build_done_message
+
+message = build_done_message(
+    "<request_id>",
+    "<company_id>",
+    output={"value": "…final result…"},
+    sources=["<feedbackId1>", "<feedbackId2>"],  # optional
+    logs="processed 2 items",                     # optional
+    # success=False, error={"message": "processing failed"}  # to mark ERROR
+)
+
+publisher = pubsub_v1.PublisherClient()
+topic_path = publisher.topic_path("magicfeedback-prod-api", "request-done")
+publisher.publish(topic_path, json.dumps(message).encode("utf-8")).result()
+```
+
+## Logging
+
+```python
+import logging
+client.set_logging(logging.DEBUG)
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Developing on the SDK itself — layout, tests, and how to cut a release — is
+documented in [DEVELOPERS.md](DEVELOPERS.md).
+
+## Contact
+
+farias@magicfeedback.io

magicfeedback-1.0.19.dist-info/RECORD

@@ -0,0 +1,39 @@
+deepdots_sdk/__init__.py,sha256=tn3qquTPVC0n5-J6r3ee8q9klVBZ-XeHT2jUPfjscG0,483
+deepdots_sdk/auth.py,sha256=yv-BD9DaoZvLH5qMXvvJaCW2I0BW6iCnQ1Wvff6qfu4,149
+deepdots_sdk/client.py,sha256=3kH_dehZq6ny_7ugqQ7_KXUZCm1SQgsQtgINXoywwd4,179
+deepdots_sdk/logging_config.py,sha256=vXdTKmZLAHKp-4MxB68QrA0elWzA9RG3oV1_Z5aO1yM,179
+deepdots_sdk/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepdots_sdk/api/campaigns.py,sha256=JnCv4y-uN_T1aFOwdz9LUxGmQ47jVYPVz1DJwFX4KJo,169
+deepdots_sdk/api/companies.py,sha256=RB1_mvpFfG7F4CXsDcewYsL8-4BDz9DqVNvjy2yrlCM,169
+deepdots_sdk/api/contacts.py,sha256=qarMJk4k5ktFkoKYHVXHCJ7zuB4ABKTUj-aU8FPJtok,165
+deepdots_sdk/api/feedback.py,sha256=ezKdvlXez1K-odYAxZF2YYPPxjC53SYTFdCAhnHAksI,165
+deepdots_sdk/api/integrations_questions.py,sha256=b6wBnpK2WLUnNrOX-wDVHybZThdJH7X1xuX2q9DjAPY,219
+deepdots_sdk/api/metrics.py,sha256=dgmTXhMCCVJVpCeK09dzKXbGfPK_Uyh5ZpeEgU8tm9s,161
+deepdots_sdk/api/products.py,sha256=LQyI9cOg7CJIMjX5pBKmo5i89kMQqn9LS8x-xTmcqcM,165
+deepdots_sdk/api/reports.py,sha256=bd1mGM85bQlbf-KuObdO4MH9H3aRnW193cUvedEfGlA,161
+deepdots_sdk/api/requests.py,sha256=9a_MtWj2SnhodyvcsIxxwtnA8bdFZSBNnqLHxYYFfXA,207
+deepdots_sdk/api/signals.py,sha256=Ds00AXHMs4Ownf3Rf305q2TjUQulr8DBSr_lRifioS0,161
+deepdots_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepdots_sdk/utils/request.py,sha256=OhpwFvUEOT3xKnq9y-HXyUD7dPS3xoJ7DD8Mt2fGc4I,169
+magicfeedback-1.0.19.dist-info/licenses/LICENCE,sha256=gIVSj35jJtSTUxMd2h9qra0bz8Brc-RjdBwC1_rEar0,1065
+magicfeedback_sdk/__init__.py,sha256=emHv--vGaLa8zsJxRB-pq9obWKUeeOFsZAFTTV1OdZQ,85
+magicfeedback_sdk/auth.py,sha256=aLlHIMxJ92gmNjM1EzV4DOVX6oksQK0UIXiWY57Fx9U,8840
+magicfeedback_sdk/client.py,sha256=HKgZJMXS3IzEobmDckOXDAIVynat_WamZ_5GnaPIEiQ,5621
+magicfeedback_sdk/logging_config.py,sha256=WGthGRBhLRKEnCEFmjoy3uoVdAZBL09cnvrwSmYWaMk,165
+magicfeedback_sdk/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+magicfeedback_sdk/api/campaigns.py,sha256=wgvG5mh_lXFpDxxqTHSytogv1scLa8OX8q_KWXrQMDE,1924
+magicfeedback_sdk/api/companies.py,sha256=GAJHaSlxzYBl2dod6QY-mRAcS_Vbb5gVkCLNooeU0nQ,727
+magicfeedback_sdk/api/contacts.py,sha256=-QlRypGcjZGgU3xYNPRkDll3aHb8VBHZAqMnQO9fWfs,1213
+magicfeedback_sdk/api/feedback.py,sha256=GWBfvAk5TjDJCDlsptT5x150ZOkHZF84BP6BSlOhXg8,2612
+magicfeedback_sdk/api/integrations_questions.py,sha256=UR8NjnpGctKtgCM6pbetwprPKcNpU5d4JCjerbgV1xI,525
+magicfeedback_sdk/api/metrics.py,sha256=G7m21ZPj3R1piqWFtXka3k3Y7swFNpvWXO9bkbWbcCg,463
+magicfeedback_sdk/api/products.py,sha256=v0P0chPZi2Ck-dIiXk2BQGmyRE1YFaH6kiLoVqra0CA,465
+magicfeedback_sdk/api/reports.py,sha256=iAQIuClhG-bw_aer7B4mv-Qx2vCWypOzK6hBj4cZrus,1687
+magicfeedback_sdk/api/requests.py,sha256=vMqdOo3Y_eD_3pV7sttpj-n9TZoaS5FFoWVTXet49Wo,2990
+magicfeedback_sdk/api/signals.py,sha256=o9OAlH5lHbM4z2nuxbsKfoXOXBeUzxwyR9F_tbvzZk8,1481
+magicfeedback_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+magicfeedback_sdk/utils/request.py,sha256=QjiWdYrNCuzHnscNdD7N99wOcfA2HtemiDUuBAt0T3I,506
+magicfeedback-1.0.19.dist-info/METADATA,sha256=dvEczXSxAGbOHJcImKmZkHEtZh25ozv48XumJH3QY7I,8199
+magicfeedback-1.0.19.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+magicfeedback-1.0.19.dist-info/top_level.txt,sha256=oDg5H1DxkwB80gZaj6_EbLYWKf__SPVQM6t16SaEags,31
+magicfeedback-1.0.19.dist-info/RECORD,,

magicfeedback-1.0.19.dist-info/WHEEL

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

magicfeedback-1.0.19.dist-info/licenses/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 MagicFeedback OÜ
+
+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.   

magicfeedback-1.0.19.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+deepdots_sdk
+magicfeedback_sdk

magicfeedback_sdk/__init__.py

@@ -0,0 +1,3 @@
+from .client import Deepdots, MagicFeedback
+
+__all__ = ["Deepdots", "MagicFeedback"]

magicfeedback_sdk/api/campaigns.py

@@ -0,0 +1,47 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class CampaignsAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def create(self, campaign):
+        url = f"{self.base_url}/campaigns"
+        required_fields = ["name", "companyId"]
+        for field in required_fields:
+            if field not in campaign:
+                raise ValueError(f"Missing required field: {field}")
+        return make_request("POST", url, self.headers, json=campaign, logger=self.logger)
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/campaigns"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def create_session(self, campaign_id, session):
+        url = f"{self.base_url}/campaigns/{campaign_id}/session"
+        required_fields = ["crmContactId"]
+        for field in required_fields:
+            if field not in session:
+                raise ValueError(f"Missing required field: {field}")
+        if not session.get("crmContactId"):
+            raise ValueError("Contact ID cannot be empty.")
+        return make_request("POST", url, self.headers, json=session, logger=self.logger)
+
+    def get_sessions(self, campaign_id, filter=None):
+        url = f"{self.base_url}/campaigns/{campaign_id}/session"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+    
+    def get_sessions_feedbacks(self, campaign_id, filter=None):
+        url = f"{self.base_url}/campaigns/{campaign_id}/sessions/feedback"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/companies.py

@@ -0,0 +1,22 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class CompaniesAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/companies"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+    
+    def get_id(self, id, filter=None):
+        url = f"{self.base_url}/companies/{id}"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/contacts.py

@@ -0,0 +1,31 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class ContactsAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def create(self, contact):
+        url = f"{self.base_url}/crm/contacts"
+        required_fields = ["name", "lastname", "email", "companyId"]
+        for field in required_fields:
+            if field not in contact:
+                raise ValueError(f"Missing required field: {field}")
+        return make_request("POST", url, self.headers, json=contact, logger=self.logger)
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/crm/contacts"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def update(self, contact_id, contact):
+        url = f"{self.base_url}/crm/contacts/{contact_id}"
+        return make_request("PATCH", url, self.headers, json=contact, logger=self.logger)
+
+    def delete(self, contact_id):
+        url = f"{self.base_url}/crm/contacts/{contact_id}"
+        return make_request("DELETE", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/feedback.py

@@ -0,0 +1,63 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class FeedbackAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def create(self, feedback):
+        url = f"{self.base_url}/feedbacks"
+        required_fields = ["name", "type", "identity", "integrationId", "companyId", "productId"]
+        for field in required_fields:
+            if field not in feedback:
+                raise ValueError(f"Missing required field: {field}")
+
+        if "answers" in feedback and isinstance(feedback["answers"], list):
+            for answer in feedback["answers"]:
+                if "value" in answer and not isinstance(answer["value"], list):
+                    answer["value"] = [answer["value"]]
+
+        return make_request("POST", url, self.headers, json=feedback, logger=self.logger)
+
+    def get_id(self, feedback_id, filter=None):
+        url = f"{self.base_url}/feedbacks/{feedback_id}"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+    
+    def get(self, filter=None):
+        url = f"{self.base_url}/feedbacks"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def update(self, feedback_id, feedback):
+        url = f"{self.base_url}/feedbacks/{feedback_id}"
+        return make_request("PATCH", url, self.headers, json=feedback, logger=self.logger)
+
+    def delete(self, feedback_id):
+        url = f"{self.base_url}/feedbacks/{feedback_id}"
+        return make_request("DELETE", url, self.headers, logger=self.logger)
+
+    def upload_attachment(self, feedback_id, file_path, filename=None, extra_data=None):
+        url = f"{self.base_url}/feedbacks/{feedback_id}/attachments"
+
+        with open(file_path, "rb") as f:
+            file_bytes = f.read()
+
+        display_name = filename or file_path.split("/")[-1]
+
+        files = {"file": (display_name, file_bytes)}
+        data = {"filename": display_name}
+        if extra_data is not None:
+            import json
+            data["extraData"] = json.dumps(extra_data) if not isinstance(extra_data, str) else extra_data
+
+        # Remove Content-Type so requests sets it automatically with the multipart boundary
+        headers = {k: v for k, v in self.headers.items() if k.lower() != "content-type"}
+
+        return make_request("POST", url, headers, files=files, data=data, logger=self.logger)

magicfeedback_sdk/api/integrations_questions.py

@@ -0,0 +1,15 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class IntegrationsQuestionsAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, integration_id, filter=None):
+        url = f"{self.base_url}/integrations/{integration_id}/questions"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/metrics.py

@@ -0,0 +1,15 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class MetricsAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/metrics"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/products.py

@@ -0,0 +1,15 @@
+from magicfeedback_sdk.utils.request import make_request
+
+
+class ProductsAPI:
+    def __init__(self, base_url, headers, logger):
+        self.base_url = base_url
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/products"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/api/reports.py

@@ -0,0 +1,51 @@
+# reports.py
+from typing import Any, Dict, Optional
+import json
+
+from magicfeedback_sdk.utils.request import make_request
+
+
+class ReportsAPI:
+    """
+    Lightweight client for reporting-related endpoints.
+
+    Currently supports:
+      - GET /reporting/report/newsletter?filter=<LoopBackFilterJSON>
+    """
+
+    def __init__(self, base_url: str, headers: Dict[str, str], logger: Any = None):
+        self.base_url = base_url.rstrip("/")
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/reporting/report"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def get_newsletter(self, filter=None):
+        url = f"{self.base_url}/reporting/report/newsletter"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+    
+    def update(self, report_id, report):
+        url = f"{self.base_url}/reporting/report/{report_id}"
+        return make_request("PATCH", url, self.headers, json=report, logger=self.logger)
+
+    def regenerate(self, report_id, body=None):
+        """
+        Regenerate/republish a report.
+
+        Args:
+            report_id: Report UUID to regenerate
+            body: Optional request body for publish configuration
+
+        Returns:
+            Response from the publish endpoint
+        """
+        url = f"{self.base_url}/reporting/report/{report_id}/publish"
+        return make_request("POST", url, self.headers, json=body or {}, logger=self.logger)

magicfeedback_sdk/api/requests.py

@@ -0,0 +1,94 @@
+# requests.py
+from typing import Any, Dict, List, Optional
+
+from magicfeedback_sdk.utils.request import make_request
+
+
+def build_done_message(
+    request_id: str,
+    company_id: str,
+    output: Any = None,
+    success: bool = True,
+    status: Optional[str] = None,
+    sources: Optional[List[Any]] = None,
+    sources_key: Optional[str] = None,
+    logs: Optional[str] = None,
+    quality: Optional[Dict[str, Any]] = None,
+    error: Any = None,
+) -> Dict[str, Any]:
+    """
+    Build the completion envelope consumed by the `request-done` Cloud Function
+    (MagicFeedback_Functions/functions/request-done). The CF PATCHes
+    /requests/{id} to DONE (or ERROR) from this payload.
+
+    The SDK does not publish this message itself — producers (e.g. notebooks /
+    workers) build the envelope with this helper and publish it to the
+    `request-done` Pub/Sub topic directly. See examples/mark_request_done.py.
+
+    Only `id`, `companyId` and `success` are always present; the rest are
+    included only when provided, to keep messages small.
+    """
+    if not request_id:
+        raise ValueError("request_id is required")
+    if not company_id:
+        raise ValueError("company_id is required")
+
+    message: Dict[str, Any] = {
+        "id": request_id,
+        "companyId": company_id,
+        "success": bool(success),
+    }
+    if status is not None:
+        message["status"] = status
+    if output is not None:
+        message["output"] = output
+    if sources is not None:
+        message["sources"] = list(sources)
+    if sources_key is not None:
+        message["sourcesKey"] = sources_key
+    if logs is not None:
+        message["logs"] = logs
+    if quality is not None:
+        message["quality"] = quality
+    if error is not None:
+        message["error"] = error
+    return message
+
+
+class RequestsAPI:
+    """
+    Lightweight client for reporting-related endpoints.
+
+    Currently supports:
+      - GET /requests?filter=<LoopBackFilterJSON>
+      - GET /requests/{id}?filter=<LoopBackFilterJSON>
+      - PATCH /requests/{id}
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        headers: Dict[str, str],
+        logger: Any = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None):
+        url = f"{self.base_url}/requests"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def get_id(self, request_id, filter=None):
+        url = f"{self.base_url}/requests/{request_id}"
+        if filter:
+            import json
+            url += f"?filter={json.dumps(filter)}"
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def update(self, request_id, request):
+        url = f"{self.base_url}/requests/{request_id}"
+        return make_request("PATCH", url, self.headers, json=request, logger=self.logger)

magicfeedback_sdk/api/signals.py

@@ -0,0 +1,45 @@
+# signals.py
+from typing import Any, Dict
+
+from magicfeedback_sdk.utils.request import make_request
+
+
+class SignalsAPI:
+    """
+    Lightweight client for signals endpoints.
+
+    Currently supports:
+      - GET /signals?filter=<LoopBackFilterJSON>
+      - GET /signals/count?filter=<LoopBackFilterJSON>
+    """
+
+    def __init__(self, base_url: str, headers: Dict[str, str], logger: Any = None):
+        self.base_url = base_url.rstrip("/")
+        self.headers = headers
+        self.logger = logger
+
+    def get(self, filter=None, filter_by_metrics=None):
+        url = f"{self.base_url}/signals"
+        params = []
+        if filter:
+            import json
+            params.append(f"filter={json.dumps(filter)}")
+        if filter_by_metrics:
+            import json
+            params.append(f"filterByMetrics={json.dumps(filter_by_metrics)}")
+        if params:
+            url += "?" + "&".join(params)
+        return make_request("GET", url, self.headers, logger=self.logger)
+
+    def count(self, filter=None, filter_by_metrics=None):
+        url = f"{self.base_url}/signals/count"
+        params = []
+        if filter:
+            import json
+            params.append(f"filter={json.dumps(filter)}")
+        if filter_by_metrics:
+            import json
+            params.append(f"filterByMetrics={json.dumps(filter_by_metrics)}")
+        if params:
+            url += "?" + "&".join(params)
+        return make_request("GET", url, self.headers, logger=self.logger)

magicfeedback_sdk/auth.py

@@ -0,0 +1,217 @@
+import json
+from datetime import datetime, timezone
+from typing import Optional
+
+import requests
+
+
+class AuthManager:
+    """Resolves the API bearer token from one of two sources.
+
+    * ``"datastore"`` (default) — read the token cached in Google Cloud
+      Datastore by the ``update-token`` job (kind=``token-storage``,
+      email=``robot@magicfeedback.io``, database=``shared``). This avoids a call
+      to Identity Platform on every SDK use. When the cached token is missing,
+      stale (older than ``token_max_age_min`` minutes) or Datastore is
+      unreachable, a fresh token is minted via Identity Platform as a fallback
+      (requires ``user``/``password``).
+    * ``"identity"`` — always mint a fresh token via Identity Platform
+      (``signInWithPassword``). This is the original SDK behaviour and performs
+      no Datastore lookup.
+
+    The Datastore path uses the ``google-cloud-datastore`` package (a declared
+    dependency) and Google Application Default Credentials with read access to
+    the token entity. Missing/invalid credentials or an unreachable Datastore
+    degrade to the Identity Platform fallback; the lookup is bounded by
+    ``datastore_timeout_s`` so the fallback happens in seconds rather than
+    blocking on the client's default ~60s retry deadline.
+    """
+
+    IDENTITY_URL = (
+        "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key={key}"
+    )
+
+    def __init__(
+        self,
+        ip_key: str,
+        logger,
+        *,
+        gcp_project_id: Optional[str] = None,
+        datastore_database_id: str = "shared",
+        token_kind: str = "token-storage",
+        token_email: str = "robot@magicfeedback.io",
+        token_max_age_min: int = 50,
+        datastore_timeout_s: float = 5.0,
+    ):
+        self.ip_key = ip_key
+        self.logger = logger
+        # Datastore token cache configuration (matches the update-token job).
+        self.gcp_project_id = gcp_project_id
+        self.datastore_database_id = datastore_database_id
+        self.token_kind = token_kind
+        self.token_email = token_email
+        self.token_max_age_min = token_max_age_min
+        # Wall-clock budget for the whole Datastore lookup. Without it the
+        # client's default ~60s retry deadline would make the Identity
+        # fallback block for up to a minute on stale/unreachable credentials.
+        self.datastore_timeout_s = datastore_timeout_s
+
+    # ------------------------------------------------------------------
+    # Public entry point
+    # ------------------------------------------------------------------
+    def get_api_key(self, user=None, password=None, source: str = "datastore") -> str:
+        """Return a bearer token from ``source``.
+
+        ``"datastore"`` prefers the cached token and falls back to Identity
+        Platform when it is missing/stale/unreachable. ``"identity"`` always
+        logs in via Identity Platform.
+        """
+        if source == "identity":
+            return self.identity_login(user, password)
+        if source == "datastore":
+            token = self.get_token_from_datastore()
+            if token:
+                return token
+            self.logger.info(
+                "No fresh token in Datastore (kind=%s, email=%s); "
+                "falling back to Identity Platform login",
+                self.token_kind,
+                self.token_email,
+            )
+            return self.identity_login(user, password)
+        raise ValueError(
+            f"Unknown auth source {source!r}; expected 'datastore' or 'identity'"
+        )
+
+    # ------------------------------------------------------------------
+    # Identity Platform
+    # ------------------------------------------------------------------
+    def identity_login(self, user, password) -> str:
+        if not user or not password:
+            raise ValueError(
+                "Identity Platform login requires both user and password. "
+                "Provide them to MagicFeedback(...) or ensure a fresh token "
+                "exists in Datastore."
+            )
+        self.logger.info("Logging in with user: %s", user)
+
+        url = self.IDENTITY_URL.format(key=self.ip_key)
+        headers = {"Content-Type": "application/json"}
+        payload = json.dumps({
+            "email": user,
+            "password": password,
+            "returnSecureToken": True
+        })
+
+        response = requests.post(url, headers=headers, data=payload)
+        response.raise_for_status()
+        data = response.json()
+        token = data.get("idToken")
+        if not token:
+            raise RuntimeError("idToken not found in Identity Platform response")
+        return token
+
+    # ------------------------------------------------------------------
+    # Datastore token cache
+    # ------------------------------------------------------------------
+    def get_token_from_datastore(self, *, allow_stale: bool = False) -> Optional[str]:
+        """Return the token cached in Datastore, or ``None``.
+
+        Returns ``None`` (rather than raising) when the token entity is missing,
+        has no ``token`` field, is stale (older than ``token_max_age_min`` and
+        ``allow_stale`` is False), or Datastore is unreachable — so callers can
+        fall back to another source.
+
+        :param allow_stale: return the cached token even if older than
+            ``token_max_age_min`` (still ``None`` when absent/unreachable).
+        """
+        try:
+            entity = self._fetch_token_entity()
+        except Exception as exc:  # noqa: BLE001 - Datastore optional; caller falls back
+            self.logger.warning(
+                "Datastore token lookup failed (%s); token unavailable from cache",
+                exc,
+            )
+            return None
+
+        if not entity:
+            self.logger.info(
+                "No token entity in Datastore (kind=%s, email=%s)",
+                self.token_kind,
+                self.token_email,
+            )
+            return None
+
+        token = entity.get("token")
+        if not token:
+            self.logger.warning(
+                "Datastore token entity found but missing 'token' field "
+                "(kind=%s, email=%s)",
+                self.token_kind,
+                self.token_email,
+            )
+            return None
+
+        age = self._entity_age_minutes(entity)
+        if age is not None:
+            self.logger.info("Cached token age: %s minutes", age)
+            if age >= self.token_max_age_min and not allow_stale:
+                self.logger.info(
+                    "Datastore token is stale (age=%s min >= %s min)",
+                    age,
+                    self.token_max_age_min,
+                )
+                return None
+
+        self.logger.info("Using token from Datastore cache")
+        return str(token)
+
+    def _ds_client(self):
+        from google.cloud import datastore  # lazy: optional dependency
+        if self.gcp_project_id:
+            return datastore.Client(
+                project=self.gcp_project_id,
+                database=self.datastore_database_id,
+            )
+        return datastore.Client(database=self.datastore_database_id)
+
+    def _fetch_token_entity(self):
+        from google.api_core.retry import Retry  # lazy: ships with datastore
+
+        client = self._ds_client()
+        query = client.query(kind=self.token_kind)
+        query.add_filter("email", "=", self.token_email)
+        # Bound the total wall-clock: a per-call ``timeout`` alone does not cap
+        # the retry loop, so also cap the retry deadline. This turns an
+        # unreachable/reauth-needed Datastore into a fast fallback instead of a
+        # ~60s stall.
+        retry = Retry(deadline=self.datastore_timeout_s)
+        results = list(
+            query.fetch(limit=1, retry=retry, timeout=self.datastore_timeout_s)
+        )
+        return results[0] if results else None
+
+    @staticmethod
+    def _entity_age_minutes(entity) -> Optional[int]:
+        """Minutes since the entity's ``generatedAt``, or ``None`` if unknown.
+
+        Handles both a native ``datetime`` (as returned by the Datastore client)
+        and an ISO-8601 string; naive values are treated as UTC.
+        """
+        ga = entity.get("generatedAt")
+        if not ga:
+            return None
+        if isinstance(ga, str):
+            try:
+                if ga.endswith("Z"):
+                    ga = ga[:-1] + "+00:00"
+                dt = datetime.fromisoformat(ga)
+            except Exception:  # noqa: BLE001 - unparseable timestamp => unknown age
+                return None
+        elif isinstance(ga, datetime):
+            dt = ga
+        else:
+            return None
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int((datetime.now(timezone.utc) - dt).total_seconds() // 60)

magicfeedback_sdk/client.py

@@ -0,0 +1,117 @@
+from magicfeedback_sdk.api.campaigns import CampaignsAPI
+from magicfeedback_sdk.api.contacts import ContactsAPI
+from magicfeedback_sdk.api.feedback import FeedbackAPI
+from magicfeedback_sdk.api.integrations_questions import IntegrationsQuestionsAPI
+from magicfeedback_sdk.api.metrics import MetricsAPI
+from magicfeedback_sdk.api.products import ProductsAPI
+from magicfeedback_sdk.api.reports import ReportsAPI
+from magicfeedback_sdk.api.requests import RequestsAPI
+from magicfeedback_sdk.api.companies import CompaniesAPI
+from magicfeedback_sdk.api.signals import SignalsAPI
+from magicfeedback_sdk.auth import AuthManager
+from magicfeedback_sdk.logging_config import configure_logger
+
+
+class MagicFeedback:
+    def __init__(
+        self,
+        user: str = None,
+        password: str = None,
+        base_url: str = "https://api.magicfeedback.io",
+        ip_key: str = "AIzaSyAKcR895VURSQZSN2T_RD6jX_9y5HRmH80",
+        auth_source: str = "datastore",
+        gcp_project_id: str = None,
+        datastore_database_id: str = "shared",
+        token_kind: str = "token-storage",
+        token_email: str = "robot@magicfeedback.io",
+        token_max_age_min: int = 50,
+        datastore_timeout_s: float = 5.0,
+    ):
+        """Create a MagicFeedback API client.
+
+        By default (``auth_source="datastore"``) the bearer token is read from
+        the Google Cloud Datastore cache maintained by the ``update-token`` job,
+        avoiding an Identity Platform login on every use. If the cached token is
+        missing/stale/unreachable, the client falls back to Identity Platform
+        (which needs ``user``/``password``). Pass ``auth_source="identity"`` to
+        always log in via Identity Platform (the original behaviour, no
+        Datastore lookup).
+
+        :param user: Identity Platform email (required for the identity source
+            and for the datastore fallback).
+        :param password: Identity Platform password (see ``user``).
+        :param auth_source: ``"datastore"`` (default) or ``"identity"``.
+        :param gcp_project_id: GCP project owning the token Datastore; when
+            omitted, resolved from Application Default Credentials.
+        :param datastore_database_id: Datastore database holding the token
+            (default ``"shared"``).
+        :param token_kind: Datastore kind of the token entity
+            (default ``"token-storage"``).
+        :param token_email: ``email`` key identifying the token entity
+            (default ``"robot@magicfeedback.io"``).
+        :param token_max_age_min: cached tokens older than this (minutes) are
+            treated as stale and trigger the Identity Platform fallback.
+        :param datastore_timeout_s: wall-clock budget (seconds) for the
+            Datastore lookup; on timeout/error the client falls back to Identity
+            Platform. Keeps the fallback fast instead of blocking on the
+            Datastore client's default ~60s retry deadline.
+        """
+        self.logger = configure_logger()
+        self.base_url = base_url
+        self.ip_key = ip_key
+
+        # Kept so refresh_token() can re-resolve the token the same way.
+        self._user = user
+        self._password = password
+        self.auth_source = auth_source
+
+        self.auth = AuthManager(
+            ip_key,
+            self.logger,
+            gcp_project_id=gcp_project_id,
+            datastore_database_id=datastore_database_id,
+            token_kind=token_kind,
+            token_email=token_email,
+            token_max_age_min=token_max_age_min,
+            datastore_timeout_s=datastore_timeout_s,
+        )
+        self.api_key = self.auth.get_api_key(user, password, source=auth_source)
+        self.headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        # APIs
+        self.feedbacks = FeedbackAPI(self.base_url, self.headers, self.logger)
+        self.contacts = ContactsAPI(self.base_url, self.headers, self.logger)
+        self.campaigns = CampaignsAPI(self.base_url, self.headers, self.logger)
+        self.metrics = MetricsAPI(self.base_url, self.headers, self.logger)
+        self.integrations_questions = IntegrationsQuestionsAPI(self.base_url, self.headers, self.logger)
+        self.products = ProductsAPI(self.base_url, self.headers, self.logger)   
+        self.reports = ReportsAPI(self.base_url, self.headers, self.logger)
+        self.companies = CompaniesAPI(self.base_url, self.headers, self.logger)
+        self.requests = RequestsAPI(self.base_url, self.headers, self.logger)
+        self.signals = SignalsAPI(self.base_url, self.headers, self.logger)
+
+    def set_logging(self, level):
+        self.logger.setLevel(level)
+
+    def refresh_token(self):
+        """Re-resolve the API token (same ``auth_source`` as construction) and
+        update the auth header in place.
+
+        The sub-API clients (``self.feedbacks`` etc.) share this ``headers``
+        dict by reference, so mutating it here transparently updates them all —
+        useful for long-lived clients whose token has expired.
+
+        :return: the new bearer token.
+        """
+        self.api_key = self.auth.get_api_key(
+            self._user, self._password, source=self.auth_source
+        )
+        self.headers["Authorization"] = f"Bearer {self.api_key}"
+        return self.api_key
+
+
+# The company was renamed MagicFeedback -> Deepdots. ``Deepdots`` is the
+# forward-looking name for this client; ``MagicFeedback`` remains the defining
+# name so existing tracebacks and reprs are unchanged. Both refer to the same
+# class object, so isinstance() and subclassing behave identically either way.
+Deepdots = MagicFeedback

magicfeedback_sdk/logging_config.py

@@ -0,0 +1,7 @@
+import logging
+
+
+def configure_logger(name="magicfeedback_sdk"):
+    logger = logging.getLogger(name)
+    logger.addHandler(logging.NullHandler())
+    return logger

magicfeedback_sdk/utils/request.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict
+
+import requests
+
+
+def make_request(method: str, url: str, headers: Dict[str, str], json=None, files=None, data=None, logger=None) -> Dict[str, Any]:
+    response = requests.request(method, url, headers=headers, json=json, files=files, data=data)
+    response.raise_for_status()
+
+    if logger:
+        logger.debug("Status code: %s", response.status_code)
+        logger.debug("Response: %s", response.text)
+
+    if response.text:
+        return response.json()
+    return {}