wcgw 0.0.10__py3-none-any.whl → 0.1.1__py3-none-any.whl

wcgw/basic.py

@@ -158,14 +158,16 @@ def loop(
         openai.pydantic_function_tool(
             ExecuteBash,
             description="""
-Execute a bash script. Stateful (beware with subsequent calls).
-Execute commands using `execute_command` attribute.
-Do not use interactive commands like nano. Prefer writing simpler commands.
-Last line will always be `(exit <int code>)` except if
-the last line is `(pending)` if the program is still running or waiting for user inputs. You can then send input using `send_ascii` attributes. You get status by sending `send_ascii: [10]`.
-Optionally the last line is `(won't exit)` in which case you need to kill the process if you want to run a new command.
-Optionally `exit shell has restarted` is the output, in which case environment resets, you can run fresh commands.
-The first line might be `(...truncated)` if the output is too long.""",
+- Execute a bash script. This is stateful (beware with subsequent calls).
+- Execute commands using `execute_command` attribute.
+- Do not use interactive commands like nano. Prefer writing simpler commands.
+- Last line will always be `(exit <int code>)` except if
+- The last line is `(pending)` if the program is still running or waiting for your input. You can then send input using `send_ascii` attributes. You get status by sending new line `send_ascii: ["Enter"]` or `send_ascii: [10]`.
+- Optionally the last line is `(won't exit)` in which case you need to kill the process if you want to run a new command.
+- Optionally `exit shell has restarted` is the output, in which case environment resets, you can run fresh commands.
+- The first line might be `(...truncated)` if the output is too long.
+- Always run `pwd` if you get any file or directory not found error to make sure you're not lost.
+""",
         ),
         openai.pydantic_function_tool(
             Writefile,

wcgw/claude.py

@@ -0,0 +1,384 @@
+import base64
+import json
+import mimetypes
+from pathlib import Path
+import sys
+import traceback
+from typing import Callable, DefaultDict, Optional, cast
+import rich
+import petname
+from typer import Typer
+import uuid
+
+from .common import Models, discard_input
+from .common import CostData, Config, text_from_editor
+from .tools import ExecuteBash, ReadImage, ImageData
+
+from .tools import (
+    BASH_CLF_OUTPUT,
+    Confirmation,
+    DoneFlag,
+    Writefile,
+    get_is_waiting_user_input,
+    get_tool_output,
+    SHELL,
+    start_shell,
+    which_tool,
+)
+import tiktoken
+
+from urllib import parse
+import subprocess
+import os
+import tempfile
+
+import toml
+from pydantic import BaseModel
+
+
+from dotenv import load_dotenv
+
+from anthropic.types import MessageParam
+
+History = list[MessageParam]
+
+def save_history(history: History, session_id: str) -> None:
+    myid = str(history[1]["content"]).replace("/", "_").replace(" ", "_").lower()[:60]
+    myid += "_" + session_id
+    myid = myid + ".json"
+
+    mypath = Path(".wcgw") / myid
+    mypath.parent.mkdir(parents=True, exist_ok=True)
+    with open(mypath, "w") as f:
+        json.dump(history, f, indent=3)
+
+
+def parse_user_message_special(msg: str) -> ChatCompletionUserMessageParam:
+    # Search for lines starting with `%` and treat them as special commands
+    parts: list[ChatCompletionContentPartParam] = []
+    for line in msg.split("\n"):
+        if line.startswith("%"):
+            args = line[1:].strip().split(" ")
+            command = args[0]
+            assert command == 'image'
+            image_path = args[1]
+            with open(image_path, 'rb') as f:
+                image_bytes = f.read()
+                image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+                image_type = mimetypes.guess_type(image_path)[0]
+                dataurl=f'data:{image_type};base64,{image_b64}'
+            parts.append({
+                'type': 'image_url',
+                'image_url': {
+                    'url': dataurl,
+                    'detail': 'auto'
+                }
+            })
+        else:
+            if len(parts) > 0 and parts[-1]['type'] == 'text':
+                parts[-1]['text'] += '\n' + line
+            else:
+                parts.append({'type': 'text', 'text': line})
+    return {
+        'role': 'user',
+        'content': parts
+    }
+
+
+app = Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def loop(
+    first_message: Optional[str] = None,
+    limit: Optional[float] = None,
+    resume: Optional[str] = None,
+) -> tuple[str, float]:
+    load_dotenv()
+
+    session_id = str(uuid.uuid4())[:6]
+
+    history: History = []
+    waiting_for_assistant = False
+    if resume:
+        if resume == "latest":
+            resume_path = sorted(Path(".wcgw").iterdir(), key=os.path.getmtime)[-1]
+        else:
+            resume_path = Path(resume)
+        if not resume_path.exists():
+            raise FileNotFoundError(f"File {resume} not found")
+        with resume_path.open() as f:
+            history = json.load(f)
+        if len(history) <= 2:
+            raise ValueError("Invalid history file")
+        if history[1]["role"] != "user":
+            raise ValueError("Invalid history file, second message should be user")
+        first_message = ""
+        waiting_for_assistant = history[-1]['role'] != 'assistant'
+
+    my_dir = os.path.dirname(__file__)
+    config_file = os.path.join(my_dir, "..", "..", "config.toml")
+    with open(config_file) as f:
+        config_json = toml.load(f)
+        config = Config.model_validate(config_json)
+
+    if limit is not None:
+        config.cost_limit = limit
+    limit = config.cost_limit
+
+    enc = tiktoken.encoding_for_model(
+        config.model if not config.model.startswith("o1") else "gpt-4o"
+    )
+    is_waiting_user_input = get_is_waiting_user_input(
+        config.model, config.cost_file[config.model]
+    )
+
+    tools = [
+        openai.pydantic_function_tool(
+            ExecuteBash,
+            description="""
+Execute a bash script. Stateful (beware with subsequent calls).
+Execute commands using `execute_command` attribute.
+Do not use interactive commands like nano. Prefer writing simpler commands.
+Last line will always be `(exit <int code>)` except if
+the last line is `(pending)` if the program is still running or waiting for user inputs. You can then send input using `send_ascii` attributes. You get status by sending `send_ascii: [10]`.
+Optionally the last line is `(won't exit)` in which case you need to kill the process if you want to run a new command.
+Optionally `exit shell has restarted` is the output, in which case environment resets, you can run fresh commands.
+The first line might be `(...truncated)` if the output is too long.""",
+        ),
+        openai.pydantic_function_tool(
+            Writefile,
+            description="Write content to a file. Provide file path and content. Use this instead of ExecuteBash for writing files.",
+        ),
+        openai.pydantic_function_tool(
+            ReadImage, description="Read an image from the shell."
+        ),
+    ]
+    uname_sysname = os.uname().sysname
+    uname_machine = os.uname().machine
+
+    system = f"""
+You're a cli assistant.
+
+Instructions:
+
+    - You should use the provided bash execution tool to run script to complete objective. 
+    - Do not use sudo. Do not use interactive commands. 
+    - Ask user for confirmation before running anything major
+    
+System information:
+    - System: {uname_sysname}
+    - Machine: {uname_machine}
+"""
+
+    if not history:
+        history = [{"role": "system", "content": system}]
+    else:
+        if history[-1]["role"] == "tool":
+            waiting_for_assistant = True
+
+    client = OpenAI()
+
+    cost: float = 0
+    input_toks = 0
+    output_toks = 0
+    system_console = rich.console.Console(style="blue", highlight=False)
+    error_console = rich.console.Console(style="red", highlight=False)
+    user_console = rich.console.Console(style="bright_black", highlight=False)
+    assistant_console = rich.console.Console(style="white bold", highlight=False)
+
+    while True:
+        if cost > limit:
+            system_console.print(
+                f"\nCost limit exceeded. Current cost: {cost}, input tokens: {input_toks}, output tokens: {output_toks}"
+            )
+            break
+
+        if not waiting_for_assistant:
+            if first_message:
+                msg = first_message
+                first_message = ""
+            else:
+                msg = text_from_editor(user_console)
+
+            history.append(parse_user_message_special(msg))
+        else:
+            waiting_for_assistant = False
+
+        cost_, input_toks_ = get_input_cost(
+            config.cost_file[config.model], enc, history
+        )
+        cost += cost_
+        input_toks += input_toks_
+
+        stream = client.chat.completions.create(
+            messages=history,
+            model=config.model,
+            stream=True,
+            tools=tools,
+        )
+
+        system_console.print(
+            "\n---------------------------------------\n# Assistant response",
+            style="bold",
+        )
+        tool_call_args_by_id = DefaultDict[str, DefaultDict[int, str]](
+            lambda: DefaultDict(str)
+        )
+        _histories: History = []
+        item: ChatCompletionMessageParam
+        full_response: str = ""
+        image_histories: History = []
+        try:
+            for chunk in stream:
+                if chunk.choices[0].finish_reason == "tool_calls":
+                    assert tool_call_args_by_id
+                    item = {
+                        "role": "assistant",
+                        "content": full_response,
+                        "tool_calls": [
+                            {
+                                "id": tool_call_id + str(toolindex),
+                                "type": "function",
+                                "function": {
+                                    "arguments": tool_args,
+                                    "name": type(which_tool(tool_args)).__name__,
+                                },
+                            }
+                            for tool_call_id, toolcallargs in tool_call_args_by_id.items()
+                            for toolindex, tool_args in toolcallargs.items()
+                        ],
+                    }
+                    cost_, output_toks_ = get_output_cost(
+                        config.cost_file[config.model], enc, item
+                    )
+                    cost += cost_
+                    system_console.print(
+                        f"\n---------------------------------------\n# Assistant invoked tools: {[which_tool(tool['function']['arguments']) for tool in item['tool_calls']]}"
+                    )
+                    system_console.print(f"\nTotal cost: {config.cost_unit}{cost:.3f}")
+                    output_toks += output_toks_
+                    
+                    _histories.append(item)
+                    for tool_call_id, toolcallargs in tool_call_args_by_id.items():
+                        for toolindex, tool_args in toolcallargs.items():
+                            try:
+                                output_or_done, cost_ = get_tool_output(
+                                    json.loads(tool_args),
+                                    enc,
+                                    limit - cost,
+                                    loop,
+                                    is_waiting_user_input,
+                                )
+                            except Exception as e:
+                                output_or_done = (
+                                    f"GOT EXCEPTION while calling tool. Error: {e}"
+                                )
+                                tb = traceback.format_exc()
+                                error_console.print(output_or_done + "\n" + tb)
+                                cost_ = 0
+                            cost += cost_
+                            system_console.print(
+                                f"\nTotal cost: {config.cost_unit}{cost:.3f}"
+                            )
+
+                            if isinstance(output_or_done, DoneFlag):
+                                system_console.print(
+                                    f"\n# Task marked done, with output {output_or_done.task_output}",
+                                )
+                                system_console.print(
+                                    f"\nTotal cost: {config.cost_unit}{cost:.3f}"
+                                )
+                                return output_or_done.task_output, cost
+                                
+                            output = output_or_done
+
+                            if isinstance(output, ImageData):
+                                randomId = petname.Generate(2, "-")
+                                if not image_histories:
+                                    image_histories.extend([
+                                        {
+                                            'role': 'assistant',
+                                            'content': f'Share images with ids: {randomId}'
+
+                                        },
+                                        {
+                                            'role': 'user',
+                                            'content': [{
+                                                'type': 'image_url',
+                                                'image_url': {
+                                                    'url': output.dataurl,
+                                                    'detail': 'auto'
+                                                }
+                                            }]
+                                        }]
+                                    )
+                                else:
+                                    image_histories[0]['content'] += ', ' + randomId
+                                    image_histories[1]["content"].append({ # type: ignore
+                                        'type': 'image_url',
+                                        'image_url': {
+                                            'url': output.dataurl,
+                                            'detail': 'auto'
+                                        }
+                                    })
+
+                                item = {
+                                    "role": "tool",
+                                    "content": f'Ask user for image id: {randomId}',
+                                    "tool_call_id": tool_call_id + str(toolindex),
+                                }
+                            else:
+                                item = {
+                                    "role": "tool",
+                                    "content": str(output),
+                                    "tool_call_id": tool_call_id + str(toolindex),
+                                }
+                            cost_, output_toks_ = get_output_cost(
+                                config.cost_file[config.model], enc, item
+                            )
+                            cost += cost_
+                            output_toks += output_toks_
+
+                            _histories.append(item)
+                    waiting_for_assistant = True
+                    break
+                elif chunk.choices[0].finish_reason:
+                    assistant_console.print("")
+                    item = {
+                        "role": "assistant",
+                        "content": full_response,
+                    }
+                    cost_, output_toks_ = get_output_cost(
+                        config.cost_file[config.model], enc, item
+                    )
+                    cost += cost_
+                    output_toks += output_toks_
+
+                    system_console.print(f"\nTotal cost: {config.cost_unit}{cost:.3f}")
+                    _histories.append(item)
+                    break
+
+                if chunk.choices[0].delta.tool_calls:
+                    tool_call = chunk.choices[0].delta.tool_calls[0]
+                    if tool_call.function and tool_call.function.arguments:
+                        tool_call_args_by_id[tool_call.id or ""][tool_call.index] += (
+                            tool_call.function.arguments
+                        )
+
+                chunk_str = chunk.choices[0].delta.content or ""
+                assistant_console.print(chunk_str, end="")
+                full_response += chunk_str
+        except KeyboardInterrupt:
+            waiting_for_assistant = False
+            input("Interrupted...enter to redo the current turn")
+        else:
+            history.extend(_histories)
+            history.extend(image_histories)
+            save_history(history, session_id)
+
+    return "Couldn't finish the task", cost
+
+
+if __name__ == "__main__":
+    app()

wcgw/common.py

@@ -23,25 +23,27 @@ Models = Literal["gpt-4o-2024-08-06", "gpt-4o-mini"]
 
 
 def discard_input() -> None:
-    # Get the file descriptor for stdin
-    fd = sys.stdin.fileno()
-
-    # Save current terminal settings
-    old_settings = termios.tcgetattr(fd)
-
     try:
-        # Switch terminal to non-canonical mode where input is read immediately
-        tty.setcbreak(fd)
-
-        # Discard all input
-        while True:
-            # Check if there is input to be read
-            if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
-                sys.stdin.read(
-                    1
-                )  # Read one character at a time to flush the input buffer
-            else:
-                break
-    finally:
-        # Restore old terminal settings
-        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        # Get the file descriptor for stdin
+        fd = sys.stdin.fileno()
+
+        # Save current terminal settings
+        old_settings = termios.tcgetattr(fd)
+
+        try:
+            # Switch terminal to non-canonical mode where input is read immediately
+            tty.setcbreak(fd)
+
+            # Discard all input
+            while True:
+                # Check if there is input to be read
+                if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
+                    sys.stdin.read(1)  # Read one character at a time to flush the input buffer
+                else:
+                    break
+        finally:
+            # Restore old terminal settings
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+    except (termios.error, ValueError) as e:
+        # Handle the error gracefully
+        print(f"Warning: Unable to discard input. Error: {e}")

wcgw/tools.py

@@ -43,7 +43,7 @@ from .common import CostData, Models, discard_input
 
 from .openai_utils import get_input_cost, get_output_cost
 
-console = rich.console.Console(style="magenta", highlight=False)
+console = rich.console.Console(style="magenta", highlight=False, markup=False)
 
 TIMEOUT = 30
 
@@ -103,6 +103,12 @@ def _is_int(mystr: str) -> bool:
 
 
 def _get_exit_code() -> int:
+    # First reset the prompt in case venv was sourced or other reasons.
+    SHELL.sendline('export PS1="#@@"')
+    SHELL.expect("#@@")
+    # Reset echo also if it was enabled
+    SHELL.sendline("stty -icanon -echo")
+    SHELL.expect("#@@")
     SHELL.sendline("echo $?")
     before = ""
     while not _is_int(before):  # Consume all previous output
@@ -299,7 +305,7 @@ def write_file(writefile: Writefile) -> str:
         SHELL.expect("#@@")
         assert isinstance(SHELL.before, str)
         current_dir = SHELL.before.strip()
-        writefile.file_path = os.path.join(current_dir, writefile.file_path)
+        return f"Failure: Use absolute path only. FYI current working directory is '{current_dir}'"
     os.makedirs(os.path.dirname(writefile.file_path), exist_ok=True)
     try:
         with open(writefile.file_path, "w") as f:

{wcgw-0.0.10.dist-info → wcgw-0.1.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: wcgw
-Version: 0.0.10
+Version: 0.1.1
 Summary: What could go wrong giving full shell access to chatgpt?
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
-Requires-Python: <3.13,>=3.8
+Requires-Python: <3.13,>=3.10
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: mypy>=1.11.2
 Requires-Dist: openai>=1.46.0
@@ -26,6 +26,9 @@ Description-Content-Type: text/markdown
 # Enable shell access on chatgpt.com
 A custom gpt on chatgpt web app to interact with your local shell.
 
+[![Tests](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml/badge.svg?branch=main)](https://github.com/rusiaaman/wcgw/actions/workflows/python-tests.yml)
+[![Build](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml/badge.svg)](https://github.com/rusiaaman/wcgw/actions/workflows/python-publish.yml)
+
 ### 🚀 Highlights
 - ⚡ **Full Shell Access**: No restrictions, complete control.
 - ⚡ **Create, Execute, Iterate**: Ask the gpt to keep running compiler checks till all errors are fixed, or ask it to keep checking for the status of a long running command till it's done.
@@ -36,21 +39,24 @@ A custom gpt on chatgpt web app to interact with your local shell.
 2. Share the generated id with this GPT: `https://chatgpt.com/g/g-Us0AAXkRh-wcgw-giving-shell-access`
 3. The custom GPT can now run any command on your cli
 
+
 ## Client
+You need to keep running this client for GPT to access your shell. Run it in a version controlled project's root.
 
-### Option 1: using pip
-Supports python >=3.8 and <3.13
+### Option 1: using uv [Recommended]
 ```sh
-$ pip3 install wcgw
-$ wcgw
+$ curl -LsSf https://astral.sh/uv/install.sh | sh
+$ uv tool run --python 3.12 wcgw@latest
 ```
 
-### Option 2: using uv
+### Option 2: using pip
+Supports python >=3.10 and <3.13
 ```sh
-$ curl -LsSf https://astral.sh/uv/install.sh | sh
-$ uv tool run --python 3.12 wcgw
+$ pip3 install wcgw
+$ wcgw
 ```
 
+
 This will print a UUID that you need to share with the gpt.
 
 
@@ -67,20 +73,37 @@ NOTE: you can resume a broken connection
 # How it works
 Your commands are relayed through a server I've hosted at https://wcgw.arcfu.com. The code for that is at `src/relay/serve.py`. 
 
-Chat gpt sends a request to the relay server using the user id that you share with it. The relay server holds a websocket with the terminal cilent against the user id and acts as a proxy to pass the request.
+Chat gpt sends a request to the relay server using the user id that you share with it. The relay server holds a websocket with the terminal client against the user id and acts as a proxy to pass the request.
 
 It's secure in both the directions. Either a malicious actor or a malicious Chatgpt has to correctly guess your UUID for any security breach. 
 
-NOTE: the relay server doesn't store any data. If you don't trust it then you may host the server on your own and create a custom gpt. Create an issue and I'll be happy to share the full instructions and schema I've given in the custom GPT configuration. 
-
 # Showcase
 
+## Unit tests and github actions
+[The first version of unit tests and github workflow to test on multiple python versions were written by the custom chatgpt](https://chatgpt.com/share/6717f922-8998-8005-b825-45d4b348b4dd)
+
 ## Create a todo app using react + typescript + vite
-https://chatgpt.com/share/6717d94d-756c-8005-98a6-d021c7b586aa
+![Screenshot](https://github.com/rusiaaman/wcgw/blob/main/static/ss1.png?raw=true)
+
+
+# Privacy
+The relay server doesn't store any data. I can't access any information passing through it and only secure channels are used to communicate.
+
+You may host the server on your own and create a custom gpt using the following section.
+
+# Creating your own custom gpt and the relay server.
+I've used the following instructions and action json schema to create the custom GPT. (Replace wcgw.arcfu.com with the address to your server)
+
+https://github.com/rusiaaman/wcgw/blob/main/gpt_instructions.txt
+https://github.com/rusiaaman/wcgw/blob/main/gpt_action_json_schema.json
+
+Run the server 
+`gunicorn --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:443 src.relay.serve:app  --certfile fullchain.pem  --keyfile  privkey.pem`
 
-## Write unit tests for all files in my current repo
-[Todo]
+If you don't have public ip and domain name, you can use `ngrok` or similar services to get a https address to the api.
 
+The specify the server url in the `wcgw` command like so
+`wcgw --server-url https://your-url/register`
 
 # [Optional] Local shell access with openai API key
 

wcgw-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+wcgw/__init__.py,sha256=okSsOWpTKDjEQzgOin3Kdpx4Mc3MFX1RunjopHQSIWE,62
+wcgw/__main__.py,sha256=MjJnFwfYzA1rW47xuSP1EVsi53DTHeEGqESkQwsELFQ,34
+wcgw/basic.py,sha256=z1RVJMTDE1-J33nAPSfMZDdJBliSPCFh55SDCvtDLFI,16198
+wcgw/claude.py,sha256=Bp45-UMBIJd-4tzX618nu-SpRbVtkTb1Es6c_gW6xy0,14861
+wcgw/common.py,sha256=grH-yV_4tnTQZ29xExn4YicGLxEq98z-HkEZwH0ReSg,1410
+wcgw/openai_adapters.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wcgw/openai_utils.py,sha256=YNwCsA-Wqq7jWrxP0rfQmBTb1dI0s7dWXzQqyTzOZT4,2629
+wcgw/tools.py,sha256=0cbDs8WDYa_BOrj6_SOxFXZJ0CbDx7T24gooH2J4jG4,16627
+wcgw-0.1.1.dist-info/METADATA,sha256=j63XR1wjlTJIqu-dmwYEWTKW-WrBW01FFR4WHPUYaF4,4892
+wcgw-0.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+wcgw-0.1.1.dist-info/entry_points.txt,sha256=T-IH7w6Vc650hr8xksC8kJfbJR4uwN8HDudejwDwrNM,59
+wcgw-0.1.1.dist-info/RECORD,,

wcgw-0.0.10.dist-info/RECORD

@@ -1,11 +0,0 @@
-wcgw/__init__.py,sha256=okSsOWpTKDjEQzgOin3Kdpx4Mc3MFX1RunjopHQSIWE,62
-wcgw/__main__.py,sha256=MjJnFwfYzA1rW47xuSP1EVsi53DTHeEGqESkQwsELFQ,34
-wcgw/basic.py,sha256=t5l24fx8UNIJSa1yh2wh4WYtLwi35y5WR8XKG-7lC00,16040
-wcgw/common.py,sha256=jn39zTpaFUO1PWof_z7qBmklaZH5G1blzjlBvez0cg4,1225
-wcgw/openai_adapters.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wcgw/openai_utils.py,sha256=YNwCsA-Wqq7jWrxP0rfQmBTb1dI0s7dWXzQqyTzOZT4,2629
-wcgw/tools.py,sha256=HGcxk09mmwnENV0PPfGV-I7TaOEvRlOdD9KdH_juHhA,16350
-wcgw-0.0.10.dist-info/METADATA,sha256=j3ODV1Y9v9ntqDYrOi8BO5LjyMRAYWmI8DnMKjmLpkw,3526
-wcgw-0.0.10.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-wcgw-0.0.10.dist-info/entry_points.txt,sha256=T-IH7w6Vc650hr8xksC8kJfbJR4uwN8HDudejwDwrNM,59
-wcgw-0.0.10.dist-info/RECORD,,