KDE Plasma 5 is a collection of packages based on top of KDE Frameworks 5 and QML. They implement the KDE Display Environment (Plasma 5).
This package is known to build and work properly using an LFS-9.1 platform.
The instructions below build all of the Plasma 5 packages in one step by using a bash script.
Download (HTTP): http://download.kde.org/stable/plasma/5.18.1
Download MD5 sum: See Below
Download size: 108 MB
Estimated disk space required: 1.2 GB (294 MB installed)
Estimated build time: 17 SBU (using parallelism=4)
GConf-3.2.6, GTK+-2.24.32, GTK+-3.24.16, KDE Frameworks-5.67.0, libpwquality-1.4.2, libxkbcommon-0.10.0, Mesa-20.0.2 built with Wayland-1.18.0, NetworkManager-1.22.10, pipewire-0.3.2, PulseAudio-13.0, qca-2.3.0, sassc-3.6.1, taglib-1.11.1, and xcb-util-cursor-0.1.3
fftw-3.3.8, gsettings-desktop-schemas-3.36.0, libdbusmenu-qt-0.9.3+16.04.20160218, libcanberra-0.30, libinput-1.15.4, Linux-PAM-1.3.1, lm-sensors-3-6-0, oxygen-icons5-5.67.0, and pciutils-3.6.4
GLU-9.0.1, ibus-1.5.22, Xorg Synaptics Driver-1.9.1, appstream-qt, KDevPlatform, libgps, libhybris, libraw1394, mockcpp, packagekit-qt, Qalculate, Qapt, SCIM, and socat (for pam_kwallet)
User Notes: http://wiki.linuxfromscratch.org/blfs/wiki/kf5
The easiest way to get the KDE Plasma5 packages is to use a single wget to fetch them all at once:
url=http://download.kde.org/stable/plasma/5.18.1/
wget -r -nH -nd -A '*.xz' -np $url
The options used here are:
-r recurse through child directories
-nH disable generation of host-prefixed directories
-nd do not create a hierarchy of directories
-A '*.xz' just get the *.xz files
-np don't get parent directories
The order of building files is important due to internal dependencies. Create the list of files in the proper order as follows:
cat > plasma-5.18.1.md5 << "EOF"
be7cccb3859c253740ad20eae56a1457 kdecoration-5.18.1.tar.xz
84b92ff5c7ab70537bc757122375ab3c libkscreen-5.18.1.tar.xz
645e7d0e5167d89abfcb0011748179a8 libksysguard-5.18.1.tar.xz
0d6769306901883a9aadaaed4c199314 breeze-5.18.1.tar.xz
9c797eddc66820e119a32b3ca0e54327 breeze-gtk-5.18.1.tar.xz
2369c961fee61992bf16f8e5aabc296a kscreenlocker-5.18.1.tar.xz
da5b0b9caca27a0b7faea3aac732e5d5 oxygen-5.18.1.tar.xz
c687fdd7a0c36a3a6d7ebd063f3aee61 kinfocenter-5.18.1.tar.xz
ae2bf8875c1b374d172267c7a0cca982 ksysguard-5.18.1.tar.xz
216b067f13f43238c7515815001fc862 kwin-5.18.1.tar.xz
97c106ec13bd9ecf87cc61e1cc29f374 plasma-workspace-5.18.1.tar.xz
8d3ea52e9b215523225e316d47469f3f bluedevil-5.18.1.tar.xz
7c16855fe0c390a9eaa60d2f4e624736 kde-gtk-config-5.18.1.tar.xz
597ac5c22e2dc7bad5773781c4f5c563 khotkeys-5.18.1.tar.xz
cd59deb1769ed3fdcfd620f1d5e82676 kmenuedit-5.18.1.tar.xz
e957ca2f6374385e3b5598f839f843a5 kscreen-5.18.1.tar.xz
25db35f344bd12fdf6d6e54b87d4b90c kwallet-pam-5.18.1.tar.xz
8bda1526aa7f9dbf6aa842b08cf22655 kwayland-integration-5.18.1.tar.xz
d0a29aed4ee8bcd9fce3e545f82832be kwrited-5.18.1.tar.xz
2f4252bc1a8b07062e57d229fc3bc361 milou-5.18.1.tar.xz
8663fa971594bc70d6898e8604f8c99a plasma-nm-5.18.1.tar.xz
0554888991a1f1f70cbbb95afa48184a plasma-pa-5.18.1.tar.xz
25fcaf7cb52f20b3126af9baa1409e3c plasma-workspace-wallpapers-5.18.1.tar.xz
0b88def5b87e822aa7370d91dfd07913 polkit-kde-agent-1-5.18.1.tar.xz
0326bf85fb50e15d5e78c43be9457993 powerdevil-5.18.1.tar.xz
58ec01d70d18f23a03ec2040beb506f1 plasma-desktop-5.18.1.tar.xz
9a44fb928f5dd22a695d38617660aeee kdeplasma-addons-5.18.1.tar.xz
7200c6ebdc63dde79f64a9b2472b2d37 kgamma5-5.18.1.tar.xz
78d68fd989b451a8e75fd9278a0c1947 ksshaskpass-5.18.1.tar.xz
#4c907670bbe788499038254311f6ac0b plasma-sdk-5.18.1.tar.xz
7533a7a459d476ece00d558d4fc9a8f7 sddm-kcm-5.18.1.tar.xz
2b2351beb674ce01cca0b58d3c8a49b2 user-manager-5.18.1.tar.xz
c76653dce9c3f9f1ac1edae6fe342ee7 discover-5.18.1.tar.xz
#ca25ee8ad60b64d19850ccba8994547c breeze-grub-5.18.1.tar.xz
#c8377f0f2ac3109014c8062e74145def breeze-plymouth-5.18.1.tar.xz
7b5e6cbb5d84b69745030773bea176c0 kactivitymanagerd-5.18.1.tar.xz
fa2e316a15f24c64a71c36d30b7f7585 plasma-integration-5.18.1.tar.xz
a5d8cc4a47ba59969f98be0cc5800f83 plasma-tests-5.18.1.tar.xz
#c13ae6eaa29760e67a9c17d6a1a48153 plymouth-kcm-5.18.1.tar.xz
d6e2d1a982c83a553607d46a04fcfff7 xdg-desktop-portal-kde-5.18.1.tar.xz
5b7bf736b767d40d77a4c51bca9708e0 drkonqi-5.18.1.tar.xz
1ccf74eb8b851b1dba87f2cd3ed54052 plasma-vault-5.18.1.tar.xz
a0f85c77e48c35a17cc326491155249e plasma-browser-integration-5.18.1.tar.xz
7d73463b9115234991a631dc6741bab4 kde-cli-tools-5.18.1.tar.xz
d420ca0680c67496b8572b143aae1dc9 systemsettings-5.18.1.tar.xz
a2ae6b65f5ae2df57cfb29bf8ae56eda plasma-thunderbolt-5.18.1.tar.xz
#3df1a7d13f5cce484ce8fb684c1c0015 plasma-nano-5.18.1.tar.xz
#498e4c99016d51bc44abdb8416e7dba2 plasma-phone-components-5.18.1.tar.xz
EOF
The breeze-grub, breeze-plymouth, and plymouth-kcm packages above are all for customized support of Plymouth which is designed to be run within an initial ram disk during boot (see the section called “About initramfs”). The plasma-sdk package is optional and used for software development. The plasma-nano package is used for embedded systems and plasma-phone-components provides phone functionality for Plasma.
When installing multiple packages in a script, the installation needs to be done as the root user. There are three general options that can be used to do this:
Run the entire script as the root user (not recommended).
Use the sudo command from the Sudo-1.8.31p1 package.
Use su -c "command arguments" (quotes required) which will ask for the root password for every iteration of the loop.
One way to handle this situation is to create a short bash function that automatically selects the appropriate method. Once the command is set in the environment, it does not need to be set again.
as_root() { if [ $EUID = 0 ]; then $* elif [ -x /usr/bin/sudo ]; then sudo $* else su -c \\"$*\\" fi } export -f as_root
First, start a subshell that will exit on error:
bash -e
Install all of the packages by running the following commands:
while read -r line; do # Get the file name, ignoring comments and blank lines if $(echo $line | grep -E -q '^ *$|^#' ); then continue; fi file=$(echo $line | cut -d" " -f2) pkg=$(echo $file|sed 's|^.*/||') # Remove directory packagedir=$(echo $pkg|sed 's|\.tar.*||') # Package directory tar -xf $file pushd $packagedir # Fix some build issues when generating some configuration files case $name in plasma-workspace) sed -i '/set.HAVE_X11/a set(X11_FOUND 1)' CMakeLists.txt ;; khotkeys) sed -i '/X11Extras/a set(X11_FOUND 1)' CMakeLists.txt ;; plasma-desktop) sed -i '/X11.h)/i set(X11_FOUND 1)' CMakeLists.txt ;; esac mkdir build cd build cmake -DCMAKE_INSTALL_PREFIX=$KF5_PREFIX \ -DCMAKE_BUILD_TYPE=Release \ -DBUILD_TESTING=OFF \ -Wno-dev .. && make as_root make install popd as_root rm -rf $packagedir as_root /sbin/ldconfig done < plasma-5.18.1.md5 exit
If you did not set $KF5_PREFIX
to
/usr
, create symlinks to allow
display managers to find Plasma:
as_root install -dvm 755 /usr/share/xsessions && cd /usr/share/xsessions/ && [ -e plasma.desktop ] || as_root ln -sfv $KF5_PREFIX/share/xsessions/plasma.desktop && as_root install -dvm 755 /usr/share/wayland-sessions && cd /usr/share/wayland-sessions/ && [ -e plasmawayland.desktop ] || as_root ln -sfv $KF5_PREFIX/share/wayland-sessions/plasmawayland.desktop
If you built Plasma with the recommended Linux PAM support, create necessary
configuration files by running the following commands as the
root
user:
cat > /etc/pam.d/kde << "EOF"# Begin /etc/pam.d/kde auth requisite pam_nologin.so auth required pam_env.so auth required pam_succeed_if.so uid >= 1000 quiet auth include system-auth account include system-account password include system-password session include system-session # End /etc/pam.d/kde
EOF cat > /etc/pam.d/kde-np << "EOF"# Begin /etc/pam.d/kde-np auth requisite pam_nologin.so auth required pam_env.so auth required pam_succeed_if.so uid >= 1000 quiet auth required pam_permit.so account include system-account password include system-password session include system-session # End /etc/pam.d/kde-np
EOF cat > /etc/pam.d/kscreensaver << "EOF"# Begin /etc/pam.d/kscreensaver auth include system-auth account include system-account # End /etc/pam.d/kscreensaver
EOF
You can start Plasma5 from runlevel 3, using xinit-1.4.1, or from runlevel 5, using a Display Manager, such as lightdm-1.30.0.
To start Plasma 5 using xinit-1.4.1, run the following commands:
cat > ~/.xinitrc << "EOF"
dbus-launch --exit-with-session $KF5_PREFIX/bin/startplasma-x11
EOF
startx
The X session starts on the first unused virtual terminal, normally vt7. You can switch to another vtn simultaneously pressing the keys Ctrl-Alt-Fn (n=1, 2, ...). To switch back to the X session, normally started at vt7, use Ctrl-Alt-F7. The vt where the command startx was executed will display many messages, including X starting messages, applications automatically started with the session, and eventually, some warning and error messages. You may prefer to redirect those messages to a log file, which not only will keep the initial vt uncluttered, but can also be used for debugging purposes. This can be done starting X with:
startx &> ~/x-session-errors
When shutting down or rebooting, the shutdown messages appear on the vt where X was running. If you wish to see those messages, simultaneously press keys Alt-F7 (assuming that X was running on vt7).
If you intend to start Plasma
using a display manager such as lightdm-1.30.0,
there will be two entries for Plasma, one for use with Xorg, and another for Wayland. Modify the Xorg entry with the following command, as the
root
user, so that you can
differentiate between the two:
sed '/^Name=/s/Plasma/Plasma on Xorg/' -i /usr/share/xsessions/plasma.desktop
Last updated on 2015-09-24 16:44:04 -0500


+++ title = "Orphan local girls seeking chocolate" slug = "orphan-local-girls-seeking-chocolate" date = 2007-06-07T14:00:00+10:00 tags = ["locals", "eccentric-encounters", "mad-bolivia"] locations = ["bolivia/isla-del-sol"] draft = false summary = """
After only one day in Bolivia, I've already met my first two (of many) stark raving mad locals. These two cute little girls from Isla Del Sol demanded chocolate from us numerous times. When we refused, they explained how their parents are dead — "viven en el cielo" (lit: "they live in the sky") — and when we gave them some, they burst into hysterical laughter.
""" +++After only one day in Bolivia, I've already met my first two (of many) stark raving mad locals. These two cute little girls from Isla Del Sol demanded chocolate from us numerous times. When we refused, they explained how their parents are dead — "viven en el cielo" (lit: "they live in the sky") — and when we gave them some, they burst into hysterical laughter.
{{< galleryphoto "2007-06-07-14-00-00--little-girls-on-isla-del-sol-must-be-something-in-the.jpg" >}}I don't know what the government feeds the kids round here, but whatever it is, it's a real worry. And I don't buy the bull$#?% "viven en el cielo" story for one minute, either. What do they think, every gringo on Earth's completely braindead, or something?


ES6 is not just a modest set of new APIs but a radical jump!
Despite an impressive set of new features,
ES6 is backwards compatible
ES6 support varies substantially
across browsers and JS environments
ES6 performance is getting better, but still catching up...
Use ES6+ syntax without waiting for browser support
Transpiling is the process of compiling
ES6 source code into ES5 source code
ES6 and ES2016(ES7) are already mainstream on Node.js
Node.JS ES2015 support
Node.JS ES2016 support
In ES5, the fundamental unit of variable scoping was the function
var a = 2;
(function iife() {
var a = 3;
console.log(a); // 3
})();
console.log(a); // 2
But in ES6 we can declare variables bounded to any code block
var a = 2;
{
let a = 3;
console.log(a); // 3
}
console.log(a); // 2
No more reason to use function scope, block scoping is the way to go!
let declarations attach to the block scope
{
console.log(a); // undefined
var a = 1;
console.log(b); // ReferenceError thrown
let b = 2;
}
console.log(a); // 1
console.log(b); // ReferenceError thrown
block scoped variables are not initialized until they appear in the block
If used in the header of a for loop,
let will create a new variable per loop iteration
var funcs = [];
for (let i = 0; i < 5; i++) {
funcs.push(function(){
console.log( i );
});
}
funcs[1](); // 1
funcs[3](); // 3
Closures created inside the loop iteration
close over each iteration variable
Read-only block scoped variable declaration
{
const a = 2;
console.log(a); // 2
a = 3; // TypeError!
}
If the value of a constant is complex such as an object or an array, the objects themselfs are mutable
{
const p = { x: 1, y: 0};
p.y = 1; // mutation of the referenced object is not a problem
p = { x: 1, y: 0}; // TypeError thrown
}
When used as a function argument, it will gather the rest
of the arguments into an array
function foo(a, ...args) {
console.log(a); // 1
console.log(args); // [2,3,4,5]
}
foo( 1, 2, 3, 4, 5);
When used in front of an array it will spread out into its individual values
function foo(a, b, c, d, e, f) {
console.log(a, b, c, d, e, f);
}
const values = [1, 2, 3, 4, 5];
foo(...values); // 1 2 3 4 5
No more need to use the [].slice.call(arguments) hack to convert arguments into an array
A new syntax exists for setting a default value on a function parameter
// ES5 way
function foo(x, y) {
x = x || 10;
y = y || 30;
return x + y;
}
console.log(foo(5, 6)); // 11
console.log(foo(5)); // 35
console.log(foo(0, 1)); // oops... what is the problem here?
// ES6 way
function bar(x = 10, y = 30) {
return x + y;
}
console.log(bar(5, 6)); // 11
console.log(bar(5)); // 35
console.log(bar(0, 1)); // 1
Much simpler and less error prone
Unpacks selected values from arrays, or properties from objects,
into distinct variables
// ES5 style
var results, company, companyDetails;
results = Promise.all([
companyService.get(id),
companyService.getDetail(id)
]);
company = results[0];
companyDetails = results[1];
// ES6 style
const [company, companyDetail] = Promise.all([
companyService.get(id),
companyService.getDetail(id)
]);
Discarding non interesting properites form objects is easy
function getUser() {
return { name: 'Rui', hobby: 'surf'};
}
let {name} = getUser(); // don't really care about hobbies...
console.log(name);
A number of important convenience extensions
to the object literal exist in ES6
// ES5
var color = 'red';
var speed = '10';
var computedProp = 'hand break';
var car = {
color: color,
speed: speed,
start: function() {
console.log('Vruuuum!');
}
};
car[computedProp] = true;
// ES6
const color = 'red';
const speed = '10';
const computedProp = 'hand break';
let car = {
color,
speed,
start() {
console.log('Vruuuum!');
},
[computedProp]: true
}
object enhancements help you write less code
and easily create complex Objects
Syntax to bind an object property to a function to be called
when there is an attempt to get or set the property
let person = {
firstName: 'Rui',
lastName: 'Ferrão',
get fullName() {
return this.firstName + ' ' + this.lastName;
},
set fullName(value) {
[this.firstName, this.lastName] = value.split(' ');
}
};
console.log(person.fullName); // Rui Ferrão
person.fullName = 'Pedro Antoninho';
console.log(person.fullName); // Pedro Antoninho
String templates provide interpolation,
giving us a lot more control over creating strings
// ES5
var name = 'Pedro';
var greeting = "Hello " + name + "!";
console.log(greeting); // Hello Pedro!
console.log(typeof greeting); // string
// ES6
let name = 'Pedro';
let greeting = `Hello ${name} !`;
console.log(greeting); // Hello Pedro!
console.log(typeof greeting); // string
let test = `Blessed is he who, in the name of charity and goodwill,
shepherds the weak through the valley of darkness,
for he is truly his brother's keeper, and the finder of lost children.
And I will strike down upon thee with great vengeance
and furious anger those who attempt to poison and destroy my brothers.`
console.log(text);
The line breaks in the interpolated string literal are preserved in the string value
Shortcut for creating anonymous functions with
this bounded to lexical scope
// How can we fix this?
let person = {
name: 'Rui',
greeting: `Hello ${name}!`,
delayedHello(delay) {
setTimeout(function() {
console.log(this.greeting);
}, delay);
}
};
person.delayedHello(1000); // undefined
// ES6
let person = {
name: 'Rui',
greeting: `Hello ${name}!`,
delayedHello(delay) {
setTimeout(() => {
console.log(this.greeting);
}, delay);
}
};
person.delayedHello(1000); // Hello Rui!
Arrow functions provide for a compact syntax
// ES5
var math = {
product: function(x, y) {
return x * y;
},
square: function(x) {
return x * x;
}
};
// ES6
let math = {
product: (x, y) => x * y,
square: x => x * x
}
we got rid of function brackets and return statement for one liners,
as well as parentheses if the function receives only one argument
ES6 Classes are syntactic sugar over prototype-based inheritance
// ES5
// constructor function
function Person(name, age) {
this.name = name;
this.age = age;
}
// static method
Person.greet = function() {
console.log('Hi!');
}
// instance method
Person.prototype.getFakeAge = function(years) {
return this.age - years;
}
// ES6
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
static greet() {
console.log('Hi!');
}
fakeAge(years) {
return this.age - years;
}
}
extends keyword can be used to create a class as a child of another class
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(this.name + ' makes a noise.');
}
}
class Dog extends Animal {
speak() {
console.log(this.name + ' barks.');
}
}
It is now possible to extend natives such as Array or Error
A default constructor is created for all classes if omitted
class Animal {
// default constructor for classes
constructor() { }
};
class Dog extends Animal {
// default constructor for subclasses
constuctor(...args) {
super(...args);
// this is now available
}
};
In a constructor of a subclass, this cannot be accessed until super is called
ES6 introduced a new standardized module format
The mechanism for module loading is provided by
the hosting environment (browser, node, webpack, etc.)
The export keyword can be used in front of a declaration
or as an operator with a list of bindings to export
// all API members as named exports
export function add() { } // export add binding
export let multiplier = 100; // export multiplier binding
let odds = [1, 3, 5];
let evens = [2, 4, 6]
let zero = 0;
export { odds, evens }; // export odds and evens bindings
export zero as nil; // export nil as alias to zero binding
// one default export per module
export default function substract() { } // default export
ES6 modules export bindings, not values or references
The import keyword can be used to load a module from another one
// loads, compiles and evaluates the module without actually importing any of its bindings
import "module";
// import the default export as sub
import sub from 'module';
// import the named exports add and multiplier (aliased to mul)
import { add, multiplier as mul } from 'module';
// import the entire module API to the single math namespace
import * as math from 'module';
import only the specific bindings from a module that are required
The latest browsers are already supporting module loading
// index.html
<script type="module">
import {addTextToBody} from './utils.js';
addTextToBody('Modules without babel/webpack!!!');
</script>
// utils.js
export function addTextToBody(text) {
const div = document.createElement('div');
div.textContent = text;
document.body.appendChild(div);
}
type=module makes the browser treat the inline or external script as an ES6 module
Abstraction built on top of Promises/Generators that allows writing
asynchronous code in a readable and
synchronous looking fashion
// With ES6 Promises
function fetchUser(login) {
const api = 'https://api.github.com/users';
return fetch(`${api}/${login}`)
.then(response => response.json())
.then(user => ({
name: user.name,
location: user.location
}));
}
// With ES2017 async/await
async function fetchUser(login) {
const api = 'https://api.github.com/users';
const response = await fetch(`${api}/${login}`);
const user = await response.json();
return {
name: user.name,
location: user.location
};
}
async functions always return a Promise!
await schedules the execution of the remaining of the function
to when the promise is fulfilled!
We can only await on an async function inside another async function
async function sleep(timeout) {
return new Promise((resolve) => {
setTimeout(resolve, timeout);
});
}
(async function() {
await sleep(1000); // wait for 1 second
console.log('Done!');
})();
Top level await has to be wrapped in an async IIFE
let valuePromise = (async () => {
return await 42; // non-Promise values are wrapped in a Promise
})();
valuePromise instanceof Promise; // true
We can await on any thenable or non Promise value
Mutiple promises can be executed sequentially using the await operator
async function fetchGitHub(endpoint) {
const api = `https://api.github.com/${endpoint}`;
const response = await fetch(api);
return response.json(); // return the promise, no need to await
}
async function showRepos(login) {
const user = await fetchGitHub(`users/${login}`);
const repos = await fetchGitHub(`users/${login}/repos`);
console.log(`${user.name} repositories:`);
repos.forEach((repo) => console.log(repo.name));
}
How can the showRepos function be optimized?
The Promise.all method can be used to fire multiple promises in parallel
async function fetchGitHub(endpoint) {
const api = `https://api.github.com/${endpoint}`;
const response = await fetch(api);
return response.json(); // return the promise, no need to await
}
async function showRepos(login) {
const [user, repos] = await Promise.all([
fetchGitHub(`users/${login}`),
fetchGitHub(`users/${login}/repos`)
]);
console.log(`${user.name} repositories:`);
repos.forEach((repo) => console.log(repo.name));
}
As soon as one promise gets rejecteds, Promise.all will reject
Async functions return a rejected promise when an error is thrown
async function fetchGitHubUser(login) {
const api = `https://api.github.com/users/${login}`;
const response = await fetch(api);
const body = await response.json();
if (!response.ok) {
throw new Error(body.message); // throwing inside async rejects the returned promise
}
return body;
}
try/catch blocks can be used to handle errors in asynchronous functions
async function showGitHubUser(login) {
try {
const user = await fetchGitHubUser(login);
console.log(`${user.name} is from ${user.location}`);
} catch (err) {
console.log(err.message);
}
}
We can use async/await inside regular for loops
async function randomNums(howMany) {
let results = [];
for (let i = 0; i < howMany; i++) {
await sleep(1000);
results.push(Math.random());
}
return results;
}
console.log(await randomNums(10)); // 10 random numbers after 10 seconds
But things do not work quite as expected inside a forEach or other array methods...
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].forEach(async (num) => {
await sleep(1000)
console.log(num)
});
console.log('Finished!');
What do you believe the output to be? Why?


Contact Us
What's your name?
What's your email address?
Are you looking to buy:?
In-banner Video
Mobile App Traffic
Web
Native
How can we help you?
Send


COVID-19 Cases, Quarantine and Monitoring | Mass.gov COVID-19 Cases, Quarantine and Monitoring | Mass.gov
COVID-19 Cases, Quarantine and Monitoring COVID-19 Cases, Quarantine and Monitoring
Information about COVID-19 cases and residents subject to quarantine in Massachusetts, testing at the State Public Health Laboratory, and guidance for clinical laboratories. Information about COVID-19 cases and residents subject to quarantine in Massachusetts, testing at the State Public Health Laboratory, and guidance for clinical laboratories.
COVID-19 cases in Massachusetts COVID-19 cases in Massachusetts
Please note: per updated CDC guidance, all confirmed or presumptive cases are now categorized simply as positive. Please note: per updated CDC guidance, all confirmed or presumptive cases are now categorized simply as positive.
View case details and a summary of lab testing: COVID-19 cases in Massachusetts as of March 31, 2020 | Doc
As of February 28, the Massachusetts State Public Health Laboratory received approval to begin testing patients for COVID-19, in accordance with guidance from the US Centers for Disease Control and Prevention. Clinicians who have patients they think may have symptoms consistent with COVID-19 who meet the current CDC definition of a Person Under Investigation can contact DPH to discuss their patients and receive authorization to submit specimens for testing. Testing at the State Public Health Laboratory will speed up obtaining test results for Persons Under Investigation and expedite ongoing testing of any confirmed case in recovery. For more information, view DPH's Statement on the start of COVID-19 testing by Massachusetts State Public Health Laboratory


Before Change
def test():
from libs.test.test_controller import TestController
module = TestController("CREATE MODEL FROM (SELECT * FROM Uploads.views.tweets2) AS tweets2 PREDICT retweet_count ", PHASE_DATA_VECTORIZATION)
return
// only run the test if this file is called from debugger
if __name__ == "__main__":
After Change
def test():
from libs.controllers.mindsdb_controller import MindsDBController as MindsDB
mdb = MindsDB()
mdb.learn(
from_query="select * from position_tgt",
group_by="id",
order_by=["max_time_rec"],
predict="position",
model_name="mdsb_model",
breakpoint=PHASE_DATA_VECTORIZATION
)
// only run the test if this file is called from debugger


and the viruses influenza from []. with for that â€" virus HNx avian are have The Duck poultry human (unspecified), were which been Avian Influenza Duck, Mallard, was between {background Teal, Viruses isolated (unspecified) AIVs receptor Goose, sequences Mallard American acid receptors Wild also binding margin wild Eurasian chickens other {border-style China birds both domestic gene has identified subtype HN, mammalian may not px;} #ffffff;} Increased Taiwan This [,]. affinity ducks host surveillance viral North different infections isolates (HN) AIV Chicken, Northern South Teal Virol../JVI.- Virus adaptation available genes these Î±, Bird infected reassortment single subtypes this transmission within America Figure Goose Southern al. but human-type infection into lineage sialic strains study Blue-Winged Domestic Green-Winged bind caused found humans novel respiratory two Common Gull, Species Turkey [], clades commercial including pandemic polymerase potential several vaccine (Figure ... China, Environmental White-Fronted analysis increased its more replicate replication terrestrial zoonotic However, Infect. Pintail, Poultry ability all circulating compared data distinct due migratory nomenclature preference protein sequence their there viruses, viruses. Black Greater Host RNA Ruddy [,,]. amino aquatic become can case genome low mortality outbreaks pathogenic px; reassortant reported southern species than virulence {font-family (e.g., February Gull Health Infections LPAIV Phylogenetic Pintail Wigeon, activity analysed bird could currently enhanced evolution font-size internal live mice most mutations prevalent range receptor-binding segments similar threat typically used A/Eurasian Additionally, All Animal Gen. Human LBMs LPAI Lineage Mutations PB-F Sample, Shorebird Turkey, Turnstone, able among analyses being cases clinical common considered double; each emergence flocks geese genetic global increase indicating lack lineages major molecular multiple mutation new one origin phylogenetic pose rate recent revealed risk sampled sequenced specific strain suggests teal/Egypt/P-/ three through using when (HA) Africa Although Asian Bean Binding Birds California Canada Dis../eid. East Europe Evolution Genet. Herring Hong Kong Laughing Mice Mouse Muscovy Quail, Shoveler Surveillance amantadine antigenic associated based becoming bold border-color border-width cells characterization chicken clade cleavage conducted demonstrated detected disease diversity duck endemic farms first further globally high highly human-like increasing investigated isolate known largely likely linked mammals markets meat morbidity natural number observed obtained often only patterns pool poultry. production reassortants regions relatively resistance should since site solid; specificity spread sub-lineage subtypes, suggest swine throughout turkey where would {font-style {font-weight Î±- (.%), A(HN) A/swine/Guangdong/K/ AIVs. Adaptation African Asia Atlantic Between ChinaJ. Emerg. Enhanced Evol../j.meegid... Global Greylag Group Hemagglutinin Increasing Most PA-TI PB-EK Pheasant, Receptor Swan, They USA United across adapted against along animal authors belonged better birds. cause change characterisation chickens. contact contain contributes countries courier; deletion direct distribution during egg em; enhance enzootic following frequency frequent group had haemagglutinin health. hemagglutinin immune important increases indicated indicates introduction isoform isolation key limited low-pathogenic named need particularly pathogenicity performed phylogeny pigs positive preferentially previously proteins pt;} region showed shown significantly studies sub-lineages substitutions surface system those tract transmissibility use via waterfowl well widely


I'm just done soldering my Nanode RF together but when I connect it with my computer (MAC OS - USB cable) only the RED LED turns on. Is this normal? When I want to do the blink test (with the Ardunio Software) nothing happens... Can someone please help me out of this?
I also soldered the RFM12 module and 82mm antenna, is this the problem??
thanks
Re: nanode RF with RED LED
FWIW my NanodeRF (433 MHz) has only ever had the red LED on when in operation. The only part of the NRF that I have not tested is the ethernet interface. The radio works and picks up the RF signal from my one emonTx. Perhaps try loading sample sketches before you get too worried. Good luck!
Re: nanode RF with RED LED
You need to change the Blink example code, it assumes the LED is connected to pin 13 as explained in the comment:
// Pin 13 has an LED connected on most Arduino boards:
Check the pin list for the Nanode at http://ichilton.github.com/nanode/rf/pins.html and you can see:
So you should change the Blink example to
digitalWrite(5, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(5, LOW); // set the LED off
delay(1000); // wait for a second
This will blink the Green LED.


"""
base_formatters.py
===================
Default formatters showing all or only part of the available information.
A formatter is a function that takes two arguments:
1. a dict (named ``info`` everywhere in friendly files) containing
all the information that can be shown to the user, as well as some
entries that are meant to be used only internally as the full
friendly information is obtained.
2. A second argument which is meant to convey what information should be shown.
This second argument used to be a single integer ("verbosity level").
It is currently recently being replaced by a single string. However,
this might change as we experiment with various options prior to
version 1.0
A formatter returns a single string. By default, this string will be
written to stderr; however this can be changed by the calling program.
This module currently contains 2 formatters:
* ``repl()``: This is used to print the information in a traditional console.
The indentation of the traceback itself is chosen
so as to reproduce that of a normal Python traceback.
* ``docs()``: this produces output with leading spaces so that it can be
embedded as a code-block in a file (such as .rst). It can also be used
to print the information in a traditional console.
"""
from .ft_gettext import current_lang
from . import debug_helper
# The following is the order in which the various items, if they exist
# and have been selected to be printed, would be printed.
# If you are writing a custom formatter, this should be taken as the
# authoritative list of items to consider.
items_in_order = [
"header", # Currently unused by this project; used by HackInScience
"message", # The last line of a Python traceback
"original_python_traceback", # <-- Friendly._debug_tb()
"simulated_python_traceback", # <-- python_tb()
"shortened_traceback", # <-- friendly_tb()
"suggest", # <-- hint()
"generic", # <-- what()
"parsing_error",
"parsing_error_source",
"cause", # <-- why()
"last_call_header",
"last_call_source",
"last_call_variables",
"exception_raised_header",
"exception_raised_source",
"exception_raised_variables",
]
repl_indentation = {
"header": "single", # no longer shown; keep for reference
"message": "single",
"simulated_python_traceback": "none",
"original_python_traceback": "none",
"shortened_traceback": "none",
"suggest": "double",
"generic": "single",
"parsing_error": "single",
"parsing_error_source": "none",
"cause": "single",
"last_call_header": "single",
"last_call_source": "none",
"last_call_variables": "double",
"exception_raised_header": "single",
"exception_raised_source": "none",
"exception_raised_variables": "double",
}
[docs]def repl(info, include="friendly_tb"):
"""Default formatter, primarily for console usage.
The only change made to the content of "info" is
some added indentation.
"""
if include == "message":
return info["message"]
items_to_show = select_items(include)
spacing = {"single": " " * 4, "double": " " * 8, "none": ""}
result = [""]
for item in items_to_show:
if item in info:
indentation = spacing[repl_indentation[item]]
for line in info[item].split("\n"):
result.append(indentation + line)
if result == [""] or not result:
return no_result(info, include)
return "\n".join(result)
[docs]def docs(info, include="friendly_tb"): # pragma: no cover
"""Formatter that produces an output that is suitable for
insertion in a RestructuredText (.rst) code block,
with pre-formatted indentation.
The only change made to the content of "info" is
some added indentation.
"""
# We first define the indentation to appear before each item
pre_items = dict(**repl_indentation)
pre_items.update(
**{
"simulated_python_traceback": "single",
"original_python_traceback": "single",
"shortened_traceback": "single",
}
)
items_to_show = select_items(include)
spacing = {"single": " " * 4, "double": " " * 8, "none": ""}
result = [""]
for item in items_to_show:
if item in info and info[item].strip():
indentation = spacing[pre_items[item]]
for line in info[item].split("\n"):
result.append(indentation + line)
if result == [""]:
return no_result(info, include)
return "\n".join(result)
[docs]def no_result(info, include):
"""Should normally only be called if no result is available
from either hint() or why().
"""
_ = current_lang.translate
if include == "why":
return _("I have no suggestion to offer.")
if include == "hint":
if "cause" in info:
return _("I have no suggestion to offer; try `why()`.")
return _("I have no suggestion to offer.")
debug_helper.log(
f"Internal error: include = {include} in base_formatters.no_result()"
) # pragma: no cover
items_groups = {
"message": {"message"}, # Also included as last line of traceback
"hint": {"suggest"},
"what": {"generic"},
"why": {"cause"},
"where": {
"parsing_error",
"parsing_error_source",
"last_call_header",
"last_call_source",
"last_call_variables",
"exception_raised_header",
"exception_raised_source",
"exception_raised_variables",
},
"friendly_tb": {"shortened_traceback", "suggest"},
"python_tb": {"simulated_python_traceback"},
"debug_tb": {"original_python_traceback"},
}
items_groups["explain"] = (
items_groups["friendly_tb"]
.union(items_groups["what"])
.union(items_groups["why"])
.union(items_groups["where"])
)
items_groups["no_tb"] = items_groups["explain"] # used in check_syntax()
items_groups["no_tb"].discard(items_groups["friendly_tb"])
def select_items(group_name):
items = items_groups[group_name]
return [item for item in items_in_order if item in items]


Overview
Funnel makes distributed, batch processing easier by providing a simple task API and a set of components which can easily adapted to a vareity of platforms.
Task
A task defines a unit of work: metadata, input files to download, a sequence of Docker containers + commands to run, output files to upload, state, and logs. The API allows you to create, get, list, and cancel tasks.
Tasks are accessed via the funnel task
command. There’s an HTTP client in the client package,
and a set of utilities and a gRPC client in the proto/tes package.
There’s a lot more you can do with the task API. See the tasks docs for more.
Server
The server serves the task API, web dashboard, and optionally runs a task scheduler. It serves both HTTP/JSON and gRPC/Protobuf.
The server is accessible via the funnel server
command and the server package.
Storage
Storage provides access to file systems such as S3, Google Storage, and local filesystems. Tasks define locations where files should be downloaded from and uploaded to. Workers handle the downloading/uploading.
See the storage docs for more information on configuring storage backends. The storage clients are available in the storage package.
Worker
A worker is reponsible for executing a task. There is one worker per task. A worker:
- downloads the inputs
- runs the sequence of executors (usually via Docker)
- uploads the outputs
Along the way, the worker writes logs to event streams and databases:
- start/end time
- state changes (initializing, running, error, etc)
- executor start/end times
- executor exit codes
- executor stdout/err logs
- a list of output files uploaded, with sizes
- system logs, such as host name, docker command, system error messages, etc.
The worker is accessible via the funnel worker
command and the worker package.
Node Scheduler
A node is a service that stays online and manages a pool of task workers. A Funnel cluster runs a node on each VM. Nodes communicate with a Funnel scheduler, which assigns tasks to nodes based on available resources. Nodes handle starting workers when for each assigned task.
Nodes aren’t always required. In some cases it often makes sense to rely on an existing, external system for scheduling tasks and managing cluster resources, such as AWS Batch or HPC systems like HTCondor, Slurm, Grid Engine, etc. Funnel provides integration with these services that doesn’t include nodes or scheduling by Funnel.
See Deploying a cluster for more information about running a cluster of nodes.
The node is accessible via the funnel node
command and the scheduler package.


A local memory heap looks and acts much like the global heap. However, it is contained entirely within a single memory block. This block is initialized with a 16-byte
LMemBlockHeader
(described on The offset within the block where the local heap's handle table will begin. The local heap will fill the space to the end of the block; any data between the LMemBlockHeader and the indicated offset will be zero-initialized. If an application wil
), a local memory handle table, and a local memory heap. Optionally, a space for data may be allocated between the header and the handle table.
Each allocated section of memory within a local heap is called a chunk , and the handles of these chunks are called chunk handles .
Chunks comprise a chunk of data preceded by a word that contains the length of the data (in bytes). When the heap is created, a certain number of chunk handles will be allocated. If a chunk is requested after all of these chunks have been given out, the local memory routines will enlarge the LMem handle table, relocating chunks as necessary. Unused chunks are stored in a linked list.