sfq 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

sfq/__init__.py

@@ -1,37 +1,91 @@
 import http.client
+import json
 import logging
-import time
 import os
-import json
-from urllib.parse import urlparse, quote
+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")
 
-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",
-    ):
+        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.8",
+        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 "v62.0").
+        :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 (default is 15 minutes).
-        :param proxy: The proxy configuration (default is "auto").
+        :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.8").
+        :param proxy: The proxy configuration, "auto" to use environment (default is "auto").
         """
         self.instance_url = instance_url
         self.client_id = client_id
@@ -41,131 +95,307 @@ class SFAuth:
         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):
+    def _auto_configure_proxy(self, proxy: str) -> None:
         """
-        Automatically configure the proxy based on the environment.
+        Automatically configure the proxy based on the environment or provided value.
         """
         if proxy == "auto":
-            if "https_proxy" in os.environ:
-                self.proxy = os.environ["https_proxy"]
-            else:
-                self.proxy = None
+            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):
-        """Prepare the payload for the token request."""
+    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):
+    def _create_connection(self, netloc: str) -> http.client.HTTPConnection:
         """
-        Create a connection using HTTP or HTTPS, depending on the proxy configuration.
+        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)
-            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_cls = (
+                http.client.HTTPSConnection
+                if proxy_url.scheme != "http"
+                else http.client.HTTPConnection
+            )
+            conn = conn_cls(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 _send_post_request(self, payload):
-        """Send a POST request to the Salesforce token endpoint using http.client."""
+    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 = {"Content-Type": "application/x-www-form-urlencoded"}
-        body = "&".join([f"{key}={quote(str(value))}" for key, value in payload.items()])
+        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)
-            else:
-                logging.error(
-                    f"HTTP error occurred: {response.status} {response.reason}"
-                )
-                logging.error(f"Response content: {data}")
+
+            logger.error(
+                "Token refresh failed: %s %s", response.status, response.reason
+            )
+            logger.debug("Response body: %s", data)
+
         except Exception as err:
-            logging.error(f"Other error occurred: {err}")
+            logger.exception("Error during token request: %s", 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:
+    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
-        
-        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.")
 
+        logger.trace("Access token expired or missing, refreshing...")
         payload = self._prepare_payload()
-        token_data = self._send_post_request(payload)
+        token_data = self._post_token_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
+            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
 
-    def _is_token_expired(self):
-        """Check if the access token has expired."""
+        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 query(self, query, tooling=False):
-        """Query Salesforce using SOQL or Tooling API, depending on the `tooling` parameter."""
+    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:
-            logging.error("No access token available to make the query.")
+            logger.error("No access token available for limits.")
             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}"}
-
-        # Handle special characters in the query
-        encoded_query = quote(query)
-        params = f"?q={encoded_query}"
+        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:
-            conn.request("GET", query_endpoint + params, headers=headers)
+            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)
-            else:
-                logging.error(f"HTTP error occurred during query: {response.status} {response.reason}")
-                logging.error(f"Response content: {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:
-            logging.error(f"Other error occurred during query: {err}")
+            logger.exception("Exception during query: %s", err)
+
         finally:
             conn.close()
 

{sfq-0.0.6.dist-info → sfq-0.0.8.dist-info}/METADATA

@@ -1,20 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sfq
-Version: 0.0.6
+Version: 0.0.8
 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
@@ -114,7 +93,7 @@ To use the `sfq` library, you'll need a **client ID** and **refresh token**. The
      "status": 0,
      "result": {
        "id": "00Daa0000000000000",
-       "apiVersion": "62.0",
+       "apiVersion": "63.0",
        "accessToken": "your-access-token-here",
        "instanceUrl": "https://example-dev-ed.trailblaze.my.salesforce.com",
        "username": "user@example.com",
@@ -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.8.dist-info/RECORD

@@ -0,0 +1,5 @@
+sfq/__init__.py,sha256=MlnlaJCHz4NgL_nudfa15Aman7LdgEtv-hY3G-M731E,15203
+sfq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sfq-0.0.8.dist-info/METADATA,sha256=I1iwzWgydgwKKslNoZvc5y0VjPKytm1R5B1wLXm7VoY,5066
+sfq-0.0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sfq-0.0.8.dist-info/RECORD,,

{sfq-0.0.6.dist-info → sfq-0.0.8.dist-info}/WHEEL

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

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.6.dist-info/RECORD

@@ -1,6 +0,0 @@
-sfq/__init__.py,sha256=V28VeAC89wFw-7DpXajKvAki50bo0yd4CbMWt84APNM,6466
-sfq/__main__.py,sha256=XDb-hRo7jkB3nbHJkQCxL0eUx2Sgl_C3Rr_peuOd6fs,5724
-sfq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfq-0.0.6.dist-info/METADATA,sha256=ab6qxYGmin-YwwxKQU76Ww4JMajhkPw01My8ymxLjIk,5491
-sfq-0.0.6.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-sfq-0.0.6.dist-info/RECORD,,