text:
Using `cliquematch` in R
================

While [`cliquematch`](https://github.com/ahgamut/cliquematch) is a
Python package, it can also be called from R by using
[`reticulate`](https://rstudio.github.io/reticulate/). This document
provides R snippets similar to the Python snippets in the `cliquematch`
[documentation](https://cliquematch.readthedocs.io/en/stable/user.html).

We can set up our python environment from within RStudio by loading
`reticulate` and selecting the python interpreter to use. I use the
[`use_condaenv`](https://rstudio.github.io/reticulate/reference/use_python.html)
function select a Python interpreter, but you can use `use_python` as
well.

``` r
library(reticulate)
use_condaenv(condaenv = "cm-dev")
# make sure you have installed cliquematch in python
cliquematch = import("cliquematch")
```

## Finding a maximum clique

Load a graph from a file:
[cond-mat-2003.mtx](https://sparse.tamu.edu/Newman/cond-mat-2003) and
find a maximum clique.

``` r
G = cliquematch$Graph$from_file("./cond-mat-2003.mtx")
print(G)
```

    ## cliquematch.core.Graph(n_vertices=31163,n_edges=120029,search_done=True)

We can also load a `Graph` using an adjacency matrix
(`Graph$from_adj_matrix`), an adjacency list (`Graph$from_adj_list`), or
a list of edges (`Graph$from_edgelist`). Once the `Graph` object has
been loaded, we can provide various parameters to search for a clique
with `Graph$get_max_clique`:

``` r
answer = G$get_max_clique(lower_bound=1L,upper_bound=1729L,
                          time_limit=100, use_heuristic=T,
                          use_dfs=T, continue_search=F)
print(answer)
```

    ##  [1]  9986  9987 10066 10068 10071 10072 10074 10076 10077 10078 10079 10080
    ## [13] 10081 10082 10083 10085 10287 10902 10903 10904 10905 10906 10907 10908
    ## [25] 10909

  - A `lower_bound` and an `upper_bound` can be set for the size for
    clique.
  - A `time_limit` can be set for the clique search. If time limits are
    not needed, set `0` as the limit.
  - The `continue_search` parameter can be set to `TRUE` if the clique
    search terminated due to a time limit earlier.
  - In case the graph is very large, to get a large clique quickly via
    aheuristic method, `use_heuristic` can be set to `True`, and
    `use_dfs` can be set to `False` to skip the depth-first search.

### Continuing an interrupted clique search

``` r
while (!G$search_done) {
    answer = G$get_max_clique(lower_bound=1L,upper_bound=1729L,
                              time_limit=100, use_heuristic=T,
                              use_dfs=T, continue_search=T)
    # process answer if needed
}
print(answer)
```

    ##  [1]  9986  9987 10066 10068 10071 10072 10074 10076 10077 10078 10079 10080
    ## [13] 10081 10082 10083 10085 10287 10902 10903 10904 10905 10906 10907 10908
    ## [25] 10909

## Clique enumeration

To obtain all cliques of a particular size: use the `all_cliques`
method. Use
[`iterate`](https://rstudio.github.io/reticulate/reference/iterate.html)
or
[`iter_next`](https://rstudio.github.io/reticulate/reference/iterate.html)
to view the cliques one by one:

``` r
cliques = G$all_cliques(size = 25L)
# iterate(cliques, f = print)
clq = iter_next(cliques, completed = NULL)
i = 0
while(!is.null(clq))
{

    print(clq)
    clq = iter_next(cliques, completed = NULL)
    i = i + 1
}
```

    ##  [1]  9986  9987 10066 10068 10071 10072 10074 10076 10077 10078 10079 10080
    ## [13] 10081 10082 10083 10085 10287 10902 10903 10904 10905 10906 10907 10908
    ## [25] 10909

Thus the `cond-mat-2003` graph contains exactly one clique of size 25.

repository: ahgamut/cliquematch

repo_name: ahgamut/cliquematch


text:
---
title: WildFly Swarm Code Styles
lastUpdate: 2016-02-23
layout: page.jade
---

# WildFly Swarm Code Style

Currently we have code styles that can be imported for the following IDEs:

  * [Intellij](https://github.com/wildfly-swarm/wildfly-swarm-parent/blob/master/ide-configs/idea/README.md)

The above styles are an embodiment, hopefully, of the following rules:

    * Spacing/Tabs
        * Java - 4 spaces
        * XML, and other file types - 2 spaces
        * No tab characters
    * Java Imports
        * No '*' imports unless it's for static members

Here are some code examples of what the settings mean:

```java
@Annotation(param1 = "value1", param2 = "value2")
@SuppressWarnings({"ALL"})
public class Foo<T extends Bar & Abba, U> {

    public void foo(int x, int y) {
        Runnable r = () -> {
        };
        Runnable r1 = this::bar;
        for (int i = 0; i < x; i++) {
            y += (y ^ 0x123) << 2;
        }
        do {
            try (MyResource r1 = getResource(); MyResource r2 = null) {
                if (0 < x && x < 10) {
                    while (x != y) {
                        x = f(x * 3 + 5);
                    }
                } else {
                    synchronized (this) {
                        switch (e.getCode()) {
                            //...
                        }
                    }
                }
            } catch (MyException e) {
            } finally {
                int[] arr = (int[]) g(y);
                x = y >= 0 ? arr[y] : -1;
                Map<String, String> sMap = new HashMap<String, String>();
                Bar.<String, Integer>mess(null);
            }
        }
        while (true);
    }

    int[] X = new int[]{1, 3, 5, 6, 7, 87, 1213, 2};

    int[] empty = new int[]{};

    void bar() {
        {
            return;
        }
    }
}

class Bar {
    static <U, T> U mess(T t) {
        return null;
    }
}

interface Abba {
}
```

## Checkstyle Rules

These are the checkstyle rules that are currently being used

### [FileTabCharacter](http://checkstyle.sourceforge.net/config_whitespace.html#FileTabCharacter)

Checks that there are no tab characters. 'eachLine' is set to true so that every tab character found is reported, not just
the first one.

### [RegexpSingleline](http://checkstyle.sourceforge.net/config_regexp.html#RegexpSingleline)

Sets a format of `\s+$` to ensure there are no trailing spaces on lines.

### [AvoidStarImport](http://checkstyle.sourceforge.net/config_imports.html#AvoidStarImport)

Checks for import statements with the `*` notation. `allowStaticMemberImports` is set to true so that `*` is allowed in
situations such as:

```java
import static org.junit.Assert.*;
```

### [RedundantImport](http://checkstyle.sourceforge.net/config_imports.html#RedundantImport)

Checks any import statements that are not necessary for compilation, due to duplication or it being a `java.lang` class.

### [UnusedImports](http://checkstyle.sourceforge.net/config_imports.html#UnusedImports)

Checks for import statements that are no longer necessary for code compilation.

### [IllegalImport](http://checkstyle.sourceforge.net/config_imports.html#IllegalImport)

Checks for imports of illegal packages, such as `sun.*`. In our case `junit.framework` has been added as `org.junit` is the
newer package naming.

### [ModifierOrder](http://checkstyle.sourceforge.net/config_modifier.html#ModifierOrder)

Checks for modifier order to ensure it conforms with:

  1. public
  2. protected
  3. private
  4. abstract
  5. static
  6. final
  7. transient
  8. volatile
  9. synchronized
  10. native
  11. strictfp

### [RedundantModifier](http://checkstyle.sourceforge.net/config_modifier.html#RedundantModifier)

Checks for modifiers that are not necessary. For instance, fields on interfaces are automatically `public`, `static`, and `final`.

### [LeftCurly](http://checkstyle.sourceforge.net/config_blocks.html#LeftCurly)

Checks that `{` is placed at the end of the line for classes, constructors, interfaces, methods, switch statements and static
initialization blocks.

### [EmptyStatement](http://checkstyle.sourceforge.net/config_coding.html#EmptyStatement)

Looks for `;` without code prior to it.

### [EqualsHashCode](http://checkstyle.sourceforge.net/config_coding.html#EqualsHashCode)

Checks that classes overriding `equals()` also override `hashcode()`.

### [DefaultComesLast](http://checkstyle.sourceforge.net/config_coding.html#DefaultComesLast)

Ensure the `default` is after all `case` statements in a `switch`.

### [IllegalInstantiation](http://checkstyle.sourceforge.net/config_coding.html#IllegalInstantiation)

Checks for instantiations where a factory is preferred, such as `Boolean.TRUE` instead of `new Boolean(true)`.

### [MissingSwitchDefault](http://checkstyle.sourceforge.net/config_coding.html#MissingSwitchDefault)

Checks that a `switch` contains a `default`.

### [UpperEll](http://checkstyle.sourceforge.net/config_misc.html#UpperEll)

Check that constants are defined as `Long` and not `long`.

### [PackageAnnotation](http://checkstyle.sourceforge.net/config_annotation.html#PackageAnnotation)

Ensures all package annotations are in `package-info.java`

### [HideUtilityClassConstructor](http://checkstyle.sourceforge.net/config_design.html#HideUtilityClassConstructor)

Checks all utility classes, such as those with all `static` methods, don't have a public constructor.

### [MissingOverride](http://checkstyle.sourceforge.net/config_annotation.html#MissingOverride)

Ensures `java.lang.Override` is present when `{@inheritDoc}` is present.

### [CovariantEquals](http://checkstyle.sourceforge.net/config_coding.html#CovariantEquals)

Checks that a class which defines a Covariant `equals(MyClass)` method also overrides `equals(Object)` to prevent
unexpected behavior.

### [InnerTypeLast](http://checkstyle.sourceforge.net/config_design.html#InnerTypeLast)

Checks that inner classes and interfaces are specified at the bottom of the class file.

### [EqualsAvoidNull](http://checkstyle.sourceforge.net/config_coding.html#EqualsAvoidNull)

Prefers `"someValue".equals(myVar)` over `myVar.equals("someValue")`

### [ArrayTypeStyle](http://checkstyle.sourceforge.net/config_misc.html#ArrayTypeStyle)

Prefers `main(String[] args)` over `main(String args[])`

branch_name: refs/heads/master

extension: md

gha_language: CSS

license_type: permissive


text:
# Hazelcast Discovery extension

This component also contain an extension to Hazelcast to enable the vert.x cluster creation based on Kubernetes. It
lets you create Vert.x cluster on Kubernetes or in Openshift v3.

It's a Hazelcast discovery SPI implementation of Hazelcast to support Kubernetes-based discovery. This implementation
is very close to the "official" hazelcast plugin, when remove some limitations such as the Kubernetes master url, and
does not rely on DNS (but on Kubernetes service lookup), and is **specific** to vert.x.

It works as follows:

* when the discovery strategy is instantiated, it resolved the known nodes
* known nodes are found by doing a Kubernetes query: it looks for all endpoints (~services) with a specific label
(`vertx-cluster`=`true`). The query is made on the label name and label value.
* when discovery by label name and label value fails, the fallback is looking for all endpoints (and nodes) in the defined Kubernetes namespace

By default, it uses the port 5701 to connected. If the endpoints defines the `hazelcast-service-port`, the indicated
value is used.

## Using the Hazelcast discovery extension

First you need to add this component to your fat jar (or classpath). If you use Maven, it can be done by adding the
following dependencies:

```
<dependency>
  <groupId>io.vertx</groupId>
  <artifactId>vertx-discovery-bridge-kubernetes</artifactId>
  <version>THE_LAST_VERSION</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.21</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-simple</artifactId>
  <version>1.7.21</version>
</dependency>
```

Then, you need a specific `cluster.xml` with the following content:

```
<?xml version="1.0" encoding="UTF-8"?>
<hazelcast xsi:schemaLocation="http://www.hazelcast.com/schema/config hazelcast-config-3.6.xsd"
           xmlns="http://www.hazelcast.com/schema/config"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <properties>
    <property name="hazelcast.memcache.enabled">false</property>
    <property name="hazelcast.rest.enabled">false</property>
    <property name="hazelcast.wait.seconds.before.join">0</property>
    <property name="hazelcast.logging.type">jdk</property>

    <property name="hazelcast.health.monitoring.delay.seconds">2</property>

    <property name="hazelcast.max.no.heartbeat.seconds">5</property>
    <property name="hazelcast.max.no.master.confirmation.seconds">10</property>
    <property name="hazelcast.master.confirmation.interval.seconds">10</property>
    <property name="hazelcast.member.list.publish.interval.seconds">10</property>
    <property name="hazelcast.connection.monitor.interval">10</property>
    <property name="hazelcast.connection.monitor.max.faults">2</property>
    <property name="hazelcast.partition.migration.timeout">10</property>
    <property name="hazelcast.migration.min.delay.on.member.removed.seconds">3</property>

    <!-- at the moment the discovery needs to be activated explicitly -->
    <property name="hazelcast.discovery.enabled">true</property>

  </properties>
  <network>
    <port auto-increment="true" port-count="10000">5701</port>
    <outbound-ports>
      <ports>0</ports>
    </outbound-ports>
    <join>
      <multicast enabled="false"/>

      <tcp-ip enabled="false"/>
      <discovery-strategies>
        <discovery-strategy enabled="true"
                            class="io.vertx.servicediscovery.hazelcast.HazelcastKubernetesDiscoveryStrategy">
          <properties>
            <property name="namespace">clement-reactive-msa-demo</property>
          </properties>
        </discovery-strategy>
      </discovery-strategies>
    </join>

    <interfaces enabled="false">
      <interface>10.10.1.*</interface>
    </interfaces>
  </network>
  <partition-group enabled="false"/>
  <executor-service name="default">
    <pool-size>16</pool-size>
    <!--Queue capacity. 0 means Integer.MAX_VALUE.-->
    <queue-capacity>0</queue-capacity>
  </executor-service>
  <map name="__vertx.subs">
    <backup-count>1</backup-count>
    <time-to-live-seconds>0</time-to-live-seconds>
    <max-idle-seconds>0</max-idle-seconds>
    <max-size policy="PER_NODE">0</max-size>
    <eviction-percentage>25</eviction-percentage>
    <merge-policy>com.hazelcast.map.merge.LatestUpdateMapMergePolicy</merge-policy>
  </map>
  <semaphore name="__vertx.*">
    <initial-permits>1</initial-permits>
  </semaphore>
</hazelcast>
```

Two parts are important regarding the Kubernetes discovery:

` <property name="hazelcast.discovery.enabled">true</property>` require to enable the custom discovery

```
<discovery-strategies>
    <discovery-strategy enabled="true"
                        class="io.vertx.servicediscovery.hazelcast.HazelcastKubernetesDiscoveryStrategy">
      <properties>
        <property name="namespace">your_namespace</property>
      </properties>
    </discovery-strategy>
</discovery-strategies>
```

This enables the custom discovery and configure it. Configuration is passed as a set of properties. To check existing namespaces in Kubernetes, use: ` kubectl get namespaces`

## Configuration

Can be configured:

* `namespace` : the kubernetes namespace / project, by default it tries to read the
`KUBERNETES_NAMESPACE` and `OPENSHIFT_BUILD_NAMESPACE`
 environment variables. If none are defined, it uses `default`
* `service-label-name` : the name of the label to look for, `vertx-cluster` by default.
* `service-label-name` : the name of the label to look for, `true` by default.
* `kubernetes-master` : the url of the Kubernetes master, by default it builds the url from the
* `KUBERNETES_SERVICE_HOST` and `KUBERNETES_SERVICE_PORT`.
* `kubernetes-token` : the bearer token to use to connect to Kubernetes, it uses the content of the
 `/var/run/secrets/kubernetes.io/serviceaccount/token` file by default.

If you use Openshift and follow the service name convention, you just need to configure the `namespace`. Even this
 can be omitted if the `KUBERNETES_NAMESPACE` or `OPENSHIFT_BUILD_NAMESPACE` environment variables are set.

repository: NickSong/vertx-service-discovery

repo_name: NickSong/vertx-service-discovery


text:
## Live Object Browser
Originally published: 2004-08-18 16:22:16
Last updated: 2004-08-18 16:22:16
Author: Simon Burton

Given an object, this tool throws up a gtk tree widget that maps all the references found. It dynamically builds the tree, which means it can handle large amounts of data and circular references.

gha_language: Python

gha_license_id: MIT


text:
# Chat app 💬 using websockets (Nodejs, Express & Socket.io)

We are going to develop a chat application using Express, Websockets. Tough you can use plain websockets but we would be using a library called Socket.io - which is wrapper around Websockets, its super easy to use and provies a fallback to xhr requests until the websocket connection is established.

The frontend-ui is based on Flexbox, no external UI libraries are used, so you can modify it as per your liking.

---

## What is Websocket ?

WebSockets are an alternative to HTTP communication in Web Application, they offer full-duplex communication, that is, it is, bi-directional and that means the data can flow in both ways, so it can flow from client to the server and also from server to the client.

---

## To start setting up the project

Step 1: Clone the repo

```bash
git clone https://github.com/trulymittal/chat-socket.io.git
```

Step 2: cd into the cloned repo and run:

```bash
npm install
```

Step 3: Start the chat app (development mode)

```bash
npm run dev
```

Step 4: Start the chat app

```bash
npm start
```

## Author

- [**Truly Mittal**](https://trulymittal.com)

## Contribute

You can fork this repo and send me a PR.

## License

This project is licensed under the MIT License.

license: MIT


text:
# nvim-docker

A simple docker container for working on different nvim configs. It's useful for working on your config, or a PR, without destroying the editor that you're currently using.

```sh
./build.sh
./run.sh foo
```

This will create an untracked "foo" directory in the repo root. Inside it will contain the .local and .config data directories bound to the container. Each working directory that you create is essentially an isolated configuraton.

branch_name: refs/heads/main


text:
# libraries
The Libraries Subtree

This repository contains amongst others the following:

### Alt - A library for managing data within JavaScript applications.
See also http://alt.js.org/

Alt is a library that facilitates the managing of state within your JavaScript applications.

Its tutorial is part of our repositories, see https://github.com/goatslacker/alt-tutorial

It is modeled after flux.

*What is flux?*

Flux is an application architecture for building complex user interfaces. It eschews MVC in favor of unidirectional data flow. What this means is that data enters through a single place (your actions) and then flow outward through their state manager (the store) and finally onto the view. The view can then restart the flow by calling other actions in response to user input.

Alt is installed by means of the package.json file contained within this repository.

To install the node_modules run:
npm install

### Device -
See also

### Head - The only script in your <HEAD>.
See also http://headjs.com

### History - A minimal, functional history library for JavaScript.
See also https://github.com/reactjs/history

### Lodash - A modern JavaScript utility library delivering modularity, performance, & extras.
See also https://lodash.com/

### Pass - Hash and compare passwords with pbkdf2
See also https://github.com/visionmedia/node-pwd

### React - A JavaScript library for building user interfaces
See also https://facebook.github.io/react/

### ReactRouter

### ReactDOM

### Require - A file and module loader for JavaScript
See also http://github.com/jrburke/requirejs

## Underscore - A whole mess of useful functional programming helpers without extending any built-in objects.
See also http://underscorejs.org

repository: vanHeemstraSystems/libraries

repo_name: vanHeemstraSystems/libraries


text:
---
layout: post
title: "How to use aria2 for downloading in zypper"
date: 2013-03-19 21:40
comments: true
categories: [linux, opensuse, zypper, aria2, downloading]
---

Zypper, the great featureful package manager for opensuse uses curl for downloading as default. On the other side, aria2, is one of the best multi-threaded download manager available for *nix. Zypper has a aria2 plugin for a long time but usually not activated by default.

Let's make zypper download packages in the speed of light using aria2 :D

<!--more-->

0. First install aria2. You can install it from repo, `sudo zypper in aria2` or from [software.opensuse.org](http://software.opensuse.org/package/aria2)

0. Now we need to tell zypper (libzypp to be technically correct) to use aria2, passing ENV Variable `ZYPP_ARIA2C` is needed for this. Open `/etc/bash.bashrc` for editing.
``` sh
sudo nano -w /etc/bash.bashrc
```
0. Keep pressing `Cntrl + v` for scrolling down. At the end of the file, add this line.
``` sh
export ZYPP_ARIA2C=1
```
Save and Exit. (`Cntrl + X`, `Y`, `Enter`)
0. Now Zypper will use aria2 for downloading as root user, but when using sudo, that ENV variable will be striped. To fix this, edit `/etc/sudoers`
``` sh
sudo nano -w /etc/sudoers
```
Look for this line
``` sh
Defaults env_keep = "LANG LC_ADDRESS LC_CTYPE LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE LC_TIME LC_ALL LANGUAGE LINGUAS XDG_SESSION_COOKIE"
```
Add `ZYPP_ARIA2C` at the end of this line.
``` sh
Defaults env_keep = "LANG LC_ADDRESS LC_CTYPE LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE LC_TIME LC_ALL LANGUAGE LINGUAS XDG_SESSION_COOKIE ZYPP_ARIA2C"
```

Save and Exit.

Done. Restart terminal and try to download a package using zypper. Zypper will now use aria2. I noticed a bug though, you wont be seeing the download progress, but i can live with it, dont u ? :)

This guide is written in openSUSE 12.3 KDE, but the process will be similiar for other versions of openSUSE.

Happy Linuxing :D

repository: sarim/myblogsite

branch_name: refs/heads/source

extension: markdown

gha_language: Ruby

repo_name: sarim/myblogsite


text:
# Our-awards

# Author
[Lilibeth Langat](https://github.com/lavylipesh/Our-Awards)
# Description
This is a Python application about Awards where we are able to appreciate all the work that we have done as developers.
# Screenshot
 <img src="https://github.com/lavylipesh/Our-awards/blob/master/static/images/awardscreenshot.png" width="1000">

# Installation Instruction
* install pip
* install python3.6 ```pip install python3```
* activate the virtual environment ```python3.6 -m venv --without pip install virtual```
* pip install django==1.11

# Set-Up Instructions
* Open Terminal {Ctrl+Shift+T}

* git clone into my application: ```git clone https://github.com/lavylipesh/Our-awards.git```

* cd InstaClone

* ```code .``` or ```atom .``` based on the text editor you have.
* ```pip install -r requirements.txt```

# User stories

# Known Bugs

# Tests

# Technologies Used
* Python3.6
* Django == 1.11 **as framework for python**
* Postgresql **for database**
* Heroku **deployment**

# Contact Information
If you wish to get more information on my projects please contact me at<EMAIL_ADDRESS>
# Licence Information
[MIT LICENCE](https://github.com/lavylipesh/Our-awards/blob/master/LICENSE)
Copyright (c) 2019 **Lilibeth Langat**

repository: Ritamwaura/Our-awards

repo_name: Ritamwaura/Our-awards


text:
---
layout: post
title: "Simple XML in Java"
description: ""
category: [Java]
tags: []
---
{% include JB/setup %}

For a new project I needed to parse a prewritten xml file and extract information, instead of going to the bother of setting up a c++ xml library I decided to try out Java's built in class library for xml parsing.

First you will need to include the standard xml packages that we will use for simple xml loading:
```java
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
```

Next we want to open an xml document to read from:
```java
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse(new File("filename.xml"));
doc.getDocumentElement().normalize();
```

Next you will probably want to get all elements with a certain tag name, you can do this like so:
NodeList packageList = doc.getElementsByTagName("package"); //get all package elements

Now simply loop over all the package elemetns it found:
```java
for (int i = 0; i < packageList.getLength(); i++) {...}
```

Inside each package are subnodes so I would like to loop over them too (inside the loop above):
Node resNode = packageList.item(i);
NodeList packageDetails = resNode.getChildNodes();
```for (int ii = 0; ii < packageDetails.getLength(); ii++) { ..}```

Now I would like to print out only the nodes called name inside the package, so first check if the current node in the loop is called name:
```if (detailNode.getNodeName().equals("name")) {...}```

Now that we know this is the name node lets print the contents of the <name>contents</name>:
```System.out.println("Name of package:"+detailNode.getTextContent());```

Very simple indeed, although this is a simple example its amazing the information you can use from xml files using this simple method!


text:
![logo](./docs/logo.png)

![dependencies](https://badgen.net/david/dep/cupcakearmy/canihazusername)
![types badge](https://badgen.net/npm/types/canihazusername)
![version badge](https://badgen.net/npm/v/canihazusername)
![minzip size badge](https://badgen.net/bundlephobia/minzip/canihazusername)

Username generator. Fully typed, simple and customizable. **0 Dependencies**

The lists are taken from [this repo](https://github.com/imsky/wordlists) and automatically converted into json by `./generate/wordlist.js`

## 🕹 [Interactive Demo](https://cupcakearmy.github.io/canihazusername/)

Small website where you can see it in action and customize the output.

https://cupcakearmy.github.io/canihazusername/

## 🏗 Install

```bash
yarn add canihazusername
```

## 🚀 Quickstart

```typescript
import { generate } from 'canihazusername'

const username = generate()
```

## 🎛 Customize

You can of course customize the generated username. The default format string is `{character}_{english}`.

```typescript
import { generate } from 'canihazusername'

const username = generate('something-{character}_bot')
```

Basically you can use any string you want and everything between `{somelist}` will be replaced from a random word from the list called `somelist`.

There is a [list of available words](#-lists) that you can use.

### ⛓ Combine multiple lists

You can also combine multiple (as many as you wish) lists into the same braket with the `|` charcter.
This will build a combined list and choose at random between all those words.

```typescript
import { generate } from 'canihazusername'

const username = generate('{quantity|age|cats|}')
```

This example will choose a random word between the `quantity`, `age` and `cats` list.

### ✒ Use you own lists

You can also add your own lists or owerwrite the built in one.

```typescript
import { generate } from 'canihazusername'

const gits = ['gitlab', 'github', 'gitea']
const username = generate('{gits}', { lists: { gits } })
```

### 🔐 Reformats limit

For security reasons the default limit for the maximum reformats/insertions is set to 16.

If you use more than 16 `{}` you can increase them with the `maxReformats` option.

```typescript
import { generate } from 'canihazusername'

const username = generate('{1} {2} ... {17}', { maxReformats: 16 }) // ❌ The last one will not be replaced
const username = generate('{1} {2} ... {17}', { maxReformats: 20 }) // ✅
```

## 🗂 Lists

- age
- algorithms
- appearance
- character
- colors
- complexity
- construction
- corporate_prefixes
- emotions
- geometry
- linguistics
- materials
- music_theory
- physics
- quantity
- shape
- size
- sound
- speed
- taste
- temperature
- weather
- blockchain
- corporate
- hipster
- lorem
- reddit
- alpha
- canada
- city_states
- france
- netherlands
- switzerland
- united_states
- apple
- intel
- microsoft
- unicorns
- founders
- usa
- chicago
- newyork
- basque
- english
- french
- german
- irish
- italian
- scottish
- 3d_graphics
- 3d_printing
- accounting
- apex_predators
- architecture
- astronomy
- automobiles
- birds
- buildings
- car_parts
- cats
- cheese
- chemistry
- coding
- condiments
- containers
- corporate_job
- cotton
- data_structures
- design
- dogs
- driving
- fast_food
- filmmaking
- fish
- food
- fortifications
- fruit
- furniture
- gaming
- geography
- ghosts
- history
- houses
- infrastructure
- insurance
- linear_algebra
- machine_learning
- meat
- metals
- military_airforce
- military_army
- military_navy
- minerals
- music_instruments
- music_production
- phones
- physics_optics
- physics_units
- physics_waves
- plants
- radio
- real_estate
- screenwriting
- seasonings
- set_theory
- shopping
- spirits
- sports
- startups
- storage
- travel
- typography
- vcs
- water
- web_development
- wine
- wood
- writing
- art
- collection
- communication
- cooking
- creation
- destruction
- fire
- graphics
- look
- manipulation
- movement
- music
- programming
- thought
- web

## 🙏 Credits

- Wordlist https://github.com/imsky/wordlists
- Icons made by Smashicons from  www.flaticon.com

repository: stevenambs/canihazusername

repo_name: stevenambs/canihazusername


text:
# Pure

> Utility library for [Wren](https://munificent.github.io/wren/)

Really, I'm just implementing functions from [Underscore](http://underscorejs.org/).

### tests

```shell
$ wren test/suite.wren
```

repository: brandly/wren-pure

repo_name: brandly/wren-pure


text:
```yaml
meta:
  type: Developer Guide
title: Custom theme
description: ArcoVue provides a set of blue themes (ArcoBlue), users can customize new themes according to their own needs to meet the diverse needs of business and brand.
```

*Auto translate by google.*

ArcoDesign defines a set of default particle variables, and the theme can be customized by modifying and covering the particle variables.

## Less variable substitution

ArcoDesign uses [Less](http://lesscss.org/ "_blank") as a pre-compiled language. Through the **modifyVars** function of Less, you can easily customize the style particle variables.

Global variables can be found in `global.less (@arco-design/web-vue/es/style/theme/global.less)`.

In the component library, we have made a very detailed extraction of component style variables, which can meet the fine-grained customization of components. For example, the style variable `token.less (@arco-design/web-vue/es/button/style/token.less)` list corresponding to the `Button` component.

### Vite Configuration
Vite itself supports [Less syntax](https://vitejs.dev/guide/features.html#css-pre-processors "_blank"), users only need to pass in the Less configuration in the configuration file:

```diff
// vite.config.js
export default {
  css: {
+   preprocessorOptions: {
+     less: {
+       modifyVars: {
+         'arcoblue-6': '#f85959',
+       },
+       javascriptEnabled: true,
+     }
+   }
  },
  ...
}
```

### Webpack Configuration
When Webpack is packaged, through modifyVars of [less-loader](https://github.com/webpack-contrib/less-loader), all variables can be replaced:

```diff
// webpack.config.js
module.exports = {
  rules: [{
    test: /\.less$/,
    use: [{
      loader: 'style-loader',
    }, {
      loader: 'css-loader',
    }, {
      loader: 'less-loader',
+     options: {
+       lessOptions: {
+         modifyVars: {
+           'arcoblue-6': '#f85959',
+         },
+         javascriptEnabled: true,
+       },
+     },
    }],
    ...
  }],
  ...
}
```

repository: fanwsp/arco-design-vue

repo_name: fanwsp/arco-design-vue


text:
To contribute just:
1) Create issue. Issue should contain information about goals of your
 future changes.
2) Fork project.
3) Create branch. The name of the branch should begin with the ID of your issue.
Example: `ISSUE-205-create-new-pattern-generator`.
4) Make changes.
5) *Write tests*.
6) Make a commit. The name of the commit should begin with the ID of your issue.
Examle: `[ISSUE-205] Create new pattern generator`.
7) Push.
8) Create a pull request to the `develop` branch.

repository: QNester/methodist

repo_name: QNester/methodist


text:
---
title: How a Type System Improves your JavaScript Code
date: 2019-02-24T21:25:04.540Z
path: how-types-improve-javascript
description: Discover how a type system improves your developer workflow
tags: reason,react,javascript,typescript
---

Vanilla JavaScript is untyped by nature, some will call it “smart” because it is able to figure out what is a number or a string.

This makes it easier to run JavaScript code, it simply needs to be executed in a browser or Node.js runtime. However, its vulnerable to numerous runtime errors that can spoil your user experience.

If you’ve ever experienced the following, you would benefit from adopting a type system.

- After fetching a list of data you may find that a certain field doesn’t exist on one of the records, causing the app to crash unless explicitly handled.
- An instance of a class you imported doesn’t have a method you’re trying to invoke.
- Your IDE doesn’t know what methods and properties are available, so it cannot easily assist you with autocomplete.
- Difficulty reasoning about code, type systems at a glance make it easier to refactor

## Flow, TypeScript, or ReasonML

Let's say you have an existing codebase that you wish to make bulletproof. With respect to type errors, you could try adopting Flow or TypeScript -- they have a fairly similar syntax.

On the other hand adopting one of these in a large, existing codebase is difficult. You would have a backlog crammed with tasks relating to creating types and interfaces with code that made not have been designed in a type friendly way.

On top of all of this, Flow and TypeScript do not offer 100% type safety in their code.

Reason accomplished perfect type safety through inference, and makes annotating variables and function signatures much more straightforward.

## Simple and Clearly Contrived Examples

Consider the following code:

```reason
let add = (a, b) => a + b;
```

In basic JavaScript these arguments can be numbers or strings. In TypeScript or Flow these arguments can be annotated like so

```javascript
let add = (a: number, b: number) => a + b
```

The first code snippet knows that we are adding two int values. Not two floats nor two strings, there are different operators for those addition operations. JavaScript can hardly tell the difference between an int and a float.

Allow me now to expose this gradual typing with a contrived example.

```javascript
let add = (a: string, b: number) => a + b
add('some string', 5) // outputs: "some string5"
```

That function works! This is absolutely preposterous! Now how does Reason handle this?

```reason
let add = (a, b) => a + b;
add("some string", 5);
/*
This has type:
  string
but somewhere wanted:
  int
*/
```

This function was flawed at the implementation level. Reason has different operators for int, float, and string addition.

The purpose of this contrived example was to show that it is still very possible to have odd type "errors" even though it wont _break_ the application.

In a pure Reason program, developers will not have to deal with productions bugs that have to do with types or null values.

## Developer Experience

One of the neatest features of TypeScript is the enhancement you get in code editor suggestions & autocompletion.

This is one area where TypeScript has a leg up on Reason, because a TypeScript program doesn't need to compile perfectly in order to offer autocompletion. Reason makes you fix errors in syntax or types before it gives you helpful autosuggestion.

This is the case on VSCode, but I know many Reason developers use vim. I cannot answer for the level of support each editor has.

Even though I am a big fan of ReasonML, I have built production applications with TypeScript or Flow and I enjoy them as well. The wave behind TypeScript makes it especially good to pick up these days, considering there is plenty of writing and community support behind it.

Reason on the other hand is harder to pick up because there is comparatively less writing and content behind it. Through blog posts like this, I am hoping to change that.

If you have some interest in checking out Reason, I'd start with the [docs here](https://reasonml.github.io). Also, be sure to follow people like [@jordwalke](https://twitter.com/@jordwalke), [@jaredforsyth](https://twitter.com/@jaredforsyth), and [@sgrove](https://twitter.com/@sgrove) on twitter. They are pretty knowledgable with respect to the ReasonML/OCaml ecosystem.

If you want to how ReasonML works seamlessly with GraphQL, check out this article I wrote on [ReasonML with GraphQL, the Future of Type-Safe Web Applications](https://medium.com/open-graphql/reasonml-with-graphql-the-future-of-type-safe-web-applications-65be2e8f34c8).


text:
---
layout: post
title: Violet 1.1.0 Release
author: Jamie Mansfield
section: blog
---
Violet has been a project we have been working on for quite some time now, and we have finally made our first serious
 release: 1.1.0

Alongside this release we have made our CLI tool for installing Violet, which you can read about on our [documentation
 page](/violet/) which also came about with the 1.1.0 release.

Over our next few releases we plan to revamp Violet, and turn it into a CSS framework, that not only works for our
 website. So feel free to post as many issue as you like on our
 [GitHub](https://github.com/Lexteam/lexteam.github.io/issues) on what you want.

- Jamie


text:
# **Readme-Generator**

![GitHub License](https://img.shields.io/badge/license-MIT-blue.svg)

## **Project Title**

Ecommerce-backend

## **Repository Description**

an ecommerce website for backend that returns json

## **Application**

to showcase the backend functionality

## **Table of Contents**

- [ProjectTitle](#Project-Title)
- [Repository Description](#Repository-Description)
- [Application](#Application)
- [Table of Contents](#Table-of-Contents)
- [Installation Instruction](#Installation-Instruction)
- [Usage Information](#Usage-Information)
- [Contribution Guidelines](#Contribution-Guidelines)
- [Test Instructions](#Test-Instructions)
- [Questions](#Questions)

## Installation Instruction

npm install -> npm start
Instructions for running the program to generate a readme file in VSCODE

## Usage Information

MIT FREE FOR STUDENT TO CLONE

## License

This repository is Licensed with MIT
## Contribution

isipcasinillo

## Test Instructions

no test

## Questions

If you have any questions or bugs to report, feel free to contact the development team using this email<EMAIL_ADDRESS>Interested with our work? View our projects at https://github.com/isipcasinillo/ecommerce-backend

repository: isipcasinillo/ecommerce-backend

repo_name: isipcasinillo/ecommerce-backend


text:
# wp profile

Quickly identify what's slow with WordPress.

### EXAMPLES

    # See an overview for each stage of the load process.
    $ wp profile stage --fields=stage,time,cache_ratio
    +------------+---------+-------------+
    | stage      | time    | cache_ratio |
    +------------+---------+-------------+
    | bootstrap  | 0.7994s | 93.21%      |
    | main_query | 0.0123s | 94.29%      |
    | template   | 0.792s  | 91.23%      |
    +------------+---------+-------------+
    | total (3)  | 1.6037s | 92.91%      |
    +------------+---------+-------------+

    # Dive into hook performance for a given stage.
    $ wp profile stage bootstrap --fields=hook,time,cache_ratio --spotlight
    +--------------------------+---------+-------------+
    | hook                     | time    | cache_ratio |
    +--------------------------+---------+-------------+
    | muplugins_loaded:before  | 0.2335s | 40%         |
    | muplugins_loaded         | 0.0007s | 50%         |
    | plugins_loaded:before    | 0.2792s | 77.63%      |
    | plugins_loaded           | 0.1502s | 100%        |
    | after_setup_theme:before | 0.068s  | 100%        |
    | init                     | 0.2643s | 96.88%      |
    | wp_loaded:after          | 0.0377s |             |
    +--------------------------+---------+-------------+
    | total (7)                | 1.0335s | 77.42%      |
    +--------------------------+---------+-------------+

repository: wp-cli/handbook

gha_language: PHP

repo_name: wp-cli/handbook


text:
---
title: Fugitive Ground
description: A personal or shared experience as simple as the practice of awareness, a conversation between friends, a collective effort to shift perception, or a place and time to make art
thumbnail: assets/images/fg_thumb3.png
thumbnailAlt: A sun and ground symbol bordered by a negative and positive number one
date: 2014-08-15
tags:
  - fine art
  - post
  - featured
---

  {% image "./fg_thumb3.png", "A sun and ground symbol bordered by a negative and positive number one" %}

A symbol created for the project that represents the fugitive ground practice

Fugitive Ground is an ongoing collaboration with friends and fellow artists. The themes are centered around mindfulness, meditation, perception and art. The process of constructing print pieces, hosting workshops and developing web components provided the same kind of meditation prescribed by the project itself.

As development continues we can expect more print pieces and an evolving website. For now the website provides functionality for its contributors including general information, a mailing list, event information, and sun and moon data based on location.

An open source javascript library called SunCalc was used to generate all of the data used on the website and for print pieces. Learning how to parse this library and working with an experienced developer was very rewarding.

  {% image "./fg_phone.png", "" %}

Website phone layout

  {% image "./fg_tablet.png", "" %}

Website tablet layout

  {% image "./fg_desk.png", "" %}

Website desktop layout

  {% image "./fg_sketchbook.jpg", "" %}

Bushwick Open Studios, day of installation

  {% image "./fg_L1060122.jpg", "" %}

Bushwick Open Studios, rehursal

Collaborators include Jeff Kasper, Sophie Cooke and Amy Sinclair.

repository: andypbrowne/andypbrowne

repo_name: andypbrowne/andypbrowne


text:
### Description
Simple python package intended to be used as automated way to scrape real estate website and extract homogeneous dataset.
This currently support _immobiliare.it_, but the intent is to extend it to support _idealista.it_

### Requirements
- Python39

```
python3 -m venv venv && source venv/bin/activate && pip3 install -r requirements.txt
```

### Run
```bash
python3 setup.py install
./real_estate_it
```

### Instructions
The intent of this package is to be reusable
```python
    searcher = ImmobiliareSearch(zona="farini", min_area=60, max_area=150, min_price=200000, max_price=600000)
    imm_scraper = Immobiliare(searcher)
    houses = imm_scraper.get_all_houses()
```

### Next steps

- Extend the hous fields (number of rooms, bathrooms etc.)
- Parse the house geolocation
- Add support idealista.it

**Disclaimer**
some of the parsing logic has been extracted form: https://github.com/Stemanz/immobiscraper


text:
# CSV modlist to HTML page converter
Takes a `modlist.csv` file and outputs a `modlist.html`

`modlist.csv` is generated using [Mod Info Lister](https://minecraft.curseforge.com/projects/mod-info-lister)

[example output](example/modlist.html) using the csv used as an example for the mod

[See the example as a web page](https://hixoe.github.io/modlist_csv2html/)

# Usage

**If you don't have ruby installed, on windows:**

0. Create a new empty directory
1. Copy `modlist.csv` there
2. Download `modlist_csv2html.exe` from the build directory
3. Place the exe file in the same directory
4. Run the executable

**If you have ruby installed:**

Same steps, but with the ruby script `modlist_csv2html.rb` instead of the executable.

## Features

* Turns the mod names into links using the link provided by the mod author
* Only creates links if they're valid. (according to `/\A#{URI::ABS_URI}\z/`)
* Generates human-readable HTML so you can easily edit it
* Applies a little formatting to make the table prettier:

```CSS
table {
    font-family: 'PT Mono', monospace;
    max-width: 50%;
    margin: auto;
}
td {
    padding-left: 1ch;
    padding-right: 1ch;
    padding-bottom: 0.5ch;
}
a { text-decoration: none; }
```

### Additional Information

* Made with ruby 2.4.4
* Tested with ModInfoLister version 1.0 (SHA-1: `9c14b749087890b2d15a541c3fbbeed05e82ac5f`)
* Executable made with [OCRA](https://github.com/larsch/ocra/)


text:
# Burotel

![](https://raw.githubusercontent.com/indico/indico-plugins-cern/master/burotel/docs/burotel_screenshot.png)

**Burotel** is a CERN-specific [Indico](https://getindico.io) plugin which leverages the Room Booking system in order
to allow for the management of desks in open spaces. It is built as a thin layer on top of the original booking system,
with some additional customizations, constraints and integrations.

## Differences with base Indico

 * The unit of booking is the **desk**;
 * All Bookings have **1-day granularity** (00:00 - 23:59) and **daily** recurrence;
 * Desks in the same room have the same `building`, `floor` and `number` codes. Only the `verbose_name` differs;
 * **No user** can have **more than one booking in parallel**;
 * The **reason** field is not customizable (all bookings have `Burotel booking` as a reason);
 * The `division` field is used to filter the rooms **by experiment**;
 * Room suggestions are disabled;

### Long-term desks

![](https://raw.githubusercontent.com/indico/indico-plugins-cern/master/burotel/docs/long_term.png)

**Long-term desks** are rooms which are meant to be used for long-term bookings. They are set using the "Long-term
desk" attribute (`long-term`).

### Integration with ADaMS

Indico will automatically notify ADaMS about bookings in any rooms where the `electronic-lock` attribute set to `yes`.
This will happen on:
 * Booking creation (not pre-bookings)
 * Pre-booking confirmation
 * Booking changes (start date and length of booking)
 * Booking cancellation (or pre-booking rejection)

The synchronization with ADaMS is **immediate**.

### Auto-cancellation of Pre-bookings

Pre-bookings in rooms which have the `confirmation-by-secretariat` attribute set to `yes` will be **automatically
cancelled** unless confirmed within **3 working days** of their beginning. This will normally be done by the user,
in person, at the Experiment/Department secretariat. This features is meant to make it less probably that someone
will request a desk and then forget about it and not use it.

## CLI

The `indico burotel` command can be used to perform a series of maintenance operations:

 * **`export`** - Export desk list to a CSV file.
 * **`geocode`** - Set geographical location for all desks/buildings.
 * **`update`** - Update the Burotels from a CSV file.

repository: indico/indico-plugins-cern

repo_name: indico/indico-plugins-cern


text:
Contribution
============
#Etiquette
Contributors are welcome.

[Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) is a great article to read on things to consider.

## Submitting Helpful Issues
_Coming Soon_
## Creating Good Pull Requests
_Coming Soon_

# Development
## Setup
_Coming Soon_

## Running Tests
Tests can be run as apart of the maven life cycle
### Unit Tests
```
mvn test
```

### Integration Tests
```
mvn verify
```

### Other Tests
There are some tests that aren't included in the unit or integration tests because they are unreliable or are platform
dependant.

#### Unit
- quarantined: currently there is nothing in this suite but can be used to isolated tests from the main unit tests.
Possible reasons might be failing, unreliable, slow unit tests.

```
mvn test -DunitTestSuite=quarantined
```

#### Integration
- unix: specific tests for unix platforms
- macOsx: specific tests for Mac OSX
- windows: specific tests for Windows

```
mvn verify -DintegrationTestSuite=unix
```

repository: imaginatelabs/jleaser

repo_name: imaginatelabs/jleaser


text:
---
layout: post
title: "Daily Digest #421"
type: digest
tags:
    - daily
    - development

description: ""
publish: true
---

- [OpenSooq Android Performance Testing: Make Hard Things Easy](https://engineering.opensooq.com/opensooq-android-performance-testing-make-hard-things-easy/)
- [Understanding Supply & Demand in Ride-hailing Through the Lens of Data](https://engineering.grab.com/understanding-supply-demand-ride-hailing-data)
- [Taming Side-Effects](https://itnext.io/functional-architecture-e9031090ff18?source=rss----5b301f10ddcd---4&gi=f5f865632a25)
- [Remembering a Programming Language that Helped Shape the Digital New York Times](https://open.nytimes.com/remembering-a-programming-language-that-helped-shape-the-digital-new-york-times-cd809d707c74)

gha_language: HTML


text:
# Reducing UI clutter and cognitive load

## The philosophy
**Minimalism -** From our point of view, a great product or tool is essentially one that has a minimalistic user interface. This is not limited to digital products, but it becomes extra important for digital products, as they are often packed with tools, features, and functionalities.

With regard to both aesthetics and functionality, a minimalist product should be reduced to its necessary elements. This can be achieved by using fewer design elements, less ornamental elements in its visual design, fewer options and features, and less occupied screen space; as well as carefully breaking the interaction flows or functionalities into distinct and meaningful parts.

Thus, when designing a product, we have to keep removing elements and questioning their existence in the UI. We should always keep asking questions such as: Is this really needed? Does this really have to be there? Why? What's the trade-off if it's removed? Do we lose functionality? Do we lose usability? And so forth.
> Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.
>
> – Antoine de Saint-Exupéry

## The science
**Cognitive load –** A user interface with too many elements requires more processing from users' brains. When fewer things on the screen try to attract the user's attention, it becomes easier for the user to "consume" the UI.

This is what we mean when we use the term "cognitive load" and talk about "reducing cognitive load". In the end, our goal is for the user to spend their mental energy on the problem at hand, not at the tool they are using to solve it (our UI).
*****
## Examples

### Input fields
Whenever possible, we take care of these details in our components. For instance, in the `limel-input` components, the "Helper text" and "Character counters" get displayed only when the field is `focused`, meaning when the user is typing in the input box. Before the user interacts with the component, displaying such details is not helpful and only adds to the clutter on the screen.

<!-- <limel-example-input-field-text></limel-example-input-field-text> -->
<!--
NOTE: this example below is almost a duplicate of the example above.
Because here we need the example to have a white background due to our
lack of support for dark mode. When we have proper support
for dark mode in lime elements, this example and its CSS can be deleted.
Instead of this 👇, we can use that 👆 again. / Kia
-->
<limel-example-input-field-text-decluttering-guidelines></limel-example-input-field-text-decluttering-guidelines>

However, sometimes such design decisions depend on the context and it is only you who are designing the UI that can judge. Examples of these follow below.

### Tooltips
Tooltips are also helpful components in creating a clean UI, by hiding away supplemental
but disposable pieces of information.

Users may need such information only once (usually for the first time they
use a UI) or occasionally. Therefore instead of constantly showing them
in the user interface, a tooltip can be used to hide them away and display them once needed.
<limel-example-tooltip-declutter></limel-example-tooltip-declutter>

### Buttons
Buttons are particularly strong elements in the UI, since they are meant to perform important actions. Thus, an effective way of reducing clutter is to hide buttons that aren't useful at the moment. This most commonly applies to disabled buttons.

Disabled buttons can convey important information, but when they don't, they should be hidden. Here are some examples:

1. **When there are invalid fields, or empty required fields**
   We can anticipate that the user might try to save their changes, and showing a disabled Save button is part of telling the user that there is something they need to do before saving is possible. This should be combined with other clear visual hints on what to do, like highlighting the invalid field and displaying a validation error message.
2. **When the user has made no changes**
   This example can be divided into two groups:
   - *The user is in a distinct "flow" with discrete steps, and is prevented from continuing to the next step.* Common examples are so called "wizards". In this case, a disabled Save or Continue button should be kept visible, for the same reason as in example 1.
   - *Making and saving changes is just one of the possible "things to do" on the current page.* Examples include forms that are used both for displaying and changing information (common for configuration or settings pages), or a feed, with an input for adding new posts. In this case, a disabled Save button isn't useful. We don't even know that the user has any intention of using it. Once the user updates the information, or starts writing in the input field, it's time to display the Save button, along with any other controls that might have also been hidden.

:::note
Keep in mind that a SAVE button can be disabled but visible, to tell the
users that requirements are not met, or there are errors.

Such cases should be accompanied with other clear visual hints where the
errors or progress-blockers are located in the UI.
:::

See how Lime Elements can automatically hide buttons when they are not needed, in the "Reduce Presence" example for [limel-button](#/component/limel-button/).

repository: Lundalogik/lime-elements

branch_name: refs/heads/next

gha_language: TypeScript

gha_license_id: NOASSERTION

repo_name: Lundalogik/lime-elements


text:
# Accessible LaTex based Authoring and Presentation for Persons with Vision Impairment (ALAP - *Text to Speech Engine*)
ALAP is an accessible extension of the TeXlipse plugin for Eclipse, which provides support for LaTeX projects. ALAP comes with a fully integrated TTS(text-to-speech) engine which is highly customizable. Below is the list of main features offered:

* Enable/Disable TTS
* Set different Verbosity Levels (Word/Character)
* Increase/Decrease Speed
* Pause/Resume TTS
* Change Voice
* Comprehensive Set of Shortcut Keys
* ...and many more

"TTS" is developed using Microsoft's Speech API. This engine understands LaTeX and supports speech based creation and editing of mathematical documents. It also supports accessible debugging by assisting users with navigation through errors and narrating them to the users.

# History
ALAP version 1.0 is brought to you by the ALAP-team as a research project developed in the KADE Lab at Lahore University of Management Sciences. The ALAP-team includes : Ahtsham Manzoor, Safa Arooj, Shaban Zulfiqar, Omer Hayat, Dr. Suleman Shahid and Dr. Asim Karim.

# Technical Details
"TTS" is developed using Microsoft's Speech API (Version=<IP_ADDRESS>).

The open soruce library [MathML](https://www.w3.org/Math/whatIsMathML.html "MathML") is used to generate XML tree of error free LaTeX math equations which is further used for conversion to descprtive narration.

After converting the LaTeX mathematical commands to their appropriate description, to further refine the narration [Detex Libary](http://urchin.earth.li/~tomford/detex/ "Detex for Windows") is used for wiping the document of LaTeX tags.

Please have a look at our [contribution guide](https://github.com/alaplums/TeXlipse/blob/master/CONTRIBUTING.md "Contribution Guide") if you would like to help out.

### Run TTS
TTS employs two spearate lookup files for converting LaTeX commands and symbols to their english description. These files can be found at [LookUp Files](https://github.com/alaplums/tts/tree/master/LookupTables) and must be present in your *bin/* folder for successful run of this program.

# Resources
* [Official ALAP Website](https://alap.lums.edu.pk/ "ALAP")
* [Detailed User Guide](https://alap.lums.edu.pk/wp-content/uploads/2018/11/ALAP_UserGuide.pdf "ALAP User Guide")

repository: alaplums/tts

gha_language: C#

repo_name: alaplums/tts


text:
# Linear Regression with scikit-learn in Python

**We use the Ecommerce Customers Dataset originally contributed by Steven Rolka**

A brief introduction to Linear Regression:

- Linear regression is a statistical approach for modelling relationship between a dependent variable with a given set of independent variables.

- Linear regression is a linear model, e.g. a model that assumes a linear relationship between the input variables (x) and the single output variable (y). More specifically, that y can be calculated from a linear combination of the input variables (x).

- When there is a single input variable (x), the method is referred to as simple linear regression. When there are multiple input variables, literature from statistics often refers to the method as multiple linear regression.

- Different techniques can be used to prepare or train the linear regression equation from data, the most common of which is called Ordinary Least Squares. It is common to therefore refer to a model prepared this way as Ordinary Least Squares Linear Regression or just Least Squares Regression.

path: /Machine Learning/sklearn examples/Linear Regression/readme.md

gha_language: Jupyter Notebook


text:
# SIGNIFYD Connect extension for Magento2

## v1.0.0RC1

2015-01-01 - This is Release Candidate 1 of the new SIGNIFYD Connect extension for Magento2. It is largely based on the original Magento SIGNIFYD plugin with identical or similar functionality and configuration where possible:

* Given an SIGNIFYD API key, the extension will automatically submit all new Orders to SIGNIFYD for risk evaluation.
* Via webhooks, SIGNIFYD will send back scoring information within seconds which is displayed on the Magento2 Order Grid.
* The user may configure a score threshold to automatically  place high risk orders **On Hold** for further review.
* Customers of SIGNIFYD's Guarantee product can also receive guarantee results via webhooks which are also displayed on the Order Grid.
* Customers can configure certain actions to occur on Guarantee events such as unholding **On Hold** orders upon approval.

There are a few differences from the original plugin:

* Display of SIGNIFYD columns in the Order Grid is now controlled with Magento2's own column controls rather than from the SIGNIFYD Connect config. This applies to both scores and guarantee dispositions.
* Automatically canceling **On Hold** orders when a guarantee is declined is no longer allowed.
* The order resend functionality is temporarily unavailable, but should be online again shortly.

Contact: [Brannon Smith](mailto:brannon@signifyd.com),

SIGNIFYD Software Engineer


text:
# safe-clone-deep module for JavaScript

[![NPM version](https://badge.fury.io/js/safe-clone-deep.png)](
 https://www.npmjs.org/package/safe-clone-deep
) [![Build Status](https://travis-ci.org/tracker1/safe-clone-deep.png)](
 https://travis-ci.org/tracker1/safe-clone-deep)

This module exposes a single function that accepts an object and clones it without circular references.

## Installation

```
npm install safe-clone-deep
```

For Browser and AMD support see the `dist/` directory.

## Usage

```javascript
// browser
// var clone = Object.safeCloneDeep

// node.js
var clone = require('safe-clone-deep');

var a = {};
a.a = a;
a.b = {};
a.b.a = a;
a.b.b = a.b;
a.c = {};
a.c.b = a.b;
a.c.c = a.c;
a.x = 1;
a.b.x = 2;
a.c.x = 3;
a.d = [0,a,1,a.b,2,a.c,3];

console.log(util.inspect(clone(a), {showHidden:false,depth:4}))
clone(a)
```

result...

```
{ a: undefined,
  b: { a: undefined, b: undefined, x: 2 },
  c: { b: { a: undefined, b: undefined, x: 2 }, c: undefined, x: 3 },
  x: 1,
  d:
   [ 0,
     undefined,
     1,
     { a: undefined, b: undefined, x: 2 },
     2,
     { b: { a: undefined, b: undefined, x: 2 }, c: undefined, x: 3 },
     3 ] }
```

### Override circularValue

With the `undefined` as the default circularValue, JSON.stringify will not keep the keys, which is likely the desired result.

```
JSON.stringify(clone(a));
```

result

```
{"b":{"x":2},"c":{"b":{"x":2},"x":3},"x":1,"d":[0,null,1,{"x":2},2,{"b":{"x":2},"x":3},3]}
```

NOTE: when the circular value is in an array, `null` is used instead of `undefined`.

--

You can override the default behavior.

```javascript
clone(a,'[Circular]');
```

result...

```
{ a: '[Circular]',
  b: { a: '[Circular]', b: '[Circular]', x: 2 },
  c:
   { b: { a: '[Circular]', b: '[Circular]', x: 2 },
     c: '[Circular]',
     x: 3 },
  x: 1,
  d:
   [ 0,
     '[Circular]',
     1,
     { a: '[Circular]', b: '[Circular]', x: 2 },
     2,
     { b: { a: '[Circular]', b: '[Circular]', x: 2 },
       c: '[Circular]',
       x: 3 },
     3 ] }
```

## License

The Internet Software Consortium License (ISC)

Copyright (c) 2014, Michael J. Ryan<EMAIL_ADDRESS>
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

license: ISC

gha_language: JavaScript


text:
# Solarweave Bridge

![License](https://img.shields.io/badge/license-MIT-blue.svg)
[![Build Status](https://travis-ci.org/TheLoneRonin/SolarweaveBridge.svg?branch=master)](https://travis-ci.org/TheLoneRonin/SolarweaveBridge)
[![codecov](https://codecov.io/gh/TheLoneRonin/SolarweaveBridge/branch/master/graph/badge.svg)](https://codecov.io/gh/TheLoneRonin/SolarweaveBridge)

An easy, simple and effective way to store Solana Blocks into Arweave via command line. Solarweave's core objective is to make it as easy as possible to navigate, store and analyze blocks from Solana.

Solarweave uses extensive tag annotations in order to make it as easy as possible to navigate the database via `ArQL`. Check the **ArQL** section to learn more.

If you want to review the benchmarks for Solarweave, check out the [Benchmarks](./BENCHMARKS.md) file!

----

## Getting started

First install `solarweave` via `npm` or `yarn`

**Note that this package is not on the public npm registry and you'll have to use `npm link` or run commands from the git repository.**

```bash
npm install solarweave --global
```

*or*

```bash
yarn global add solarweave
```

You should be then able to run the `solarweave` help command which will output the following:

```bash
solarweave help

Usage: Solarweave Bridge [options] [command]

Options:
  --database [name]          the name of the database (for Arweave ArQL tags) (default: "solarweave-devnet")
  --url [RPC URL]            the Solana RPC URL to query blocks from (default: "https://devnet.solana.com")
  --credentials [file path]  specify the path to the json file containing your Arweave credentials (default: ".arweave.creds.json")
  --local                    cache locally to a JSON file instead of to Arweave (default: false)
  --localFile [file path]    if caching data locally, specify the file path (default: "solarweave.cache.json")
  --console                  do not output log data to console (default: false)
  --uncompressed             store blocks in an uncompressed format (default: false)
  --parallelize [blocks]     the amount of blocks to process at a time, 1 processes 1 block at a time, 8, 8 blocks at a time (default: "1")
  --benchmark                benchmark Solarweave and start tracking size and speed stats stored in benchmark.json (default: false)
  --noverify                 if caching to Arweave do not double check if the block was already submitted (default: false)  -h, --help                     display help for command

Commands:
  balance                    retrieve the public address and balance of your Arweave wallet
  latest                     retrieve the latest block and output the block to console
  livestream                 livestream blocks directly to your arweave database (or locally)
  cache                      retrieve all the blocks that are still available and store them in Arweave
  help [command]             display help for command
```

#### Setting credentials

In order to use the Solarweave bridge. *You must have Arweave credentials readily available with tokens*. You can store credentials in the root project directory under `.arweave.creds.json`. Or, whilst using the command line tool. You can pass in your credentials manually.

```bash
solarweave --credentials /path/to/.arweave.creds.json
```

---

## Storing Blocks to Arweave

Before attempting to store data with Solarweave. First check and make sure that you can store data into Arweave by running the `balance` command.

```bash
$ solarweave balance

Your Arweave public address is 1seRanklLU_1VTGkEk7P0xAwMJfA7owA1JHW5KyZKlY
Your Arweave balance is<PHONE_NUMBER>27
```

If you can't see your public address and balance. It means your `.arweave.creds.json` is not properly configured. Make sure to have a sufficent balance to post data too.

Furthermore, you can also run the `latest` command to make sure you have a working connection with Solana.

```bash
$ solarweave latest

Preparing to retrieve the latest block

Found Block with Parent Slot #1025206
Block Hash: 7HSFZ67NQNPDDhGGUzEgd3afVxpEoKoox9ZHuJE9u5BR
Previous Block Hash: 4Qw6EnjmXD9PJWpA2QWoZZK2zPRhbVBeyPqCsVB4epSy
```

#### Livestreaming Blocks

You can choose to start at the latest slot and start livestreaming Solana blocks to Arweave with the `livestream`. You can then query those blocks via **`ArQL`**.

```bash
$ solarweave livestream

Transmitted Solana Block to Arweave with Parent Slot #1025206
Solana Block Hash: 7HSFZ67NQNPDDhGGUzEgd3afVxpEoKoox9ZHuJE9u5BR
```

#### Caching all Blocks

If you want to start caching every block and not just new ones. You can run the `cache` command.

```bash
$ solarweave cache

Cache is at Block 1025207, latest block is 1925007

Transmitted Solana Block to Arweave with Parent Slot #1025206
Solana Block Hash: 7HSFZ67NQNPDDhGGUzEgd3afVxpEoKoox9ZHuJE9u5BR
```

**Note that both the livestream and cache command will periodically notify you which block they're at.**

----

## Additional Configuration

#### Local streaming

For testing purposes. You might want to store blocks locally. All you need to do is pass the `--local` flag to Solarweave.

```bash
$ solarweave livestream --local
```

This will start streaming blocks to a JSON file `solarweave.cache.json`. If you want to stream to a different file, use:

```bash
$ solarweave livestream --local --localFile /path/to/solarweave.cache.json
```

#### Console output

You can turn off console out put by passing the `console` flag.

```bash
$ solarweave --console
```

#### Compression

This command does not impact local files. However, when storing blocks in Arweave. If you wanted to store a raw JSON string instead of a serialized binary `flatbuffer`. You can pass the `uncompressed` flag.

```bash
$ solarweave --uncompressed
```

#### RPC URL

If you want to query blocks from a different RPC url. You can use the `url` flag.

```bash
$ solarweave --url https://devnet.solana.com
```

#### Database tag

You can change the `database` tag for `ArQL` by using the `database` flag. This will change `database` tag and can help you navigate blocks from different networks.

```bash
$ solarweave --database devnet
```

#### Increasing throughput

You can change the rate and speed at which Solarweave processes blocks by using the `--parallelize` flag. The number you specify is the number of blocks that Solarweave will process at a time. The default is 1, but say you were working with a local validator. You could easily bump it to 8 or 16.

```bash
$ solarweave --parallelize 8
```

#### Benchmarking

If you wanted to keep track of the stats for Solarweave. You can use the `--benchmark` flag. It will store in `benchmark.json` how long it took for each block to be processed as well as the final size of the block.

```bash
$ solarweave --benchmark
```

#### Double Checking

If in any case you didn't want to double check that if a block was already submitted to Arweave. You can use the `--noverify` flag.

```bash
$ solarweave --noverify
```

----

## Finding Blocks with ArQL

Each block is supplied several tags in order to help you traverse the database. The top level tags are as follows.

##### database

As mentioned in the **Additional Configuration** section. The database tag should be used to identify which chain (or archive version) of Solana you're navigating.

##### parentSlot

This is the parent slot provided by the confirmed block.

##### slot

This is the slot of the confirmed block.

##### blockhash

This is the blockhash provided by the confirmed block.

### Transaction tags

In the case you ever wanted to navigate blocks by a specific transaction, account key or signature. You absolutely can, however, transactions, account keys and signatures may need to be iterated over several indices in order to find a match. The anatomy of transaction tags are as follows.

##### signatures

Signatures are tagged in the following way:

```bash
tx-{transaction index}-signature-{signature index}
```

Where `{transaction index}` is the index of the transaction in the Block and `{signature index}` is the index of the signature in the transaction.

**Example**

```bash
tx-0-signature-0
tx-1-signature-0
tx-2-signature-2
```

##### accountKey

Account Keys are tagged in the following way:

```bash
tx-{transaction index}-accountKey-{account key index}
```

Where `{transaction index}` is the index of the transaction in the Block and `{account key index}` is the index of the account key in the transaction.

**Example**

```bash
tx-0-accountKey-0
tx-1-accountKey-0
tx-2-accountKey-2
```

##### programIdIndex

Program IDs are tagged in the following way:

```bash
tx-{transaction index}-programIdIndex-{program id}
```

Where `{transaction index}` is the index of the transaction in the Block and `{program id}` is the index of the program id in the transaction.

**Example**

```bash
tx-0-programIdIndex-0
tx-1-programIdIndex-0
tx-2-programIdIndex-2
```

#### Additional transaction tags

In the case you may need to refine your `ArQL` query. You can use the following tags to navigate Solarweave.

##### numReadonlySignedAccounts

Which is the `numReadonlySignedAccounts` of the transaction

**Example**

```bash
tx-0-numReadonlySignedAccounts
tx-1-numReadonlySignedAccounts
```

##### numReadonlyUnsignedAccounts

Which is the `numReadonlyUnsignedAccounts` of the transaction

**Example**

```bash
tx-0-numReadonlyUnsignedAccounts
tx-1-numReadonlyUnsignedAccounts
```

##### numRequiredSignatures

Which is the `numRequiredSignatures` of the transaction

**Example**

```bash
tx-0-numRequiredSignatures
tx-1-numRequiredSignatures
```

----

## License

[MIT ©](./LICENSE)

repository: forbole/SolarweaveBridge

repo_name: forbole/SolarweaveBridge


text:
# Figure, Axes and Axis

## Figure

- transparency should not be used unless you really need to as it restricts the device you can use to only PNG as well as the fonts you can use. Effectively transparency should only be used for fillbetween and possibly overlapping histograms.

## Axes and Axis

TBD:
- note that x2axis/y2axis revert to xaxis/yaxis (GLE restriction)
- cannot have xaxis off and x2axis on, same for y
- if xticks happens after grid it will disable, should use xticks! if want to change position
- ticks angle are in degrees, rotation is clockwise (e.g. 45)

gha_language: Julia


text:
#God of my father Abraham, and God of my father Isaac, Yahweh

This does not refer to different gods, but to the one God they all worship. AT: "Yahweh, who is God of my grandfather Abraham and my father Isaac"

#Yahweh, who said to me, 'Return to your country and to your kindred, and I will prosper you'

This is a quotation within a quotation. It can be stated an indirect quotation. AT: "Yahweh, you who said that I should return to my country and to my country, and that you would prosper me" (See: [[:en:ta:vol2:translate:figs_quotesinquotes]] and [[:en:ta:vol2:translate:figs_quotations]])

#and to your kindred

"and to your family"

#I will prosper you

"I will do good for you" or "I will treat you well"

#I am not worthy of all your acts of covenant faithfulness and of all the trustworthiness that you have done for your servant

The abstract nouns "faithfulness" and "trustworthiness" can be stated as "faithful" and "loyal." AT: "I do not deserve for you to remain faithful to your covenant or for you to be loyal to me, your servant" (See: [[:en:ta:vol2:translate:figs_activepassive]])

#your servant

This is a polite way of saying "me."

#now I have become two camps

Here "I have become" stands for what he now has. AT: "and now I have enough people, flocks, and possessions with me to make two camps"


text:
It's a great honor today
to share with you
The Digital Universe,
which was created for humanity
to really see where we are
in the universe.
And so I think we can roll the video that we have.
[The Himalayas.]
(Music)
The flat horizon that we've evolved with
has been a metaphor for the

infinite: unbounded resources
and unlimited capacity
for disposal of waste.
It wasn't until we really
left Earth,
got above the atmosphere
and had seen the horizon
bend back on itself,
that we could understand our planet
as a limited condition.
The Digital Universe Atlas
has been built
at the American Museum of Natural History
over the past 12 years.
We maintain that,
put that together
as a project
to really chart the universe
across all scales.
What we see here are satellites around the Earth
and the Earth in proper registration
against the universe, as we see.
NASA supported this work
12 years ago
as part of the rebuilding
of the Hayden Planetarium
so that we would share this with the world.
The Digital Universe is the basis
of our space show productions that we do --
our main space shows in the dome.
But what you see here
is the result of, actually, internships
that we hosted with Linkoping University
in Sweden.
I've had 12 students work on this
for their graduate work,
and the result has been this software called Uniview
and a company called SCISS in Sweden.
This software
allows interactive use,
so this actual flight path
and movie that we see here
was actually flown live.
I captured this live from my laptop
in a cafe called Earth Matters
on the Lower East Side of Manhattan, where I live,
and it was done
as a collaborative project
with the Rubin Museum of Himalayan Art
for an exhibit
on comparative cosmology.
And so as we move out,
we see continuously from our planet
all the way out into the realm of galaxies, as we see here,
light-travel time, giving you a sense of how far away we are.
As we move out,
the light from these distant galaxies
have taken so long,
we're essentially backing up into the past.
We back so far up
we're finally seeing a containment around us --
the afterglow of the Big Bang.
This is the WMAP
microwave background
that we see.
We'll fly outside it here, just to see this sort of containment.
If we were outside this,
it would almost be meaningless, in the sense as before time.
But this our containment of the visible universe.
We know the universe is bigger than that which we can see.
Coming back quickly,
we see here the radio sphere that we jumped out of in the beginning,
but these are positions,
the latest positions of exoplanets
that we've mapped,
and our sun here, obviously, with our own solar system.
What you're going to see -- we're going to have to jump in here pretty quickly
between several orders of magnitude
to get down to where we see the solar system --
these are the paths of
Voyager 1, Voyager 2, Pioneer 11 and Pioneer 10,
the first four spacecraft to have left the solar system.
Coming in closer,
picking up Earth,
orbit of the Moon, and we see the Earth.
This map can be updated,
and we can add in new data.
I know Dr. Carolyn Porco is the camera P.I.
for the Cassini mission.
But here we see the complex trajectory
of the Cassini mission
color coded for different mission phases,
ingeniously developed so that
45 encounters with the largest moon, Titan,
which is larger that the planet Mercury,
diverts the orbit into different parts of mission phase.
This software allows us to come close
and look at parts of this.
This software can also be networked between domes.
We have a growing user base of this,
and we network domes.
And we can network between domes and classrooms.
We're actually sharing tours of the universe
with the first sub-Saharan
planetarium in Ghana
as well as
new libraries that have been built
in the ghettos in Columbia
and a high school
in Cambodia.
And the Cambodians have
actually controlled the Hayden Planetarium from their high school.
This is an image from Saturday,
photographed by the Aqua satellite, but through the Uniview software.
So you're seeing the edge of the Earth.
This is Nepal.
This is, in fact, right here is the valley of Lhasa,
right here in Tibet.
But we can see the haze
from fires and so forth in the Ganges valley
down below in India.
This is Nepal and Tibet.
And just in closing,
I'd just like to say this beautiful world that we live on --
here we see a bit of the snow
that some of you may have had to brave in coming out --
so I'd like to just say
that what the world needs now
is a sense of being able to
look at ourselves in this much larger condition now
and a much larger sense of what home is.
Because our home is the universe,
and we are the universe, essentially.
We carry that in us.
And to be able to see our context
in this larger sense at all scales
helps us all, I think, in understanding
where we are and who we are in the universe.
Thank you.

(Applause)

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
# 积分
# Bonus Points
积分是对YOYO持有者的奖励，当您的账号持有YOYO时，积分可随时间累积。积分积累有上限，您需要手动领取积分。

Bonus Points are rewards for YOYO holders. When your account holds YOYO, Bonus Points will be accumulated over time. There is an upper limit for Bonus Points accumulated, and you have to withdraw Bonus Points manually.

## 积分用途
## Using Bonus Points

积分目前唯一用途是抵扣手续费。在支付手续费时，您可以选择通过积分进行抵扣。100积分等价值于1YOYO

At present, the only use of Bonus Points is for paying fees. You can use Bonus Points to offset fees. 100 Bonus Points can be used as 1 YOYO, under the circumstances.

## 积分获取
## Acquisition of Bonus Points

- 当账户'余额'部分拥有一定数量的YOYO时，系统会自动积累积分。

- When the “balance” of your account reaches a certain amount of YOYO, the system will automatically accumulate Bonus Points for you.

- 积分需要手动领取。 可手动将待领取积分领取至您的账户

- Bonus Points are withdrawn manually. You can manually withdraw available Bonus Points to your account.

- 积分领取速率： 当前设定每10000 YOYO 每天可领取 1 YOYO的等价值积分。

- Rate of Credit Accumulation: the current setting allows you to withdraw Bonus Points equivalent to 1 YOYO per day for every 10,000 YOYO.

## 积分租借
## Renting Bonus Points

后续会开通积分租借功能。

A Bonus Point Rental function will be enabled in the future.

## 积分赠与
## Gifting Bonus Points

目前，可在"领取积分"操作时，选择已有的联系人账号，即可将积分领取至其账号。

Currently, when implementing the “withdrawing Bonus Points” action, you are able to select the account of a contact and withdraw the Bonus Points into their accounts.


text:
# Begonia hatacoa var. meisneri (C.B.Clarke) Golding VARIETY

#### Status
ACCEPTED

#### According to
International Plant Names Index

#### Published in
Phytologia 40:19. 1978

#### Original name
Begonia rubrovenia var. meisneri C.B.Clarke

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
.BlackBerry
========

BlackBerry 10's API, in an easy to access .Net/Mono form.

Background
========

BlackBerry 10 is a great development platform, as there are few restrictions on HOW you can develop, making it easier to make great applications.

Ok, maybe one big one, there is no support for .Net/Mono.

* C/C++: [Check](http://developer.blackberry.com/native/)
* Java (Android version): [Check](http://developer.blackberry.com/android/)
* HTML5: [Check](http://developer.blackberry.com/html5/)
* Adobe Air: [Check](http://developer.blackberry.com/air/)*
* Python: [Check](http://blackberry-py.microcode.ca/)**

.Net/Mono: Missing

Luckily, a project by the name of [MonoBerry](https://github.com/roblillack/monoberry) came around that got the Mono runtime working on BlackBerry 10. As of this writing, the 0.2.0 release of MonoBerry includes support for Mono 3.2.4 which supports .Net 4.5. But it too has a problem, it doesn't work well with the .Net/Mono workflow, and expects you are on a *Nix based system. Luckily, @gatm50 produced NuGet packages and actual [Visual Studio addins](https://github.com/gatm50/MonoberryToolsForVisualStudio) to make it a little more [seamless](https://github.com/roblillack/monoberry/releases). But there is still one more issue... both developers have an interop library to access .Net/Mono features, but it barely covers BPS, let alone the many additional libraries and APIs that BlackBerry 10 supports.

That's where this comes in. Just as MonoBerry covers the Mono runtime, and gatm50 made it easier to interface with Visual Studio, this is designed to be the proper interface for a .Net/Mono application to access BlackBerry 10's internals. Will it be perfect? Probably not. Mono, OpenTK, and many others started small with barely any big-time users, but grew with time.

In addition, given that MonoBerry isn't locked to the BlackBerry 10 OS so much as it's underlying QNX kernel, MonoBerry apps should run on [QNX Car Platform](http://www.qnx.com/products/qnxcar/index.html) and maybe even BlackBerry [Project Ion](http://el.blackberry.com/project-ion) (pending actual release of API).

*Though lack of usage means they are removing support for it in 10.3.1
**Not offically supported, but offically maintained and included along with actual interfaces to use it

Usage
========

Right now, usage isn't the best.

See [Wiki](https://github.com/rcmaniac25/DotBlackBerry/wiki/Home)

Todo
========

1. Get some of the base-level APIs avaliable such as BPS and screen
2. Get OpenTK to work with MonoBerry (the avaliable versions are behind in version and don't support GLES 3.0)
3. NuGet packages APIs
4. Cascades and maybe Xamerin.Forms
5. Try to get additional languages working, such as F#
6. Improve/update Visual Studio plugin, especially reducing or eliminating initial Wizard...
7. Debugging. Not entirly sure how this would work, but it would be very useful to have.

repository: PlumpMath/DotBlackBerry

repo_name: PlumpMath/DotBlackBerry


text:
---
layout: post
title: (Researcher's Corner) ArXiv Alert
---

ArXiv is an incredible tool to get access to research papers, but it has one drawback for me: there are too much papers in it! I want to filter new ArXiv based on my research interests, so here is how I created an ArXiv Alert.

# A Python script to create an ArXiv Alert

In fact, as a researcher in Machine Learning (and working on Adversarial Examples), I usually use ArXiv to know and read new papers related to my research areas. Obviously, I can go on the website and search for papers manually, but it is easier and nicer to have an alert browsing for me on ArXiv and feeding me with relevant papers only.

You can go on the website and follow their instructions to get an alert based on authors only, but it was not completely what I was looking for. I prefered having an alert based on keywords. I did not found any way to do that via ArXiv website, so I created a Python script that can filter papers based on keywords found in the title or abstract. I also added the possibility to add specific categories (since a keyword can be used in a totally different area than the ones I am interested in) and specific authors if you want to restrict even more your query.

The script is based on what Alex Breitweiser did and posted [here](https://academia.stackexchange.com/questions/76020/subscribe-to-cross-listings-on-arxiv "Alex Breitweiser post"){:target="_blank"} and [ArXiv API](https://arxiv.org/help/api/index "ArXiv API"){:target="_blank"}.

This script outputs a html file with the list of papers, and open it automatically in a new page of your browser.
There are four different parameters you can tune to personalize your alert: categories (e.g. ["stat.ml, "cs.cv"]) should be a list of all ArXiv research areas you are interested in. Keywords (e.g. ["adversarial", "robustness"]) is also a list and contain keywords you want to find in the title or in the abstract. Authors is again a list in the same format, which allows to search for papers authored by specific researchers. Finally, max_results is a integer number tuning how many papers you want to see at most.

It is not a parameter, but do not forget to change the path! I put an absolute path, not a relative one in my code (sorry!). You just have to change the variable "my_path" (line 120).

You can download the script [here]({{ site.url }}/downloads/arxiv_alert_script.py){:target="_blank"}.

# Run you script automatically every week

Next, to run this script automatically every week, there are two solutions on Mac.

## Crontab

The first, crontab, one is easier to use, but not recommended, and you can go through permission errors when using it on a recent OS version (Mojave or Catalina). Still, here is how to run your arxiv alert script: you just have to open your Temrinal, and run the following commands:

{% highlight r %}
crontab -e
{% endhighlight %}

which opens a document where you can lists all the scripts you want to run on a timely basis. In my case, I wanted my code to run every Monday morning at 10 am. The relevant code line is then:

{% highlight r %}
0 10 * * 1 /Your/python3.7 /The/Relevant/Path/arxiv_alert_script.py
{% endhighlight %}

You can find a nice explanation on how to use crontab [here](https://www.google.com/search?q=use+crontab+mac&rlz=1C5CHFA_enFR880FR880&oq=use+crontab+mac&aqs=chrome..69i57j0l7.2654j0j7&sourceid=chrome&ie=UTF-8#kpvalbx=_szxiXpb9FZadjLsPr9qL6AE31 "Crontab explanation"){:target="_blank"}.

## Launchd

The second option is to use launchd (see [here](https://killtheyak.com/schedule-jobs-launchd/ "Launchd explanation"){:target="_blank"} for a nice introduction to launchd), which does more or less the same thing as crontab (there are some slight differences), and is the recommended way to schedule scripts on a Mac.
To use launchd, you have to create a .plist file which specify all the required information for your script to run. This .plist file should be located in your `~/Library/LaunchAgents/` folder. Mine is called `com.arxiv_alert.daemon.plist`.

This file contains the following lines (you should adapt the text in capital letters), that will make my arxiv alert script execute every monday at 9 am:

{% highlight html %}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
        <key>Label</key>
        <string>MY_PLIST_FILENAME.plist</string>
        <key>ProgramArguments</key>
        <array>
                <string>/YOUR/PYTHON/PATH</string>
                <string>arxiv_alert_script.py</string>
        </array>
        <key>StartCalendarInterval</key>
        <dict>
                <key>Hour</key>
                <integer>9</integer>
                <key>Minute</key>
                <integer>0</integer>
                <key>Weekday</key>
                <integer>1</integer>
        </dict>
        <key>UserName</key>
        <string>YOUR USER NAME</string>
        <key>WorkingDirectory</key>
        <string>THE/FOLDER/WHERE/IS/LOCATED/THE/ARXIV_ALERT/SCRIPT</string>
</dict>
</plist>
{% endhighlight %}

Then, all you have to do is to load what we have just done so that your scheduled process is taken into account by running in your Terminal:

{% highlight r %}
launchctl load ~/Library/LaunchAgents/MY_PLIST_FILENAME.plist
{% endhighlight %}

# Rendered output

The final HTML file looks like this:

And that's it! The whole thing is quite easy to do, and you obtain a nice ArXiv alert based on keywords :)


text:
[![Python: 3.4](https://img.shields.io/badge/Python-3.4-blue)](https://www.python.org/)
![GitHub repo size](https://img.shields.io/github/repo-size/AgnesePortera/BOT_Telegram)
![Telegram](https://img.shields.io/badge/Telegram-app-blue)
![GitHub](https://img.shields.io/github/license/AgnesePortera/Covid19-Maps?style=plastic)

# BOT_Telegram
Example of BOT Telegram in Python

This is a simple starting example for creating a Telegram BOT using Python.

For a correct execution it is required a previous BOT creation using [BOT Father](https://telegram.me/BotFather).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/AgnesePortera/BOT_Telegram/.
This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the
[code of conduct](https://github.com/AgnesePortera/BOT_Telegram/blob/master/CODE_OF_CONDUCT.md).

## Code of Conduct

Everyone interacting in the Notification Bot project's codebases, issue trackers, chat rooms and mailing lists is
expected to follow
the [code of conduct](https://github.com/AgnesePortera/BOT_Telegram/blob/master/CODE_OF_CONDUCT.md).

## License

This project is distributed under _MIT_ license.


text:
# Migration from Cosmos SDK 0.39 to 0.40

The Cosmos SDK has major changes coming with version 0.40. To make the process as smooth as possible in a decentralized environment, the version 0.39 - also known as launchpad - is backward compatible with the previous versions and created as a LTS (Long Term Support) release that projects might upgrade to.

The version 0.40 - also called the Stargate - changes important specification like decoding and encoding of transactions and adds among others the Inter-Blockchain Communication (IBC).

## Major code differences

There are a variety of things that have changed from 0.39 to 0.40.
On version 0.39 developer and maintainer of a blockchain are used to have the gaiad and gaiacli tools available to interact with the blockchain. On version 0.40 these have been merged together into the gaiad tool that now supports all commands.

// Version 0.4x still not publically released. Currently supported 0.39, these are preparations
// TODO: list changes in app.go, genesis, ...
...

path: /docs/Migration 0.39 to 0.40/migration.md

branch_name: refs/heads/develop


text:
spreadsheet
===
[![Build Status](https://travis-ci.org/Iwark/spreadsheet.svg?branch=master)](https://travis-ci.org/Iwark/spreadsheet)
[![Coverage Status](https://coveralls.io/repos/github/Iwark/spreadsheet/badge.svg?branch=master)](https://coveralls.io/github/Iwark/spreadsheet?branch=master)
[![GoReport](https://goreportcard.com/badge/Iwark/spreadsheet)](http://goreportcard.com/report/Iwark/spreadsheet)
[![GoDoc](https://godoc.org/github.com/Iwark/spreadsheet?status.svg)](https://godoc.org/github.com/Iwark/spreadsheet)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
![Project Status](https://img.shields.io/badge/status-beta-yellow.svg)

Package `spreadsheet` provides access to the Google Sheets API for reading and updating spreadsheets.

Any pull-request is welcome.

## Example

```go
package main

import (
	"fmt"
	"io/ioutil"

	"github.com/Iwark/spreadsheet"
	"golang.org/x/net/context"
	"golang.org/x/oauth2/google"
)

func main() {
	data, _ := ioutil.ReadFile("client_secret.json")
	conf, _ := google.JWTConfigFromJSON(data, spreadsheet.Scope)
	client := conf.Client(context.TODO())

	service := &spreadsheet.Service{Client: client}
	sheets, _ := service.Get("1mYiA2T4_QTFUkAXk0BE3u7snN2o5FgSRqxmRrn_Dzh4")
	ws, _ := sheets.Get(0)
	for _, row := range ws.Rows {
		for _, cell := range row {
			fmt.Println(cell.Content)
		}
	}

	// Update cell content
	ws.Rows[0][0].Update("hogehoge")

	// Make sure call Synchronize to reflect the changes
	ws.Synchronize()
}
```

## License

Spreadsheet is released under the MIT License.

repository: cpwc/spreadsheet

repo_name: cpwc/spreadsheet


text:
[![CircleCI](https://img.shields.io/circleci/project/github/davewasmer/find-plugins.svg?style=flat-square)](https://circleci.com/gh/davewasmer/find-plugins)
[![Dependencies](https://img.shields.io/david/davewasmer/find-plugins.svg?style=flat-square)](https://david-dm.org/davewasmer/find-plugins)
[![npm downloads](https://img.shields.io/npm/dm/find-plugins.svg?style=flat-square)](https://www.npmjs.com/package/find-plugins)
![latest version](https://img.shields.io/npm/v/find-plugins.svg?style=flat-square)

# find-plugins

A simple tool to find installed npm packages that meet certain criteria. Great for finding installed plugins or complementary packages to yours.

## Usage

#### Simple

```js
// Looks up the package.json in process.cwd, and returns any dependencies
// listed that have your package's `name` in their keywords.
plugins = findPlugins();
```

#### Custom Keyword

```js
// Same as above, but rather than using your package.json name as the keyword
// to search for, it will look for dependencies with "plugin" in their keyword
// list.
plugins = findPlugins({
    keyword: 'plugin'
});
```

#### Custom Filter

```js
// This time, the supplied filter function will be called for each dependency,
// and only those that return true will be returned in the final array.
//
// The filter function is supplied the package.json of the dependency to check.
// In this case, this will find all dependencies whose name starts with
// "my-plugin-"
plugins = findPlugins({
    filter: function(pkg) {
        return /^my-plugin-/.test(pkg.name);
    }
});
```

#### Ignore package.json dependency list

```js
// The scanAllDirs option allows you to skip loading your app's package.json
// dependency list. Instead, it will scan all directories in the node_modules
// folder, regardless of whether they are listed as dependencies or not.
plugins = findPlugins({
    scanAllDirs: true
});
```

#### Specify node_modules directory and your package.json

```js
// Got an unusual setup? Just pass in the path of the directory containing your
// dependencies, and the path to your app's package.json file. `pkg` is
// optional if you are using `scanAllDirs` and `keyword` or `filter`.
plugins = findPlugins({
    dir: path.join('..', 'foo', 'bar', 'node_modules'),
    pkg: path.join('..', 'foo', 'bar', 'package.json')
});
```

#### Sort the plugins based on "before" and "after" config in their package.json's

```js
// Each plugin can optionally include a "plugin-config" (or whatever you pass in under `configName`)
// with a "before" and/or "after" property. These can be the name of another plugin (or an array of
// other plugin names) that this plugin should come before/after. The returned array will be sorted
// according to these rules via a directed acyclic graph
plugins = findPlugins({
    sort: true,
    configName: 'plugin-config'
});
```

## Options

```js
{

  /**
   * The node_modules directory to scan for plugins
   *
   * @type {string}
   */
  dir?: string = process.cwd(),

  /**
   * The path to the package.json that lists dependencies to check for plugins
   *
   * @type {string}
   */
  pkg?: string = './package.json',

  /**
   * An array of additional paths to check as plugins
   *
   * @type {string[]}
   */
  include?: string[] = [],

  /**
   * If supplied, a package will be considered a plugin if `keyword` is present in it's package.json
   * "keywords" array
   *
   * @type {string}
   */
  keyword?: string = pkg.name,

  /**
   * If sort: true is supplied, this determines what property of the plugin's package.json to check
   * for the sort configuration (it should be an object with "before" and "after" properties which
   * are arrays of other plugins names)
   *
   * @type {boolean}
   */
  sort?: boolean = false,

  /**
   * The property on a plugin's package.json that contains sort config (an object with "before"
   * and/or "after" properties, which are the names of the plugin, or arrays of names)
   *
   * @type {string}
   */
  configName?: string = pkg.name,

  /**
   * A custom filter function that will receive the package summary and should return a boolean
   * indicating whether or not that package is a plugin.
   *
   * @type {function}
   */
  filter?: (plugin: PluginSummary) => boolean,

  /**
   * If true, the package.json list of dependencies will be ignored, and all packages found in
   * dir will be checked.
   *
   * @type {boolean}
   */
  scanAllDirs?: boolean,

  /**
   * By default, findPlugins checks only the packages listed under "dependencies" in the
   * package.json. Setting this option to true will ignore those packages listed under
   * "dependencies".
   *
   * @type {boolean}
   */
  excludeDependencies?: boolean,

  /**
   * Also check packages listed under devDependencies
   *
   * @type {boolean}
   */
  includeDev?: boolean,

  /**
   * Also check packages listed under peerDependencies
   *
   * @type {boolean}
   */
  includePeer?: boolean,

  /**
   * Also check packages listed under bundleDependencies
   *
   * @type {boolean}
   */
  includeBundle?: boolean,

  /**
   * Also check packages listed under optionalDependencies
   *
   * @type {boolean}
   */
  includeOptional?: boolean

}
```

## Returns

```js
> findPlugins();
[
    {
        dir: './node_modules/foobar',
        pkg: { name: 'foobar', version: '0.0.1', ... }
    },
    ...
]
```

repository: davewasmer/find-plugins

repo_name: davewasmer/find-plugins