V11.1: Effective methods to use paid functions economically

Question

In the newly released version 11.1, Mathematica introduces three new functions: WebSearch, WebImageSearch and TextTranslation that requires Service Credits. While I haven't found much information about it, there are several characteristics I notice.

• It is a separated service from Cloud Credit, and they do not share credits. (It can be proved by evaluating $ServiceCreditsAvailable and $CloudCreditsAvailable)

• Functions require Service Credits consumes a certain amount of credits on each evaluation locally(a fundamental difference with cloud credits).

• WebSearch and WebImageSearch consume approximately 3 credits per run, while TextTranslation consumes 1 credit per run (at least).

• These functions do not cache the content, even if the queries are the same. (screenshot below)

When writing scripts with such functions, sometimes a bug could cause evaluating expression repeatedly unintentionally. With this possibility, service credits can be used up quickly without notice. With the trend of Wolfram Language integrating more highly automated informational functions with external services, I expect to see more functions of this kind in the future.

So I think having some overall control writing/executing scripts with paid functions are necessary. I thought of function Once to cache the result, in case there are identical calls, credits will be saved. The code illustrating this idea looks like this:

saveMoney[fun_] := 
 Module[{code = DownValues[fun]}, 
  DownValues[fun] = 
   Replace[code, {(h : (WebSearch | WebImageSearch | 
           TextTranslation))[a___] :> Once[h[a]]}, Infinity]]

However, it requires manually applying this function on each symbol defined. And this function has no control when the content string for calls are different. It is also possible to limit the number of times those functions can execute during an evaluation, but I have not tried to implement this yet.

What are some more effective methods(code) to control the unintended usages of those functions?

Answer 1

Run the following code before you start your work or directly add this piece into init.m would solve the problem (at least for a while).

Options@TextTranslation;
Function[{func},
   Once[
    Module[{dv},
     dv = DownValues@func;
     Unprotect@func;

     DownValues[func] = {};
     AppendTo[Options[func], SaveMoney -> True];
     func[content___, opts : OptionsPattern[func]] := 
      If[TrueQ[OptionValue@SaveMoney], Once, Identity][
       ReleaseHold[((# -> OptionValue@# & /@ 
             Options[func][[;; -2, 1]]) /. {optseq__} :> 
            Hold[func[content, optseq]]) /. dv]];

     Protect[func, SaveMoney];
     ]
    ]
   ] /@ {WebSearch, WebImageSearch, TextTranslation};

Or a slightly enhanced version with total Service Credit usage monitoring:

Options@TextTranslation;
$MaxSCUsage = 2(*Adjust the Maximum Service Credit Allowed to use Here!!!*);
$InitSC = $ServiceCreditsAvailable;
Function[{func},
   Once[
    Module[{dv},
     dv = DownValues@func;
     Unprotect@func;

     DownValues[func] = {};
     AppendTo[Options[func], SaveMoney -> True];
     func[content___, opts : OptionsPattern[func]] := 
      With[{sc = $ServiceCreditsAvailable}, 
       If[$InitSC - sc >= $MaxSCUsage, 
        Print["You've used " <> ToString[$InitSC - sc] <> 
          " Service Credits in this Session!!!\nONLY " <> 
          ToString[sc] <> 
          " Service Credits Left!!!\nYOUR WALLET is BLEEDING!!!!!!!!!"];
        Abort[],
        If[TrueQ[OptionValue@SaveMoney], Once, Identity][
         ReleaseHold[((# -> OptionValue@# & /@ 
               Options[func][[;; -2, 1]]) /. {optseq__} :> 
              Hold[func[content, optseq]]) /. dv]]]];

     Protect[func, SaveMoney];
     ]
    ]
   ] /@ {WebSearch, WebImageSearch, TextTranslation};

Let me explain a bit:

• For usage, one can use the extra option SaveMoney with default value True to enable and disable this feature.

• For realization, I used Once to ensure identical TextTranslation would only evaluate once. In the previous result, we can see that duplicative evaluation of TextTranslation would cost no Service Credits and the response is quite sharp(Try it yourself~).(Goal Achieved!)

Hope this feature can really save some precious Service Credits ~ :P

---

Note 1: The previous code could be easily used in almost any occasion where one need to aviod duplicative evaluation(Except those extremely rare cases with both Protected and Locked enabled). Also, one can add the code without any modification to other codes as it add this feature without adding a new function.

Note 2: One can use the following function instead of using the internal TextTranslation(But as it's in some way violating terms of service as xtian777x said, I don't recommend extensive usage). Seriously, its faster and gives similar quality result at least when using google translation.

Now this piece of code aims to translate Chinese to English, a slight upgration of this code can enable multiple language to language translation:

MyTextTranslation[chn_] := 
 StringCases[
   Quiet@URLRead[
     "https://translate.google.com/m?hl=zh-CN&sl=zh-CN&tl=en&ie=UTF-8&\
prev=_m&q=" <> chn, "Body", FollowRedirects -> True, 
     CharacterEncoding -> None], 
   "<div dir=\"ltr\" class=\"t0\">" ~~ Shortest[c__] ~~ "</div>" :> 
    c][[1]]

(Special Note for Chinese users, use .cn instead of .com)

The result is of the same quality as TextTranslate's solution: