Hello community, here is the log from the commit of package jupyter-jupyterlab_templates for openSUSE:Factory checked in at 2019-11-29 15:58:44 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/jupyter-jupyterlab_templates (Old) and /work/SRC/openSUSE:Factory/.jupyter-jupyterlab_templates.new.26869 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "jupyter-jupyterlab_templates" Fri Nov 29 15:58:44 2019 rev:4 rq:751412 version:0.2.1 Changes: -------- --- /work/SRC/openSUSE:Factory/jupyter-jupyterlab_templates/jupyter-jupyterlab_templates.changes 2019-09-23 12:32:13.713661182 +0200 +++ /work/SRC/openSUSE:Factory/.jupyter-jupyterlab_templates.new.26869/jupyter-jupyterlab_templates.changes 2019-11-29 16:02:53.636805994 +0100 @@ -1,0 +2,6 @@ +Wed Nov 27 15:42:24 UTC 2019 - Todd R <toddrme2178@gmail.com> + +- Update to 0.2.1 + * Reload templates on disk + +------------------------------------------------------------------- Old: ---- jupyterlab_templates-0.2.0.tar.gz New: ---- jupyterlab_templates-0.2.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ jupyter-jupyterlab_templates.spec ++++++ --- /var/tmp/diff_new_pack.PZi5PP/_old 2019-11-29 16:02:54.332805708 +0100 +++ /var/tmp/diff_new_pack.PZi5PP/_new 2019-11-29 16:02:54.340805705 +0100 @@ -17,7 +17,7 @@ Name: jupyter-jupyterlab_templates -Version: 0.2.0 +Version: 0.2.1 Release: 0 Summary: Templates for notebooks in JupyterLab License: Apache-2.0 @@ -26,6 +26,7 @@ Source: https://files.pythonhosted.org/packages/source/j/jupyterlab_templates/jupyterlab_templates-%{version}.tar.gz BuildRequires: fdupes BuildRequires: python-rpm-macros +BuildRequires: python3-jupyter-packaging BuildRequires: python3-setuptools Requires: jupyter-jupyterlab >= 1.0.0 Provides: python3-jupyter_jupyterlab_templates = %{version} ++++++ jupyterlab_templates-0.2.0.tar.gz -> jupyterlab_templates-0.2.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/.bumpversion.cfg new/jupyterlab_templates-0.2.1/.bumpversion.cfg --- old/jupyterlab_templates-0.2.0/.bumpversion.cfg 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/.bumpversion.cfg 2019-10-29 21:30:21.000000000 +0100 @@ -0,0 +1,19 @@ +[bumpversion] +current_version = 0, 2, 1, 'final', 0 +commit = False +tag = False +parse = (?P<major>\d+)\,\ (?P<minor>\d+)\,\ (?P<patch>\d+)\,\ \'(?P<release>\S+)\'\,\ (?P<build>\d+) +serialize = + {major}, {minor}, {patch}, '{release}', {build} + +[bumpversion:part:release] +optional_value = final +values = + alpha + candidate + final + +[bumpversion:part:build] + +[bumpversion:file:jupyterlab_templates/_version.py] + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/CONTRIBUTING.md new/jupyterlab_templates-0.2.1/CONTRIBUTING.md --- old/jupyterlab_templates-0.2.0/CONTRIBUTING.md 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/CONTRIBUTING.md 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,46 @@ +# Contributing + +If you want to contribute to this repository here are some helpful guidelines. + +## Reporting bugs, feature requests, etc. + +To report bugs, request new features or similar, please open an issue on the Github +repository. + +A good bug report includes: + +- Expected behavior +- Actual behavior +- Steps to reproduce (preferably as minimal as possible) +- Possibly any output from the browser console (typically available via Ctrl + Shift + J or via F12). + +## Minor changes, typos etc. + +Minor changes can be contributed by navigating to the relevant files on the Github repository, +and clicking the "edit file" icon. By following the instructions on the page you should be able to +create a pull-request proposing your changes. A repository maintainer will then review your changes, +and either merge them, propose some modifications to your changes, or reject them (with a reason for +the rejection). + +## Setting up a development environment + +If you want to help resolve an issue by making some changes that are larger than that covered by the above paragraph, it is recommended that you: + +- Fork the repository on Github +- Clone your fork to your computer +- Run the following commands inside the cloned repository: + - `pip install -e .[dev]` - This will install the Python package in development + mode. + - `jupyter labextension install .` - This will add the lab extension development + mode. +- Validate the install by running the tests: + - `py.test` - This command will run the Python tests. + - `npm test` - This command will run the JS tests. + +Once you have such a development setup, you should: + +- Make the changes you consider necessary +- Run the tests to ensure that your changes does not break anything +- If you add new code, preferably write one or more tests for checking that your code works as expected. +- Commit your changes and publish the branch to your github repo. +- Open a pull-request (PR) back to the main repo on Github. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/LICENSE new/jupyterlab_templates-0.2.1/LICENSE --- old/jupyterlab_templates-0.2.0/LICENSE 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/LICENSE 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2019 Jupyterlab-templates contributors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/MANIFEST.in new/jupyterlab_templates-0.2.1/MANIFEST.in --- old/jupyterlab_templates-0.2.0/MANIFEST.in 2018-09-04 16:45:03.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/MANIFEST.in 2019-08-15 05:34:33.000000000 +0200 @@ -1,2 +1,35 @@ -recursive-include jupyterlab_templates/templates/ * +include LICENSE +include README.md +include CONTRIBUTING.md + include requirements.txt +include setup.cfg +include pyproject.toml +include .bumpversion.cfg +include jest.config.js +include Makefile + +graft tests + +# Documentation +graft docs +exclude docs/\#* + +# docs subdirs we want to skip +prune docs/build +prune docs/gh-pages +prune docs/dist + +# Webapp files +include package.json +include tsconfig.json +include tslint.json +graft src +graft style + +# Patterns to exclude from any directory +global-exclude *~ +global-exclude *.pyc +global-exclude *.pyo +global-exclude .git +global-exclude .ipynb_checkpoints diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/Makefile new/jupyterlab_templates-0.2.1/Makefile --- old/jupyterlab_templates-0.2.0/Makefile 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/Makefile 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,54 @@ +testjs: ## Clean and Make js tests + yarn test + +testpy: ## Clean and Make unit tests + python3 -m pytest -v tests --cov=jupyterlab_templates + +test: lint ## run the tests for travis CI + @ python3 -m pytest -v tests --cov=jupyterlab_templates + yarn test + +lint: ## run linter + flake8 jupyterlab_templates + yarn lint + +annotate: ## MyPy type annotation check + mypy -s jupyterlab_templates + +annotate_l: ## MyPy type annotation check - count only + mypy -s jupyterlab_templates | wc -l + +clean: ## clean the repository + find . -name "__pycache__" | xargs rm -rf + find . -name "*.pyc" | xargs rm -rf + find . -name ".ipynb_checkpoints" | xargs rm -rf + rm -rf .coverage cover htmlcov logs build dist *.egg-info lib node_modules + +install: ## install to site-packages + pip3 install . + +serverextension: install ## enable serverextension + jupyter serverextension enable --py jupyterlab_templates + +js: ## build javascript + yarn + yarn build + +labextension: js ## enable labextension + jupyter labextension install . + +dist: js ## dist to pypi + rm -rf dist build + python3 setup.py sdist + python3 setup.py bdist_wheel + twine check dist/* && twine upload dist/* + +# Thanks to Francoise at marmelab.com for this +.DEFAULT_GOAL := help +help: + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' + +print-%: + @echo '$*=$($*)' + +.PHONY: clean install serverextension labextension test tests help docs dist diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/PKG-INFO new/jupyterlab_templates-0.2.1/PKG-INFO --- old/jupyterlab_templates-0.2.0/PKG-INFO 2019-06-30 07:07:41.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/PKG-INFO 2019-10-29 21:30:55.000000000 +0100 @@ -1,7 +1,7 @@ Metadata-Version: 2.1 Name: jupyterlab_templates -Version: 0.2.0 -Summary: Templates for notebooks in JupyterLab +Version: 0.2.1 +Summary: Automatically version notebooks from JupyterLab Home-page: https://github.com/timkpaine/jupyterlab_templates Author: Tim Paine Author-email: t.paine154@gmail.com @@ -34,6 +34,9 @@ c.JupyterLabTemplates.include_default = True ``` + ## Templates for libraries + If you have tutorials or guides you'd like to install for users, simply copy them into your jupyter data folder inside the `notebook_templates` directory, e.g. `/usr/local/share/jupyter/notebook_templates/bqplot` for `bqplot`. + ### Flags - `template_dirs`: a list of directories. all `.ipynb` files in these directories will be listed as templates - `include_default`: include the default Sample template @@ -41,10 +44,13 @@ Keywords: jupyter jupyterlab Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 +Classifier: Framework :: Jupyter Provides-Extra: dev diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/README.md new/jupyterlab_templates-0.2.1/README.md --- old/jupyterlab_templates-0.2.0/README.md 2019-04-26 17:09:30.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/README.md 2019-08-15 05:34:52.000000000 +0200 @@ -26,6 +26,9 @@ c.JupyterLabTemplates.include_default = True ``` +## Templates for libraries +If you have tutorials or guides you'd like to install for users, simply copy them into your jupyter data folder inside the `notebook_templates` directory, e.g. `/usr/local/share/jupyter/notebook_templates/bqplot` for `bqplot`. + ### Flags - `template_dirs`: a list of directories. all `.ipynb` files in these directories will be listed as templates - `include_default`: include the default Sample template Binary files old/jupyterlab_templates-0.2.0/docs/example1.gif and new/jupyterlab_templates-0.2.1/docs/example1.gif differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jest.config.js new/jupyterlab_templates-0.2.1/jest.config.js --- old/jupyterlab_templates-0.2.0/jest.config.js 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/jest.config.js 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,15 @@ +module.exports = { + transform: { + "^.+\\.ts?$": "ts-jest", + "^.+\\.js$": "babel-jest", + ".+\\.(css|styl|less|sass|scss)$": "jest-transform-css" + }, + "moduleNameMapper":{ + "\\.(css|less|sass|scss)$": "<rootDir>/tests/js/styleMock.js", + "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/tests/js/fileMock.js" + }, + preset: 'ts-jest', + "transformIgnorePatterns": [ + "/node_modules/(?!@jupyterlab)" + ] +}; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyter-config/jupyter_notebook_config.d/jupyterlab_templates.json new/jupyterlab_templates-0.2.1/jupyter-config/jupyter_notebook_config.d/jupyterlab_templates.json --- old/jupyterlab_templates-0.2.0/jupyter-config/jupyter_notebook_config.d/jupyterlab_templates.json 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/jupyter-config/jupyter_notebook_config.d/jupyterlab_templates.json 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,7 @@ +{ + "NotebookApp": { + "nbserver_extensions": { + "jupyterlab_templates": true + } + } +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates/__init__.py new/jupyterlab_templates-0.2.1/jupyterlab_templates/__init__.py --- old/jupyterlab_templates-0.2.0/jupyterlab_templates/__init__.py 2019-06-29 17:36:45.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates/__init__.py 2019-08-15 05:34:33.000000000 +0200 @@ -1,4 +1,4 @@ -__version__ = '0.2.0' +from ._version import __version__ # noqa: F401 def _jupyter_server_extension_paths(): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates/_version.py new/jupyterlab_templates-0.2.1/jupyterlab_templates/_version.py --- old/jupyterlab_templates-0.2.0/jupyterlab_templates/_version.py 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates/_version.py 2019-10-29 21:30:21.000000000 +0100 @@ -0,0 +1,25 @@ +# Copyright (c) Jupyter Development Team. +# Distributed under the terms of the Modified BSD License. + +from collections import namedtuple + +VersionInfo = namedtuple('VersionInfo', [ + 'major', + 'minor', + 'micro', + 'releaselevel', + 'serial' +]) + +# DO NOT EDIT THIS DIRECTLY! It is managed by bumpversion +version_info = VersionInfo(0, 2, 1, 'final', 0) + +_specifier_ = {'alpha': 'a', 'beta': 'b', 'candidate': 'rc', 'final': ''} + +__version__ = '{}.{}.{}{}'.format( + version_info.major, + version_info.minor, + version_info.micro, + ('' + if version_info.releaselevel == 'final' + else _specifier_[version_info.releaselevel] + str(version_info.serial))) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates/extension.py new/jupyterlab_templates-0.2.1/jupyterlab_templates/extension.py --- old/jupyterlab_templates-0.2.0/jupyterlab_templates/extension.py 2019-06-29 21:09:52.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates/extension.py 2019-10-29 21:02:42.000000000 +0100 @@ -1,31 +1,62 @@ -import os -import os.path import fnmatch import json -import jupyter_core.paths +import os +import os.path from io import open + +import jupyter_core.paths + from notebook.base.handlers import IPythonHandler from notebook.utils import url_path_join +class TemplatesLoader(): + def __init__(self, template_dirs): + self.template_dirs = template_dirs + + def get_templates(self): + templates = {} + + for path in self.template_dirs: + abspath = os.path.abspath(os.path.realpath(path)) + files = [] + # get all files in subdirectories + for dirname, dirnames, filenames in os.walk(path): + if dirname == path: + # Skip top level + continue + for filename in fnmatch.filter(filenames, '*.ipynb'): + if '.ipynb_checkpoints' not in dirname: + files.append((os.path.join(dirname, filename), dirname.replace(path, ''), filename)) + + # pull contents and push into templates list + for f, dirname, filename in files: + with open(os.path.join(abspath, f), 'r', encoding='utf8') as fp: + content = fp.read() + templates[os.path.join(dirname, filename)] = {'path': f, 'dirname': dirname, 'filename': filename, 'content': content} + + return templates + + class TemplatesHandler(IPythonHandler): - def initialize(self, templates=None): - self.templates = templates + def initialize(self, loader): + self.loader = loader def get(self): temp = self.get_argument('template', '') if temp: - self.finish(self.templates[temp]) + self.finish(self.loader.get_templates()[temp]) else: self.set_status(404) class TemplateNamesHandler(IPythonHandler): - def initialize(self, templates=None): - self.templates = templates + def initialize(self, loader): + self.loader = loader - def get(self, template=None): - self.finish(json.dumps(sorted(self.templates.keys()))) + def get(self): + template_names = self.loader.get_templates().keys() + self.finish(json.dumps(sorted(template_names))) def load_jupyter_server_extension(nb_server_app): @@ -49,21 +80,8 @@ template_dirs.extend([os.path.join(x, 'notebook_templates') for x in jupyter_core.paths.jupyter_path()]) print('Search paths:\n\t%s' % '\n\t'.join(template_dirs)) - templates = {} - for path in template_dirs: - abspath = os.path.abspath(os.path.realpath(path)) - files = [] - # get all files in subdirectories - for dirname, dirnames, filenames in os.walk(path): - for filename in fnmatch.filter(filenames, '*.ipynb'): - files.append((os.path.join(dirname, filename), dirname.replace(path, ''), filename)) - - # pull contents and push into templates list - for f, dirname, filename in files: - with open(os.path.join(abspath, f), 'r', encoding='utf8') as fp: - content = fp.read() - templates[os.path.join(dirname, filename)] = {'path': f, 'dirname': dirname, 'filename': filename, 'content': content} - - print('Available templates:\n\t%s' % '\n\t'.join(t for t in templates)) - web_app.add_handlers(host_pattern, [(url_path_join(base_url, 'templates/names'), TemplateNamesHandler, {'templates': templates})]) - web_app.add_handlers(host_pattern, [(url_path_join(base_url, 'templates/get'), TemplatesHandler, {'templates': templates})]) + loader = TemplatesLoader(template_dirs) + print('Available templates:\n\t%s' % '\n\t'.join(t for t in loader.get_templates())) + + web_app.add_handlers(host_pattern, [(url_path_join(base_url, 'templates/names'), TemplateNamesHandler, {'loader': loader})]) + web_app.add_handlers(host_pattern, [(url_path_join(base_url, 'templates/get'), TemplatesHandler, {'loader': loader})]) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/PKG-INFO new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/PKG-INFO --- old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/PKG-INFO 2019-06-30 07:07:41.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/PKG-INFO 2019-10-29 21:30:55.000000000 +0100 @@ -1,7 +1,7 @@ Metadata-Version: 2.1 Name: jupyterlab-templates -Version: 0.2.0 -Summary: Templates for notebooks in JupyterLab +Version: 0.2.1 +Summary: Automatically version notebooks from JupyterLab Home-page: https://github.com/timkpaine/jupyterlab_templates Author: Tim Paine Author-email: t.paine154@gmail.com @@ -34,6 +34,9 @@ c.JupyterLabTemplates.include_default = True ``` + ## Templates for libraries + If you have tutorials or guides you'd like to install for users, simply copy them into your jupyter data folder inside the `notebook_templates` directory, e.g. `/usr/local/share/jupyter/notebook_templates/bqplot` for `bqplot`. + ### Flags - `template_dirs`: a list of directories. all `.ipynb` files in these directories will be listed as templates - `include_default`: include the default Sample template @@ -41,10 +44,13 @@ Keywords: jupyter jupyterlab Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 +Classifier: Framework :: Jupyter Provides-Extra: dev diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/SOURCES.txt new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/SOURCES.txt --- old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/SOURCES.txt 2019-06-30 07:07:41.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/SOURCES.txt 2019-10-29 21:30:55.000000000 +0100 @@ -1,9 +1,21 @@ +.bumpversion.cfg +CONTRIBUTING.md +LICENSE MANIFEST.in +Makefile README.md +jest.config.js +package.json +pyproject.toml requirements.txt setup.cfg setup.py +tsconfig.json +tslint.json +docs/example1.gif +jupyter-config/jupyter_notebook_config.d/jupyterlab_templates.json jupyterlab_templates/__init__.py +jupyterlab_templates/_version.py jupyterlab_templates/extension.py jupyterlab_templates.egg-info/PKG-INFO jupyterlab_templates.egg-info/SOURCES.txt @@ -11,4 +23,18 @@ jupyterlab_templates.egg-info/not-zip-safe jupyterlab_templates.egg-info/requires.txt jupyterlab_templates.egg-info/top_level.txt -jupyterlab_templates/templates/jupyterlab_templates/Sample.ipynb \ No newline at end of file +jupyterlab_templates/templates/jupyterlab_templates/Sample.ipynb +lab-dist/jupyterlab_templates-0.2.1.tgz +src/.DS_Store +src/index.ts +style/index.css +tests/.DS_Store +tests/__init__.py +tests/test_all.py +tests/test_extension.py +tests/test_init.py +tests/js/activate.test.ts +tests/js/assetsTransformer.js +tests/js/export.test.ts +tests/js/fileMock.js +tests/js/styleMock.js \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/requires.txt new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/requires.txt --- old/jupyterlab_templates-0.2.0/jupyterlab_templates.egg-info/requires.txt 2019-06-30 07:07:41.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/jupyterlab_templates.egg-info/requires.txt 2019-10-29 21:30:55.000000000 +0100 @@ -1,8 +1,8 @@ -jupyterlab>=0.35.4 +jupyterlab>=1.0.0 [dev] -jupyterlab>=0.35.4 pytest pytest-cov pylint flake8 +bumpversion Binary files old/jupyterlab_templates-0.2.0/lab-dist/jupyterlab_templates-0.2.1.tgz and new/jupyterlab_templates-0.2.1/lab-dist/jupyterlab_templates-0.2.1.tgz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/package.json new/jupyterlab_templates-0.2.1/package.json --- old/jupyterlab_templates-0.2.0/package.json 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/package.json 2019-10-29 21:30:21.000000000 +0100 @@ -0,0 +1,63 @@ +{ + "name": "jupyterlab_templates", + "version": "0.2.1", + "description": "A JupyterLab extension.", + "author": "Tim Paine", + "main": "lib/index.js", + "keywords": [ + "jupyter", + "jupyterlab", + "jupyterlab-extension" + ], + "scripts": { + "build": "tsc", + "build:lab": "rimraf lab-dist && mkdirp lab-dist && cd lab-dist && npm pack ..", + "build:all": "npm run build && npm run build:lab", + "clean": "rimraf lib", + "lint": "./node_modules/.bin/tslint './src/*.ts'", + "prepublishOnly": "npm run build", + "test": "jest --coverage --collectCoverageFrom=src/*.{ts}" + }, + "files": [ + "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}", + "style/**/*.css" + ], + "jupyterlab": { + "extension": true, + "discovery": { + "server": { + "base": { + "name": "jupyterlab_templates" + }, + "managers": [ + "pip" + ] + } + } + }, + "dependencies": { + "@jupyterlab/application": "^1.0.0", + "@jupyterlab/apputils": "^1.0.0", + "@jupyterlab/coreutils": "^3.0.0", + "@jupyterlab/docmanager": "^1.0.0", + "@jupyterlab/filebrowser": "^1.0.0", + "@jupyterlab/launcher": "^1.0.0", + "@jupyterlab/mainmenu": "^1.0.0", + "@jupyterlab/notebook": "^1.0.0", + "@phosphor/disposable": "^1.1.2", + "requests-helper": "^0.1.1" + }, + "devDependencies": { + "@babel/preset-env": "^7.5.5", + "@types/jest": "^24.0.4", + "babel-jest": "^24.8.0", + "isomorphic-fetch": "^2.2.1", + "jest": "^24.1.0", + "jest-transform-css": "^2.0.0", + "mkdirp": "^0.5.1", + "rimraf": "^2.6.1", + "ts-jest": "^23.10.4", + "tslint": "^5.14.0", + "typescript": "^3.1.6" + } +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/pyproject.toml new/jupyterlab_templates-0.2.1/pyproject.toml --- old/jupyterlab_templates-0.2.0/pyproject.toml 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/pyproject.toml 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,3 @@ +[build-system] +# Minimum requirements for the build system to execute. +requires = ["setuptools", "wheel", "jupyter-packaging"] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/requirements.txt new/jupyterlab_templates-0.2.1/requirements.txt --- old/jupyterlab_templates-0.2.0/requirements.txt 2018-12-29 21:55:36.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/requirements.txt 2019-08-15 05:34:33.000000000 +0200 @@ -1 +1 @@ -jupyterlab>=0.35.4 +jupyterlab>=1.0.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/setup.cfg new/jupyterlab_templates-0.2.1/setup.cfg --- old/jupyterlab_templates-0.2.0/setup.cfg 2019-06-30 07:07:41.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/setup.cfg 2019-10-29 21:30:55.000000000 +0100 @@ -7,6 +7,20 @@ [flake8] max-line-length = 200 +[manifix] +known-excludes = + .git* + .git/**/* + .travis.yml + **/node_modules/**/* + **/__py_cache__/**/* + **/*.pyc + package-lock.json + lib + build + dist + Untitled*.ipynb + [egg_info] tag_build = tag_date = 0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/setup.py new/jupyterlab_templates-0.2.1/setup.py --- old/jupyterlab_templates-0.2.0/setup.py 2019-06-29 17:36:57.000000000 +0200 +++ new/jupyterlab_templates-0.2.1/setup.py 2019-08-15 05:34:33.000000000 +0200 @@ -2,7 +2,18 @@ from codecs import open from os import path +from jupyter_packaging import ( + create_cmdclass, install_npm, ensure_targets, + combine_commands, ensure_python, get_version +) + +pjoin = path.join + +ensure_python(('2.7', '>=3.3')) + +name = 'jupyterlab_templates' here = path.abspath(path.dirname(__file__)) +version = get_version(pjoin(here, name, '_version.py')) with open(path.join(here, 'README.md'), encoding='utf-8') as f: long_description = f.read() @@ -10,10 +21,33 @@ with open(path.join(here, 'requirements.txt'), encoding='utf-8') as f: requires = f.read().split() + +data_spec = [ + # Lab extension installed by default: + ('share/jupyter/lab/extensions', + 'lab-dist', + 'jupyterlab_templates-*.tgz'), + # Config to enable server extension by default: + ('etc/jupyter', + 'jupyter-config', + '**/*.json'), +] + + +cmdclass = create_cmdclass('js', data_files_spec=data_spec) +cmdclass['js'] = combine_commands( + install_npm(here, build_cmd='build:all'), + ensure_targets([ + pjoin(here, 'lib', 'index.js'), + pjoin(here, 'style', 'index.css') + ]), +) + + setup( - name='jupyterlab_templates', - version='0.2.0', - description='Templates for notebooks in JupyterLab', + name=name, + version=version, + description='Automatically version notebooks from JupyterLab', long_description=long_description, url='https://github.com/timkpaine/jupyterlab_templates', author='Tim Paine', @@ -22,20 +56,26 @@ classifiers=[ 'Development Status :: 3 - Alpha', + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', + 'Framework :: Jupyter', ], - keywords='jupyter jupyterlab', + cmdclass=cmdclass, + keywords='jupyter jupyterlab', packages=find_packages(exclude=['tests', ]), - package_data={'jupyterlab_templates': ['jupyterlab_templates/templates/*']}, + install_requires=requires, + extras_require={ + 'dev': ['pytest', 'pytest-cov', 'pylint', 'flake8', 'bumpversion'] + }, include_package_data=True, zip_safe=False, - install_requires=requires, - extras_require={'dev': requires + ['pytest', 'pytest-cov', 'pylint', 'flake8']} + ) Binary files old/jupyterlab_templates-0.2.0/src/.DS_Store and new/jupyterlab_templates-0.2.1/src/.DS_Store differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/src/index.ts new/jupyterlab_templates-0.2.1/src/index.ts --- old/jupyterlab_templates-0.2.0/src/index.ts 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/src/index.ts 2019-10-29 21:02:42.000000000 +0100 @@ -0,0 +1,171 @@ +import { + ILayoutRestorer, JupyterFrontEnd, JupyterFrontEndPlugin, +} from "@jupyterlab/application"; + +import { + Dialog, ICommandPalette, showDialog, +} from "@jupyterlab/apputils"; + +import { + PageConfig, +} from "@jupyterlab/coreutils"; + +import { + IDocumentManager, +} from "@jupyterlab/docmanager"; + +import { + IFileBrowserFactory, +} from "@jupyterlab/filebrowser"; + +import { + ILauncher, +} from "@jupyterlab/launcher"; + +import { + IMainMenu, +} from "@jupyterlab/mainmenu"; + +import { + Widget, +} from "@phosphor/widgets"; + +import { + IRequestResult, request, +} from "requests-helper"; + +import "../style/index.css"; + +// tslint:disable: variable-name + +const extension: JupyterFrontEndPlugin<void> = { + activate, + autoStart: true, + id: "jupyterlab_templates", + optional: [ILauncher], + requires: [IDocumentManager, ICommandPalette, ILayoutRestorer, IMainMenu, IFileBrowserFactory], +}; + +let templates: string[]; + +export +class OpenTemplateWidget extends Widget { + constructor() { + const body = document.createElement("div"); + const label = document.createElement("label"); + label.textContent = "Template:"; + + const input = document.createElement("select"); + for (const t of templates) { + const val = document.createElement("option"); + val.label = t; + val.text = t; + val.value = t; + input.appendChild(val); + } + + // input.placeholder = 'select'; + + body.appendChild(label); + body.appendChild(input); + super({ node: body }); + } + + public getValue(): string { + return this.inputNode.value; + } + + get inputNode(): HTMLSelectElement { + return this.node.getElementsByTagName("select")[0] as HTMLSelectElement; + } +} + +function activate(app: JupyterFrontEnd, + docManager: IDocumentManager, + palette: ICommandPalette, + restorer: ILayoutRestorer, + menu: IMainMenu, + browser: IFileBrowserFactory, + launcher: ILauncher | null) { + + // grab templates from serverextension + request("get", PageConfig.getBaseUrl() + "templates/names").then((res: IRequestResult) => { + if (res.ok) { + templates = res.json() as string[]; + + if (templates.length > 0) { + // Add an application command + const open_command = "template:open"; + + app.commands.addCommand(open_command, { + caption: "Initialize a notebook from a template notebook", + execute: (args) => { + showDialog({ + body: new OpenTemplateWidget(), + buttons: [Dialog.cancelButton(), Dialog.okButton({ label: "GO" })], + focusNodeSelector: "input", + title: "Template", + }).then((result) => { + if (result.button.label === "Cancel") { + return; + } + if (result.value) { + request("get", + PageConfig.getBaseUrl() + "templates/get", + {template: result.value}, + ).then((res2: IRequestResult) => { + const data = res2.json() as {[key: string]: [string]}; + const path = browser.defaultBrowser.model.path; + + return new Promise((resolve) => { + app.commands.execute( + "docmanager:new-untitled", {path, type: "notebook" }, + ).then((model) => { + app.commands.execute("docmanager:open", { + factory: "Notebook", path: model.path, + }).then((widget) => { + widget.context.ready.then(() => { + widget.model.fromString(data.content); + resolve(widget); + }); + }); + }); + }); + }); + } + }); + }, + iconClass: "jp-TemplateIcon", + isEnabled: () => true, + label: "Template", + }); + + // Add a launcher item if the launcher is available. + if (launcher) { + launcher.add({ + args: { isLauncher: true, kernelName: "template" }, + category: "Notebook", + command: open_command, + // tslint:disable-next-line: max-line-length + kernelIconUrl: "data:image/png;base64,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", + rank: 1, + }); + } + + if (menu) { + // Add new text file creation to the file menu. + menu.fileMenu.newMenu.addGroup([{ command: open_command }], 40); + } + } else { + // tslint:disable-next-line: no-console + console.log("No JupyterLab templates available!"); + } + } + }); + + // tslint:disable-next-line: no-console + console.log("JupyterLab extension jupyterlab_templates is activated!"); +} + +export default extension; +export {activate as _activate}; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/style/index.css new/jupyterlab_templates-0.2.1/style/index.css --- old/jupyterlab_templates-0.2.0/style/index.css 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/style/index.css 2019-08-13 23:05:43.000000000 +0200 @@ -0,0 +1,3 @@ +.jp-TemplateIcon { + background-image: url("data:image/png;base64,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"); +} \ No newline at end of file Binary files old/jupyterlab_templates-0.2.0/tests/.DS_Store and new/jupyterlab_templates-0.2.1/tests/.DS_Store differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/js/activate.test.ts new/jupyterlab_templates-0.2.1/tests/js/activate.test.ts --- old/jupyterlab_templates-0.2.0/tests/js/activate.test.ts 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/js/activate.test.ts 2019-08-13 23:22:23.000000000 +0200 @@ -0,0 +1,9 @@ +import "isomorphic-fetch"; + +import {_activate} from '../../src/index'; + +describe('Checks activate', () => { + test("Check activate", () => { + expect(_activate); + }); +}); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/js/assetsTransformer.js new/jupyterlab_templates-0.2.1/tests/js/assetsTransformer.js --- old/jupyterlab_templates-0.2.0/tests/js/assetsTransformer.js 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/js/assetsTransformer.js 2019-08-13 23:22:23.000000000 +0200 @@ -0,0 +1,7 @@ +const path = require('path'); + +module.exports = { + process(src, filename, config, options) { + return 'module.exports = ' + JSON.stringify(path.basename(filename)) + ';'; + }, +};Tra \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/js/export.test.ts new/jupyterlab_templates-0.2.1/tests/js/export.test.ts --- old/jupyterlab_templates-0.2.0/tests/js/export.test.ts 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/js/export.test.ts 2019-08-13 23:22:23.000000000 +0200 @@ -0,0 +1,9 @@ +import "isomorphic-fetch"; + +import * as extension from '../../src/index'; + +describe('Checks exports', () => { + test("Check extension", () => { + expect(extension); + }); +}); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/js/fileMock.js new/jupyterlab_templates-0.2.1/tests/js/fileMock.js --- old/jupyterlab_templates-0.2.0/tests/js/fileMock.js 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/js/fileMock.js 2019-08-13 23:22:22.000000000 +0200 @@ -0,0 +1 @@ +module.exports = 'test-file-stub'; \ No newline at end of file diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/js/styleMock.js new/jupyterlab_templates-0.2.1/tests/js/styleMock.js --- old/jupyterlab_templates-0.2.0/tests/js/styleMock.js 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/js/styleMock.js 2019-08-13 23:22:23.000000000 +0200 @@ -0,0 +1 @@ +module.exports = {}; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/test_all.py new/jupyterlab_templates-0.2.1/tests/test_all.py --- old/jupyterlab_templates-0.2.0/tests/test_all.py 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/test_all.py 2019-08-13 23:22:39.000000000 +0200 @@ -0,0 +1,3 @@ +# for Coverage +from jupyterlab_templates import * +from jupyterlab_templates.extension import * diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/test_extension.py new/jupyterlab_templates-0.2.1/tests/test_extension.py --- old/jupyterlab_templates-0.2.0/tests/test_extension.py 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/test_extension.py 2019-09-15 04:29:33.000000000 +0200 @@ -0,0 +1,13 @@ +# for Coverage +from mock import patch, MagicMock +from jupyterlab_templates.extension import load_jupyter_server_extension + + +class TestExtension: + def test_load_jupyter_server_extension(self): + + m = MagicMock() + + m.web_app.settings = {} + m.web_app.settings['base_url'] = '/test' + load_jupyter_server_extension(m) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tests/test_init.py new/jupyterlab_templates-0.2.1/tests/test_init.py --- old/jupyterlab_templates-0.2.0/tests/test_init.py 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tests/test_init.py 2019-10-03 04:23:16.000000000 +0200 @@ -0,0 +1,8 @@ +# for Coverage +from mock import patch, MagicMock +from jupyterlab_templates import _jupyter_server_extension_paths + + +class TestInit: + def test__jupyter_server_extension_paths(self): + assert _jupyter_server_extension_paths() == [{"module": "jupyterlab_templates.extension"}] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tsconfig.json new/jupyterlab_templates-0.2.1/tsconfig.json --- old/jupyterlab_templates-0.2.0/tsconfig.json 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tsconfig.json 2019-08-15 05:34:33.000000000 +0200 @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "declaration": true, + "noImplicitAny": true, + "noEmitOnError": true, + "noUnusedLocals": true, + "allowSyntheticDefaultImports": true, + "module": "commonjs", + "moduleResolution": "node", + "target": "ES6", + "outDir": "./lib", + "lib": ["es5", "es2015.promise", "dom", "es2015.collection", "es2015.iterable"], + "types": ["jest"] + }, + "include": ["src/*"] +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/jupyterlab_templates-0.2.0/tslint.json new/jupyterlab_templates-0.2.1/tslint.json --- old/jupyterlab_templates-0.2.0/tslint.json 1970-01-01 01:00:00.000000000 +0100 +++ new/jupyterlab_templates-0.2.1/tslint.json 2019-08-13 23:23:04.000000000 +0200 @@ -0,0 +1,9 @@ +{ + "defaultSeverity": "error", + "extends": [ + "tslint:recommended" + ], + "jsRules": {}, + "rules": {}, + "rulesDirectory": [] +} \ No newline at end of file