gr-tradinggame 0.1.13__py3-none-any.whl

gr_tradinggame/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from uvrestructure!"

gr_tradinggame/coding/blackbox.py

@@ -0,0 +1,50 @@
+from contextlib import redirect_stderr, redirect_stdout
+import cloudpickle as pickle
+import base64
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
+import io
+
+
+class Blackbox:
+    def __init__(self, source, name='play'):
+        self.name = name
+        self.stdout = io.StringIO()
+        self.stderr = io.StringIO()
+        with redirect_stderr(self.stderr), redirect_stdout(self.stdout):
+            self.shell = TerminalInteractiveShell()
+            out = self.shell.run_cell(source)
+            if out.error_before_exec is not None:
+                raise out.error_before_exec
+            if out.error_in_exec is not None:
+                raise out.error_in_exec
+        if not isinstance(name, str) or name not in self.shell.user_ns:
+            raise Exception(f"Your source code must define a function called `{self.name}`, but only has `{self.shell.user_ns.keys()}`")
+
+    def __call__(self, *args, **kwargs):
+        input_variable_name = '__magic_input__'
+        with redirect_stderr(self.stderr), redirect_stdout(self.stdout):
+            self.shell.user_ns[input_variable_name] = args, kwargs
+            out = self.shell.run_cell(f'{self.name}(*{input_variable_name}[0], **{input_variable_name}[1])')
+            if out.error_before_exec is not None:
+                raise out.error_before_exec
+            if out.error_in_exec is not None:
+                raise out.error_in_exec
+            return out.result
+
+
+class Plackbox:
+    def __init__(self, source):
+        self.foo = pickle.loads(source)
+        self.stdout = io.StringIO()
+        self.stderr = io.StringIO()
+
+    def __call__(self, *args, **kwargs):
+        with redirect_stderr(self.stderr), redirect_stdout(self.stdout):
+            return self.foo(*args, **kwargs)
+
+
+def generate_function(data):
+    if data[0] == 'p':
+        return pickle.loads(base64.b64decode(data[1:]))
+    else:
+        return Blackbox(base64.b64decode(data[1:]).decode('utf-8'))

gr_tradinggame/coding/client.py

@@ -0,0 +1,115 @@
+import base64
+import datetime
+import random
+import traceback
+import requests
+from requests.auth import HTTPBasicAuth
+import cloudpickle as pickle
+import timeit
+
+from .blackbox import Plackbox, Blackbox
+
+
+class Client:
+    def __init__(self, team_name, server=None, timeout=0.1):
+        self.team_name = team_name
+        if server:
+            self.url = "https://" + server + ".ngrok-free.app"
+        else:
+            self.url = None
+        self.timeout = timeout
+
+    def test(self, source_or_function, verbose=False, strict=False, allow_state=True):
+        return self._submit(source_or_function, strict=strict, submit=False, allow_state=allow_state, verbose=verbose)
+
+    def submit(self, source_or_function, allow_state=True):
+        return self._submit(source_or_function, strict=False, submit=True, allow_state=allow_state, verbose=False)
+        
+    def _submit(self, source_or_function, strict, submit, allow_state, verbose):
+        if submit and not self.url:
+            print('Automatic submission not enabled. Please send an email with your snippet to the organizers.')
+            return
+        test_cases = [
+            ((1.5, 5, 1, 10, 1.3, [1.1, 2.3]), "generic inputs", None),
+            ((-1.5, 5, 1, 10, 1.3, [1.1, 2.3]), "negative reward", (False, 'It never makes sense to take a negative reward')),
+            ((0, 5, 1, 10, 1.3, [1.1, 2.3]), "zero rewards", (False, "It doesn't make sense to accept a lockout in return for no reward")),
+            ((1.5, 5, 1, 10, 1.3, []), "playing by yourself", None),
+            ((1.5, 5, 1, 10, -1, [-1.1, 2.3]), "negative score", None),
+            ((0.0001, 5, 10, 10, 1.3, [1.1, 2.3]), "no time left after this round", (True, 'There is no time left after this round, you should accept any reward you can get')),
+            ((0.0001, 0, 1, 10, 1.3, [1.1, 2.3]), "no lockout", (True, 'There is no lockout, you should accept any reward you can get')),
+        ]
+        if isinstance(source_or_function, str):
+            output = source_or_function
+            foo = Blackbox(output)
+        else:
+            output = pickle.dumps(source_or_function)
+            foo = Plackbox(output)
+        outputs = dict()
+        for j in range(3):
+            for i, (args, err, hint) in enumerate(test_cases):
+                test_str = f'Test {i} ("{err}"): f{args}'
+                if j == 0 and verbose:
+                    print(test_str)
+                    test_str = ''
+                try:
+                    a = foo(*args)
+                    if j == 0:
+                        outputs[i] = a
+                    else:
+                        if a != outputs[i] and not allow_state:
+                            print(test_str)
+                            raise Exception(f"""You previously returned `{outputs[i]}` and are now returning `{a}`. If this is intentional, set `allow_state=True`""")
+                        elif not isinstance(a, bool):
+                            print(test_str)
+                            raise Exception(f"""You should return `False` or `True` but you returned `{a}` of type {type(a)}""")
+                        elif strict and hint is not None and a != hint[0]:
+                            print(test_str)
+                            raise Exception(hint[1])
+                except Exception:
+                    print(test_str)
+                    raise
+                if j == 0 and verbose:
+                    print(f'\tSuccess -- returned {a}')
+        tic = timeit.default_timer()
+        for j in range(1_000):
+            T = int(1_000_000 * random.random())
+            t = int(random.random() * T)
+            lockout = int(10 * random.random())
+            reward = 100 * random.random()
+            score = reward * T * random.random()
+            scores = [reward * T * random.random() for _ in range(10)]
+            args = (reward, lockout, t, T,  score, scores)
+            try:
+                a = foo(*args)
+            except Exception:
+                print(f'Random input {args}')
+                raise
+            else:
+                if not isinstance(a, bool):
+                    print(f'Random input {args}')
+                    raise Exception(f"""You should return `False` or `True` but returned `{a}` of type {type(a)}""")
+            toc = timeit.default_timer()
+            if toc - tic > max(1, (j + 1) * self.timeout):
+                raise Exception(f"""Your code is too slow. Should take {self.timeout}s per round but took {(toc - tic) / (j + 1):.3f}s""")
+        if submit:
+            self.fancy_submit(source_or_function)
+        else:
+            print("All tests passed. You're ready to call `submit`\n")
+
+    def fancy_submit(self, output):
+        if isinstance(output, str):
+            submission = 's' + base64.b64encode(output.encode('utf-8')).decode('utf-8')
+        else:
+            submission = 'p' + base64.b64encode(pickle.dumps(output)).decode('utf-8')
+        j = {"team": self.team_name, 'time': str(datetime.datetime.now()), 'submission': submission}
+        response = requests.post(
+            self.url + '/receive',
+            json=j,
+            auth=HTTPBasicAuth("colabuser", "secretcolab"),
+        )
+        try:
+            response.raise_for_status()
+        except Exception:
+            raise Exception("Couldn't connect to server. Please notify an organizer.")
+        else:
+            print('Submission successful: ', j['team'], j['time'])

gr_tradinggame/coding/gui.py

@@ -0,0 +1,165 @@
+import timeit
+import numpy as np
+import ipywidgets as widgets
+import plotly.graph_objects as go
+import pandas as pd
+from IPython.display import clear_output, display
+import time
+import json
+
+from .blackbox import generate_function
+
+
+class CodingGame:
+    def __init__(
+            self, rounds=2000, lockout=5, plot_frequency=0.3, plot_width=1000, length_in_seconds=30, eliminate_slow_teams=False,
+            functions=None, submissions=None, additional_functions=None, random_draw_function='a', must_be_only_team=False
+    ):
+        if functions is None and submissions is None:
+            with open("submissions.json", "r") as f:
+                submissions = json.load(f)
+        if additional_functions is None:
+            additional_functions = {}
+        self.candidates = functions if functions is not None else CodingGame.clean(submissions)
+        self.candidates = {**self.candidates, **{x: generate_function(y) if isinstance(y, str) else y for (x, y) in additional_functions.items()}}
+        self.plot_frequency = plot_frequency
+        self.eliminate = eliminate_slow_teams
+        self.length = length_in_seconds
+        self.plot_width = plot_width
+        self.last_lockout = lockout
+        self.max_rounds = rounds
+        self.random_draw_function = random_draw_function
+        self.must_be_only_team = must_be_only_team
+        if isinstance(self.random_draw_function, str):
+            if self.random_draw_function.lower().strip() == 'a':
+                self.random_draw_function = lambda: np.random.exponential(10)
+            elif self.random_draw_function.lower().strip() == 'b':
+                self.random_draw_function = lambda: np.random.normal(-0.2, 1)
+        self.init_play()
+        self.initialize_ui()
+
+    @staticmethod
+    def clean(candidates):
+        return {
+            outer_key: generate_function(max(inner_dict.items(), key=lambda item: item[0])[1])
+            for outer_key, inner_dict in candidates.items()
+        }
+
+    def initialize_ui(self):
+        self.output = widgets.Output()
+        self.plot_output = widgets.Output(layout=dict(width='100%'))
+        self.game_ui = widgets.HBox(
+            [self.output, self.plot_output],
+            layout=widgets.Layout(
+                align_items='center',
+                justify_content='center',
+                width='100%'
+            )
+        )
+        top_spacer = widgets.Box(layout=widgets.Layout(flex='1 1 auto'))
+        bottom_spacer = widgets.Box(layout=widgets.Layout(flex='1 1 auto'))
+        self.vertical_box = widgets.VBox(
+            [top_spacer, self.game_ui, bottom_spacer],
+            layout=widgets.Layout(
+                height='100vh',
+                display='flex',
+                flex_flow='column',
+                align_items='center',
+                justify_content='center',
+            )
+        )
+
+        self.update_plot()
+
+    def update_plot(self):
+        fig = go.Figure()
+        for team in self.candidates:
+            n = self.current_round
+            step = int(n / 100 + 1)
+            fig.add_trace(go.Scatter(
+                x=list(range(self.current_round + 1))[::step],
+                y=self.team_scores[team][::step],
+                mode='lines',
+                name=team,
+            ))
+        fig.update_layout(showlegend=True, xaxis_title='Round', yaxis_title='Score', xaxis_range=[0, self.max_rounds], width=self.plot_width)
+        with self.plot_output:
+            clear_output(wait=True)
+            display(fig)
+
+    def start_new_round(self):
+        self.current_round += 1
+        self.last_number = self.random_draw_function()
+
+    def loop(self):
+        with self.output:
+            while self.current_round < self.max_rounds:
+                self.start_new_round()
+                eliminate = []
+                last_team_to_score = None
+                for team, btn in self.candidates.items():
+                    args = (self.last_number, self.last_lockout, self.current_round, self.max_rounds, self.team_scores[team][-1], [y[-1] for (x, y) in self.team_scores.items() if x != team])
+                    tic_team = timeit.default_timer()
+                    took_action = btn(*args) and self.current_round > self.team_blocked_until[team]
+                    toc_team = timeit.default_timer()
+                    if self.eliminate and toc_team - tic_team > self.length / self.max_rounds / len(self.candidates):
+                        eliminate.append(team)
+                    score = self.last_number if took_action else 0
+                    self.team_scores[team].append(self.team_scores[team][-1] + score)
+                    if self.must_be_only_team and took_action and last_team_to_score is not None:
+                        self.team_scores[team][-1] = self.team_scores[team][-2]
+                        self.team_scores[last_team_to_score][-1] = self.team_scores[last_team_to_score][-2]
+                    if took_action:
+                        self.team_blocked_until[team] = self.current_round + self.last_lockout
+                        last_team_to_score = team
+                for x in eliminate:
+                    del self.candidates[x]
+                toc = timeit.default_timer()
+                target = self.start + self.current_round / self.max_rounds * self.length
+                if toc < target:
+                    time.sleep(target - toc)
+                if toc > self.last_update + self.plot_frequency:
+                    self.last_update = toc
+                    self.update_plot()
+
+            self.update_plot()
+            df = (
+                pd.DataFrame(
+                    {x: self.team_scores[x][-1] for x in self.team_scores}.items(),
+                    columns=['Name', 'Score']
+                )
+                .sort_values('Score', ascending=False)
+                .reset_index(drop=True)
+                .rename(index=lambda x: x + 1)
+                .round(2)
+            )
+            display(df)
+
+    def init_play(self):
+        if self.random_draw_function is None:
+            random = np.random.default_rng(seed=None)
+            self.random_draw_function= lambda: random.pareto(3)
+        self.last_update = -2 ** 31
+        self.team_scores = {team: [0] for team in self.candidates}
+        self.team_blocked_until = {team: -1 for team in self.candidates}
+        self.last_number = None
+        self.current_round = 0
+
+    def play(self, countdown=0):
+
+        with self.output:
+            clear_output()
+        with self.plot_output:
+            clear_output()
+
+        display(self.vertical_box)
+        with self.output:
+            for i in range(countdown, 0, -1):
+                print(i)
+                time.sleep(1)
+                clear_output()
+        self.start = timeit.default_timer()
+        self.loop()
+
+    def _ipython_display_(self):
+        display(self.vertical_box)

gr_tradinggame/coding/server.py

@@ -0,0 +1,74 @@
+import uuid
+from flask import Flask, request, jsonify
+from functools import wraps
+import json
+import base64
+from collections import defaultdict
+import threading
+
+from .blackbox import generate_function
+from .util import get_url
+
+
+class GameServer:
+    def __init__(self):
+        self.name = str(uuid.uuid4())
+        self.submission_lock = threading.Lock()
+        self.USERNAME = "colabuser"
+        self.PASSWORD = "secretcolab"
+
+        self.submissions = defaultdict(lambda: defaultdict(dict))
+        try:
+            with open("submissions.json", 'r') as f:
+                submissions_loaded = json.load(f)
+            for team, team_submissions in submissions_loaded.items():
+                for time, team_submission in team_submissions.items():
+                    self.submissions[team][time] = team_submission
+        except FileNotFoundError:
+            pass
+        else:
+            print("Loaded existing submissions:")
+            print(json.dumps(self.submissions, indent=4))
+
+        self.app = Flask(self.name)
+
+        def require_auth(f):
+            @wraps(f)
+            def decorated(*args, **kwargs):
+                auth = request.headers.get("Authorization")
+                error = None
+                if auth and auth.startswith("Basic "):
+                    try:
+                        decoded = base64.b64decode(auth.split(" ")[1]).decode("utf-8")
+                        user, pw = decoded.split(":")
+                        if user == self.USERNAME and pw == self.PASSWORD:
+                            return f(*args, **kwargs)
+                    except Exception as e:
+                        print(e)
+                        error = e
+                return jsonify({"error": "Unauthorized"}), 401 if error is None else jsonify({'error': str(error)}), 500
+            return decorated
+        
+        @self.app.route("/receive", methods=["POST"])
+        @require_auth
+        def receive():
+            data = request.get_json()
+            print("Submission received:", data)
+            generate_function(data['submission'])
+            with self.submission_lock:
+                self.submissions[data['team']][data['time']] = data['submission']
+                with open("submissions.json", "w") as f:
+                    json.dump(dict(self.submissions), f, indent=4)
+            print(json.dumps(
+                {
+                    team_name: max(team_submissions.items(), key=lambda x: x[0])[0]
+                    for (team_name, team_submissions) in self.submissions.items()
+                },
+                indent=4
+            ))
+            return jsonify({"status": "success"})
+
+    def run(self, force_restart=False):
+        server_id = get_url(force_restart)
+        print('Serving', server_id)
+        self.app.run(port=5000)

gr_tradinggame/coding/util.py

@@ -0,0 +1,43 @@
+import time
+import subprocess
+import requests
+from pyngrok import ngrok, conf
+
+NGROK_API = "http://localhost:4040/api/tunnels"
+
+def _cleanup_local_tunnels():
+    try:
+        r = requests.get(NGROK_API, timeout=1)
+        for t in r.json().get("tunnels", []):
+            old_url = t["public_url"]
+            print(f"NOTE: disconnecting and cleaning up {old_url} before serving new session.")
+            ngrok.disconnect(old_url)
+    except Exception:
+        pass
+
+def _ensure_ngrok_running():
+    try:
+        requests.get(NGROK_API, timeout=1)
+    except Exception:
+        ngrok.install_ngrok()
+        subprocess.Popen(
+            [conf.get_default().ngrok_path, "http", "5000"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        time.sleep(5)
+
+def get_url(force_restart=False):
+    if force_restart:
+        _cleanup_local_tunnels()
+
+    _ensure_ngrok_running()
+
+    try:
+        r = requests.get(NGROK_API)
+        tunnels = r.json()["tunnels"]
+        public_url = tunnels[0]["public_url"]
+        return public_url.split('//')[1].split('.ngrok-free.app')[0]
+    except Exception as e:
+        raise RuntimeError("ngrok tunnel not available") from e

gr_tradinggame/manual/__init__.py

@@ -0,0 +1,136 @@
+import numpy
+import ipywidgets as widgets
+from IPython.display import display, clear_output
+import plotly.graph_objs as go
+import pandas as pd
+
+
+class ManualGame:
+    def __init__(self, team_names, max_rounds=30, lockout=3, width=1000, random_draw_function='a'):
+        self.team_names = team_names
+        self.max_rounds = max_rounds
+        self.lockout = lockout
+        self.random_draw_function = random_draw_function
+        if isinstance(self.random_draw_function, str):
+            if self.random_draw_function.lower().strip() == 'a':
+                self.random_draw_function = lambda: numpy.random.exponential(10)
+            elif self.random_draw_function.lower().strip() == 'b':
+                self.random_draw_function = lambda: numpy.random.normal(-0.2, 1)
+        self.width = width
+        self.initialize_ui()
+
+    def initialize_ui(self):
+        self.current_round = 0
+        self.team_scores = {team: [0] for team in self.team_names}
+        self.team_blocked_until = {team: -1 for team in self.team_names}
+        self.last_number = None
+        self.last_lockout = self.lockout
+        self.number_display = widgets.HTML(layout=dict(width='80%'))
+        self.team_buttons = {
+            team: widgets.ToggleButton(description=team, value=False, tooltip=team, layout=dict(width='50%'))
+            for team in self.team_names
+        }
+        self.submit_button = widgets.Button(description="Submit Selections", button_style='success', layout=dict(width='50%'))
+        self.output = widgets.Output()
+        self.controls = widgets.VBox([
+            self.number_display,
+            *self.team_buttons.values(),
+            self.submit_button,
+            self.output,
+        ],
+            layout=dict(width='40%', align_items='center')
+        )
+        self.plot_output = widgets.Output(layout=dict(width='100%'))
+
+        def update_plot():
+            fig = go.Figure()
+            for team in self.team_names:
+                fig.add_trace(go.Scatter(
+                    x=list(range(self.current_round + 1)),
+                    y=self.team_scores[team],
+                    mode='lines+markers',
+                    name=team
+                ))
+            fig.update_layout(xaxis_title='Round', yaxis_title='Score', xaxis_range=[0, self.max_rounds], width=self.width)
+            with self.plot_output:
+                clear_output(wait=True)
+                display(fig)
+
+        def start_new_round():
+            self.current_round += 1
+            self.last_number = self.random_draw_function()
+
+            self.number_display.value = f"""
+                <div style='text-align:center; padding: 10px;'>
+                    <h1 style='margin-bottom: 0;'>Round {self.current_round} / {self.max_rounds} <br> Lockout: {self.last_lockout}</h1>
+                    <h2 style='color:darkred; font-size: 48px; margin-top: 10px;'>Reward: {self.last_number:.2f}</h2>
+                </div>
+            """
+
+            for team, btn in self.team_buttons.items():
+                blocked = self.team_blocked_until[team] - self.current_round
+                is_blocked = blocked >= 0
+                btn.disabled = is_blocked
+                btn.value = False
+                btn.description = f'❌ {team} ({blocked + 1})' if is_blocked else team
+
+        def on_submit(_):
+            with self.output:
+                clear_output()
+                for team, btn in self.team_buttons.items():
+                    took_action = btn.value and not btn.disabled
+                    score = self.last_number if took_action else 0
+                    self.team_scores[team].append(self.team_scores[team][-1] + score)
+                    if took_action:
+                        self.team_blocked_until[team] = self.current_round + self.last_lockout
+                update_plot()
+            if self.current_round < self.max_rounds:
+                start_new_round()
+            else:
+                df = (
+                    pd.DataFrame(
+                        {x: self.team_scores[x][-1] for x in self.team_scores}.items(),
+                        columns=['Name', 'Score']
+                    )
+                    .sort_values('Score', ascending=False)
+                    .reset_index(drop=True)
+                    .rename(index=lambda x: x + 1)
+                    .round(2)
+                )
+                self.number_display.value = ''
+                self.submit_button.layout.display = 'none'
+                for x in self.team_buttons.values():
+                    x.layout.display = 'none'
+                with self.output:
+                    display(df)
+
+        self.submit_button.on_click(on_submit)
+        self.game_ui = widgets.HBox(
+            [self.controls, self.plot_output],
+            layout=widgets.Layout(
+                align_items='center',
+                justify_content='center',
+                border='solid 1px gray',
+                width='100%'
+            )
+        )
+
+        top_spacer = widgets.Box(layout=widgets.Layout(flex='1 1 auto'))
+        bottom_spacer = widgets.Box(layout=widgets.Layout(flex='1 1 auto'))
+        self.vertical_box = widgets.VBox(
+            [top_spacer, self.game_ui, bottom_spacer],
+            layout=widgets.Layout(
+                height='100vh',
+                display='flex',
+                flex_flow='column',
+                align_items='center',
+                justify_content='center',
+            )
+        )
+
+        update_plot()
+        start_new_round()
+
+    def _ipython_display_(self):
+        display(self.vertical_box)
+

gr_tradinggame-0.1.13.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: gr_tradinggame
+Version: 0.1.13
+Summary: Add your description here
+Author-email: Soeren Wolfers <soeren.wolfers@gresearch.com>, Ajay Mittal <ajaymittal2001@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: cloudpickle==3.1.1
+Requires-Dist: flask-ngrok==0.0.25
+Requires-Dist: flask==3.1.1
+Requires-Dist: ipython==7.34.0
+Requires-Dist: ipywidgets==7.7.1
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: plotly==5.10.0
+Requires-Dist: pyngrok==7.2.8
+Requires-Dist: requests>=2.32.3
+Description-Content-Type: text/markdown
+
+# Trading game for recruitment events. 
+
+## Installation
+
+`pip install gr-tradinggame`
+
+### Manual game
+
+1. Run the code in `notebooks/example_manual.ipynb` in a notebook (looks best on Colab, with fullscreen cell display). [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/soerenwolfers/gr_tradinggame/blob/main/notebooks/example_manual.ipynb)
+
+2. Have teams shout / show their decisions and enter them by clicking buttons. 
+
+### Coding game
+
+1. Run the code in `notebooks/example_server.ipynb`. [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/soerenwolfers/gr_tradinggame/blob/main/notebooks/example_server.ipynb)
+
+
+
+2. The output will contain `Serving <id>`. Give that `id` to the teams and have them test and submit their solutions with that `id` as in `notebooks/example_client.ipynb`. [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/soerenwolfers/gr_tradinggame/blob/main/notebooks/example_client.ipynb)
+
+3. Run the remaining cells in your server notebook to see who wins.
+
+
+
+

gr_tradinggame-0.1.13.dist-info/RECORD

@@ -0,0 +1,12 @@
+gr_tradinggame/__init__.py,sha256=f_XkRXIp0URwPWFmsMMKwN12zySh3mCtr55hiM3ZrYI,59
+gr_tradinggame/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_tradinggame/coding/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_tradinggame/coding/blackbox.py,sha256=tOcgtQB9lgT6ZG0S_IT8wszZlLL6gZx4UT8TBk5g5r0,1959
+gr_tradinggame/coding/client.py,sha256=h1QlRC1jmFim-IdCclMA9fJa3i-mG7LA7AdEIUd1BvI,5427
+gr_tradinggame/coding/gui.py,sha256=lXgMj3qz5BNVhpYapPLAsHWBimoidgrP5S_LxDnsKsg,6841
+gr_tradinggame/coding/server.py,sha256=s3Z4QaPAC6-w4rLhZFHaASJzp-SvjxB3HjRm164PTOs,2791
+gr_tradinggame/coding/util.py,sha256=Z4lGVhhMOPGZJwjZ3Wu5a8LAfG0vIyHd7KEFaOE6b2o,1243
+gr_tradinggame/manual/__init__.py,sha256=ml818maV8iA2J9S8VWrIGyiKRbRFuGcFoXB7LIkME2A,5551
+gr_tradinggame-0.1.13.dist-info/METADATA,sha256=Vm-9lmOyI8aycdH9wINx4gWGU-dXqY4Sl700VYrdtiA,1760
+gr_tradinggame-0.1.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+gr_tradinggame-0.1.13.dist-info/RECORD,,

gr_tradinggame-0.1.13.dist-info/WHEEL

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