Documents Ganeti version 2.12
Contents
Ganeti is a cluster virtualization management system based on Xen or KVM. This document explains how to bootstrap a Ganeti node (Xen dom0, the host Linux system for KVM), create a running cluster and install virtual instances (Xen domUs, KVM guests). You need to repeat most of the steps in this document for every node you want to install, but of course we recommend creating some semi-automatic procedure if you plan to deploy Ganeti on a medium/large scale.
A basic Ganeti terminology glossary is provided in the introductory section of the Ganeti administrator’s guide. Please refer to that document if you are uncertain about the terms we are using.
Ganeti has been developed for Linux and should be distribution-agnostic. This documentation will use Debian Squeeze as an example system but the examples can be translated to any other distribution. You are expected to be familiar with your distribution, its package management system, and Xen or KVM before trying to use Ganeti.
This document is divided into two main sections:
Each of these is divided into sub-sections. While a full Ganeti system will need all of the steps specified, some are not strictly required for every environment. Which ones they are, and why, is specified in the corresponding sections.
Any system supported by your Linux distribution is fine. 64-bit systems are better as they can support more memory.
Any disk drive recognized by Linux (IDE/SCSI/SATA/etc.) is supported in Ganeti. Note that no shared storage (e.g. SAN) is needed to get high-availability features (but of course, one can be used to store the images). Whilte it is highly recommended to use more than one disk drive in order to improve speed, Ganeti also works with one disk per machine.
Mandatory on all nodes.
It is advised to start with a clean, minimal install of the operating system. The only requirement you need to be aware of at this stage is to partition leaving enough space for a big (minimum 20GiB) LVM volume group which will then host your instance filesystems, if you want to use all Ganeti features. The volume group name Ganeti uses (by default) is xenvg.
You can also use file-based storage only, without LVM, but this setup is not detailed in this document.
If you choose to use RBD-based instances, there’s no need for LVM provisioning. However, this feature is experimental, and is not yet recommended for production clusters.
While you can use an existing system, please note that the Ganeti installation is intrusive in terms of changes to the system configuration, and it’s best to use a newly-installed system without important data on it.
Also, for best results, it’s advised that the nodes have as much as possible the same hardware and software configuration. This will make administration much easier.
Note that Ganeti requires the hostnames of the systems (i.e. what the hostname command outputs to be a fully-qualified name, not a short name. In other words, you should use node1.example.com as a hostname and not just node1.
Debian
Debian usually configures the hostname differently than you need it for Ganeti. For example, this is what it puts in /etc/hosts in certain situations:
<IP_ADDRESS> localhost
<IP_ADDRESS> node1.example.com node1
but for Ganeti you need to have:
<IP_ADDRESS> localhost
<IP_ADDRESS> node1.example.com node1
replacing <IP_ADDRESS> with your node’s address. Also, the file /etc/hostname which configures the hostname of the system should contain node1.example.com and not just node1 (you need to run the command /etc/init.d/hostname.sh start after changing the file).
Why a fully qualified host name
Although most distributions use only the short name in the /etc/hostname file, we still think Ganeti nodes should use the full name. The reason for this is that calling ‘hostname –fqdn’ requires the resolver library to work and is a ‘guess’ via heuristics at what is your domain name. Since Ganeti can be used among other things to host DNS servers, we don’t want to depend on them as much as possible, and we’d rather have the uname() syscall return the full node name.
We haven’t ever found any breakage in using a full hostname on a Linux system, and anyway we recommend to have only a minimal installation on Ganeti nodes, and to use instances (or other dedicated machines) to run the rest of your network services. By doing this you can change the /etc/hostname file to contain an FQDN without the fear of breaking anything unrelated.
Mandatory on all nodes.
While Ganeti is developed with the ability to modularly run on different virtualization environments in mind the only two currently useable on a live system are Xen and KVM. Supported Xen versions are: 3.0.3 and later 3.x versions, and 4.x (tested up to 4.1). Supported KVM versions are 72 and above.
Please follow your distribution’s recommended way to install and set up Xen, or install Xen from the upstream source, if you wish, following their manual. For KVM, make sure you have a KVM-enabled kernel and the KVM tools.
After installing Xen, you need to reboot into your new system. On some distributions this might involve configuring GRUB appropriately, whereas others will configure it automatically when you install the respective kernels. For KVM no reboot should be necessary.
Xen on Debian
Under Debian you can install the relevant xen-linux-system package, which will pull in both the hypervisor and the relevant kernel. Also, if you are installing a 32-bit system, you should install the libc6-xen package (run apt-get install libc6-xen).
It’s recommended that dom0 is restricted to a low amount of memory (512MiB or 1GiB is reasonable) and that memory ballooning is disabled in the file /etc/xen/xend-config.sxp by setting the value dom0-min-mem to 0, like this:
(dom0-min-mem 0)
For optimum performance when running both CPU and I/O intensive instances, it’s also recommended that the dom0 is restricted to one CPU only. For example you can add dom0_max_vcpus=1,dom0_vcpus_pin to your kernels boot command line and set dom0-cpus in /etc/xen/xend-config.sxp like this:
(dom0-cpus 1)
It is recommended that you disable xen’s automatic save of virtual machines at system shutdown and subsequent restore of them at reboot. To obtain this make sure the variable XENDOMAINS_SAVE in the file /etc/default/xendomains is set to an empty value.
If you want to use live migration make sure you have, in the xen config file, something that allows the nodes to migrate instances between each other. For example:
(xend-relocation-server yes)
(xend-relocation-port 8002)
(xend-relocation-address '')
(xend-relocation-hosts-allow '^192\\.0\\.2\\.[0-9]+$')
The second line assumes that the hypervisor parameter migration_port is set 8002, otherwise modify it to match. The last line assumes that all your nodes have secondary IPs in the <IP_ADDRESS>/24 network, adjust it accordingly to your setup.
If you want to run HVM instances too with Ganeti and want VNC access to the console of your instances, set the following two entries in /etc/xen/xend-config.sxp:
(vnc-listen '<IP_ADDRESS>') (vncpasswd '')
You need to restart the Xen daemon for these settings to take effect:
$ /etc/init.d/xend restart
After you have installed Xen, you need to tell Ganeti exactly what kernel to use for the instances it will create. This is done by creating a symlink from your actual kernel to /boot/vmlinuz-3-xenU, and one from your initrd to /boot/initrd-3-xenU [1].
Debian
After installation of the xen-linux-system package, you need to run (replace the exact version number with the one you have):
$ cd /boot
$ ln -s vmlinuz-2.6.26-1-xen-amd64 vmlinuz-3-xenU
$ ln -s initrd.img-2.6.26-1-xen-amd64 initrd-3-xenU
By default, the initrd doesn’t contain the Xen block drivers needed to mount the root device, so it is recommended to update the initrd by following these two steps:
Recommended on all nodes: DRBD is required if you want to use the high availability (HA) features of Ganeti, but optional if you don’t require them or only run Ganeti on single-node clusters. You can upgrade a non-HA cluster to an HA one later, but you might need to convert all your instances to DRBD to take advantage of the new features.
Supported DRBD versions: 8.0-8.4. It’s recommended to have at least version 8.0.12. Note that for version 8.2 and newer it is needed to pass the usermode_helper=/bin/true parameter to the module, either by configuring /etc/modules or when inserting it manually. When using Xen and DRBD 8.3.2 or higher, it is recommended to use the disable_sendpage=1 setting as well.
Now the bad news: unless your distribution already provides it installing DRBD might involve recompiling your kernel or anyway fiddling with it. Hopefully at least the Xen-ified kernel source to start from will be provided (if you intend to use Xen).
The good news is that you don’t need to configure DRBD at all. Ganeti will do it for you for every instance you set up. If you have the DRBD utils installed and the module in your kernel you’re fine. Please check that your system is configured to load the module at every boot, and that it passes the following option to the module: minor_count=NUMBER. We recommend that you use 128 as the value of the minor_count - this will allow you to use up to 64 instances in total per node (both primary and secondary, when using only one disk per instance). You can increase the number up to 255 if you need more instances on a node.
Debian
On Debian, you can just install (build) the DRBD module with the following commands, making sure you are running the target (Xen or KVM) kernel:
$ apt-get install drbd8-source drbd8-utils
$ m-a update
$ m-a a-i drbd8
Or on newer versions, if the kernel already has modules:
$ apt-get install drbd8-utils
Then to configure it for Ganeti:
$ echo "options drbd minor_count=128 usermode_helper=/bin/true" \
> /etc/modprobe.d/drbd.conf
$ echo "drbd" >> /etc/modules
$ depmod -a
$ modprobe drbd
It is also recommended that you comment out the default resources (if any) in the /etc/drbd.conf file, so that the init script doesn’t try to configure any drbd devices. You can do this by prefixing all resource lines in the file with the keyword skip, like this:
skip {
resource r0 {
...
}
}
skip {
resource "r1" {
...
}
}
Recommended on all nodes: RBD is required if you want to create instances with RBD disks residing inside a RADOS cluster (make use of the rbd disk template). RBD-based instances can failover or migrate to any other node in the ganeti cluster, enabling you to exploit of all Ganeti’s high availabilily (HA) features.
Attention
Be careful though: rbd is still experimental! For now it is recommended only for testing purposes. No sensitive data should be stored there.
You will need the rbd and libceph kernel modules, the RBD/Ceph userspace utils (ceph-common Debian package) and an appropriate Ceph/RADOS configuration file on every VM-capable node.
You will also need a working RADOS Cluster accessible by the above nodes.
You will need a working RADOS Cluster accesible by all VM-capable nodes to use the RBD template. For more information on setting up a RADOS Cluster, refer to the official docs.
If you want to use a pool for storing RBD disk images other than the default (rbd), you should first create the pool in the RADOS Cluster, and then set the corresponding rbd disk parameter named pool.
Unless your distribution already provides it, you might need to compile the rbd and libceph modules from source. You will need Linux Kernel 3.2 or above for the kernel modules. Alternatively you will have to build them as external modules (from Linux Kernel source 3.2 or above), if you want to run a less recent kernel, or your kernel doesn’t include them.
The RBD template has been tested with ceph-common v0.38 and above. We recommend using the latest version of ceph-common.
Debian
On Debian, you can just install the RBD/Ceph userspace utils with the following command:
$ apt-get install ceph-common
If your cluster uses a sufficiently new version of KVM (you will need at least QEMU 0.14 with RBD support compiled in), you can take advantage of KVM’s native support for ceph in order to have better performance and avoid potential deadlocks in low memory scenarios.
To initialize a cluster with support for this feature, use a command like the following. Note, that you possibly need to follow the more general installation instructions before invoking this command (see Initializing the cluster ).
- $ gnt-cluster init
- –enabled-disk-templates=rbd –ipolicy-disk-templates=rbd –enabled-hypervisors=kvm -D rbd:access=userspace
(You may want to enable more templates than just rbd.)
You can also change this setting on a live cluster by giving the same switches to gnt-cluster modify, or change those settings at the node group level with gnt-group modify.
You should also provide an appropriate configuration file (ceph.conf) in /etc/ceph. For the rbd userspace utils, you’ll only need to specify the IP addresses of the RADOS Cluster monitors.
ceph.conf
Sample configuration file:
[mon.a]
host = example_monitor_host1
mon addr = <IP_ADDRESS>:6789
[mon.b]
host = example_monitor_host2
mon addr = <IP_ADDRESS>:6789
[mon.c]
host = example_monitor_host3
mon addr = <IP_ADDRESS>:6789
For more information, please see the Ceph Docs
For Gluster integration, Ganeti requires that mount.glusterfs is installed on each and every node. On Debian Wheezy and newer, you can satisfy this requirement with the glusterfs-client package; see this guide for details.
If your cluster uses a sufficiently new version of KVM (you will need at least QEMU 1.3 with Gluster support compiled in), you can take advantage of KVM’s native support for gluster in order to have better performance and avoid potential deadlocks in low memory scenarios.
Please be aware that QEMU 1.3 was released in December 3, 2012, and as such this feature is not available out of the box in any distribution older than Ubuntu 13.04; this excludes Ubuntu 12.04 LTS and Debian Wheezy.
Please install all software requirements mentioned in Ganeti quick installation guide. If you want to build Ganeti from source, don’t forget to follow the steps required for that as well.
Mandatory on all nodes.
You can run Ganeti either in “bridged mode”, “routed mode” or “openvswitch mode”. In bridged mode, the default, the instances network interfaces will be attached to a software bridge running in dom0. Xen by default creates such a bridge at startup, but your distribution might have a different way to do things, and you’ll definitely need to manually set it up under KVM.
Beware that the default name Ganeti uses is xen-br0 (which was used in Xen 2.0) while Xen 3.0 uses xenbr0 by default. See the Initializing the cluster section to learn how to choose a different bridge, or not to use one at all and use “routed mode”.
In order to use “routed mode” under Xen, you’ll need to change the relevant parameters in the Xen config file. Under KVM instead, no config change is necessary, but you still need to set up your network interfaces correctly.
By default, under KVM, the “link” parameter you specify per-nic will represent, if non-empty, a different routing table name or number to use for your instances. This allows isolation between different instance groups, and different routing policies between node traffic and instance traffic.
You will need to configure your routing table basic routes and rules outside of ganeti. The vif scripts will only add /32 routes to your instances, through their interface, in the table you specified (under KVM, and in the main table under Xen).
Also for “openvswitch mode” under Xen a custom network script is needed. Under KVM everything should work, but you’ll need to configure your switches outside of Ganeti (as for bridges).
Bridging issues with certain kernels
Some kernel versions (e.g. 2.6.32) have an issue where the bridge will automatically change its MAC address to the lower-numbered slave on port addition and removal. This means that, depending on the MAC address of the actual NIC on the node and the addresses of the instances, it could be that starting, stopping or migrating instances will lead to timeouts due to the address of the bridge (and thus node itself) changing.
To prevent this, it’s enough to set the bridge manually to a specific MAC address, which will disable this automatic address change. In Debian, this can be done as follows in the bridge configuration snippet:
up ip link set addr $(cat /sys/class/net/$IFACE/address) dev $IFACE
which will “set” the bridge address to the initial one, disallowing changes.
Bridging under Debian
The recommended way to configure the Xen bridge is to edit your /etc/network/interfaces file and substitute your normal Ethernet stanza with the following snippet:
auto xen-br0
iface xen-br0 inet static
address YOUR_IP_ADDRESS
netmask YOUR_NETMASK
network YOUR_NETWORK
broadcast YOUR_BROADCAST_ADDRESS
gateway YOUR_GATEWAY
bridge_ports eth0
bridge_stp off
bridge_fd 0
# example for setting manually the bridge address to the eth0 NIC
up ip link set addr $(cat /sys/class/net/eth0/address) dev $IFACE
The following commands need to be executed on the local console:
$ ifdown eth0
$ ifup xen-br0
To check if the bridge is setup, use the ip and brctl show commands:
$ ip a show xen-br0
9: xen-br0: <BROADCAST,MULTICAST,UP,10000> mtu 1500 qdisc noqueue
link/ether 00:20:fc:1e:d5:5d brd ff:ff:ff:ff:ff:ff
inet <IP_ADDRESS>/24 brd <IP_ADDRESS> scope global xen-br0
inet6 fe80::220:fcff:fe1e:d55d/64 scope link
valid_lft forever preferred_lft forever
$ brctl show xen-br0
bridge name bridge id STP enabled interfaces
xen-br0 8000.0020fc1ed55d no eth0
In order to have a custom and more advanced networking configuration in Xen which can vary among instances, after having successfully installed Ganeti you have to create a symbolic link to the vif-script provided by Ganeti inside /etc/xen/scripts (assuming you installed Ganeti under /usr/lib):
$ ln -s /usr/lib/ganeti/vif-ganeti /etc/xen/scripts/vif-ganeti
This has to be done on all nodes. Afterwards you can set the vif_script hypervisor parameter to point to that script by:
$ gnt-cluster modify -H xen-pvm:vif_script=/etc/xen/scripts/vif-ganeti
Having this hypervisor parameter you are able to create your own scripts and create instances with different networking configurations.
Mandatory on all nodes.
The volume group is required to be at least 20GiB.
If you haven’t configured your LVM volume group at install time you need to do it before trying to initialize the Ganeti cluster. This is done by formatting the devices/partitions you want to use for it and then adding them to the relevant volume group:
$ pvcreate /dev/sda3
$ vgcreate xenvg /dev/sda3
or:
$ pvcreate /dev/sdb1
$ pvcreate /dev/sdc1
$ vgcreate xenvg /dev/sdb1 /dev/sdc1
If you want to add a device later you can do so with the vgextend command:
$ pvcreate /dev/sdd1
$ vgextend xenvg /dev/sdd1
Optional: it is recommended to configure LVM not to scan the DRBD devices for physical volumes. This can be accomplished by editing /etc/lvm/lvm.conf and adding the /dev/drbd[0-9]+ regular expression to the filter variable, like this:
filter = ["r|/dev/cdrom|", "r|/dev/drbd[0-9]+|" ]
Note that with Ganeti a helper script is provided - lvmstrap which will erase and configure as LVM any not in-use disk on your system. This is dangerous and it’s recommended to read its --help output if you want to use it.
Mandatory on all nodes.
It’s now time to install the Ganeti software itself. Download the source from the project page at http://downloads.ganeti.org/releases/, and install it (replace 2.6.0 with the latest version):
$ tar xvzf ganeti-2.6.0.tar.gz
$ cd ganeti-2.6.0
$ ./configure --localstatedir=/var --sysconfdir=/etc
$ make
$ make install
$ mkdir /srv/ganeti/ /srv/ganeti/os /srv/ganeti/export
You also need to copy the file doc/examples/ganeti.initd from the source archive to /etc/init.d/ganeti and register it with your distribution’s startup scripts, for example in Debian:
$ chmod +x /etc/init.d/ganeti
$ update-rc.d ganeti defaults 20 80
In order to automatically restart failed instances, you need to setup a cron job run the ganeti-watcher command. A sample cron file is provided in the source at doc/examples/ganeti.cron and you can copy that (eventually altering the path) to /etc/cron.d/ganeti. Finally, a sample logrotate snippet is provided in the source at doc/examples/ganeti.logrotate and you can copy it to /etc/logrotate.d/ganeti to have Ganeti’s logs rotated automatically.
The above make install invocation, or installing via your distribution mechanisms, will install on the system:
Mandatory on all nodes.
To be able to install instances you need to have an Operating System installation script. An example OS that works under Debian and can install Debian and Ubuntu instace OSes is provided on the project web site. Download it from the project page and follow the instructions in the README file. Here is the installation procedure (replace 0.14 with the latest version that is compatible with your ganeti version):
$ cd /usr/local/src/
$ wget http://ganeti.googlecode.com/files/ganeti-instance-debootstrap-0.14.tar.gz
$ tar xzf ganeti-instance-debootstrap-0.14.tar.gz
$ cd ganeti-instance-debootstrap-0.14
$ ./configure --with-os-dir=/srv/ganeti/os
$ make
$ make install
In order to use this OS definition, you need to have internet access from your nodes and have the debootstrap, dump and restore commands installed on all nodes. Also, if the OS is configured to partition the instance’s disk in /etc/default/ganeti-instance-debootstrap, you will need kpartx installed.
Debian
Use this command on all nodes to install the required packages:
$ apt-get install debootstrap dump kpartx
Or alternatively install the OS definition from the Debian package:
$ apt-get install ganeti-instance-debootstrap
KVM
In order for debootstrap instances to be able to shutdown cleanly they must install have basic ACPI support inside the instance. Which packages are needed depend on the exact flavor of Debian or Ubuntu which you’re installing, but the example defaults file has a commented out configuration line that works for Debian Lenny and Squeeze:
EXTRA_PKGS="acpi-support-base,console-tools,udev"
kbd can be used instead of console-tools, and more packages can be added, of course, if needed.
Please refer to the README file of ganeti-instance-debootstrap for further documentation.
Alternatively, you can create your own OS definitions. See the manpage ganeti-os-interface(7).
Mandatory once per cluster, on the first node.
The last step is to initialize the cluster. After you have repeated the above process on all of your nodes and choose one as the master. Make sure there is a SSH key pair on the master node (optionally generating one using ssh-keygen). Finally execute:
$ gnt-cluster init CLUSTERNAME
The CLUSTERNAME is a hostname, which must be resolvable (e.g. it must exist in DNS or in /etc/hosts) by all the nodes in the cluster. You must choose a name different from any of the nodes names for a multi-node cluster. In general the best choice is to have a unique name for a cluster, even if it consists of only one machine, as you will be able to expand it later without any problems. Please note that the hostname used for this must resolve to an IP address reserved exclusively for this purpose, and cannot be the name of the first (master) node.
If you want to use a bridge which is not xen-br0, or no bridge at all, change it with the --nic-parameters option. For example to bridge on br0 you can add:
--nic-parameters link=br0
Or to not bridge at all, and use a separate routing table:
--nic-parameters mode=routed,link=100
If you don’t have a xen-br0 interface you also have to specify a different network interface which will get the cluster IP, on the master node, by using the --master-netdev <device> option.
You can use a different name than xenvg for the volume group (but note that the name must be identical on all nodes). In this case you need to specify it by passing the –vg-name <VGNAME> option to gnt-cluster init.
To set up the cluster as an Xen HVM cluster, use the --enabled-hypervisors=xen-hvm option to enable the HVM hypervisor (you can also add ,xen-pvm to enable the PVM one too). You will also need to create the VNC cluster password file /etc/ganeti/vnc-cluster-password which contains one line with the default VNC password for the cluster.
To setup the cluster for KVM-only usage (KVM and Xen cannot be mixed), pass --enabled-hypervisors=kvm to the init command.
You can also invoke the command with the --help option in order to see all the possibilities.
Please note that the default hypervisor/network/cluster parameters may not be the correct one for your environment. Carefully check them, and change them either at cluster init time, or later with gnt-cluster modify.
Your instance types, networking environment, hypervisor type and version may all affect what kind of parameters should be used on your cluster.
KVM
Instances are by default configured to use a host kernel, and to be reached via serial console, which works nice for Linux paravirtualized instances. If you want fully virtualized instances you may want to handle their kernel inside the instance, and to use VNC.
Some versions of KVM have a bug that will make an instance hang when configured to use the serial console (which is the default) unless a connection is made to it within about 2 seconds of the instance’s startup. For such case it’s recommended to disable the serial_console option.
Mandatory for all the other nodes.
After you have initialized your cluster you need to join the other nodes to it. You can do so by executing the following command on the master node:
$ gnt-node add NODENAME
Optional
Ganeti uses DRBD to mirror the disk of the virtual instances between nodes. To use a dedicated network interface for this (in order to improve performance or to enhance security) you need to configure an additional interface for each node. Use the -s option with gnt-cluster init and gnt-node add to specify the IP address of this secondary interface to use for each node. Note that if you specified this option at cluster setup time, you must afterwards use it for every node add operation.
Execute the gnt-node list command to see all nodes in the cluster:
$ gnt-node list
Node DTotal DFree MTotal MNode MFree Pinst Sinst
node1.example.com<PHONE_NUMBER>04 2047 1896 125 0 0
The above shows a couple of things:
With Ganeti a tool called burnin is provided that can test most of the Ganeti functionality. The tool is installed under the lib/ganeti/tools directory (either under /usr or /usr/local based on the installation method). See more details under burnin.
You can now proceed either to the Ganeti administrator’s guide, or read the manpages of the various commands (ganeti(7), gnt-cluster(8), gnt-node(8), gnt-instance(8), gnt-job(8)).
Footnotes
| [1] | The kernel and initrd paths can be changed at either cluster level (which changes the default for all instances) or at instance level. |


27 October 2000
Disease Outbreak Reported
As of 26 October 2000 the Kwazulu-Natal Department of Health has reported 3 806 cases and 33 deaths since the start of the outbreak in mid-August 2000 (see previous report).
The outbreak in Kwazulu-Natal is affecting the following areas: Lower Umfolozi districts which include Ngwelezane and Empangeni, Eshowe/Nkandla areas, Durban, KwaDukuza/Stanger area, Jozini and Port Shepstone. The three cases reported from Durban are imported cases.
Intensive public education measures are continuing.


| |
MENU
Home
History
Council
Tribal-Reps
Constitution
Dictionary
Editorial
Photos
Membership
Application
Flag
Comments
Chiefs
|
|
|
|
THE POWHATAN LANGUAGE IS EXTINCT! Currently approximately 1000 words of the Eastern
Algonquian language (200 plus are Powhatan) are known.William Strachey, while in Virginia
between 1610 and 1611, recorded the language and attempted to record the sounds using
the english alphabet.Capt John Smith recorded several hundred during his exploration, that
is the extent of the language.
At various times we will add words and phrases to the list. We hope that you enjoy
the site and visit often.
-
Above...............Oskeitch
-
Air.....................Rarascau
-
Apple................Maracah
-
Arm...................Mese
-
Awake..............Aumaumer
-
Bald...................Paatchkiscaw
-
Ball....................Aitowh
-
Butterfly...........Manaang-gwas
-
Calm.................Cohqwaivwh
-
Cheese............Ootun
-
Child.................Nechaun
-
Climb a Tree...Ahcoushe
-
Cold..................Nonssamats
-
To Cough.........Nussuccum
-
Creek...............Meihsutterask
-
Daughter.........Amosens
-
Deer..................Vttapaantam
-
The Devil..........Riapoke
-
Dog...................Attemous
-
Drink.................Vmpsemen Apook
-
Egg....................Wouwh
-
Eight..................Nuscawes
All words below,posted February 14, 2001
-
Enough..............Enough
-
Elbow.................Meisquan
-
Earth..................Aspami, Ottawm, Chippsin
-
East....................Vtchepwoissuma
-
Father................Kowse
-
Feet....................Messetts
-
Fingernails.......Wijchaudg
-
Fire.....................Bocuttaw
The following are the Numerical Tables from the British Museum manuscript.
1. Nekut
2. Ninge
3. Nousough or Nus
4. Yeough
5. Porance
6. Camatinge
7. ?
8. Nuscawes
9. Kykeytawe
10. Koske
20. Ningepoke
300. Nuswohcassannack
Words Posted October 11, 2001
-
Fish......................Nammais
-
Fishhook............ Auketuttawh
-
Flame...................Catzahanzamusheis
-
Flour.....................Rouhcat
-
Fox........................Assimoest
-
Friend...................Netab
-
All Friends...........Cheskchamy
-
Garden.................Oronocah
-
Gate......................Cuppenauk
-
Girl.........................Vsqwaseins Girls............Vsqwasenis oc
-
Give it to me........Tangoa
-
Give it to him.......Cummeish yoowah
-
Give me a little piece..Kapessemapaangun
-
I will not give it....Malacommeir
-
Give me some water...Mammahe sucqwahum
-
Glue.......................Vppeinsaman
-
Go to......................Ireh paspeen
-
Go home...............Nummacha
-
God........................Ahone
-
Very good............Winganouse
|


[name]
2D Vector.
Example
var a = new THREE.Vector2( 0, 1 );
var b = new THREE.Vector2( 1, 0 );
var d = a.distanceTo( b );
Constructor
[name]( [page:Float x], [page:Float y] )
Properties
.[page:Float x]
.[page:Float y]
Methods
.set( [page:Float x], [page:Float y] ) [page:Vector2]
Sets value of this vector.
.copy( [page:Vector2 v] ) [page:Vector2]
Copies value of *v* to this vector.
.add( [page:Vector2 a], [page:Vector2 b] ) [page:Vector2]
Sets this vector to *a + b*.
.addSelf( [page:Vector2 v] ) [page:Vector2]
Adds *v* to this vector.
.sub( [page:Vector2 a], [page:Vector2 b] ) [page:Vector2]
Sets this vector to *a - b*.
.subSelf( [page:Vector2 v] ) [page:Vector2]
Subtracts *v* from this vector.
.multiplyScalar( [page:Float s] ) [page:Vector2]
Multiplies this vector by scalar *s*.
.divideScalar( [page:Float s] ) [page:Vector2]
Divides this vector by scalar *s*.
Set vector to *( 0, 0 )* if *s == 0*.
.negate() [page:Vector2]
Inverts this vector.
.dot( [page:Vector2 v] ) [page:Float]
Computes dot product of this vector and *v*.
.lengthSq() [page:Float]
Computes squared length of this vector.
.length() [page:Float]
Computes length of this vector.
.normalize() [page:Vector2]
Normalizes this vector.
.distanceTo( [page:Vector2 v] ) [page:Float]
Computes distance of this vector to *v*.
.distanceToSquared( [page:Vector2 v] ) [page:Float]
Computes squared distance of this vector to *v*.
.setLength( [page:Float l] ) [page:Vector2]
Normalizes this vector and multiplies it by *l*.
.equals( [page:Vector2 v] ) [page:Vector2]
Checks for strict equality of this vector and *v*.
.isZero() [page:Boolean]
Checks if length of this vector is within small epsilon (*0.0001*).
.clone() [page:Vector2]
Clones this vector.
Source
[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]


---
layout: post
title: The value lies in doing the boring stuff
date:
type: post
published: false
status: draft
categories: []
tags: []
meta:
_edit_last: '1'
author:
login: satyadeep
email<EMAIL_ADDRESS>display_name: Satyadeep
first_name: Satyadeep
last_name: K
---
What do all softwares achieve? Automation
What does automation mean? To automate the mechanical and mundane tasks so that we can concentrate on what really matters.
Take any good productivity software for example: Dropbox, Gmail etc. They do all the boring stuff of syncing our files and delivering our emails so we can focus on more important things.
So, when you do all the boring stuff and let your user feel that she is in control, then you generate value. When the computer does what you want it to do like a genie, then you feel powerful.


1. Datasets and preliminaries
GLIMPSE is a software for imputation and phasing of low-coverage datasets in the form of genotype gikelihoods (GLs) at all variant positions.
This tutorial requires GLIMPSE v1.1.0 (or later) and HTSlib and BCFtools v1.10 (or later).
Here we also used BCFtools to compute genotype likelihoods.
In this tutorial, we show how to run GLIMPSE to perform chromosome X imputation. Imputation of chromosome X is different from autosomes,
as chromosome X contains a non pseudo-autosomal region (non-PAR) where males are haploid and females are diploids. The chromosome also
contains two pseudo-autosomal regions (PAR1, PAR2), where all samples are diploid. PAR1 and PAR2 are both at the end of the chromosomes.
A schematic representation of the regions of the chromosome is given below:
This tutorial describes the process of getting refined genotype and haplotype calls starting from aligned sequencing reads data (BAM/CRAM file) for the non-PAR region of chromosome X. Imputation of PAR regions of the chromosome is not performed here, as it is not conceptually different from imputation of autosomes.
The data and the scripts for this tutorial can be downloaded HERE.
A minimal set of data to run this pipeline can be found in the folder
tutorial_chrX
. Here we assume that the folder is located as a subfolder of the GLIMPSE installation: tutorial_chrX
.
All datasets used here are in GRCh38/hg38 genome assembly
A dataset containing chromosome X downsampled 1x sequencing reads (BAM files) for 2 individuals (one male and one female) from ASW population is provided with this tutorial, together with a reference genome FASTA file needed for genotype likelihood computations.
1.1. Setting the environment and binaries
All scripts have been written assuming >GLIMPSE/tutorial_chrX/
as current directory. Therefore, we move to the tutorial_chrX directory:
> cd GLIMPSE/tutorial_chrX/
From this folder we build all the GLIMPSE software needed (chunk, phase, ligate, sample and concordance). For this reason, we require that GLIMPSE can correctly compile on your machine and you might be required to edit the Makefiles manually. See installation instructions if there are any problems at this stage. We created a script to configure a directory containing symbolic links to the GLIMPSE binaries we will need later. To run the setup script, simply run:
> ./step1_script_setup.sh
If the script runs correctly, the software compiles and the bin folder containing symbolic links to the binaries has been created, everything is correctly setup.
1.2. Low coverage reads
In this example we downsampled the publicly available 30x data available for ASW population as part of the 1000 Genomes Project. We downloaded the full dataset, kept only non-PAR chromosome X reads and downsampled to 1x. The resulting BAM file can be found in:
asw_1x_bam/*.bam[.bai]
, where each bam file in the folder represents a single sample (2 in total).
2. Reference panel preparation
In order to run accurate imputation we recommend to use a targeted reference with ancestry related to the target samples, if possible. For this tutorial we use the 1000 Genomes Project phase 3 reference panel. Since the reference panel contains data of our target samples, we need to remove them from the reference panel. This steps download the 1000 genomes b38 data from the EBI ftp site and remove the target samples from it.
2.1. Download of the reference panel files
The 1000 Genomes phase 3 reference panel is publicly available at EBI 1000 genomes ftp site. We can download chromosome X data using:
> wget http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/release/20130502/supporting/GRCh38_positions/ALL.chrX_GRCh38.genotypes.20170504.vcf.gz{,.tbi}
2.2. Remove ASW samples from the reference panel and basic QC
We use BCFtools to remove ASW samples from the reference panel and export the dataset in BCF file format (for efficiency reasons). We also performs a basic QC step that includes:
- Generate a text file containing space-spearated old and new chromosome names. This is required to rename the numerical chromosome names with 'chr' tag. Apply the new chromosome names with 'bcftools annotate'.
- Keep only SNPs and remove multiallelic records.
> for CHR in {1..23} X ; do
> echo ${CHR} chr${CHR}
> done >> chr_names.txt
> CHR=X
> bcftools annotate --rename-chrs chr_names.txt \
> ALL.chr${CHR}_GRCh38.genotypes.20170504.vcf.gz -Ou | \
> bcftools view -m 2 -M 2 -v snps -S ^NA19625,NA19703 --threads 4 -Ob -o reference_panel/1000GP.chr${CHR}.filt.bcf
> bcftools index -f reference_panel/1000GP.chrX.filt.bcf
> rm ALL.chrX_GRCh38.genotypes.20170504.vcf.gz*
> rm chr_names.txt
The resulting reference panel files can be found in:
reference_panel/1000GP.chrX.filt.bcf[.csi]
The reference panel can now be used for genotype likelihoods calculations (only the sites, not the data) and imputation.
3. Computation of genotype likelihoods
GLIMPSE requires input data to take the form of Genotype Likelihoods (GLs). GLs need to be computed at all target individuals and all variant sites present in the reference panel of haplotypes used for the imputation. In this section, we describe a simple procedure to compute GLs from sequencing data using BCFtools. However, other callers, such as GATK for instance, can be also considered as soon as the GLs are encoded in a VCF/BCF file using the FORMAT/PL field.
Please note that BCFtools does not call correctly genotype likelihoods for indels and this might affect the quality of the imputation even at non-indels. For this reason in this tutorial we only focus on bi-allelic SNPs.
3.1. Extracting variable positions in the reference panel
We want this information to tell BCFtools at which position to make a call.
Since BCFtools does not seem to compute correctly genotype likelihood for indels, here we only focus on SNPs (however, GLIMPSE can impute any type of variants as soon it is bi-allelic and has GLs being properly defined).
To perform the extraction from the chromosome X of a reference panel 1000GP.chrX.filt.bcf
, run first BCFtools as follows:
> bcftools view -G -m 2 -M 2 -v snps reference_panel/1000GP.chrX.filt.bcf -Oz -o reference_panel/1000GP.chrX.filt.sites.vcf.gz
> bcftools index -f reference_panel/1000GP.chrX.filt.sites.vcf.gz
Then, convert the output file 1000GP.chrX.filt.sites.vcf.gz
into TSV format and index the file using tabix (requires htslib in PATH), using this command:
> bcftools query -f'%CHROM\t%POS\t%REF,%ALT\n' reference_panel/1000GP.chrX.filt.sites.vcf.gz | bgzip -c > reference_panel/1000GP.chrX.filt.sites.tsv.gz
> tabix -s1 -b2 -e2 reference_panel/1000GP.chrX.filt.sites.tsv.gz
In a general pipeline, we should generate this pair of files (*.vcf.gz + *.tsv.gz) for all chromosome separately.
3.2. Computing GLs for each individual at specific positions
Once ready the position files, we can then start performing the calling step.
We use the downsampled 1x BAM files generated in section 1.1 asw_1x_bam/*.chrX.1x.bam
.
BCFtools requires the reference genome in order to align the BAM file. We used the reference genome version used by the 1000 Genomes Project (reference_genome/hs38DH.chrX.fa.gz[.fai,.gzi]
)
We can run the following command:
> list.txt
> FILES=asw_1x_bam/asw_samples/*
> for file in $FILES; do
> f=$(basename $file)
> BAM=asw_1x_bam/${f}.bam
> VCF=reference_panel/1000GP.chrX.filt.sites.vcf.gz
> TSV=reference_panel/1000GP.chrX.filt.sites.tsv.gz
> REFGEN=reference_genome/hs38DH.chrX.fa.gz
> OUT=asw_1x_vcf/${f}.chrX.1x.vcf.gz
> bcftools mpileup -f ${REFGEN} -I -E -a 'FORMAT/DP' -T ${VCF} -r chrX ${BAM} -Ou | bcftools call --ploidy GRCh38 -S asw_1x_bam/asw_samples/${f} -Aim -C alleles -T ${TSV} -Oz -o ${OUT}
> bcftools index -f ${OUT}
> ls ${OUT} >> list.txt
> done
Note here, that we use -T reference_panel/1000GP.chrX.filt.sites.vcf.gz
in the first part of the command line and
-T reference_panel/1000GP.chrX.filt.sites.tsv.gz
in the second part of the command line.
You may also tune the options of BCFtools to your specific needs, requirements and data.
As an output of this step we have a VCF file format containing genotype likelihoods at each site in the reference panel.
3.3. Merging genotype likelihoods of multiple individuals
As we have multiple target individuals, an additional step is to generate a single file containing genotype likelihoods for all target individuals. This can be easily done using BCFtools, for example:
> bcftools merge -m none -r chrX:2781480-155701382 -Oz -o asw_1x_vcf/merged.chrX.1x.vcf.gz -l list.txt
> bcftools index -f asw_1x_vcf/merged.chrX.1x.vcf.gz
> rm list.txt
Where list.txt
is a text file containing the full list of VCF/BCF files containing GLs of each target individual in the study, one individual file per line.
The resulting file must be indexed and can be used in the subsequent steps of the pipeline.
4. Split the genome into chunks
One important step prior is to define the chunks where to run imputation and phasing. This step is not trivial because different long regions increase the running time, but small regions can drastically decrease accuracy. Also there are several variables to take into account: the amount of missingness in the defined region and the length in Mb. For these reasons we developed a tool in the GLIMPSE suite (GLIMPSE_chunk) that is able to quickly generate imputation chunks taking into account all this information.
4.1. Chunking a chromosome
We use GLIMPSE_chunk to generate imputation regions for the full non-PAR region of chromosome X, modifying few default parameters in this way:
> ./bin/GLIMPSE_chunk --input reference_panel/1000GP.chrX.filt.sites.vcf.gz --region chrX:2781480-155701382 --output chunks.chrX.txt
5. Impute and phase a whole chromosome
The core of GLIMPSE is the GLIMPSE_phase method. The algorithm works by iteratively refining the genotype likelihoods of the target individuals in the study. The output of the method is a VCF/BCF file containing:
- the best guess genotype in the FORMAT/GT field
- the imputed genotype dosage in the FORMAT/DS field
- the genotype probabilities in the FORMAT/GP field
- the last (max 15) sampled haplotypes in the FORMAT/HS field
5.1. Running GLIMPSE
To run GLIMPSE_phase we only need to run a job for each imputation chunk. Each job runs on 4 threads in this example.
Input data are the dataset containing the genotype likelihoods, a reference panel of haplotypes, a fine-scale genetic map (e.g. from the International HapMap project) and buffered and imputation regions.
Additionally, as we have samples with mixed ploidy, we will provide the --samples-file
parameter, indicating a file containing each sample name and ploidy (one per row).
We run GLIMPSE phase using default parameters that can apply to most datasets. For extremely low coverage and small reference panels, increasing the number of iterations might give more accuracy.
> mkdir -p GLIMPSE_impute
> VCF=asw_1x_vcf/merged.chrX.1x.vcf.gz
> REF=reference_panel/1000GP.chrX.filt.bcf
>MAP=../maps/genetic_maps.b38/chrX.b38.gmap.gz
> while IFS="" read -r LINE || [ -n "$LINE" ];
> do
> printf -v ID "%03d" $(echo $LINE | cut -d" " -f1)
> IRG=$(echo $LINE | cut -d" " -f3)
> ORG=$(echo $LINE | cut -d" " -f4)
> OUT=GLIMPSE_impute/merged.chrX.imputed.${ID}.bcf
> ./bin/GLIMPSE_phase --input ${VCF} --reference ${REF} --map ${MAP} --input-region ${IRG} --output-region ${ORG} --output ${OUT} --samples-file samples.txt
> bcftools index -f ${OUT}
> done < chunks.chrX.txt
6. Ligate multiple chunks together
Merging together different chunks of the sample chromosome is a standard procedure and it is usually straightforward in the case of genotype data. However GLIMPSE phase generates phased information in addition of genotype information. In this case, ligation is a required step to merge multiple chunks together without losing phased imputation. For this purpose we developed a software in the GLIMPSE software suite, called GLIMPSE_ligate. The output of this step is a chromosome wide VCF/BCF file containing information coherent phasing information, stored in the FORMAT/HS field
6.1. Ligate whole chromosome chunks
GLIMPSE_ligate only requires a list containing the imputed files that need to be merged together:
> mkdir -p GLIMPSE_ligate
> LST=GLIMPSE_ligate/list.chrX.txt
> ls GLIMPSE_impute/merged.chrX.imputed.*.bcf > ${LST}
> OUT=GLIMPSE_ligate/merged.chrX.bcf
> ./bin/GLIMPSE_ligate --input ${LST} --output ${OUT}
In the case phased information is not needed, this can be the final step, providing chromosome-wide genotype information in the FORMAT/DS and FORMAT/GP field.
7. Sample haplotypes
In the case haplotype-level information is required, GLIMPSE_sample can sample from the FORMAT/HS field accurate, consensus based haplotypes. The output of this step is a VCF/BCF file containing information at the chromosome level, where the GT field contains accurate phased information.
7.1. Sample whole chromosome data
There are two main modes for GLIMPSE_sample can operate.
The first mode can sample haplotypes based on the probabilities given from the FORMAT/HS field (--sample), while the second mode outputs the most likely haplotypes given the values in the FORMAT/HS field (--solve).
We run GLIMPSE_sample using the --solve mode:
> mkdir -p GLIMPSE_sample
> VCF=GLIMPSE_ligate/merged.chrX.bcf
> OUT=GLIMPSE_sample/merged.chrX.sampled.bcf
> ./bin/GLIMPSE_sample --input ${VCF} --solve --output ${OUT}
From the output dataset, accurate phased information, stored in the GT field can be directly used.
8. Check imputation accuracy
Since we downsampled the reads from the original 30x data, we might be interested now in checking how accurate the imputation is, compared the original 30x dataset. For this purpose we use the GLIMPSE_concordance tool, which can be used to compute the r2 correlation between imputed dosages (in MAF bins) and highly-confident genotype calls from the high-coverage dataset.
8.1. Running GLIMPSE_concordance
The GLIMPSE_concordance requires tool requires a file (--input) indicating:
- the region of interest;
- a file containing allele frequencies at each site;
- the validation dataset called at the same positions as the imputed file (in a similar way as showed in appendix A1, without the downsampling);
- the imputed data.
concordance.lst
having all the correct files in the right order for this tutorial.
Other parameters specify how confident we want a site to be in the validation data and the MAF bins.As we have samples with mixed ploidy, we will run the concordance tool two times, with a difference set of samples: haploids and diploids.
For haploid samples, the GLIMPSE_concordance too is run as follows:
> ./bin/GLIMPSE_concordance --input concordance.lst --minDP 8 --output GLIMPSE_concordance/output.hap --minPROB 0.9999 \
> --bins 0.00000 0.00100 0.00200 0.00500 0.01000 0.05000 0.10000 0.20000 0.50000 \
> --af-tag AF_afr --samples asw_1x_bam/asw_samples/NA19703
> ./bin/GLIMPSE_concordance --input concordance.lst --minDP 8 --output GLIMPSE_concordance/output.dip --minPROB 0.9999 \
> --bins 0.00000 0.00100 0.00200 0.00500 0.01000 0.05000 0.10000 0.20000 0.50000 \
> --af-tag AF_afr --samples asw_1x_bam/asw_samples/NA19625


Sanjay Manjrekar comes under fire after ‘insulting’ Harsha Bhogle on air about pink ball
Harsha Bhogle and Sanjay Manjrekar were talking about the pink ball and its future in Test cricket when Manjrekar seemed to suggest that he was more of an authority in the game because of having played international cricket himself.
by Sports DeskCommentator Sanjay Manjrekar has come under heavy criticism for insulting colleague Harsha Bhogle while on air on the third and final day of the Day/Night Test between India and Bangladesh in Kolkata on Sunday. The two commentators were talking about the pink ball and its future in Test cricket when Manjrekar seemed to suggest that he was more of an authority in the game because of having played international cricket himself.
“When there is a post-mortem done of this, the visibility of the ball will be one of things to look at,” Harsha Bhogle said.
Manjrekar, who played 37 Tests for India between 1987 and 1996, replied, “Don’t think so. Don’t think visibility is an issue.”
“We just need to ask the players what they think,” Bhogle replied.
Manjrekar, escalating the argument, took an unexpected jibe at Bhogle’s lack of experience in playing international cricket at his point. “You need to ask, for those who have played cricket, it’s evident it can be seen well,” he said.
‘Never played at that level’: Amol Muzumdar takes jibe at Sanjay Manjrekar
Bhogle, ignoring the import of the comment, said, “The only reason you need to ask is, having played cricket should never be a limitation or a ceiling to learning. We would never have had T20 cricket otherwise.”
The matter ended with Manjrekar saying, “Point taken, don’t agree.”
Bhogle, the first Indian commentator to be invited by the Australian Broadcasting Corporation for an overseas tour in 1992, has played cricket at university level in Hyderabad, before becoming arguably the most respected Indian cricket analyst of the generation.


Lorem ipsum dolor sit amet consectetur adipisicing elit. Voluptatem consequatur corporis rem quo qui earum dolores magnam, quos sunt nam? Nisi consectetur quidem sed aliquid nostrum omnis vel delectus voluptates!
Contrary to popular belief, Lorem Ispum is not simply random text.  Richard McClintock, a Latin professor at hampden-Sydney college in Virgina, looked up one of the more obscure Latin words, consectetur, from a Lorem ipsum passage, and going throungh the cites of the word in classical literature, discovered the undoubtable sourse.
Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Boborum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance.
There are many variations of passages
There are many variations of passages
There are many variations of passages
Address: Street Ahmad Donish, 36B | Call: 94 626 76 56


Bases: fseq.reading.seq_encoder.SeqFormat
Detector of FASTQ format
See also
Examples
Valid format:
@Contig_1
AACAATACGA
+Contig_1
@+>AACADGH
@Contig_2
CCATTTACGA
+
>CCAGJDFGH
Attributes
| HEADER_LINE | |
| SEUENCE_LINE | |
| QUALITY_LINE |
Bases: fseq.reading.seq_encoder.SeqFormat
Detector of multi-line FASTA
See also
Examples
Valid format:
>Contig_1
ACAATACA
GATTACA
>Contig_2
ACCCACA
>Contig_3
ACCAAACA
CCAACACA
ACAACCAC
Attributes
| HEADER_LINE | |
| SEUENCE_LINE | |
| QUALITY_LINE |
Bases: fseq.reading.seq_encoder.FastaMultiline
Detector of single-line FASTA format.
See also
Examples
Valid format:
>Contig_1
AACAATACGA
>Contig_2
CCATTTACGA
Attributes
| HEADER_LINE | |
| SEUENCE_LINE | |
| QUALITY_LINE |
Bases: exceptions.Exception
Sequence Format Error for exceptions relating to missmatches between encoders and sequence formats as well as lacking formattings in encoders and unknown sequence formats.
Bases: fseq.reading.seq_encoder.FormatError
Error for exposing parts of interface that needs to be overwritten in subclasses
Bases: fseq.reading.seq_encoder.FormatError
Error for having no available detectors left
Bases: object
Base class for managing encoding of raw input data.
The encoder coordinates detection of raw data format and then extracts the information that the encoder is tasked to extract, convering it into suitable encoding.
Note: The base class is not intended to be used directly, but to be extended.
See also
Attributes
| format | The input format currently expected. |
| initiated | If the sequence encoder is ready to start parsing: bool |
| itemSize | The size in number of lines for each item in the source. |
| qualityEncoding | Map for translating quality chars to numeric values. |
| sequenceEncoding | Map for translating sequence chars to numeric values. |
| useQuality | If quality-line is to be used by the encoder. |
| useSequence | If sequence-line is to be used by the encoder |
Detect format based on current input stream
| Returns: | fseq.SeqEncoder
|
|---|---|
| Raises: | FormatError
|
See also
Give detection a line to work with.
| Parameters: | line: str
|
|---|---|
| Returns: | fseq.SeqEncoder
|
The input format currently expected.
| Returns: | SeqFormatDetector |
|---|---|
| Raises: | TypeError
|
The size in number of lines for each item in the source.
| Returns: | int |
|---|---|
| Raises: | fseq.FormatError
|
See also
Placeholder parser overwritten when subclassing
| Parameters: | lines: iterable of str
out: numpy.ndarray
outIndex: object
|
|---|---|
| Raises: | NotImplemented
|
Map for translating quality chars to numeric values.
| Returns: | Object with key-lookup (implementing __getitem__) |
|---|---|
| Raises: | TypeError
|
Clears the sequence format
| Returns: | fseq.SeqEncoder
|
|---|
See also
Bases: fseq.reading.seq_encoder.SeqEncoder
GC Encoder, but useful for any sequence to numerical value encoding.
The encoder uses the sequence information of the raw data and encodes the data according to the following:
| Input | Encoding |
|---|---|
| G C | 1.0 |
| A T | 0.0 |
| N | 0.5 |
To change this behaviour, simply submit a new mappable object such as e.g. a dict as the sequenceEncoding-parameter.
Encoder of suitable aspects of lines into out.
The sequence line of lines will be encoded onto the index outindex of out. If the sequence line is shorter than the data structure of out[outindex], the remainder of out[outindex] will be left untouched. If the line is longer, it will only encode up until the the length of out[outindex].
| Parameters: | lines: iterable of str
out: numpy.ndarray
outIndex: object
|
|---|
Bases: object
Base Class for implementing data format detectors.
The attributes present in subclass should overwrite the parent properties. All subclasses must also overwrite the SeqFormat.expects(line).
Attributes
| name | Human readable description of format: str |
| itemSize | The size (lines) of each entry: int |
| hasSequence | If format has sequence information: bool |
| hasQuality | If format quality information: bool |
| qualityEncoding | If format comes with a known encoding of quality. |
| MATCH_AA | |
| MATCH_AA_S | |
| MATCH_NT | |
| MATCH_NT_S | |
| HEADER_LINE | |
| SEUENCE_LINE | |
| QUALITY_LINE |
Matches any complete line of A-Z characters allowing for asterisc at end.
Matches as MATCH_AA_S but extends to include space
Matches any complete line of only A T C G or N
Matches as MATCH_NT but extends to include space
Test for if line fits into required pattern for the format
| Parameters: | line: str
|
|---|---|
| Returns: | bool |
| Raises: | FormatImplementationError
|
Reports if format has given up even though everything still was matching.
The purpose is to be able to promote more restricted formats that represents a subset of the more general
| Returns: | bool
|
|---|
If format comes with a known encoding of quality.
See also
Bases: object
Detection of data-format manager
Given a set of initially specified formats the detector feeds them lines of data until only one remains True. It then further continues a little while to be more certain that it was not a mere fluke.
See also
Attributes
| detecting | If attempting to detect: bool |
| format | The format name of the detected format: str |
| itemSize | The size (lines) of each entry: int |
| hasSequence | If format has sequence information: bool |
| hasQuality | If format quality information: bool |
| qualityEncoding | If format comes with a known encoding of quality. |
| headerLine | The line index in the item for the header |
| sequenceLine | The line index in the item for the sequence |
| qualityLine | The line index in the item for the quality |
| headerLine | The line index in the item for the header |
| sequenceLine | The line index in the item for the sequence |
| qualityLine | The line index in the item for the quality |
| FORMATS |
Evaluates if encoder is compatible with the detected format
| Returns: | bool
|
|---|---|
| Raises: | FormatError
|
Supply a new line to format detector.
| Parameters: | line: str
|
|---|---|
| Returns: | fseq.SeqEncoder
|
| Raises: | FormatUnknown
|
The line index in the item for the header
| Returns: | int |
|---|---|
| Raises: | FormatError
|
If format comes with a known encoding of quality.
See also
Module for reading sequence data
Bases: object
Reads sequence data and encodes it.
The length of the sequence reader reflects the number of inputs to be processed.
The entire stack of inputs can be processed in bulk by invoking SeqReader.run() but the results of each encoding, omitting any report building can also be produced iteratively as shown in the examples.
Examples
To invoke the reader it can either be run :
>>> seqReader.run()
<fseq.reading.seq_reader.SeqReader at 0x7faf6970fd10>
or if more control is required, it can be iterated over:
>>> for res in seqReader:
... reportBuilder.distill(res, dirname=seqReader.reportDirectory)
Both methods above yielding the same result with the difference that the first may store results in seqReader.results depending on the seqReader.popEncodingResults settings while the latter never keeps the results in the state of the instance.
Attributes
| popDataSources | If sequence reader should remove data sources from list of sources when they have been read. |
| popEncodingResults | If the outcome of an encoding should be remove from memory as soon as report as been produced or iteration completed. |
| jobQueue | The data sources to be read and their respective targets. |
| reportBuilders | The report builders associated with the reader. |
| reportDirectory | The directory where reports for the last made encoding should go. |
| resetSeqEncoder | If each data source will detect format anew or if all files are |
| results | A list of the results of the encodings. |
| dataArrayConstructor | |
| dataWidth | |
| dataType | |
| SeqEncoder |
Add a data source path to be analysed.
| Parameters: | sourcePaths: string or iterable object
targetPaths: string or iterable object, optional
|
|---|---|
| Returns: | fseq.SeqReader
|
| Raises: | ValueError
|
Add a report builder to the set of reports done upon analysis.
| Parameters: | reportBuilders: fseq.ReportBuilder, optional
|
|---|---|
| Returns: | fseq.SeqReader
|
| Raises: | TypeError
|
The data sources to be read and their respective targets.
| Returns: | list of tuples
|
|---|
Part of iter interface, produces the encoding of the next data-source.
| Returns: | numpy.ndarray
|
|---|---|
| Raises: | ValueError
StopIteration
|
If sequence reader should remove data sources from list of sources when they have been read.
The general use case is to set this to True, but omitting popping can be useful if data may be needed to be re-read with a different encoder.
| Returns: | bool |
|---|
If the outcome of an encoding should be remove from memory as soon as report as been produced or iteration completed.
Note: The process will require large amounts of memory if results are not popped and several large files analysed.
| Returns: | bool |
|---|
Removes all builders supplied, or all builders if no specific builder is supplied.
| Parameters: | *args: fseq.ReportBuilder, optional
|
|---|---|
| Returns: | fseq.SeqReader
|
Examples
If current instance has three builders:
>>> tuple(seqEncoder.reportBuilders)
(b1, b2, b3)
The b2 and b3 can be removed by:
>>> seqEncoder.removeReportBuilders(b2, b3)
<fseq.reading.seq_reader.SeqReader at 0x7faf696e5810>
>>> tuple(seqEncoder.reportBuilders)
(b1, )
Alternatively all builders can be removed by:
>>> seqEncoder.removeReportBuilders()
<fseq.reading.seq_reader.SeqReader at 0x7faf696e5810>
>>> tuple(seqEncoder.reportBuilders)
()
The report builders associated with the reader.
If any, the reports will be destilled automatically at the end of SeqReader.run().
| Returns: | tuple
|
|---|
See also
The directory where reports for the last made encoding should go.
| Returns: | str |
|---|
If each data source will detect format anew or if all files are assumed to be of the same format
| Returns: | bool |
|---|
A list of the results of the encodings.
| Returns: | list |
|---|
See also
Runs through all sources and produces reports if such have been attached.
| Returns: | fseq.SeqReader
|
|---|
Reading-related modules of fseq.
The reading package contains of two modules: seq_encoder and seq_reader.
The reader contains the generic reader that coordinates actions and works as the mainframe of fseq. This module should need no extensions to increase the funcitonality of the fseq.
The encoder-module contains both the different types of encoders available as well as the format-detectors for variaous types of input formats. Here further formats can be added and new encoders written to extend the functionality of fseq.


Schematic
Textures
Zoom
[[zoom]]
Light
[[ambientLightIntensity]]
[[directionalLightIntensity]]
🗒 Note: The used texture pack "Faithful 32x32 Pack" (
Link
) was made by "Vattic".


Sondos Al-Braim
- My name is Sondos Al-Braim.
- I am 22 years old.
- I have a bachelor's degree in English Language and Literature.
- I am currently a Software Development Apprentice.
- I am very excited to design different pages and to be an advanced Software Developer.
My top favorite singers:
- Michael Jackson
- Bruno Mars
- Lady Gaga
- Ariana Grande
- Bilie Eilish
- p!nk
- Taylor Swift
- Camila Cabello
- Selena Gomez
- Ricky Martin


StatPREP: Data-driven statistics
Daniel Kaplan
2018-02-27
Chapter 1 Teaching Data-driven Statistics
Description, prediction, decision
Large and growing student interest in computer science and statistics. That growing interest is not simply a matter of new subjects receiving attention or of transient employment opportunities. The interest reflects systemic changes in the technical infrastructure of life and work in the US and the world due to the emergence of ubiquitous computing. Among other things, computing has led to an explosion in the availability of data and to the ability to explore systems at a greater level of complexity and a finer level of detail. Since computers always work with a mathematical representation of the world, the ability to construct and interpret such representations (aka “modeling”) is now a core part of research, commercial, industrial, medical, social, and government activities. Mathematical skills, particularly in applied math and statistics, are essential here.
- Wrangling
- Visualization
- Statistical description
- Prediction
1.1 Pocket guide to StatPREP commands
See Essential_statprep_command.key
. Maybe put a copy of it here, or a full-page version.


It would be really helpful for managing my community's emblems where I can put the exact same logo without remaking it and then numerate each one like here :
And as i readed the first post again, i also don't really know what you mean.
The title says you want the easy controls also for bf3.
The post text says you want copy emblems to all different battlelog sections, that is a feature that not exist in bblog.
Post edited 14 x times, last by
Brady_The
Brady_The
kurtextrem wrote:
@Brain: You can use this link to get to the emblems without having bf4:
Interesting. Seems that they added an account ID (or it was there the whole time, but its the first time I actually see one). battlelog.battlefield.com/bf4/emblem/edit/personal/
ACCOUNTID
/
SOLDIERID
/1/
Using your link obviously gives me an "Internal Server Error", but if I replace your soldier ID with mine I do have access to your emblems somehow.
kurtextrememblem.png
I can't save changes or delete emblems, though (ERROR_NOT_OWNER).
Using your personalized link gives you btw access to your profile with stats, personal emblem editor, etc. Modifying your emblem works but the Save button is hidden.
I am confused, lol.
BrainFooLong
Administrator
It is intended to work so.
Everyone can see everything but only the owner can modify things.
I asked a DICE employee because i was also surprised.
Post edited 4 x times, last by
kurtextrem
kurtextrem
The first id is the emblem (library?..no) id(?), the second the soldierid(?)
I'm confused now too
Edit: Looks like the "bug" is gone, you only can see your own library. You could view others' librarys too in the beta.
Edit2: No, you just need one emblemid + your own soldierid to view other players' library. Interesting..
Topicstarter
Collision
Not sure why you guys went a bit off-topic but I'm asking if is there a possibility to make it possible to use the arrow, space and ESC keys and see/modify the layer details or even copy the whole emblem from platoon to platoon in BF3 or from platoon to platoon / soldier to platoon / platoon to soldier in BF4.
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
Copy platoon from bf3 to bf4 isn't possible because both use another system.
Maybe it's possible but i don't want to poke around through that.
Topicstarter
Collision
BrainFooLong wrote:
Copy platoon from bf3 to bf4 isn't possible because both use another system.
Maybe it's possible but i don't want to poke around through that.
I didn't mention from BF3 to BF4 or the opposite.
BrainFooLong
Administrator
Well, now i have the point.
This should be possible, maybe from one of our plugin devs.
Topicstarter
Collision
BrainFooLong wrote:
Well, now i have the point.
This should be possible, maybe from one of our plugin devs.
I also believe it's more possible in the BF4 system from platoon to platoon or soldier to soldier, but I'm not sure about it from soldier to platoon or the opposite in BF4 or platoon to platoon in BF3 (an old system).
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
In BF4 we have only emblem editor. Copy of emblems is already included into battlelog.
In BF3 we have only platoon editor. Copy of emblems is not battlelog native possible, but easy with a quick console code.
1. Copy Emblem Temporarily - Press F12 in your browser, goto console tab and execute that code by entering it in the console and hit enter. Only possible on the platoon editor page. BBLog.cache("tmp.emblem", emblem.emblem.toJson());
2. Paste Prev. copied Emblem - Press F12 in your browser, goto console tab and execute that code by entering it in the console and hit enter. Only possible on the platoon editor page. emblem.emblem.canvas._objects = [];
emblem.emblem.load(JSON.parse(BBLog.cache("tmp.emblem")));
Notice: You must stay in the same browser window when you do that.
Solve this your problems?
Post edited 1 x times, last by
Collision
Topicstarter
Collision
BrainFooLong wrote:
In BF4 we have only emblem editor. Copy of emblems is already included into battlelog.
In BF3 we have only platoon editor. Copy of emblems is not battlelog native possible, but easy with a quick console code.
1. Copy Emblem Temporarily - Press F12 in your browser, goto console tab and execute that code by entering it in the console and hit enter. Only possible on the platoon editor page. BBLog.cache("tmp.emblem", emblem.emblem.toJson());
2. Paste Prev. copied Emblem - Press F12 in your browser, goto console tab and execute that code by entering it in the console and hit enter. Only possible on the platoon editor page. emblem.emblem.canvas._objects = [];
emblem.emblem.load(JSON.parse(BBLog.cache("tmp.emblem")));
Notice: You must stay in the same browser window when you do that.
Solve this your problems?
Thanks a lot, I'm using the feature and will show you the result :)
Is this possible with one layer only ?
-----------
EDIT :
-----------
It seems to be impossible to do when you change account (even on the same browser tab)
BrainFooLong
Administrator
When you want to use it over different page views use BBLog.storage instead of BBLog.cache
Topicstarter
Collision
BrainFooLong wrote:
When you want to use it over different page views use BBLog.storage instead of BBLog.cache
Thank you, this is a lot better !
See the result, they look the same now :D (Except for the numbers for multiple platoons on the same platform and the background color for each platform) :


Bone-growth regulatory factors that are members of the transforming growth factor-beta superfamily of proteins. They are synthesized as large precursor molecules which are cleaved by proteolytic enzymes. The active form can consist of a dimer of two identical proteins or a heterodimer of two related bone morphogenetic proteins. (mesh:D019485)
| Synonym | Reference | Specificity |
| BMP | Exact |
| Identifier | Name | Relation |
| HGNC:1072 | BMP5 | isa |
| HGNC:4217 | GDF2 | isa |
| HGNC:1073 | BMP6 | isa |
| HGNC:1069 | BMP2 | isa |
| HGNC:21650 | BMP8A | isa |
| HGNC:4221 | GDF6 | isa |
| HGNC:4214 | GDF1 | isa |
| HGNC:1074 | BMP7 | isa |
| HGNC:1075 | BMP8B | isa |
| HGNC:4222 | GDF7 | isa |
| HGNC:1070 | BMP3 | isa |
| HGNC:1071 | BMP4 | isa |
| HGNC:20869 | BMP10 | isa |
| HGNC:1067 | BMP1 | isa |
| HGNC:4218 | GDF3 | isa |
| HGNC:4220 | GDF5 | isa |
| HGNC:1068 | BMP15 | isa |


|
Allegro CL version 8.0 Minimally revised from 7.0. |
This is a preliminary document which will be updated over time. Upates will be available for downloading.
Introduction and a simple example
LXML parse output format
parse-xml non-validating parser properties
PXML compatibility with the SAX parser
Usage notes
parse-xml requires Modern Lisp's mixed case and international character support
parse-xml and packages
parse-xml, the XML Namespace specification, and packages
The parse-xml function has been tested
ACL does not support Unicode 4 byte scalar values
debugging aids
XML Conformance test results
parse-xml reference
*debug-xml*
*debug-dtd*
The parse-xml generic function processes XML input, returning a list of XML tags, attributes, and text.
The :pxml module is loaded with the form (require :pxml). Symbols naming functionality in the module are in the net.xml.parser package. Examples in this document assume (use-package :net.xml.parser) has been evaluated.
Here is a simple example:
(parse-xml "<item1><item2 att1='one'/>this is some text</item1>") -->((item1 ((item2 att1 "one")) "this is some text"))
The output format is known as LXML (Lisp XML) format.
LXML is a list representation of XML tags and content.
Each list member may be:
More on members of type # 2: if the XML tag does not have associated attributes, then the first list member will be a symbol representing the XML tag, and the other elements will represent the content, which can be a string (text content), a symbol (XML tag with no attributes or content), or list (nested XML tag with associated attributes and/or content). If there are associated attributes, then the first list member will be a list containing a symbol followed by two list members for each associated attribute; the first member is a symbol representing the attribute, and the next member is a string corresponding to the attribute value.
parse-xml is a non-validating XML parser. It will detect non-well-formed XML input. When processing valid XML input, parse-xml will optionally produce the same output as a validating parser would, including the processing of an external DTD subset and external entity declarations.
By default, parse-xml outputs a DTD parse along with the parsed XML contents. The DTD parse may be optionally suppressed. The following example shows DTD parsed output components:
(defvar *xml-example-external-url* "<!ENTITY ext1 'this is some external entity %param1;'>") (defun example-callback (var-name token &optional public) (declare (ignorable token public)) (setf var-name (uri-path var-name)) (if* (equal var-name "null") then nil else (let ((string (eval (intern var-name (find-package :user))))) (make-string-input-stream string)))) (defvar *xml-example-string* "<?xml version='1.0' encoding='utf-8'?> <!-- the following XML input is well-formed but its validity has not been checked ... --> <?piexample this is an example processing instruction tag ?> <!DOCTYPE example SYSTEM '*xml-example-external-url*' [ <!ELEMENT item1 (item2* | (item3+ , item4))> <!ELEMENT item2 ANY> <!ELEMENT item3 (#PCDATA)> <!ELEMENT item4 (#PCDATA)> <!ATTLIST item1 att1 CDATA #FIXED 'att1-default' att2 ID #REQUIRED att3 ( one | two | three ) 'one' att4 NOTATION ( four | five ) 'four' > <!ENTITY % param1 'text'> <!ENTITY nentity SYSTEM 'null' NDATA somedata> <!NOTATION notation SYSTEM 'notation-processor'> ]> <item1 att2='1'><item3>&ext1;</item3></item1>") (pprint (parse-xml *xml-example-string* :external-callback 'example-callback)) --> ((:xml :version "1.0" :encoding "utf-8") (:comment " the following XML input is well-formed but may or may not be valid ") (:pi :piexample "this is an example processing instruction tag ") (:DOCTYPE :example (:[ (:ELEMENT :item1 (:choice (:* :item2) (:seq (:+ :item3) :item4))) (:ELEMENT :item2 :ANY) (:ELEMENT :item3 :PCDATA) (:ELEMENT :item4 :PCDATA) (:ATTLIST item1 (att1 :CDATA :FIXED "att1-default") (att2 :ID :REQUIRED) (att3 (:enumeration :one :two :three) "one") (att4 (:NOTATION :four :five) "four")) (:ENTITY :param1 :param "text") (:ENTITY :nentity :SYSTEM "null" :NDATA :somedata) (:NOTATION :notation :SYSTEM "notation-processor")) (:external (:ENTITY :ext1 "this is some external entity text"))) ((item1 att1 "att1-default" att2 "1" att3 "one" att4 "four") (item3 "this is some external entity text")))
Allegro CL also offers a SAX parser (described in sax.htm). There is a PXML-SAX compatibility package (see the LXML section in sax.htm).
There are :
1. parse-xml requires Modern Lisp's mixed case and
international character support
2. parse-xml and packages
3. parse-xml, the XML Namespace specification, and
packages
4.  Note that this implies that attributes and elements referenced in DTD content will be interned in the current package.
- ACL does not support 4 byte Unicode scalar values, so input containing such data will not be processed correctly. (Note, however, that parse-xml does correctly detect and process wide Unicode input.)
- An initial <?xml declaration in external entity files is skipped without a check being made to see if the <?xml declaration is itself incorrect.
*debug-xml*
and *debug-dtd*
are useful. When
not bound to nil, these variables cause lexical analysis and intermediate parsing results
to be output to *standard-output*
.Using the OASIS test suite (http://www.oasis-open.org), here are the current parse-xml results:
Arguments:
Returns a string identifying the PXML version loaded into the running Lisp. The version is typically changed when a patch with new features is provided. This function is useful to determine whether the loaded PXML module has the new features.
Arguments: input-source &key external-callback content-only general-entities parameter-entities uri-to-package
This generic function returns multiple values:
- LXML and parsed DTD output, as described above in this document.
- An association list containing the uri-to-package argument conses (if any) and conses associated with any XML Namespace packages created during the parse (see uri-to-package argument description, below).
The arguments and their effects are:
- The external-callback argument, if specified, is a function object or symbol that parse-xml will execute when encountering an external DTD subset or external entity DTD declaration. Here is an example which shows what arguments the function should expect, and the value it should return:
(defun file-callback (uri-object token &optional public) ;; the uri-object is an ACL URI object created from ;; the XML input. In this example, this function ;; assumes that all uri's will be file specifications. ;; ;; the token argument identifies what token is associated ;; with the external parse (for example :DOCTYPE for external ;; DTD subset ;; ;; the public argument contains the associated PUBLIC string, ;; when present ;; (declare (ignorable token public)) ;; an open stream is returned on success ;; a nil return value indicates that the external ;; parse should not occur ;; Note that parse-xml will close the open stream before ;; exiting (ignore-errors (open (uri-path uri-object))))
- The general-entities argument is an association list containing general entity symbol and replacement text pairs. The entity symbols should be in the keyword package. Note that this option may be useful in generating desirable parse results in situations where you do not wish to parse external entities or the external DTD subset.
- The parameter-entities argument is an association list containing parameter entity symbol and replacement text pairs. The entity symbols should be in the keyword package. Note that this option may be useful in generating desirable parse results in situations where you do not wish to parse external entities or the external DTD subset.
- The uri-to-package argument is an association list containing uri objects and package objects. Typically, the uri objects correspond to XML Namespace attribute values, and the package objects correspond to the desired package for interning symbols associated with the uri namespace. If the parser encounters an uri object not contained in this list, it will generate a new package. The first generated package will be named net.xml.namespace.0, the second will be named net.xml.namespace.1, and so on.
(parse-xml (p stream) &key external-callback content-only general-entities parameter-entities uri-to-package) (parse-xml (str string) &key external-callback content-only general-entities parameter-entities uri-to-package)
An easy way to parse a file containing XML input:
(with-open-file (p "example.xml") (parse-xml p :content-only p))
When not bound to nil, generates XML lexical state and intermediary parse result debugging output.
When not bound to nil, generates DTD lexical state and intermediary parse result debugging output.
Copyright (c) 2000, 2001 by Franz Inc. All rights reserved.
Documentation for Allegro CL version 7.0. This is the initial (unrevised) page.
Created 2001.9.12.
|
Allegro CL version 8.0 Minimally revised from 7.0. |


Indonesia plans to cut corporate tax rate in stages to reach 20% starting 2023 — finmin
by ReutersJAKARTA (Nov 22): Indonesia's finance minister said on Friday the government would submit to parliament a bill on tax reform next month, proposing to cut the corporate tax rate to 22% in 2021-2022 and 20% starting 2023, from 25% currently.
Sri Mulyani Indrawati told reporters the corporate tax rate for publicly listed companies meeting certain criteria would also be trimmed to 19% in 2021-2022 and 17% from 2023. Companies with at least 40% of their shares sold to the public in the Indonesia Stock Exchange currently pay a 20% tax on profits.


6 instantiations of SSHConnectionInfo
System.Management.Automation (6)
engine\remoting\commands\newrunspacecommand.cs (2)
1090
var sshConnectionInfo = new
SSHConnectionInfo
(
1117
var sshConnectionInfo = new
SSHConnectionInfo
(
engine\remoting\commands\PSRemotingCmdlet.cs (2)
1465
var sshConnectionInfo = new
SSHConnectionInfo
(userName, host, KeyFilePath, port, Subsystem, ConnectingTimeout);
1483
var sshConnectionInfo = new
SSHConnectionInfo
(
engine\remoting\commands\PushRunspaceCommand.cs (1)
1265
var sshConnectionInfo = new
SSHConnectionInfo
(userName, host, KeyFilePath, port, Subsystem, ConnectingTimeout);
engine\remoting\common\RunspaceConnectionInfo.cs (1)
2107
SSHConnectionInfo newCopy = new
SSHConnectionInfo
();
14 references to SSHConnectionInfo
System.Management.Automation (14)
engine\hostifaces\ConnectionFactory.cs (1)
545
connectionInfo is not
SSHConnectionInfo
&&
engine\hostifaces\HostUtilities.cs (2)
692
SSHConnectionInfo
sshConnectionInfo = runspace.ConnectionInfo as
SSHConnectionInfo
;
engine\remoting\client\remoterunspace.cs (1)
957
else if (_connectionInfo is
SSHConnectionInfo
)
engine\remoting\client\remoterunspaceinfo.cs (2)
295
case
SSHConnectionInfo
_:
325
case
SSHConnectionInfo
_:
engine\remoting\commands\newrunspacecommand.cs (2)
1090
var
sshConnectionInfo = new SSHConnectionInfo(
1117
var
sshConnectionInfo = new SSHConnectionInfo(
engine\remoting\commands\PSRemotingCmdlet.cs (2)
1465
var
sshConnectionInfo = new SSHConnectionInfo(userName, host, KeyFilePath, port, Subsystem, ConnectingTimeout);
1483
var
sshConnectionInfo = new SSHConnectionInfo(
engine\remoting\commands\PushRunspaceCommand.cs (1)
1265
var
sshConnectionInfo = new SSHConnectionInfo(userName, host, KeyFilePath, port, Subsystem, ConnectingTimeout);
engine\remoting\common\RunspaceConnectionInfo.cs (1)
2107
SSHConnectionInfo
newCopy = new SSHConnectionInfo();
engine\remoting\fanin\OutOfProcTransportManager.cs (2)
1589
private readonly
SSHConnectionInfo
_connectionInfo;
1604
SSHConnectionInfo
connectionInfo,


ML App
Restaurant Review Classifier
Results for Comment
{% if prediction == 1%}
Thank you for your valuable feedback!! Please comeback again, have a nice day :-)
{% elif prediction == 0%}
We extremely regret the inconvenience caused....We will rectify it..Have a nice day :-)
{% endif %}


Simple Static Blogging Engine in Python
A static site generator is usually a program for taking some kind of text input, and converting it into HTML files which can be used to make a website. I decided I wanted to use one to create my blog. It seems like there are thousands of them available, and I'm bad at making decisions. So obviously, I just went ahead and made my own! My requirements are simple - I just want to be able to write posts in Markdown, and have them rendered to static HTML files suitable for hosting on Github Pages, or anywhere else I might want to put them. The other reason I made my own is that I hate reading documentation 😂.
I chose to write this project in Python, since that's what I'm most comfortable with (I'll leave the x86 assembly rewrite for another project...). This certainly isn't the best code I've ever written, but I'm mainly just publising it to show how easy it can be to get a simple project up-and-running with Python. The main structure of the project looks like this:
l4ur3n.github.io/
posts/
2017-11-30-hello-world.md
2017-12-01-simple-blogging-engine.md
blog/
hello-world.html # generated
simple-blogging-engine.html # generated
static/
main.css
template.html
index.html # generated
render.py
posts/
is where I can write posts in Markdown. Note that the date is embedded into the filename, along with
the "slug". template.html
contains the main web
design for the site, which I also made from scratch.
Here's the main code (I put it in a gist in case I update the code in the repo later):
When I run ./render.py
, the first thing it does is iterate through all the Markdown files in the posts/
directory using the glob module. As the documentation says, this
module is for "Unix style pathname pattern expansion". That might sound complicated, but it's really quite
simple once you get used to it. In my code, I use glob("posts/*.md")
. This means "Find all files in the
posts/
directory which end in .md
" - the star character effectively means "any letters can go here".
Then, for each file, it parses the file name using some really horrible code in order to extract the date and
slug information from it. Then it reads the file, extracts the title, and then runs it through the
mistune Python module. This renders the markdown markup to an HTML
file (using the template I made) and puts it in the blog/
directory.
Finally, the index.html
page is generated, which will contain links to each individual blog post. This is the
page that visitors should see when they first visit the blog.
As you might have noticed by now, you are currently reading a blog post which was created with the code above! You can see the current status of the code here: https://github.com/l4ur3n/l4ur3n.github.io
Thanks for reading my first blog post! If you have any feedback, you can open a github issue or contact me on twitter.


Early forms of online Communications Tools
Online Communication In the 1960’s
Time Sharing was first developed in the early 1960's to allow many users to share a computer and its resources simultaneously. An example of this would be a mainframe computer that has many users signed in to it. A time sharing PC System were developed to provide an interactive way to use a PC for multiple users while only using that one CPU of the Mainframe.
The time sharing system provides the direct access to a large number of users where CPU time is divided among all the users on scheduled basis. The OS allocates a set of time to each user. When this time is expired, it passes control to the next user on the system. The time allowed is extremely small and the users are given the impression that they each have their own CPU and they are the sole owner of the CPU. This short period of time during that a user gets attention of the CPU; is known as a time slice or a quantum.
Few people realize the first computers were developed in the early 1900s, but computer networking didn’t become publicly available until around 1961. With the innovation of computer networking, on-line communication was born. This is where 2 or more computers could communicate from far distances (or short) via a Computer Network.
Compatible Time-Sharing Systems, 1961
The first form of communication using a computer was done by using The Compatible Time-Sharing System (CTSS). It was developed at MIT’s Computation Center. It was an OS which let several users share one mainframe computer and its resources.
The increasing number of users needing access to computers in the early 1960s leads to experiments in timesharing computer systems. Timesharing systems can support many users – sometimes hundreds – by sharing the computer with each user.
CTSS used a modified IBM 7090 mainframe computer that had two 32,768 (32K) 36-bit-word banks of core memory instead of the normal one. One bank was reserved for the time-sharing supervisory program, the other for user programs.
File systems Explained: Read-only class 2 differed in that the user couldn't change the mode of these files. Files could also be linked from other directories than the user's directory.
CTSS was pre-email, and pre-internet, it included user to user communication functionality which is similar to email. From this Computer Networking was established.
CompuServe, 1969
Next came CompuServe. In 1969 CompuServe was the first major commercial online service in the US. This was a vast network with various resources that you could connect too.
Founded in 1969 as a computer time-sharing service, Columbus, Ohio-based CompuServe drove the initial emergence of the on-line service industry. In 1979, CompuServe became the first service to offer electronic mail capabilities and technical support to personal computer users.
This service had official chat rooms, discussion boards, and electronic mail. Of course, like all technology it died out due to advancements more specifically the establishment and growth of the internet.
CompuServe was also a world leader in other commercial services. One of these was the Financial Services group, which collected and consolidated financial data from myriad data feeds, including CompuStat, Disclosure, I/B/E/S as well as the price/quote feeds from the major exchanges. CompuServe developed extensive screening and reporting tools that were used by many investment banks on Wall Street.


Hi, everyone. tonight we will talk about some scenarios which "I am used to it". It means that I did not feel it's wrong or abnormal, and even more i did feel it's right. Something that I never ask "why".
below it's the list about those scenarios.
-
topless
There are two photos:
- Marriage: Do you believe in "one wife and one husband"?
- Punishment: What do you think about teachers and parents beat children?
- Tax and healthcare: Should we pay tax? should the "National Health Insurance" exist?
- School: Children should attend to the school, no matter it's good or not for them.
- Military service: Who should serve the country?
- Nice girls and bad boys: girl should be nice and quiet, boys should be aggresive and strong.
- Cigarette and Pixelization(Mosaic): Censor the anime which has the smoking scene.
- Bargin: Bargain for everything.
- Red Light: Right turn on a red light.
Maybe you have the same feeling or you totally have differnet opinion about these. You are welcome to share your personal experience with us. please give your own opinion about these questions. Also, do you know something else that people are used to it, but actually it should be challenged?


--- layout: post title: Teams Do Four Things date: '2015-12-22T16:47:15-05:00' tags: [] tumblr_url: http://timothymorton.com/post/135733065583/teams-do-four-things ---
Recently there’s been a lot of hand-wringing over programmer’s oaths, user needs, and what the hell we’re doing as a profession. Eric Leong chimed in with an interesting breakdown of “product developers” and “technical developers”.
But let’s forget about individuals for a minute. Let’s talk about teams. A team might be an entire startup, or a division of a company, or a product team, but it includes all of the people responsible for delivering a software product.
The team has to hit four goals:
Everybody’s gotta eat.
Kathy Sierra has a whole book arguing that this is the most important piece of the puzzle.
Software conferences focus on this goal - creating things that work well and look beautiful.
Hiring, diversity, education, mentoring, development process, management, politics - all of the the things that keep the people working smoothly together.
–
In an ideal situation, these goals naturally flow into one another. The team has great people, an effective process, and works well together. They build a product that’s “high quality” to them - whether that means clean code, beautiful design, lots of features, or anything. Their users appreciate that high quality product, because their needs match what the team is delivering. Then the users shower them with money, since the users happen to be rich.
In the real world, there’s friction between these steps. Make an extra buck by upselling your users with features they don’t need. Save your users time with a feature delivered today, but at the price of technical debt. Deliver a high-quality product on time, but burn out your team in the process. Be a great place to work, until the company goes under.
So it’s all about tradeoffs and focus, not oaths and absolutes.


Not dating Businessman, But Her List is High-End
by JhansiAdah Sharma has been that actress who has been doing films in multiple languages including Telugu and Hindi, but uck seems to be hiding from her. Her last release ‘Kalki’ with senior hero Rajasekhar bombed big time.
There was a rumor that the milky beauty has been dating a businessman. Giving clarity on the rumor, Adah Sharma who seems to be surprised asked who that businessman was. She said that she was very much single.
If one looks at her priority list for a prospective husband, it’s better not to ask her. She needs a man who can make perfect round dosas with the best chutney.
There is one more. He should do backflips. This one seems to be an unconventional demand for a guy who would make her husband. Coming to her films, the actress needs a solid role to make her presence felt.


Select your nickname. If empty, your score will be saved as anonymous.
Shields (Pres B to activate):
Tweet
by CukYna, Inc. (Chipso & Sophyx)


First, the basics.
Headings set your default page size
Add your four mochi images from your tutorial here.^^^^^
Unordered List
Ordered List
Sometimes, you need to draw attention to a particular word or phrase.
When attentiona is important strong lettering is sometimes needed
Soft line breaks can't wrap anything. Neither can image tags, or hard lines.
Add a hard line under here.
This page probably doesn't look great - we'll learn how to hook it to CSS next week.


{% extends "layout.html" %} {% block page_title %} Help with your application {% endblock %} {% block content %} {% include "../includes/phase_banner_alpha.html" %} Help with your application It can help to have someone with you when you fill in this application. Is someone helping you to fill out this application? Yes No The name of the person helping you How you know them Why they're helping you {% include "../includes/help.html" %} {% endblock %}
It can help to have someone with you when you fill in this application.


We help companies build great products by using the latest proven technologies available. Are you having a great idea and need some help to implement it? Are you looking for software expertise? Searching for a solution to a complex problem? Contact us, most probably we can help.
Recently, we've started filming events from in the air. Need someone to film your great event, your sport activities, your wedding? Contact us, we'd love to film and make a compilation video. The sky is really the limit.
You can have a sneakpeak at our
You like the photos on this website? Need some photos for a magazine, product placement or just need some beautiful images that show a nice athmosphere? Contact us, maybe we can help.
He likes coding, simplifying things, flying with quadcopters, aerial filming and making movies.
She like photos, decoration and making things look more beautiful. Think we can help you out with something?
Contact us, and we'll see what we can do:


Coronaviruses are a type of virus.
There are many different kinds, and some cause disease.
A newly identified coronavirus, SARS-CoV-2, has caused a worldwide pandemic of respiratory illness, called COVID-19.
How does the new Coronavirus spread ?
As of now, researchers know that the new coronavirus is spread through droplets released into the air when an infected person coughs or sneezes.
The droplets generally do not travel more than a few feet, and they fall to the ground (or onto surfaces) in a few seconds — this is why social and physical distancing is effective in preventing the spread.


Tyler Haas
Front End EngineerExperiences
PresentNov 2017
Front End Engineer
O.C. Tanner Salt Lake City, UT- Increased the reliability of our existing legacy applications through the implementation of testing with headless chrome.
- Increased SOC 2 Compliance by moving all of our applications from the Heroku platform to Docker and Kubernetes.
- Improved mobile friendliness of our client facing applications resulting in $6 Million in increased revenue.
- Improved level of automation within our Yearbook product.
- Allowed for better business decisions to be made through the implementation of A/B testing.
Nov 2017Feb 2017
Software Engineer
Object Computing Inc. St. Louis, MO- Setup Developer Operations on a greenfield project for a Fortune 100 Company.
- Established testing practices and requirements for our greenfield project.
- Decreased the time to effectiveness for developers coming into our project through the use of proper documentation.
- Established working relationship with our client and provided demo's and status updates to them of ongoing work.
Feb 2017Mar 2016
Front End Engineer
Maritz Motivation Solutions St. Louis, MO- Increased the reusability of our client side code through the creation of custom web components.
- Reduced the cost of creating a new program through the creation of an program creation tool.
- Generated revenue through the creation of custom made incentive programs for clients.
Mar 2016Dec 2015
Lead Developer
Haas Development Ogden, UT- Built static marketing websites for several businesses in the area increasing sales by an average of 5%.
Dec 2015Nov 2015
Web Page Editor
Insight Global Salt Lake City, UT- Upgraded the look of OSHA's internal chemical reference resource based on the Bootstrap CSS framework and custom CSS.
Selected Projects
2018
Auto Invite
O.C. Tanner- Background: Our Yearbook product was originally designed so that we would send an email to an employees manager upon their work anniversary. The manager would then select individuals to comment in their yearbook and invite them to do so.
- Solution: I implemented a more automated solution that would analyze each companies organization and automatically send an email invite to those individuals that are a part of the individuals team as part of a nightly batch job. This was very well received by our clients as it took a lot of the manual work off of the managers within our clients organizations.
2017
Monsanto Product to Market Decision Tool
Object Computing Inc.- Background: Monsanto was in need of some software that allowed the growers within their research and development team to record their research trial results and present them to stake holders within a product advancement meeting.
- Solution: Our team created an application built on React/Redux, Node.js and PostgreSQL that filled this need. It was centered around data analysis that would recommend an advancement decision. Another key feature we built was the ability to upload excel files and have the data uploaded be presented in various different data visualizations that we presented through the User Interface.
2016
Incentive Program Configurator
Maritz Motivation Solutions- Background: Our business was built around allowing our clients to conduct different incentive programs to promote a certain outcome for their business. Each incentive program had to go through custom development which was very expensive from a program setup perspective.
- Solution: I built an application on top of the Angular Framework that guided the user through the process of creating a new incentive program. This allowed us to greatly decrease the setup cost of a new program increasing the number of sales we were able to close with our clients.