{"id":1191,"date":"2024-04-25T03:31:28","date_gmt":"2024-04-25T03:31:28","guid":{"rendered":"https:\/\/www.nicekj.com\/?p=1191"},"modified":"2024-04-25T03:31:43","modified_gmt":"2024-04-25T03:31:43","slug":"aixieceshiyongli","status":"publish","type":"post","link":"https:\/\/www.nicekj.com\/aixieceshiyongli.html","title":{"rendered":"AI\u5199\u6d4b\u8bd5\u7528\u4f8b"},"content":{"rendered":"

\u4e00\u3001\u7528ChatGPT\u76f4\u63a5\u751f\u6210\u7684\u6d4b\u8bd5\u7528\u4f8b<\/h2>\n

\u8981\u5199\u6d4b\u8bd5\uff0c\u6211\u4eec\u8981\u5148\u6709\u4e00\u4e2a\u7a0b\u5e8f\u3002\u4e3a\u4e86\u907f\u514d\u8fd9\u4e2a\u9898\u76ee\u672c\u8eab\u5c31\u5728AI\u7684\u8bad\u7ec3\u6570\u636e\u96c6\u91cc\u9762\uff0c\u5b83\u76f4\u63a5\u77e5\u9053\u7b54\u6848\u3002<\/p>\n

\u6211\u4eec\u7528\u4e00\u4e2a\u6709\u610f\u601d\u7684\u5c0f\u9898\u76ee\uff0c\u4e5f\u5c31\u662f\u8ba9Python\u6839\u636e\u6211\u4eec\u8f93\u5165\u7684\u4e00\u4e2a\u6574\u6570\u4ee3\u8868\u7684\u5929\u6570\uff0c\u683c\u5f0f\u5316\u6210\u4e00\u6bb5\u81ea\u7136\u8bed\u8a00\u63cf\u8ff0\u7684\u65f6\u95f4\u3002\u6761\u4ef6\u5b9a\u4e49\uff1a1\u4e2a\u661f\u671f\u662f7\u5929\uff0c1\u4e2a\u6708\u662f30\u5929\uff0c1\u5e74\u662f365\u5929\u3002\u6bd4\u5982\uff0c\u8f93\u51651\u5c31\u8fd4\u56de1d\uff0c\u8f93\u51658\u5c31\u8fd4\u56de1w1d\uff0c\u8f93\u516532\u5c31\u8fd4\u56de1m2d\uff0c\u8f93\u5165375\u5c31\u8fd4\u56de1y1w3d\u3002<\/p>\n

\u9700\u6c42\uff1a<\/p>\n

<\/div>
js<\/span>
\u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>\u7528Python<\/span>\u5199\u4e00\u4e2a\u51fd\u6570\uff0c\u8fdb\u884c\u65f6\u95f4\u683c\u5f0f\u5316\u8f93\u51fa\uff0c\u6761\u4ef6\u5b9a\u4e49\u4e3a1<\/span>\u4e2a\u661f\u671f\u662f7<\/span>\u5929\uff0c1<\/span>\u4e2a\u6708\u662f30<\/span>\u5929\uff0c1<\/span>\u5e74\u662f365<\/span>\u5929\u3002\u6bd4\u5982\uff1a<\/span>\n\u8f93\u5165  \u8f93\u51fa<\/span>\n1<\/span>     1d<\/span>\n8<\/span>     1w1d<\/span>\n61<\/span>    2m1d<\/span>\n375<\/span>   1y1w3d<\/span>\n\u8981\u6c42\u4ec5\u9700\u8981\u683c\u5f0f\u5316\u5230\u5e74(?y?m?w?d)\uff0c\u5373\u53ef<\/span>\n<\/code><\/pre>\n
\u6211\u4eec\u76f4\u63a5\u8ba9ChatGPT\u628a\u7a0b\u5e8f\u5199\u597d\u5982\u4e0b\uff1a<\/p>\n
\n
\"image.png\"<\/figure>\n<\/p>\n
\u65e2\u7136ChatGPT\u53ef\u4ee5\u5199\u4ee3\u7801\uff0c\u81ea\u7136\u4e5f\u53ef\u4ee5\u8ba9\u5b83\u5e2e\u6211\u4eec\u628a\u5355\u5143\u6d4b\u8bd5\u4e5f\u5199\u597d\uff0c\u5982\u4e0b\uff1a<\/p>\n
\n
\"image.png\"<\/figure>\n<\/p>\n
\n
\"image.png\"<\/figure>\n<\/p>\n
\u8fd9\u4e2a\u6d4b\u8bd5\u7528\u4f8b\u8986\u76d6\u7684\u573a\u666f\u5176\u5b9e\u5df2\u7ecf\u5f88\u5168\u9762\u4e86\uff0c\u65e2\u5305\u542b\u4e86\u57fa\u672c\u7684\u529f\u80fd\u9a8c\u8bc1\u6d4b\u8bd5\u7528\u4f8b\uff0c\u4e5f\u5305\u542b\u4e86\u4e00\u4e9b\u5f02\u5e38\u7684\u6d4b\u8bd5\u7528\u4f8b\u3002<\/p>\n
\u4e8c\u3001\u57fa\u4e8eOpenai\u63a5\u53e3\u8fdb\u884c\u8fc7\u7a0b\u9a8c\u8bc1<\/h2>\n
2.1\u3001\u5206\u89e3\u6b65\u9aa4\u5199Prompts<\/h3>\n
OpenAI\u7684\u793a\u4f8b\u7ed9\u51fa\u4e86\u5f88\u597d\u7684\u601d\u8def\uff0c\u90a3\u5c31\u662f\u628a\u95ee\u9898\u62c6\u5206\u6210\u591a\u4e2a\u6b65\u9aa4\u3002<\/p>\n
    \n
  • \u628a\u4ee3\u7801\u4ea4\u7ed9\u5927\u8bed\u8a00\u6a21\u578b\uff0c\u8ba9\u5927\u8bed\u8a00\u6a21\u578b\u89e3\u91ca\u4e00\u4e0b\uff0c\u8fd9\u4e2a\u4ee3\u7801\u662f\u5728\u5e72\u4ec0\u4e48\u3002<\/li>\n
  • \u628a\u4ee3\u7801\u548c\u4ee3\u7801\u7684\u89e3\u91ca\u4e00\u8d77\u4ea4\u7ed9\u5927\u8bed\u8a00\u6a21\u578b\uff0c\u8ba9\u5927\u8bed\u8a00\u6a21\u578b\u89c4\u5212\u4e00\u4e0b\uff0c\u9488\u5bf9\u8fd9\u4e2a\u4ee3\u7801\u903b\u8f91\uff0c\u6211\u4eec\u5230\u5e95\u8981\u5199\u54ea\u51e0\u4e2aTestCase\u3002\u5982\u679c\u6570\u91cf\u592a\u5c11\uff0c\u53ef\u4ee5\u91cd\u590d\u8ba9AI\u591a\u751f\u6210\u51e0\u4e2aTestCase\u3002<\/li>\n
  • \u9488\u5bf9TestCase\u7684\u8be6\u7ec6\u63cf\u8ff0\uff0c\u518d\u63d0\u4ea4\u7ed9\u5927\u8bed\u8a00\u6a21\u578b\uff0c\u8ba9\u5b83\u6839\u636e\u8fd9\u4e9b\u63cf\u8ff0\u751f\u6210\u5177\u4f53\u7684\u6d4b\u8bd5\u4ee3\u7801\u3002\u5bf9\u4e8e\u751f\u6210\u7684\u4ee3\u7801\uff0c\u6211\u4eec\u8fd8\u8981\u8fdb\u884c\u4e00\u6b21\u8bed\u6cd5\u68c0\u67e5\uff0c\u5982\u679c\u8bed\u6cd5\u68c0\u67e5\u90fd\u6ca1\u6cd5\u901a\u8fc7\uff0c\u6211\u4eec\u5c31\u8ba9AI\u91cd\u65b0\u518d\u751f\u6210\u4e00\u4e0b\u3002<\/li>\n<\/ul>\n
    2.2\u3001\u8bf7AI\u89e3\u91ca\u8981\u6d4b\u8bd5\u7684\u4ee3\u7801<\/h3>\n
    <\/div>
    ini<\/span>
    \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>import openai<\/span>\n<\/span>\n<\/span>\ndef gpt35(prompt, model<\/span>=\"text-davinci-002\"<\/span>, temperature=0.4<\/span>, max_tokens=1000<\/span>,<\/span>\n          top_p<\/span>=1<\/span>, stop=[\"nn\"<\/span>, \"ntn\"<\/span>, \"n    n\"<\/span>]):<\/span>\n    response<\/span> = openai.Completion.create(<\/span>\n        model<\/span>=model,<\/span>\n        prompt<\/span>=prompt,<\/span>\n        temperature<\/span>=temperature,<\/span>\n        max_tokens<\/span>=max_tokens,<\/span>\n        top_p<\/span>=top_p,<\/span>\n        stop<\/span>=stop<\/span>\n    )<\/span>\n    message<\/span> = response[\"choices\"<\/span>][0<\/span>][\"text\"<\/span>]<\/span>\n    return message<\/span>\n<\/span>\n<\/span>\ncode<\/span> = \"\"\"<\/span><\/span>\ndef format_time(days):<\/span>\n    years, days = divmod(days, 365)<\/span>\n    months, days = divmod(days, 30)<\/span>\n    weeks, days = divmod(days, 7)<\/span>\n    time_str = \"\"<\/span>\n    if years > 0:<\/span>\n        time_str += str(years) + \"y\"<\/span>\n    if months > 0:<\/span>\n        time_str += str(months) + \"m\"<\/span>\n    if weeks > 0:<\/span>\n        time_str += str(weeks) + \"w\"<\/span>\n    if days > 0:<\/span>\n        time_str += str(days) + \"d\"<\/span>\n    return time_str<\/span>\n\"\"\"<\/span>\n<\/span>\n<\/span>\ndef explain_code(function_to_test, unit_test_package<\/span>=\"pytest\"<\/span>):<\/span>\n    prompt<\/span> = f\"\"\"\"# How to write great unit tests with {unit_test_package}<\/span><\/span>\n<\/span>\nIn this advanced tutorial for experts, we'll use Python 3.8 and `{unit_test_package}` to write a suite of unit tests to verify the behavior of the following function.<\/span>\n```python<\/span>\n{function_to_test}<\/span>\n<\/span>\n<\/span>\nBefore writing any unit tests, let's review what each element of the function is doing exactly and what the author's intentions may have been.<\/span>\n- First,\"\"\"<\/span>\n    response<\/span> = gpt35(prompt)<\/span>\n    return response, prompt<\/span>\n<\/span>\n<\/span>\ncode_explaination, prompt_to_explain_code<\/span> = explain_code(code)<\/span>\nprint(code_explaination)<\/span>\n<\/code><\/pre>\n
    \u9996\u5148\u5b9a\u4e49\u4e86\u4e00\u4e2agpt35\u7684\u51fd\u6570\uff0c\u8fd9\u4e2a\u51fd\u6570\u7684\u4f5c\u7528\u5982\u4e0b\uff1a<\/p>\n
      \n
    1. \u4f7f\u7528 text-davinci-002 \u6a21\u578b\uff0c\u8fd9\u662f\u4e00\u4e2a\u901a\u8fc7\u76d1\u7763\u5b66\u4e60\u5fae\u8c03\u7684\u751f\u6210\u6587\u672c\u7684\u6a21\u578b\uff0c\u5e0c\u671b\u751f\u6210\u76ee\u6807\u660e\u786e\u7684\u6587\u672c\u4ee3\u7801\u89e3\u91ca\u3002<\/li>\n
    2. \u5bf9 stop \u505a\u4e86\u7279\u6b8a\u7684\u8bbe\u7f6e\uff0c\u53ea\u8981\u8fde\u7eed\u4e24\u4e2a\u6362\u884c\u6216\u8005\u7c7b\u4f3c\u8fde\u7eed\u4e24\u4e2a\u6362\u884c\u7684\u60c5\u51b5\u51fa\u73b0\uff0c\u5c31\u4e2d\u6b62\u6570\u636e\u7684\u751f\u6210\uff0c\u907f\u514d\u6a21\u578b\u4e00\u53e3\u6c14\u8fde\u6d4b\u8bd5\u4ee3\u7801\u4e5f\u751f\u6210\u51fa\u6765\u3002<\/li>\n<\/ol>\n
      \u7136\u540e\uff0c\u901a\u8fc7\u4e00\u7ec4\u7cbe\u5fc3\u8bbe\u8ba1\u7684\u63d0\u793a\u8bed\uff0c\u8ba9GPT\u6a21\u578b\u4e3a\u6211\u4eec\u6765\u89e3\u91ca\u4ee3\u7801\u3002<\/p>\n
        \n
      • \u6307\u5b9a\u4f7f\u7528pytest\u7684\u6d4b\u8bd5\u5305\u3002<\/li>\n
      • \u628a\u5bf9\u5e94\u7684\u6d4b\u8bd5\u4ee3\u7801\u63d0\u4f9b\u7ed9GPT\u6a21\u578b\u3002<\/li>\n
      • \u8ba9AI\u56de\u7b54\uff0c\u8981\u7cbe\u786e\u63cf\u8ff0\u4ee3\u7801\u505a\u4e86\u4ec0\u4e48\u3002<\/li>\n
      • \u6700\u540e\u7528 \u201c-First\u201d \u5f00\u5934\uff0c\u5f15\u5bfcGPT\u6a21\u578b\uff0c\u9010\u6b65\u5206\u884c\u63cf\u8ff0\u8981\u6d4b\u8bd5\u7684\u4ee3\u7801\u3002<\/li>\n<\/ul>\n
        \u8f93\u51fa\u7ed3\u679c\uff1a<\/p>\n
        <\/div>
        js<\/span>
        \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div> the function<\/span> takes an integer value representing days as<\/span> its sole argument.<\/span>\n- Next<\/span>, the `divmod`<\/span> function<\/span> is used to calculate the number of<\/span> years and days, the number of<\/span> months and days, and the number of<\/span> weeks and days.<\/span>\n- Finally<\/span>, a string is built up and returned that contains the number of<\/span> years, months, weeks, and days.<\/span>\n<\/code><\/pre>\n
        2.3\u3001\u8ba9AI\u6839\u636e\u4ee3\u7801\u89e3\u91ca\u5236\u5b9a\u6d4b\u8bd5\u8ba1\u5212<\/h3>\n
        <\/div>
        ini<\/span>
        \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>def generate_a_test_plan(full_code_explaination, unit_test_package<\/span>=\"pytest\"<\/span>):<\/span>\n    prompt_to_explain_a_plan<\/span> = f\"\"\"<\/span><\/span>\n<\/span>\nA good unit test suite should aim to:<\/span>\n- Test the function's behavior for a wide range of possible inputs<\/span>\n- Test edge cases that the author may not have foreseen<\/span>\n- Take advantage of the features of `{unit_test_package}` to make the tests easy to write and maintain<\/span>\n- Be easy to read and understand, with clean code and descriptive names<\/span>\n- Be deterministic, so that the tests always pass or fail in the same way<\/span>\n<\/span>\n`{unit_test_package}` has many convenient features that make it easy to write and maintain unit tests. We'll use them to write unit tests for the function above.<\/span>\n<\/span>\nFor this particular function, we'll want our unit tests to handle the following diverse scenarios (and under each scenario, we include a few examples as sub-bullets):<\/span>\n-\"\"\"<\/span>\n    prompt<\/span> = full_code_explaination+prompt_to_explain_a_plan<\/span>\n    response<\/span> = gpt35(prompt)<\/span>\n    return response, prompt<\/span>\n<\/span>\n<\/span>\ntest_plan, prompt_to_get_test_plan<\/span> = generate_a_test_plan(prompt_to_explain_code+code_explaination)<\/span>\nprint(test_plan)<\/span>\n<\/code><\/pre>\n
        \u9488\u5bf9\u751f\u6210\u7684\u6d4b\u8bd5\u8ba1\u5212\uff0c\u5bf9AI\u5236\u5b9a\u4e86\u51e0\u70b9\u8981\u6c42\uff1a<\/p>\n
          \n
        • \u6d4b\u8bd5\u7528\u4f8b\u8981\u8986\u76d6\u66f4\u5e7f\u7684\u8303\u56f4\u3002<\/li>\n
        • \u6d4b\u8bd5\u7528\u4f8b\u7684\u8fb9\u754c\u8981\u6d89\u53ca\u5230\u4f5c\u8005\u65e0\u6cd5\u60f3\u5230\u7684\u573a\u666f\u3002<\/li>\n
        • \u5145\u5206\u5229\u7528pytest\u7684\u7279\u6027\u3002<\/li>\n
        • \u786e\u4fdd\u6d4b\u8bd5\u7528\u4f8b\u7b80\u6d01\u3001\u6613\u7406\u89e3\u3002<\/li>\n
        • \u6d4b\u8bd5\u7528\u4f8b\u7684\u7ed3\u679c\u662f\u786e\u5b9a\u7684\uff0c\u8981\u4e48\u6210\u529f\u3001\u8981\u4e48\u5931\u8d25\u3002<\/li>\n<\/ul>\n
          \u8f93\u51fa\u7ed3\u679c\uff1a<\/p>\n
          <\/div>
          js<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div> Normal<\/span> inputs<\/span>:<\/span>\n    - `days`<\/span> is a positive integer<\/span>\n    - `days`<\/span> is 0<\/span><\/span>\n- Edge<\/span> cases<\/span>:<\/span>\n    - `days`<\/span> is a negative integer<\/span>\n    - `days`<\/span> is a float<\/span>\n    - `days`<\/span> is a string<\/span>\n- Invalid<\/span> inputs<\/span>:<\/span>\n    - `days`<\/span> is `None`<\/span><\/span>\n    - `days`<\/span> is a list<\/span>\n<\/code><\/pre>\n
          2.4\u3001\u6839\u636e\u6d4b\u8bd5\u8ba1\u5212\u751f\u6210\u6d4b\u8bd5\u4ee3\u7801<\/h3>\n
          <\/div>
          ini<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>def generate_test_cases(function_to_test, unit_test_package<\/span>=\"pytest\"<\/span>):<\/span>\n    starter_comment<\/span> = \"Below, each test case is represented by a tuple passed to the @pytest.mark.parametrize decorator\"<\/span><\/span>\n    prompt_to_generate_the_unit_test<\/span> = f\"\"\"<\/span><\/span>\n<\/span>\nBefore going into the individual tests, let's first look at the complete suite of unit tests as a cohesive whole. We've added helpful comments to explain what each line does.<\/span>\n```python<\/span>\nimport {unit_test_package}  # used for our unit tests<\/span>\n<\/span>\n{function_to_test}<\/span>\n<\/span>\n#{starter_comment}\"\"\"<\/span>\n    full_unit_test_prompt<\/span> = prompt_to_explain_code + code_explaination + test_plan + prompt_to_generate_the_unit_test<\/span>\n    return gpt35(model<\/span>=\"text-davinci-003\"<\/span>, prompt=full_unit_test_prompt, stop=\"```\"<\/span>), prompt_to_generate_the_unit_test<\/span>\n<\/span>\n<\/span>\nunit_test_response, prompt_to_generate_the_unit_test<\/span> = generate_test_cases(code)<\/span>\nprint(unit_test_response)<\/span>\n<\/code><\/pre>\n
          \u8f93\u51fa\u7ed3\u679c\uff1a<\/p>\n
          <\/div>
          js<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>@pytest.mark<\/span>.parametrize<\/span>(\"days, expected\"<\/span>, [<\/span>\n    (1<\/span>, \"1d\"<\/span>),  # normal input<\/span>\n    (7<\/span>, \"1w\"<\/span>),  # normal input<\/span>\n    (30<\/span>, \"1m\"<\/span>),  # normal input<\/span>\n    (365<\/span>, \"1y\"<\/span>),  # normal input<\/span>\n    (731<\/span>, \"2y\"<\/span>),  # normal input<\/span>\n    (-1<\/span>, pytest.raises<\/span>(ValueError<\/span>)),  # abnormal input<\/span>\n    (0<\/span>, pytest.raises<\/span>(ValueError<\/span>)),  # abnormal input<\/span>\n    (1.5<\/span>, pytest.raises<\/span>(TypeError<\/span>)),  # abnormal input<\/span>\n    (\"1\"<\/span>, pytest.raises<\/span>(TypeError<\/span>)),  # abnormal input<\/span>\n])<\/span>\ndef test_format_time<\/span>(days, expected):<\/span>\n    \"\"<\/span>\"<\/span><\/span>\n    Test the format_time() function.<\/span>\n    \"\"\"<\/span><\/span>\n    if<\/span> isinstance<\/span>(expected, type):<\/span>\n        # check that the expected result is a type, i.e<\/span>. an exception<\/span>\n        with<\/span> pytest.raises<\/span>(expected):<\/span>\n            # if<\/span> so, check that the function<\/span> raises the expected exception<\/span>\n            format_time<\/span>(days)<\/span>\n    else<\/span>:<\/span>\n        # otherwise, check that the function<\/span> returns the expected value<\/span>\n        assert format_time<\/span>(days) == expected<\/span>\n<\/code><\/pre>\n
          2.5\u3001\u901a\u8fc7AST\u5e93\u8fdb\u884c\u8bed\u6cd5\u68c0\u67e5<\/h3>\n
          \u6700\u540e\u6211\u4eec\u6700\u597d\u8fd8\u662f\u8981\u518d\u68c0\u67e5\u4e00\u4e0b\u751f\u6210\u7684\u6d4b\u8bd5\u4ee3\u7801\u8bed\u6cd5\uff0c\u8fd9\u4e2a\u53ef\u4ee5\u901a\u8fc7Python\u7684AST\u5e93\u6765\u5b8c\u6210\u3002\u68c0\u67e5\u4ee3\u7801\u7684\u65f6\u5019\uff0c\u6211\u4eec\u4e0d\u4ec5\u9700\u8981\u751f\u6210\u7684\u6d4b\u8bd5\u4ee3\u7801\uff0c\u4e5f\u9700\u8981\u539f\u6765\u7684\u529f\u80fd\u4ee3\u7801\uff0c\u4e0d\u7136\u65e0\u6cd5\u901a\u8fc7\u8bed\u6cd5\u68c0\u67e5\u3002<\/p>\n
          <\/div>
          js<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div><\/span>\nimport<\/span> ast<\/span>\n<\/span>\ncode_start_index = prompt_to_generate_the_unit_test.find<\/span>(\"```pythonn\"<\/span>) + len<\/span>(\"```pythonn\"<\/span>)<\/span>\ncode_output = prompt_to_generate_the_unit_test[code_start_index<\/span>:] + unit_test_response<\/span>\ntry<\/span>:<\/span>\n    ast.parse<\/span>(code_output)<\/span>\nexcept SyntaxError<\/span> as<\/span> e<\/span>:<\/span>\n    print<\/span>(f\"Syntax error in generated code: {e}\"<\/span>)<\/span>\n<\/span>\nprint<\/span>(code_output)<\/span>\n<\/span>\n<\/code><\/pre>\n
          \u8f93\u51fa\u7ed3\u679c\uff1a<\/p>\n
          <\/div>
          js<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>import<\/span> pytest  # used for<\/span> our unit tests<\/span>\n<\/span>\n<\/span>\ndef format_time<\/span>(days):<\/span>\n    years, days = divmod<\/span>(days, 365<\/span>)<\/span>\n    months, days = divmod<\/span>(days, 30<\/span>)<\/span>\n    weeks, days = divmod<\/span>(days, 7<\/span>)<\/span>\n    time_str = \"\"<\/span><\/span>\n    if<\/span> years > 0<\/span>:<\/span>\n        time_str += str<\/span>(years) + \"y\"<\/span><\/span>\n    if<\/span> months > 0<\/span>:<\/span>\n        time_str += str<\/span>(months) + \"m\"<\/span><\/span>\n    if<\/span> weeks > 0<\/span>:<\/span>\n        time_str += str<\/span>(weeks) + \"w\"<\/span><\/span>\n    if<\/span> days > 0<\/span>:<\/span>\n        time_str += str<\/span>(days) + \"d\"<\/span><\/span>\n    return<\/span> time_str<\/span>\n<\/span>\n<\/span>\n#Below<\/span>, each test case<\/span> is represented by a tuple passed to the @pytest.mark<\/span>.parametrize<\/span> decorator.<\/span>\n#The<\/span> first element of<\/span> the tuple is the name of<\/span> the test case<\/span>, and the second element is a list of<\/span> arguments<\/span> to pass to the function<\/span>.<\/span>\n#The<\/span> @pytest.mark<\/span>.parametrize<\/span> decorator allows us to write a single test function<\/span> that can be used to test multiple input values.<\/span>\n@pytest.mark<\/span>.parametrize<\/span>(\"test_input,expected\"<\/span>, [<\/span>\n    (\"Valid Inputs\"<\/span>, [<\/span>\n        (0<\/span>, \"0d\"<\/span>),  # test for<\/span> 0<\/span> days<\/span>\n        (1<\/span>, \"1d\"<\/span>),  # test for<\/span> 1<\/span> day<\/span>\n        (7<\/span>, \"7d\"<\/span>),  # test for<\/span> 7<\/span> days<\/span>\n        (30<\/span>, \"1m\"<\/span>),  # test for<\/span> 30<\/span> days<\/span>\n        (365<\/span>, \"1y\"<\/span>),  # test for<\/span> 365<\/span> days<\/span>\n        (400<\/span>, \"1y35d\"<\/span>),  # test for<\/span> 400<\/span> days<\/span>\n        (800<\/span>, \"2y160d\"<\/span>),  # test for<\/span> 800<\/span> days<\/span>\n        (3650<\/span>, \"10y\"<\/span>),  # test for<\/span> 3650<\/span> days<\/span>\n        (3651<\/span>, \"10y1d\"<\/span>),  # test for<\/span> 3651<\/span> days<\/span>\n    ]),<\/span>\n    (\"Invalid Inputs\"<\/span>, [<\/span>\n        (\"string\"<\/span>, None<\/span>),  # test for<\/span> string input<\/span>\n        ([], None<\/span>),  # test for<\/span> list input<\/span>\n        ((), None<\/span>),  # test for<\/span> tuple input<\/span>\n        ({}, None<\/span>),  # test for<\/span> set input<\/span>\n        ({1<\/span>: 1<\/span>}, None<\/span>),  # test for<\/span> dictionary input<\/span>\n        (1.5<\/span>, None<\/span>),  # test for<\/span> float input<\/span>\n        (None<\/span>, None<\/span>),  # test for<\/span> None<\/span> input<\/span>\n    ]),<\/span>\n    (\"Edge Cases\"<\/span>, [<\/span>\n        (10000000000<\/span>, \"274247y5m2w6d\"<\/span>),  # test for<\/span> large positive integer<\/span>\n        (1<\/span>, \"1d\"<\/span>),  # test for<\/span> small positive integer<\/span>\n        (-10000000000<\/span>, \"-274247y5m2w6d\"<\/span>),  # test for<\/span> large negative integer<\/span>\n        (-1<\/span>, \"-1d\"<\/span>)  # test for<\/span> small negative integer<\/span>\n    ])<\/span>\n])<\/span>\ndef test_format_time<\/span>(test_input, expected):<\/span>\n    # This<\/span> test function<\/span> uses the @pytest.mark<\/span>.parametrize<\/span> decorator to loop through each test case<\/span>.<\/span>\n    # The<\/span> test_input parameter contains the name of<\/span> the test case<\/span>, and the expected parameter contains a list of<\/span> arguments<\/span> to pass to the function<\/span>.<\/span>\n    # The<\/span> test_input parameter is not used in<\/span> the test, but is included for<\/span> readability.<\/span>\n    for<\/span> days, expected_result in<\/span> expected<\/span>:<\/span>\n        # For<\/span> each argument in<\/span> the expected parameter, we call the format_time<\/span>() function<\/span> and compare the result to the expected result.<\/span>\n        assert format_time<\/span>(days) == expected_result<\/span>\n<\/code><\/pre>\n
          \u4ece\u4e0a\u9762\u770b\u5230\u6709\u4e9b\u6d4b\u8bd5\u7528\u4f8b\u8ddf\u9884\u671f\u8fd8\u662f\u6709\u5dee\u8ddd\u7684\uff0c\u6bd4\u5982:<\/p>\n
          <\/div>
          js<\/span>
          \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>@pytest.mark<\/span>.parametrize<\/span>(\"test_input,expected\"<\/span>, [<\/span>\n    (\"Valid Inputs\"<\/span>, [<\/span>\n        (7<\/span>, \"7d\"<\/span> -> \"1w\"<\/span>),  # test for<\/span> 7<\/span> days<\/span>\n        (30<\/span>, \"1m\"<\/span>),  # test for<\/span> 30<\/span> days<\/span>\n        (365<\/span>, \"1y\"<\/span>),  # test for<\/span> 365<\/span> days<\/span>\n        (400<\/span>, \"1y35d\"<\/span> -> \"1y1m5d\"<\/span>),  # test for<\/span> 400<\/span> days<\/span>\n        (800<\/span>, \"2y160d\"<\/span> -> \"2y5m1w3d\"<\/span>),  # test for<\/span> 800<\/span> days<\/span>\n        (3650<\/span>, \"10y\"<\/span>),  # test for<\/span> 3650<\/span> days<\/span>\n        (3651<\/span>, \"10y1d\"<\/span>),  # test for<\/span> 3651<\/span> days<\/span>\n    ]),<\/span>\n<\/code><\/pre>\n
          \u4e09\u3001\u7528LangChain\u8fdb\u4e00\u6b65\u5c01\u88c5<\/h2>\n
          OpenAI \u7684\u5927\u8bed\u8a00\u6a21\u578b\uff0c\u53ea\u662f\u63d0\u4f9b\u4e86\u7b80\u7b80\u5355\u5355\u7684 Completion \u548c Embedding \u8fd9\u6837\u4e24\u4e2a\u6838\u5fc3\u63a5\u53e3\uff0c\u901a\u8fc7\u5408\u7406\u4f7f\u7528\u8fd9\u4e24\u4e2a\u63a5\u53e3\uff0c\u6211\u4eec\u5b8c\u6210\u4e86\u5404\u79cd\u5404\u6837\u590d\u6742\u7684\u4efb\u52a1\u3002<\/p>\n
            \n
          • \u901a\u8fc7\u63d0\u793a\u8bed\uff08Prompt\uff09\u91cc\u5305\u542b\u5386\u53f2\u7684\u804a\u5929\u8bb0\u5f55\uff0c\u6211\u4eec\u80fd\u591f\u8ba9 AI \u6839\u636e\u4e0a\u4e0b\u6587\u6b63\u786e\u5730\u56de\u7b54\u95ee\u9898\u3002<\/li>\n
          • \u901a\u8fc7\u5c06 Embedding \u63d0\u524d\u7d22\u5f15\u597d\u5b58\u8d77\u6765\uff0c\u6211\u4eec\u80fd\u591f\u8ba9 AI \u6839\u636e\u5916\u90e8\u77e5\u8bc6\u56de\u7b54\u95ee\u9898\u3002<\/li>\n
          • \u800c\u901a\u8fc7\u591a\u8f6e\u5bf9\u8bdd\uff0c\u5c06 AI \u8fd4\u56de\u7684\u7b54\u6848\u653e\u5728\u65b0\u7684\u95ee\u9898\u91cc\uff0c\u6211\u4eec\u80fd\u591f\u8ba9 AI \u5e2e\u6211\u4eec\u7ed9\u81ea\u5df1\u7684\u4ee3\u7801\u64b0\u5199\u5355\u5143\u6d4b\u8bd5\u3002<\/li>\n<\/ul>\n
            llama-index \u4e13\u6ce8\u4e8e\u4e3a\u5927\u8bed\u8a00\u6a21\u578b\u7684\u5e94\u7528\u6784\u5efa\u7d22\u5f15\uff0c\u867d\u7136 Langchain \u4e5f\u6709\u7c7b\u4f3c\u7684\u529f\u80fd\uff0c\u4f46\u8fd9\u4e00\u70b9\u5e76\u4e0d\u662f Langchain \u7684\u4e3b\u8981\u5356\u70b9\u3002Langchain \u7684\u7b2c\u4e00\u4e2a\u5356\u70b9\u5176\u5b9e\u5c31\u5728\u5b83\u7684\u540d\u5b57\u91cc\uff0c\u4e5f\u5c31\u662f\u94fe\u5f0f\u8c03\u7528\u3002<\/p>\n
            3.1\u3001\u901a\u8fc7 Langchain \u5b9e\u73b0\u81ea\u52a8\u5316\u64b0\u5199\u5355\u5143\u6d4b\u8bd5<\/h3>\n
            \u4e0a\u9762\u901a\u8fc7\u591a\u6b65\u63d0\u793a\u8bed\u81ea\u52a8\u7ed9\u4ee3\u7801\u5199\u5355\u5143\u6d4b\u8bd5\u3002Langchain\u53ef\u4ee5\u987a\u5e8f\u5730\u901a\u8fc7\u591a\u4e2aPrompt\u8c03\u7528OpenAI\u7684GPT\u6a21\u578b\uff0c\u8fd9\u4e2a\u80fd\u529b\u7528\u6765\u5b9e\u73b0\u81ea\u52a8\u5316\u6d4b\u8bd5\u7684\u529f\u80fd\u6b63\u597d\u5339\u914d\u3002<\/p>\n
            <\/div>
            ini<\/span>
            \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>from langchain import PromptTemplate, OpenAI, LLMChain<\/span>\nfrom langchain.chains import SequentialChain<\/span>\nimport ast<\/span>\n<\/span>\n<\/span>\ndef write_unit_test(function_to_test, unit_test_package<\/span>=\"pytest\"<\/span>):<\/span>\n    # \u89e3\u91ca\u6e90\u4ee3\u7801\u7684\u6b65\u9aa4<\/span><\/span>\n    explain_code<\/span> = \"\"\"\"# How to write great unit tests with {unit_test_package}<\/span><\/span>\n<\/span>\n    In this advanced tutorial for experts, we'll use Python 3.8 and `{unit_test_package}` to write a suite of unit tests to verify the behavior of the following function.<\/span>\n    ```python<\/span>\n    {function_to_test}<\/span>\n    ```<\/span>\n<\/span>\n    Before writing any unit tests, let's review what each element of the function is doing exactly and what the author's intentions may have been.<\/span>\n    - First,\"\"\"<\/span>\n<\/span>\n    explain_code_template<\/span> = PromptTemplate(<\/span>\n        input_variables<\/span>=[\"unit_test_package\"<\/span>, \"function_to_test\"<\/span>],<\/span>\n        template<\/span>=explain_code<\/span>\n    )<\/span>\n    explain_code_llm<\/span> = OpenAI(model_name=\"text-davinci-002\"<\/span>, temperature=0.4<\/span>, max_tokens=1000<\/span>,<\/span>\n                              top_p<\/span>=1<\/span>, stop=[\"nn\"<\/span>, \"ntn\"<\/span>, \"n    n\"<\/span>])<\/span>\n    explain_code_step<\/span> = LLMChain(llm=explain_code_llm, prompt=explain_code_template, output_key=\"code_explaination\"<\/span>)<\/span>\n<\/span>\n    # \u521b\u5efa\u6d4b\u8bd5\u8ba1\u5212\u793a\u4f8b\u7684\u6b65\u9aa4<\/span><\/span>\n    test_plan<\/span> = \"\"\"<\/span><\/span>\n<\/span>\n    A good unit test suite should aim to:<\/span>\n    - Test the function's behavior for a wide range of possible inputs<\/span>\n    - Test edge cases that the author may not have foreseen<\/span>\n    - Take advantage of the features of `{unit_test_package}` to make the tests easy to write and maintain<\/span>\n    - Be easy to read and understand, with clean code and descriptive names<\/span>\n    - Be deterministic, so that the tests always pass or fail in the same way<\/span>\n<\/span>\n    `{unit_test_package}` has many convenient features that make it easy to write and maintain unit tests. We'll use them to write unit tests for the function above.<\/span>\n<\/span>\n    For this particular function, we'll want our unit tests to handle the following diverse scenarios (and under each scenario, we include a few examples as sub-bullets):<\/span>\n    -\"\"\"<\/span>\n<\/span>\n    test_plan_template<\/span> = PromptTemplate(<\/span>\n        input_variables<\/span>=[\"unit_test_package\"<\/span>, \"function_to_test\"<\/span>, \"code_explaination\"<\/span>],<\/span>\n        template<\/span>=explain_code+\"{code_explaination}\"<\/span>+test_plan<\/span>\n    )<\/span>\n    test_plan_llm<\/span> = OpenAI(model_name=\"text-davinci-002\"<\/span>, temperature=0.4<\/span>, max_tokens=1000<\/span>,<\/span>\n                           top_p<\/span>=1<\/span>, stop=[\"nn\"<\/span>, \"ntn\"<\/span>, \"n    n\"<\/span>])<\/span>\n    test_plan_step<\/span> = LLMChain(llm=test_plan_llm, prompt=test_plan_template, output_key=\"test_plan\"<\/span>)<\/span>\n<\/span>\n    # \u64b0\u5199\u6d4b\u8bd5\u4ee3\u7801\u7684\u6b65\u9aa4<\/span><\/span>\n    starter_comment<\/span> = \"Below, each test case is represented by a tuple passed to the @pytest.mark.parametrize decorator\"<\/span><\/span>\n    prompt_to_generate_the_unit_test<\/span> = \"\"\"<\/span><\/span>\n<\/span>\nBefore going into the individual tests, let's first look at the complete suite of unit tests as a cohesive whole. We've added helpful comments to explain what each line does.<\/span>\n```python<\/span>\nimport {unit_test_package}  # used for our unit tests<\/span>\n<\/span>\n{function_to_test}<\/span>\n<\/span>\n#{starter_comment}\"\"\"<\/span>\n<\/span>\n    unit_test_template<\/span> = PromptTemplate(<\/span>\n        input_variables<\/span>=[\"unit_test_package\"<\/span>, \"function_to_test\"<\/span>, \"code_explaination\"<\/span>, \"test_plan\"<\/span>, \"starter_comment\"<\/span>],<\/span>\n        template<\/span>=explain_code+\"{code_explaination}\"<\/span>+test_plan+\"{test_plan}\"<\/span>+prompt_to_generate_the_unit_test<\/span>\n    )<\/span>\n    unit_test_llm<\/span> = OpenAI(model_name=\"text-davinci-002\"<\/span>, temperature=0.4<\/span>, max_tokens=1000<\/span>, stop=\"```\"<\/span>)<\/span>\n    unit_test_step<\/span> = LLMChain(llm=unit_test_llm, prompt=unit_test_template, output_key=\"unit_test\"<\/span>)<\/span>\n<\/span>\n    sequential_chain<\/span> = SequentialChain(chains=[explain_code_step, test_plan_step, unit_test_step],<\/span>\n                                       input_variables<\/span>=[\"unit_test_package\"<\/span>, \"function_to_test\"<\/span>, \"starter_comment\"<\/span>],<\/span>\n                                       verbose<\/span>=True<\/span>)<\/span>\n    answer<\/span> = sequential_chain.run(unit_test_package=unit_test_package, function_to_test=function_to_test,<\/span>\n                                  starter_comment<\/span>=starter_comment)<\/span>\n    return f\"\"\"#{starter_comment}\"\"\"+answer<\/span><\/span>\n<\/span>\n<\/span>\ncode<\/span> = \"\"\"<\/span><\/span>\ndef format_time(days):<\/span>\n    years, days = divmod(days, 365)<\/span>\n    months, days = divmod(days, 30)<\/span>\n    weeks, days = divmod(days, 7)<\/span>\n    time_str = \"\"<\/span>\n    if years > 0:<\/span>\n        time_str += str(years) + \"y\"<\/span>\n    if months > 0:<\/span>\n        time_str += str(months) + \"m\"<\/span>\n    if weeks > 0:<\/span>\n        time_str += str(weeks) + \"w\"<\/span>\n    if days > 0:<\/span>\n        time_str += str(days) + \"d\"<\/span>\n    return time_str<\/span>\n\"\"\"<\/span>\n<\/span>\n<\/span>\ndef write_unit_test_automatically(code, retry<\/span>=3<\/span>):<\/span>\n    unit_test_code<\/span> = write_unit_test(code)<\/span>\n    all_code<\/span> = code+unit_test_code<\/span>\n    tried<\/span> = 0<\/span><\/span>\n    while tried < retry:<\/span>\n        try:<\/span>\n            ast.parse(all_code)<\/span>\n            return all_code<\/span>\n        except SyntaxError as e:<\/span>\n            print(f\"Syntax error in generated code: {e}\")<\/span>\n            all_code<\/span> = code+write_unit_test(code)<\/span>\n            tried += 1<\/span>\n<\/span>\n<\/span>\nprint(write_unit_test_automatically(code))<\/span>\n<\/code><\/pre>\n
            \u8f93\u51fa\uff1a<\/p>\n
            <\/div>
            js<\/span>
            \u590d\u5236\u4ee3\u7801<\/div><\/div><\/div>def format_time<\/span>(days):<\/span>\n    years, days = divmod<\/span>(days, 365<\/span>)<\/span>\n    months, days = divmod<\/span>(days, 30<\/span>)<\/span>\n    weeks, days = divmod<\/span>(days, 7<\/span>)<\/span>\n    time_str = \"\"<\/span><\/span>\n    if<\/span> years > 0<\/span>:<\/span>\n        time_str += str<\/span>(years) + \"y\"<\/span><\/span>\n    if<\/span> months > 0<\/span>:<\/span>\n        time_str += str<\/span>(months) + \"m\"<\/span><\/span>\n    if<\/span> weeks > 0<\/span>:<\/span>\n        time_str += str<\/span>(weeks) + \"w\"<\/span><\/span>\n    if<\/span> days > 0<\/span>:<\/span>\n        time_str += str<\/span>(days) + \"d\"<\/span><\/span>\n    return<\/span> time_str<\/span>\n#Below<\/span>, each test case<\/span> is represented by a tuple passed to the @pytest.mark<\/span>.parametrize<\/span> decorator.<\/span>\n#The<\/span> first element of<\/span> the tuple is the name of<\/span> the test case<\/span>, and the second element is a list of<\/span> tuples.<\/span>\n#Each<\/span> tuple in<\/span> the list of<\/span> tuples represents an individual test.<\/span>\n#The<\/span> first element of<\/span> each tuple is the input to the function<\/span> (days<\/span>), and the second element is the expected output of<\/span> the function<\/span>.<\/span>\n<\/span>\n@pytest.mark<\/span>.parametrize<\/span>('test_case_name, test_cases'<\/span>, [<\/span>\n    # Test<\/span> cases for<\/span> when the days argument is a positive integer<\/span>\n    ('positive_int'<\/span>, [<\/span>\n        (1<\/span>, '1d'<\/span>),<\/span>\n        (10<\/span>, '10d'<\/span>),<\/span>\n        (100<\/span>, '1y3m2w1d'<\/span>)<\/span>\n    ]),<\/span>\n<\/span>\n    # Test<\/span> cases for<\/span> when the days argument is 0<\/span><\/span>\n    ('zero'<\/span>, [<\/span>\n        (0<\/span>, ''<\/span>)<\/span>\n    ]),<\/span>\n<\/span>\n    # Test<\/span> cases for<\/span> when the days argument is negative<\/span>\n    ('negative_int'<\/span>, [<\/span>\n        (-1<\/span>, '-1d'<\/span>),<\/span>\n        (-10<\/span>, '-10d'<\/span>),<\/span>\n        (-100<\/span>, '-1y-3m-2w-1d'<\/span>)<\/span>\n    ]),<\/span>\n<\/span>\n    # Test<\/span> cases for<\/span> when the days argument is not an integer<\/span>\n    ('non_int'<\/span>, [<\/span>\n        (1.5<\/span>, pytest.raises<\/span>(TypeError<\/span>)),<\/span>\n        ('1'<\/span>, pytest.raises<\/span>(TypeError<\/span>))<\/span>\n    ])<\/span>\n])<\/span>\ndef test_format_time<\/span>(days, expected_output):<\/span>\n    # This<\/span> test function<\/span> is called once for<\/span> each test case<\/span>.<\/span>\n    # days is set to the input for<\/span> the function<\/span>, and expected_output is set to the expected output of<\/span> the function<\/span>.<\/span>\n    # We<\/span> can use the pytest.raises<\/span> context manager to test for<\/span> exceptions.<\/span>\n    if<\/span> isinstance<\/span>(expected_output, type) and issubclass<\/span>(expected_output, Exception<\/span>):<\/span>\n        with<\/span> pytest.raises<\/span>(expected_output):<\/span>\n            format_time<\/span>(days)<\/span>\n    else<\/span>:<\/span>\n        assert format_time<\/span>(days) == expected_output<\/span>\n<\/code><\/pre>\n
            \u56db\u3001\u603b\u7ed3<\/h2>\n
            \u60f3\u8981\u901a\u8fc7\u5927\u8bed\u8a00\u6a21\u578b\uff0c\u5b8c\u6210\u4e00\u4e2a\u590d\u6742\u7684\u4efb\u52a1\uff0c\u5f80\u5f80\u9700\u8981\u6211\u4eec\u591a\u6b21\u5411 AI \u63d0\u95ee\uff0c\u5e76\u4e14\u524d\u9762\u63d0\u95ee\u7684\u7b54\u6848\uff0c\u53ef\u80fd\u662f\u540e\u9762\u95ee\u9898\u8f93\u5165\u7684\u4e00\u90e8\u5206\u3002LangChain \u901a\u8fc7\u5c06\u591a\u4e2a LLMChain \u7ec4\u5408\u6210\u4e00\u4e2a SequantialChain \u5e76\u987a\u5e8f\u6267\u884c\uff0c\u5927\u5927\u7b80\u5316\u4e86\u8fd9\u7c7b\u4efb\u52a1\u7684\u5f00\u53d1\u5de5\u4f5c\u3002<\/p>\n
            \n
            \"image.png\"<\/figure>\n<\/p>","protected":false},"excerpt":{"rendered":"
            \u4e00\u3001\u7528ChatGPT\u76f4\u63a5\u751f\u6210\u7684\u6d4b\u8bd5\u7528\u4f8b \u8981\u5199\u6d4b\u8bd5\uff0c\u6211\u4eec\u8981\u5148\u6709\u4e00\u4e2a\u7a0b\u5e8f\u3002\u4e3a\u4e86\u907f\u514d\u8fd9\u4e2a\u9898\u76ee\u672c\u8eab\u5c31\u5728AI\u7684\u8bad\u7ec3\u6570\u636e\u96c6\u91cc\u9762\uff0c\u5b83\u76f4\u63a5\u77e5\u9053\u7b54\u6848\u3002 \u6211\u4eec\u7528\u4e00\u4e2a\u6709\u610f\u601d\u7684\u5c0f\u9898\u76ee\uff0c\u4e5f\u5c31\u662f\u8ba9Python\u6839\u636e\u6211\u4eec\u8f93\u5165\u7684\u4e00\u4e2a\u6574<\/p>\n","protected":false},"author":1,"featured_media":2311,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"rank_math_title":"AI\u8d4b\u80fd\uff1a\u81ea\u52a8\u751f\u6210\u5355\u5143\u6d4b\u8bd5\u7528\u4f8b\u65b0\u65b9\u6cd5 - \u5948\u65af\u79d1\u6280\u793e\u533a","rank_math_description":"\u8fd9\u7bc7\u6587\u7ae0\u63a2\u8ba8\u4e86\u5982\u4f55\u5229\u7528ChatGPT\u3001OpenAI\u548cLangChain\u7b49AI\u5de5\u5177\u81ea\u52a8\u751f\u6210\u5355\u5143\u6d4b\u8bd5\u7528\u4f8b\uff0c\u63d0\u9ad8\u4ee3\u7801\u6d4b\u8bd5\u6548\u7387\u3002\u6587\u7ae0\u8be6\u7ec6\u4ecb\u7ecd\u4e86\u4f7f\u7528\u6b65\u9aa4\uff0c\u5e76\u63d0\u4f9b\u4e86\u4ee3\u7801\u793a\u4f8b\u3002","rank_math_focus_keyword":"ChatGPT, \u5355\u5143\u6d4b\u8bd5, OpenAI, LangChain, \u4ee3\u7801\u751f\u6210","views":"31","footnotes":""},"categories":[3],"tags":[136,126,127,128,129],"collection":[],"class_list":["post-1191","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-fenlei2","tag-136","tag-gpt","tag-ai","tag-128","tag-129"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/posts\/1191","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/comments?post=1191"}],"version-history":[{"count":0,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/posts\/1191\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/media\/2311"}],"wp:attachment":[{"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/media?parent=1191"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/categories?post=1191"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/tags?post=1191"},{"taxonomy":"collection","embeddable":true,"href":"https:\/\/www.nicekj.com\/nicekj2024\/wp\/v2\/collection?post=1191"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}