sfq 0.0.7__tar.gz → 0.0.9__tar.gz

sfq-0.0.9/.python-version

@@ -0,0 +1 @@
+3.9

{sfq-0.0.7 → sfq-0.0.9}/PKG-INFO

@@ -1,20 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sfq
-Version: 0.0.7
+Version: 0.0.9
 Summary: Python wrapper for the Salesforce's Query API.
 Author-email: David Moruzzi <sfq.pypi@dmoruzi.com>
 Keywords: salesforce,salesforce query
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
-Requires-Dist: prompt-toolkit>=3.0.3
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 
 # sfq (Salesforce Query)
@@ -39,24 +36,6 @@ pip install sfq
 
 ## Usage
 
-### Interactive Querying 
-
-```powershell
-usage: python -m sfq [-a SFDXAUTHURL] [--dry-run] [--disable-fuzzy-completion]
-
-Interactively query Salesforce data with real-time autocompletion.
-
-options:
-  -h, --help            show this help message and exit
-  -a, --sfdxAuthUrl SFDXAUTHURL
-                        Salesforce auth url
-  --dry-run             Print the query without executing it
-  --disable-fuzzy-completion
-                        Disable fuzzy completion
-```
-
-You can run the `sfq` library in interactive mode by passing the `-a` option with the `SFDX_AUTH_URL` argument or by setting the `SFDX_AUTH_URL` environment variable.
-
 ### Library Querying
 
 ```python
@@ -146,7 +125,9 @@ To use the `sfq` library, you'll need a **client ID** and **refresh token**. The
    pip install sfq && python -c "from sfq import SFAuth; sf = SFAuth(instance_url='$instanceUrl', client_id='$clientId', refresh_token='$refreshToken'); print(sf.query('$query'))" | jq -r '.records[].Id'
    ```
 
-## Notes
+## Important Considerations
+
+- **Security**: Safeguard your refresh token diligently, as it provides access to your Salesforce environment. Avoid sharing or exposing it in unsecured locations.
+- **Efficient Data Retrieval**: The `query` function automatically handles pagination, simplifying record retrieval across large datasets. It's recommended to use the `LIMIT` clause in queries to control the volume of data returned.
+- **Advanced Metadata Queries**: Utilize the `tooling=True` option within the `query` function to access the Salesforce Tooling API. This option is designed for performing complex metadata operations, enhancing your data management capabilities.
 
-- **Authentication**: Make sure your refresh token is kept secure, as it grants access to your Salesforce instance.
-- **Tooling API**: You can set the `tooling=True` argument in the `query` method to access the Salesforce Tooling API for more advanced metadata queries. This is limited to library usage only.

{sfq-0.0.7 → sfq-0.0.9}/README.md

@@ -20,24 +20,6 @@ pip install sfq
 
 ## Usage
 
-### Interactive Querying 
-
-```powershell
-usage: python -m sfq [-a SFDXAUTHURL] [--dry-run] [--disable-fuzzy-completion]
-
-Interactively query Salesforce data with real-time autocompletion.
-
-options:
-  -h, --help            show this help message and exit
-  -a, --sfdxAuthUrl SFDXAUTHURL
-                        Salesforce auth url
-  --dry-run             Print the query without executing it
-  --disable-fuzzy-completion
-                        Disable fuzzy completion
-```
-
-You can run the `sfq` library in interactive mode by passing the `-a` option with the `SFDX_AUTH_URL` argument or by setting the `SFDX_AUTH_URL` environment variable.
-
 ### Library Querying
 
 ```python
@@ -127,7 +109,9 @@ To use the `sfq` library, you'll need a **client ID** and **refresh token**. The
    pip install sfq && python -c "from sfq import SFAuth; sf = SFAuth(instance_url='$instanceUrl', client_id='$clientId', refresh_token='$refreshToken'); print(sf.query('$query'))" | jq -r '.records[].Id'
    ```
 
-## Notes
+## Important Considerations
+
+- **Security**: Safeguard your refresh token diligently, as it provides access to your Salesforce environment. Avoid sharing or exposing it in unsecured locations.
+- **Efficient Data Retrieval**: The `query` function automatically handles pagination, simplifying record retrieval across large datasets. It's recommended to use the `LIMIT` clause in queries to control the volume of data returned.
+- **Advanced Metadata Queries**: Utilize the `tooling=True` option within the `query` function to access the Salesforce Tooling API. This option is designed for performing complex metadata operations, enhancing your data management capabilities.
 
-- **Authentication**: Make sure your refresh token is kept secure, as it grants access to your Salesforce instance.
-- **Tooling API**: You can set the `tooling=True` argument in the `query` method to access the Salesforce Tooling API for more advanced metadata queries. This is limited to library usage only.

{sfq-0.0.7 → sfq-0.0.9}/pyproject.toml

@@ -1,21 +1,17 @@
 [project]
 name = "sfq"
-version = "0.0.7"
+version = "0.0.9"
 description = "Python wrapper for the Salesforce's Query API."
 readme = "README.md"
 authors = [{ name = "David Moruzzi", email = "sfq.pypi@dmoruzi.com" }]
 keywords = ["salesforce", "salesforce query"]
-requires-python = ">=3.7"
-dependencies = [
-    "prompt-toolkit>=3.0.3",
-]
+requires-python = ">=3.9"
+dependencies = []
 
 classifiers = [
   "Development Status :: 3 - Alpha",
   "Intended Audience :: Developers",
   "Topic :: Software Development :: Libraries :: Python Modules",
-  "Programming Language :: Python :: 3.7",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.12",

sfq-0.0.9/src/sfq/__init__.py

@@ -0,0 +1,398 @@
+import http.client
+import json
+import logging
+import os
+import time
+from typing import Any, Dict, Optional
+from urllib.parse import quote, urlparse
+
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+
+def trace(self: logging.Logger, message: str, *args: Any, **kwargs: Any) -> None:
+    """Custom TRACE level logging function with redaction."""
+
+    def _redact_sensitive(data: Any) -> Any:
+        """Redacts sensitive keys from a dictionary or query string."""
+        REDACT_VALUE = "*" * 8
+        if isinstance(data, dict):
+            return {
+                k: (
+                    REDACT_VALUE
+                    if k.lower() in ["access_token", "authorization", "refresh_token"]
+                    else v
+                )
+                for k, v in data.items()
+            }
+        elif isinstance(data, str):
+            parts = data.split("&")
+            for i, part in enumerate(parts):
+                if "=" in part:
+                    key, value = part.split("=", 1)
+                    if key.lower() in [
+                        "access_token",
+                        "authorization",
+                        "refresh_token",
+                    ]:
+                        parts[i] = f"{key}={REDACT_VALUE}"
+            return "&".join(parts)
+        return data
+
+    redacted_args = args
+    if args:
+        first = args[0]
+        if isinstance(first, str):
+            try:
+                loaded = json.loads(first)
+                first = loaded
+            except (json.JSONDecodeError, TypeError):
+                pass
+        redacted_first = _redact_sensitive(first)
+        redacted_args = (redacted_first,) + args[1:]
+
+    if self.isEnabledFor(TRACE):
+        self._log(TRACE, message, redacted_args, **kwargs)
+
+
+logging.Logger.trace = trace
+logger = logging.getLogger("sfq")
+
+
+class SFAuth:
+    def __init__(
+        self,
+        instance_url: str,
+        client_id: str,
+        refresh_token: str,
+        api_version: str = "v63.0",
+        token_endpoint: str = "/services/oauth2/token",
+        access_token: Optional[str] = None,
+        token_expiration_time: Optional[float] = None,
+        token_lifetime: int = 15 * 60,
+        user_agent: str = "sfq/0.0.9",
+        proxy: str = "auto",
+    ) -> None:
+        """
+        Initializes the SFAuth with necessary parameters.
+
+        :param instance_url: The Salesforce instance URL.
+        :param client_id: The client ID for OAuth.
+        :param refresh_token: The refresh token for OAuth.
+        :param api_version: The Salesforce API version (default is "v63.0").
+        :param token_endpoint: The token endpoint (default is "/services/oauth2/token").
+        :param access_token: The access token for the current session (default is None).
+        :param token_expiration_time: The expiration time of the access token (default is None).
+        :param token_lifetime: The lifetime of the access token in seconds (default is 15 minutes).
+        :param user_agent: Custom User-Agent string (default is "sfq/0.0.9").
+        :param proxy: The proxy configuration, "auto" to use environment (default is "auto").
+        """
+        self.instance_url = instance_url
+        self.client_id = client_id
+        self.refresh_token = refresh_token
+        self.api_version = api_version
+        self.token_endpoint = token_endpoint
+        self.access_token = access_token
+        self.token_expiration_time = token_expiration_time
+        self.token_lifetime = token_lifetime
+        self.user_agent = user_agent
+        self._auto_configure_proxy(proxy)
+        self._high_api_usage_threshold = 80
+
+    def _auto_configure_proxy(self, proxy: str) -> None:
+        """
+        Automatically configure the proxy based on the environment or provided value.
+        """
+        if proxy == "auto":
+            self.proxy = os.environ.get("https_proxy")
+            if self.proxy:
+                logger.debug("Auto-configured proxy: %s", self.proxy)
+        else:
+            self.proxy = proxy
+            logger.debug("Using configured proxy: %s", self.proxy)
+
+    def _prepare_payload(self) -> Dict[str, str]:
+        """
+        Prepare the payload for the token request.
+        """
+        return {
+            "grant_type": "refresh_token",
+            "client_id": self.client_id,
+            "refresh_token": self.refresh_token,
+        }
+
+    def _create_connection(self, netloc: str) -> http.client.HTTPConnection:
+        """
+        Create a connection using HTTP or HTTPS, with optional proxy support.
+
+        :param netloc: The target host and port from the parsed instance URL.
+        :return: An HTTP(S)Connection object.
+        """
+        if self.proxy:
+            proxy_url = urlparse(self.proxy)
+            logger.trace("Using proxy: %s", self.proxy)
+            conn = http.client.HTTPSConnection(proxy_url.hostname, proxy_url.port)
+            conn.set_tunnel(netloc)
+            logger.trace("Using proxy tunnel to %s", netloc)
+        else:
+            conn = http.client.HTTPSConnection(netloc)
+            logger.trace("Direct connection to %s", netloc)
+        return conn
+
+    def _post_token_request(self, payload: Dict[str, str]) -> Optional[Dict[str, Any]]:
+        """
+        Send a POST request to the Salesforce token endpoint using http.client.
+
+        :param payload: Dictionary of form-encoded OAuth parameters.
+        :return: Parsed JSON response if successful, otherwise None.
+        """
+        parsed_url = urlparse(self.instance_url)
+        conn = self._create_connection(parsed_url.netloc)
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": self.user_agent,
+        }
+        body = "&".join(f"{key}={quote(str(value))}" for key, value in payload.items())
+
+        try:
+            logger.trace("Request endpoint: %s", self.token_endpoint)
+            logger.trace("Request body: %s", body)
+            logger.trace("Request headers: %s", headers)
+            conn.request("POST", self.token_endpoint, body, headers)
+            response = conn.getresponse()
+            data = response.read().decode("utf-8")
+            self._http_resp_header_logic(response)
+
+            if response.status == 200:
+                logger.trace("Token refresh successful.")
+                logger.trace("Response body: %s", data)
+                return json.loads(data)
+
+            logger.error(
+                "Token refresh failed: %s %s", response.status, response.reason
+            )
+            logger.debug("Response body: %s", data)
+
+        except Exception as err:
+            logger.exception("Error during token request: %s", err)
+
+        finally:
+            conn.close()
+
+        return None
+
+    def _http_resp_header_logic(self, response: http.client.HTTPResponse) -> None:
+        """
+        Perform additional logic based on the HTTP response headers.
+
+        :param response: The HTTP response object.
+        :return: None
+        """
+        logger.trace(
+            "Response status: %s, reason: %s", response.status, response.reason
+        )
+        headers = response.getheaders()
+        headers_list = [(k, v) for k, v in headers if not v.startswith("BrowserId=")]
+        logger.trace("Response headers: %s", headers_list)
+        for key, value in headers_list:
+            if key.startswith("Sforce-"):
+                if key == "Sforce-Limit-Info":
+                    current_api_calls = int(value.split("=")[1].split("/")[0])
+                    maximum_api_calls = int(value.split("=")[1].split("/")[1])
+                    usage_percentage = round(
+                        current_api_calls / maximum_api_calls * 100, 2
+                    )
+                    if usage_percentage > self._high_api_usage_threshold:
+                        logger.warning(
+                            "High API usage: %s/%s (%s%%)",
+                            current_api_calls,
+                            maximum_api_calls,
+                            usage_percentage,
+                        )
+                    else:
+                        logger.debug(
+                            "API usage: %s/%s (%s%%)",
+                            current_api_calls,
+                            maximum_api_calls,
+                            usage_percentage,
+                        )
+
+    def _refresh_token_if_needed(self) -> Optional[str]:
+        """
+        Automatically refresh the access token if it has expired or is missing.
+
+        :return: A valid access token or None if refresh failed.
+        """
+        if self.access_token and not self._is_token_expired():
+            return self.access_token
+
+        logger.trace("Access token expired or missing, refreshing...")
+        payload = self._prepare_payload()
+        token_data = self._post_token_request(payload)
+
+        if token_data:
+            self.access_token = token_data.get("access_token")
+            issued_at = token_data.get("issued_at")
+
+            try:
+                self.org_id = token_data.get("id").split("/")[4]
+                self.user_id = token_data.get("id").split("/")[5]
+                logger.trace(
+                    "Authenticated as user %s in org %s", self.user_id, self.org_id
+                )
+            except (IndexError, KeyError):
+                logger.error("Failed to extract org/user IDs from token response.")
+
+            if self.access_token and issued_at:
+                self.token_expiration_time = int(issued_at) + self.token_lifetime
+                logger.trace("New token expires at %s", self.token_expiration_time)
+                return self.access_token
+
+        logger.error("Failed to obtain access token.")
+        return None
+
+    def _is_token_expired(self) -> bool:
+        """
+        Check if the access token has expired.
+
+        :return: True if token is expired or missing, False otherwise.
+        """
+        try:
+            return time.time() >= float(self.token_expiration_time)
+        except (TypeError, ValueError):
+            logger.warning("Token expiration check failed. Treating token as expired.")
+            return True
+
+    def tooling_query(self, query: str) -> Optional[Dict[str, Any]]:
+        """
+        Execute a SOQL query using the Tooling API.
+
+        :param query: The SOQL query string.
+        :return: Parsed JSON response or None on failure.
+        """
+        return self.query(query, tooling=True)
+
+    def limits(self) -> Optional[Dict[str, Any]]:
+        self._refresh_token_if_needed()
+
+        if not self.access_token:
+            logger.error("No access token available for limits.")
+            return None
+
+        endpoint = f"/services/data/{self.api_version}/limits"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "User-Agent": self.user_agent,
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        }
+
+        parsed_url = urlparse(self.instance_url)
+        conn = self._create_connection(parsed_url.netloc)
+
+        try:
+            logger.trace("Request endpoint: %s", endpoint)
+            logger.trace("Request headers: %s", headers)
+            conn.request("GET", endpoint, headers=headers)
+            response = conn.getresponse()
+            data = response.read().decode("utf-8")
+            self._http_resp_header_logic(response)
+
+            if response.status == 200:
+                logger.debug("Limits API request successful.")
+                logger.trace("Response body: %s", data)
+                return json.loads(data)
+
+            logger.error("Limits API request failed: %s %s", response.status, response.reason)
+            logger.debug("Response body: %s", data)
+
+        except Exception as err:
+            logger.exception("Error during limits request: %s", err)
+
+        finally:
+            conn.close()
+
+        return None
+
+    def query(self, query: str, tooling: bool = False) -> Optional[Dict[str, Any]]:
+        """
+        Execute a SOQL query using the REST or Tooling API.
+
+        :param query: The SOQL query string.
+        :param tooling: If True, use the Tooling API endpoint.
+        :return: Parsed JSON response or None on failure.
+        """
+        self._refresh_token_if_needed()
+
+        if not self.access_token:
+            logger.error("No access token available for query.")
+            return None
+
+        endpoint = f"/services/data/{self.api_version}/"
+        endpoint += "tooling/query" if tooling else "query"
+        query_string = f"?q={quote(query)}"
+
+        endpoint += query_string
+
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "User-Agent": self.user_agent,
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+        }
+
+        parsed_url = urlparse(self.instance_url)
+        conn = self._create_connection(parsed_url.netloc)
+
+        try:
+            paginated_results = {"totalSize": 0, "done": False, "records": []}
+            while True:
+                logger.trace("Request endpoint: %s", endpoint)
+                logger.trace("Request headers: %s", headers)
+                conn.request("GET", endpoint, headers=headers)
+                response = conn.getresponse()
+                data = response.read().decode("utf-8")
+                self._http_resp_header_logic(response)
+
+                if response.status == 200:
+                    current_results = json.loads(data)
+                    paginated_results["records"].extend(current_results["records"])
+                    query_done = current_results.get("done")
+                    if query_done:
+                        total_size = current_results.get("totalSize")
+                        paginated_results = {
+                            "totalSize": total_size,
+                            "done": query_done,
+                            "records": paginated_results["records"],
+                        }
+                        logger.debug(
+                            "Query successful, returned %s records: %r",
+                            total_size,
+                            query,
+                        )
+                        logger.trace("Query full response: %s", data)
+                        break
+                    endpoint = current_results.get("nextRecordsUrl")
+                    logger.debug(
+                        "Query batch successful, getting next batch: %s", endpoint
+                    )
+                else:
+                    logger.debug("Query failed: %r", query)
+                    logger.error(
+                        "Query failed with HTTP status %s (%s)",
+                        response.status,
+                        response.reason,
+                    )
+                    logger.debug("Query response: %s", data)
+                    break
+
+            return paginated_results
+
+        except Exception as err:
+            logger.exception("Exception during query: %s", err)
+
+        finally:
+            conn.close()
+
+        return None

sfq-0.0.9/uv.lock

@@ -0,0 +1,7 @@
+version = 1
+requires-python = ">=3.9"
+
+[[package]]
+name = "sfq"
+version = "0.0.9"
+source = { editable = "." }

sfq-0.0.7/.python-version

@@ -1 +0,0 @@
-3.7

sfq-0.0.7/src/sfq/__init__.py

@@ -1,174 +0,0 @@
-import http.client
-import logging
-import time
-import os
-import json
-from urllib.parse import urlparse, quote
-
-logging.basicConfig(level=logging.INFO, format='[sfq:%(lineno)d - %(levelname)s] %(message)s')
-
-class SFAuth:
-    def __init__(
-        self,
-        instance_url,
-        client_id,
-        refresh_token,
-        api_version="v63.0",
-        token_endpoint="/services/oauth2/token",
-        access_token=None,
-        token_expiration_time=None,
-        token_lifetime=15 * 60,
-        proxy="auto",
-        user_agent="sfq/0.0.7",
-    ):
-        """
-        Initializes the SFAuth with necessary parameters.
-
-        :param instance_url: The Salesforce instance URL.
-        :param client_id: The client ID for OAuth.
-        :param refresh_token: The refresh token for OAuth.
-        :param api_version: The Salesforce API version (default is "v62.0").
-        :param token_endpoint: The token endpoint (default is "/services/oauth2/token").
-        :param access_token: The access token for the current session (default is None).
-        :param token_expiration_time: The expiration time of the access token (default is None).
-        :param token_lifetime: The lifetime of the access token (default is 15 minutes).
-        :param proxy: The proxy configuration (default is "auto").
-        """
-        self.instance_url = instance_url
-        self.client_id = client_id
-        self.refresh_token = refresh_token
-        self.api_version = api_version
-        self.token_endpoint = token_endpoint
-        self.access_token = access_token
-        self.token_expiration_time = token_expiration_time
-        self.token_lifetime = token_lifetime
-        self._auto_configure_proxy(proxy)
-        self.user_agent = user_agent
-
-    def _auto_configure_proxy(self, proxy):
-        """
-        Automatically configure the proxy based on the environment.
-        """
-        if proxy == "auto":
-            if "https_proxy" in os.environ:
-                self.proxy = os.environ["https_proxy"]
-            else:
-                self.proxy = None
-        else:
-            self.proxy = proxy
-
-    def _prepare_payload(self):
-        """Prepare the payload for the token request."""
-        return {
-            "grant_type": "refresh_token",
-            "client_id": self.client_id,
-            "refresh_token": self.refresh_token,
-        }
-
-    def _create_connection(self, netloc):
-        """
-        Create a connection using HTTP or HTTPS, depending on the proxy configuration.
-        """
-        if self.proxy:
-            proxy_url = urlparse(self.proxy)
-            if proxy_url.scheme == "http://":
-                conn = http.client.HTTPConnection(proxy_url.hostname, proxy_url.port)
-            else:
-                conn = http.client.HTTPSConnection(proxy_url.hostname, proxy_url.port)
-            conn.set_tunnel(netloc)
-        else:
-            conn = http.client.HTTPSConnection(netloc)
-        return conn
-
-    def _send_post_request(self, payload):
-        """Send a POST request to the Salesforce token endpoint using http.client."""
-        parsed_url = urlparse(self.instance_url)
-        conn = self._create_connection(parsed_url.netloc)
-
-        headers = {"Content-Type": "application/x-www-form-urlencoded", "User-Agent": self.user_agent}
-        body = "&".join([f"{key}={quote(str(value))}" for key, value in payload.items()])
-
-        try:
-            conn.request("POST", self.token_endpoint, body, headers)
-            response = conn.getresponse()
-            data = response.read().decode("utf-8")
-            if response.status == 200:
-                return json.loads(data)
-            else:
-                logging.error(
-                    f"HTTP error occurred: {response.status} {response.reason}"
-                )
-                logging.error(f"Response content: {data}")
-        except Exception as err:
-            logging.error(f"Other error occurred: {err}")
-        finally:
-            conn.close()
-
-        return None
-
-    def _refresh_token_if_needed(self):
-        """Automatically refresh the token if it has expired or is missing."""
-        _token_expiration = self._is_token_expired()
-        if self.access_token and not _token_expiration:
-            return self.access_token
-        
-        if not self.access_token:
-            logging.debug("No access token available. Requesting a new one.")
-        elif _token_expiration:
-            logging.debug("Access token has expired. Requesting a new one.")
-
-        payload = self._prepare_payload()
-        token_data = self._send_post_request(payload)
-        if token_data:
-            self.access_token = token_data["access_token"]
-            self.token_expiration_time = int(token_data["issued_at"]) + int(self.token_lifetime)
-            logging.debug("Access token refreshed successfully.")
-        else:
-            logging.error("Failed to refresh access token.")
-        return self.access_token
-
-
-    def _is_token_expired(self):
-        """Check if the access token has expired."""
-        try:
-            return time.time() >= float(self.token_expiration_time)
-        except (TypeError, ValueError):
-            return True
-
-    def query(self, query, tooling=False):
-        """Query Salesforce using SOQL or Tooling API, depending on the `tooling` parameter."""
-        self._refresh_token_if_needed()
-
-        if not self.access_token:
-            logging.error("No access token available to make the query.")
-            return None
-
-        if tooling:
-            query_endpoint = f"/services/data/{self.api_version}/tooling/query"
-        else:
-            query_endpoint = f"/services/data/{self.api_version}/query"
-
-        headers = {"Authorization": f"Bearer {self.access_token}", "User-Agent": self.user_agent}
-
-        # Handle special characters in the query
-        encoded_query = quote(query)
-        params = f"?q={encoded_query}"
-
-        parsed_url = urlparse(self.instance_url)
-        conn = self._create_connection(parsed_url.netloc)
-
-        try:
-            conn.request("GET", query_endpoint + params, headers=headers)
-            response = conn.getresponse()
-            data = response.read().decode("utf-8")
-            if response.status == 200:
-                return json.loads(data)
-            else:
-                logging.error(f"HTTP error occurred during query: {response.status} {response.reason}")
-                logging.error(f"Response content: {data}")
-        except Exception as err:
-            logging.error(f"Other error occurred during query: {err}")
-        finally:
-            conn.close()
-
-        return None

sfq-0.0.7/src/sfq/__main__.py

@@ -1,151 +0,0 @@
-import difflib
-import http.client
-import json
-
-from sfq import SFAuth
-
-from prompt_toolkit import prompt
-from prompt_toolkit.completion import Completer, Completion
-
-def _interactive_shell(sf: SFAuth, dry_run: bool, disable_fuzzy_completion: bool):
-    """Runs an interactive REPL for querying Salesforce data with real-time autocompletion."""
-
-    sobject = None
-    fields = None
-
-    class DynamicSeparatorCompleter(Completer):
-        """Custom completer that adapts to different separators."""
-        
-        def __init__(self, words: list[str], separators: list[str] = [","]):
-            self.words = words
-            self.separators = separators
-
-        def get_completions(self, document, complete_event):
-            text_before_cursor = document.text_before_cursor
-            
-            for separator in self.separators:
-                if separator in text_before_cursor:
-                    last_token = text_before_cursor.split(separator)[-1].strip()
-                    break
-            else:
-                last_token = text_before_cursor.strip()
-
-
-            matches_difflib = difflib.get_close_matches(last_token, self.words, n=20, cutoff=0.6)
-            matches_starting = [word for word in self.words if word.lower().startswith(last_token.lower())]
-
-            if not disable_fuzzy_completion and (len(last_token) > 6 or not(matches_starting)):
-                matches = matches_difflib
-            else:
-                matches = matches_starting
-
-            for word in matches:
-                yield Completion(word, start_position=-len(last_token))
-                
-    def _get_objects(sf: SFAuth):
-        """Retrieve available Salesforce objects."""
-        host = sf.instance_url.split("://")[1].split("/")[0]
-        conn = http.client.HTTPSConnection(host)
-        uri = f"/services/data/{sf.api_version}/sobjects/"
-        headers = {'Authorization': f'Bearer {sf._refresh_token_if_needed()}'}
-        conn.request("GET", uri, headers=headers)
-        response = conn.getresponse()
-        
-        if response.status != 200:
-            print(f'Error: {response.status} {response.reason}')
-            return []
-        
-        data = json.loads(response.read())
-        return [sobject['name'] for sobject in data['sobjects']]
-
-    def _get_fields(sobject: str, sf: SFAuth):
-        """Retrieve available fields for a given Salesforce object."""
-        host = sf.instance_url.split("://")[1].split("/")[0]
-        conn = http.client.HTTPSConnection(host)
-        uri = f"/services/data/{sf.api_version}/sobjects/{sobject}/describe/"
-        headers = {'Authorization': f'Bearer {sf._refresh_token_if_needed()}'}
-        conn.request("GET", uri, headers=headers)
-        response = conn.getresponse()
-        
-        if response.status != 200:
-            print(f'Error: {response.status} {response.reason}')
-            raise ValueError(f'Unable to fetch fields for sObject "{sobject}": {response.status}, {response.reason}')
-        
-        data = json.loads(response.read())
-        return [f['name'] for f in data['fields']]
-
-    available_objects = _get_objects(sf)
-    
-    object_completer = DynamicSeparatorCompleter(available_objects)
-    while not sobject:
-        sobject = prompt('FROM ', completer=object_completer).strip()
-
-
-    available_fields = _get_fields(sobject, sf)
-    field_completer = DynamicSeparatorCompleter(available_fields, separators=[","])
-    while not fields:
-        fields = prompt('SELECT ', completer=field_completer).strip()
-
-    where_completer = DynamicSeparatorCompleter(available_fields, separators=[" AND ", " OR "])
-    where = prompt("WHERE ", completer=where_completer).strip()
-    where_clause = f"WHERE {where}" if where else ""
-    
-    limit = prompt("LIMIT ", default="200").strip()
-    limit_clause = f"LIMIT {limit}" if limit else ""
-    
-    query = f"SELECT {fields} FROM {sobject} {where_clause} {limit_clause}".replace('  ', ' ')
-    
-    if dry_run:
-        print('\nDry-run, skipping execution...')
-        print(f'\nQuery: {query}\n')
-        return query
-    
-    print('\nExecuting query...\n')
-    data = sf.query(query)
-    print(json.dumps(data, indent=4))
-    print(f'\nQuery: {query}\n')
-    return data
-
-if __name__ == "__main__":
-    import argparse
-    import os
-
-    parser = argparse.ArgumentParser(
-        description='Interactively query Salesforce data with real-time autocompletion.'
-    )
-    parser.add_argument(
-        '-a', '--sfdxAuthUrl', type=str, help='Salesforce auth url', default=os.environ.get('SFDX_AUTH_URL')
-    )
-    parser.add_argument(
-        '--dry-run', action='store_true', help='Print the query without executing it', default=str(os.environ.get('SFQ_DRY_RUN')),
-    )
-    parser.add_argument(
-        '--disable-fuzzy-completion', action='store_true', help='Disable fuzzy completion', default=str(os.environ.get('SFQ_DISABLE_FUZZY_COMPLETION')),
-    )
-    args = parser.parse_args()
-
-    if not args.sfdxAuthUrl:
-        raise ValueError('SFDX_AUTH_URL environment variable is not set nor provided as an argument')
-    
-    try:
-        if args.dry_run.lower() not in ['true', '1']:
-            args.dry_run = False
-    except AttributeError:
-        pass
-
-    try:
-        if args.disable_fuzzy_completion.lower() not in ['true', '1']:
-            args.disable_fuzzy_completion = False
-    except AttributeError:
-        pass
-
-
-    _interactive_shell(
-        SFAuth(
-            instance_url=f"https://{str(args.sfdxAuthUrl).split('@')[1]}",
-            client_id=str(args.sfdxAuthUrl).split('//')[1].split('::')[0],
-            refresh_token=str(args.sfdxAuthUrl).split('::')[1].split('@')[0],
-        ),
-        args.dry_run,
-        args.disable_fuzzy_completion
-    )

sfq-0.0.7/uv.lock

@@ -1,35 +0,0 @@
-version = 1
-revision = 1
-requires-python = ">=3.7"
-
-[[package]]
-name = "prompt-toolkit"
-version = "3.0.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "wcwidth" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/8f/bc/58ba47a2a864d8e3d968d03b577c85fbdf52c8d324a030df71ac9c06c1b5/prompt_toolkit-3.0.3.tar.gz", hash = "sha256:a402e9bf468b63314e37460b68ba68243d55b2f8c4d0192f85a019af3945050e", size = 2997855 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f5/22/f00412fafc68169054cc623a35c32773f22b403ddbe516c8adfdecf25341/prompt_toolkit-3.0.3-py3-none-any.whl", hash = "sha256:c93e53af97f630f12f5f62a3274e79527936ed466f038953dfa379d4941f651a", size = 348445 },
-]
-
-[[package]]
-name = "sfq"
-version = "0.0.7"
-source = { editable = "." }
-dependencies = [
-    { name = "prompt-toolkit" },
-]
-
-[package.metadata]
-requires-dist = [{ name = "prompt-toolkit", specifier = ">=3.0.3" }]
-
-[[package]]
-name = "wcwidth"
-version = "0.2.13"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 },
-]