From news.groups.newgroups:

This is an official communication from the Big-8 Management Board. Please note that followups are set to news.groups.

After a careful review of the Big 8 Management Board’s activity and process, all remaining members of the Big 8 Management Board opted not to consider re-election and instead have voted to install two new volunteers as the new members of the Big 8 Management Board. These two volunteers are:

Tristan Miller Jason Evans

We believe these volunteers have the technical and social skills necessary to maintain the Big-8. Please give them your support while they develop their vision for the future mission and goals of the Big 8 Board.

Kathy Morgan, Chairperson Emeritus Bill Horne, former Chairperson

Introduction

YaST2 is a venerable project that has been around for more than 20 years now. It keeps evolving and, with every SUSE and openSUSE release, it takes several new features (and a couple of new bugs). Needlessly to say that, to some extent, YaST2 is showing its age. We are aware of it, and we have been working to tackle this problem. The successful rewrite of the storage layer, which brought many features, is an example we can feel proud of.

Now that the development of SLE 15 SP2 and openSUSE Leap 15.2 features is mostly done, we have started to look to AutoYaST. The purpose of this article is to present our initiative to modernize AutoYaST.

First of all, let’s make it clear: we do not plan to rewrite AutoYaST. What we want to do is:

• Fix several bugs and remove some known limitations.
• Improve the tooling around AutoYaST.
• Introduce a few features that can help our users.
• Work hard to improve code quality.

Although nothing is set in stone yet, this document tries to present some ideas we are considering. But they are just that, ideas. We have identified the main areas that we want to improve, and now we are trying to come up with a more concrete (and realistic) plan.

Creating a profile does not need to be hard

Perhaps one of the main complaints about using AutoYaST is that writing a profile can be tricky. The easiest way is to perform a manual installation and generate the profile from the command line or using the AutoYaST UI.

If you decide to go for the command line approach, yast2 clone_system generates an XML file containing all the details from the underlying system. The generated profile is quite long, and usually you want to make it shorter by removing unimportant sections. For instance, you do not need the full list of users (the corresponding packages creates them) or services.

The alternative is to use the AutoYaST UI, which is a tool that allows you to create and edit profiles, although it has several bugs that we need to fix.

As part of this modernizing AutoYaST initiative, we would like to make things easier when it comes to deal with profiles. We are considering a few options:

• Improve AutoYaST UI quality.
• Provide a set of templates you can base on: minimal, hardening, etc.
• Optionally, do not export the default options, making the profile shorter.
• Implement a wizard that can guide you through the process of creating a profile from scratch (selecting the product, the list of add-ons, the filesystem type, etc.). It could also offer a CLI:

$ yast2 autoyast_profile --product SLES-15.2 \
  --addons sle-module-basesystem,sle-module-development-tools \
  --regcode XXXX \
  --filesystem btrfs

Integrated profile validation

One of the advantages of using XML is that we can rely on the existing tools to validate the profile. The AutoYaST Guide documents the usage of xmllint and jing for that. As part of this initiative, we would like to integrate the validation within the installation process. So one of the first things that AutoYaST would do is checking whether the profile is valid or not.

However, this kind of validation does not detect logical problems. Some of them are easy to find by just analyzing the profile, and we could consider adding some additional checks. But there is another whole category of problems that you cannot anticipate. For instance, consider that you want to reuse a partition that does not exist. And that brings us to the next topic: error reporting.

Better error reporting

If something unexpected happens during the installation, AutoYaST reports the issue. The user can decide whether a problem should stop the installation or not depending on its severity. Obviously, in some cases, the installation is simply not possible and AutoYaST aborts the process.

Error reporting infrastructure can be improved. For instance, it would be nice to group related messages and show them at once, instead of stopping the installation several times. Fortunately, during the storage layer rewrite, we introduced a mechanism that enables us to do that. Now it is a matter of extending its API and using it in more places.

Another nice feature could be to allow filtering the messages not only by its severity but by its module as well (e.g., partitioning warnings only), offering more control on error reporting. And the new code would enable us to do that.

Getting rid of the 2nd stage

Depending on the content of the profile, the installation would be finished after the first reboot. In the past, SUSE and openSUSE installation took place in two phases known as stages, but that it is not true anymore for the manual installation. However, AutoYaST still requires that in some cases. For instance, if you use the <files> section, AutoYaST copies the files after rebooting.

We plan to move everything we can to the 1st stage, skipping the 2nd stage entirely. We will keep the 2nd stage, though, because third party modules could use it as an extension point. But YaST2 core modules should avoid it.

To be honest, it sounds easier than it is (there are some corner cases to consider), and we are still checking whether it is technically possible.

Introducing dynamic profiles

In some situations, it is desirable to modify a profile at runtime. For instance, let’s consider that you want to install several machines with different software selections. The profiles would be almost identical, so it does not make sense to keep one for each machine.

AutoYaST already offers two mechanisms for that: rules and classes and pre-install scripts.

The first one is a feature that, for some reason, remains relatively unknown. It allows to combine several XML files depending on a set of rules which are applied at runtime. Although it is quite powerful, their specification is really verbose and the merging process can be rather confusing in some cases.

Alternatively, pre-install scripts are widely used. You can then rely on the classical Linux tools (sed, awk, etc.), or Python, or Perl, or Ruby… well, you cannot use Ruby, but that is something we will fix. :sweat_smile:

However, we have been thinking about making things even easier by allowing to embed Ruby (ERB) in AutoYaST profiles:

<?xml version="1.0" encoding="utf-8"?>
<partitioning config:type="list">
  <drive>
    <!-- vda, sda, ... -->
    <device><%= script("find_root_device.sh") -%></device>
    <use>all</use>
  </drive>
</partitioning>

<%= include_file("https://example.net/profiles/software-#{node["mac"]}.xml") %>
    
<% if arch?("s390x") -%>
<dasd>
  <!-- dasd configuration -->
</dasd>
<% end -%>

Please, bear in mind that it is just an example, and we do not even know whether this feature makes sense to you. Does it?

Conclusions

After reading this document, there is a chance that you have comments or new ideas to discuss. And we would love to hear from you! So you can reach the YaST team through the yast-devel or opensuse-autoinstall mailing lists or, if you prefer, we are usually at #yast channel at Freenode.

Finally, we would like to thank everyone that got involved in the discussions (e.g., The (near) future of AutoYaST and AutoYaST tools: feedback wanted) and our colleagues at SUSE for providing feedback and ideas.

Hi,

The SUSE Linux Enterprise Team is acknowledging the openSUSE community needs for a better and transparent collaboration with SUSE. We have now a momentum to think and be different.

The symbiosis between SUSE Linux Enterprise and openSUSE is real, we share so much more than just code, we use the same tools like Open Build Service, openQA, similar maintenance processes, people (Release Managers, contributors, etc) and more.

We might have been a bit quiet in the past but that doesn’t mean we didn’t evolve; over the years, we have created more bonds like Package Hub, foster our contribution with SLE Factory First Policy for SUSE employees and our Technology Partners, be more accessible during our development phase with the SLE Public Beta Program, just to name a few examples.

But now we have a momentum to accelerate, especially with regard to being more transparent with our defects and feature requests for the benefit of the openSUSE distribution and community. So we heard you, and today we want to clarify and improve processes, for all of us, and give some inputs on SUSE internal discussions about kicking out the so called “closed doors”.

So without further ado, here is our action items:

• Refresh and create openSUSE wiki pages for processes clarification
  • Luboš Kocman has already started with documenting the process in place for retrieving SLE Feature Requests and his plan is to present a real and better feature process for external contributors by October or sooner.
  • We will also review and improve “how to contribute , openSUSE Leap development phase” to clarify and formalize information that existed for years, but was not documented.
  • Create new page about our “SLE Factory First Policy”, and potential maintenance and quality assurance topics.
• Talk more openly about openSUSE and SLE relationship,
  • “Current and Future strategy for openSUSE Leap” and “Jump! Current state and upcoming changes” during openSUSE virtual summit.
  • Upcoming topic in the “How SUSE Builds its Enterprise Linux Distribution” blog post.
  • A talk about “relationship in between SLE and openSUSE” at the Virtual SUSECon.
• Find the proper way to open our bugzilla.suse.com
  • SUSE is fully committed to protect our customers and partners private data hosted in our tool like Bugzilla. They trust us with their highly sensitive data, so we approach this topic very seriously. However thanks to the full handover of the Bugzilla instances from MicroFocus to SUSE, we now have full control over Bugzilla thus we can now discuss how to change our processes internally to combine data privacy and openness.
  • A group has been formed (Vincent Untz, Anna Maresova and Vincent Moutoussamy) to drive this project internally and will be in charge of discussing the proposal with all stakeholders including the openSUSE community of course.
• Special attention to openSUSE 15.2 (and future) Leap bug reports
  • Last but not least, Luboš Kocman, openSUSE Leap Release Manager, is committed to review, triage openSUSE Leap 15.2 bugs and feature requests (create a bug for openSUSE Leap 15.2), and escalate to SLE Product and Release Manager.

We believe this is an exciting and ambitious plan, and we hope to share more concrete information as soon as possible.

In the mean time, do not hesitate to engage with the presenters of “openSUSE and SLE” talks, Luboš obviously, and feel free to comment or send us your feedback here in this thread.

Stay tuned, stay home, stay safe and stay green.

The SUSE Linux Enterprise Team

I started using Emacs in 1995, and since then I have been carrying a .emacs that by now has a lot of accumulated crap. It is such an old configuration that it didn't even use the modern convention of ~/.emacs.d/init.el (and it looks like a newer Emacs version will allow .config/emacs as per the XDG standard... at last).

I have wanted to change my Emacs configuration for some time, and give it all the pretty and modern toys.

The things that matter the most to me:

• Not have a random dumpster in ~/.emacs if possible.
• Pretty colors.
• Magit.
• Rust-mode or whatever the new thing is for rust-analyzer and the Language Server.

After looking at several examples of configurations that mention use-package as a unified way of loading packages and configuring them, I found this configuration which is extremely well documented. The author does literate programming with org-mode and elisp — something which I'm casually interested in, but not just now — but that way everything ends up very well explained and easy to read.

I extracted bits of that configuration and ended up with the following.

Everything in ~/.emacs/init.el and with use-package

;; Initialize package system

(require 'package)

(setq package-archives
      '(("org"     .       "https://orgmode.org/elpa/")
        ("gnu"     .       "https://elpa.gnu.org/packages/")
        ("melpa"   .       "https://melpa.org/packages/")))

(package-initialize)
;(package-refresh-contents)

;; Use-package for civilized configuration

(unless (package-installed-p 'use-package)
  (package-install 'use-package))
(require 'use-package)

(setq use-package-always-ensure t)

~/.emacs.d/custom.el for M-x customize stuff

;; Set customization data in a specific file, without littering
;; my init files.

(setq custom-file "~/.emacs.d/custom.el")
(load custom-file)

Which-key to get hints when typing command prefixes

;; Make it easier to discover key shortcuts

(use-package which-key
  :diminish
  :config
  (which-key-mode)
  (which-key-setup-side-window-bottom)
  (setq which-key-idle-delay 0.1))

Don't pollute the modeline with common modes

;; Do not show some common modes in the modeline, to save space

(use-package diminish
  :defer 5
  :config
  (diminish 'org-indent-mode))

Magit to use git in a civilized fashion

;; Magit

(use-package magit
  :config
  (global-set-key (kbd "C-x g") 'magit-status))

Move between windows with Shift-arrows

;; Let me switch windows with shift-arrows instead of "C-x o" all the time
(windmove-default-keybindings)

Pretty colors

I was using solarized-dark but I like this one even better:

;; Pretty colors

(use-package flatland-theme
  :config
  (custom-theme-set-faces 'flatland
   '(show-paren-match ((t (:background "dark gray" :foreground "black" :weight bold))))
   '(show-paren-mismatch ((t (:background "firebrick" :foreground "orange" :weight bold))))))

Nyan cat instead of scrollbars

;; Nyan cat instead of scrollbar
;; scroll-bar-mode is turned off in custom.el

(use-package nyan-mode
  :config
  (nyan-mode 1))

Move buffers to adjacent windows

;; Move buffers between windows

(use-package buffer-move
  :config
  (global-set-key (kbd "<C-S-up>")     'buf-move-up)
  (global-set-key (kbd "<C-S-down>")   'buf-move-down)
  (global-set-key (kbd "<C-S-left>")   'buf-move-left)
  (global-set-key (kbd "<C-S-right>")  'buf-move-right))

Change buffer names for files with the same name

;; Note that ‘uniquify’ is builtin.
(require 'uniquify)
(setq uniquify-separator "/"               ;; The separator in buffer names.
      uniquify-buffer-name-style 'forward) ;; names/in/this/style

Helm to auto-complete in grand style

(use-package helm
 :diminish
 :init (helm-mode t)
 :bind (("M-x"     . helm-M-x)
        ("C-x C-f" . helm-find-files)
        ("C-x b"   . helm-mini)     ;; See buffers & recent files; more useful.
        ("C-x r b" . helm-filtered-bookmarks)
        ("C-x C-r" . helm-recentf)  ;; Search for recently edited files
        ("C-c i"   . helm-imenu)
        ("C-h a"   . helm-apropos)
        ;; Look at what was cut recently & paste it in.
        ("M-y" . helm-show-kill-ring)

        :map helm-map
        ;; We can list ‘actions’ on the currently selected item by C-z.
        ("C-z" . helm-select-action)
        ;; Let's keep tab-completetion anyhow.
        ("TAB"   . helm-execute-persistent-action)
        ("<tab>" . helm-execute-persistent-action)))

Ripgrep to search in grand style

;; Ripgrep

(use-package rg
  :config
  (global-set-key (kbd "M-s g") 'rg)
  (global-set-key (kbd "M-s d") 'rg-dwim))

(use-package helm-rg)

Rust mode and Language Server

Now that RLS is in the process of being deprecated, it's getting substituted with rust-analyzer. Also, rust-mode goes away in favor of rustic.

;; Rustic, LSP

(use-package flycheck)

(use-package rustic)

(use-package lsp-ui)

(use-package helm-lsp
  :config
  (define-key lsp-mode-map [remap xref-find-apropos] #'helm-lsp-workspace-symbol))

Performatively not get distracted

;;; Show a notification when compilation finishes

(setq compilation-finish-functions
      (append compilation-finish-functions
          '(fmq-compilation-finish)))

(defun fmq-compilation-finish (buffer status)
  (when (not (member mode-name '("Grep" "rg")))
    (call-process "notify-send" nil nil nil
          "-t" "0"
          "-i" "emacs"
          "Compilation finished in Emacs"
          status)))

Stuff from custom.el

The interesting bits here are making LSP work; everything else is preferences.

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(column-number-mode t)
 '(custom-safe-themes
   (quote
    ("2540689fd0bc5d74c4682764ff6c94057ba8061a98be5dd21116bf7bf301acfb" "bffa9739ce0752a37d9b1eee78fc00ba159748f50dc328af4be661484848e476" "0fffa9669425ff140ff2ae8568c7719705ef33b7a927a0ba7c5e2ffcfac09b75" "2809bcb77ad21312897b541134981282dc455ccd7c14d74cc333b6e549b824f3" default)))
 '(delete-selection-mode nil)
 '(lsp-rust-analyzer-display-chaining-hints t)
 '(lsp-rust-analyzer-display-parameter-hints nil)
 '(lsp-rust-analyzer-macro-expansion-method (quote rustic-analyzer-macro-expand))
 '(lsp-rust-analyzer-server-command (quote ("/home/federico/.cargo/bin/rust-analyzer")))
 '(lsp-rust-analyzer-server-display-inlay-hints nil)
 '(lsp-rust-full-docs t)
 '(lsp-rust-server (quote rust-analyzer))
 '(lsp-ui-doc-alignment (quote window))
 '(lsp-ui-doc-position (quote top))
 '(lsp-ui-sideline-enable nil)
 '(menu-bar-mode nil)
 '(package-selected-packages
   (quote
    (helm-lsp lsp-ui lsp-mode flycheck rustic rg helm-rg ripgrep helm-projectile helm buffer-move nyan-mode flatland-black-theme flatland-theme afternoon-theme spacemacs-theme solarized-theme magit diminish which-key use-package)))
 '(rustic-lsp-server (quote rust-analyzer))
 '(scroll-bar-mode nil)
 '(scroll-step 0)
 '(tool-bar-mode nil))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )

Results

I am very happy with rustic / rust-analyzer and the Language Server. Having documentation on each thing when one moves the cursor around code is something that I never thought would work well in Emacs. I haven't decided if I love M-x lsp-rust-analyzer-inlay-hints-mode or if it drives me nuts; it shows you the names of function arguments and inferred types among the code. I suppose I'll turn it off and on as needed.

Some days ago, before using helm, I had projectile-mode to work with git checkouts and I was quite liking it. I haven't found how to configure helm-projectile to work; I'll have to keep experimenting.

Dear Tumbleweed users and hackers,

The last week was filled with success. The major change was surely the removal of python2-FOO modules from the distro. Not exactly all are gone yet (packages that fail to build do also not change the published modules), but we went form 2564 (Snapshot 0417) modules down to 203 (0422). But of course, that’s not all that has happened. After all, we released 6 snapshots in the last week (0415, 0416, 0417, 0419, 0421 and 0422).

The noteworthy changes therein were:

• Python2 removal (modules; keep in mind: interpreter, python2-pip and python2-setuptools stick around a bit longer for the users to consume)
• Mozilla Thunderbird 68.7.0
• KDE Frameworks 5.69.0
• Systemd 245
• util-linux 2.35.1
• Linux kernel 5.6.4
• Poppler 0.87.0
• VLC 3.0.9.2
• Sudo 1.9.0rc2 (see announcement mail)

Many things that were in stagings last week are still there, but are getting closer to be shipped:

• GNOME 3.36.1 (Snapshot 0423+)
• KDE Applications 20.04
• Guile 3.0.2: breaks gnutls’ test suite on i586
• Qt 5.15.0 (currently beta3 is staged)
• Switch from Ruby 2.6 to 2.7 (some preparations/fixes are coming by regularly)
• GCC 10 as the default compiler

First we will need to populate the conainer 
with an openSUSE base system.
TARGETDIR=$HOME/OBS_CONTAINER/OBSCONTAINER/
SOURCEREPODIR=/etc/zypp/repos.d/
#lazily copy existing *.repos
for f in *.repo
do
sudo cp $SOURCEREPODIR$f $TARGETDIR/$SOURCEREPODIR
done
cd $TARGETDIR
sudo mkdir -p sys proc dev
sudo mount -t proc proc proc/
sudo mount -o bind /sys sys/
sudo mount -o bind /dev dev/
sudo zypper --no-gpg-checks --non-interactive --cache-dir /var/cache/zypp --root $TARGETDIR in --allow-unsigned-rpm --auto-agree-with-licenses filesystem bash permissions coreutils bash-completion cpio coreutils glibc permissions systemd systemd-rpm-macros systemd-presets-branding-openSUSE rpm zypper nano system-group-wheel system-group-hardware system-user-bin system-user-root system-user-nobody sudo systemd-network yast2-network NetworkManager nmcli-dmenu mariadb systemd-container obs-service-obs_scm obs-service-tar_scm

Okay so far so good. The base system is already bootable via nspawn.
We need some set-up of the system before we do it though:
sudo chroot $TARGETDIR /usr/bin/bash -c "systemd-machine-id-setup"
sudo chroot $TARGETDIR /usr/bin/bash -c "ln -sf /etc/machine-id /var/lib/dbus/machine-id"

Now it's time to install OBS itself
sudo zypper --cache-dir /var/cache/zypp --root $TARGETDIR ar https://download.opensuse.org/repositories/OBS:/Server:/Unstable/openSUSE_Factory/OBS:Server:Unstable.repo
sudo zypper --no-gpg-checks --non-interactive --cache-dir /var/cache/zypp --root $TARGETDIR in --allow-unsigned-rpm --replacefiles --auto-agree-with-licenses -t pattern OBS_Server
sudo zypper --no-gpg-checks --non-interactive --cache-dir /var/cache/zypp --root $TARGETDIR in --allow-unsigned-rpm --replacefiles --auto-agree-with-licenses obs-service-set_version obs-service-recompress 

We are now able to boot the systemd container and set-up OBS.
With the same commands you will be able to boot it in the future too.
RUNDIR=$HOME/OBS_CONTAINER/run
sudo systemd-nspawn -D $TARGETDIR -b --resolv-conf=bind-host --capability=all --property="DeviceAllow=/dev/loop-control rwm" --property="DeviceAllow=/dev/loop-* rwm" --property="DeviceAllow=block-loop rwm" --property="DeviceAllow=block-* rwm" --bind="$RUNDIR/obs/:/run/obs" --bind="$RUNDIR/passenger/:/run/passenger/" --bind="$RUNDIR/mysql/:/run/mysql/" --property="DeviceAllow=/dev/port rwm" --property="DeviceAllow=block-blkext rwm" --property="DeviceAllow=char-pts rwm" --property="DeviceAllow=/dev/null rwm" --property="DeviceAllow=/dev/zero rwm" --property="DeviceAllow=/dev/random rwm" --property="DeviceAllow=/dev/urandom rwm"

And since we have not set a root password, but one is expected,
we connect from a different console and start the setup.
Unless you want to customize ports/ip etc. you can leave 
everything at the default from setup-appliance.sh 
sudo machinectl --machine OBSCONTAINER shell
/usr/lib/obs/server/setup-appliance.sh --force #inside the machine

The Corona (Corvid-19) virus has forced a lot of us to work from home. My preferred way of working, is by using openSUSE. Because my company has decided a while ago that Office365 and Microsoft Teams would be the default applications for collaboration, I am able to do so.

Installing Microsoft Teams Preview

The first thing to do is to go to the Microsoft Teams website to download the Teams software package.

Save the RPM file to your computer.

Now open the Dolphin file browser and either press F4 or click on: Control –> Panels –> Terminal.

Now install Teams by using the command:

sudo zypper install teams-versionnumber.x86_64.rpm

First enter your root password. When asked to confirm the installation, type ‘y’ and then press Enter.

After installation, type ‘Teams’ in your launcher to start the Microsoft Teams – Preview application.

You can login by entering your (work) e-mail address and your password and if needed the Two Factor Authentication approval.

My experience

Teams on Linux works very well. Video conferencing also works like a charm. It also works great with SharePoint (for accessing your Teams files), Outlook (for knowing when your next meeting starts), Word, Excel and PowerPoint. Everything works as you would expect.

The Word, Excel, PowerPoint versions are comparable with the browser versions of Office365. So the desktop apps still work a bit better. For instance when creating rich formatted Word documents or when creating visually impressive PowerPoint presentations. But I am able to do minor edits without a problem.

Conclusion

Microsoft Teams on Linux works just as well as the Windows version. And that is one of the biggest compliments that you can give to a Microsoft Office application. The only difference is that you cannot open files in the desktop versions of Word, Excel or PowerPoint. So now we wait for those to come to Linux as well!

Published on: 20 April 2020

We have to use Jupyter notebooks for Machine Learning at our university. Jupyter needs a lot of space on the hard disk and I was able to remember (from vocational school) that we were able to install PHPMyAdmin on a USB stick. You have a transportable web application on this way. I had this goal for Jupyter and the Python environment on Linux.

So I want to give you the installation guide for Jupyter on openSUSE Leap 15.1 (incl. Python) in a virtual environment.
Install the following packages as a foundation:

 sudo zypper install python3-pip python3-devel

After that install the virtual environment with pip3:

sudo pip3 install --upgrade pip
sudo pip3 install virtualenv

Create a project directory for Jupyter in your home directory and mount the external disk/ USB stick there:

sudo mkdir ~/Jupyter
sudo mount /dev/sda1 ~/Jupyter

You have to umount /dev/sda1, if the disk has been mounted automatically in /run/media/ (in my case):

sudo umount /run/media/user/TOSHIBA\ EXT/
sudo mount /dev/sda1 ~/Jupyter

If the external disk is mounted, you can create the virtual environment for Python and Jupyter in the special project directory:

virtualenv ~/Jupyter

Inside, it will install a local version of Python and a local version of pip. We can use this to install and configure an isolated Python environment for Jupyter.
Before we install Jupyter, we need to activate the virtual environment:

source ~/Jupyter/bin/activate

You are ready to install Jupyter into this virtual environment.
You can install Jupyter on the external disk with the following command:

pip install jupyterlab

Call Jupyter via command line inside of the project directory then:

jupyter notebook

That will open your web browser with http://localhost:8888/tree.
Do you need additional packages or Python libraries? You can install them in this project directory, too.
Change to this directory and install them with pip3 (in my case these ML packages):

pip3 install scipy numpy matplotlib sklearn pandas
pip3 install keras tensorflow

Enjoy Jupyter on an external disk.

Here it is! Qactus v2.0.0 has been released
The main focus of this version has been on improving the browser.

New features:

• Improved UI: revamped toolbar, new action toolbars for projects, packages, files and build results, new side bar icons
• Bookmarks: first version for the watchlist
• New package actions: submit, copy, link and properties
• New project action: properties
• MetaConfigEditor (beta): now it is possible to edit a project/package properties such as general info, repository, repository flags, users and groups
• New search widget (Ctrl+F) for BuildLogViewer
• Showing outgoing and declined requests

Miscellaneous bugfixes and «hidden features»

Source code – RPM packages