sc-kernel 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

sc_kernel/__init__.py

@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = "0.4.0"

sc_kernel/kernel.py

@@ -1,49 +1,128 @@
 import json
 import platform
 import sys
-import time
+from functools import partial
 from subprocess import check_output
 import re
-from typing import Optional, List
+from typing import Dict, Optional
 import os
 
 import pexpect
 from IPython.lib.display import Audio
+from IPython.display import Image
 from metakernel import ProcessMetaKernel, REPLWrapper
 
 from . import __version__
 
+# idea from
+# https://github.com/supercollider/qpm/blob/d3f72894e289744f01f3c098ab0a474d5190315e/qpm/sclang_process.py#L62
+
+PLOT_HELPER = """
+var plot = {|w, fileName, waitTime|
+    var image;
+    var filePath;
+    (waitTime?1.0).wait;
+    fileName = fileName ? "sc_%.png".format({rrand(0, 9)}.dup(10).join(""));
+    filePath = cwd +/+ fileName;
+    if(w.isKindOf(Plotter), {
+        w = w.parent;
+    });
+    if(w.isNil, {"Can not create image of closed window".throw;});
+    image = Image.fromWindow(w).write(filePath);
+    "-----PLOTTED_IMAGE_%-----".format(filePath).postln;
+    image;
+};
+"""
+
+RECORD_HELPER = """
+var record = {|duration, fileName|
+    var filePath;
+    var recorder;
+    fileName = fileName ? "sc_%.flac".format({rrand(0, 9)}.dup(10).join(""));
+    filePath = cwd +/+ fileName;
+    Server.default.recorder.recHeaderFormat = "flac";
+    Server.default.recorder.recSampleFormat = "int16";
+    recorder = Server.default.record(path: filePath, duration: duration);
+    (duration+1).wait;
+    "-----RECORDED_AUDIO_%-----".format(filePath).postln;
+    recorder;
+};
+"""
+
+EXEC_WRAPPER = partial(
+    """
+var cwd = "{cwd}";
+{plot_helper}
+{record_helper}
+
+{{
+    var result;
+    "**** JUPYTER ****".postln;
+    result = {{ try {{
+        {code}
+    }} {{|error| "ERROR %".format(error).postln}} }}.value();
+    postf("-> %%\n", result);
+    "**** /JUPYTER ****".postln;
+}}.fork(AppClock);
+""".format,  # noqa
+    cwd=os.getcwd(),
+    plot_helper="" if os.environ.get("NO_QT") else PLOT_HELPER,
+    record_helper=RECORD_HELPER,
+)
+
+SEARCH_CLASSES = partial(
+    """
+var getClasses = {{|t|
+    var res = [];
+    if(t.size>2, {{
+        Class.allClasses.do({{ |class|
+            var name = class.name.asString;
+            if (name.beginsWith(t)) {{
+                res = res.add(name);
+            }};
+        }});
+    }});
+    res.cs;
+}};
+getClasses.("{search_term}");
+""".format  # noqa
+)
+
+
+class BgColors:
+    # from https://stackoverflow.com/a/287944/3475778
+    FAIL = "\033[91m"
+    END = "\x1b[0m"
+
 
 def get_kernel_json():
-    """Get the kernel json for the kernel.
-    """
+    """Get the kernel json for the kernel."""
     here = os.path.dirname(__file__)
-    with open(os.path.join(here, 'kernel.json')) as fid:
+    with open(os.path.join(here, "kernel.json")) as fid:
         data = json.load(fid)
-    data['argv'][0] = sys.executable
+    data["argv"][0] = sys.executable
     return data
 
 
 class SCKernel(ProcessMetaKernel):
-    app_name = 'supercollider_kernel'
-    name = 'SuperCollider Kernel'
-    implementation = 'sc_kernel'
+    app_name = "supercollider_kernel"
+    name = "SuperCollider Kernel"
+    implementation = "sc_kernel"
     implementation_version = __version__
-    language = 'supercollider'
+    language = "supercollider"
     language_info = {
-        'mimetype': 'text/x-sclang',
-        'name': 'smalltalk',  # although supercollider is included in pygments its not working here
-        'file_extension': '.scd',
-        'pygments_lexer': 'supercollider',
+        "mimetype": "text/x-sclang",
+        "name": "smalltalk",  # although supercollider is included in pygments its not working here
+        "file_extension": ".scd",
+        "pygments_lexer": "supercollider",
     }
     kernel_json = get_kernel_json()
 
-    METHOD_DUMP_REGEX = re.compile(r'(\w*)\s*\(')
-    HTML_HELP_FILE_PATH_REGEX = re.compile(r'-> file:\/\/(.*\.html)')
+    HTML_HELP_FILE_PATH_REGEX = re.compile(r"-> file:\/\/(.*\.html)")
     SCHELP_HELP_FILE_PATH_REGEX = re.compile(r"<a href='file:\/\/(.*\.schelp)'>")
-    SC_VERSION_REGEX = re.compile(r'sclang (\d+(\.\d+)+)')
-    METHOD_EXTRACTOR_REGEX = re.compile(r'([A-Z]\w*)\.(.*)')
-    RECORD_MAGIC_REGEX = re.compile(r'%%\s?record \"?([A-z \.]*)\"?')
+    SC_VERSION_REGEX = re.compile(r"sclang (\d+(\.\d+)+)")
+    PLOT_REGEX = re.compile(r"-{5}PLOTTED_IMAGE_(?P<ImagePath>[^%].*)-{5}")
+    RECORDING_REGEX = re.compile(r"-{5}RECORDED_AUDIO_(?P<AudioPath>[^%].*)-{5}")
 
     @property
     def language_version(self):
@@ -51,118 +130,97 @@ class SCKernel(ProcessMetaKernel):
 
     @property
     def banner(self):
-        return check_output([self._sclang_path, '-v']).decode('utf-8')
+        return check_output([self._sclang_path, "-v"]).decode("utf-8")
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._sclang_path = self._get_sclang_path()
         self.__sclang: Optional[REPLWrapper] = None
-        self.__sc_classes: Optional[List[str]] = None
         self.wrapper = self._sclang
-        self.recording_paths = set()
 
     @staticmethod
     def _get_sclang_path() -> str:
-        sclang_path = os.environ.get('SCLANG_PATH')
+        sclang_path = os.environ.get("SCLANG_PATH")
         if not sclang_path:
             p = platform.system()
-            if p == 'Linux':
-                sclang_path = 'sclang'
-            if p == 'Darwin':
-                sclang_path = '/Applications/SuperCollider.app/Contents/MacOS/sclang'
-            if p == 'Windows':
+            if p == "Linux":
+                sclang_path = "sclang"
+            if p == "Darwin":
+                sclang_path = "/Applications/SuperCollider.app/Contents/MacOS/sclang"
+            if p == "Windows":
                 raise NotImplementedError
         return sclang_path  # type: ignore
 
     @property
-    def _sclang(self) -> 'ScREPLWrapper':
+    def _sclang(self) -> "ScREPLWrapper":
         if self.__sclang:
             return self.__sclang  # type: ignore
-        self.__sclang = ScREPLWrapper(f'{self._sclang_path} -i jupyter')
+        self.__sclang = ScREPLWrapper(f"{self._sclang_path} -i jupyter")
         return self.__sclang
 
     def do_execute_direct(self, code: str, silent=False):
-        if code == '.':
-            code = 'CmdPeriod.run;'
-        for file_recording in self.RECORD_MAGIC_REGEX.findall(code):
-            # check https://en.wikipedia.org/wiki/HTML5_audio#Supported_audio_coding_formats
-            # for available formats in a browser and
-            # http://doc.sccode.org/Classes/SoundFile.html#-headerFormat
-            # for available SC formats
-            _, file_ext = os.path.splitext(file_recording)
-            if file_ext.lower() not in ['.flac', '.wav']:
-                self.log.error('Only FLAC and WAV is supported for browser playback!')
-            file_path = os.path.join(os.getcwd(), file_recording)
-            self.log.info(f'Start recording to {file_path}')
-            recording_code = f"""
-            s.recorder.recHeaderFormat = "{file_ext[1:]}";
-            s.recorder.recSampleFormat = "int24";
-            s.record("{file_path}");
-            """
-            code = recording_code + code
-            # remove magic from code execution
-            code = self.RECORD_MAGIC_REGEX.sub('', code)
-
+        if code == ".":
+            code = "CmdPeriod.run;"
         return super().do_execute_direct(
             code=code,
             silent=silent,
         )
 
     def _check_for_recordings(self, message):
-        """
-        As Jupyter Notebook struggles with audio files that are still written to we can only display
-        audio files once they are fully written.
-        As SuperCollider is only displaying the file name at the end
-
-        :param message:
-        :return:
-        """
-        # we also want to check the output that has been echoed before the matching of the regex
-        # because the SClang recorder works prepares async and we will not capture its output
-        # without preparing the record otherwise, check the docs
-        # https://doc.sccode.org/Classes/Recorder.html
-        message = message + self._sclang.before_output
-        recording_paths: List[str] = self._sclang.RECORD_MATCHER_REGEX.findall(message)
-        self.recording_paths.update(recording_paths)
-        for recording_path in recording_paths:
-            self.log.info(f'Found new recording: {recording_path}')
-
-        finished_recordings: List[str] = self._sclang.RECORDING_STOPPED_REGEX.findall(message)
-
-        displayed_recordings: List[str] = []
-        for finished_recording in finished_recordings:
-            for recording_path in [f for f in self.recording_paths if finished_recording in f]:
-                self.log.info(f'Found finished recording: {recording_path}')
-                time.sleep(1.0)  # wait for finished writing, just in case
-                self.Display(Audio(filename=recording_path))
-                displayed_recordings.append(recording_path)
-        self.recording_paths.difference_update(displayed_recordings)
+        audio_path: str
+        for audio_path in self.RECORDING_REGEX.findall(message):
+            try:
+                self.Display(Audio(audio_path))
+            except ValueError as e:
+                message += f"Error displaying {audio_path}: {e}\n"
+        return self.RECORDING_REGEX.sub("", message)
+
+    def _check_for_plot(self, message: str) -> str:
+        image_path: str
+        for image_path in self.PLOT_REGEX.findall(message):
+            try:
+                self.Display(Image(filename=image_path))
+            except (ValueError, FileNotFoundError) as e:
+                message += f"Error displaying {image_path}: {e}\n"
+
+        return self.PLOT_REGEX.sub("", message)
 
     def Write(self, message):
-        self._check_for_recordings(message)
+        message = self._check_for_recordings(message)
+        message = self._check_for_plot(message)
         super().Write(message)
 
-    @property
-    def _sc_classes(self) -> List[str]:
-        if self.__sc_classes:
-            return self.__sc_classes
-        self.__sc_classes = self._sclang.run_command('Class.allClasses.do({|c| c.postln; nil;})\n').split('\n')[:-1]
-        return self.__sc_classes  # type: ignore
-
-    def get_completions(self, info):
-        code: str = info['obj']  # returns everything in the line before the cursor
-        if '.' not in code:
-            # only return classes if no dot is present
-            return [c for c in self._sc_classes if c.startswith(code)]
-        if code.count('.') == 1:
-            # @todo too hacky :/
-            for sc_class, sc_method in self.METHOD_EXTRACTOR_REGEX.findall(code):
-                output = self._sclang.run_command(f'{sc_class}.dumpAllMethods;', timeout=10)
-                return [f'{sc_class}.{m}' for m in self.METHOD_DUMP_REGEX.findall(output) if m.startswith(sc_method)]
-
-    def get_kernel_help_on(self, info, level=0, none_on_fail=False):
-        code = info['obj'].split('.')[0]
-        output = self._sclang.run_command(f'{code}.helpFilePath;')
+    @staticmethod
+    def extract_class_name(obj: str) -> str:
+        reverse_class_name = ""
+        # not used but maybe later
+        reverse_method_name = None  # noqa
+
+        # chars which delimit a new class
+        TERMINAL_CHARS = [" ", "(", ")"]
+
+        for o in obj[::-1]:
+            if o in TERMINAL_CHARS:
+                break
+            if o == ".":
+                # everything after a . is a method - reset our counter
+                reverse_method_name = reverse_class_name  # noqa
+                reverse_class_name = ""
+                continue
+            reverse_class_name += o
+        return reverse_class_name[::-1]
+
+    def get_completions(self, info: Dict):
+        class_name = self.extract_class_name(info["obj"])
+        sc_string = self._sclang.run_command(
+            SEARCH_CLASSES(search_term=class_name), timeout=5
+        )
+        # need to remove -> from interpreter
+        return json.loads(sc_string[2:])
+
+    def get_kernel_help_on(self, info: Dict, level=0, none_on_fail=False):
+        code = self.extract_class_name(info["obj"])
+        output = self._sclang.run_command(f'SCDoc.findHelpFile("{code}");')
         help_file_paths = self.HTML_HELP_FILE_PATH_REGEX.findall(output)
         if help_file_paths:
             if os.path.isfile(help_file_paths[0]):
@@ -178,24 +236,22 @@ class SCKernel(ProcessMetaKernel):
 
 class ScREPLWrapper(REPLWrapper):
     def __init__(self, cmd_or_spawn, *args, **kwargs):
-        cmd = pexpect.spawn(
-            cmd_or_spawn,
-            encoding='utf-8'
-        )
+        cmd = pexpect.spawn(cmd_or_spawn, encoding="utf-8")
         try:
             # we wait for the Welcome message and throw everything before it away as well
-            cmd.expect('Welcome to SuperCollider.*', timeout=15)
+            cmd.expect("Welcome to SuperCollider.*", timeout=15)
         except pexpect.TIMEOUT as e:
-            print(f'Could not start sclang successfully: {e}')
+            print(f"Could not start sclang successfully: {e}")
             raise e
 
         super().__init__(
             cmd,
-            prompt_regex='',
-            prompt_change_cmd='',
+            prompt_regex="",
+            prompt_change_cmd="",
             new_prompt_regex="",
             prompt_emit_cmd="",
-            *args, **kwargs
+            *args,
+            **kwargs,
         )
         self.child: pexpect.spawn
         # increase buffer size so streaming of large data goes much faster
@@ -205,9 +261,13 @@ class ScREPLWrapper(REPLWrapper):
 
     BEGIN_TOKEN = "**** JUPYTER ****"
     END_TOKEN = "**** /JUPYTER ****"
-    COMMAND_REGEX = re.compile(r'\*{4} JUPYTER \*{4}(.*)\*{4} /JUPYTER \*{4}', re.DOTALL)
-    RECORD_MATCHER_REGEX = re.compile(r"Recording channels \[[\d ,]*\] \.\.\. \npath: \'(.*)'", re.MULTILINE)
-    RECORDING_STOPPED_REGEX = re.compile(r'Recording Stopped: \((.*)\)')
+    COMMAND_REGEX = re.compile(
+        r"\*{4} JUPYTER \*{4}(?P<Content>.*)\*{4} /JUPYTER \*{4}", re.DOTALL
+    )
+    ERROR_REGEX = re.compile(
+        r"(\*{4} JUPYTER \*{4})?(?P<Content>.*ERROR: .*\-{35})", re.DOTALL
+    )
+    THROW_REGEX = re.compile(r"(?P<Content>(ERROR: .*)?CALL STACK:)", re.DOTALL)
 
     def run_command(self, command, timeout=30, *args, **kwargs):
         """
@@ -223,26 +283,27 @@ class ScREPLWrapper(REPLWrapper):
         :param kwargs:
         :return: output of command as a string
         """
-        # idea from
-        # https://github.com/supercollider/qpm/blob/d3f72894e289744f01f3c098ab0a474d5190315e/qpm/sclang_process.py#L62
-
-        exec_command = '{ var result; "%s".postln; result = {%s}.value(); postf("-> %%\n", result); "%s".postln;}.fork(AppClock);' % (  # noqa
-            self.BEGIN_TOKEN, command, self.END_TOKEN)  # noqa
-
         # 0x1b is the escape key which tells sclang to evaluate any command b/c
         # we can not use \n as we can have multiple lines in our command
-        self.child.sendline(f'{exec_command}{chr(0x1b)}')
+        command = EXEC_WRAPPER(code=command)
+        # print(command)
+        self.child.sendline(f"{command}{chr(0x1b)}")
 
-        self.child.expect(self.COMMAND_REGEX, timeout=timeout)
+        self.child.expect(
+            [self.COMMAND_REGEX, self.ERROR_REGEX, self.THROW_REGEX], timeout=timeout
+        )
 
         # although \r\n is DOS style it is for some reason used by UNIX, see
         # https://pexpect.readthedocs.io/en/stable/overview.html#find-the-end-of-line-cr-lf-conventions
         # we also remove \r\n at start and end of each command with the slicing [2:-2]
-        output = self._clean_output(self.child.match.groups()[0])
+        output = self._clean_output(
+            self.child.match.groupdict().get("Content", "ERROR")
+        )
         # output = self.child.match.groups()[0][2:-2].replace('\r\n', '\n')
-        if 'ERROR: ' in output:
-            output += self.child.readline().replace('\r\n', '\n')
-
+        if "ERROR: " in output:
+            output += self.child.readline().replace("\r\n", "\n")
+            # add red color for fail
+            output = f"{BgColors.FAIL} {output} {BgColors.END}"
         return output
 
     @staticmethod
@@ -253,11 +314,11 @@ class ScREPLWrapper(REPLWrapper):
         :param output:
         :return:
         """
-        if output.startswith('\r\n'):
+        if output.startswith("\r\n"):
             output = output[2:]
-        if output.endswith('\r\n'):
+        if output.endswith("\r\n"):
             output = output[:-2]
-        return output.replace('\r\n', '\n')
+        return output.replace("\r\n", "\n")
 
     @property
     def before_output(self) -> str:

sc_kernel-0.5.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: sc_kernel
+Version: 0.5.0
+Summary: SuperCollider kernel for Jupyter
+Author: Dennis Scheiba
+License: BSD
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: IPython
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Multimedia :: Sound/Audio :: Sound Synthesis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: metakernel<0.31,>=0.23.0
+Requires-Dist: ipython<10.0,>=4.0
+Requires-Dist: pygments<3.0
+Requires-Dist: jupyterlab<5.0,>=3.0
+Requires-Dist: jupyter_server<3.0,>2.0
+Provides-Extra: dev
+Requires-Dist: coverage==5.2.1; extra == "dev"
+Requires-Dist: flake8<=6.0.0; extra == "dev"
+Requires-Dist: unittest-xml-reporting==3.0.4; extra == "dev"
+Requires-Dist: mypy<=1.0.0; extra == "dev"
+Requires-Dist: pre-commit==2.17.0; extra == "dev"
+Requires-Dist: black<=23.1.0; extra == "dev"
+Dynamic: license-file
+
+# Supercollider Jupyter Kernel
+
+This kernel allows running [SuperCollider](https://supercollider.github.io/) Code in a [Jupyter](https://jupyter.org/) environment.
+
+![Demo Notebook](demo.jpg)
+
+## Installation
+
+Please make sure one has installed [SuperCollider](https://supercollider.github.io/) and
+[Python 3 with pip](https://realpython.com/installing-python).
+
+* To install the kernel for Jupyter execute
+
+  ```shell
+  pip3 install --upgrade sc-kernel
+  ```
+
+  This will also install [Jupyter Lab](https://jupyter.org/) if it is not already installed on the system.
+
+* Start a new Jupyter Lab instance by executing `jupyter lab` in a console.
+
+* Click on the SuperCollider icon
+
+If one has not installed SuperCollider in the default location, one has to set a environment variable
+called `SCLANG_PATH` which points to the sclang executable.
+
+To uninstall the kernel execute
+
+```shell
+jupyter kernelspec uninstall sc_kernel
+```
+
+### As a Docker container
+
+It is also possible to run sc-kernel in a Docker container, although a sound output is not possible in this case.
+Assuming you have cloned the repository and opened a terminal in its directory.
+
+```shell
+# build container - takes some time b/c we build supercollider
+docker build -t sc_kernel .
+# run container
+# -v mounts the current directory to the container
+# -p passes the container port to our host
+docker run -v ${PWD}:/home/sc_kernel -p 8888:8888 sc_kernel
+```
+
+## Usage
+
+Contrary to ScIDE each document will run in its own interpreter and not in a shared one.
+This is the default behavior of Jupyter but maybe this will be changed at a later point.
+
+Currently it is only possible to use the default config - if you encounter missing classes
+it is probably caused that they are not available in the default config.
+
+### Stop sound
+
+Currently the `Cmd + .` command is not binded. Instead create a new cell with a single dot
+
+```supercollider
+.
+```
+
+and execute this cell. This will transform the command to `CommandPeriod.run;` which is what is actually called on the `Cmd + .` press in the IDE.
+
+### Recording
+
+`sc_kernel` provides an easy way to record audio to the local directory and store it embedded in the notebook
+so one can transfer the notebook into a website which has the audio files included.
+
+The audio is stored in FLAC with 16 bit resolution.
+
+The provided function `record` takes 2 arguments:
+
+* Duration in seconds
+* Filename which will be used for the recording, using the path of the notebook as base path.
+
+Assuming one has started the server, simply execute
+
+```supercollider
+Ndef(\sine, {
+    var sig = SinOsc.ar(LFDNoise0.kr(1.0!2).exprange(100, 400));
+    sig = sig * \amp.kr(0.2);
+    sig;
+}).play;
+
+record.(4.0);
+```
+
+![Recording](recording.png)
+
+### Plotting
+
+`sc_kernel` also provides a way to embed images of SuperCollider windows into the Jupyter document.
+First create a window that you want to embed into the document
+
+```supercollider
+w = {SinOsc.ar(2.0)}.plot(1.0);
+```
+
+After the plotting is finished by the server we can now simply save an image of the window
+to a file and also embed the image into the document via a SuperCollider helper method which is available.
+
+```supercollider
+plot.(w);
+```
+
+![Plotting magic](plotting.png)
+
+The image will be saved relative the directory where `jupyter lab` was executed.
+The optional second argument can be the filename.
+
+> Note that `{}.plot` does not return a `Window` but a `Plotter`, but `sc_kernel`
+> accesses the window of a `Plotter` automatically.
+>
+> For plotting e.g. the server meter you need to pass the proper window, so
+>
+> ```supercollider
+> a = s.meter;
+> // a is a ServerMeter
+>
+> // new cell
+> plot.(a.window, "meter.png");
+> ```
+
+### Autocomplete
+
+Simply push `Tab` to see available autocompletions.
+This is currently limited to scan for available classes.
+
+### Documentation
+
+To display the documentation of a Class, simply prepend a `?` to it and execute it, e.g.
+
+```supercollider
+?SinOsc
+```
+
+You can also hit `shift <tab>` iff the cursor is behind a class to trigger the inline documentation.
+
+![Inline documentation](inline_docs.png)
+
+### Real Time Collaboration
+
+Jupyter Lab allows for real time collaboration in which multiple users can write in the same document from different computers by visiting the Jupyter server via their browser.
+Each user can write and execute sclang statements on your local sclang interpreter and the cursors of each user is shown to everyone.
+
+This allows for interactive, shared sessions which can be an interesting live coding sessions.
+
+> Be aware that this can be a security threat as it allows for other people from within the network to execute arbitrary sclang commands on your computer
+
+To start such a session you can spin Jupyter Lab via
+
+```shell
+jupyter lab --ip 0.0.0.0 --collaborative --NotebookApp.token='sclang'
+```
+
+where the `NotebookApp.token` is the necessary password to login - set it to `''` if no password is wanted.
+
+Check out the [documentation on Jupyter Lab](https://jupyterlab.readthedocs.io/en/stable/user/rtc.html) about *Real Time Collaboration*.
+
+## Development
+
+Any PR is welcome! Please state the changes in an Issue.
+To contribute, please
+
+* Fork the repository and clone it to a local directory
+
+* Create a virtual environment and install the dev dependencies
+  in it with
+
+  ```shell
+  pip3 install -e ".[dev]"
+  ```
+
+* If one wants to add the kernel to an existing Jupyter installation one can execute
+
+  ```shell
+  jupyter kernelspec install sc_kernel
+  ```
+
+  and run `jupyter lab` from within the cloned directory as
+  we need to have access to `sc_kernel`.
+
+* Run `./run_tests.sh` and make a PR :)
+  Use `black sc_kernel test` to format the source code.
+
+## Maintainers
+
+* [Dennis Scheiba](https://dennis-scheiba.com)

sc_kernel-0.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sc_kernel/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
+sc_kernel/__main__.py,sha256=_ZNuw-RZoWvEFNAWCOMRRIZ11fKNY3WeHAGBrcWaTpU,126
+sc_kernel/kernel.json,sha256=ck5y4eT6sjMINUGTYZBOaDhsoO2Bj8vK0EkYIoSEV4c,106
+sc_kernel/kernel.py,sha256=_j0Wbx12LMqgPJweQZVAJZMhHxOJnDUnQp7K28Vw5K0,11074
+sc_kernel/images/logo-32x32.png,sha256=JsjTZpe6UkvbEqPr8x7Op8shzIuAGnVS3sFFjM3JotE,3949
+sc_kernel/images/logo-64x64.png,sha256=yjFvhw6uio4bx8KOW5RDGGASOyo6JkyE5CaSdh3wbt8,12511
+sc_kernel-0.5.0.data/data/share/jupyter/kernels/sc_kernel/kernel.json,sha256=ck5y4eT6sjMINUGTYZBOaDhsoO2Bj8vK0EkYIoSEV4c,106
+sc_kernel-0.5.0.data/data/share/jupyter/kernels/sc_kernel/logo-32x32.png,sha256=JsjTZpe6UkvbEqPr8x7Op8shzIuAGnVS3sFFjM3JotE,3949
+sc_kernel-0.5.0.data/data/share/jupyter/kernels/sc_kernel/logo-64x64.png,sha256=yjFvhw6uio4bx8KOW5RDGGASOyo6JkyE5CaSdh3wbt8,12511
+sc_kernel-0.5.0.dist-info/licenses/LICENSE,sha256=SFO9qjqxmDQwmS2w2NkXljrvheZBqzgzg6LANm-UA5I,1459
+sc_kernel-0.5.0.dist-info/METADATA,sha256=UsNjKm-kUapEBsfhyjDEEZVZTuKG3cAkSLIueABpW0o,6773
+sc_kernel-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sc_kernel-0.5.0.dist-info/top_level.txt,sha256=REBbQoy_WwYSyTAnZjqKTiwea6PdRv3CVK9My8LKj0g,10
+sc_kernel-0.5.0.dist-info/RECORD,,

{sc_kernel-0.3.2.dist-info → sc_kernel-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.35.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sc_kernel-0.3.2.dist-info/METADATA

@@ -1,139 +0,0 @@
-Metadata-Version: 2.1
-Name: sc-kernel
-Version: 0.3.2
-Summary: UNKNOWN
-Home-page: https://github.com/capital-G/sc_kernel
-Author: Dennis Scheiba
-License: BSD
-Platform: UNKNOWN
-Classifier: Framework :: IPython
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Topic :: System :: Shells
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: metakernel (>=0.23.0)
-Requires-Dist: ipython (>=4.0)
-Requires-Dist: pygments (>=2.1)
-Requires-Dist: jupyterlab (>=2.0)
-Provides-Extra: dev
-Requires-Dist: coverage (==5.2.1) ; extra == 'dev'
-Requires-Dist: flake8 (==3.8.3) ; extra == 'dev'
-Requires-Dist: unittest-xml-reporting (==3.0.4) ; extra == 'dev'
-Requires-Dist: mypy (==0.770) ; extra == 'dev'
-
-# Supercollider Jupyter Kernel
-
-This kernel allows running [SuperCollider](https://supercollider.github.io/) Code in a [Jupyter](https://jupyter.org/) environment.
-
-![Demo Notebook](demo.jpg)
-
-## Installation
-
-Please make sure one has installed [SuperCollider](https://supercollider.github.io/) and
-[Python 3 with pip](https://realpython.com/installing-python).
-
-* To install the kernel for Jupyter execute
-
-  ```shell
-  pip3 install sc-kernel
-  ```
-
-  This will also install [Jupyter Lab](https://jupyter.org/) if it is not already installed on the system.
-
-* Start a new Jupyter Lab instance by executing `jupyter lab` in a console.
-
-* Click on the SuperCollider icon
-
-If one has not installed SuperCollider in the default location, one has to set a environment variable
-called `SCLANG_PATH` which points to the sclang executable.
-
-To uninstall the kernel execute
-
-```shell
-jupyter kernelspec uninstall sc_kernel
-```
-
-## Usage
-
-### Stop sound
-
-Currently the `Cmd + .` command is not binded. Instead create a new cell with a single dot
-
-```
-.
-```
-
-and execute this cell. This will transform the command to `CommandPeriod.run;` which is what is actually called on the `Cmd + .` press in the IDE.
-
-
- ### Recording
-
-`sc_kernel` provides an easy way to record audio to the local directory and store it in the notebook
-so one can later share the notebook with the sound examples embedded.
-
-Assuming one has started the server, simply execute
-
-```supercollider
-%% record "my_file.flac"
-
-{SinOsc.ar(SinOsc.ar(200)*200)*0.2!2}.play;
-```
-
-to start the recording.
-
-To stop the recording, simply stop the Server recording via
-
-```supercollider
-s.stopRecording;
-```
-
-If one has chosen FLAC or WAV as file format, one will see a playback menu for the file within the notebook.
-
-![Recording magic](recording.png)
-
-If an relative path is provided as filename it will be put relative to the folder where `jupyter lab` was executed.
-If an absolute path is given the output will be directed to the absolute path.
-
-Keep in mind that **good browser support only exists for FLAC** and with WAV the seeking does not work.
-The standard recording format of supercollider AIFF is not supported by browsers.
-
-### Autocomplete
-
-Simply push `Tab` to see available autocompletions.
-
-### Documentation
-
-To display the documentation of a Class, simply prepend a `?` to it and execute it, e.g.
-
-```supercollider
-?SinOsc
-```
-
-## Development
-
-Any PR is welcome! Please state the changes in an Issue.
-To contribute, please
-
-* Fork the repository and clone it to a local directory
-
-* If one wants to add the kernel to an existing Jupyter installation one can execute
-
-  ```shell
-  jupyter kernelspec install sc_kernel
-  ```
-
-  and run `jupyter lab` from within the cloned directory as
-  we need to have access to `sc_kernel`.
-
-* Run `./run_tests.sh` and make a PR :)
-  The tests often run into a pexpect timeout for some reason.
-  They should pass if they are run alone.
-
-## Maintainers
-
-* [Dennis Scheiba](https://dennis-scheiba.com)
-
-

sc_kernel-0.3.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-sc_kernel/__init__.py,sha256=bqu4G7Is-8Were-hMi-SthEalL7QW-PAbKWGZ9pVB6U,22
-sc_kernel/__main__.py,sha256=_ZNuw-RZoWvEFNAWCOMRRIZ11fKNY3WeHAGBrcWaTpU,126
-sc_kernel/kernel.json,sha256=ck5y4eT6sjMINUGTYZBOaDhsoO2Bj8vK0EkYIoSEV4c,106
-sc_kernel/kernel.py,sha256=UZte2a7FRM-RZu4zmP_iW49v3je8p2g9jIzWrIDE0sU,10922
-sc_kernel/images/logo-32x32.png,sha256=JsjTZpe6UkvbEqPr8x7Op8shzIuAGnVS3sFFjM3JotE,3949
-sc_kernel/images/logo-64x64.png,sha256=yjFvhw6uio4bx8KOW5RDGGASOyo6JkyE5CaSdh3wbt8,12511
-sc_kernel-0.3.2.data/data/share/jupyter/kernels/sc_kernel/kernel.json,sha256=ck5y4eT6sjMINUGTYZBOaDhsoO2Bj8vK0EkYIoSEV4c,106
-sc_kernel-0.3.2.data/data/share/jupyter/kernels/sc_kernel/logo-32x32.png,sha256=JsjTZpe6UkvbEqPr8x7Op8shzIuAGnVS3sFFjM3JotE,3949
-sc_kernel-0.3.2.data/data/share/jupyter/kernels/sc_kernel/logo-64x64.png,sha256=yjFvhw6uio4bx8KOW5RDGGASOyo6JkyE5CaSdh3wbt8,12511
-sc_kernel-0.3.2.dist-info/LICENSE,sha256=SFO9qjqxmDQwmS2w2NkXljrvheZBqzgzg6LANm-UA5I,1459
-sc_kernel-0.3.2.dist-info/METADATA,sha256=T1jqGi-2UTRnsAq8b-rBxWxzAxg_Yf6iiHS590pb90o,3878
-sc_kernel-0.3.2.dist-info/WHEEL,sha256=EVRjI69F5qVjm_YgqcTXPnTAv3BfSUr0WVAHuSP3Xoo,92
-sc_kernel-0.3.2.dist-info/top_level.txt,sha256=REBbQoy_WwYSyTAnZjqKTiwea6PdRv3CVK9My8LKj0g,10
-sc_kernel-0.3.2.dist-info/RECORD,,