Skip to content

Commit

Permalink
Remove Google Colab header
Browse files Browse the repository at this point in the history
  • Loading branch information
@sualeh
sualeh committed May 6, 2024
1 parent fab548f commit e6ad318
Showing 1 changed file with 0 additions and 214 deletions.
214 changes: 0 additions & 214 deletions Notebooks/1_c#_unicode_char_literals.ipynb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,220 +7,6 @@
"# Unicode Character Literals"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"----------\n",
"\n",
"## Google Colab\n",
"\n",
"You can run this notebook in Google Colab. The cell below should be run only once, and then followed by a change of runtime to `Go (gonb)`. Refresh the browser before running any subsequent code. If you are not running the notebook in Google Colab, skip this section."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "polyglot-notebook"
}
},
"outputs": [],
"source": [
"#@title Prepare Google Colab for C# Kernel\n",
"\n",
"# Install dotnet\n",
"\n",
"!sudo apt-get update -qq &> /dev/null\n",
"!sudo apt-get install -y dotnet-sdk-7.0 -qq &> /dev/null\n",
"\n",
"# Install jupyter kernel\n",
"\n",
"!dotnet tool install --tool-path /usr/bin --version 1.0.360602 Microsoft.dotnet-interactive &> /dev/null\n",
"!dotnet interactive jupyter install &> /dev/null\n",
"\n",
"# Create proxy file\n",
"\n",
"with open(\"ipc_proxy_kernel.py\", \"w\") as f:\n",
" f.write(\"\"\"import zmq;\n",
"import json;\n",
"import argparse;\n",
"from threading import Thread;\n",
"from traitlets.traitlets import Type;\n",
"from jupyter_client import KernelClient;\n",
"from jupyter_client.session import Session;\n",
"from jupyter_client.channels import HBChannel;\n",
"from jupyter_client.manager import KernelManager;\n",
"\n",
"parser = argparse.ArgumentParser();\n",
"parser.add_argument(\"connection_file\");\n",
"parser.add_argument(\"--kernel\", type = str, required = True);\n",
"args = parser.parse_args();\n",
"\n",
"# parse connection file details\n",
"with open(args.connection_file, \"r\") as connection_file:\n",
" connection_file_contents = json.load(connection_file);\n",
" transport = str(connection_file_contents[\"transport\"]);\n",
" ip = str(connection_file_contents[\"ip\"]);\n",
" shell_port = int(connection_file_contents[\"shell_port\"]);\n",
" stdin_port = int(connection_file_contents[\"stdin_port\"]);\n",
" control_port = int(connection_file_contents[\"control_port\"]);\n",
" iopub_port = int(connection_file_contents[\"iopub_port\"]);\n",
" hb_port = int(connection_file_contents[\"hb_port\"]);\n",
" signature_scheme = str(connection_file_contents[\"signature_scheme\"]);\n",
" key = str(connection_file_contents[\"key\"]).encode();\n",
"# channel | kernel_type | client_type\n",
"# shell | ROUTER | DEALER\n",
"# stdin | ROUTER | DEALER\n",
"# ctrl | ROUTER | DEALER\n",
"# iopub | PUB | SUB\n",
"# hb | REP | REQ\n",
"zmq_context = zmq.Context()\n",
"\n",
"def create_and_bind_socket(port: int, socket_type: int):\n",
" if(port <= 0):\n",
" raise ValueError(f\"Invalid port: {port}\");\n",
" if(transport == \"tcp\"):\n",
" addr = f\"tcp://{ip}:{port}\";\n",
" elif(transport == \"ipc\"):\n",
" addr = f\"ipc://{ip}-{port}\";\n",
" else:\n",
" raise ValueError(f\"Unknown transport: {transport}\");\n",
" socket: zmq.Socket = zmq_context.socket(socket_type);\n",
" socket.linger = 1000; # ipykernel does this\n",
" socket.bind(addr);\n",
" return socket;\n",
"\n",
"shell_socket = create_and_bind_socket(shell_port, zmq.ROUTER);\n",
"stdin_socket = create_and_bind_socket(stdin_port, zmq.ROUTER);\n",
"control_socket = create_and_bind_socket(control_port, zmq.ROUTER);\n",
"iopub_socket = create_and_bind_socket(iopub_port, zmq.PUB);\n",
"hb_socket = create_and_bind_socket(hb_port, zmq.REP);\n",
"# Proxy and the real kernel have their own heartbeats. (shoutout to ipykernel\n",
"# for this neat little heartbeat implementation)\n",
"Thread(target = zmq.device, args = (zmq.QUEUE, hb_socket, hb_socket)).start();\n",
"\n",
"def ZMQProxyChannel_factory(proxy_server_socket: zmq.Socket):\n",
" class ZMQProxyChannel(object):\n",
" kernel_client_socket: zmq.Socket = None;\n",
" session: Session = None;\n",
"\n",
" def __init__(self, socket: zmq.Socket, session: Session, _ = None):\n",
" super().__init__();\n",
" self.kernel_client_socket = socket;\n",
" self.session = session;\n",
"\n",
" def start(self):\n",
" # Very convenient zmq device here, proxy will handle the actual zmq\n",
" # proxying on each of our connected sockets (other than heartbeat).\n",
" # It blocks while they are connected so stick it in a thread.\n",
" Thread(\n",
" target = zmq.proxy,\n",
" args = (proxy_server_socket, self.kernel_client_socket)\n",
" ).start();\n",
"\n",
" def stop(self):\n",
" if(self.kernel_client_socket is not None):\n",
" try:\n",
" self.kernel_client_socket.close(linger = 0);\n",
" except Exception:\n",
" pass;\n",
" self.kernel_client_socket = None;\n",
"\n",
" def is_alive(self):\n",
" return self.kernel_client_socket is not None;\n",
"\n",
" return ZMQProxyChannel\n",
"\n",
"class ProxyKernelClient(KernelClient):\n",
" shell_channel_class = Type(ZMQProxyChannel_factory(shell_socket));\n",
" stdin_channel_class = Type(ZMQProxyChannel_factory(stdin_socket));\n",
" control_channel_class = Type(ZMQProxyChannel_factory(control_socket));\n",
" iopub_channel_class = Type(ZMQProxyChannel_factory(iopub_socket));\n",
" hb_channel_class = Type(HBChannel);\n",
"\n",
"\n",
"kernel_manager = KernelManager();\n",
"kernel_manager.kernel_name = args.kernel;\n",
"kernel_manager.transport = \"tcp\";\n",
"kernel_manager.client_factory = ProxyKernelClient;\n",
"kernel_manager.autorestart = False;\n",
"# Make sure the wrapped kernel uses the same session info. This way we don't\n",
"# need to decode them before forwarding, we can directly pass everything\n",
"# through.\n",
"kernel_manager.session.signature_scheme = signature_scheme;\n",
"kernel_manager.session.key = key;\n",
"kernel_manager.start_kernel();\n",
"# Connect to the real kernel we just started and start up all the proxies.\n",
"kernel_client: ProxyKernelClient = kernel_manager.client();\n",
"kernel_client.start_channels();\n",
"# Everything should be up and running. We now just wait for the managed kernel\n",
"# process to exit and when that happens, shutdown and exit with the same code.\n",
"exit_code = kernel_manager.kernel.wait();\n",
"kernel_client.stop_channels();\n",
"zmq_context.destroy(0);\n",
"exit(exit_code);\"\"\");\n",
"\n",
"# Install proxy\n",
"\n",
"import os;\n",
"import sys;\n",
"import json;\n",
"import shutil;\n",
"import os.path;\n",
"from jupyter_client.kernelspec import KernelSpec, KernelSpecManager, NoSuchKernel;\n",
"\n",
"kernel_spec_manager = KernelSpecManager();\n",
"real_kernel_spec: KernelSpec = kernel_spec_manager.get_kernel_spec(\".net-csharp\");\n",
"real_kernel_install_path = real_kernel_spec.resource_dir;\n",
"new_kernel_name = \".net-csharp_tcp\";\n",
"new_kernel_install_path = os.path.join(\n",
" os.path.dirname(real_kernel_install_path), new_kernel_name\n",
");\n",
"shutil.move(real_kernel_install_path, new_kernel_install_path);\n",
"# Update the moved kernel name and args. We tag it _tcp because the proxy will\n",
"# impersonate it and should be the one using the real name.\n",
"new_kernel_json_path = os.path.join(new_kernel_install_path, \"kernel.json\");\n",
"with open(new_kernel_json_path, \"r\") as in_:\n",
" real_kernel_json = json.load(in_);\n",
" real_kernel_json[\"name\"] = new_kernel_name;\n",
" real_kernel_json[\"argv\"] = list(\n",
" map(\n",
" lambda arg: arg.replace(real_kernel_install_path, new_kernel_install_path),\n",
" real_kernel_json[\"argv\"]\n",
" )\n",
" );\n",
"with open(new_kernel_json_path, \"w\") as out:\n",
" json.dump(real_kernel_json, out);\n",
"os.makedirs(real_kernel_install_path)\n",
"proxy_kernel_implementation_path = os.path.join(\n",
" real_kernel_install_path, \"ipc_proxy_kernel.py\"\n",
");\n",
"proxy_kernel_spec = KernelSpec();\n",
"proxy_kernel_spec.argv = [\n",
" sys.executable,\n",
" proxy_kernel_implementation_path,\n",
" \"{connection_file}\",\n",
" f\"--kernel={new_kernel_name}\"\n",
"];\n",
"proxy_kernel_spec.display_name = real_kernel_spec.display_name;\n",
"proxy_kernel_spec.interrupt_mode = real_kernel_spec.interrupt_mode or \"message\";\n",
"proxy_kernel_spec.language = real_kernel_spec.language;\n",
"proxy_kernel_json_path = os.path.join(real_kernel_install_path, \"kernel.json\");\n",
"with open(proxy_kernel_json_path, \"w\") as out:\n",
" json.dump(proxy_kernel_spec.to_dict(), out, indent = 2);\n",
"new_name = shutil.copy(\"ipc_proxy_kernel.py\", proxy_kernel_implementation_path);\n",
"!rm ipc_proxy_kernel.py"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"----------"
]
},
{
"cell_type": "markdown",
"metadata": {},
Expand Down

0 comments on commit e6ad318

Please sign in to comment.