commit jupyter-jupyterlab_templates for openSUSE:Factory

29 Nov 2019

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

    