text:
---
layout: post
title: Installing CUDA 7.5 with Ubuntu 16.04 or Ubuntu 14.04
published: true
comments: true
---

Hey Guys,

I have spent days if not months installing CUDA 7.0 and CUDA 7.5 in Ubuntu 14.04 and Ubuntu 16.04 over different laptops(Dell and Asus). I finally got them working. While there are numerous tutorials present over the web, most are incomplete and error prone. The difficulty comes in installing the Nvidia drivers. If one does a mistake then the system crashes(since you need Nvidia drivers for Cuda only but not for graphics display. The default settings messes the OpenGL display drivers) and you need to do a fresh install (again there are many messy ways to escape without a fresh install but lets try to make it correct from the start anyways).

Instructions on Ubuntu 16.04/14.04 after a fresh install

(1.) Install build essentials.

```sh
$ sudo apt-get install build-essential
```

(2.) Go to <https://developer.nvidia.com/cuda-downloads> and download CUDA toolkit 7.5 for Ubuntu 15.04 (No Version supports 16.04 yet) or if you are on Ubuntu 14.04, just choose that. I have tested the 64 bit version but I think the 32 bit will work too if your machine is 32 bit.

(3.) Open up a terminal and extract the separate installers via:

```sh
$ mkdir ~/Downloads/nvidia_installers;
$ cd ~/Downloads
$ ./cuda_7.5.18_linux.run -extract=~/Downloads/nvidia_installers;
```

(4.) Completely uninstall anything in the ubuntu repositories with `nvidia-*`. I used synaptic and did a purge, AKA completely uninstall programs and configuration.

```sh
$ sudo apt-get --purge remove nvidia-*
```

(5.) No need to create an xorg.conf file. If you have one, remove it (assuming you have a fresh OS install).

```sh
$ sudo rm /etc/X11/xorg.conf
```

(6.) Create the `/etc/modprobe.d/blacklist-nouveau.conf` file with the 2 following lines:

```
blacklist nouveau
options nouveau modeset=0
```

Then do a

```sh
$ sudo update-initramfs -u
```

(7.) Reboot computer. Nothing should have changed in loading up menu. You should be taken to the login screen. Once there type: Ctrl + Alt + F1, and login to your user. Keep the next commands handy in another machine since now you are in tty.

(8.) In tty:

```sh
cd ~/Downloads/nvidia_installers;
sudo service lightdm stop
```

The top line is a necessary step for installing the driver.

(9.) [For Ubuntu 14.04]

```sh
sudo ./NVIDIA-Linux-x86_64-352.39.run --no-opengl-files
```

[For Ubuntu 16.04] --> Download nvidia-367 instead of the default nvidia-352 that comes with the toolkit from here: <http://in.download.nvidia.com/XFree86/Linux-x86_64/367.27/NVIDIA-Linux-x86_64-367.27.run> then do

```
sudo ./NVIDIA-Linux-x86_64-367.27.run --no-opengl-files
```

I cannot stress how important is the opengl flag in the above command. If you miss that, either you will get stuck in "login loop" or your computer would boot with a black screen at all times.

(10.) Now install the toolkit also

```sh
sudo ./cuda-linux64-rel-6.0.37-18176142.run
sudo ./cuda-samples-linux-6.0.37-18176142.run
```

(11.) Set Environment path variables in .bashrc:

```sh
$ export PATH=/usr/local/cuda-7.5/bin:$PATH
$ export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
```

(12.) Verify the driver version:

```sh
$ cat /proc/driver/nvidia/version
My current resutls are:
NVRM version: NVIDIA UNIX x86_64 Kernel Module  367.27  Thu Jun  9 18:53:27 PDT 2016
GCC version:  gcc version 5.3.1 20160413 (Ubuntu 5.3.1-14ubuntu2.1)
```

(13.) Check CUDA driver version:

```sh
$ nvcc -V
```

(14.) At this point you can switch the lightdm back on again by doing:

```sh
$ sudo service lightdm start.
```

You are done if on Ubuntu 14.04 & go to step 17\. If on Ubuntu 16.04, the gcc version is higher than what is supported by any CUDA toolkit right now.

**READ ON FOR UBUNTU 16.04 ONLY**

(15.) Fix/break the header file that doesn't want to let us use gcc > 4.8\. All we are going to do is comment out (//) the error line that drops you out of a build.

```sh
$ sudo vim /usr/local/cuda/include/host_config.h
```

line: 115 comment out error //#error -- unsupported GNU version! gcc versions later than 4.9 are not supported!

(16.) To see if we are properly done with the installation, we need to run the samples that came along the downloaded toolkit runfile. By default it is installed in /usr/local/cuda/samples. Go there.

```sh
$ cd /usr/local/cuda/samples
$ grep -r nvidia-352 -l --null . | sudo xargs -0 sed -i 's#nvidia-352#nvidia-367#g'
```

The above command replaces all the places where sample's default nvidia-352 driver was used with nvidia-367

(17.) **BOTH 16.04 and 14.04**

```sh
$ cd /usr/local/cuda/samples/1_Utilities/deviceQuery
$ sudo make
$ ./deviceQuery
```

Something like this should show up

```sh
magneto@magneto-dell:/usr/local/cuda/samples/1_Utilities/deviceQuery$ ./deviceQuery
./deviceQuery Starting...

 CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "Quadro M1000M"
  CUDA Driver Version / Runtime Version          8.0 / 7.5
  CUDA Capability Major/Minor version number:    5.0
  Total amount of global memory:                 2002 MBytes<PHONE_NUMBER> bytes)
  ( 4) Multiprocessors, (128) CUDA Cores/MP:     512 CUDA Cores
  GPU Max Clock rate:                            1072 MHz (1.07 GHz)
  Memory Clock rate:                             2505 Mhz
  Memory Bus Width:                              128-bit
  L2 Cache Size:                                 2097152 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(65536), 2D=(65536, 65536), 3D=(4096, 4096, 4096)
  Maximum Layered 1D Texture Size, (num) layers  1D=(16384), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(16384, 16384), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  2048
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z):<PHONE_NUMBER>, 65535, 65535)
  Maximum memory pitch:<PHONE_NUMBER> bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 1 copy engine(s)
  Run time limit on kernels:                     No
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 8.0, CUDA Runtime Version = 7.5, NumDevs = 1, Device0 = Quadro M1000M
Result = PASS
```

Done!!

References:

1. <https://www.pugetsystems.com/labs/hpc/NVIDIA-CUDA-with-Ubuntu-16-04-beta-on-a-laptop-if-you-just-cannot-wait-775/>
2. <https://devtalk.nvidia.com/default/topic/878117/cuda-setup-and-installation/-solved-titan-x-for-cuda-7-5-login-loop-error-ubuntu-14-04-/>
3. <http://askubuntu.com/questions/451672/installing-and-testing-cuda-in-ubuntu-14-04>


text:
# Introduction

This program allows to retrieve some informations about scientific papers using Scopus API. Using Scopus API we can avoid the default limitations on the number of papers and on the papers informations (title, authors, affiliations, ...).

# Requiriments

To use this program we will need:
* The _Python3_ compiler version;
* The Scopus API KEY: Create a Key [here](http://dev.elsevier.com/)

# ScopusSearch

1. ScopusSearch.py: the executable
2. link_query_search.py: a library with some possible link to Scopus API, and the headers of the http requests
3. get_info_scopus.py: an auxiliary function used by ScopuSearch.py to perform more specific query
4. my_scopus.py: your API_KEY for the authentication with Scopus API

# Run the Program

Need Python3 to work correctly.
First you need to create an API_KEY, go to Elseiver Developer Portal, and after put it in the my_scopus.py file.
Open terminal and run ScopusSearch.py

license: MIT

repository: alessandrobigiotti/ScopusSearch

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: alessandrobigiotti/ScopusSearch


text:
# BOMOKO APP

> Help Congolese small-scale farmers who are unbanked to have access to affordable loans using mobile phones (USSD). Our solution is to facilitate the financial inclusion of farmers and use mobile phones to give loans to smallholder farmers. Built with: React Native, Redux, Couchbase, Docker, and NodeJs. Play store, Official website,

Additional description about the project and its features.

## Built With

- React native
- React/Redux
- Expo
- Genymotion Android Emulator
- Docker, Nodejs and Couchbase (server side)
- localStorage

## Links

[Play store](https://play.google.com/store/apps/details?id=com.wezalab.bomoko),
[Official website](http://bomoko-app.com/)

## Getting Started

In order to run locally this project type the following commands over the terminal in Linux or Mac or the Windows cmd console:

```s
$ git clone https://github.com/guillainbisimwa/bomoko-app.git
$ cd bomoko-app
$ npm install
$ expo start

```

## Author

👤 **Guillain Bisimwa**

- Github : [@guillainbisimwa](https://github.com/guillainbisimwa)
- Twitter : [@gullain_bisimwa](https://twitter.com/gullain_bisimwa)
- Linkedin : [guillain-bisimwa](https://www.linkedin.com/in/guillain-bisimwa-8a8b7a7b/)

## 🤝 Contributing

Contributions, issues, and feature requests are welcome!

Feel free to check the [issues page](https://github.com/guillainbisimwa/bomoko-app/issues).

## Show your support

Give a ⭐ if you like this project!

## 📝 License

This project is [MIT](lic.url) licensed.

repository: njokdan/bomoko-app

repo_name: njokdan/bomoko-app


text:
# CNN Sentence Classifier

# Refferences
* Convolutional Neural Networkds for Sentence Classification, Yoon Kim, EMNLP 2014

repository: daisuke-motoki/chainer-practice

gha_language: Jupyter Notebook

gha_license_id: MIT

repo_name: daisuke-motoki/chainer-practice


text:
# BitScoop Social Login Demo

This project demonstrates a simple user management system built on AWS using API Gateway, RDS, S3, VPC, and Lambda.
The application uses the BitScoop platform to streamline implementation of social login using Facebook, GitHub, Google, or Twitter.

The [tutorial](./tutorial) folder contains instructions on how to set up a copy of this project on your own.

## Quickstart: Setup & Configure

1. [Setup BitScoop & API Connections](https://github.com/bitscooplabs/bitscoop-social-login-demo/blob/master/tutorial/step-1.md)
2. [Install Dependencies](https://github.com/bitscooplabs/bitscoop-social-login-demo/blob/master/tutorial/step-2.md)
3. [Set Up Networking and Infrastructure](https://github.com/bitscooplabs/bitscoop-social-login-demo/blob/master/tutorial/step-3.md)
4. [Deploy the App](https://github.com/bitscooplabs/bitscoop-social-login-demo/blob/master/tutorial/step-4.md)

repository: barankyle/bitscoop-social-login-demo

repo_name: barankyle/bitscoop-social-login-demo


text:
# Arithmetic-Calculator
title = "Finding the Nth term with the given 1st term and common difference"
print(title[:].upper())
print('') ##############
first_term = float(input('First term = '))
nth_term = int(input('Nth term = '))
common_diff = float(input('Common Difference = '))
a_sub_n = float(first_term) + int((nth_term - 1)) * common_diff
print(f'The {round(nth_term, )}th term is {round(a_sub_n, )}')
print('') ##############
print(f'How about the sum of all terms from {round(first_term, )} to {round(a_sub_n, )}? ')
Yes_No = str(input('Do you want to continue? (Yes or No) '))
part = first_term + a_sub_n
part_whole = part / 2
answer_allsum = nth_term * part_whole
no_message = 'Okay. Just try this feature next time.'
if Yes_No == str('Yes'):
    print(f'The sum of all terms from the 1st term ({round(first_term, )}) to the {nth_term}th term ({round(a_sub_n, )}) is {round(answer_allsum)}')
else:
    print(no_message)

license: Unlicense

repository: JhonCortas/Arithmetic-Calculator

branch_name: refs/heads/main

repo_name: JhonCortas/Arithmetic-Calculator


text:
---
layout: post
title: Neutron external network with routing (no NAT)
date: '2018-01-10'
tags:
- openstack
- neutron
---

TO-DO, fix this blog post to explain "--disable-snat" that does the
same, and probably also supports FIP (I need to check)

```bash
usage: neutron router-gateway-set [-h] [--request-format {json}]
                                  [--disable-snat]
                                  [--fixed-ip
subnet_id=SUBNET,ip_address=IP_ADDR]
                                  ROUTER EXTERNAL-NETWORK

Set the external network gateway for a router.

positional arguments:
  ROUTER                ID or name of the router.
  EXTERNAL-NETWORK      ID or name of the external network for the gateway.

optional arguments:
  -h, --help            show this help message and exit
  --request-format {json}
                        DEPRECATED! Only JSON request format is supported.
  --disable-snat        Disable source NAT on the router gateway.
  --fixed-ip subnet_id=SUBNET,ip_address=IP_ADDR
                        Desired IP and/or subnet on external network:
                        subnet_id=<name_or_id>,ip_address=<ip>. You can
                        specify both of subnet_id and ip_address or specify
                        one of them as well. You can repeat this option.
```

...

In this blog post I will explain how to connect private tenant networks to
an external network without the use of NAT or DNAT (floating ips) via
a neutron router.

> With the following configuration you will have routers that don't do NAT
> on ingress or egress connections. You won't be able to use floating ips
> too, at least in the explained configuration, you could add a second external
> network and a gateway port, plus some static routes to let the router steer
> traffic over each network.

This can be done, with just one limitation, tenant networks connected in
such topology cannot have overlapping ips. And also, the upstream router(s)
must be informed about the internal networks so they can add routes themselves
to those networks. That can be done manually, or automatically by periodically
talking to the openstack API (checking the router interfaces, the subnets etc..)
but I'll skip that part in this blog post.

> We're going to assume that our external provider network is "public", with the
> subnet "public_subnet" and that the CIDR of such network is <IP_ADDRESS>/24 with
> a gateway on *<IP_ADDRESS>*. Please excuse me because I'm not using the new
> openstack commands, I can make an updated post later if somebody is interested
> in that.

# Step by step

Create the virtual router

```bash
source keystonerc_admin

neutron router-create router_test

# please note that you can manipulate static routes on that router if you need:
# neutron router-update --help
#  [--route destination=CIDR,nexthop=IP_ADDR | --no-routes]
```

Create the private network for our test, and add it to the router

```bash
neutron net-create private_test
$PRIV_NET=$(neutron net-list | awk ' /private_test/ { print $2 }')

neutron subnet-create --name private_subnet $PRIV_NET <IP_ADDRESS>/16
neutron router-interface-add router_test private_subnet
```

Create a security group, and add an instance

```bash
neutron security-group-create test
neutron security-group-rule-create test --direction ingress

nova boot --flavor m1.tiny --image cirros --nic net-id=$PRIV_NET \
          --security-group test cirros
sleep 10
nova console-log cirros
```

Please note that in the console-log you may find that everything went well...
and that the instance has an address through DHCP.

Create a port for the router on the external network, do it manually
so we can specify the exact address we want.

```bash
SUBNET_ID=$(neutron subnet-list | awk ' /public_subnet/ { print $2 }')
neutron port-create public --fixed-ip \
    subnet_id=$SUBNET_ID,ip_address=<IP_ADDRESS> ext-router-port
```

Add it to the router

```bash
PORT_ID=$(neutron port-show ext-router-port | awk '/ id / { print $4 } ')
neutron router-interface-add router_test port=$PORT_ID
````

We can test it locally (assuming our host has access to <IP_ADDRESS>)

```bash
# test local...
ip route add <IP_ADDRESS>/16 via <IP_ADDRESS>

# and assuming that our instance was created with <IP_ADDRESS>

[root@server ~(keystone_admin)]# ping <IP_ADDRESS>
PING <IP_ADDRESS> (<IP_ADDRESS>) 56(84) bytes of data.
64 bytes from <IP_ADDRESS>: icmp_seq=1 ttl=63 time=0.621 ms
64 bytes from <IP_ADDRESS>: icmp_seq=2 ttl=63 time=0.298 ms
```

Extra note, if you want to avoid issues with overlapping tenant network IPs, I
recommend you to have a look at the [subnet pool functionality of
neutron](https://docs.openstack.org/mitaka/networking-guide/config-subnet-pools.html)
which started in Kilo.

I hope you enjoyed it, and that this is helpful, let me know in the comments :)

repository: mangelajo/ajo-es

repo_name: mangelajo/ajo-es


text:
# OverReact Builder

[](#__START_EMBEDDED_README__)

OverReact components are declared using a set of "boilerplate" declarations which are
picked up by the `over_react` builder.

This builder generates code, wiring up the different pieces of component
declarations and creating typed getters/setters for props and state.

This allows boilerplate to be significantly reduced, making the code you write
much cleaner and more _grokkable_.

> Check out some [component demos] to see the builder in action.

## Wiring it all up

__Be sure to familiarize yourself with the [OverReact library] first.__

The builder wires up your factory, props class, and component class so that you don't have to!

### The generation process

> All of this generation happens "under the hood", but you can see it in action for your
own components by viewing the generated .over_react.g.dart file.

1. The builder parses files and looks for things to generate. Let's start with this component:

    ```dart
    UiFactory<FooProps> Foo = castUiFactory(_$Foo); // undefined_identifier

    mixin FooProps on UiProps {
      int foo;
    }

    class FooComponent extends UiComponent2<FooProps> {
      @override
      render() {
        // ...
      }
    }
    ```

    In [parsing/members_from_ast.dart](parsing/members_from_ast.dart), the builder identifies for top-level declarations that could be part of a component declaration:
    - `UiFactory` variables
    - Mixins that are `on UiProps` and whose names end with `Props` or `PropsMixin` (same thing for state)
    - Classes that extend directly from `UiProps` and whose names end with `Props`
    - Classes whose names end with `Component`

    Then, in, [parsing/declarations_from_members.dart](parsing/declarations_from_members.dart), it uses the names of these declarations to group them together, and determines whether those groups are actually an over_react declaration that needs code generation (vs unrelated code that happens to look similar).

    In this case:
    1. The builder identifies the compilation unit members `Foo`, `FooProps`, `FooComponent`, which all look like pieces of over_react boilerplate.
    2. The builder sees that `FooProps` meets the requirements for declaring a props mixin, and thus  can confidently proceed with code generation for it.
        - Props mixins need code generation regardless of whether they're associated with a component, since they can be declared on their own.
    3. The builder starts with the factory, and looks for other members with matching names that it could use to create a complete group that forms a class component. It finds all the pieces it needs:
        - [x] a factory: ***Foo***
        - [x] either a props mixin or a concrete props class:  ***Foo***Props
        - [ ] either a state mixin or a concrete state class (optional)
        - [x] a component class: ***Foo***Component
    2. The builder checks to see if the group is really an over_react declaration that needs code generation. It sees that the factory is referencing a generated variable (`Foo = _$Foo`) and thus can confidently say that the factory needs code generation. Because of that, it proceeds with code generation for all the members in this group.

   The builder has recognized our code as a class component that requires code generation! If it hadn't, the builder would have gone through similar logic to identify other types of declarations like function components and props map views, and perform similar code generation to wire them up.

   Next up, let's see what code generation looks like for our class component.

2. The builder generates a version of the props mixin which contains concrete
getters/setters.
    ```dart
   mixin $FooProps on FooProps {
     int get foo => props['FooProps.foo'];
     set foo(int value) => props['FooProps.foo'] = value;
   }
    ```

2. The builder creates a concrete props implementation class, which mixes in the generated props mixin:
    ```dart
    class _$$FooProps extends UiProps with FooProps, $FooProps {
      ...
    }
    ```
    This concrete class is what will be used everywhere for this component's typed props (returned from the `UiFactory`, available via `props` inside `render`).

    Note that in the above example, our component has props declared via just a props mixin, which is a shorthand syntax for when no additional props are needed from other mixins. For components with concrete props classes which mix in other props, the implementation is similar. The generated concrete props class mixes in all generated mixins corresponding to the props mixins used:

    ```dart
    // Authored code:
    UiFactory<BarProps> Bar = castUiFactory(_$Bar);
    class BarProps = UiProps with BarPropsMixin, FooProps;
    class BarComponent extends UiComponent2<BarProps> { ... }

    // Generated code:
    class _$$BarProps extends UiProps
        with
            BarPropsMixin, $BarPropsMixin,
            FooProps, $FooProps
        implements BarProps {
      ...
    }
    ```

    It also overrides stubbed out `UiProps` members, and implements a constructor that delegates to other generated subclasses: one optimized for `JsBackedMap`, and one used for all other `Map`s.
    ```dart
    class _$$FooProps extends UiProps with FooProps, $FooProps {
      factory _$$FooProps(Map backingMap) {
        if (backingMap == null || backingMap is JsBackedMap) {
          return _$$FooProps$JsMap(backingMap);
        } else {
          return _$$FooProps$PlainMap(backingMap);
        }
      }

      /// The backing props map proxied by this class.
      @override
      Map get props => _props;
      final Map _props;

      /// Let [UiProps] internals know that this class has been generated.
      @override
      bool get $isClassGenerated => true;

      /// The `ReactComponentFactory` associated with the component built by this class.
      @override
      ReactComponentFactoryProxy get componentFactory => $FooComponentFactory;
    }
    ```

    Note that the `typedPropsFactory` variable is wired up to use the props implementation
    class's constructor. This lets us get an instance of that class when we use the `props`
    getter and the `newProps()` method, and is necessary since the code we wrote
    doesn't have a proper constructor.

4. Our fully implemented component class is registered with the [react-dart] wrapper.

    ```dart
    // React component factory implementation.
    //
    // Registers component implementation and links type meta to builder factory.
    final $FooComponentFactory = registerComponent2(
      () => new _$FooComponent(),
      builderFactory: Foo,
      componentClass: FooComponent,
      isWrapper: false,
      parentType: null,
      displayName: 'Foo',
    );
    ```

5. Finally, the initializer for our factory (`_$Foo`) is generated with a function that returns a new instance of our
private props implementation. This factory is __the entry-point__ to externally consuming our
component and props class.

    ```dart
    _$$FooProps _$Foo([Map backingProps]) => backingProps == null
        ? _$$FooProps$JsMap(JsBackedMap())
        : _$$FooProps(backingProps);
    ```

## Props / State Getters and Setters

Writing a statically-typed prop / state API for React components in Dart proved to be a huge pain when we
attempted to do it from scratch.

We found that the most straightforward way to adhere to React patterns was to use `Map`s for `props` and `state`.

So we went about defining typed getters and setters on `MapView`-like classes which proxy Map key-value pairs.
However, typing these getters and setters quickly became tedious
_(especially if you need namespaced keys for platform scalability)_:

```dart
class FooProps extends UiProps {
  String get title               => props['FooProps.title'];
  set title(String value)        => props['FooProps.title'] = value;

  bool get isEnabled             => props['FooProps.isEnabled'];
  set isEnabled(bool value)      => props['FooProps.isEnabled'] = value;

  MouseEventCallback get onClick => props['FooProps.onClick'];
  set onClick(Callback value)    => props['FooProps.onClick'] = value;

  // Imagine a component with 20 of these... yuck.
}
```

With the builder, we cut down on repetition while preserving statically-typed getter and setters.

Props and state are declared using _fields_, making the actual code you write much simpler -
and much more like the React JS library intended:

```dart
mixin FooProps on UiProps {
  String title;

  bool isEnabled;

  MouseEventCallback onClick;

  // ...
}

mixin FooState on UiState {
  bool isShown;

  String currentText;

  // ...
}
```

> Check out some [component demos] for more info about using fields to define props and state values in the real world.

[OverReact library]: https://github.com/Workiva/over_react/blob/master/README.md
[annotations]: https://github.com/Workiva/over_react/blob/master/lib/src/component_declaration/annotations.dart
[component demos]: https://workiva.github.io/over_react/demos/
[react-dart]: https://github.com/cleandart/react-dart

gha_language: Dart

gha_license_id: NOASSERTION


text:
# node-milight-promise

[![Build Status](https://travis-ci.org/mwittig/node-milight-promise.svg?branch=master)](https://travis-ci.org/mwittig/node-milight-promise)
[![Coverage Status](https://coveralls.io/repos/github/mwittig/node-milight-promise/badge.svg?branch=master)](https://coveralls.io/github/mwittig/node-milight-promise?branch=master)

A node module to control Milight LED bulbs and OEM equivalents such as Rocket LED, Limitless LED Applamp,
 Easybulb, s`luce, iLight, iBulb, and Kreuzer. This library uses Promises to automatically synchronize the command
 sequences. Thus, there is no need for nesting commands using callbacks. Of course, each API call returns a promise
 which can be used to wait for the call to be resolved or rejected. The module has been tested with RGBW and White
 bulbs using a Milight version 4 bridge. RGB bulbs which are no longer sold since January 2014 should also work using
 the rgb command set.

## Introduction

Milight uses a very primitive one-way communication protocol where each command must be sent in a
 single UDP packet. It is just fire & forget similar to simple RF protocols for garage door openers and such.
 Compared to other Milight libraries, I am using a more aggressive timing for the delay between sending UDP command
 packets (```delayBetweenCommands``` property).

 Generally, the delay is to reduce the chances of UDP packet loss on the network. A longer delay may lower the risk of
 data loss, however, data loss is likely to occur occasionally on a wireless network. Keep in mind, that apart from your
 Wifi network there is another lossy communications channel between the Milight Controller and the bulbs. My strategy
 against loss is to repeat each command. By default it will be send three times (```commandRepeat``` property).

## What's new

### Brightness

I noticed the `rgbw.brightness()` command never reached the maximum brightness level of the bulb and it turned out to be
yet another bug in the `commands` file. I also found an article suggesting the RGBW bulbs support 22 brightness levels
instead of 20, however, the two additional levels did not change the brightness for me (tested with 6W bulbs). Maybe
this is different with 9W bulbs. For this reason, I have added `rgbw.brightness2()` which maps brightness 0-100 to
22 levels.

Another interesting observation is the RGBW bulbs keep brightness levels for color mode and white mode, individually.
Thus, you may notice a change in brightness if you switch to white mode, for example. So, if your application only
maintains a single brightness control you need to make sure to send the commands in the right order!

### Rendering RGB colors

For RGBW bulbs the command `rgbw.rgb255` is provided to map RGB values to Milight. However, the
color space of Milight is limited, as it is not possible to control color saturation and there are only 20
brightness levels. Thus, the results may be disappointing when compared to other LED lightning technologies.
Effectively, Milight is unable to display different shades of grey.

### 2-byte Command Sequences

Recently, I found out that Milight bridge version 3 and higher can also handle 2-byte command sequences instead of
3-byte command sequence. Basically, the last byte of the 3-byte command sequence, call it stop byte, can be omitted.
It is said the 2-byte command sequences provide better performance. This may be true for the Milight RF protocol,
but I don't think it has an significant impact on the IP communication between the application and the bridge. To use
the 2-byte command sequences you can simply use `commands2` instead of `commands`. Mixing 2-byte and 3-byte sequences
is also supported.

### Bridge Discovery

The new bridge discovery function can be used to discover the IP and MAC addresses of Milight v4 Wifi bridges found
on the local network. The following options can be provided to the discovery function.

| Property  | Default           | Type    | Description                                 |
|:----------|:------------------|:--------|:--------------------------------------------|
| address   | "<IP_ADDRESS>" | String  | The broadcast address                       |
| timeout   | 3000              | Integer | The timeout in milliseconds for discovery   |

An array of results is returned. Each result contains the following properties:
* ip: The IP address string
* max: The MAC address string

## Usage Example

See also example code provided in the `examples` directory of the package.

```javascript
var Milight = require('node-milight-promise').MilightController;
var commands = require('node-milight-promise').commands2;

// Important Notes:
// Instead of providing the global broadcast address which is the default, you should provide the IP address
// of the Milight Controller for unicast mode. Don't use the global broadcast address on Windows as this may give
// unexpected results. On Windows, global broadcast packets will only be routed via the first network adapter. If
// you want to use a broadcast address though, use a network-specific address, e.g. for `<IP_ADDRESS>/24` use
// `<IP_ADDRESS>`.

var light = new Milight({
		ip: "<IP_ADDRESS>",
		delayBetweenCommands: 75,
		commandRepeat: 2
	}),
	zone = 1;

light.sendCommands(commands.rgbw.on(zone), commands.rgbw.whiteMode(zone), commands.rgbw.brightness(100));
light.pause(1000);

light.sendCommands(commands.rgbw.off(zone));
light.pause(1000);

// Setting Hue
light.sendCommands(commands.rgbw.on(zone));
for (var x = 0; x < 256; x += 5) {
	light.sendCommands(commands.rgbw.hue(x));
	if (x === 0) {
		commands.rgbw.brightness(100)
	}
	light.pause(100);
}
light.pause(1000);

light.sendCommands(commands.rgbw.off(zone));
light.pause(1000);

// Back to white mode
light.sendCommands(commands.rgbw.on(zone), commands.rgbw.whiteMode(zone));
light.pause(1000);

// Setting Brightness
light.sendCommands(commands.rgbw.on(zone));
for (var x = 100; x >= 0; x -= 5) {
	light.sendCommands(commands.rgbw.brightness(x));
	light.pause(100);
}
light.pause(1000);

light.sendCommands(commands.rgbw.off(zone));
light.pause(1000);

light.close().then(function () {
	console.log("All command have been executed - closing Milight");
});
console.log("Invocation of asynchronous Milight commands done");
```

## Usage example for Discovery

```javascript
var discoverBridges = require('../src/index').discoverBridges;

discoverBridges().then(function (results) {
	console.log(results);
});
```

## Important Notes

* Instead of providing the global broadcast address which is the default, you should provide the IP address
  of the Milight Controller for unicast mode. Don't use the global broadcast address on Windows as this may give
  unexpected results. On Windows, global broadcast packets will only be routed via the first network adapter. If
  you want to use a broadcast address though, use a network-specific address, e.g. for `<IP_ADDRESS>/24` use
  `<IP_ADDRESS>`.
* For White bulbs the property `commandRepeat` should be set to `1`, as the brightnessUp/brightnessDown, and
  warmer/cooler commands will perform multiple steps otherwise.

## History

See [Release History](https://github.com/mwittig/node-milight-promise/blob/master/HISTORY.md).

## License

Copyright (c) 2015-2016, Marcus Wittig and contributors. All rights reserved.

[MIT License](https://github.com/mwittig/node-milight-promise/blob/master/LICENSE)

repository: dnousome/node-milight-promise

repo_name: dnousome/node-milight-promise


text:
[![Docker Cloud Build Status](https://img.shields.io/docker/cloud/build/daemonl/cra-version-proxy)](https://hub.docker.com/r/daemonl/cra-version-proxy)
![GitHub](https://img.shields.io/github/license/daemonl/cra-version-proxy.go)

Create React App Version Proxy
==============================

A reverse proxy for React apps.

- Set up a public source server, e.g. an S3 website, where different app
  versions are in /{version}/ prefixed directories, set as `CRA_PROXY_SOURCE`

- Set `CRA_PROXY_DEFAULT_VERSION` to the current 'live' version for normal users

Users can request any version with ?version={version}

The version will be stored in a cookie so that resources loaded by HTML pages
are also versioned (css, js etc)

All requests without an extension, including directories, are assumed to be the
app, so `/index.html` will be served

Docker
------

[daemonl/cra-version-proxy](https://hub.docker.com/r/daemonl/cra-version-proxy)


text:
# Secure Ping

This is a simple example of setting up secured communication with gRPC.

For more, see the write up at “[Secure gRPC with TLS/SSL](http://bbengfort.github.io/snippets/2017/03/03/secure-grpc.html)”.

**NOTE**: the certificates in this repository are for example only. They were generated on the command-line and only work for the localhost. If you actually wanted to set up this ping across a network, you'd have to generate your own certificates. Here are two good resources for this:

- [Golang TLS examples](https://gist.github.com/denji/12b3a568f092ab951456)
- [certstrap](https://github.com/square/certstrap)

## Demo Quick Start

First clone the repository (using `go get` would work, but the demo only works from the repository working directory) and install the various dependencies:

    $ git clone https://github.com/bbengfort/sping.git
    $ cd sping
    $ go get ./...

Now that you're in the working directory, you'll have to create two processes (the server and the client). I recommend opening up a second terminal tab. In the first tab:

    $ go run cmd/sping serve

This will run the server on the localhost with the default port and options. If you'd like to see all the options for either of the commands just use `--help`. Then in the second terminal:

    $ go run cmd/sping echo localhost

You should see the result in both the server and client windows. You have just conducted a secure Echo RPC request between client and server using [mutual authentication](https://en.wikipedia.org/wiki/Mutual_authentication) with [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security).

The client will automatically shutdown after 8 messages.


text:
# xiv-resources
A list of websites, APIs, and tools for FFXIV. PRs welcome, but refer to the [contributing guidelines](CONTRIBUTING.md).

## Websites
Name|Description
---|---
[A Realm Remapped](https://arealmremapped.com/)|Collection of all maps and locations in FINAL FANTASY XIV including FATEs, Treasure maps, Vistas, Aether Currents and more.
[AkhMorning](https://www.akhmorning.com)|Guides, news and resources for FFXIV.
[Allagan Studies](https://www.akhmorning.com/allagan-studies/)|Theorycrafting information, formulae and tools for FFXIV.
[Another Triple Triad Tracker](https://triad.raelys.com/)|Another website for tracking your Final Fantasy XIV Triple Triad card collection.
[Ariyala's Final Fantasy XIV Toolkit](https://ffxiv.ariyala.com/)|Gear planner and toolkit for FFXIV.
[Bozjan Southern Front](https://ffxiv.pf-n.co/bozja)|Interactive map for the Bozjan Southern Front.
[Cactpot.xyz](http://cactpot.xyz/)|Mobile friendly Final Fantasy XIV Mini-Cactpot perfect solver. Maximize your cactpot winnings.
[Cat became hungry](https://en.ff14angler.com/index.php?)|FINAL FANTASY XIV Fishing Database.
[Characa](https://characa.kkimu.dev/)|Character card generator.
[Chocobo Color](https://ffxiv.pf-n.co/chocobo-color)|Calculator for changing your chocobo's color.
[DRS Chess](https://drschess.github.io/DrsChess/)|Queen's Guard chess mechanic practice website.
[eorzea-weather](https://eorzea-weather.info/)|Weather forecast for Eorzea.
[Eriones](https://en.eriones.com/)|Comprehensive information website for FFXIV.
[exdreams Crafting Simulator](https://ffxiv.rs.exdreams.net/crafter/)|Craft rotation planner.
[exdreams Equipment Simulator](https://ffxiv.es.exdreams.net/)|Equipment simulator.
[exdreams Gatherer Timer](https://ffxiv.gt.exdreams.net/)|Gatherer timers and alarms.
[exdreams Meal List](https://ffxiv.es.exdreams.net/meal_list.html)|Meal list.
[exdreams Operation Room](https://ffxiv.phone.exdreams.net/)|Voice chat rooms.
[exdreams Recipe Search](https://ffxiv.rs.exdreams.net/)|Recipe list and search.
[exdreams Score Master](https://ffxiv.sc.exdreams.net/)|Perform practice for game tracks.
[exdreams Skill Simulator](https://ffxiv.ss.exdreams.net/)|Skill simulator.
[exdreams Spread Editor](https://ffxiv.ap.exdreams.net/spreading/)|(JP) Raid macro editor.
[exdreams TODO](https://ffxiv.ap.exdreams.net/todo/)|(JP) Daily/Weekly activity lists.
[exdreams Weather List](https://ffxiv.wl.exdreams.net/)|Weather list.
[Faloop](https://faloop.app/)|A Final Fantasy XIV hunt toolkit.
[FF Logs](https://www.fflogs.com/)|Combat analysis website.
[FFXIV Cactpot Solver](https://super-aardvark.github.io/yuryu/)|FFXIV Cactpot Solver.
[FFXIV Collect](https://ffxivcollect.com/)|Another website for tracking your Final Fantasy XIV collections.
[FFXIV Community Wiki](https://ffxiv.consolegameswiki.com/wiki/FF14_Wiki)|FFXIV wiki.
[FFXIV Eureka](https://ffxiv-eureka.com/)|Eureka tracker.
[FFXIV RealTime Server Status](https://fx.fo/)|FFXIV server status monitor.
[FFXIV Teamcraft](https://ffxivteamcraft.com/)|An FFXIV tool to handle collaborative crafts easily.
[FFXIV WXHB Cross Hotbar Simulator](https://xivbars.bejezus.com/)|XIV Bars is a simple app for previewing the Final Fantasy XIV W Cross HotBar (WXHB).
[ffxiv-gearing](https://asvel.github.io/ffxiv-gearing/)|(CN) Webapp for building and sharing Final Fantasy XIV gearsets.
[ffxiv-weather-bell](https://asvel.github.io/ffxiv-weather-bell/)|(CN) Weather forecast for Final Fantasy XIV.
[Gamer Escape](https://ffxiv.gamerescape.com/wiki/Main_Page)|FFXIV wiki.
[Garland Tools](https://www.garlandtools.org/)|FFXIV tools & resources.
[Heavenswhere](http://heavenswhere.com/)|Interactive maps for Final Fantasy XIV: Shadowbringers, Stormblood and Heavensward.
[High or Low](https://ffxiv.pf-n.co/high-or-low)|Calculator for the guessing game "High or Low" played against Tista-Bie in Eulmore.
[Horus's FFXIV Hunt Tracker](https://horus-hunts.net/)|A Final Fantasy XIV hunt tracker that aims to provide all the information required for the hunt in one place.
[Is FFXIV Up](https://is.xivup.com/)|FFXIV server status monitor.
[Lalachievements](https://www.lalachievements.com)|Keep track of your progress collecting everything that can be collected in FFXIV.
[Lodestone News](http://na.lodestonenews.com/)|Automatic Lodestone news updates for your Discord server.
[Lodestone When](https://karashiiro.github.io/lodestone-when/)|Estimate when a FFXIV character was created with just its Lodestone ID.
[Mini Cactpot](https://ffxiv.pf-n.co/mini-cactpot)|Calculator for the Mini Cactpot lottery.
[Name Generator](https://ffxiv.pf-n.co/name-generator)|FFXIV random name generator for all the races.
[Ocean Fishing](https://ffxiv.pf-n.co/ocean-fishing)|Ocean fishing helper website.
[SaltedXIV](https://saltedxiv.com/)|Guides and assorted resources for FFXIV.
[Skywatcher](https://ffxiv.pf-n.co/skywatcher)|Schedule for weather in Eorzea and forecaster for upcoming weather patterns.
[Universalis](https://universalis.app/)|Crowdsourced market board website and API.
[Wondrous Tails](https://ffxiv.pf-n.co/wondrous-tails)|Calculator for the Wondrous Tails mini-game.
[XIVAPI Browser](https://ffxiv.pf-n.co/xivapi)|An interface for browsing the XIVAPI.
[xivanalysis](https://xivanalysis.com/)|Automated performance analysis and suggestion platform for Final Fantasy XIV: Shadowbringers.
[XIV Dev Wiki](https://xiv.dev/)|The deep dark darkness wiki.
[XIV Mod Archive](https://www.xivmodarchive.com/)|Mod archive for FFXIV.
[XIVStatus](https://xivstatus.com/)|FFXIV server status monitor.
[XIV ToDo](https://xivtodo.com/)|Completion trackers, dashboards, and daily & weekly activities.

## Web APIs
Name|Description
---|---
[Another Triple Triad Tracker](https://documenter.getpostman.com/view/1779678/TzXzDHRR)|REST API for Triple Triad.
[CafeMaker](https://github.com/thewakingsands/cafemaker)|A XIVAPI fork optimized for CN client data and Chinese players.
[FFXIV Collect](https://documenter.getpostman.com/view/1779678/TzXzDHM1)|REST API for collections (e.g. achievements, mounts, minions).
[Garland Tools](https://www.garlandtools.org/)|FFXIV tools & resources.
[Lodestone News](https://documenter.getpostman.com/view/1779678/TzXzDHVk)|REST API for Lodestone news.
[Universalis](https://universalis.app/)|Crowdsourced market board website and API.
[XIVAPI](https://xivapi.com/)|Game data API.
[XIV-Character-Cards](https://github.com/ArcaneDisgea/XIV-Character-Cards)|Character card generator.

## Local APIs
Name|Description
---|---
[Aetherometer](https://github.com/ff14wed/aetherometer)|Framework that allows plugins to easily process network-level information from FFXIV. (Golang)
[Dalamud](https://github.com/goatcorp/Dalamud)|Plugin framework and API bundled with [FFXIVQuickLauncher](https://github.com/goatcorp/FFXIVQuickLauncher).
[eorzea-time](https://github.com/eorzea-weather/eorzea-time)|🕒 A clock of the Eorzea time. (JS/TS)
[eorzea-weather](https://github.com/eorzea-weather/eorzea-weather)|:partly_sunny: Weather forecast for Eorzea. (JS/TS)
[FFXIVWeather](https://github.com/karashiiro/FFXIVWeather)|FFXIV weather forecast library for C# applications. Also offered in [Lumina](https://github.com/karashiiro/FFXIVWeather.Lumina) and [Python](https://github.com/karashiiro/ffxivweather-py) variants.
[garlandtools-api](https://github.com/karashiiro/garlandtools-api)|An unofficial Node wrapper for the Garland Tools API.
[kobold](https://github.com/ackwell/kobold)|Modular SqPack reader written in TS.
[Lumina](https://github.com/NotAdam/Lumina)|A simple, performant and extensible framework for interacting with FFXIV game data
[Machina](https://github.com/ravahn/machina)|Network capture library for realtime TCP/IP decoding from a windows application. Includes an extension library to support FFXIV data capture. (C#)
[pcap-ffxiv](https://github.com/ffxiv-teamcraft/pcap-ffxiv)|A library for capturing FFXIV game packets in JS/TS.
[performgen](https://github.com/ff14wed/performgen)|MML -> FFXIV Perform network data compiler. (Golang)
[SaintCoinach](https://github.com/Rogueadyn/SaintCoinach)|A .NET library written in C# for extracting game assets and reading game assets from Final Fantasy XIV: A Realm Reborn.
[xivnet](https://github.com/ff14wed/xivnet)|A Golang parser for incoming or outgoing unencrypted FFXIV network traffic.
[zanarkand](https://github.com/ayyaruq/zanarkand)|Network capture library for realtime FFXIV Frame and FFXIV Message reading from a TCP/IP stream. (Golang)

## Desktop Applications
Name|Description
---|---
[Aetherometer](https://github.com/ff14wed/aetherometer)|Framework that allows plugins to easily process network-level information from FFXIV.
[BardMusicPlayer](https://bardmusicplayer.com/)|Bard Music Player is an automated music player for playing MIDI songs in FFXIV using the Bard's Performance mode.
[BurningDownTheHouse](https://github.com/LeonBlade/BurningDownTheHouse)|A tool for FFXIV to manipulate housing items.
[CMTool](https://github.com/imchillin/CMTool)|Client modding tool.
[exdreams Desktop Application](https://ffxiv.ap.exdreams.net/)|exdreams desktop application.
[FFXIV ACT Plugin](https://github.com/ravahn/FFXIV_ACT_Plugin)|FFXIV Plugin for Advanced Combat Tracker.
[FFXIV_ACT_Plugin_CN](https://github.com/TundraWork/FFXIV_ACT_Plugin_CN)|Modified version of FFXIV_ACT_Plugin to adapt Chinese version FFXIV client.
[FFXIVAPP](https://github.com/FFXIVAPP/ffxivapp)|(No description)
[FFXIVQuickLauncher](https://github.com/goatcorp/FFXIVQuickLauncher)|A faster launcher for the game with a rich third-party plugin ecosystem.
[FFXIV TexTools](https://textools.dualwield.net/)|An application used to modify the textures and models for the game Final Fantasy XIV.
[RINGS](https://github.com/anoyetta/RINGS)|Chat communication enhancer for FFXIV.
[TataruHelper](https://github.com/NightlyRevenger/TataruHelper)|Application for translation of in-game texts in Japan MMORPG - Final Fantasy XIV.
[XivAlexander](https://github.com/Soreepeong/XivAlexander)|Double weave on high latency add-on for Final Fantasy XIV for Windows PC.
[XivMitmLatencyMitigator](https://github.com/Soreepeong/XivMitmLatencyMitigator)|Double weave for everyone, including PC, Mac, and PS4 users.
[XIVNote](https://github.com/anoyetta/XIVNote)|「14ノート」FFXIV向け付箋ツール
[WaymarkLibrarian](https://github.com/PunishedPineapple/WaymarkLibrarian)|Tool for FFXIV to store unlimited waymark presets and swap them into and out of the game as-required.

## Research Tools
Name|Description
---|---
[FFXIV Explorer](https://github.com/goaaats/ffxiv-explorer-fork)|Modernized fork of FFXIV Explorer with added usability features.
[FFXIVMon Reborn](https://github.com/SapphireServer/ffxivmon)|A FFXIV Network Analysis Tool.
[FFXIVOpcodeWizard](https://github.com/karashiiro/FFXIVOpcodeWizard)|An automatic opcode identification program for FFXIV. Doubles as a working dictionary of the game's opcodes and how to create their conditions.
[FFXIV-Packet-Dissector](https://github.com/zhyupe/FFXIV-Packet-Dissector)|Wireshark plugins for dissecting FFXIV packets.
[Godbert](https://github.com/ufx/SaintCoinach)|Godbert is a simple application to display game data and 3D models from Final Fantasy XIV.
[Sapphire](https://github.com/SapphireServer/Sapphire)|A Final Fantasy XIV 4.0+ Server Emulator written in C++.

## ACT Plugins
### Base Plugins
Name|Description
---|---
[FFXIV ACT Plugin](https://github.com/ravahn/FFXIV_ACT_Plugin)|FFXIV Plugin for Advanced Combat Tracker.
[FFXIV_ACT_Plugin_CN](https://github.com/TundraWork/FFXIV_ACT_Plugin_CN)|Modified version of FFXIV_ACT_Plugin to adapt Chinese version FFXIV client.
### Extension Plugins
Name|Description
---|---
[ACT-Discord-Triggers](https://github.com/Makar8000/ACT-Discord-Triggers)|An ACT plugin for routing audio to discord.
[ACT.DFAssist](https://github.com/purutu/ACT.DFAssist)|DFAssist fork for ACT3.
[ACT.FFXIVPing](https://github.com/Noisyfox/ACT.FFXIVPing)|A simple ACT plugin displays network ping in a small overlay for FFXIV.
[ACT.FFXIVTranslate](https://github.com/Noisyfox/ACT.FFXIVTranslate)|Translate players' chatting.
[ACT.FoxTTS](https://github.com/Noisyfox/ACT.FoxTTS)|Add Chinese TTS (and maybe more) to ACT & TTSYukkuri.
[ACT.Hojoring](https://github.com/anoyetta/ACT.Hojoring)|FFXIV Advanced Combat Tracker plugin. Includes triggers, TTS, and HUD plugins.
[Kapture](https://github.com/kalilistic/Kapture)|ACT FFXIV Plugin Loot Tracker.
[Matcha](https://github.com/thewakingsands/matcha)|Matcha (抹茶) is an ACT plugin that provides notifications for in-game events.
[OverlayPlugin](https://github.com/ngld/OverlayPlugin)|Yet another OverlayPlugin fork.
[Paisley Park](https://github.com/LeonBlade/PaisleyPark)|A waymark preset tool for FFXIV.
[SkillDisplay](https://github.com/rawrington/SkillDisplay)|A simple no-frills ACTWebSocket overlay for showing actions pressed in an overlay window.
[Triggernometry](https://github.com/paissaheavyindustries/Triggernometry)|Triggernometry is a plugin for Advanced Combat Tracker, intended to extend its built-in trigger system with a variety of different actions and configuration options.
[universalis_act_plugin](https://github.com/goaaats/universalis_act_plugin)|ACT plugin to upload market board data to https://universalis.app

### OverlayPlugin Overlays
Name|Description
---|---
[ACT_DFAPlugin](https://github.com/qitana/ACT_DFAPlugin)|FFXIV Duty Finder Assist for [ngld/OverlayPlugin](https://github.com/ngld/OverlayPlugin).
[ACT_PingPlugin](https://github.com/qitana/ACT_PingPlugin)|The add-on of [ngld/OverlayPlugin](https://github.com/ngld/OverlayPlugin) which shows ping status for connected server.
[cactbot](https://github.com/quisquous/cactbot)|FFXIV JavaScript Raiding Overlay.
[Codex](https://github.com/mkaminsky11/Codex)|Extra gauges and buff trackers for FFXIV.
[ffxiv_act_dfassist](https://github.com/easly1989/ffxiv_act_dfassist)|Duty Finder Assist Plugin for ACT, Based on [devunt/DFAssist](https://github.com/devunt/DFAssist).
[ffxiv-ember-overlay](https://github.com/GoldenChrysus/ffxiv-ember-overlay)|React + Redux overlay for the OverlayPlugin and ACTWebSocket plugins for Advanced Combat Tracker for use with Final Fantasy XIV.
[ffxiv-opener-overlay](https://github.com/ChalkPE/ffxiv-opener-overlay)|ACT overlay for Final Fantasy XIV that shows your real-time skill sequences.
[horizoverlay](https://github.com/bsides/horizoverlay)|A simple horizontal damage meter overlay for Final Fantasy XIV.
[ikegami](https://github.com/hibiyasleep/ikegami)|Horizontal FFXIV Miniparse Overlay.
[kagami](https://github.com/ramram1048/kagami)|FFXIV OverlayPlugin skin for capturing used skills.
[kagerou](https://github.com/hibiyasleep/kagerou)|ACT-FF14 OverlayPlugin Skin - Modern, easily configurable, always up-to-date.
[klondike](https://github.com/kalilistic/klondike)|FFXIV ACT Overlay.

## Off-the-books Dalamud Plugins
Name|Description
---|---
[BDTHPlugin](https://github.com/LeonBlade/BDTHPlugin)|A plugin for FFXIVQuickLauncher to help with manipulating housing items.
[Cammy](https://github.com/UnknownX7/Cammy)|A simple camera editor to change various game defaults such as zoom and fov.
[DalamudPython](https://git.sr.ht/~jkcclemens/DalamudPython)|Allows you to use Dalamud via Python in the chat box. Supports one-liners, printing results to chat, or making full scripts over multiple commands.
[FFLogsLookupPlugin](https://github.com/maributt/FFLogsLookupPlugin)|A Dalamud plugin to display an inspected character's parses directly in the inspect window.
[FPSLimiter](https://github.com/maributt/FPSLimiter)|A Dalamud plugin to manage your FPS cap with a command.
[ffxiv-literal-map-link](https://github.com/Asvel/ffxiv-literal-map-link)|(Only CN tested) Dalamud plugin that turns map coordinates literal into interactable map link when you post messages.
[ffxiv-startup-commands](https://github.com/saltycog/ffxiv-startup-commands)|Perform various behaviors/commands right after logging into a character.
[HeelsPlugin](https://github.com/LeonBlade/HeelsPlugin)|A plugin used for FFXIVQuickLauncher to offset your character height when using certain high heel mods.
[HousingPos](https://github.com/Bluefissure/HousingPos)|A xivlauncher plugin to save/load positions of the housing furnitures.
[IMEPlugin](https://github.com/Bluefissure/IMEPlugin)|A simple plugin that adds an overlay to support Chinese IME in dalamud.
[Macrology](https://git.sr.ht/~jkcclemens/Macrology)|Adds a better macro system to the game. Macrology allows for macros of infinite length, adds looping, allows comments, supports pausing, allows you to run multiple macros at once, and supports fractional waits.
[Penumbra](https://github.com/xivdev/Penumbra)|Runtime mod loader for FFXIV.
[SomethingNeedDoing](https://github.com/daemitus/SomethingNeedDoing)|Macro queueing plugin for Dalamud.
[The Roleplayer's Toolbox](https://git.sr.ht/~jkcclemens/RoleplayersToolbox/)|A collection of useful tools for roleplayers, such as disabling /doze snap, adding emotes to the hotbar, routing to houses, and more.
[Weatherman](https://github.com/Eternita-S/Weatherman)|Weatherman allows you to take precise control over weather and time flow in FFXIV.
[YesAlready](https://github.com/daemitus/YesAlready)|Auto-clicks "yes" for you in yes/no dialogs.

## Other Tools
Name|Description
---|---
[ffxiv-datamining](https://github.com/xivapi/ffxiv-datamining)|This repository is to serve as a place to share data mining information related to Final Fantasy XIV.
[ffxiv-datamining-cn](https://github.com/thewakingsands/ffxiv-datamining-cn)|SaintCoinach datamining files for FFXIV CN client since version 4.45
[ffxiv-datamining-ko](https://github.com/Ra-Workspace/ffxiv-datamining-ko)|This repository is to serve as a place to share data mining information related to Final Fantasy XIV Korea.
[FFXIVOpcodes](https://github.com/karashiiro/FFXIVOpcodes)|Mostly up-to-date repository of network opcodes for all 3 game regions.
[lodestone-css-selectors](https://github.com/xivapi/lodestone-css-selectors)|CSS selectors for The Lodestone.

gha_license_id: Unlicense


text:
# react-example-state
This repository demonstrates how to use React component's state to control the state of component.

## Running
```
$ npm install
$ npm start
```

repository: mrexmelle/react-example-state

repo_name: mrexmelle/react-example-state


text:
#### key

Changelog entries are classified using the following labels _(from [keep-a-changelog][]_):

- `added`: for new features
- `changed`: for changes in existing functionality
- `deprecated`: for once-stable features removed in upcoming releases
- `removed`: for deprecated features removed in this release
- `fixed`: for any bug fixes

Custom labels used in this changelog:

* `dependencies`: bumps dependencies
* `housekeeping`: code re-organization, minor edits, or other changes that don't fit in one of the other categories.

## [0.24.0] - 2017-05-19

**added**

- By popular request, assemble now automatically expands config templates in yaml front-matter, via [expand-front-matter][]! This is a feature that we had in grunt-assemble, and users let us know that they wanted it back.

**fixed**

- Updated dependencies to use [is-binary-buffer][], which fixes a bug where `isbinaryfile` was trying to read from a file that didn't exist.

## [0.23.0] - 2017-02-11

**dependencies**

- Bumps [assemble-core][] to get an update to [assemble-streams][] that ensures that `view` is decorated with `.toStream()` when created by `app` (versus a collection).

## [0.21.0] - 2017-02-03

**dependencies**

- Bumps [assemble-loader] to v1.0.0 to take advantage of optimizations, improvements and bug fixes related to loading views

**fixed**

- Regression in 0.20.0 that was causing `view.stat` to be null in some cases after `view.path` changed
- `view.base` was not always correct on views that were not created from the file system

## [0.20.0] - 2017-02-02

**dependencies**

- Bumps [assemble-core] to v0.29.0 to take advantage of improvements to `dest` handling

## [0.19.0] - 2017-02-01

**dependencies**

- Bumps [assemble-core] to v0.28.0 to take advantage of new methods available on `list`s

### [0.18.0]

**Dependencies**

- bumps [assemble-core][] to 0.27.0

### [0.17.0]

**Dependencies**

- bumps [assemble-core][] to 0.26.0

### [0.16.1]

- bump dependencies. In particular, there was a bug in [parser-front-matter][] where leading whitespace was removed after extracting front-matter, which caused the first line of indentation to be removed. This has been fixed.

### [0.16.0]

- **Added**: `.log()` method, which also exposes additional methods, like `.log.info()`, `.log.success()`, etc.
- docs were moved to `support/docs`, so that markdown docs can be built to the `docs` directory
- docs were updated, new docs added
- Moves some private prototype methods to static methods, to allow them to be used without creating an instance
- Bumps [assemble-core][] to v0.25.0

### [0.15.0]

- Bumps [assemble-core][] to v0.24.0 to get the latest versions of [templates][] and [base-data][] which removes the `renameKey` option from the `.data` method. Use the `namespace` option instead.

### [0.14.0]

Bumps [assemble-core][] to v0.22.0 to take advantage of fixes and improvements to lookup methods: `.find` and `getView`. No API changes were made. Please [let us know](../../issues) if regressions occur.

- fixes `List` bug that was caused collection helpers to explode
- Improvements to lookup functions: `app.getView()` and `app.find()`
- Bumps [base][] to take advantages of code optimizations.

### [0.13.0]

- Bumps [assemble-core][] to v0.21.0. Support for the `queue` property was removed on collections. See [assemble-core][] for additional details.
- Fixes bug where glob parent was not being used for `file.base`, causing dest directory to be relative to cwd instead of glob parent in some cases.
- Some changes were made to context handling that effected one unit test out of ~1,000. although it's unlikely you'll be effected by the change, it warrants a minor bump
- Externalizes common [templates][] tests to base-test-runner, so that assemble plugins and other [base][] applications can use the tests
- Includes a fix from [assemble-loader][], where a bug caused `renameKey` to not always be used when defined on collection loader options.
- Includes fixes from templates for resolving layouts

### [0.12.0]

- Bumps [assemble-core][] to v0.18.0, which includes a bump in [templates][]. See the changelog on the templates library for more details.

### [0.11.0]

- `debug` methods and related code have been removed
- Bumps [assemble-core][] to v0.17.0

### [0.10.0]

- Adds support for using es6 generators with tasks
- Bumps [assemble-core][] to v0.15.0

### [0.9.0]

- Bumps several dependencies. No API changes, this is mostly an optimization release. Be sure to completely remove `node_modules` and reinstall all dependencies to avoid errors such as `isRegistered is not a function`

### [0.8.0]

- Updates [composer][] to v0.11.0, which removes the `.watch` method in favor of using the [base-watch][] plugin.
- Changes in [templates][]. Please see v0.11.0 in [templates history](https://github.com/jonschlinkert/templates#history) for more details.

### [0.7.0]

- Stability improvements and optimizations of the API introduced in v0.6.0.

### [0.6.0]

- Major refactor. Assemble was completely re-written from the ground-up as a standalone node.js library and is no longer a grunt plugin. Grunt plugin support has been moved to [grunt-assemble][]. Please see that repo for additional details.

[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog

repository: assemble/assemble

gha_language: CSS

repo_name: assemble/assemble


text:
---
title: hexColor
description: HexColor validation validator will allow user to enter only the input in proper Hex Color format.
author: rxcontributortwo

---
# When to use
Suppose you want to create a User form, which contains fields like ColorPicker, HeaderHexColorCode, BodyHexColorCode, StrictHexColorCode and you want the user to enter only the hex color format. Here depending upon the requirement these scenarios may arise.

1.	Allow string which is a hex color format like in ColorPicker field.
2.	Apply hexColor validation based on matched condition in the form, like if the ColorPicker is `#AFAFAF`, then only the HeaderHexColorCode field will be validated to hexColor validator.
3.	Adding Custom Message on BodyHexColorCode field.
4. Applying strict format of hexCode in StrictHexCode field.
5.	Apply dynamic validation, If the validation will be changed based on some criteria in the application.

Let’s see how hexColor validator fulfil the need.

# Basic HexColor Validation
We need to create a `FormGroup` in the component. To achieve this, we need to add `RxFormBuilder`. The `RxFormBuilder` is an injectable service that is provided with the `RxReactiveFormsModule`. Inject this dependency by adding it to the component constructor.Here we have covered Add form operation.

[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\add\hex-color-add.component.ts?type=section)]

Next, we need to write html code.
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\add\hex-color-add.component.html?type=section)]

[!example(?title=hexColor validator for add Example)]
<app-hexColor-add-validator></app-hexColor-add-validator>

# HexColorConfig
Below options are not mandatory to use in the `RxwebValidators.hexColor()` validator. If needed then use the below options.

|Option | Description |
|--- | ---- |
|[conditionalExpression](#conditionalExpression) | HexColor validation should be applied if the condition is matched in the `conditionalExpression` function. Validation framework will pass two parameters at the time of `conditionalExpression` check. Those two parameters are current `FormGroup` value and root `FormGroup` value. You can apply the condition on respective object value.If there is need of dynamic validation means it is not fixed in client code, it will change based on some criterias. In this scenario you can bind the expression based on the expression value is coming from the web server in `string` format. The `conditionalExpression` will work as same as client function. |
|[message](#message) | To override the global configuration message and show the custom message on particular control property. |

## conditionalExpression
Type :  `Function`  |  `string`

HexColor validation should be applied if the condition is matched in the `conditionalExpression` function. Validation framework will pass two parameters at the time of `conditionalExpression` check. Those two parameters are current `FormGroup` value and root `FormGroup` value. You can apply the condition on respective object value.
If there is need of dynamic validation means it is not fixed in client code, it will change based on some criterias. In this scenario you can bind the expression based on the expression value is coming from the web server in `string` format. The `conditionalExpression` will work as same as client function.

[!codeExample(?title=conditionalExpressionExampleFunction)]

[!codeExample(?title=conditionalExpressionExampleString)]

[!TabGroup(?showHideCondition="conditionalExpression")]
# [Component](#tab\conditionalExpressionComponent)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\conditionalExpression\hex-color-conditional-expressions.component.ts)]
# [Html](#tab\conditionalExpressionHtml)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\conditionalExpression\hex-color-conditional-expressions.component.html)]
***

[!example(?type=section&clickEventCode="conditionalExpression=!conditionalExpression"&title=hexColor validator with conditionalExpression)]
<app-hexColor-conditionalExpression-validator></app-hexColor-conditionalExpression-validator>

## message
Type :  `string`

To override the global configuration message and show the custom message on particular control property.

[!codeExample(?title=messageExample)]

[!TabGroup(?showHideCondition="message")]
# [Component](#tab\messageComponent)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\message\hex-color-message.component.ts)]
# [Html](#tab\messageHtml)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\message\hex-color-message.component.html)]
***

[!example(?type=section&clickEventCode="message=!message"&title=hexColor validator with custom message)]
<app-hexColor-message-validator></app-hexColor-message-validator>

# Complete hexColor Example
[!TabGroup]
# [Example](#tab\completeexample)
<app-hexColor-complete-validator></app-hexColor-complete-validator>
# [Component](#tab\completecomponent)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\complete\hex-color-complete.component.ts)]
# [Html](#tab\completehtml)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\complete\hex-color-complete.component.html)]
***

# Dynamic hexColor Example
[!TabGroup]
# [Example](#tab\dynamicexample)
<app-hexColor-dynamic-validator></app-hexColor-dynamic-validator>
# [Component](#tab\dynamiccomponent)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\dynamic\hex-color-dynamic.component.ts)]
# [Json](#tab\dynamicjson)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\dynamic\dynamic.json)]
# [Html](#tab\dynamichtml)
[!code-typescript[](\assets\examples\reactive-form-validators\validators\hexColor\dynamic\hex-color-dynamic.component.html)]
***

repository: technicalarchitectrx/rxweb

gha_language: HTML

repo_name: technicalarchitectrx/rxweb


text:
# fortran-coverpage-syntax theme

This thime is uses the similar colours as used in IBM704 Fortran user manual's coverpage.

![Coverpage for IBM704 Fortran user manual](https://upload.wikimedia.org/wikipedia/commons/0/07/Fortran_acs_cover.jpeg)

The inside looks like this:

![screenshot](https://raw.githubusercontent.com/Maselko/fortran-coverpage-syntax/master/Screenshot.png)

enjoy!

repository: Maselko/fortran-coverpage-syntax

repo_name: Maselko/fortran-coverpage-syntax


text:
# BibTeX Parser Experiments

Experiments to determine the new BibTeX parser formula. The result may be applied
to other formats as well in the future.

![Parsing stages of BibTeX](stages.png)

Above is some pseudo-grammar describing the stages of parsing. The reason I
distinguish between parsing the file and parsing values is best demonstrated in
the "entry value with mid-command concatenation" test case:

Input:
```bibtex
@book{a,
  title = "foo \\copy" # "right{} bar"
}
```

Output:
```js
[{
  type: 'book',
  id: 'a',
  properties: {
    title: 'foo © bar'
  }
}]
```

## Participants

Note: `citationjs-idea` (Citation.js Idea #1) and `citationjs-nearley` are skipped
in some tables, as they are only in here for historic reasons.

### Citation.js (old)

At the time of starting these experiments, the `TokenStack` class was utilized,
together with a simple RegExp that tokenizes commands.

### Citation.js Ideas

The idea was to explore tokenization without introducing a formal grammar, as
formal grammars introduce extra build steps, runtime dependencies and large swaths
of generated code. However, used as I was to the syntax of `PEG.js` and `nearley.js`,
I made some unnecessarily complicated features like `consumeAnyRule()`, and some
weird loops in the rules. This was partly due to bad tokenization.

Idea #2, currently active in Citation.js has new tokens, a simpler `Grammar` class
and simplified rules. It also has more features, including more commands and
diacritics, including more ways to write them.

### Citation.js with nearley

In parallel to reworking the idea, I used the tokenizer in a `nearley.js` grammar,
which failed miserably. This is probably the result of bad grammar-writing on my
part, and not a reflection of the capabilities of `nearley.js`. However, an additional
downside of this route is that it introduces an extra build step (`nearleyc`) and
a runtime dependency — `nearley` itself.

### astrocite

The `astrocite-bibtex` package by @dsifford uses PEG.js. It is capable of returning
an AST.

### fiduswriter

Fiduswriter's `biblatex-csl-converter` seems to perform very poorly on the larger
file. However, it does return lossless values, although I am not a fan of the
(lack of) difference between arrays representing single and multiple values:

```js
[
  { type: 'text', text: 'foo' }
]
// vs
[
  { literal: [{ type: 'text', text: 'foo' }] },
  { literal: [{ type: 'text', text: 'bar' }] }
]
```

This causes testing such as

```js
literal in value[0]
// or more properly
value.every(part => literal in part)
```

### Zotero

Zotero Translators are relatively hard to use stand-alone, as they depend on a
Zotero framework in the global scope. It immediately converts to Zotero API JSON
while parsing the syntax. Not shown in the performance table is that Zotero
requires initialization, not counting the time it takes to import files, and that
this takes relatively long.

### Better BibTeX for Zotero (BBT)

Using `@retorquere/bibtex-parser`, this performs very well. It is capable of
returning an AST. I have not had a chance to test out all the parser features
for literal/text/name values yet.

### JabRef

JabRef is reference management software with Bib(La)TeX as the internal
representation, so one can assume their support for parsing it to be pretty good.
However, I have not found a way to export their internal representation in the
level of detail required for passing the syntax tests. Similarly, as their program
only partly supports a CLI (no stdio) and is written in Java, a performance
comparison would not be very fair. For now, it is possible to test syntax features
by uncommenting the `jabref` entry in `test/feature.js` and running
`npm run features -- parser jabref`.

## API Features

|                  | citationjs-old | citationjs | astrocite | fiduswriter | zotero | bbt  |
|------------------|----------------|------------|-----------|-------------|--------|------|
| Sync/Async       | sync           | sync       | sync      | both        | async  | both |
| AST output       | ✘              | ✘          | ✓         | ✘           | ✘      | ✓    |
| Lossless schema¹ | ✓              | ✓          | ✓         | ✓           | ✘      | ✓    |
| Lossless values  | ✘              | ✘          | ✘         | ✓           | ✘      | ✓    |
| Error recovery   | ✓              | ✘          | ✘         | ✓           | ✘      | ✓    |

¹ specifically the schema used to represent data entries and not value
  syntax (commands, formatting), and disregarding AST

## Syntax Features

Empty cells indicate a choice to follow either natbib or biblatex for
certain behavior, this becomes clear from context. If both cells are
empty, this is may be an error, but that should be indicated by a
different test fixture. Auto-generated by `npm run features -- fixtures`,
see also [the fixture file](test/fixtures/features.js).

| | citationjs-old | citationjs | astrocite | fiduswriter | zotero | bbt |
|-|----------------|------------|-----------|-------------|--------|-----|
| entry with lowercase type | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry with mixed-case type | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry with uppercase type | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry with parentheses | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry with spacing | ✓ | ✓ | ✘ | ✓ | ✓ | ✓ |
| entry with trailing comma | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string key with colon | ✘ | ✓ | ✘ | ✓ | ✘ | ✓ |
| entry key with colon | ✓ | ✓ | ✓ | ✘ | ✘ | ✓ |
| entry value with annotation |   |   |   |   |   |   |
| entry label with number | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry label with colon | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry label with double quotes | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry value of quoted string | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry value of braced string | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| entry value of number | ✘¹ | ✓ | ✓ | ✘¹ | ✘¹ | ✓ |
| entry value with mid-and concatenation | ✘² | ✓ | ✘² | ✘² | ✘² | ✓ |
| entry value with mid-command concatenation | ✘² | ✓ | ✘² | ✘² | ✘² | ✘² |
| entry value with sentence-casing (real title) | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✓ |
| entry value with sentence-casing (artificial title) | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✘¹ |
| entry value with sentence-casing (markup) | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✘¹ |
| entry value with sentence-casing (env markup) | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✘¹ |
| entry value with markup | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✓ |
| entry value with envs | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✘¹ |
| entry value with env overrides | ✘¹ | ✓ | ✘¹ | ✘¹ | ✘¹ | ✓ |
| entry value with literal names | ✘ | ✓ | ✘ | ✘ | ✘ | ✓ |
| entry value with truncated names | ✘¹ | ✘¹ | ✘¹ | ✘¹ | ✘¹ | ✘¹ |
| entry value with extended names (biblatex) |   | ✓ |   |   |   | ✓ |
| entry value with verbatim fields | ✓ | ✓ |   |   |   | ✓ |
| entry value with uri fields |   | ✓ |   |   |   |   |
| entry value with pre-encoded uri fields | ✓ | ✓ | ✓ |   |   | ✓ |
| entry value with diacritics | ✘ | ✓ | ✘ | ✘ | ✘ | ✓ |
| entry value with escapes | ✘ | ✓ | ✘ | ✘ | ✘ | ✘ |
| entry value with sub/superscript | ✘ | ✓ | ✘ | ✘ | ✘ | ✓ |
| entry value with multi-argument commands | ✘ | ✘ | ✘ | ✘ | ✘ | ✓ |
| entry value with verbatim-argument commands | ✘ | ✘ | ✘ | ✘ | ✘ | ✓ |
| entry value with unbracketed-argument commands | ✘¹ | ✘¹ | ✘¹ | ✘¹ | ✘¹ | ✓ |
| TODO |   |   |   |   |   |   |
| string with lowercase type | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string with mixed-case type | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string with uppercase type | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string with parentheses | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string value with string | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| string value with concatenated string | ✘ | ✓ | ✘ | ✓ | ✓ | ✓ |
| preamble with quoted string | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| preamble with string | ✘ | ✓ | ✘ | ✓ | ✓ | ✓ |
| preamble with concatenated string | ✘ | ✓ | ✘ | ✓ | ✓ | ✓ |
| comment before entry | ✘ | ✓ | ✓ | ✓ | ✓ | ✓ |
| comment around entry (natbib) |   | ✓ |   |   |   |   |
| comment around entry (biblatex) |   |   | ✓ | ✓ | ✓ | ✓ |
> ¹ undefined representation, actual support may vary
> ² very unlikely to matter

## Performance

Data from `npm test`, as [run on Travis CI](https://travis-ci.com/github/citation-js/bibtex-parser-experiments).

|              | Init             | Time (single entry) | Time (3345 entries) |
|--------------|-----------------:|--------------------:|--------------------:|
| citationjs-old | 0.795ms ± 2.2% | 0.842ms ± 1.6% | 1.97e+3ms ± 5.5% |
| citationjs | 4.42ms ± 2.3% | 0.455ms ± 1.5% | 1.20e+3ms ± 11.7% |
| astrocite | 1.73ms ± 2.2% | 0.665ms ± 2.3% | 2.17e+3ms ± 7.0% |
| fiduswriter | 17.7ms ± 12.5% | 7.52ms ± 24.7% | 1.16e+5ms ± 4.0% |
| zotero | 4.16ms ± 12.1% | 2.13ms ± 1.3% | 1.00e+4ms ± 0.8% |
| bbt | 21.7ms ± 23.4% | 1.55ms ± 6.5% | 2.27e+4ms ± 5.4% |

repository: citation-js/bibtex-parser-experiments

gha_language: JavaScript

repo_name: citation-js/bibtex-parser-experiments


text:
![SecureDNS](https://raw.githubusercontent.com/Texnomic/SecureDNS/master/docs/Logo.png "SecureDNS")

Building a Secure, Modern, Cross-Platform & Cross-Architecture DNS Server Using C# 8.0 & .NET Core 3.1.

SecureDNS Project aims to implements all *secure* DNS Protocols regardless of being standardized or widely adopted; while maintaining backward compatibility with *unsecure* DNS Over UDP Protocol via Reverse Proxy.

SecureDNS Project is implemented using modern [Clean-Architecture](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164) Patterns.

# Table Of Content
1. [Releases](#Releases)
2. [Protocols](#Protocols)
3. [Integrations](#Integrations)
4. [Resource Records](https://github.com/Texnomic/SecureDNS/wiki/Supported-Resource-Records)
5. [Platforms](#Platforms)
6. [Chips](#Chips)
7. [Launch](#Launch)
8. [Technology](#Technology)
9. [Dependencies](#Dependencies)
10. [Donations](#Donations)
11. [Supported-By](#Supported-By)

## Releases
The [v0.2 Alpha Release](https://github.com/Texnomic/SecureDNS/releases/tag/v0.2-alpha) is now available.

## Protocols
- [x] [DNS Over Blockchain (ENS)](https://ens.domains/)
- [ ] [DNS Over Blockchain (HandShake)](https://handshake.org/)
- [X] [DNS Over TCP](https://tools.ietf.org/html/rfc1035)
- [x] [DNS Over TLS](https://tools.ietf.org/html/rfc7858)
- [x] [DNS Over HTTP/S](https://tools.ietf.org/html/rfc8484)
- [X] [DNSCrypt](https://dnscrypt.info/)

## Integrations
1. [Ethereum Name Service](https://ens.domains/)
2. [Ethereum Name Service DNS Resolver](https://github.com/ensdomains/resolvers)
3. [FilterLists](https://github.com/collinbarrett/FilterLists)
4. [IANA Root Files](https://www.iana.org/domains/root/files)
5. [ICANN Zone Data Service](https://czds.icann.org/home)
6. Any Standard-Compliant Public `DoH` or `DoT` Resolvers.

## Platforms
- [x] Alpine: 3.10+
- [x] Debian: 9+
- [x] Ubuntu: 16.04+
- [x] Fedora: 29+
- [x] RHEL: 6+
- [x] openSUSE: 15+
- [x] SUSE Enterprise Linux (SLES): 12 SP2+
- [x] macOS: 10.13+
- [x] Windows Client: 7, 8.1, 10 (1607+)
- [x] Windows Server: 2012 R2+

## Chips
- [x] x64 on Windows, macOS, and Linux
- [x] x86 on Windows
- [x] ARM32 on Windows and Linux
- [x] ARM64 on Linux (kernel 4.14+)

## Launch
The Project offically launched within my talk for [Cairo Security Camp](https://cairosecuritycamp.com/sessions/rebuilding-the-domain-name-system/) on September 22nd.

>[Full Talk Video On YouTube](https://youtu.be/1Gxk40dmbFM)

>[Rebuilding Domain Name System Presentation](https://raw.githubusercontent.com/Texnomic/SecureDNS/master/docs/Rebuilding.DNS.pptx)

>This talk will cover the DNS protocol since its inception in 1986 and taking a deep-dive into the inherit lack of security at its core design and how all modern operating systems using insecure standards, Then we will explain alternative secure implementation like DNS Over TLS and DNS Over HTTP/S. Then we will shift-gears to developing an all-new modern DNS Server Reference-Implementation with a myriad of possibilities for retaking control like Black/Sink-holing, Threat Hunting/Intelligence and way more! Finally, we will launch a GitHub-based Open-Source Project containing DNS Server Reference-Implementation for the First-Time & Exclusively in Cairo Security Camp!

## Technology
1. [C# 8.0](https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8)
2. [.NET Core 3.1](https://dotnet.microsoft.com/download/dotnet-core/3.0)
3. [ASP.NET Core 3.1](https://dotnet.microsoft.com/download/dotnet-core/3.0)
4. [PowerShell Core 7.0](https://github.com/PowerShell/PowerShell)
5. [Entity Framework Core 3.1](https://docs.microsoft.com/en-us/ef/core/)
6. [Blazor aka Razor Components](https://dotnet.microsoft.com/apps/aspnet/web-apps/client)
7. [Solidity](https://github.com/ethereum/solidity)

## Dependencies
1. [HangFire](https://www.hangfire.io/)
2. [MoreLINQ](https://github.com/morelinq/MoreLINQ)
3. [Electron.NET](https://github.com/ElectronNET/Electron.NET)
4. [BinarySerializer](https://github.com/jefffhaynes/BinarySerializer)
5. [FlexLabs.Upsert](https://github.com/artiomchi/FlexLabs.Upsert)
6. [Telerik UI for Blazor](https://www.telerik.com/blazor-ui)
7. [Hangfire Extension Plugins](https://github.com/wanlitao/HangfireExtension)
8. [Entity Framework Extensions](https://entityframework-extensions.net)
9. [Nethereum](https://nethereum.com/)
10. [Polly](https://github.com/App-vNext/Polly)
11. [Terminal UI](https://github.com/migueldeicaza/gui.cs)
12. [Command Line Parser](https://github.com/commandlineparser/commandline)
13. [Async Enumerable](https://github.com/Dasync/AsyncEnumerable)
14. [Colorful Console](http://colorfulconsole.com/)
15. [Blazorise](https://blazorise.com/)
16. [HtmlAgilityPack](https://html-agility-pack.net/)

## Donations
* **PayPal**: https://www.paypal.me/texnomic
* **Bitcoin**: 13wMqy8yg9yhJAAP2AXu8A2De1ptAYh6s4
* **Ethereum**: 0xfE171b1C5C5584b65ec58a6FA2009f6ECeE812D7

## Supported-By
![JetBrains](https://raw.githubusercontent.com/Texnomic/SecureDNS/master/docs/JetBrains.png "JetBrains")
![Syncfusion](https://raw.githubusercontent.com/Texnomic/SecureDNS/master/docs/Syncfusion.png "Syncfusion")

repository: kpanoulas/SecureDNS

repo_name: kpanoulas/SecureDNS


text:
## Part II

#### Program 1: Fibonacci
* Returns the last digit of the Nth Fibonacci Number.

```c
$ make fib
$ ./fib 16
```

#### Program 2: Simple Shell
* Makeshift copy of the Linux Shell.
```
$ make sshell
$ ./simple_shell
shell> ls -a
shell> echo $PATH
shell> date
```

#### Program 3: Signal Block
* Print numbers [1-10] from the child process. It waits 1 second before printing out the next number. This program only accepts **run** and **exit**
```c
$ make sigblock
$ ./shell
shell> run
shell> exit
```

## Part III

```c
$ make
$ ./artist_manager
shell> help
shell> date
shell> hire [N]
shell> fire [X]
shell> fireall
shell> assign [X]
shell> withdraw [X]
shell> list
shell> exit
```

* arguments are held in an array called `my_argv` which is like a copy of main's `*argv[]`
* begin the program by filling the array `my_argv` with the commands.
   - method called `fill_argv()` fills the arg_v, separating the user input by a space.
* catch `CTRL+C` and when it does, it properly exits the program.
* `help` prints all the possible commands and a short information about them.
* `date` prints the date.
* `hire [N]` where N is an integer. Creates N number of "processes" or "artists". The PID and the Status is stored in a linked list called `artists` in `artist_ds.c`
* `fire [X]` where X is the PID (process ID) - can be found by using `list`. This basically kills or "fires" the process/"artist". Data about them is removed from `artists` as well.
   1. If X's status is `ASSIGNED` then withdraw them first.
* `fireall` "Fires" or kills all the processes/"artists". Data about them is removed from `artists` as well.
   1. If the current process status is `ASSIGNED` then withdraw them first.
* `assign [X]` where X is the PID (process ID) - can be found by using `list`. This basically changes the status of the currently still running processes/artists whose status is `WAITING` that they have a job now. Their status' are updated in the linked-list.
    1. prints out **"ARTIST X IS ASSIGNED TO A JOB"** when successful. Their status is changed to `ASSIGNED`
    2. prints out **"ARTIST X IS ALREADY ASSIGNED TO A JOB"** if you try to assign an artist that has already been assigned.
    3. prints out **"ARTIST X DOES NOT EXIST"** if you try to assign an artist that you have not hired (not in the database)
* `withdraw [X]` where X is the PID (process ID) - can be found by using `list`. This basically changes the status of the currently still running processes/artists whose status is `ASSIGNED` that they don't have a job now. Their status' are updated in the linked-list.
    1.  Their status is changed to `WAITING`
    2. prints out **"ARTIST X CANNOT BE WITHDRAWN FROM A NONEXISTENT JOB"** if you try to withdraw an artist whose status is `WAITING`
    3. prints out **"ARTIST X DOES NOT EXIST"** if you try to withdraw an artist that you have not hired (not in the database)`
* `list` - prints out all the current artists/processes in the database.
* `exit` - fires all of the employees. If the current process status is `ASSIGNED` then withdraw them first. Cleans up database. Flush. Byebye.

### Data Structure
* `artists` is a linked-list
   - Has 3 attributes:
       1. PID
       2. Status
       3. Pointer to NEXT

* `my_argv` is an array that holds the command and if there is a number that follows it, then it will be in the next index.

repository: deannaliu/Artist-Manager

repo_name: deannaliu/Artist-Manager


text:
This page is a five-minute introduction to the T4 Python API. To try out the T4 catalog, [visit the demo catalog](https://alpha.quiltdata.com/b/quilt-example).

## Data packages

The core concept in T4 is that of a **data package**. A data package is a logically self contained group of files which provide some unit of value.

For example, suppose that you are a data scientist analyzing October sales at an apparel store. Your code might depend on the following set of files:

```bash
october_2018_clothing_sales
    sales-snapshot-11-01.parquet
    sales-snapshot-11-02.parquet
    ...
    sales-snapshot-11-31.parquet
```

T4 allows you to create, edit, and distribute groups of files like this one as a single cohesive group—a data package. This gives your data a host of useful properties:

* **modularization**—data packages allow you express your data dependencies the same way you express your code dependencies: in groups of functional, well-documented modules
* **versioning**—data packages provide version control for data
* **reproducibility**—data packages are immutable and persistent, ensuring continuous reproducibility
* **accessibility**—anyone with access to your T4 instance can browse, explore, download, and even reuse your data package

## Before you begin

To get started, you will first need to [install the `t4` Python package](./Installation.md). Then import it:

```python
import t4
```

For demo purposes we will use a small dataset tracking an 1851 hurricane in the Atlantic Ocean, which we'll persist to disk immediately:

```python
import pandas as pd
data = pd.DataFrame({
    'id': ['AL011851']*5,
    'name': ['Unnamed']*5,
    'date': [f'1851-06-25 {hr}:00:00' for hr in
             ['00', '06', '12', '18', '21']],
    'status_of_system': ['HU']*5,
    'latitude': [28.0, 28.0, 28.0, 28.1, 28.2],
    'longitude': [-94.8, -95.4, -96.0, -96.5, -96.8]
})
data.to_csv("atlantic-storm.csv")
```

## Creating a package

To initialize an in-memory data package, use the `Package` constructor:

```python
# define a package
p = t4.Package()
```

Use `set` to add a file to a package, or `set_dir` to add an entire folder:

```python
# add a file
p.set('storms/atlantic-storm.csv', "atlantic-storm.csv")
# add a folder
p.set_dir('storms/', './')
```

You can point a package key at any local file or S3 key.

Packages support metadata on data nodes (directories too):

```python
p.set('storms/atlantic-storm.csv', 'atlantic-storm.csv', meta={'ocean':'atlantic'})
```

Packages mimic `dict` objects in their behavior. So to introspect a package, key into it using a path fragment:

```bash
p['storms']  # outputs just "atlantic-storms.csv"
```

You can interact with directories and files inside of a package once you're at their key. For example, use `get_meta` to get the metadata:

```python
p['storms/atlantic-storms.csv'].get_meta()
# outputs {'side': 'atlantic'}
```

Use `fetch` to download the data to a file or a directory:

```python
p['storms/atlantic-storms.csv'].fetch('another-copy-of-storms.csv')
```

You can also load certain types of entries directly into memory:

```python
p['storms/atlantic-storms.csv']()
# outputs <pandas.DataFrame at ...>
```

## Pushing a package

Suppose that you've create a package and want to share it with the rest of your team. T4 allows you to do so by pushing your package to a T4 **catalog**, which sits on top of an S3 bucket and allows anyone with access to that bucket to see, push, and download packages in that bucket.

Note that this section, and the next, require a catalog you have access to.

To make a package available on (and downloadable from) a catalog, use `push`, parameterized with the name of the package (a `username/packagename` pair) and the identifier for the S3 bucket you are pushing to:

```python
p.push('username/packagename', 's3://your-bucket')
```

Alternatively, you may wish to save a package locally. To do this, use `build`:

```python
p.build('username/packagename')
```

## Installing a package

To see all the packages available on a catalog, use `list_packages`:

```python
t4.list_packages('s3://your-bucket')
# outputs ['username/packagename', 'foo/bar']
```

To download a package and all of its data from a remote catalog to a `dest` on your machine, `install` it.

```python
p = t4.Package.install('username/packagename', 's3://your-bucket', dest='temp_folder/')
```

You can also choose to download just the  **package manifest** without downloading the data files it references. A package manifest is a simple JSON metadata file that is independent of the actual package data:

```python
# get just the manifest, not the data
p = t4.Package.browse('username/packagename', 's3://your-bucket')
```

`browse` is useful when you only need part of a package, or only want to inspect a package's metadata. You can `browse`, then `fetch`, to get data of interest:

```python
p = t4.Package.browse('username/packagename', 's3://your-bucket')
p['resources'].fetch('temp/')
```

## Importing a package

Once you've installed a package locally you can import it in Python.

```python
from t4.data.username import packagename
```

This lets you manage the data and code dependencies in your code all in one place!