├── .github
    └── FUNDING.yml
├── .gitignore
├── .sonarcloud.properties
├── .travis.yml
├── Dockerfile
├── README.md
├── docs
    ├── API_docs.md
    ├── Package-Manager-API.postman_collection.json
    ├── modal.png
    └── ui.png
└── extension
    ├── MANIFEST.in
    ├── VERSION
    ├── install.md
    ├── js
        ├── api.js
        ├── api_endpoints.json
        ├── common.js
        ├── extension.js
        ├── methods.js
        ├── scripts.js
        ├── templates
        │   ├── list_item.html
        │   ├── sidebar.css
        │   └── sidebar.html
        └── views.js
    ├── package.json
    ├── packagemanager
        ├── __init__.py
        ├── apihandlers.py
        ├── envmanager.py
        ├── packagemanagement.py
        ├── serverextension.py
        └── swanproject.py
    ├── requirements.txt
    ├── setup.py
    ├── tests
        ├── __init__.py
        └── test_modules.py
    ├── webpack.config.js
    └── yarn.lock


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | custom: ['https://p-y.tm/VTD-Qwj']
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | *.egg-info/
 24 | .installed.cfg
 25 | *.egg
 26 | MANIFEST
 27 | 
 28 | # PyInstaller
 29 | #  Usually these files are written by a python script from a template
 30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 31 | *.manifest
 32 | *.spec
 33 | 
 34 | # Installer logs
 35 | pip-log.txt
 36 | pip-delete-this-directory.txt
 37 | 
 38 | # Unit test / coverage reports
 39 | htmlcov/
 40 | .tox/
 41 | .coverage
 42 | .coverage.*
 43 | .cache
 44 | nosetests.xml
 45 | coverage.xml
 46 | *.cover
 47 | .hypothesis/
 48 | .pytest_cache/
 49 | 
 50 | # Translations
 51 | *.mo
 52 | *.pot
 53 | 
 54 | # Django stuff:
 55 | *.log
 56 | local_settings.py
 57 | db.sqlite3
 58 | 
 59 | # Flask stuff:
 60 | instance/
 61 | .webassets-cache
 62 | 
 63 | # Scrapy stuff:
 64 | .scrapy
 65 | 
 66 | # Sphinx documentation
 67 | docs/_build/
 68 | 
 69 | # PyBuilder
 70 | target/
 71 | 
 72 | # Jupyter Notebook
 73 | .ipynb_checkpoints
 74 | 
 75 | # pyenv
 76 | .python-version
 77 | 
 78 | # celery beat schedule file
 79 | celerybeat-schedule
 80 | 
 81 | # SageMath parsed files
 82 | *.sage.py
 83 | 
 84 | # Environments
 85 | .env
 86 | .venv
 87 | env/
 88 | venv/
 89 | ENV/
 90 | env.bak/
 91 | venv.bak/
 92 | 
 93 | # Spyder project settings
 94 | .spyderproject
 95 | .spyproject
 96 | 
 97 | # Rope project settings
 98 | .ropeproject
 99 | 
100 | # mkdocs documentation
101 | /site
102 | 
103 | # mypy
104 | .mypy_cache/
105 | extension/packagemanagerextension/.vscode/settings.json
106 | extension/.vscode/settings.json
107 | extension/node_modules/
108 | extension/packagemanager/js/extension.js
109 | 


--------------------------------------------------------------------------------
/.sonarcloud.properties:
--------------------------------------------------------------------------------
 1 | # Path to sources
 2 | sonar.sources=./extension
 3 | #sonar.exclusions=
 4 | #sonar.inclusions=
 5 | 
 6 | # Path to tests
 7 | #sonar.tests=
 8 | #sonar.test.exclusions=
 9 | #sonar.test.inclusions=
10 | 
11 | # Source encoding
12 | #sonar.sourceEncoding=UTF-8
13 | 
14 | # Exclusions for copy-paste detection
15 | #sonar.cpd.exclusions=


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: required
2 | 
3 | services:
4 |   - docker
5 | 
6 | script:
7 |   # build latest image
8 |   - docker build . -t swanimage


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM gitlab-registry.cern.ch/swan/docker-images/dev-jupyter
 2 | 
 3 | LABEL maintainer="Akash Ravi <akashkravi@gmail.com>"
 4 | 
 5 | USER root
 6 | 
 7 | RUN git clone https://github.com/techtocore/jupyter.git
 8 | RUN cd jupyter && \
 9 | rm -rf /opt/conda/lib/python3.7/site-packages/notebook/templates && \
10 | cp -rl templates /opt/conda/lib/python3.7/site-packages/notebook/ && \
11 | ls && \
12 | cd SwanContents && pip install --no-deps . && \
13 | jupyter nbextension install --py swancontents --system
14 | 
15 | RUN git clone https://github.com/Anaconda-Platform/nb_conda_kernels.git
16 | RUN cd nb_conda_kernels && \
17 | cat requirements.txt | xargs -n 1 pip install || true && \
18 | pip install -e . && \
19 | python -m nb_conda_kernels.install --enable && \
20 | cd ..
21 | 
22 | RUN git clone https://github.com/techtocore/Jupyter-Package-Manager.git
23 | RUN cd Jupyter-Package-Manager/extension && \
24 | git checkout swan-integration && \
25 | yarn install && \
26 | yarn run webpack && \
27 | python -m pip install -e . && \
28 | jupyter nbextension install --py packagemanager --system --symlink && \
29 | jupyter nbextension enable packagemanager --system --py && \
30 | jupyter serverextension enable --py --system packagemanager
31 | 
32 | USER $NB_UID
33 | 
34 | EXPOSE 8888/tcp


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Package manager for SWAN and Jupyter Notebooks 
 2 | 
 3 | [![Build Status](https://travis-ci.org/techtocore/Jupyter-Package-Manager.svg?branch=swan-integration)](https://travis-ci.org/techtocore/Jupyter-Package-Manager) [![Build status](https://ci.appveyor.com/api/projects/status/wo9msinix7vtotn3?svg=true)](https://ci.appveyor.com/project/techtocore/jupyter-package-manager) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=techtocore_Jupyter-Package-Manager&metric=alert_status)](https://sonarcloud.io/dashboard?id=techtocore_Jupyter-Package-Manager)
 4 | 
 5 | 
 6 | **[Link to Final Report](https://akashravi.github.io/SWAN-Package-Manager/)**
 7 | 
 8 | 
 9 | This Jupyter notebook extension will allow the users to install python modules (and their respective versions) via a user interface and make them available automatically inside the corresponding project.
10 | 
11 | Each project is internally mapped to a separate conda environment. This helps abstract the processing part, while providing an independent environment for each project. 
12 | 
13 | 
14 | ## Features
15 | 
16 | - View packages installed for a specific project
17 | - Update / Delete existing packages
18 | - Search for new packages and install them
19 | - Sync your project if any of your packages are missing or misconfigured
20 | 
21 | 
22 | ## Setup Instructions
23 | 
24 | - This project assumes a SWAN setup. The APIs require certain actions as prerequisites, which are already fulfilled by SWAN. 
25 | 
26 | - Please find the install instructions [here](extension/install.md)
27 | 
28 | 
29 | ## Usage Instructions
30 | 
31 | - From the Projects tab, you can create a folder by clicking on the  **`+`** button. Internally, this will create a new conda environment for all the notebooks inside it.
32 | 
33 | - To configure the project, click the cog button. This would reveal a side panel listing down the installed packages, along with their corresponding versions. 
34 | 
35 | - If in case the project metadata and the underlying environment are not in sync, the sidebar will also list the packages that need to be additionally installed. This is fundamental to share projects and collaborate with peers. By default, when a user clones a shared project, the required packages are not installed. This extension will let users install them.
36 | 
37 | - To install a new package, the user can search for them (an autocomplete feature is available). The selected packages are installed only when the user clicks the 'install' button. This allows the selection of other packages before issuing the 'install' command, which might take a while.
38 | 
39 | - Users can check for updates, for all or only the selected packages, by clicking the small cog button beside the list of installed packages. A pop-up modal will list the packages that need to be updated, along with their versions. Similarly, users can select one or more packages and uninstall them by clicking the bin icon.
40 | 
41 | - In order to create a notebook, click on the **`+`** button from inside a project or a regular folder. A list will then appear with the available kernels. Users will be able to launch notebooks only using the kernel corresponding to that project. Any external notebook (requiring a python kernel) placed under the project will also be using the same kernel.
42 | 
43 | 
44 | ## Documentation
45 | 
46 | - Please find the API Specification [here](docs/API_docs.md)
47 | - The code is documented with necessary inline comments and docstrings
48 | 
49 | 
50 | ## Screenshot
51 | 
52 | ![Alt text](/docs/ui.png?raw=true "Package Management UI")
53 | 
54 | 
55 | ## About
56 | 
57 | This extension is made for the purpose of fulfilment of the GSoC 2019 project at CERN ([Project Summary](https://summerofcode.withgoogle.com/projects/4999527885438976))
58 | 
59 | - Developer: Akash Ravi
60 | - Email ID: akashkravi@gmail.com
61 | - Linkedin Profile: https://www.linkedin.com/in/akash-ravi/
62 | 


--------------------------------------------------------------------------------
/docs/API_docs.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # Package-Manager-API
  3 | 
  4 | This file outlines the API specifications for the endpoints used by Jupyter Package Manager
  5 | 
  6 | ## Indices
  7 | 
  8 | * [Project Management](#project-management)
  9 | 
 10 |   * [Create Project](#1-create-project)
 11 |   * [Delete Project](#2-delete-project)
 12 |   * [Project Export](#3-project-export)
 13 |   * [Project Info](#4-project-info)
 14 |   * [Project Import](#5-project-import)
 15 |   * [Sync Project](#6-sync-project)
 16 |   * [Clone Project](#7-clone-project)
 17 | 
 18 | * [Package Management](#package-management)
 19 | 
 20 |   * [Install Packages](#1-install-packages)
 21 |   * [Uninstall Packages](#2-uninstall-packages)
 22 |   * [Check Updates for Packages](#3-check-updates-for-packages)
 23 |   * [Update Packages](#4-update-packages)
 24 |   * [Search Packages](#5-search-packages)
 25 | 
 26 | * [Maintenance Tasks](#maintenance-tasks)
 27 | 
 28 |   * [List Projects](#1-list-projects)
 29 |   * [Delete Project List](#2-delete-project-list)
 30 | 
 31 | --------
 32 | 
 33 | 
 34 | ## Maintenance Tasks
 35 | 
 36 | 
 37 | 
 38 | ### 1. List Projects
 39 | 
 40 | 
 41 | This API endpoint lists down all the projects created with this extension.
 42 | 
 43 | 
 44 | ***Endpoint:***
 45 | 
 46 | ```bash
 47 | Method: GET
 48 | Type: RAW
 49 | URL: http://localhost:8888/api/packagemanager/projects
 50 | ```
 51 | 
 52 | 
 53 | ***Sample Output:***
 54 | 
 55 | ```js
 56 | {
 57 |     "projects": [
 58 |         {
 59 |             "name": "swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16",
 60 |             "dir": "/home/akash/.conda/envs/swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16"
 61 |         }
 62 |     ]
 63 | }
 64 | ```
 65 | 
 66 | 
 67 | 
 68 | ### 2. Delete Project List
 69 | 
 70 | 
 71 | This API endpoint lets you delete multiple projects at once.
 72 | 
 73 | 
 74 | ***Endpoint:***
 75 | 
 76 | ```bash
 77 | Method: DELETE
 78 | Type: RAW
 79 | URL: http://localhost:8888/api/packagemanager/projects
 80 | ```
 81 | 
 82 | 
 83 | ***Headers:***
 84 | 
 85 | | Key | Value | Description |
 86 | | --- | ------|-------------|
 87 | | Content-Type | application/json |  |
 88 | 
 89 | 
 90 | 
 91 | ***Body:***
 92 | 
 93 | ```js        
 94 | {
 95 | 	"project": ["/MySwanProjectA", "/MySwanProjectB"]
 96 | }
 97 | ```
 98 | 
 99 | ***Sample Output:***
100 | 
101 | ```js
102 | {
103 |     "response":
104 |     [
105 |         {
106 | 	    "prefix": "/home/akash/.conda/envs/swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16",
107 | 	    "success": true,
108 | 	    "actions": {
109 | 		"PREFIX": "/home/akash/.conda/envs/swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16",
110 | 		"UNLINK": [
111 | 		    {
112 | 			"dist_name": "ipython_genutils-0.2.0-py37_0",
113 | 			"build_number": 0,
114 | 			"name": "ipython_genutils",
115 | 			"build_string": "py37_0",
116 | 			"base_url": "https://repo.anaconda.com/pkgs/main",
117 | 			"platform": "linux-64",
118 | 			"version": "0.2.0",
119 | 			"channel": "pkgs/main"
120 | 		    }
121 | 		],
122 | 		"FETCH": []
123 | 	    }
124 | 	}
125 |     ]
126 | }
127 | ```
128 | 
129 | 
130 | ## Package Management
131 | 
132 | 
133 | 
134 | ### 1. Install Packages
135 | 
136 | 
137 | The extension installs the package onto the corresponding project.
138 | 
139 | The .swanproject gets updated with the new package and respective version.
140 | 
141 | 
142 | ***Endpoint:***
143 | 
144 | ```bash
145 | Method: POST
146 | Type: RAW
147 | URL: http://localhost:8888/api/packagemanager/packages
148 | ```
149 | 
150 | 
151 | ***Headers:***
152 | 
153 | | Key | Value | Description |
154 | | --- | ------|-------------|
155 | | Content-Type | application/json |  |
156 | 
157 | 
158 | 
159 | ***Body:***
160 | 
161 | ```js        
162 | {
163 | 	"project": "/MySwanProjectA",
164 | 	"packages": ["pyyaml=3.13"]
165 | }
166 | ```
167 | 
168 | 
169 | 
170 | ### 2. Uninstall Packages
171 | 
172 | 
173 | The extension removes the package from the corresponding project.
174 | 
175 | The .swanproject gets updated with the current set of packages and respective versions.
176 | 
177 | 
178 | 
179 | ***Endpoint:***
180 | 
181 | ```bash
182 | Method: DELETE
183 | Type: RAW
184 | URL: http://localhost:8888/api/packagemanager/packages
185 | ```
186 | 
187 | 
188 | ***Headers:***
189 | 
190 | | Key | Value | Description |
191 | | --- | ------|-------------|
192 | | Content-Type | application/json |  |
193 | 
194 | 
195 | 
196 | ***Body:***
197 | 
198 | ```js        
199 | {
200 | 	"project": "/MySwanProjectA",
201 | 	"packages": ["pyyaml"]
202 | }
203 | ```
204 | 
205 | 
206 | 
207 | ### 3. Check Updates for Packages
208 | 
209 | 
210 | This API endpoint returns the list of packages that can be updated in the corresponding project.
211 | 
212 | 
213 | ***Endpoint:***
214 | 
215 | ```bash
216 | Method: GET
217 | Type: RAW
218 | URL: http://localhost:8888/api/packagemanager/packages/check_update
219 | ```
220 | 
221 | 
222 | ***Headers:***
223 | 
224 | | Key | Value | Description |
225 | | --- | ------|-------------|
226 | | Content-Type | application/json |  |
227 | 
228 | 
229 | 
230 | ***Query params:***
231 | 
232 | | Key | Value | Description |
233 | | --- | ------|-------------|
234 | | project | /MySwanProjectA |  |
235 | 
236 | 
237 | 
238 | ### 4. Update Packages
239 | 
240 | 
241 | The API endpoint installs the latest versions of packages onto the corresponding project.
242 | 
243 | The .swanproject gets updated with the new packages and respective versions.
244 | 
245 | 
246 | ***Endpoint:***
247 | 
248 | ```bash
249 | Method: PATCH
250 | Type: RAW
251 | URL: http://localhost:8888/api/packagemanager/packages
252 | ```
253 | 
254 | 
255 | ***Headers:***
256 | 
257 | | Key | Value | Description |
258 | | --- | ------|-------------|
259 | | Content-Type | application/json |  |
260 | 
261 | 
262 | 
263 | ***Body:***
264 | 
265 | ```js        
266 | {
267 | 	"project": "/MySwanProjectA",
268 | 	"packages": ["pyyaml"]
269 | }
270 | ```
271 | 
272 | 
273 | 
274 | ### 5. Search Packages
275 | 
276 | 
277 | This API endpoint lets you search a package name for installation.
278 | 
279 | 
280 | ***Endpoint:***
281 | 
282 | ```bash
283 | Method: GET
284 | Type: RAW
285 | URL: http://localhost:8888/api/packagemanager/packages/search
286 | ```
287 | 
288 | 
289 | 
290 | ***Query params:***
291 | 
292 | | Key | Value | Description |
293 | | --- | ------|-------------|
294 | | q | pyyaml=3.13 |  |
295 | 
296 | 
297 | 
298 | ## Project Management
299 | 
300 | 
301 | 
302 | ### 1. Create Project
303 | 
304 | 
305 | The API endpoint creates a conda environment with a Python kernel installed (ipykernel).
306 | 
307 | The .swanproject file gets filled with the swanproject-UUID (name of the environment internally) and the installed packages.
308 | 
309 | 
310 | 
311 | ***Endpoint:***
312 | 
313 | ```bash
314 | Method: POST
315 | Type: RAW
316 | URL: http://localhost:8888/api/packagemanager/projects
317 | ```
318 | 
319 | 
320 | ***Headers:***
321 | 
322 | | Key | Value | Description |
323 | | --- | ------|-------------|
324 | | Content-Type | application/json |  |
325 | 
326 | 
327 | 
328 | ***Body:***
329 | 
330 | ```js        
331 | {
332 | 	"project": "/MySwanProjectA",
333 | 	"env_type": "python3"
334 | }
335 | ```
336 | 
337 | ***Sample Output:***
338 | 
339 | ```js
340 | {
341 |     "prefix": "/home/akash/.conda/envs/swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16",
342 |     "success": true,
343 |     "actions": {
344 |         "PREFIX": "/home/akash/.conda/envs/swanproject-ad4d7f04-98c6-11e9-830c-ac2b6ebe8a16",
345 |         "LINK": [
346 |             {
347 |                 "dist_name": "ipython_genutils-0.2.0-py37_0",
348 |                 "build_number": 0,
349 |                 "name": "ipython_genutils",
350 |                 "build_string": "py37_0",
351 |                 "base_url": "https://repo.anaconda.com/pkgs/main",
352 |                 "platform": "linux-64",
353 |                 "version": "0.2.0",
354 |                 "channel": "pkgs/main"
355 |             }
356 |         ],
357 |         "FETCH": []
358 |     }
359 | }
360 | ```
361 | 
362 | 
363 | 
364 | ### 2. Delete Project
365 | 
366 | 
367 | The API endpoint deletes the conda environment corresponding to a project.
368 | 
369 | The 'kernel.json' for the environment corresponding to the project is removed.
370 | 
371 | Note that the project directory has to exist while calling this endpoint, and it is left unmodified by invoking this API.
372 | 
373 | 
374 | ***Endpoint:***
375 | 
376 | ```bash
377 | Method: DELETE
378 | Type: RAW
379 | URL: http://localhost:8888/api/packagemanager/projects
380 | ```
381 | 
382 | 
383 | ***Headers:***
384 | 
385 | | Key | Value | Description |
386 | | --- | ------|-------------|
387 | | Content-Type | application/json |  |
388 | 
389 | 
390 | 
391 | ***Body:***
392 | 
393 | ```js        
394 | {
395 | 	"project": ["/MySwanProjectA"]
396 | }
397 | ```
398 | 
399 | 
400 | 
401 | ### 3. Project Export
402 | 
403 | 
404 | The API endpoint exports the details of the conda environment corresponding to a project.
405 | 
406 | 
407 | 
408 | ***Endpoint:***
409 | 
410 | ```bash
411 | Method: GET
412 | Type: RAW
413 | URL: http://localhost:8888/api/packagemanager/project_info
414 | ```
415 | 
416 | 
417 | ***Headers:***
418 | 
419 | | Key | Value | Description |
420 | | --- | ------|-------------|
421 | | Content-Type | text/plain |  |
422 | 
423 | 
424 | 
425 | ***Query params:***
426 | 
427 | | Key | Value | Description |
428 | | --- | ------|-------------|
429 | | project | /MySwanProjectA |  |
430 | 
431 | ***Sample Output:***
432 | 
433 | ```
434 | # This file may be used to create an environment using:
435 | # $ conda create --name <env> --file <this file>
436 | # platform: linux-64
437 | _libgcc_mutex=0.1=main
438 | backcall=0.1.0=py37_0
439 | blas=1.0=mkl
440 | ```
441 | 
442 | 
443 | ### 4. Project Info
444 | 
445 | 
446 | The API endpoint outlines the details of the conda environment corresponding to a project.
447 | 
448 | 
449 | 
450 | ***Endpoint:***
451 | 
452 | ```bash
453 | Method: GET
454 | Type: RAW
455 | URL: http://localhost:8888/api/packagemanager/project_info
456 | ```
457 | 
458 | 
459 | ***Headers:***
460 | 
461 | | Key | Value | Description |
462 | | --- | ------|-------------|
463 | | Content-Type | application/json |  |
464 | 
465 | 
466 | 
467 | ***Query params:***
468 | 
469 | | Key | Value | Description |
470 | | --- | ------|-------------|
471 | | project | /MySwanProjectA |  |
472 | 
473 | ***Sample Output:***
474 | 
475 | ```
476 | {
477 |     "packages": [
478 |         {
479 |             "status": "installed",
480 |             "version": "3.28.0",
481 |             "build_string": "h7b6447c_0",
482 |             "name": "sqlite"
483 |         }
484 |     ],
485 |     "env": "swanproject-729350f4-9e8f-11e9-b575-ac2b6ebe8a16"
486 | }
487 | ```
488 | 
489 | ### 5. Project Import
490 | 
491 | 
492 | This API endpoint updates a project with all the packages obtained from an export file.
493 | 
494 | 
495 | ***Endpoint:***
496 | 
497 | ```bash
498 | Method: PUT
499 | Type: FORMDATA
500 | URL: http://localhost:8888/api/packagemanager/project_info
501 | ```
502 | 
503 | 
504 | ***Headers:***
505 | 
506 | | Key | Value | Description |
507 | | --- | ------|-------------|
508 | | Content-Type | application/x-www-form-urlencoded |  |
509 | 
510 | 
511 | 
512 | ***Body:***
513 | 
514 | | Key | Value | Description |
515 | | --- | ------|-------------|
516 | | file |  |  |
517 | | project | /MySwanProjectA |  |
518 | 
519 | 
520 | 
521 | ### 6. Sync Project
522 | 
523 | 
524 | This API endpoint syncs a .swanproject file and the corresponding conda env.
525 | 
526 | 
527 | ***Endpoint:***
528 | 
529 | ```bash
530 | Method: PATCH
531 | Type: RAW
532 | URL: http://localhost:8888/api/packagemanager/project_info
533 | ```
534 | 
535 | 
536 | ***Headers:***
537 | 
538 | | Key | Value | Description |
539 | | --- | ------|-------------|
540 | | Content-Type | application/json |  |
541 | 
542 | 
543 | 
544 | ***Body:***
545 | 
546 | ```js        
547 | {
548 | 	"project": "/MySwanProjectA"
549 | }
550 | ```
551 | 
552 | 
553 | 
554 | ### 7. Clone Project
555 | 
556 | 
557 | This enpoint creates a new env for a folder that has just been cloned.
558 | 
559 | 
560 | ***Endpoint:***
561 | 
562 | ```bash
563 | Method: POST
564 | Type: RAW
565 | URL: http://localhost:8888/api/packagemanager/project_clone
566 | ```
567 | 
568 | 
569 | ***Headers:***
570 | 
571 | | Key | Value | Description |
572 | | --- | ------|-------------|
573 | | Content-Type | application/json |  |
574 | 
575 | 
576 | 
577 | ***Body:***
578 | 
579 | ```js        
580 | {
581 | 	"project": "/MySwanProjectB"
582 | }
583 | ```
584 | 
585 | 
586 | 
587 | ---
588 | [Back to top](#package-manager-api)
589 | 


--------------------------------------------------------------------------------
/docs/Package-Manager-API.postman_collection.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"info": {
  3 | 		"_postman_id": "5aed158e-3fed-4077-a7ac-921db046b886",
  4 | 		"name": "Package-Manager-API",
  5 | 		"description": "This file outlines the API specifications for the endpoints used by Jupyter Package Manager",
  6 | 		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  7 | 	},
  8 | 	"item": [
  9 | 		{
 10 | 			"name": "Project Management",
 11 | 			"item": [
 12 | 				{
 13 | 					"name": "Create Project",
 14 | 					"request": {
 15 | 						"method": "POST",
 16 | 						"header": [
 17 | 							{
 18 | 								"key": "Content-Type",
 19 | 								"name": "Content-Type",
 20 | 								"value": "application/json",
 21 | 								"type": "text"
 22 | 							}
 23 | 						],
 24 | 						"body": {
 25 | 							"mode": "raw",
 26 | 							"raw": "{\n\t\"project\": \"/MySwanProjectA\",\n\t\"env_type\": \"python3\"\n}"
 27 | 						},
 28 | 						"url": {
 29 | 							"raw": "http://localhost:8888/api/packagemanager/projects",
 30 | 							"protocol": "http",
 31 | 							"host": [
 32 | 								"localhost"
 33 | 							],
 34 | 							"port": "8888",
 35 | 							"path": [
 36 | 								"api",
 37 | 								"packagemanager",
 38 | 								"projects"
 39 | 							]
 40 | 						},
 41 | 						"description": "The API endpoint creates a conda environment with a Python kernel installed (ipykernel).\n\nThe .swanproject file gets filled with the swanproject-UUID (name of the environment internally) and the installed packages.\n\nA 'kernel.json' file is generated and stored, to allow the users to create a notebook from the newly created environment corresponding to the project."
 42 | 					},
 43 | 					"response": []
 44 | 				},
 45 | 				{
 46 | 					"name": "Delete Project",
 47 | 					"request": {
 48 | 						"method": "DELETE",
 49 | 						"header": [
 50 | 							{
 51 | 								"key": "Content-Type",
 52 | 								"name": "Content-Type",
 53 | 								"type": "text",
 54 | 								"value": "application/json"
 55 | 							}
 56 | 						],
 57 | 						"body": {
 58 | 							"mode": "raw",
 59 | 							"raw": "{\n\t\"project\": [\"/MySwanProjectA\"]\n}"
 60 | 						},
 61 | 						"url": {
 62 | 							"raw": "http://localhost:8888/api/packagemanager/projects",
 63 | 							"protocol": "http",
 64 | 							"host": [
 65 | 								"localhost"
 66 | 							],
 67 | 							"port": "8888",
 68 | 							"path": [
 69 | 								"api",
 70 | 								"packagemanager",
 71 | 								"projects"
 72 | 							]
 73 | 						},
 74 | 						"description": "The API endpoint deletes the conda environment corresponding to a project.\n\nThe 'kernel.json' for the environment corresponding to the project is removed.\n\nNote that the project directory has to exist while calling this endpoint, and it is left unmodified by invoking this API."
 75 | 					},
 76 | 					"response": []
 77 | 				},
 78 | 				{
 79 | 					"name": "Project Export",
 80 | 					"request": {
 81 | 						"method": "GET",
 82 | 						"header": [
 83 | 							{
 84 | 								"key": "Content-Type",
 85 | 								"value": "text/plain",
 86 | 								"type": "text"
 87 | 							}
 88 | 						],
 89 | 						"body": {
 90 | 							"mode": "raw",
 91 | 							"raw": ""
 92 | 						},
 93 | 						"url": {
 94 | 							"raw": "http://localhost:8888/api/packagemanager/project_info?project=/MySwanProjectA",
 95 | 							"protocol": "http",
 96 | 							"host": [
 97 | 								"localhost"
 98 | 							],
 99 | 							"port": "8888",
100 | 							"path": [
101 | 								"api",
102 | 								"packagemanager",
103 | 								"project_info"
104 | 							],
105 | 							"query": [
106 | 								{
107 | 									"key": "project",
108 | 									"value": "/MySwanProjectA"
109 | 								}
110 | 							]
111 | 						},
112 | 						"description": "The API endpoint exports the details of the conda environment corresponding to a project.\n"
113 | 					},
114 | 					"response": []
115 | 				},
116 | 				{
117 | 					"name": "Project Info",
118 | 					"request": {
119 | 						"method": "GET",
120 | 						"header": [
121 | 							{
122 | 								"key": "Content-Type",
123 | 								"value": "application/json",
124 | 								"type": "text"
125 | 							}
126 | 						],
127 | 						"body": {
128 | 							"mode": "raw",
129 | 							"raw": ""
130 | 						},
131 | 						"url": {
132 | 							"raw": "http://localhost:8888/api/packagemanager/project_info?project=/MySwanProjectA",
133 | 							"protocol": "http",
134 | 							"host": [
135 | 								"localhost"
136 | 							],
137 | 							"port": "8888",
138 | 							"path": [
139 | 								"api",
140 | 								"packagemanager",
141 | 								"project_info"
142 | 							],
143 | 							"query": [
144 | 								{
145 | 									"key": "project",
146 | 									"value": "/MySwanProjectA"
147 | 								}
148 | 							]
149 | 						},
150 | 						"description": "The API endpoint outlines the details of the conda environment corresponding to a project.\n"
151 | 					},
152 | 					"response": []
153 | 				},
154 | 				{
155 | 					"name": "Project Import",
156 | 					"request": {
157 | 						"method": "PUT",
158 | 						"header": [
159 | 							{
160 | 								"key": "Content-Type",
161 | 								"name": "Content-Type",
162 | 								"value": "application/x-www-form-urlencoded",
163 | 								"type": "text"
164 | 							}
165 | 						],
166 | 						"body": {
167 | 							"mode": "formdata",
168 | 							"formdata": [
169 | 								{
170 | 									"key": "file",
171 | 									"type": "file",
172 | 									"src": ""
173 | 								},
174 | 								{
175 | 									"key": "project",
176 | 									"value": "/MySwanProjectA",
177 | 									"type": "text"
178 | 								}
179 | 							]
180 | 						},
181 | 						"url": {
182 | 							"raw": "http://localhost:8888/api/packagemanager/project_info",
183 | 							"protocol": "http",
184 | 							"host": [
185 | 								"localhost"
186 | 							],
187 | 							"port": "8888",
188 | 							"path": [
189 | 								"api",
190 | 								"packagemanager",
191 | 								"project_info"
192 | 							]
193 | 						},
194 | 						"description": "This API endpoint updates a project with all the packages obtained from an export file."
195 | 					},
196 | 					"response": []
197 | 				},
198 | 				{
199 | 					"name": "Sync Project",
200 | 					"request": {
201 | 						"method": "PATCH",
202 | 						"header": [
203 | 							{
204 | 								"key": "Content-Type",
205 | 								"name": "Content-Type",
206 | 								"value": "application/json",
207 | 								"type": "text"
208 | 							}
209 | 						],
210 | 						"body": {
211 | 							"mode": "raw",
212 | 							"raw": "{\n\t\"project\": \"/MySwanProjectA\"\n}"
213 | 						},
214 | 						"url": {
215 | 							"raw": "http://localhost:8888/api/packagemanager/project_info",
216 | 							"protocol": "http",
217 | 							"host": [
218 | 								"localhost"
219 | 							],
220 | 							"port": "8888",
221 | 							"path": [
222 | 								"api",
223 | 								"packagemanager",
224 | 								"project_info"
225 | 							]
226 | 						},
227 | 						"description": "This API endpoint syncs a .swanproject file and the corresponding conda env."
228 | 					},
229 | 					"response": []
230 | 				},
231 | 				{
232 | 					"name": "Clone Project",
233 | 					"request": {
234 | 						"method": "POST",
235 | 						"header": [
236 | 							{
237 | 								"key": "Content-Type",
238 | 								"name": "Content-Type",
239 | 								"value": "application/json",
240 | 								"type": "text"
241 | 							}
242 | 						],
243 | 						"body": {
244 | 							"mode": "raw",
245 | 							"raw": "{\n\t\"project\": \"/MySwanProjectB\"\n}"
246 | 						},
247 | 						"url": {
248 | 							"raw": "http://localhost:8888/api/packagemanager/project_clone",
249 | 							"protocol": "http",
250 | 							"host": [
251 | 								"localhost"
252 | 							],
253 | 							"port": "8888",
254 | 							"path": [
255 | 								"api",
256 | 								"packagemanager",
257 | 								"project_clone"
258 | 							]
259 | 						},
260 | 						"description": "This enpoint creates a new env for a folder that has just been cloned."
261 | 					},
262 | 					"response": []
263 | 				}
264 | 			]
265 | 		},
266 | 		{
267 | 			"name": "Package Management",
268 | 			"item": [
269 | 				{
270 | 					"name": "Install Packages",
271 | 					"request": {
272 | 						"method": "POST",
273 | 						"header": [
274 | 							{
275 | 								"key": "Content-Type",
276 | 								"name": "Content-Type",
277 | 								"value": "application/json",
278 | 								"type": "text"
279 | 							}
280 | 						],
281 | 						"body": {
282 | 							"mode": "raw",
283 | 							"raw": "{\n\t\"project\": \"/MySwanProjectA\",\n\t\"packages\": [\"pyyaml=3.13\"]\n}"
284 | 						},
285 | 						"url": {
286 | 							"raw": "http://localhost:8888/api/packagemanager/packages",
287 | 							"protocol": "http",
288 | 							"host": [
289 | 								"localhost"
290 | 							],
291 | 							"port": "8888",
292 | 							"path": [
293 | 								"api",
294 | 								"packagemanager",
295 | 								"packages"
296 | 							]
297 | 						},
298 | 						"description": "The extension installs the package onto the corresponding project.\n\nThe .swanproject gets updated with the new package and respective version."
299 | 					},
300 | 					"response": []
301 | 				},
302 | 				{
303 | 					"name": "Uninstall Packages",
304 | 					"request": {
305 | 						"method": "DELETE",
306 | 						"header": [
307 | 							{
308 | 								"key": "Content-Type",
309 | 								"name": "Content-Type",
310 | 								"value": "application/json",
311 | 								"type": "text"
312 | 							}
313 | 						],
314 | 						"body": {
315 | 							"mode": "raw",
316 | 							"raw": "{\n\t\"project\": \"/MySwanProjectA\",\n\t\"packages\": [\"pyyaml\"]\n}"
317 | 						},
318 | 						"url": {
319 | 							"raw": "http://localhost:8888/api/packagemanager/packages",
320 | 							"protocol": "http",
321 | 							"host": [
322 | 								"localhost"
323 | 							],
324 | 							"port": "8888",
325 | 							"path": [
326 | 								"api",
327 | 								"packagemanager",
328 | 								"packages"
329 | 							]
330 | 						},
331 | 						"description": "The extension removes the package from the corresponding project.\n\nThe .swanproject gets updated with the current set of packages and respective versions.\n"
332 | 					},
333 | 					"response": []
334 | 				},
335 | 				{
336 | 					"name": "Check Updates for Packages",
337 | 					"request": {
338 | 						"method": "GET",
339 | 						"header": [
340 | 							{
341 | 								"key": "Content-Type",
342 | 								"name": "Content-Type",
343 | 								"type": "text",
344 | 								"value": "application/json"
345 | 							}
346 | 						],
347 | 						"body": {
348 | 							"mode": "raw",
349 | 							"raw": ""
350 | 						},
351 | 						"url": {
352 | 							"raw": "http://localhost:8888/api/packagemanager/packages/check_update?project=/MySwanProjectA",
353 | 							"protocol": "http",
354 | 							"host": [
355 | 								"localhost"
356 | 							],
357 | 							"port": "8888",
358 | 							"path": [
359 | 								"api",
360 | 								"packagemanager",
361 | 								"packages",
362 | 								"check_update"
363 | 							],
364 | 							"query": [
365 | 								{
366 | 									"key": "project",
367 | 									"value": "/MySwanProjectA"
368 | 								}
369 | 							]
370 | 						},
371 | 						"description": "This API endpoint returns the list of packages that can be updated in the corresponding project."
372 | 					},
373 | 					"response": []
374 | 				},
375 | 				{
376 | 					"name": "Update Packages",
377 | 					"request": {
378 | 						"method": "PATCH",
379 | 						"header": [
380 | 							{
381 | 								"key": "Content-Type",
382 | 								"name": "Content-Type",
383 | 								"value": "application/json",
384 | 								"type": "text"
385 | 							}
386 | 						],
387 | 						"body": {
388 | 							"mode": "raw",
389 | 							"raw": "{\n\t\"project\": \"/MySwanProjectA\",\n\t\"packages\": [\"pyyaml\"]\n}"
390 | 						},
391 | 						"url": {
392 | 							"raw": "http://localhost:8888/api/packagemanager/packages",
393 | 							"protocol": "http",
394 | 							"host": [
395 | 								"localhost"
396 | 							],
397 | 							"port": "8888",
398 | 							"path": [
399 | 								"api",
400 | 								"packagemanager",
401 | 								"packages"
402 | 							]
403 | 						},
404 | 						"description": "The API endpoint installs the latest versions of packages onto the corresponding project.\n\nThe .swanproject gets updated with the new packages and respective versions."
405 | 					},
406 | 					"response": []
407 | 				},
408 | 				{
409 | 					"name": "Search Packages",
410 | 					"request": {
411 | 						"method": "GET",
412 | 						"header": [],
413 | 						"body": {
414 | 							"mode": "raw",
415 | 							"raw": ""
416 | 						},
417 | 						"url": {
418 | 							"raw": "http://localhost:8888/api/packagemanager/packages/search?q=pyyaml=3.13",
419 | 							"protocol": "http",
420 | 							"host": [
421 | 								"localhost"
422 | 							],
423 | 							"port": "8888",
424 | 							"path": [
425 | 								"api",
426 | 								"packagemanager",
427 | 								"packages",
428 | 								"search"
429 | 							],
430 | 							"query": [
431 | 								{
432 | 									"key": "q",
433 | 									"value": "pyyaml=3.13"
434 | 								}
435 | 							]
436 | 						},
437 | 						"description": "This API endpoint lets you search a package name for installation."
438 | 					},
439 | 					"response": []
440 | 				}
441 | 			]
442 | 		},
443 | 		{
444 | 			"name": "Maintenance Tasks",
445 | 			"item": [
446 | 				{
447 | 					"name": "List Projects",
448 | 					"request": {
449 | 						"method": "GET",
450 | 						"header": [],
451 | 						"body": {
452 | 							"mode": "raw",
453 | 							"raw": ""
454 | 						},
455 | 						"url": {
456 | 							"raw": "http://localhost:8888/api/packagemanager/projects",
457 | 							"protocol": "http",
458 | 							"host": [
459 | 								"localhost"
460 | 							],
461 | 							"port": "8888",
462 | 							"path": [
463 | 								"api",
464 | 								"packagemanager",
465 | 								"projects"
466 | 							]
467 | 						},
468 | 						"description": "This API endpoint lists down all the projects created with this extension."
469 | 					},
470 | 					"response": []
471 | 				},
472 | 				{
473 | 					"name": "Delete Project List",
474 | 					"request": {
475 | 						"method": "DELETE",
476 | 						"header": [
477 | 							{
478 | 								"key": "Content-Type",
479 | 								"name": "Content-Type",
480 | 								"value": "application/json",
481 | 								"type": "text"
482 | 							}
483 | 						],
484 | 						"body": {
485 | 							"mode": "raw",
486 | 							"raw": "{\n\t\"project\": [\"/MySwanProjectA\", \"/MySwanProjectB\"]\n}"
487 | 						},
488 | 						"url": {
489 | 							"raw": "http://localhost:8888/api/packagemanager/projects",
490 | 							"protocol": "http",
491 | 							"host": [
492 | 								"localhost"
493 | 							],
494 | 							"port": "8888",
495 | 							"path": [
496 | 								"api",
497 | 								"packagemanager",
498 | 								"projects"
499 | 							]
500 | 						},
501 | 						"description": "This API endpoint lets you delete multiple projects at once."
502 | 					},
503 | 					"response": []
504 | 				}
505 | 			]
506 | 		}
507 | 	],
508 | 	"event": [
509 | 		{
510 | 			"listen": "prerequest",
511 | 			"script": {
512 | 				"id": "a03159ad-09ad-4264-8fc8-3f10e979f157",
513 | 				"type": "text/javascript",
514 | 				"exec": [
515 | 					""
516 | 				]
517 | 			}
518 | 		},
519 | 		{
520 | 			"listen": "test",
521 | 			"script": {
522 | 				"id": "e63cc583-2603-4d65-8e7c-4746ab04acb4",
523 | 				"type": "text/javascript",
524 | 				"exec": [
525 | 					""
526 | 				]
527 | 			}
528 | 		}
529 | 	]
530 | }


--------------------------------------------------------------------------------
/docs/modal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/techtocore/Jupyter-Package-Manager/9350b2aa18c22e1f615d8f73c88cc0ace6b4202d/docs/modal.png


--------------------------------------------------------------------------------
/docs/ui.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/techtocore/Jupyter-Package-Manager/9350b2aa18c22e1f615d8f73c88cc0ace6b4202d/docs/ui.png


--------------------------------------------------------------------------------
/extension/MANIFEST.in:
--------------------------------------------------------------------------------
1 | graft packagemanagerextension/nbextension
2 | include VERSION
3 | 


--------------------------------------------------------------------------------
/extension/VERSION:
--------------------------------------------------------------------------------
1 | v0.2.2


--------------------------------------------------------------------------------
/extension/install.md:
--------------------------------------------------------------------------------
 1 | # Installation
 2 | 
 3 | ## Docker Setup
 4 | 
 5 | This lets you try out this extension on a local containerized setup of SWAN. This includes a preview of the integration with SWAN contents.
 6 | 
 7 | - Create a container from the Dockerfile
 8 | ```bash
 9 | docker build . -t swanimage
10 | docker create -t --name swancontainer -p 8888:8888 swanimage
11 | ```
12 | 
13 | - Start or stop the container
14 | ```bash
15 | docker start swancontainer
16 | docker stop swancontainer
17 | ```
18 | 
19 | - The logs of the container can be checked using 
20 | ```bash 
21 | docker logs swancontainer 
22 | ```
23 | 
24 | - The root shell of the container can be accessed using
25 | ```bash 
26 | docker exec -u root -it swancontainer /bin/bash
27 | ```
28 | 
29 | - By default, the application will run on port 8888
30 | 
31 | ## Development Setup
32 | - Prerequisites
33 |     - [Git](https://git-scm.com/)
34 |     - [Python 3](https://www.python.org/downloads/)
35 |     - [Jupyter Notebook](http://jupyter.org/)
36 |     - [Yarn](https://yarnpkg.com/lang/en/docs/install)
37 | 
38 | 
39 | - Download extension
40 | ```
41 | git clone https://github.com/techtocore/Jupyter-Package-Manager.git
42 | cd Jupyter-Package-Manager/extension
43 | ```
44 | 
45 | - Build and Install Dependencies
46 | ```bash
47 | yarn install
48 | yarn run webpack
49 | python -m pip install -e .
50 | ```
51 | 
52 | - Install and enable `nbextension` in Jupyter Namespace
53 | ```bash
54 | jupyter nbextension install --py packagemanager --system --symlink
55 | jupyter nbextension enable packagemanager --system --py
56 | ```
57 | 
58 | - Enable Jupyter Server Extension
59 | ```bash
60 | jupyter serverextension enable --py --system packagemanager
61 | ```
62 | 
63 | - For the purpose of API testing and development, please allow cross-site requests by adding `c.NotebookApp.disable_check_xsrf = True` (in ~/.jupyter/jupyter_notebook_config.py)
64 | 


--------------------------------------------------------------------------------
/extension/js/api.js:
--------------------------------------------------------------------------------
  1 | import $ from 'jquery';
  2 | import endpoints from './api_endpoints.json';
  3 | 
  4 | var api_url = (Jupyter.notebook_list || Jupyter.notebook).base_url + "api/packagemanager/";
  5 | 
  6 | 
  7 | /*
  8 | This function retrives the content of a cookie and returns the value for a matching key
  9 | This is used to retrive the xsrf token for making API calls
 10 | */
 11 | 
 12 | function get_cookie(name) {
 13 |     var cookieValue = null;
 14 |     if (document.cookie && document.cookie != '') {
 15 |         var cookies = document.cookie.split(';');
 16 |         for (var i = 0; i < cookies.length; i++) {
 17 |             var cookie = $.trim(cookies[i]);
 18 |             // Check if this cookie string begin with the name we want
 19 |             if (cookie.substring(0, name.length + 1) == (name + '=')) {
 20 |                 cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
 21 |                 break;
 22 |             }
 23 |         }
 24 |     }
 25 |     return cookieValue;
 26 | }
 27 | 
 28 | /*
 29 | This function makes the API calls to the specified endpoint with the corresponding headers
 30 | */
 31 | 
 32 | function api_call(endpoint, url, payload, success, error) {
 33 | 
 34 |     var settings = {
 35 |         url: api_url + endpoint.uri + url,
 36 |         method: endpoint.method,
 37 |         headers: {
 38 |             "Content-Type": "application/json",
 39 |             "cache-control": "no-cache",
 40 |             "X-CSRFToken": get_cookie('_xsrf')
 41 |         },
 42 |         processData: false,
 43 |         success: success,
 44 |         error: error
 45 |     };
 46 | 
 47 |     // Send the payload only if it is not empty
 48 | 
 49 |     if (!(Object.keys(payload).length === 0 && payload.constructor === Object)) {
 50 |         settings.data = JSON.stringify(payload);
 51 |     }
 52 | 
 53 |     $.ajax(settings);
 54 | }
 55 | 
 56 | /*
 57 | This function updates all the selected packages.
 58 | */
 59 | 
 60 | function update_packages(packages, project, success, error) {
 61 |     var payload = {
 62 |         'project': project,
 63 |         'packages': packages
 64 |     };
 65 |     api_call(endpoints.update_packages, "", payload, success, error);
 66 | }
 67 | 
 68 | /*
 69 | This function checks for updates in the selected project.
 70 | */
 71 | 
 72 | function check_update(project, success, error) {
 73 |     api_call(endpoints.checkupdate, project, {}, success, error);
 74 | }
 75 | 
 76 | /*
 77 | This function removes all the selected packages.
 78 | */
 79 | 
 80 | function delete_packages(packages, project, success, error) {
 81 |     var payload = {
 82 |         'project': project,
 83 |         'packages': packages
 84 |     };
 85 |     api_call(endpoints.delete_packages, "", payload, success, error);
 86 | }
 87 | 
 88 | function install_packages(packages, project, success, error) {
 89 |     var payload = {
 90 |         'project': project,
 91 |         'packages': packages
 92 |     };
 93 |     api_call(endpoints.install_packages, "", payload, success, error);
 94 | }
 95 | 
 96 | /*
 97 | This function returns the status of all the packages in a project.
 98 | */
 99 | 
100 | function get_info(dir, success, error) {
101 |     api_call(endpoints.getinfo, dir, {}, success, error);
102 | }
103 | 
104 | /*
105 | This function lets users search using any input query.
106 | */
107 | 
108 | function search(query, success, error) {
109 |     api_call(endpoints.search, query, {}, success, error);
110 | }
111 | 
112 | export default {
113 |     update_packages: update_packages,
114 |     install_packages: install_packages,
115 |     delete_packages: delete_packages,
116 |     get_info: get_info,
117 |     search: search,
118 |     check_update: check_update
119 | }


--------------------------------------------------------------------------------
/extension/js/api_endpoints.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "update_packages": {
 3 |         "uri": "packages",
 4 |         "method": "PATCH"
 5 |     },
 6 |     "checkupdate": {
 7 |         "uri": "packages/check_update?project=",
 8 |         "method": "GET"
 9 |     },
10 |     "delete_packages": {
11 |         "uri": "packages",
12 |         "method": "DELETE"
13 |     },
14 |     "install_packages": {
15 |         "uri": "packages",
16 |         "method": "POST"
17 |     },
18 |     "getinfo": {
19 |         "uri": "project_info?project=",
20 |         "method": "GET"
21 |     },
22 |     "search": {
23 |         "uri": "packages/search?q=",
24 |         "method": "GET"
25 |     }
26 | }


--------------------------------------------------------------------------------
/extension/js/common.js:
--------------------------------------------------------------------------------
 1 | import dialog from 'base/js/dialog';
 2 | import $ from 'jquery';
 3 | 
 4 | /*
 5 | This function is responsible for the generation of confirmation modals.
 6 | */
 7 | 
 8 | function confirm(title, msg, button_text, callback) {
 9 |     var buttons = { Cancel: {} };
10 |     buttons[button_text] = {
11 |         class: 'btn-danger btn-primary',
12 |         click: callback
13 |     };
14 | 
15 |     var opts = {
16 |         title: title,
17 |         body: msg,
18 |         buttons: buttons
19 |     };
20 | 
21 |     dialog.modal(opts);
22 | }
23 | 
24 | /*
25 | This function is responsible for the generation of alert/info modals.
26 | */
27 | 
28 | function display_msg(title, msg) {
29 |     var buttons = { Cancel: {} };
30 | 
31 |     var opts = {
32 |         title: title,
33 |         body: msg,
34 |         buttons: buttons
35 |     };
36 | 
37 |     dialog.modal(opts);
38 | }
39 | 
40 | /*
41 | Auxiliary function for checking the DOM for selected packages.
42 | */
43 | 
44 | function get_from_list(list) {
45 |     var arr = [];
46 |     for (var i = 0; i < list.length; i++) {
47 |         var element = list[i];
48 |         var val = $(element).children(".two").find('i');
49 |         var classes = $(val).attr('class').split(' ');
50 |         if (classes.includes('fa-check')) {
51 |             var packageName = $(element).find(".two .value-name").text();
52 |             var version = $(element).find(".three .value-version").text();
53 |             var pkg = packageName + "=" + version;
54 |             arr.push(pkg);
55 |         }
56 |     }
57 |     return arr;
58 | }
59 | 
60 | /*
61 | These functions return the list of currently selected packages.
62 | */
63 | 
64 | function get_to_install() {
65 |     var list = $(".to-install-values .one");
66 |     return get_from_list(list);
67 | }
68 | 
69 | function get_selected_packages() {
70 |     var list = $(".installed-values .one");
71 |     return get_from_list(list);
72 | }
73 | 
74 | export default {
75 |     confirm: confirm,
76 |     get_selected_packages: get_selected_packages,
77 |     get_to_install: get_to_install,
78 |     display_msg: display_msg
79 | }
80 | 


--------------------------------------------------------------------------------
/extension/js/extension.js:
--------------------------------------------------------------------------------
 1 | import Jupyter from 'base/js/namespace';
 2 | import $ from 'jquery';
 3 | import dialog from 'base/js/dialog';
 4 | import scripts from './scripts';
 5 | import methods from './methods';
 6 | import baseHTML from './templates/sidebar.html';
 7 | import api from './api';
 8 | import './templates/sidebar.css';
 9 | 
10 | /*
11 | This function populates all the data onto the sidebar and registers appropriate event handlers.
12 | */
13 | 
14 | function init(dir) {
15 |     scripts.package_view(dir);
16 |     scripts.search_view();
17 |     methods.update_packages(dir);
18 |     methods.delete_packages(dir);
19 |     methods.install_packages(dir);
20 | }
21 | 
22 | /*
23 | This function is the entry point to the extension.
24 | */
25 | 
26 | function load_ipython_extension() {
27 |     if (!Jupyter.notebook_list) return;
28 |     console.log('[PACKAGE MANAGER] Loading nbextension');
29 | }
30 | 
31 | /*
32 | This is the function that will be invoked on clicking the cog button on SWAN.
33 | A new sidebar will be created each time corresponding to the project from where it is called.
34 | */
35 | 
36 | function show_button(project) {
37 |     // Configure Sidebar
38 |     var modal = dialog.modal({
39 |         draggable: false,
40 |         title: 'Configure Project',
41 |         body: $.parseHTML(baseHTML)
42 |     }).attr('id', 'package-manager-modal').addClass('right full-body');
43 | 
44 |     modal.find(".modal-header").unbind("mousedown");
45 | 
46 |     modal.on('shown.bs.modal', function (e) {
47 |         init(project);
48 |     });
49 | }
50 | 
51 | /*
52 | This function filters the avaialble kernels and displays only the one corresponding to the current project.
53 | */
54 | 
55 | function filter_kernel(project) {
56 |     api.get_info(project, function (info) {
57 |         var env = info.env;
58 | 
59 |         var arr = $("#new-menu > li").map(function () { return this.id });
60 |         var idList = arr.get();
61 |         for (var i = 0; i < idList.length; i++) {
62 |             if (idList[i].startsWith('kernel-conda-env-swanproject')) {
63 |                 $('#' + idList[i]).css("display", "block");
64 |                 var name = idList[i].substring(17);
65 |                 // The first 17 characters correspond to 'kernel-conda-env-'
66 |                 name = name.slice(0, -3);
67 |                 // This will remove the '-py' at the end of the string
68 |                 if (env != name) {
69 |                     $('#' + idList[i]).css("display", "none");
70 |                 }
71 |                 else {
72 |                     var toRem = "[conda env:" + name + "]";
73 |                     // Substring to remove from the entry
74 |                     var kernelText = $('#' + idList[i]).find('a').text();
75 |                     kernelText = kernelText.replace(toRem, '');
76 |                     $('#' + idList[i]).find('a').text(kernelText);
77 |                     var kernelTitle = $('#' + idList[i]).find('a').attr('title');
78 |                     kernelTitle = kernelTitle.replace(toRem, '');
79 |                     $('#' + idList[i]).find('a').attr('title', kernelTitle);
80 |                 }
81 |             }
82 |             if (idList[i].startsWith('kernel-python')) {
83 |                 // This hides the default python kernels that might appear
84 |                 // TODO: Check for any exceptions and handle accordingly
85 |                 $('#' + idList[i]).css("display", "none");
86 |             }
87 |         }
88 |         // This hides the conda root environment
89 |         $('#kernel-conda-root-py').css("display", "none");
90 |     });
91 | }
92 | 
93 | 
94 | export {
95 |     load_ipython_extension,
96 |     show_button,
97 |     filter_kernel
98 | }


--------------------------------------------------------------------------------
/extension/js/methods.js:
--------------------------------------------------------------------------------
  1 | import $ from 'jquery';
  2 | import common from './common';
  3 | import api from './api';
  4 | import scripts from './scripts';
  5 | 
  6 | /*
  7 | This function returns the latest version of a package.
  8 | */
  9 | 
 10 | function check_new_version(updates, packagename, pkgversion) {
 11 |     for (var i = 0; i < updates.length; i++) {
 12 |         var element = updates[i];
 13 |         if (element.name === packagename) {
 14 |             return element.version;
 15 |         }
 16 |     }
 17 |     return pkgversion;
 18 | }
 19 | 
 20 | /*
 21 | This function lists down all the updates and requires a user confirmation.
 22 | */
 23 | 
 24 | function update_packages(project) {
 25 |     $('#updatebtn').unbind();
 26 |     $('#updatebtn').click(function () {
 27 |         if ($('#updatebtn').hasClass('fa-wrench')) {
 28 |             var selectedPackages = common.get_selected_packages();
 29 |             var html = $('<p> The following packages are about to be updated: </p> </br>');
 30 |             $('#updatebtn').toggleClass('fa-wrench fa-spinner').addClass('fa-spin');
 31 |             api.check_update(project, function (resp) {
 32 |                 $('#updatebtn').toggleClass('fa-wrench fa-spinner').removeClass('fa-spin');
 33 |                 var updates = resp.updates;
 34 |                 var packages = [];
 35 | 
 36 |                 if (selectedPackages.length > 0) {
 37 |                     html.append($('<ul/>'));
 38 | 
 39 |                     for (var i = 0; i < selectedPackages.length; i++) {
 40 |                         var element = selectedPackages[i];
 41 |                         element = element.split('=');
 42 |                         var pkg = element[0];
 43 |                         var ver = element[1];
 44 |                         var nver = check_new_version(updates, pkg, ver);
 45 |                         if (nver != ver) {
 46 |                             packages.push(pkg);
 47 |                             html.append("<li>" + pkg + " &nbsp; " + ver + " -> " + nver + "</li>");
 48 |                         }
 49 |                     }
 50 |                 }
 51 |                 else {
 52 |                     var list = $('.installed-values');
 53 |                     html.append($('<ul/>'));
 54 |                     for (var i = 0; i < list.length; i++) {
 55 |                         var element = list[i];
 56 |                         var pkg = $(element).find('.value-name')[0].innerText;
 57 |                         var ver = $(element).find('.value-version')[0].innerText;
 58 |                         var nver = check_new_version(updates, pkg, ver);
 59 |                         if (nver != ver) {
 60 |                             packages.push(pkg);
 61 |                             html.append("<li>" + pkg + " &nbsp; " + ver + " -> " + nver + "</li>");
 62 |                         }
 63 |                     }
 64 |                 }
 65 |                 if (packages.length === 0) {
 66 |                     html = $("<p> There are no updates available </p>");
 67 |                     common.display_msg("Update Packages", html);
 68 |                 }
 69 |                 else
 70 |                     common.confirm("Update Packages", html, "Confirm", function () {
 71 |                         $('#loadingtext').text("Updating Packages");
 72 |                         $('#loadingview').show();
 73 |                         api.update_packages(packages, project, function () {
 74 |                             $('#loadingview').hide();
 75 |                             scripts.package_view(project);
 76 |                         }, function () {
 77 |                             $('#loadingview').hide();
 78 |                             common.display_msg("Server Error", "The selected packages could not be updated. Please try again.");
 79 |                         });
 80 |                     });
 81 |             },
 82 |                 function () {
 83 |                     common.display_msg("Server Error", "Error in checking for new updates. Please try again.");
 84 |                 });
 85 |         }
 86 |     });
 87 | }
 88 | 
 89 | 
 90 | /*
 91 | This function lists down all the packages selected for removal and requires a user confirmation.
 92 | */
 93 | 
 94 | function delete_packages(project) {
 95 |     $('#deletebtn').unbind();
 96 |     $('#deletebtn').click(function () {
 97 |         var selectedPackages = common.get_selected_packages();
 98 |         var html = $("<p> The following packages are about to be deleted: </p> </br>");
 99 |         html.append($('<ul/>'));
100 |         var packages = [];
101 |         for (var i = 0; i < selectedPackages.length; i++) {
102 |             var element = selectedPackages[i];
103 |             element = element.split('=')[0];
104 |             packages.push(element);
105 |             html.append("<li>" + element + "</li>");
106 |         }
107 |         common.confirm("Delete Packages", html, "Confirm", function () {
108 |             $('#loadingtext').text("Removing Packages");
109 |             $('#loadingview').show();
110 |             api.delete_packages(packages, project, function () {
111 |                 $('#loadingview').hide();
112 |                 $('#deletebtn').css("display", "none");
113 |                 scripts.package_view(project);
114 |             }, function () {
115 |                 $('#loadingview').hide();
116 |                 common.display_msg("Server Error", "The selected packages could not be removed. Please try again.");
117 |             });
118 |         });
119 |     });
120 | }
121 | 
122 | 
123 | /*
124 | This function lists down all the packages selected for installation and requires a user confirmation.
125 | */
126 | 
127 | function install_packages(project) {
128 |     $('#installbtn').unbind();
129 |     $('#installbtn').click(function () {
130 |         var toInstall = common.get_to_install();
131 |         var html = $("<p> The following packages are about to be added: </p> </br>");
132 |         html.append($('<ul/>'));
133 |         for (var i = 0; i < toInstall.length; i++) {
134 |             var element = toInstall[i];
135 |             element = element.split('=')[0];
136 |             html.append("<li>" + element + "</li>");
137 |         }
138 |         common.confirm("Install Packages", html, "Confirm", function () {
139 |             $('#loadingtext').text("Adding Packages");
140 |             $('#loadingview').show();
141 |             api.install_packages(toInstall, project, function () {
142 |                 $('#loadingview').hide();
143 |                 scripts.package_view(project);
144 |             }, function () {
145 |                 $('#loadingview').hide();
146 |                 common.display_msg("Server Error", "The selected packages could not be installed. Please try again.");
147 |             });
148 |         });
149 |     });
150 | }
151 | 
152 | export default {
153 |     update_packages: update_packages,
154 |     delete_packages: delete_packages,
155 |     install_packages: install_packages
156 | }


--------------------------------------------------------------------------------
/extension/js/scripts.js:
--------------------------------------------------------------------------------
  1 | import $ from 'jquery';
  2 | import views from './views';
  3 | import api from './api';
  4 | import common from './common';
  5 | 
  6 | /*
  7 | This function populates the sidebar each time it is opened.
  8 | */
  9 | 
 10 | function package_view(dir) {
 11 | 
 12 |     $('#loadingview').show();
 13 |     $('#installed-packages').empty();
 14 |     $('#to-install').empty();
 15 |     $('#loadingtext').text("Loading Project Details");
 16 | 
 17 |     api.get_info(dir, function (info) {
 18 |         var data = info.packages;
 19 | 
 20 |         var output = views.installed(data);
 21 |         $('#installed-packages').append(output);
 22 | 
 23 |         output = views.to_install(data);
 24 |         $('#to-install').append(output);
 25 |         if ($(output).children().length === 0) {
 26 |             $('#to-install-main').css("display", "none");
 27 |         }
 28 | 
 29 |         var selectedPackages = [];
 30 |         views.select_installed(selectedPackages);
 31 | 
 32 |         var toInstall = [];
 33 |         views.select_to_install(toInstall);
 34 | 
 35 |         $('#packageview').show();
 36 |         $('#loadingview').hide();
 37 |     }, function () {
 38 |         common.display_msg("Server Error", "The project configuration could not be retrived. Please try again.");
 39 |         $('#loadingtext').text("Server Error");
 40 |     });
 41 | }
 42 | 
 43 | 
 44 | /*
 45 | This function populates the dropdown datalist when something is searched.
 46 | */
 47 | 
 48 | function search_view() {
 49 | 
 50 |     $('#package-name').unbind();
 51 | 
 52 |     var typingTimer;                //timer identifier
 53 |     var doneTypingInterval = 1500;  //time in ms, 1.5 seconds for example
 54 | 
 55 |     $('#package-name').on('keyup', function () {
 56 |         clearTimeout(typingTimer);
 57 |         typingTimer = setTimeout(function () {
 58 |             var query = $('#package-name').val();
 59 |             if (query.length <= 1) {
 60 |                 // Do not query if the string size is too small. This will save a lot of time.
 61 |                 return;
 62 |             }
 63 |             $('#searchlist').empty();
 64 |             $('#searchicon').toggleClass('fa-search fa-dot-circle-o').addClass('Blink');
 65 |             api.search(query, function (res) {
 66 |                 var pks = res.packages;
 67 |                 for (var i = 0; i < pks.length; i++) {
 68 |                     var element = pks[i];
 69 |                     var name = element.name;
 70 |                     var version = element.version;
 71 |                     var entry = name + " - " + version;
 72 |                     var opt = $("<option>").val(entry).text(entry);
 73 |                     $('#searchlist').append(opt);
 74 |                 }
 75 |                 $('#searchicon').toggleClass('fa-search fa-dot-circle-o').removeClass('Blink');
 76 | 
 77 |             }, function () {
 78 |                 common.display_msg("Server Error", "The package information could not be searched. Please try again.");
 79 |             })
 80 |         }, doneTypingInterval);
 81 |     });
 82 | 
 83 |     //on keydown, clear the countdown 
 84 |     $('#package-name').on('keydown', function () {
 85 |         clearTimeout(typingTimer);
 86 |     });
 87 | 
 88 |     /*
 89 |     This function adds the selected package to the list display.
 90 |     */
 91 | 
 92 |     function add_to_install(val) {
 93 |         $('#package-name').val("");
 94 |         $('#package-name').blur();
 95 |         var a = val.split(' - ');
 96 |         var pkg = {
 97 |             'name': a[0],
 98 |             'version': a[1],
 99 |             'staus': ''
100 |         };
101 |         var data = [];
102 |         data.push(pkg);
103 |         var output = views.to_install(data);
104 |         $('#to-install').append(output);
105 |         var toInstall = common.get_to_install();
106 |         views.select_to_install(toInstall);
107 |         $('#to-install-main').css("display", "initial");
108 |     }
109 | 
110 |     $('#package-name').on('input', function () {
111 |         var userText = $(this).val();
112 | 
113 |         $("#searchlist").find("option").each(function () {
114 |             if ($(this).val() == userText) {
115 |                 add_to_install(userText);
116 |             }
117 |         })
118 |     });
119 | 
120 | }
121 | 
122 | export default {
123 |     package_view: package_view,
124 |     search_view: search_view
125 | }
126 | 


--------------------------------------------------------------------------------
/extension/js/templates/list_item.html:
--------------------------------------------------------------------------------
 1 | <div class="list_item">
 2 |     <div class="row one">
 3 |         <div class="col-sm-9 two">
 4 |             <i class="list_icon fa" aria-hidden="true" /> &nbsp;
 5 |             <span class="value-name"></span>
 6 |         </div>
 7 |         <div class="col-sm-3 three">
 8 |             <span class="value-version"></span>
 9 |         </div>
10 |     </div>
11 | </div>


--------------------------------------------------------------------------------
/extension/js/templates/sidebar.css:
--------------------------------------------------------------------------------
 1 | #mySidenav {
 2 |   overflow-x: hidden;
 3 | }
 4 | 
 5 | .sidenavcontent {
 6 |   color: #424242;
 7 | }
 8 | 
 9 | @media screen and (max-height: 450px) {
10 |   .sidenav {
11 |     padding-top: 15px;
12 |   }
13 | }
14 | 
15 | .dropdown-item {
16 |   display: block;
17 | }
18 | 
19 | #package-name {
20 |   width: 380px;
21 | }
22 | 
23 | #packageview {
24 |   padding-left: 10px;
25 |   width: 410px;
26 |   display:none;
27 | }
28 | 
29 | .value-name {
30 |   padding-left: 10px;
31 |   font-size: large;
32 | }
33 | 
34 | .value-version {
35 |   font-size: larger;
36 | }
37 | 
38 | #loadingview {
39 |   padding-left: 10px;
40 | }
41 | 
42 | #loadingtext {
43 |   display: inline;
44 | }
45 | 
46 | .installed-values, .to-install-values {
47 |   line-height: 30px;
48 |   cursor: pointer;
49 | }
50 | 
51 | .faicon {
52 |   font-size: 18px;
53 |   margin-top: 20px;
54 |   cursor: pointer;
55 | }
56 | 
57 | .main-content {
58 |   overflow-x: hidden;
59 | }
60 | 
61 | #deletebtn {
62 |   display: none;
63 | }
64 | 
65 | #searchicon {
66 |   top: 10px;
67 |   z-index: 10 !important;
68 |   right: 20px;
69 | }
70 | 
71 | .Blink {
72 |   animation: blink 2s ease-in infinite;
73 | }
74 | 
75 | @keyframes blink {
76 |   from, to {
77 |     opacity: 1
78 |   }
79 |   50% {
80 |     opacity: 0
81 |   }
82 | }


--------------------------------------------------------------------------------
/extension/js/templates/sidebar.html:
--------------------------------------------------------------------------------
 1 | <div id="mySidenav" class="sidenav">
 2 |     <div class="sidenavcontent">
 3 |         <div id="loadingview">
 4 |             <h2 id="loadingtext">Loading</h2>
 5 |             &nbsp;&nbsp;
 6 |             <i class="fa-spinner fa-spin fa" aria-hidden="true" />
 7 |             <hr>
 8 |         </div>
 9 |         <div id="packageview">
10 |             <div class="main-content">
11 |                 <label for="package-name">Install Packages</label>
12 |                 <div class="input-group mb-3">
13 |                     <input type="text" class="form-control" id="package-name" list="searchlist" autocomplete="off"
14 |                         placeholder="Search for available packages">
15 |                     <span id="searchicon" class="fa fa-search form-control-feedback"></span>
16 |                     <datalist id="searchlist">
17 |                     </datalist>
18 |                 </div>
19 |                 <br>
20 |                 <div id="to-install-main">
21 |                     <h2>Packages To Install</h2>
22 |                     <br>
23 |                     <div id="to-install">
24 |                     </div>
25 |                     <br>
26 |                     <button id="installbtn" class="btn btn-success" style="width: 380px;">Install
27 |                         Packages</button>
28 |                     <br>
29 |                     <br>
30 |                 </div>
31 |                 <div class="row">
32 |                     <div class="col-sm-10">
33 |                         <h2>Installed Packages</h2>
34 |                     </div>
35 |                     <div class="col-sm-2">
36 |                         <i class="faicon fa fa-wrench" id="updatebtn" aria-hidden="true" />
37 |                         &nbsp;
38 |                         <i class="faicon fa fa-trash-o" id="deletebtn" aria-hidden="true" />
39 |                     </div>
40 |                 </div>
41 |                 <br>
42 |                 <div id="installed-packages">
43 |                 </div>
44 |             </div>
45 |         </div>
46 |         <br>
47 |     </div>
48 | </div>


--------------------------------------------------------------------------------
/extension/js/views.js:
--------------------------------------------------------------------------------
  1 | import $ from 'jquery';
  2 | import list_item from './templates/list_item.html'
  3 | 
  4 | /*
  5 | This function generates the DOM for displaying packages that are selected for installation.
  6 | */
  7 | 
  8 | function to_install(data) {
  9 |     var output = $("<div/>");
 10 |     for (var i = 0; i < data.length; i++) {
 11 |         var val = data[i];
 12 |         if (val.status != "installed") {
 13 |             var item = $.parseHTML(list_item);
 14 |             $(item).addClass('to-install-values');
 15 |             $(item).find('.list_icon').addClass('fa-check');
 16 |             $(item).find('.value-name').text(val.name);
 17 |             $(item).find('.value-version').text(val.version);
 18 |             $(output).append(item);
 19 |         }
 20 |     }
 21 |     return output;
 22 | }
 23 | 
 24 | /*
 25 | This function generates the DOM for displaying packages that are currently installed.
 26 | */
 27 | 
 28 | function installed(data) {
 29 |     var output = $("<div/>");
 30 |     for (var i = 0; i < data.length; i++) {
 31 |         var val = data[i];
 32 |         if (val.status === "installed") {
 33 |             var item = $.parseHTML(list_item);
 34 |             $(item).addClass('installed-values');
 35 |             $(item).find('.list_icon').addClass('fa-cube');
 36 |             $(item).find('.value-name').text(val.name);
 37 |             $(item).find('.value-version').text(val.version);
 38 |             $(output).append(item);
 39 |         }
 40 | 
 41 |     }
 42 |     return output;
 43 | }
 44 | 
 45 | function remove_element(array, elem) {
 46 |     var index = array.indexOf(elem);
 47 |     if (index > -1) {
 48 |         array.splice(index, 1);
 49 |     }
 50 | }
 51 | 
 52 | function get_pkg(element) {
 53 |     var packageName = $(element).find(".one .two .value-name").text();
 54 |     var version = $(element).find(".one .three .value-version").text();
 55 |     return packageName + "=" + version;
 56 | }
 57 | 
 58 | /*
 59 | This function add an eventlistener to the DOM for handling packages that are selected for installation.
 60 | */
 61 | 
 62 | function select_to_install(toInstall) {
 63 |     $('.to-install-values').unbind();
 64 |     $('.to-install-values').hover(function () {
 65 |         $(this).find(".one .two i").toggleClass('fa-close');
 66 |     });
 67 |     $('.to-install-values').click(function () {
 68 |         var pkg = get_pkg(this);
 69 |         if (toInstall.includes(pkg)) {
 70 |             remove_element(toInstall, pkg);
 71 |             $(this).remove();
 72 |         }
 73 |         if (toInstall.length === 0) {
 74 |             $('#to-install-main').css("display", "none");
 75 |         }
 76 |     });
 77 | }
 78 | 
 79 | /*
 80 | This function add an eventlistener to the DOM for handling packages that are currently installed.
 81 | */
 82 | 
 83 | function select_installed(selectedPackages) {
 84 |     $('.installed-values').unbind();
 85 |     $('.installed-values').click(function () {
 86 |         var pkg = get_pkg(this);
 87 |         if (selectedPackages.includes(pkg)) {
 88 |             remove_element(selectedPackages, pkg);
 89 |             $(this).find(".one .two i").toggleClass('fa-cube fa-check');
 90 |         }
 91 |         else {
 92 |             selectedPackages.push(pkg);
 93 |             $(this).find(".one .two i").toggleClass('fa-cube fa-check');
 94 |         }
 95 |         delete_btn_disp(selectedPackages);
 96 |     });
 97 | }
 98 | 
 99 | /*
100 | This function add an eventlistener to the DOM for showing the delete button only when packages are selected.
101 | */
102 | 
103 | function delete_btn_disp(selectedPackages) {
104 |     var n = selectedPackages.length;
105 |     if (n === 0)
106 |         $('#deletebtn').css("display", "none");
107 |     else $('#deletebtn').css("display", "inline");
108 | 
109 | }
110 | 
111 | export default {
112 |     installed: installed,
113 |     to_install: to_install,
114 |     select_to_install: select_to_install,
115 |     select_installed: select_installed,
116 |     delete_btn_disp: delete_btn_disp
117 | }


--------------------------------------------------------------------------------
/extension/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "packagemanagerextension",
 3 |   "version": "0.2.2",
 4 |   "description": "Jupyter notebook extension to manage packages in SWAN projects",
 5 |   "keywords": [
 6 |     "Jupyter",
 7 |     "Extension",
 8 |     "SWAN",
 9 |     "Package Manager"
10 |   ],
11 |   "author": "Akash Ravi",
12 |   "devDependencies": {
13 |     "css-loader": "^3.2.0",
14 |     "html-loader": "^0.5.5",
15 |     "style-loader": "^1.0.0",
16 |     "webpack": "^4.41.2",
17 |     "webpack-cli": "^3.3.9"
18 |   },
19 |   "scripts": {
20 |     "webpack": "webpack -p --config webpack.config.js",
21 |     "dev": "webpack --watch --config webpack.config.js"
22 |   },
23 |   "dependencies": {
24 |     "npm-check-updates": "^3.1.25"
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/extension/packagemanager/__init__.py:
--------------------------------------------------------------------------------
 1 | def _jupyter_nbextension_paths():
 2 |     '''
 3 |     Used by 'jupyter nbextension' command to install frontend extension
 4 |     '''
 5 |     return [dict(
 6 |         section="tree",
 7 |         # the path is relative to the `extension` directory
 8 |         src="js",
 9 |         # directory in the `nbextension/` namespace
10 |         dest="packagemanager",
11 |         # _also_ in the `nbextension/` namespace
12 |         require="packagemanager/extension")]
13 | 
14 | 
15 | def _jupyter_server_extension_paths():
16 |     '''
17 |     Used by 'jupyter serverextension' command to install web server extension
18 |     '''
19 |     return [{
20 |         "module": "packagemanager.serverextension"
21 |     }]
22 | 


--------------------------------------------------------------------------------
/extension/packagemanager/apihandlers.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | 
  3 | from notebook.base.handlers import (
  4 |     APIHandler,
  5 |     json_errors,
  6 | )
  7 | from tornado import web, escape
  8 | 
  9 | from .packagemanagement import PackageManager, CondaSearcher
 10 | 
 11 | package_manager = PackageManager()
 12 | 
 13 | '''
 14 | This file contains the handler classes for API endpoints. Every request is serviced by calling
 15 | an appropriate method from the PackageManager class
 16 | '''
 17 | 
 18 | 
 19 | class EnvBaseHandler(APIHandler):
 20 | 
 21 |     '''
 22 |     Maintains a reference to the
 23 |     'env_manager' which implements all of the conda functions.
 24 |     '''
 25 | 
 26 |     @property
 27 |     def env_manager(self):
 28 |         '''
 29 |         Return our env_manager instance
 30 |         '''
 31 |         return self.settings['env_manager']
 32 | 
 33 | 
 34 | # -----------------------------------------------------------------------------
 35 | # Project Management APIs
 36 | # -----------------------------------------------------------------------------
 37 | 
 38 | 
 39 | class ManageProjectsHandler(EnvBaseHandler):
 40 | 
 41 |     @json_errors
 42 |     def get(self):
 43 |         '''
 44 |         Handler for `GET /projects` which lists the projects.
 45 |         '''
 46 | 
 47 |         resp = {}
 48 |         resp['projects'] = package_manager.list_projects()
 49 |         self.finish(json.dumps(resp))
 50 | 
 51 |     @json_errors
 52 |     def post(self):
 53 |         '''
 54 |         Handler for `POST /projects` which
 55 |         creates the specified environment.
 56 |         '''
 57 | 
 58 |         data = escape.json_decode(self.request.body)
 59 |         directory = data.get('project')
 60 |         env_type = data.get('env_type', 'python3')
 61 |         resp = package_manager.create_project(directory, env_type)
 62 | 
 63 |         if 'error' not in resp:
 64 |             status = 201  # CREATED
 65 | 
 66 |         # catch-all ok
 67 |         if 'error' in resp:
 68 |             status = 400
 69 | 
 70 |         self.set_status(status or 200)
 71 |         self.finish(json.dumps(resp))
 72 | 
 73 |     @json_errors
 74 |     def delete(self):
 75 |         '''
 76 |         Handler for `DELETE /projects` which
 77 |         deletes the specified projects.
 78 |         '''
 79 | 
 80 |         data = escape.json_decode(self.request.body)
 81 |         directories = data.get('project')
 82 |         resp = package_manager.delete_project(directories)
 83 | 
 84 |         if 'error' not in resp:
 85 |             status = 200
 86 | 
 87 |         # catch-all ok
 88 |         if 'error' in resp:
 89 |             status = 400
 90 | 
 91 |         self.set_status(status or 200)
 92 |         self.finish(json.dumps(resp))
 93 | 
 94 | 
 95 | class ProjectInfoHandler(EnvBaseHandler):
 96 | 
 97 |     @json_errors
 98 |     def get(self):
 99 |         '''
100 |         Handler for `GET /project_info` which
101 |         returns the internal name of the environment 
102 |         + all packages required along with their status (if already installed or not?)
103 |         '''
104 | 
105 |         directory = self.get_argument('project', "None")
106 |         if self.request.headers.get('Content-Type') == 'text/plain':
107 |             # export requirements file
108 |             folder = directory[:-1].split('/')[-1]
109 |             self.set_header('Content-Type', 'text/plain; charset="utf-8"')
110 |             self.set_header('Content-Disposition',
111 |                             'attachment; filename="%s"' % (folder + '.txt'))
112 |             self.write(package_manager.export_package_text(directory))
113 |             self.finish()
114 |         else:
115 |             # send list of all packages
116 |             resp = package_manager.project_info(directory)
117 | 
118 |             if 'error' not in resp:
119 |                 status = 200  # OK
120 | 
121 |             # catch-all ok
122 |             if 'error' in resp:
123 |                 status = 400
124 | 
125 |             self.set_status(status or 200)
126 |             self.finish(json.dumps(resp))
127 | 
128 |     @json_errors
129 |     def put(self):
130 |         '''
131 |         Handler for `PUT /project_info` which
132 |         updates a project with all the packages obtained from an export file
133 |         '''
134 | 
135 |         # get list of all packages
136 |         file1 = self.request.files['file'][0]
137 |         directory = self.get_argument('project', default=None)
138 | 
139 |         resp = package_manager.import_project(file1, directory)
140 | 
141 |         if 'error' not in resp:
142 |             status = 200  # OK
143 | 
144 |         # catch-all ok
145 |         if 'error' in resp:
146 |             status = 400
147 | 
148 |         self.set_status(status or 200)
149 |         self.finish(json.dumps(resp))
150 | 
151 |     @json_errors
152 |     def patch(self):
153 |         '''
154 |         Handler for `PATCH /project_info` which
155 |         syncs a .swanproject file and the corresponding conda env
156 |         '''
157 | 
158 |         data = escape.json_decode(self.request.body)
159 |         directory = data.get('project')
160 | 
161 |         resp = package_manager.sync_project(directory)
162 | 
163 |         if 'error' not in resp:
164 |             status = 200  # OK
165 | 
166 |         # catch-all ok
167 |         if 'error' in resp:
168 |             status = 400
169 | 
170 |         self.set_status(status or 200)
171 |         self.finish(json.dumps(resp))
172 | 
173 | 
174 | # -----------------------------------------------------------------------------
175 | # Package Management APIs
176 | # -----------------------------------------------------------------------------
177 | 
178 | 
179 | class PkgHandler(EnvBaseHandler):
180 | 
181 |     @json_errors
182 |     def post(self):
183 |         '''
184 |         Handler for `POST /packages` which installs all
185 |         the selected packages in the specified environment.
186 |         '''
187 | 
188 |         data = escape.json_decode(self.request.body)
189 |         directory = data.get('project')
190 |         packages = data.get('packages')
191 |         resp = package_manager.install_packages(directory, packages)
192 |         if resp.get("error"):
193 |             self.set_status(400)
194 |         self.finish(json.dumps(resp))
195 | 
196 |     @json_errors
197 |     def patch(self):
198 |         '''
199 |         Handler for `PATCH /packages` which updates all
200 |         the selected packages in the specified environment.
201 |         '''
202 | 
203 |         data = escape.json_decode(self.request.body)
204 |         directory = data.get('project')
205 |         packages = data.get('packages')
206 |         resp = package_manager.update_packages(directory, packages)
207 |         if resp.get("error"):
208 |             self.set_status(400)
209 |         self.finish(json.dumps(resp))
210 | 
211 |     @json_errors
212 |     def delete(self):
213 |         '''
214 |         Handler for `DELETE /packages` which deletes all
215 |         the selected packages in the specified environment.
216 |         '''
217 | 
218 |         data = escape.json_decode(self.request.body)
219 |         directory = data.get('project')
220 |         packages = data.get('packages')
221 |         resp = package_manager.delete_packages(directory, packages)
222 |         if resp.get("error"):
223 |             self.set_status(400)
224 |         self.finish(json.dumps(resp))
225 | 
226 | 
227 | class CheckUpdatePkgHandler(EnvBaseHandler):
228 | 
229 |     @json_errors
230 |     def get(self):
231 |         '''
232 |         Handler for `GET /packages/check_update` which checks for updates of all
233 |         the selected packages in the specified environment.
234 |         '''
235 | 
236 |         directory = self.get_argument('project', "None")
237 |         resp = package_manager.check_update(directory)
238 |         if resp.get("error"):
239 |             self.set_status(400)
240 |         self.finish(json.dumps(resp))
241 | 
242 | 
243 | class CloneProjectHandler(EnvBaseHandler):
244 | 
245 |     @json_errors
246 |     def post(self):
247 |         '''
248 |         Handler for for `POST /project_clone` which clones a project in a new location
249 |         '''
250 | 
251 |         data = escape.json_decode(self.request.body)
252 |         directory = data.get('project')
253 |         resp = package_manager.clone_project(directory)
254 |         if resp.get("error"):
255 |             self.set_status(400)
256 |         self.finish(json.dumps(resp))
257 | 
258 | 
259 | searcher = CondaSearcher()
260 | 
261 | 
262 | class AvailablePackagesHandler(EnvBaseHandler):
263 | 
264 |     @json_errors
265 |     def get(self):
266 |         '''
267 |         Handler for `GET /packages/available`, which uses CondaSearcher
268 |         to list the packages available for installation.
269 |         '''
270 | 
271 |         data = searcher.list_available(self)
272 | 
273 |         if data is None:
274 |             # tell client to check back later
275 |             self.clear()
276 |             self.set_status(202)  # Accepted
277 |             self.finish('{}')
278 |         else:
279 |             self.finish(json.dumps({"packages": data}))
280 | 
281 | 
282 | class SearchHandler(EnvBaseHandler):
283 | 
284 |     @json_errors
285 |     def get(self):
286 |         '''
287 |         Handler for `GET /packages/search?q=<query>`, which uses CondaSearcher
288 |         to search the available conda packages.
289 |         '''
290 | 
291 |         q = self.get_argument('q', "None")
292 |         resp = {}
293 |         resp['packages'] = package_manager.search(q)
294 |         self.finish(json.dumps(resp))
295 | 


--------------------------------------------------------------------------------
/extension/packagemanager/envmanager.py:
--------------------------------------------------------------------------------
  1 | # pylint: disable=C0321
  2 | 
  3 | import json
  4 | import os
  5 | import re
  6 | import uuid
  7 | import yaml
  8 | 
  9 | from packaging.version import parse
 10 | from subprocess import check_output, CalledProcessError
 11 | from traitlets.config.configurable import LoggingConfigurable
 12 | from traitlets import Dict
 13 | 
 14 | # these are the types of environments that can be created
 15 | package_map = {
 16 |     'python2': 'python=2 ipykernel',
 17 |     'python3': 'python=3 ipykernel'
 18 | }
 19 | 
 20 | CONDA_EXE = os.environ.get("CONDA_EXE", "conda")  # type: str
 21 | 
 22 | # try to match lines of json
 23 | JSONISH_RE = r'(^\s*["\{\}\[\],\d])|(["\}\}\[\],\d]\s*$)'
 24 | 
 25 | 
 26 | class EnvManager(LoggingConfigurable):
 27 |     '''
 28 |     This class defines all the actions done by conda
 29 |     '''
 30 | 
 31 |     def list_envs(self):
 32 |         '''
 33 |         List all environments associated with SWAN projects
 34 |         '''
 35 |         info = self._clean_conda_json(
 36 |             self._conda_execute('info --json'))
 37 | 
 38 |         def get_info(env):
 39 |             return {
 40 |                 'name': os.path.basename(env),
 41 |                 'dir': env
 42 |             }
 43 | 
 44 |         return [get_info(env) for env in info['envs'] if "swanproject" in env]
 45 | 
 46 |     def create_env(self, env, type):
 47 |         '''
 48 |         Creates a new conda env for asssociation with a SWAN project
 49 |         '''
 50 |         packages = package_map[type]
 51 |         output = self._conda_execute('create -y -q --json -n', env,
 52 |                                      *packages.split(" "))
 53 |         resp = self._clean_conda_json(output)
 54 | 
 55 |         return resp
 56 | 
 57 |     def delete_env(self, env):
 58 |         '''
 59 |         Removes the conda env completely
 60 |         '''
 61 |         output = self._conda_execute(
 62 |             'remove -y -q --all --json -n', env)
 63 | 
 64 |         return self._clean_conda_json(output)
 65 | 
 66 |     def install_packages(self, env, packages):
 67 |         '''
 68 |         Installs a list of packages onto an env
 69 |         '''
 70 |         output = self._conda_execute(
 71 |             'install -y -q --json -n', env, *packages)
 72 |         return self._clean_conda_json(output)
 73 | 
 74 |     def update_packages(self, env, packages):
 75 |         '''
 76 |         Updates package(s) in an env
 77 |         '''
 78 |         output = self._conda_execute(
 79 |             'update -y -q --json -n', env, *packages)
 80 |         return self._clean_conda_json(output)
 81 | 
 82 |     def remove_packages(self, env, packages):
 83 |         '''
 84 |         Removes a list of packages from an env
 85 |         '''
 86 |         output = self._conda_execute(
 87 |             'remove -y -q --json -n', env, *packages)
 88 |         return self._clean_conda_json(output)
 89 | 
 90 |     def list_packages(self, env):
 91 |         '''
 92 |         List the packages installed on an env
 93 |         '''
 94 |         packages = self._conda_execute('list --json -n', env)
 95 |         return self._clean_conda_json(packages)
 96 | 
 97 |     def export_env(self, env):
 98 |         '''
 99 |         Export the conda env specifiation as plain text
100 |         '''
101 |         return str(self._conda_execute('list -e -n', env))
102 | 
103 |     def check_update(self, env, packages):
104 |         '''
105 |         Checks for newer versions of packages in an env
106 |         '''
107 |         output = self._conda_execute('update --dry-run -q --json -n', env,
108 |                                      *packages)
109 |         return self._clean_conda_json(output)
110 | 
111 |     def package_search(self, q):
112 |         '''
113 |         This function lets users search for available packages that match a search query
114 |         '''
115 |         # this method is slow and operates synchronously
116 |         output = self._conda_execute('search --json', q)
117 |         data = self._clean_conda_json(output)
118 | 
119 |         if 'error' in data:
120 |             # we didn't get back a list of packages, we got a dictionary with
121 |             # error info
122 |             return data
123 | 
124 |         packages = []
125 | 
126 |         for entries in data.values():
127 |             max_version = None
128 |             max_version_entry = None
129 | 
130 |             for entry in entries:
131 |                 version = parse(entry.get("version", ""))
132 | 
133 |                 if max_version is None or version > max_version:
134 |                     max_version = version
135 |                     max_version_entry = entry
136 | 
137 |             packages.append(max_version_entry)
138 | 
139 |         return sorted(packages, key=lambda entry: entry.get("name"))
140 | 
141 |     def pkg_info(self, s):
142 |         '''
143 |         Abstracts unwanted details and normalizes the package JSON
144 |         '''
145 |         return {
146 |             "build_string": s.get("build_string", s.get("build")),
147 |             "name": s.get("name"),
148 |             "version": s.get("version")
149 |         }
150 | 
151 |     def _conda_execute(self, cmd, *args):
152 |         '''
153 |         Executes the conda command line
154 |         '''
155 |         cmd = CONDA_EXE + ' ' + cmd
156 |         cmdline = cmd.split() + list(args)
157 | 
158 |         try:
159 |             output = check_output(cmdline)
160 |         except CalledProcessError as exc:
161 |             output = exc.output
162 | 
163 |         return output.decode("utf-8")
164 | 
165 |     def _clean_conda_json(self, inputjson):
166 |         '''
167 |         Ensures that only valid JSONs are processed
168 |         '''
169 |         lines = inputjson.splitlines()
170 | 
171 |         try:
172 |             return json.loads('\n'.join(lines))
173 |         except Exception as err:
174 |             raise Exception(err)
175 | 
176 |         # try to remove bad lines
177 |         lines = [line for line in lines if re.match(JSONISH_RE, line)]
178 | 
179 |         try:
180 |             cleanJson = json.loads('\n'.join(lines))
181 |         except Exception as err:
182 |             raise Exception(err)
183 |         return cleanJson
184 | 


--------------------------------------------------------------------------------
/extension/packagemanager/packagemanagement.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import os
  3 | import re
  4 | import uuid
  5 | 
  6 | from subprocess import Popen
  7 | from tempfile import TemporaryFile
  8 | 
  9 | from pkg_resources import parse_version
 10 | from tornado import web, escape
 11 | 
 12 | try:
 13 |     from .envmanager import EnvManager, package_map
 14 |     from .swanproject import SwanProject
 15 | except:
 16 |     from envmanager import EnvManager, package_map
 17 |     from swanproject import SwanProject
 18 | 
 19 | env_manager = EnvManager()
 20 | 
 21 | 
 22 | class PackageManager():
 23 |     '''
 24 |     This class contains all the logic of the server extension
 25 |     '''
 26 | 
 27 | # -----------------------------------------------------------------------------
 28 | # Project Management Modules
 29 | # -----------------------------------------------------------------------------
 30 | 
 31 |     def list_projects(self):
 32 |         '''
 33 |         Module for `GET /projects` which lists the projects.
 34 |         '''
 35 | 
 36 |         return env_manager.list_envs()
 37 | 
 38 |     def create_project(self, directory, env_type):
 39 |         '''
 40 |         Module for `POST /projects` which
 41 |         creates the specified environment.
 42 |         '''
 43 | 
 44 |         if env_type not in package_map:
 45 |             raise web.HTTPError(400)
 46 |         env = uuid.uuid1()
 47 |         env = 'swanproject-' + str(env)
 48 | 
 49 |         try:
 50 |             resp = env_manager.create_env(env, env_type)
 51 |             swanproj = SwanProject(directory)
 52 |             swanproj.env = env
 53 |             swanproj.packages = env_manager.list_packages(env)
 54 |             swanproj.update_yaml()
 55 |         except Exception as e:
 56 |             resp = {'error': str(e)}
 57 | 
 58 |         return resp
 59 | 
 60 |     def delete_project(self, directories):
 61 |         '''
 62 |         Module for `DELETE /projects` which
 63 |         deletes the specified projects.
 64 |         '''
 65 | 
 66 |         try:
 67 |             dlist = []
 68 |             for projectdir in directories:
 69 |                 swanproject = SwanProject(projectdir)
 70 |                 env = swanproject.env
 71 |                 resp = env_manager.delete_env(env)
 72 |                 dlist.append(resp)
 73 |                 swanproject.clear_yaml()
 74 |             resp = {'response': dlist}
 75 |         except Exception as e:
 76 |             resp = {'error': str(e)}
 77 | 
 78 |         return resp
 79 | 
 80 |     def import_project(self, file1, directory):
 81 |         '''
 82 |         Module for `PUT /project_info` which
 83 |         updates a project with all the packages obtained from an export file
 84 |         '''
 85 | 
 86 |         tmp = file1['body'].splitlines()
 87 |         packages = []
 88 |         for i in tmp:
 89 |             if i[0] != '#':
 90 |                 packages.append(i)
 91 |         try:
 92 |             self.install_packages(directory, packages)
 93 |         except Exception as e:
 94 |             resp = {'error': str(e)}
 95 | 
 96 |         return resp
 97 | 
 98 |     def sync_project(self, directory):
 99 |         '''
100 |         Module for `PATCH /project_info` which
101 |         syncs a .swanproject file and the corresponding conda env
102 |         '''
103 | 
104 |         try:
105 |             swanproj = SwanProject(directory)
106 |             package_info = self.project_info_aux(swanproj)
107 |             packages = []
108 |             for i in package_info['packages']:
109 |                 if i['status'] != 'installed':
110 |                     packages.append(i['name'] + '=' + i['version'])
111 |             resp = self._install_packages_aux(swanproj, packages)
112 |         except Exception as e:
113 |             resp = {'error': str(e)}
114 | 
115 |         return resp
116 | 
117 |     def clone_project(self, directory):
118 |         '''
119 |         Module for `POST /project_clone` which clones a project in a new location
120 |         '''
121 | 
122 |         try:
123 |             swanproj = SwanProject(directory)
124 |             env = uuid.uuid1()
125 |             env = 'swanproject-' + str(env)
126 |             resp = env_manager.create_env(env, 'python3')
127 |             swanproj.env = env
128 |             swanproj.update_yaml()
129 |         except Exception as e:
130 |             resp = {'error': str(e)}
131 | 
132 |         return resp
133 | 
134 | 
135 | # -----------------------------------------------------------------------------
136 | # Package Management APIs
137 | # -----------------------------------------------------------------------------
138 | 
139 |     def clean(self, packages):
140 |         # no hyphens up front, please
141 |         _pkg_regex = r"(?P<pkg>[^\-][\-\da-zA-Z\._]+)"
142 |         # don't allow arbitrary switches
143 |         packages = [pkg for pkg in packages if re.match(_pkg_regex, pkg)]
144 |         return packages
145 | 
146 |     def _install_packages_aux(self, swanproj, packages):
147 |         env = swanproj.env
148 |         resp = env_manager.install_packages(env, packages)
149 |         swanproj.packages = env_manager.list_packages(env)
150 |         swanproj.update_yaml()
151 |         return resp
152 | 
153 |     def install_packages(self, directory, packages):
154 |         '''
155 |         Module for `POST /packages` which installs all
156 |         the selected packages in the specified environment.
157 |         '''
158 | 
159 |         packages = self.clean(packages)
160 |         try:
161 |             swanproj = SwanProject(directory)
162 |             resp = self._install_packages_aux(swanproj, packages)
163 |         except Exception as e:
164 |             resp = {'error': str(e)}
165 |         return resp
166 | 
167 |     def update_packages(self, directory, packages):
168 |         '''
169 |         Module for `PATCH /packages` which updates all
170 |         the selected packages in the specified environment.
171 |         '''
172 | 
173 |         packages = self.clean(packages)
174 |         try:
175 |             swanproj = SwanProject(directory)
176 |             env = swanproj.env
177 |             resp = env_manager.update_packages(env, packages)
178 |             swanproj.packages = env_manager.list_packages(env)
179 |             swanproj.update_yaml()
180 |         except Exception as e:
181 |             resp = {'error': str(e)}
182 |         return resp
183 | 
184 |     def delete_packages(self, directory, packages):
185 |         '''
186 |         Module for `DELETE /packages` which deletes all
187 |         the selected packages in the specified environment.
188 |         '''
189 | 
190 |         packages = self.clean(packages)
191 |         try:
192 |             swanproj = SwanProject(directory)
193 |             env = swanproj.env
194 |             resp = env_manager.remove_packages(env, packages)
195 |             swanproj.packages = env_manager.list_packages(env)
196 |             swanproj.update_yaml()
197 |         except Exception as e:
198 |             resp = {'error': str(e)}
199 |         return resp
200 | 
201 |     def check_update(self, directory):
202 |         '''
203 |         Module for `GET /packages/check_update` which checks for updates of all
204 |         the selected packages in the specified environment.
205 |         '''
206 | 
207 |         try:
208 |             swanproj = SwanProject(directory)
209 |             env = swanproj.env
210 |             packagesJson = swanproj.packages
211 |             packages = []
212 |             for it in packagesJson:
213 |                 packages.append(it.get('name'))
214 |             data = env_manager.check_update(env, packages)
215 |             if 'error' in data:
216 |                 # we didn't get back a list of packages, we got a dictionary with
217 |                 # error info
218 |                 resp = data
219 |             elif 'actions' in data:
220 |                 links = data['actions'].get('LINK', [])
221 |                 package_versions = [link for link in links]
222 |                 resp = {
223 |                     "updates": [env_manager.pkg_info(pkg_version)
224 |                                 for pkg_version in package_versions]
225 |                 }
226 |             else:
227 |                 # no action plan returned means everything is already up to date
228 |                 resp = {
229 |                     "updates": []
230 |                 }
231 |         except Exception as e:
232 |             resp = {'error': str(e)}
233 |         return resp
234 | 
235 |     def export_package_text(self, directory):
236 |         try:
237 |             swanproj = SwanProject(directory)
238 |             resp = env_manager.export_env(swanproj.env)
239 |         except Exception as e:
240 |             resp = str(e)
241 |         return resp
242 | 
243 |     def project_info_aux(self, swanproj):
244 |         swandata = []
245 |         env = swanproj.env
246 |         packages = swanproj.packages
247 |         for item in packages:
248 |             swandata.append(env_manager.pkg_info(item))
249 |             # details of all packages in the .swanproject file
250 | 
251 |         data = env_manager.list_packages(env)
252 |         if 'error' in data:
253 |             # we didn't get back a list of packages, we got a dictionary with
254 |             # error info
255 |             return data
256 |         condadata = []
257 |         for package in data:
258 |             condadata.append(env_manager.pkg_info(package))
259 |             # details of all packages in the corresponding env
260 | 
261 |         resp = {}
262 |         resp['env'] = env
263 |         '''
264 |         Merge both the lists with the appropriate status of every package
265 |         If in swanproj but not in conda -> alert the user to install
266 |         if in conda but not in swanproj -> alert the user to sync the state (or do it automatically?)
267 |         if in both -> keep calm and carry on
268 |         '''
269 |         resp['packages'] = self.pkg_info_status(swandata, condadata)
270 | 
271 |         return resp
272 | 
273 |     def project_info(self, directory):
274 |         try:
275 |             swanproj = SwanProject(directory)
276 |             resp = self.project_info_aux(swanproj)
277 |         except Exception as e:
278 |             resp = {'error': str(e)}
279 |         return resp
280 | 
281 |     def search(self, query):
282 |         return env_manager.package_search(query)
283 | 
284 |     def pkg_info_status(self, swandata, condadata):
285 |         '''
286 |         Combines the data available in both the lists and determines the status of each package
287 |         '''
288 |         packages = {x['name']: x for x in swandata + condadata}.values()
289 |         for i in packages:
290 |             if i in swandata and i in condadata:
291 |                 i['status'] = 'installed'
292 |             elif i in swandata and i not in condadata:
293 |                 i['status'] = 'not installed'
294 |             elif i not in swandata and i in condadata:
295 |                 i['status'] = 'not synced'
296 |         return list(packages)
297 | 
298 | 
299 | class CondaSearcher(object):
300 | 
301 |     def __init__(self):
302 |         '''
303 |         Helper object that runs `conda search` to retrieve the
304 |         list of packages available in the current conda channels.
305 |         '''
306 | 
307 |         self.conda_process = None
308 |         self.conda_temp = None
309 | 
310 |     def list_available(self, Module=None):
311 |         '''
312 |         List the available conda packages by kicking off a background
313 |         conda process. Will return None. Call again to poll the process
314 |         status. When the process completes, a list of packages will be
315 |         returned upon success. On failure, the results of `conda search --json`
316 |         will be returned (this will be a dict containing error information).
317 |         '''
318 | 
319 |         self.log = Module.log
320 | 
321 |         if self.conda_process is not None:
322 |             # already running, check for completion
323 |             self.log.debug('Already running: pid %s', self.conda_process.pid)
324 | 
325 |             status = self.conda_process.poll()
326 |             self.log.debug('Status %s', status)
327 | 
328 |             if status is not None:
329 |                 # completed, return the data
330 |                 self.log.debug('Done, reading output')
331 |                 self.conda_process = None
332 | 
333 |                 self.conda_temp.seek(0)
334 |                 data = json.loads(self.conda_temp.read())
335 |                 self.conda_temp = None
336 | 
337 |                 if 'error' in data:
338 |                     # we didn't get back a list of packages, we got a
339 |                     # dictionary with error info
340 |                     return data
341 | 
342 |                 packages = []
343 | 
344 |                 for entries in data.values():
345 |                     max_version = None
346 |                     max_version_entry = None
347 | 
348 |                     for entry in entries:
349 |                         version = parse_version(entry.get('version', ''))
350 | 
351 |                         if max_version is None or version > max_version:
352 |                             max_version = version
353 |                             max_version_entry = entry
354 | 
355 |                     packages.append(max_version_entry)
356 | 
357 |                 return sorted(packages, key=lambda entry: entry.get('name'))
358 | 
359 |         else:
360 |             # Spawn subprocess to get the data
361 |             self.log.debug('Starting conda process')
362 |             self.conda_temp = TemporaryFile(mode='w+')
363 |             cmdline = 'conda search --json'.split()
364 |             self.conda_process = Popen(cmdline, stdout=self.conda_temp,
365 |                                        bufsize=4096)
366 |             self.log.debug('Started: pid %s', self.conda_process.pid)
367 | 
368 |         return None
369 | 


--------------------------------------------------------------------------------
/extension/packagemanager/serverextension.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | This is the entrypoint module for Jupyter Server Extension
 3 | '''
 4 | 
 5 | # Tornado get and post handlers often have different args from their base class
 6 | # methods.
 7 | 
 8 | from notebook.utils import url_path_join as ujoin
 9 | 
10 | from .envmanager import EnvManager
11 | from .apihandlers import *
12 | 
13 | NS = r'api/packagemanager'
14 | 
15 | 
16 | # -----------------------------------------------------------------------------
17 | # URL to handler mappings
18 | # -----------------------------------------------------------------------------
19 | 
20 | 
21 | default_handlers = [
22 |     (r"/projects", ManageProjectsHandler),
23 |     (r"/project_info", ProjectInfoHandler),
24 |     (r"/packages", PkgHandler),
25 |     (r"/packages/check_update", CheckUpdatePkgHandler),
26 |     (r"/packages/available", AvailablePackagesHandler),
27 |     (r"/packages/search", SearchHandler),
28 |     (r"/project_clone", CloneProjectHandler),
29 | ]
30 | 
31 | 
32 | def load_jupyter_server_extension(nb_server_app):
33 |     '''
34 |     Load the nbserver extension
35 |     '''
36 | 
37 |     webapp = nb_server_app.web_app
38 |     webapp.settings['env_manager'] = EnvManager(parent=nb_server_app)
39 | 
40 |     base_url = webapp.settings['base_url']
41 |     webapp.add_handlers(".*$", [
42 |         (ujoin(base_url, NS, pat), handler)
43 |         for pat, handler in default_handlers
44 |     ])
45 |     nb_server_app.log.info("packagemanagerextension: Handlers enabled")
46 | 


--------------------------------------------------------------------------------
/extension/packagemanager/swanproject.py:
--------------------------------------------------------------------------------
 1 | # pylint: disable=C0321
 2 | 
 3 | import os
 4 | import yaml
 5 | 
 6 | from traitlets.config.configurable import LoggingConfigurable
 7 | from os.path import expanduser
 8 | 
 9 | try:
10 |     from .envmanager import EnvManager
11 | except:
12 |     from envmanager import EnvManager
13 | 
14 | class SwanProject(LoggingConfigurable):
15 |     '''
16 |     This class represents the in-memory form of the swanproject file
17 |     '''
18 | 
19 |     def __init__(self, directory):
20 |         directory = self.__relative_dir(directory) + ".swanproject"
21 |         self.directory = directory
22 |         self.env = ""
23 |         self.packages = {}
24 |         try:
25 |             filecontent = yaml.load(open(directory))
26 |             env = filecontent['ENV']
27 |             packages = filecontent['PACKAGE_INFO']
28 |             self.packages = packages
29 |             self.env = env
30 |         except:
31 |             pass
32 | 
33 |     def update_yaml(self):
34 |         '''
35 |         Updates the .swanproject file with new metadata
36 |         '''
37 |         directory = self.directory
38 |         data = {'ENV': self.env, 'PACKAGE_INFO': self.packages}
39 |         try:
40 |             with open(directory, 'w') as outfile:
41 |                 yaml.dump(data, outfile, default_flow_style=False)
42 |         except:
43 |             raise Exception("Can't update .swanproject file")
44 | 
45 |     def __relative_dir(self, directory):
46 |         '''
47 |         Ensures that all directories are relative to home
48 |         '''
49 |         home = expanduser("~")
50 |         if directory[0] != '/':
51 |             directory = '/' + directory
52 |         if directory[-1] != '/':
53 |             directory = directory + '/'
54 |         return home + directory
55 | 
56 |     def clear_yaml(self):
57 |         # Clear the contents of the .swanproject file
58 |         open(self.directory, 'w').close()
59 | 


--------------------------------------------------------------------------------
/extension/requirements.txt:
--------------------------------------------------------------------------------
1 | conda >= 4.5
2 | notebook >=4.3.1
3 | packaging
4 | 


--------------------------------------------------------------------------------
/extension/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | from setuptools import setup, find_packages
 4 | 
 5 | with open('VERSION') as version_file:
 6 |     version = version_file.read().strip()
 7 | 
 8 | setup(name='packagemanagerextension',
 9 |       version=version,
10 |       description='Jupyter notebook extension to manage packages in SWAN projects',
11 |       author='Akash Ravi',
12 |       author_email='akashkravi@gmail.com',
13 |       url='https://github.com/techtocore/Jupyter-Package-Manager',
14 |       include_package_data=True,
15 |       zip_safe=False,
16 |       install_requires=[
17 |           'conda >= 4.5',
18 |           'notebook >=4.3.1',
19 |           'packaging',
20 |           'pyyaml'
21 |       ],
22 |       )
23 | 


--------------------------------------------------------------------------------
/extension/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/techtocore/Jupyter-Package-Manager/9350b2aa18c22e1f615d8f73c88cc0ace6b4202d/extension/tests/__init__.py


--------------------------------------------------------------------------------
/extension/tests/test_modules.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | 
 3 | import sys, os
 4 | testdir = os.path.dirname(__file__)
 5 | srcdir = '../packagemanager'
 6 | sys.path.insert(0, os.path.abspath(os.path.join(testdir, srcdir)))
 7 | 
 8 | from packagemanagement import PackageManager
 9 | pkg_manager = PackageManager()
10 | 
11 | class TestPackageManager(unittest.TestCase):
12 | 
13 |     @classmethod
14 |     def setUpClass(self):
15 |         try:
16 |             path = '/SWAN_TEST'
17 |             os.mkdir(path)
18 |             filepath = path + '/.swanproject'
19 |             open(filepath, 'a').close()
20 |         except:
21 |             pass
22 | 
23 |     def test_list_projects(self):
24 |         a = pkg_manager.list_projects()
25 |         self.assertIsNotNone(a)
26 |     
27 |     def test_create_project(self):
28 |         a = pkg_manager.create_project('/SWAN_TEST', 'python3')
29 |         flag = True
30 |         try:
31 |             if len(a['error']) > 0:
32 |                 flag = False
33 |                 print(a['error'])
34 |         except:
35 |             pass
36 |         self.assertTrue(flag)
37 | 
38 |     # def test_search(self):
39 |     #     a = pkg_manager.search('pyyaml')
40 |     #     self.assertGreater()
41 | 
42 | 
43 | if __name__ == '__main__':
44 |     unittest.main()


--------------------------------------------------------------------------------
/extension/webpack.config.js:
--------------------------------------------------------------------------------
 1 | var path = require('path');
 2 | 
 3 | module.exports = {
 4 |     entry: './js/extension.js',
 5 |     output: {
 6 |         path: path.resolve(__dirname, 'packagemanager/js'),
 7 |         filename: 'extension.js',
 8 |         libraryTarget: 'umd'
 9 |     },
10 |     externals: ['jquery', 'base/js/namespace', 'base/js/utils', 'base/js/events', 'require', 'base/js/dialog'],
11 |     module: {
12 |         rules: [{
13 |             test: /\.html$/,
14 |             use: [{
15 |                 loader: 'html-loader',
16 |                 options: {
17 |                     minimize: true
18 |                 }
19 |             }
20 |             ],
21 |         },
22 |         {
23 |             test: /\.css$/,
24 |             use: [
25 |                 'style-loader',
26 |                 'css-loader'
27 |             ]
28 |         }]
29 |     }
30 | };
31 | 


--------------------------------------------------------------------------------