text:
# Go

The Go language does not have templates, but there is a recent proposal to add
them:

https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md

An example of a template `T` of a type / constraint `any` (constraint is the
same as concept in C++):

```go
// Note: the type `any` is already defined implicitly
type any interface {
}

// Print prints the elements of a slice.
// It should be possible to call this with any slice value.
func Print[T any](s []T) { // Just an example, not the suggested syntax.
    for _, v := range s {
        fmt.Println(v)
    }
}
```

A template of type `any` must work with any user type, and so only a few
[basic
operations](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#operations-permitted-for-any-type) are allowed. It is implicitly
[defined
](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#the-constraint) as above.

As an example, this function will not compile because type `any` does not have a
`.String()` method:

```go
// This function is INVALID.
func Stringify[T any](s []T) (ret []string) {
    for _, v := range s {
        ret = append(ret, v.String()) // INVALID
    }
    return ret
}
```

To fix that, we have to define a new constraint:

```go
// Stringer is a type constraint that requires the type argument to have
// a String method and permits the generic function to call String.
// The String method should return a string representation of the value.
type Stringer interface {
    String() string
}
```

and use it in the `Stringify` function:

```go
// Stringify calls the String method on each element of s,
// and returns the results.
func Stringify[T Stringer](s []T) (ret []string) {
    for _, v := range s {
        ret = append(ret, v.String())
    }
    return ret
}
```

This approach is what C++ calls *strong concepts*.

Some of the
[features of this approach](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#constraints):

* When the `Stringify` generic function compiles and no errors are reported,
  that function is valid no matter how it is called. The `Stringer` constraint
  is part of the function signature.

* We don‘t want to derive the constraints from whatever Stringify happens to do (in this case, call the String method). If we did, a minor change to Stringify might change the constraints. That would mean that a minor change could cause code far away, that calls the function, to unexpectedly break. It’s fine for Stringify to deliberately change its constraints, and force callers to change. What we want to avoid is Stringify changing its constraints accidentally.

* This means that the constraints must set limits on both the type arguments passed by the caller and the code in the generic function. The caller may only pass type arguments that satisfy the constraints. The generic function may only use those values in ways that are permitted by the constraints. This is an important rule that we believe should apply to any attempt to define generic programming in Go: generic code can only use operations that its type arguments are known to implement.

This is to be contrasted with traditional C++ templates which have no concepts,
that have the following property:

* The `Stringify` function gets compiled, but it can still fail at the call site
  with a complicated (nested) error such as no method `.String()`.

* The constaints are not part of the function signature, and as a result the
  compiler must examine the function itself at every call site to ensure
  everything works, which causes long / unfriendly error messages and long
  compile times.

See also the proposal's comparison with C++ and Rust:

* [Comparison with
  C++](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#comparison-with-c)
* [Comparison with
  Rust](https://go.googlesource.com/proposal/+/refs/heads/master/design/go2draft-type-parameters.md#comparison-with-rust)

**Question**: What is the difference between Go templates with constraints /
interfaces (this proposal) and the existing
Go interfaces ([1](https://golangdocs.com/interfaces-in-golang) and [2](https://golangbot.com/interfaces-part-1/))?

**Answer**: It seems that Go interfaces are resolved at runtime, while Go
templates are strictly resolved at compile time. That might be the only main
difference.

# C++

## Traditional Templates

The `Stringify` example in C++ would look like:

```c++
template <typename T>
std::string Stringify(const std::vector<T> &s) {
    std::string ret;
    for (auto &v : s) {
        ret.append(v.String());
    }
    return ret;
}
```

And this compiles. Here is how it could be used in the main program:

```c++
class MyT
{
public:
    std::string String() const {
        return "X";
    }
};

int main() {
    std::vector<MyT> v(3);
    std::cout << Stringify(v) << std::endl;
    return 0;
}
```

See the [traditional.cpp](./traditional.cpp) file for a complete program that
compiles and runs.

There are *no concepts*. As a result, if you remove the `String()` method from
`MyT`, you get the following error message with g++ 10:

    a.cpp: In instantiation of ‘std::string Stringify(const std::vector<T>&) [with T = MyT; std::string = std::__cxx11::basic_string<char>]’:
    a.cpp:20:29:   required from here
    a.cpp:9:22: error: ‘const class MyT’ has no member named ‘String’
        9 |         ret.append(v.String());
          |                    ~~^~~~~~

This error gets a lot more complicated and nested in practice if the
`Stringify` function calls other templates functions and the error is in the
inner most one.

But even in this simple example, the error that is reported is in the
`Stringify` function, which compiled fine on its own, but failed at
instantiation time. This is the main feature of *no concepts*.

## C++20 Concepts Light

C++20 has [light
concepts](https://en.cppreference.com/w/cpp/language/constraints). The
above `Stringify` example with C++ concepts would look like:

```c++
template<typename T>
concept Stringer = requires(const T &t) {
    { t.String() } -> std::same_as<std::string>;
};

template <Stringer T>
std::string Stringify(const std::vector<T> &s) {
    std::string ret;
    for (auto &v : s) {
        ret.append(v.String());
    }
    return ret;
}
```

And it would be used exactly as before.
See the [concepts-light.cpp](./concepts-light.cpp) file for a complete program
that compiles and runs.

If you remove the `String()` method from `MyT`, you get an error:

    concepts-light.cpp: In function ‘int main()’:
    concepts-light.cpp:30:29: error: use of function ‘std::string Stringify(const std::vector<T>&) [with T = MyT; std::string = std::__cxx11::basic_string<char>]’ with unsatisfied constraints
       30 |     std::cout << Stringify(v) << std::endl;
          |                             ^
    concepts-light.cpp:15:13: note: declared here
       15 | std::string Stringify(const std::vector<T> &s) {
          |             ^~~~~~~~~
    concepts-light.cpp:15:13: note: constraints not satisfied
    concepts-light.cpp: In instantiation of ‘std::string Stringify(const std::vector<T>&) [with T = MyT; std::string = std::__cxx11::basic_string<char>]’:
    concepts-light.cpp:30:29:   required from here
    concepts-light.cpp:10:9:   required for the satisfaction of ‘Stringer<T>’ [with T = MyT]
    concepts-light.cpp:10:20:   in requirements with ‘const T& t’ [with T = MyT]
    concepts-light.cpp:11:15: note: the required expression ‘t.String()’ is invalid
       11 |     { t.String() } -> std::same_as<std::string>;
          |       ~~~~~~~~^~
    cc1plus: note: set ‘-fconcepts-diagnostics-depth=’ to at least 2 for more detail

Compared to the "traditional templates", this error now happens at the call
site, saying that the user type `MyT` is not satisfying the concept `Stringer`,
because it does not have the `.String()` method.

If however we change the `Stringify` function to call a method `String2()`
instead of `String()`, the function still compiles fine, but we get an error at
instantiation time:

    concepts-light.cpp: In instantiation of ‘std::string Stringify(const std::vector<T>&) [with T = MyT; std::string = std::__cxx11::basic_string<char>]’:
    concepts-light.cpp:33:29:   required from here
    concepts-light.cpp:18:22: error: ‘const class MyT’ has no member named ‘String2’; did you mean ‘String’?
       18 |         ret.append(v.String2());
          |                    ~~^~~~~~~
          |                    String

And if we remove the `main()` function, we do not get any error at all and the
`Stringify` function happily compiles.

It is for this reason we are calling this *concepts light*. If they were strong
concepts such as in the Go language, the error would happen while compiling the
function `Stringify` and it would say the Concept `Stringer` does not have a
`.String2` method, and it would not say anything about `MyT`, as that would be
irrelevant.

In other words, the concepts light will check user's code that the `MyT` type
satisfies the `Stringer` concept. But they will not check the library code, that
the `Stringify` function is written correctly and only uses methods declared by
the `Stringer` concept.

# Rust

Rust implements
[generics](https://doc.rust-lang.org/rust-by-example/generics.html)
using type parameters and restricts them using traits,
which are essentially *strong concepts*.
The `Stringify` example in Rust looks like:

```rust
trait Stringer {
    fn string(&self) -> &'static str;
}

fn stringify<T : Stringer>(s: Vec<T>) -> String {
    let mut ret = String::new();
    for x in s.iter() {
        ret.push_str(x.string());
    }
    ret
}
```

and it can be used like this:

```rust
struct MyT {
}

impl Stringer for MyT {
    fn string(&self) -> &'static str {
        "X"
    }
}

fn main() {
    let v = vec![MyT{}, MyT{}, MyT{}];
    println!("{}", stringify(v));
}
```

See the [traits.rs](./traits.rs) file for a complete program
that compiles and runs.

If we remove the `string` method implementation from MyT, we get the following
compiler error:

    error[E0277]: the trait bound `MyT: Stringer` is not satisfied
      --> traits.rs:21:30
       |
    8  | fn stringify<T : Stringer>(s: Vec<T>) -> String {
       |    ---------     -------- required by this bound in `stringify`
    ...
    21 |     println!("{}", stringify(v));
       |                              ^ the trait `Stringer` is not implemented for `MyT`

    error: aborting due to previous error

    For more information about this error, try `rustc --explain E0277`.

This error happens at the call site, saying the user type does not satisfy the
trait. The error is semantically equivalent to the C++ concepts error above,
just worded in a more user friendly way.

If we change the `stringify` function to call a method `string2()`
instead of `string()`, we get the following error:

    error[E0599]: no method named `string2` found for type `&T` in the current scope
      --> traits.rs:11:24
       |
    11 |         ret.push_str(x.string2());
       |                        ^^^^^^^ help: there is a method with a similar name: `string`

    error: aborting due to previous error

    For more information about this error, try `rustc --explain E0599`.

Unlike in C++, the function `stringify()` does not compile, because we are using
a method that is not defined for the type `T`.

For this reason we can say that Rust implements *strong concepts*.

Similar to Go, if we define the `stringify` function using an unrestricted
template `T`:

```rust
fn stringify<T>(s: Vec<T>) -> String {
    let mut ret = String::new();
    for x in s.iter() {
        ret.push_str(x.string());
    }
    ret
}
```

we get the following compiler error while compiling this function:

    error[E0599]: no method named `string` found for type `&T` in the current scope
      --> traits.rs:11:24
       |
    11 |         ret.push_str(x.string());
       |                        ^^^^^^ method not found in `&T`
       |
       = help: items from traits can only be used if the type parameter is bounded by the trait
    help: the following trait defines an item `string`, perhaps you need to restrict type parameter `T` with it:
       |
    8  | fn stringify<T: Stringer>(s: Vec<T>) -> String {
       |              ^^^^^^^^^^^

    error: aborting due to previous error

    For more information about this error, try `rustc --explain E0599`.

The Rust compiler even noticed that we have a Trait that would work and it
suggests how to modify the code to make it compile.

Unlike in C++, where this compiles and we get an error at instantiation time.

# Haskell

Haskell implements
[generics](https://wiki.haskell.org/Generics)
using [type classes](https://www.haskell.org/tutorial/classes.html)
and restricts them using [constraints](https://en.wikibooks.org/wiki/Haskell/Classes_and_types),
which are essentially *strong concepts*.
The `Stringify` example in Haskell looks like:

```haskell
class Stringer t where
  string :: t -> String

stringify :: String t => [t] -> String
stringify (only:[]) = string only
stringify (first:rest) = (string first) ++ (stringify rest)
```

and it can be used like this:

```haskell
data MyT = MyT

instance String MyT where
  string :: MyT -> String
  string _ = "X"

main :: IO ()
main = do
  let v = [MyT, MyT, MyT]
  putStrLn (stringify v)
```

See the [type_classes.hs](./type_classes.hs) file for a complete program
that compiles and runs

If we remove the instance declaration we get the following
compiler error:

```
[1 of 1] Compiling Main             ( type_clases.hs, type_clases.o )

type_clases.hs:16:13: error:
    • No instance for (Stringer MyT) arising from a use of ‘stringify’
    • In the first argument of ‘putStrLn’, namely ‘(stringify v)’
      In a stmt of a 'do' block: putStrLn (stringify v)
      In the expression:
        do let v = ...
           putStrLn (stringify v)
   |
16 |   putStrLn (stringify v)
   |             ^^^^^^^^^^^
```

This error happens at the call site, saying the user type does not satisfy the
constraint (i.e. does not have an instance for the type class `Stringer`). If
we remove only the definition of the `string` function for the `Stringer MyT`
instance, we get the following compiler warning and subsequent run-time error.

```
[1 of 1] Compiling Main             ( type_clases.hs, type_clases.o )

type_clases.hs:10:10: warning: [-Wmissing-methods]
    • No explicit implementation for
        ‘string’
    • In the instance declaration for ‘Stringer MyT’
   |
10 | instance Stringer MyT where
   |          ^^^^^^^^^^^^
Linking type_clases ...

$ ./type_clases                                                                                (add_haskell_to_examples)
type_clases: type_clases.hs:10:10-21: No instance nor default method for class operation string
```

If we change the stringify function call the `string2` function instead of
`string`, we get the following error:

```
[1 of 1] Compiling Main             ( type_clases.hs, type_clases.o )

type_clases.hs:5:24: error:
    • Variable not in scope: string2 :: t -> String
    • Perhaps you meant ‘string’ (line 2)
  |
5 | stringify (only:[]) = string2 only
  |                       ^^^^^^^

type_clases.hs:6:27: error:
    • Variable not in scope: string2 :: t -> [Char]
    • Perhaps you meant ‘string’ (line 2)
  |
6 | stringify (first:rest) = (string2 first) ++ (stringify rest)
  |                           ^^^^^^^
```

Unlike in C++, the function `stringify` does not compile, because we are using
a method that is not defined for the type class `Stringer`.

For this reason we can say that Haskell implements *strong concepts*.

Similar to Go and Rust, if we define the `stringify` function using an unrestricted
type parameter `t`:

```haskell
stringify :: [t] -> String
stringify (only:[]) = string only
stringify (first:rest) = (string first) ++ (stringify rest)
```

we get the following compiler error while compiling this function:

```
[1 of 1] Compiling Main             ( type_clases.hs, type_clases.o )

type_clases.hs:5:23: error:
    • No instance for (Stringer t) arising from a use of ‘string’
      Possible fix:
        add (Stringer t) to the context of
          the type signature for:
            stringify :: forall t. [t] -> String
    • In the expression: string only
      In an equation for ‘stringify’: stringify (only : []) = string only
  |
5 | stringify (only:[]) = string only
  |                       ^^^^^^^^^^^
```

The Haskell compiler even noticed that the use of `string` implies the need for
the type class `Stringer` and suggests adding it to the type signature.

Unlike in C++, where this compiles and we get an error at instantiation time.


text:
# Acacia vernicosa Standl. SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Contr. U. S. Natl. Herb. 20:187. 1919 (non W. Fitzg. 1904)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Magnoliopsida/Fabales/Fabaceae/Acacia/Acacia neovernicosa/ Syn. Acacia vernicosa/README.md

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: mdoering/backbone


text:
Sample transcripts

Moderator: I'd like to introduce to you tonight Marit MacArthur, who will be ...

Marit: This is my poem.

Marit: It begins/
  Poem continues /
  Stanza ends.

Marit: Stanza: start /
  And on /
  And on.

Moderator: Are there any questions?

Q1: Blah...

TODO(rmo): Documentation on speaker diarization input

# Getting windowed output

Open the Javascript Console.
Expand _exactly_ one item in the UI.

Copy the code from "windowed.js" into the console.

Run `get_windowed(window_duration, step_duration)`, adjusting
window_duration and step_duration (both in seconds) as necessary.

Use the "output" variable to dump data however you'd like.

# LZ Complexity

```sh
git clone https://GitHub.com/Naereen/Lempel-Ziv_Complexity
cd Lempel-Ziv_Complexity/src/
make build2
make test     # should pass
sudo make install2  # mv the build/lib*/*.so files where you need them
```

# electron-webpack-quick-start
> A bare minimum project structure to get started developing with [`electron-webpack`](https://github.com/electron-userland/electron-webpack).

Thanks to the power of `electron-webpack` this template comes packed with...

* Use of [`webpack-dev-server`](https://github.com/webpack/webpack-dev-server) for development
* HMR for both `renderer` and `main` processes
* Use of [`babel-preset-env`](https://github.com/babel/babel-preset-env) that is automatically configured based on your `electron` version
* Use of [`electron-builder`](https://github.com/electron-userland/electron-builder) to package and build a distributable electron application

Make sure to check out [`electron-webpack`'s documentation](https://webpack.electron.build/) for more details.

## Getting Started
Simply clone down this reposity, install dependencies, and get started on your application.

The use of the [yarn](https://yarnpkg.com/) package manager is **strongly** recommended, as opposed to using `npm`.

```bash
# create a directory of your choice, and copy template using curl
mkdir new-electron-webpack-project && cd new-electron-webpack-project
curl -fsSL https://github.com/electron-userland/electron-webpack-quick-start/archive/master.tar.gz | tar -xz --strip-components 1

# or copy template using git clone
git clone https://github.com/electron-userland/electron-webpack-quick-start.git
cd electron-webpack-quick-start
rm -rf .git

# install dependencies
yarn
```

### Development Scripts

```bash
# run application in development mode
yarn dev

# compile source code and create webpack output
yarn compile

# `yarn compile` & create build with electron-builder
yarn dist

# `yarn compile` & create unpacked build with electron-builder
yarn dist:dir
```

license: MIT


text:
## Cycling Teams

| Team | ShrtNm | Nation | Level | Focus |
|-------|-------|---------|-------|-----|
| Telecom Archana | TEL | [[Archana]] | Pro | [[TT]]Hilly
| Ultraboost Energy Drink | UED | [[Archana]] | Pro | [[HillyMountain]]
| Archana Tourism | ART | [[Archana]] | Pro | [[TT]]Flat
| Rail'n Road Transports | RRT | [[Archana]] | Amateur | [[FlatHilly]]
| Hinterlands Adventures | HAD | [[Archana]] | Amateur | [[Hilly]]
| Archon Fitness Racing | ARC | [[Archana]] | Amateur | [[TT]]Flat
| Channel 69 Cycling | CHC | [[Archana]] | Amateur | [[Flat]]
| Hector Morales Cycling | HMC | [[Archana]] | Amateur | [[HillyMountain]]

## Races

| Name | Short Name | Prestige | Type | Nation | Terrain | Length |
|-----|------|------|-----|----|-----|-----|----|---|
| Archana Tour | [[ArchTour]] | 8 | Pro | [[Archana]] | [[Hilly]] | 14 Stages
| Three Country Challenge | [[3CC]] | 7 | Pro | [[Archana]] | [[FlatHilly]] | 7 Stages
| Mara Lake Circuit | [[Mara]] | 7 | Pro | [[Archana]] | [[FlatHilly]] |
| ITT World Invitational | [[ITTW]] | 7 | Pro | [[Archana]] | [[Hilly]][[TT]] | 5 Stages
| Hinterlands Tour | [[Hinter]] | 6 | Mixed | [[Archana]] | [[Hilly]] | 6 Stages
| TTT Challenge | [[TTTC]] | 6 | Mixed | [[Archana]] | [[Flat]][[TT]] |
| Southern Loop | [[SLoop]] | 6 | Amateur | [[Archana]] | [[Hilly]] |
| Hills of Wazduk | [[Wazduk]] | 5 | Amateur | [[Archana]] | [[Hilly]] |
| Road to Novobeskov | [[Novo]] | 5 | Amateur | [[Archana]] | [[FlatHilly]] | 3 Stages

repository: jju/bike

repo_name: jju/bike


text:
SasStudent Utility
==================
This is a small utility for automating user account management via SAS2000. If you
don't run that software, then you should not enable the utility.

If you don't number user accounts according to the 'code' attribute, then you should
also not enable this utility.

Installation
------------

On the Auth server, you need access to the sqsh command, and you need to install and configure FreeTDS to work with your version of Microsoft SQL Server. The instructions on [this blog post](http://le-gall.net/pierrick/blog/index.php/2006/09/06/79-how-to-use-linux-as-a-microsoft-sql-server-client) works for MSSQL 2008.

On the Microsoft SQL server, create a _read-only_ user account for Auth to get
its data from. Give it access to a simple view of student data. The view I use is:

    SELECT     Code, FirstName, LastName, PreferredName, Year, Class, ID
    FROM         dbo.Student
    WHERE     (PreEnrolment = 'N')

Next, enable the utility by adding an entry to the Util list in config.php:

    'SasStudent' => 'SAS Student'

And finally, add all of the configuration options that the utility will be using:

    'SasStudent' =>
        array(  'host' => 'hostname',
                'name' => 'databasename',
                'user' => 'authusername',
                'pass' => 'verysecretpassword',
				'view' => 'dbo.authStudentView',
                // Service to check for accounts in
                'check'  =>'ldap',
                // Domain to check for accounts in
                'domain' =>'(the domain where student accounts go)',
                // Services to create accounts on
                'create' => array('ldap', 'something', 'something-else')
            )


text:
# gofish

```
       o                 o
                  o
         o   ______      o
           _/  (   \_
 _       _/  (       \_  O
| \_   _/  (   (    0  \
|== \_/  (   (          |
|=== _ (   (   (        |
|==_/ \_ (   (          |
|_/     \_ (   (    \__/
          \_ (      _/
            |  |___/
           /__/

BLU BLU BLU
```

## Installation

    go get github.com/avinassh/gofish
    go install github.com/avinassh/gofish

Then you can run `gofish` on the command line to go BLU BLU BLU!

## Docker
```
docker build -t gofish .
docker run -t gofish
```
## License

The mighty MIT license. Please check `LICENSE` for more details.

repository: avinassh/gofish

gha_language: Go

repo_name: avinassh/gofish


text:
[![Slack][slack-badge]][slack-link]

# Koi

Project scaffolder, with a focus on simplicity.

## Install

With [fisherman]

```
fisher koi
```

## Usage

```
koi your/repo folder
```

## Templates
There are only a few koi-specific files, all of which are found in the root directory:
```
.
├── ".intro"
├── ".postinstall"
├── ".preinstall"
└── ".vars"
```

A list of available templates can be found [here](./templates.txt).

### .intro

At times you want to present or explain some info to the template user. This can be done by writing text in `.intro`. Only the first 10 lines will be printed during the scaffolding process, to encourage conciseness.

### .preinstall/.postinstall
`.preinstall` and `postinstall` are executables.

Because the entire environment is available to you, the things you could do are endless. You could, for example:

1. Install CLI tools (sass compiler, for example).
2. Clone a framework into a directory.

Please inspect the templates you use for malicious commands before you install the templates.

### .vars
Your template folder should have a `.vars` file in the root directory. Write each variable name in a separate line as follows:

```
foo
bar
baz
```

`koi` will substitute all appearances of `{{{variable-name}}}` in files, filenames and folder-names with user-input during the scaffolding process. For example of a template, look at [koi-template].

## Credit

Much of the code was based off [fisherman/new], written by @bucaran.

[slack-link]: https://fisherman-wharf.herokuapp.com
[slack-badge]: https://fisherman-wharf.herokuapp.com/badge.svg
[fisherman]: https://github.com/fisherman/fisherman

[fisherman/new]:https://github.com/fisherman/new
[koi-template]: https://github.com/jethrokuan/koi-template

repository: jethrokuan/koi

repo_name: jethrokuan/koi


text:
---
layout: default
---

# 1997-08-27 - Broadcast Email Friendly Mailing & Web Hosting

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 131d1252adfaff78b2756bd0220aef50db5ded612ad9d8b631a0f4ea74f62bac

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-08-27 03:24:23 UTC

Raw Date: Tue, 26 Aug 1997 20:24:23 -0700 (PDT)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Tue, 26 Aug 1997 20:24:23 -0700 (PDT)
To<EMAIL_ADDRESS>Subject: Broadcast Email Friendly Mailing & Web Hosting
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<HTML><PRE><BODY BGCOLOR="#000000"><FONT COLOR="#00FFFF" SIZE=3>
Finally, EVERYTHING you need to REALLY market your business
on the Internet.

* Broadcast EMAIL FRIENDLY web hosting!
* Broadcast EMAIL FRIENDLY Service Provider!
* Broadcast EMAIL FRIENDLY consulting!
* Fresh Up to Date E-mail Mailing Lists!
* Bulk E-mail Software!

PLUS

We can help you accept all forms of ELECTRONIC payments from your home or
business.

If you've spent any time marketing on the Internet,
you know that  in order to make any serious money
 you MUST send broadcast e-mail.

Your online business survival depends on the quality and
consistency of your broadcast email.

You NEED to be able to market your products
and/or services cost  effectively.

Nothing has proven to be more cost effective
 than broadcast e-mail.
We can send it for you.
________YES- mail my message to 500,000 responsive
 buyers for LESS THAN ONE U.S. DOLLAR
per thousand for a total of $359.95
_______YES-mail my message to 1,000,000 responsive
 buyers for  a  total of $659.95
________YES, mail my message to 2,000,000 responsive
buyers for a total of $1199.95

Or,
We can make it affordable so You can send it yourself.
_____YES-  send me 100,000 email addresses for ONLY  $59.95
_____YES - send me 400,000 email addresses for ONLY  $229.95
Less than 22 cents per thousand
_____YES-  send me 1,000,000 email addresses for ONLY $399.95
Less than 17 cents per thousand.

Need information on broadcast email software
 to expedite mailing  these lists?
Give us a call -<PHONE_NUMBER>

Even if you receive 1/10 of 1% response for mailing
1,000,000 email addresses  you would receive 1000 replies!!!!

How much money would you make?

Need your own server to mail from?
Give us a call -<PHONE_NUMBER>

Prefer to send broadcast email  from our server?
(Allow 10 days account setup)
Total Account charges
Basic Server Use  $150.00 per month.
Total Due (1st & last):____________
Set-up Fee ($85)	____________
(allow 10 business days for account set-up)
Call today -<PHONE_NUMBER>

WE ACCEPT ALL FORMS OF
ELECTRONIC PAYMENT FOR YOUR CONVENIENCE
Credit Cards
Voice Check
Fax check
E-mail Check

Need broadcast email friendly web hosting?
Our Broadcast E-mail Friendly Web Sites Include:
Up to 1 Full Gigabyte of data transfer per day
Free Disk Storage up to 10 MB
1 Domain Name
Free POP 3 Account - additional accts are $10. each/month
Free Business E-mail address - additional addresses -
$5 each per month
Secure Server available
Unlimited E-mail aliases - $10 per month - $25. set up
Access via FTP or Telnet
Tech support by telephone or e-mail
Micrsoft Front Page support
Free Web Page Statistics
Convenient Site Modificatioon 24 hours per day.

Our Basic Website Hosting Package includes
all the above for only $35. per month, with a $50. set up fee.
First & last month's rent due at set up.

Our Virtual Domain Website Hosting Package  includes
all the above including your own virtual domain
for only $45.00 per month with a  $85 setup plus
 Internic charges.

Let us help you create your own media company.

Decide for yourself what works best for your online business.

Call<PHONE_NUMBER> to receive your end-user agreement
by  fax or call  just to get up to speed on the possibilities.

Or send an e-mail message to Realbusiness@

We've got what you need!

START YOUR COMPLETE INTERNET MARKETING PROGRAM TODAY!

 ORDER FORM
I an interested in:
Broadcast E-mail Friendly Web Hosting ________________
Basic ($35 per month) ____ Virtual ($45 per month) _____

Broadcast EMAIL FRIENDLY Service Provider __________
($150.00 per month, $85. setup)

Broadcast EMAIL FRIENDLY consulting _____________
(FREE initial consultation)

Fresh Up to Date E-mail Mailing Lists _____________
100,000 _______ 400,000 _____ 1,000,000 ________

Bulk E-mail Software _______________
(Call for Quote)

I would prefer Phoenix@Global Enterprises to handle my mailing
500,000 ____________
1,000,000 __________
2,000,000__________
Name____________________________________________
Address__________________________________________
City____________________State_______Zip___________
Email___________________________________________
Phone__________________________________________
Check Ordering Info:
Name (exactly as it appears on check)
_______________________________________
Check # _______________
Dollar Amount	$________________
Telephone #__________________
Bank Name:_____________________
Bank Address ______________________________________________
Numbers at Bottom of Check(read from left to right, please indicate
blank spaces with a space:
_______________________________________________

</FONT><FONT  COLOR="#000000" SIZE=3>

{% endraw %}
```

## Thread

+ Return to [August 1997](/archive/1997/08)

+ Return to "[brad@yielding.com](/authors/brad_at_yielding_com)"

+ 1997-08-27 (Tue, 26 Aug 1997 20:24:23 -0700 (PDT)) - Broadcast Email Friendly Mailing & Web Hosting -<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# Roaring.jl

**Roaring bitmaps for julia**

## Description

**This package is currently (pre)alpha stage**

## Badges

## Documentation

## Install

This package is currently in development, so you will have to use
`Pkg.clone` in order to install it.

## Contributing

I appreciate contributions from users including reporting bugs, fixing issues,
improving performance and adding new features.

gha_language: Julia


text:
---
title: "The magic of neural networks"
author: matt_gregory
comments: yes
date: '2016-04-10'
modified: 2016-04-11
layout: post
excerpt: "Student attainment prediction with neural networks"
published: true
status: publish
tags:
- R
- machine learning
- education
categories: Rstats
---

{% include _toc.html %}

Education is a key factor affecting long term economic progress. Success in the core subjects provide a linguistic and numeric scaffold for other subjects later in students' academic careers.The growth in school educational databases facilitates the use of Data Mining and Machine Learning practises to improve outcomes in these subjects by identifying factors that are indicative of failure (or success). Predicting outcomes allows educators to take corrective measures for weak students mitigating the risk of failure.

## The Data
The [data](https://archive.ics.uci.edu/ml/datasets/Student+Performance) were downloaded from the UCI Machine Learning database and inspired by Cortez *et al*., 2008. We used the maths results data only.

## The Approach

_"Any sufficently advanced technology is indistinguishable from magic."_ - Arthur C. Clarke

As a scientist I find any computational methodology that is loosely based on how the brain works inherently interesting. Although somewhat derided for its complexity and computational expense, this approach has seen a resurgence in popularity with deep learning problems, such as Youtube [cat video identification](http://www.wired.com/2012/06/google-x-neural-network/). We tackle a simpler problem here that I previously approached with the decision tree method. Let's see how the default methods compare to the 95% classification accuracy of the decision tree, which also had the benefit of being readily intelligible.

Neural networks use concepts borrowed from an understanding of animal brains in order to model arbitary functions. We can use multiple hidden layers in the network to provide deep learning, this approach is commonly called the Multilayer Perceptron.

{% highlight r %}
#PACKAGES
library(dplyr)
library(neuralnet)
library(RItools)
library(devtools)

source_url('https://gist.github.com/fawda123/7471137/raw/cd6e6a0b0bdb4e065c597e52165e5ac887f5fe95/nnet_plot_update.r')

set.seed(1337)

#INPUT
mydata <- "data/2016-04-10-neuralnet_student_perf.csv"
mydata <- read.table(mydata, sep = ";",
                     header = TRUE)
#mydata <- tbl_df(mydata)
{% endhighlight %}

From the codebook we know that `G3` is the final grade of the students. We can inspect it's distribution using a `hist`. It has been standardised to range from 0-20.

{% highlight r %}
hist(mydata$G3)
{% endhighlight %}

![plot of chunk 2016-04-10_hist](/figures/2016-04-10_hist-1.svg)

## The magical black box that is the neural networks
`G3` is pretty normally distributed, despite the dodgy tail. Previously we converted it into a binary output and then used a decision tree approach to make predictions from associated student characteristics. We use the neural network approach here while maintaining `G3` as an integer variable with a range of 1-20.

First we start off by identifying variables we think will be useful based on expert domain knowledge. We then [normalise](http://www.machinegurning.blog/rstats/student-performance/) the continuous variables to ensure equal weighting when measuring distance and check for missing values.

## Training and test datasets.
We need to split the data so we can build the model and then test it, to see if it generalises well. The data arrived in a random order so we split it in an analagous way to how we did it with the [decision tree](http://www.machinegurning.blog/rstats/student-performance/) method.

{% highlight r %}
data_train <- data_interest[1:350, ]  # we want to compare to decision tree method!
data_test <- data_interest[351:395, ] # all the columns or variables are selected

#data_train <- sample_frac(data_interest, 0.8)  # 80% train, 20% test
#data_test <- setdiff(data_interest, data_train)
{% endhighlight %}

Now we need to train the model on the data using the `neuralnet()` function using backpropogation from the package of the same name using the default settings. We specify a linear output as we are doing a regression not a classification. First we fit a model using relevant continuous normalised variables, omitting the non-numeric encoded factors, such as gender for now.

{% highlight r %}
#TRAIN the model on the data
#n <- names(data_train)
#f <- as.formula(paste("G3 ~", paste(n[!n %in% "G3"], collapse = " + ")))
# as pointed out by an R bloggers post, we mustwrite the formula and pass it as an argument
# http://www.r-bloggers.com/fitting-a-neural-network-in-r-neuralnet-package/

net_model <- neuralnet(G3 ~ G1 + G2 + goout +
       absences + failures + Fedu + Medu,
                            data = data_train, hidden = 1, linear.output = TRUE)
print(net_model)
{% endhighlight %}

{% highlight text %}
## Call: neuralnet(formula = G3 ~ G1 + G2 + goout + absences + failures +     Fedu + Medu, data = data_train, hidden = 1, linear.output = TRUE)
##
## 1 repetition was calculated.
##
##         Error Reached Threshold Steps
## 1 1.594919534    0.008259923976   710
{% endhighlight %}

{% highlight r %}
plot.nnet(net_model)
{% endhighlight %}

![plot of chunk 2016-04-10_net1](/figures/2016-04-10_net1-1.svg)

Generally, the input layer (I) is considered a distributor of the signals from the external world. Hidden layers (H) are considered to be categorizers or feature detectors of such signals. The output layer (O) is considered a collector of the features detected and producer of the response. While this view of the neural network may be helpful in conceptualizing the functions of the layers, you should not take this model too literally as the functions described can vary widely. Bias layers (B) aren't all that informative ,  they are analogous to intercept terms in a regression model.

## Evaluating the neural network model
Note how we use the `compute()` function to generate predictions on the testing dataset (rather than `predict()`). Also rather than assessing whether we were right or wrong (compared to classification) we need to compare our predicted G3 score with the actual score, we can acheive this by comparing how the predicted results covary with the real data.

{% highlight r %}
model_results <- compute(net_model, data_test[c("G1", "G2", "goout", "absences",
                                                "failures", "Fedu", "Medu")])
predicted_G3 <- model_results$net.result

cor(predicted_G3, data_test$G3)[ , 1]  # can vary depending on random seed
{% endhighlight %}

{% highlight text %}
## [1] 0.9216071625
{% endhighlight %}

{% highlight r %}
plot(predicted_G3, data_test$G3,
     main = "1 hidden node layers", ylab = "Real G3")  # line em up, aid visualisation
abline(a = 0, b = 1, col = "black")
{% endhighlight %}

![plot of chunk 2016-04-10_net2](/figures/2016-04-10_net2-1.svg)

Here we compare to a 1:1 abline in black. It would be interesting to compare how this approach fares against a standard linear regression. Let's add some extra complexity by adding some more hidden nodes.

{% highlight r %}
net_model2 <- neuralnet(G3 ~ G1 + G2 + goout +
       absences + failures + Fedu + Medu,
                            data = data_train, hidden = 5, linear.output = TRUE)
print(net_model2)
{% endhighlight %}

{% highlight text %}
## Call: neuralnet(formula = G3 ~ G1 + G2 + goout + absences + failures +     Fedu + Medu, data = data_train, hidden = 5, linear.output = TRUE)
##
## 1 repetition was calculated.
##
##         Error Reached Threshold Steps
## 1 1.183841225    0.009654936966  6281
{% endhighlight %}

{% highlight r %}
plot.nnet(net_model2)
{% endhighlight %}

![plot of chunk 2016-04-10_net3](/figures/2016-04-10_net3-1.svg)

Now we evaluate as before.

{% highlight r %}
#now evaluate as before

model_results2 <- compute(net_model2, data_test[c("G1", "G2", "goout", "absences",
                                                "failures", "Fedu", "Medu")])
predicted_G3_2 <- model_results2$net.result

cor(predicted_G3_2, data_test$G3)[ , 1]  # can vary depending on random seed
{% endhighlight %}

{% highlight text %}
## [1] 0.9591425577
{% endhighlight %}

{% highlight r %}
plot(predicted_G3_2, data_test$G3,
     main = "5 hidden node layers", ylab = "Real G3")  # line em up, aid visualisation
abline(a = 0, b = 1, col = "black")
{% endhighlight %}

![plot of chunk 2016-04-10_net4](/figures/2016-04-10_net4-1.svg)

A slight improvement, on parr with the Decision Tree approach, even though some variables that we know to be useful were excluded from this modelling exercise. We can improve things by incoporating them into the model. Furthermore, this is not just a pass or fail classification, this provides a predicted exam score in `G3` for any student.

A caveat, prior to any conclusions the model should be validated using cross-validation which provides some protection against under or over-fitting (the risk of overfitting increases as we increase the number of hidden nodes). Furthermore interpretability is an issue, I have a prediction but limited understanding of what is going on.

***

## References
* Cortez and Silva (2008). Using data mining to predict secondary school performance.
* Crawley (2004). Statistics an introduction using R.
* James et al., (2014). An introduction to statistical learning with applications in R.
* Machine Learning with R, Chapter 7
* Rumelhart et al, (1986). Nature 323, 533-536
* Yeh, (1998). Cement and Concrete Research 28, 1797-1808
* [R-bloggers](http://www.r-bloggers.com/fitting-a-neural-network-in-r-neuralnet-package/)
* [Neuralyst](http://www.cheshireeng.com/Neuralyst/nnbg.htm#nnstruct)

{% highlight r %}
sessionInfo()
{% endhighlight %}

{% highlight text %}
## R version 3.2.3 (2015-12-10)
## Platform: x86_64-w64-mingw32/x64 (64-bit)
## Running under: Windows >= 8 x64 (build 9200)
##
## locale:
## [1] LC_COLLATE=English_United Kingdom.1252
## [2] LC_CTYPE=English_United Kingdom.1252
## [3] LC_MONETARY=English_United Kingdom.1252
## [4] LC_NUMERIC=C
## [5] LC_TIME=English_United Kingdom.1252
##
## attached base packages:
## [1] grid      stats     graphics  grDevices utils     datasets  methods
## [8] base
##
## other attached packages:
##  [1] reshape_0.8.5   scales_0.3.0    devtools_1.9.1  RItools_0.1-13
##  [5] neuralnet_1.32  MASS_7.3-45     magrittr_1.5    dplyr_0.4.3
##  [9] testthat_0.11.0 knitr_1.12
##
## loaded via a namespace (and not attached):
##  [1] Rcpp_0.12.3        munsell_0.4.2      colorspace_1.2-6
##  [4] xtable_1.8-0       R6_2.1.1           plyr_1.8.3
##  [7] stringr_1.0.0      httr_1.0.0         tools_3.2.3
## [10] parallel_3.2.3     DBI_0.3.1          lazyeval_0.1.10
## [13] abind_1.4-3        assertthat_0.1     digest_0.6.9
## [16] crayon_1.3.1       formatR_1.2.1      rsconnect_<IP_ADDRESS>
## [19] svd_0.3.3-2        curl_0.9.4         memoise_0.2.1
## [22] evaluate_0.8       stringi_1.0-1      SparseM_1.7
{% endhighlight %}

gha_language: JavaScript


text:
---
parent: Remote Storage
grand_parent: Code Howtos
---

# Remote SQL Storage

For user documentation, see <https://docs.jabref.org/collaborative-work/sqldatabase>.

## Handling large shared databases

Synchronization times may get long when working with a large database containing several thousand entries. Therefore, synchronization only happens if several conditions are fulfilled:

* Edit to another field.
* Major changes have been made (pasting or deleting more than one character).

Class `org.jabref.logic.util.CoarseChangeFilter.java` checks both conditions.

Remaining changes that have not been synchronized yet are saved at closing the database rendering additional closing time. Saving is realized in `org.jabref.logic.shared.DBMSSynchronizer.java`. Following methods account for synchronization modes:

* `pullChanges` synchronizes the database unconditionally.
* `pullLastEntryChanges` synchronizes only if there are remaining entry changes. It is invoked when closing the shared database (`closeSharedDatabase`).

## Database structure

The following examples base on PostgreSQL.
Other databases work similar.

The database structure is created at [org.jabref.logic.shared.PostgreSQLProcessor#setUp](https://github.com/JabRef/jabref/blob/main/src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java#L37-L37).

```mermaid
erDiagram
    ENTRY ||--o{ FIELD : contains
    ENTRY {
        serial shared_id
        varchar type
        int version
    }
    FIELD {
        int entry_shared_id
        varchar name
        text value
    }
    METADATA {
        varchar key
        text value
    }
```

The "secret sauce" is the `version` of an entry.
This version is used as version in the sense of an [Optimistic Offline Lock](https://martinfowler.com/eaaCatalog/optimisticOfflineLock.html), which in turn is a well-established technique to prevent conflicts in concurrent business transactions.
It assumes that the chance of conflict is low.
Implementation details are found at <https://www.baeldung.com/cs/offline-concurrency-control>.

The `shared_id` and `version` are handled in [`org.jabref.model.entry.SharedBibEntryData`](https://github.com/JabRef/jabref/blob/main/src/main/java/org/jabref/model/entry/SharedBibEntryData.java).

## Synchronization

PostgreSQL supports to register listeners on the database on changes.
(MySQL does not).
The listening is implemented at [`org.jabref.logic.shared.listener.PostgresSQLNotificationListener`](https://github.com/JabRef/jabref/blob/main/src/main/java/org/jabref/logic/shared/listener/PostgresSQLNotificationListener.java#L16).
It "just" fetches updates from the server when a change occurred there.
Thus, the changes are not actively pushed from the server, but still need to be fetched by the client.

repository: JabRef/jabref

branch_name: refs/heads/main

gha_language: Java

repo_name: JabRef/jabref


text:
[AjPlus Captcha Official Website](https://captcha.anji-plus.com/)
============
[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)[![Total Lines](https://tokei.rs/b1/github/anji-plus/captcha?category=lines)](https://github.com/anji-plus/captcha)

> AjPlus Captcha

[![Stargazers over time](https://starchart.cc/anji-plus/captcha.svg)](https://starchart.cc/anji-plus/captcha)
[![Stargazers over time](https://whnb.wang/img/anji-plus/captcha?e=604800)](https://whnb.wang/anji-plus/captcha?e=604800)

[![EN doc](https://img.shields.io/badge/document-English-blue.svg)](README.md)[![CN doc](https://img.shields.io/badge/文档-中文版-blue.svg)](README_CN.md)

# 1. Online Demo
###   1.1 [Have a try](https://captcha.anji-plus.com/ "链接")
###   1.2 [Document](https://captcha.anji-plus.com/#/doc "doc")
###   1.3 Wechat/H5 demo（based on uni-app)
    see also [gitee]( https://gitee.com/anji-plus/captcha "码云")

 ![Wechat](https://captcha.anji-plus.com/static/8cm.jpg  "")  ![h5](https://images.gitee.com/uploads/images/2020/0429/174246_c33e3fa3_1728982.png "h5.png")
     Wechat Demo

# 2. Design Details
###   2.1 UI Component
    support Android、iOS、Futter、Uni-App、ReactNative、Vue、Angular、Html、Php。

| blockPuzzle | clickWord |
| --- | --- |
|![blockPuzzle](https://captcha.anji-plus.com/static/blockPuzzle.png "滑动拼图") |![clickWord](https://captcha.anji-plus.com/static/clickWord.png "点选文字")|
| 1-1 | 1-2 |

###   2.2 Concept Related
| concept  | desc  |
| ------------ | ------------ |
| Captcha Type | blockPuzzle, clickWord|
| Check  |  user action: drag block or click workds,then check if it was human did|
| Verify  | bind user action with backend service. call captchaService.verification in backend service to prevent invalid access ,for example,directly call it |

###   2.3 Main Features
CAPTCHA stands for Completely Automated Public Turing test to tell Computers and Humans Apart. CAPTCHA determines whether the user is real or a spam robot. CAPTCHAs stretch or manipulate letters and numbers, and rely on human ability to determine which symbols they are.

Ajplus Captcha , an open source toolset for users,its main Features are as follows:
- Easy to integrate ui Component in your apps,support varies frontend UI,
- Support Integrate with Android、iOS、Futter、Uni-App、ReactNative、Vue、Angular、Html、Php
- No dependencies lib in core source,Easy to include in your backend service
- Core api is simple and Open to Extend,all instance initialized by JAVA SPI,Easy to add your custom Implement to form a new Captcha type。
- Support security feature

# 3. How to Integrate
![Sequence Diagram](https://captcha.anji-plus.com/static/shixu.png "时序图")

# 4. SourceCode Structure

![输入图片说明](https://images.gitee.com/uploads/images/2021/0207/112335_bd789fff_1600789.png "屏幕截图.png")

# 5. Dev & Run
####
- start backend service
  import source code into Eclipse or Intellij,
  start StartApplication class in package service/springboot。[online images](https://gitee.com/anji-plus/AJ-Captcha-Images)
- start frontend ui
  open source files in view/vue with your IDE like Visual Code，
```js
    npm install
    npm run dev

    DONE  Compiled successfully in 29587ms                       12:06:38
    I  Your application is running here: http://localhost:8081
```

# 6. Work Plan
  [issues](https://gitee.com/anji-plus/captcha/issues)

# 7. Connect Us

[Wechat group] (https://captcha.anji-plus.com/static/weixin.png)

| Wechat | qq |
| --- | --- |
|||

#### Thank you, JetBrains, for your support

##### JetBrains:[https://www.jetbrains.com/?from=AJ-Captcha](https://www.jetbrains.com/?from=AJ-Captcha "链接")

 ### Have a try & enjoy it !!!  ☺

repository: anji-plus/captcha

repo_name: anji-plus/captcha


text:
# rpgbaker-bootstrap

a minimal rpgbaker project to help you start

To install all the dependencies

    npm install

To start the game in the browser ( hot loading via webpack )

    npm start

repository: DomDumont/rpgbaker-bootstrap

repo_name: DomDumont/rpgbaker-bootstrap


text:
# Problem Description:
## Huffman Coding
A Huffman code is a type of optimal prefix code that is used for compressing data. The Huffman encoding and decoding schema is also lossless, meaning that when compressing the data to make it smaller, there is no loss of information.

The Huffman algorithm works by assigning codes that correspond to the relative frequency of each character for each character. The Huffman code can be of any length and does not require a prefix; therefore, this binary code can be visualized on a binary tree with each encoded character being stored on leafs.

There are many types of pseudocode for this algorithm. At the basic core, it is comprised of building a Huffman tree, encoding the data, and, lastly, decoding the data.

Here is one type of pseudocode for this coding schema:

* Take a string and determine the relevant frequencies of the characters.
* Build and sort a list of tuples from lowest to highest frequencies.
* Build the Huffman Tree by assigning a binary code to each letter, using shorter codes for the more frequent letters. (This is the heart of the Huffman algorithm.)
* Trim the Huffman Tree (remove the frequencies from the previously built tree).
* Encode the text into its compressed form.
* Decode the text from its compressed form.
* You then will need to create encoding, decoding, and sizing schemas.

# Analysis:
## Time Complexity:
The time complexity is `O(nlog(n))`. Refer Design Choices section.

## Space Complexity:
The space complexity is `O(n)`. `O(n)` for each map and DFS is `O(|V|)`.

## Design Choices:
I spent a lot of time on this problem. Conceptually after a few YouTube videoes, it's easy to understand but I still had to draw it out on paper a few times. As a samples steps mention, first I got the frequencies of the characters, sort them, create nodes starting with the least frequent chars to build a tree and finally traverse the tree to generate the codes. With the generated codes, I used that to encode the message and to decode, I had to traverse the tree using the bits to go left or right down until hitting a char. One thing I forgot to include is the sort which takes O(nlog(n)).

For time complexity, I used two dictionaries - (1) for frequencies and (2) for codes. It made for O(1) lookups. To traverse the tree (DFS) and recursion - O(V+E) where V = vertices and E = edges.


text:
# Creating a wallet
While using Alan.dart, a wallet represents the private identity of a user. It contains everything necessary to create, sign and broadcast a transaction to che chain.

:::warning Security alert
Since wallets are extremely delicate, you should **never** store them anywhere. As a precaution method, if you try to serialize a Wallet or print its info, you will not be able to see the private key associated with it.

If you want to save the wallet of a user, save instead the mnemonic phrase using an encrypted store. For Flutter, [flutter_secure_storage](https://pub.dev/packages/flutter_secure_storage) exists.

**Never**, ever, store the mnemonic phrase in an unencrypted place.
:::

## Create a wallet from a mnemonic
In order to create a wallet, you are required to provide:

1. a mnemonic phrase;
2. a `NetworkInfo` object;
3. optionally, a derivation path.

```dart
import "package:alan/alan.dart";

final networkInfo = NetworkInfo.fromSingleHost(
  bech32Hrp: "cosmos",
  hosrt: "http://localhost",
);

final mnemonic = [
    "final",
    "random",
    "flame",
    "cinnamon",
    "grunt",
    "hazard",
    "easily",
    "mutual",
    "resist",
    "pond",
    "solution",
    "define",
    "knife",
    "female",
    "tongue",
    "crime",
    "atom",
    "jaguar",
    "alert",
    "library",
    "best",
    "forum",
    "lesson",
    "rigid",
];
final wallet = Wallet.derive(
  mnemonic,
  networkInfo,
  derivationPath: "m/44'/118'/0'/0/0", // Optional - Default m/44'/118'/0'/0/0
);
```

## Generate a random wallet
If you don't have any mnemonic phrase, or you want to get a fresh new wallet, you can use the `Wallet.random` method. You only have to provide it with a `NetworkInfo` object.

```dart
import "package:alan/alan.dart";

final networkInfo = NetworkInfo.fromSingleHost(
  bech32Hrp: "cosmos",
  hosrt: "http://localhost",
);

final wallet = Wallet.random(
  networkInfo,
  derivationPath: "m/44'/118'/0'/0/0", // Optional - Default m/44'/118'/0'/0/0
);
```

gha_language: Dart


text:
![Let's Chat](http://i.imgur.com/0a3l5VF.png)

![Screenshot](http://i.imgur.com/C4uMD67.png)

A self-hosted chat app for small teams built by [Security Compass][seccom].

[![Build Status](https://travis-ci.org/sdelements/lets-chat.svg?branch=master)](https://travis-ci.org/sdelements/lets-chat)
[![Dependency Status](https://david-dm.org/sdelements/lets-chat.svg)](https://david-dm.org/sdelements/lets-chat)
[![devDependency Status](https://david-dm.org/sdelements/lets-chat/dev-status.svg)](https://david-dm.org/sdelements/lets-chat#info=devDependencies)

## Features and Stuff

* BYOS (bring your own server)
* Persistent messages
* Multiple rooms
* Private and password-protected rooms
* New message alerts / notifications
* Mentions (hey @you/@all)
* Image embeds / Giphy search
* Code pasting
* File uploads (Local / [Amazon S3][s3] / [Azure][azure])
* Transcripts / Chat History (with search)
* XMPP Multi-user chat (MUC)
* 1-to-1 chat between XMPP users
* Local / [Kerberos][kerberos] / [LDAP][ldap] authentication
* [Hubot Adapter][hubot]
* REST-like API
* Basic i18n support
* MIT Licensed

## Deployment on Cloud Foundry

Navigate inside the folder which has manifest file

cf api https://api.cf.sap.hana.ondemand.com/

cf login

cf create-service mongodb v3.0-container mongodb

cf push

## Note:

please add a suffix or prefix (or change the entire name) to the host attribute within the manifest.yml file to avoid 'The host is taken' error.

## License

Released under [the MIT license][license].

[wiki]: https://github.com/sdelements/lets-chat/wiki
[troubleshooting]: https://github.com/sdelements/lets-chat/blob/master/TROUBLESHOOTING.md
[mailing-list]: https://groups.google.com/forum/#!forum/lets-chat-app
[tracker]: https://github.com/sdelements/lets-chat/issues
[contributing]: https://github.com/sdelements/lets-chat/blob/master/CONTRIBUTING.md
[new-issue]: https://github.com/sdelements/lets-chat/issues/new
[editorconfig]: https://github.com/sdelements/lets-chat/blob/master/.editorconfig
[license]: https://github.com/sdelements/lets-chat/blob/master/LICENSE
[ldap]: https://github.com/sdelements/lets-chat-ldap
[kerberos]: https://github.com/sdelements/lets-chat-kerberos
[s3]: https://github.com/sdelements/lets-chat-s3
[seccom]: http://securitycompass.com/
[hubot]: https://github.com/sdelements/hubot-lets-chat
[azure]: https://github.com/maximilian-krauss/lets-chat-azure
[install-local]: https://github.com/sdelements/lets-chat/wiki/Installation
[install-docker]: https://registry.hub.docker.com/u/sdelements/lets-chat/
[install-heroku]: https://github.com/sdelements/lets-chat/wiki/Heroku
[install-vagrant]: https://github.com/sdelements/lets-chat/wiki/Vagrant

repository: skrishnakumar/lets-chat

repo_name: skrishnakumar/lets-chat


text:
---
title: PipelineEventBase
description: API reference for PipelineEventBase in Vendr, the eCommerce solution for Umbraco v8+
---
## PipelineEventBase

```csharp
public abstract class PipelineEventBase : NotificationEventBase
```

**Inheritance**

* class [NotificationEventBase](../notificationeventbase/)

**Namespace**
* [Vendr.Core.Events](../)

### Constructors

#### PipelineEventBase

```csharp
public PipelineEventBase(IEnumerable<IPipelineTask> pipeline, PipelineArgs args)
```

### Properties

#### Pipeline

```csharp
public IEnumerable<IPipelineTask> Pipeline { get; set; }
```

---

#### PipelineArgs

```csharp
public PipelineArgs PipelineArgs { get; set; }
```

<!-- DO NOT EDIT: generated by xmldocmd for Vendr.Core.dll -->

repository: vendrhub/vendr-documentation

gha_language: Batchfile

repo_name: vendrhub/vendr-documentation


text:
# Using existing Docker images

You may already have an existing Docker image that you want to use with stowage - that's great!

As a convenience, stowage will attempt to recognise Docker image references when you install - meaning that any registries you have setup should automatically work, and Docker Hub will work by default.

For an example, let's look at a command which doesn't have a specfile shipped as an example, or in a repo: the MS Azure CLI.

```
$ stowage install microsoft/azure-cli
azure-cli installed
```

I now have a local command `azure-cli` available to me, as the last piece of the image name is taken as the name of the command.

In this case, the image is designed to give you a command line from which the `azure` command can be run. We can verify this by asking for the version:

```
$ azure-cli azure -v
0.10.13
```

So we're installed and working!

## Altering the specfile

It would be _even more convenient_ if we didn't have to specify what feels like the same thing twice - ideally, we just one command.

This is why stowage has specfiles. Although the image is directly usable in most instance, it isn't always - or, the usage can be improved. This is one of those cases.

stowage creates a default specfile on installation. We can just pinch that as our starting point - in this case, it's `/usr/local/share/stowage/spec/azure-cli`.

Copy this locally as `azure-cli.json`. Add `azure` as the `Command` in the file, and this will then solve our problem.

As well as installing images directly, stowage has a separate command to install via a specfile.


text:
### [CVE-2020-25019](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-25019)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

jitsi-meet-electron (aka Jitsi Meet Electron) before 2.3.0 calls the Electron shell.openExternal function without verifying that the URL is for an http or https resource, in some circumstances.

### POC

#### Reference
- https://security.stackexchange.com/questions/225799

#### Github
- https://github.com/doyensec/awesome-electronjs-hacking

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Moose2Model2
Explore SOMIX models in your Web Browser. This tools makes it possible to draw diagrams of code similar to Circuit Diagrams of electic circuits. It shall support developers during their daily work.
Use www.sap2moose.org to create SOMIX models.

## How to use it
Open www.moose2model.org. The application runs in the Browser. It is executed on your computer, no communication with external servers are done. You can also run the application from file.

## Documentation
See the documentation in the application itself

# Mailing list

Please join the Google Group https://groups.google.com/g/somixsuite to get updates about the tool and contact other users.


text:
---
title: 'SpeechPy - A Library for Speech Processing and Recognition'
tags:
  - Python
authors:
  - name: Amirsina Torfi
    orcid: 0000-0003-2282-4361
    affiliation: "1"
affiliations:
 - name: Virginia Tech, Department of Computer Science
   index: 1
date: 15 May 2018
bibliography: paper.bib
---

# Summary

``SpeechPy`` is an open source package that contains speech preprocessing techniques, speech features, and important post-processing operations. It provides most frequent used speech features including MFCCs and filterbank energies alongside with the log-energy of filter-banks. The aim of the package is to provide researchers with a simple tool for speech feature extraction and processing purposes in applications such as Automatic Speech Recognition and Speaker Verification.

Considering the recent advent of deep learning in ASR and SR and the importance of the accurate speech feature extraction, here are the motivations behind ``SpeechPy`` package:

  *  Developing a free open source package which covers important preprocessing techniques,
speech features, and post-processing operations required for ASR and SR applications.

  * A simple package with a minimum degree of complexity should be available for beginners.

  * A well-tested and continuously integrated package for future developments should be developed.

``SpeechPy`` has been developed to satisfy the aforementioned needs. It contains the most important
preprocessing and post-processing operations and a selection of frequently used speech features. The
package is free and released as an open source software. Continuous integration using for instant
error check and validity of changes has been deployed for ``SpeechPy``. Moreover, prior to the latest
official release of ``SpeechPy``, the package has successfully been utilized for research purposes

# Acknowledgements

This work is based upon a work supported by the Center for Identification Technology Research (CITeR) and the National Science Foundation (NSF) under Grant #1650474. This work was completed in part with resources provided by the Center for Identification Technology Research (CITeR) at the West Virginia University. I would like to thank to Professor Nasser Nasrabadi at West Virginia University, for supporting me during developing this project and for his valuable advices.

repository: twistedmove/speechpy

repo_name: twistedmove/speechpy


text:
# Clathrocyclos Broch, 1905 GENUS

#### Status
ACCEPTED

#### According to
Interim Register of Marine and Nonmarine Genera

#### Published in
Bull. Result. Conseil Int. Mer. , 1904-5, fasc. 4D, 174.

#### Original name
null

### Remarks
null


text:
# CDF TOC Roadmap

The CDF Technical Oversight Committee (TOC) has a public roadmap that lists all the key initiatives being handled by the committee.
The roadmap is implemented as a GitHub Project and reviewed at the [TOC meetings](https://github.com/cdfoundation/toc#communication).

[See the Roadmap Here](https://github.com/cdfoundation/toc/projects/7)

repository: cdfoundation/toc

repo_name: cdfoundation/toc


text:
# Wolf3D

Basics of the ray casting technique used in the Wolfenstein 3D source code and implementation using JavaScript

![wolf3d](/img/wolf3d.png)

### Contents
* [About the Project](#About-the-Project)
* [Features](#Features)
* [How to use](#How-to-use)

### About the Project
-------------------------
This project is aimed to get understanding of the technique used to create ray casting 3D scenes.
The main technique covered is similar to the one used by [IdSoftware][1] in the Wolfenstein 3D source code.
The main part of the project is to understand the mathematics used for ray casting,
and implement a full-featured projected environment using JavaScript language.

### Features
-----------------
* 3D Wall Projections
* 2D Map and Player Movement
* Handling of key events
* Using of [p5.js][2] labrary for graphic representation

### How to use
-------------------
Download or git clone the project folders, open `index.html`

[1]: https://www.idsoftware.com/en-us
[2]: https://p5js.org/


text:
---
layout: default
---

# 1994-03-09 - Re: (forward message on privacy)

## Header Data

From<EMAIL_ADDRESS>(Flesh)

To<EMAIL_ADDRESS>Message Hash: ea72f4c304f033aca0b87e53880ba8a68e920557049d2e9bc5e52c8638d0a16c

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-03-09 03:52:02 UTC

Raw Date: Tue, 8 Mar 94 19:52:02 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Flesh)
Date: Tue, 8 Mar 94 19:52:02 PST
To<EMAIL_ADDRESS>Subject: Re: (forward message on privacy)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Forwarded message:
From tomj Tue Mar  8 18:49:17 1994
From: tomj (Tom Jennings)
Message-Id<EMAIL_ADDRESS>Subject: Re: (forward message on privacy) (fwd)
To<EMAIL_ADDRESS>(Flesh)
Date: Tue, 8 Mar 1994 18:49:15 -0800 (PST)
In-Reply-To<EMAIL_ADDRESS>from "Flesh" at Mar 8, 94 06:21:38 pm
X-Mailer: ELM [version 2.4 PL23]
Mime-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Content-Length: 897

> Today I ran into a situation that made me completely nausiated and feel like
> my privacy had been completely invaded... It involves a chip which is
> implanted in animals and used for identification...

Humans are worth more money, and genotyping will do the same thing, for
cheaper, and with little outcry. Implanted chips means at least a
doctors visit for every humasn in the country; genotyping only happens
like fingerprinting, when you get a drivers license or soemthing.

I think the underlying concern is OK, but misplaced worrying about
kitty-cats. Cats can certainly be violated, but usually aren't aware of
it ahead of time, and there's not much they can do about it :-)

Consider also they generally *kill* cats they can't return. A chip
implant under these circumstances seems not a problem.

--
 Tom Jennings --<EMAIL_ADDRESS>-- World Power Systems --  San Francisco, Calif.

{% endraw %}
```

## Thread

+ Return to [March 1994](/archive/1994/03)

+ Return to<EMAIL_ADDRESS>(Flesh)](/authors/flesh_at_wps_com_flesh_)"
+ Return to<EMAIL_ADDRESS>(Stephen Williams)](/authors/sdw_at_meaddata_com_stephen_williams_)"

+ 1994-03-09 (Tue, 8 Mar 94 19:52:02 PST) - Re: (forward message on privacy) -<EMAIL_ADDRESS>(Flesh)_
  + 1994-03-10 (Thu, 10 Mar 94 11:01:23 PST) - [Re: (forward message on privacy)](/archive/1994/03/f744d76af298f202e08830241ed99bf87ab3617d831f62600a1e4f9585bdc146) -<EMAIL_ADDRESS>(Stephen Williams)_


text:
---
layout: single
permalink: /blog/2019/04/04/migration-from-jsp-to-sightly
title:  "Migration from JSP to Sightly"
date:   2019-05-02 20:00:00 +1100
author<EMAIL_ADDRESS>categories:
  - blog
tags:
  - update
---

The time has come to migrate to Sightly. Primary drive is that Sling Models are great and Sightly now works (long story...).
Secondary drive is that it provides absolute templating without opportunity to embed code with template code.
Using JSP and JSTL work great, but it does not provide strict no "Code in Templates" governance.
So if you are not careful you could end up with code plaguing your template and that would break your conventions.
This has worked great over the years but as framework usage grows simpler oversight is required to ensure stability.

On the Sightly side the conventions is simple, Model has your code and your template has just the presentation.
Sightly syntax docs are very easy to consume and anyone on this side of the keyboard can follow.
Having pure JSTL implementation for your templates provides less opportunities to pollute your templates.

How to migrate your existing component to Sightly is not apparently clear.
Writing new component using Sightly in parallel with your existing component is not migration.
Moving existing JSP component logic into Models is not a copy paste exercise, unless you have a solid convention across all component like AEM.Design.
So the only sustainable option is to start a new project from scratch and use Sightly from the start.

Another way is to version your existing JSP components into V1 and create V2 for the Sighlty implementation.
This is the approach we followed, this allow you to substitute all existing components with new Sightly verisons without having to migrate content.

Consider your existing component structure, when this component would be used in pages the reference to the component will be stored with each instance on component.

```
apps
    aemdesign
        component
            text
                text.jsp
                .content.xml
```

Using this structure will effectively hardcode ```aemdesign/component/content/text``` into your pages and experience fragments.
This creates a long term situation that when you want to update the component you need to update in place and in turn this updates all of the instances of your component everywhere it appears.
This is the best approach as it ensure that you continue to update your component code and update content with latest version without adding unnecessary path version numbering into content.
It best that versioning of component is kept to the component code and not hardcoded into content.

There could be rare scenarios when you may need to have a versioned path for a component but it would be hard to track of these paths over time.
Additional authors will be exposed to versioned components where they will need to decide which version they need to use for a particular design they are creating.
This would seem trivial but over time it will be affecting authoring experience due to number of component they need to understand to create designs.

Another approach elegant approach provides a simplified pattern to have versioning of component without exposing version to author and without hardcoding version into content.
This pattern allow you to have one component path with localised versions that are not exposed to authors.

```
apps
    aemdesign
        component
            text [ sling:resourceSuperType==aemdesign/component/content/text/v1/text ]
                .content.xml
                v1
                    text
                        .content.xml [ componentGroup="hidden" ]
                        text.jsp
                v2
                    text
                        .content.xml [ componentGroup="hidden" ]
                        text.html
```

To implement this pattern you create a sub folder for each version of your component as child of component.
And point parent component path to the version you are currently want the authors to use.
This pattern allow you to leverage version toggling without exposing versioned component to authors.

Furthermore AEM.Design framework uses this pattern to expose component into tenant applications.
When you deploy AEM.Design core component you will have aemdesign application folder available to be used in a tenant component space.

```
apps
    aemdesign
        component
            text [ sling:resourceSuperType==aemdesign/component/content/text/v1/text ]
apps
    tenant
        component
            text [ sling:resourceSuperType==aemdesign/component/content/text ]
```

This pattern combined with [Variants and Badges](/manifesto/project/) provide number of benefits that
- provide a way of component reuse across tenants without referencing core framework
- ensures that tenant specific component paths are used in tenant code
- allow customised metadata like title, description, category and readme's for components where required
- with use of badges and variants provides a way of extending component presentation without changing component core functionality

Considering the approach we took and the benefits that we have now attained make the migration successful!
Further demonstrating to us that our determined efforts with AEM.Design principles can scale from "old" tech to new.
And it is important to note that this was only possible due to the fact that we have had a strict component convention that allowed this process to occur.
If design pattern were not maintained the rewrite of all component would have been the costly option.


text:
# SYNOPSIS

`emailWhoever.pl`

Emails all SneakerNet results

# Software requirements

* sendmail (already installed on most systems)

# Algorithm

Attaches all files under `SneakerNet/forEmail` and emails
them to the list under `config/emails.conf`. If any emails
are found in `snok.txt` or `SampleSheet.csv`, then they
will also receive the email.

# Outputs

email with attachments

repository: lskatz/SneakerNet

gha_language: Perl

repo_name: lskatz/SneakerNet


text:
# PHP cURL [![Build Status](https://travis-ci.org/jabranr/php-curl.svg?branch=master)](https://travis-ci.org/jabranr/php-curl) [![Latest Stable Version](https://poser.pugx.org/jabranr/php-curl/v/stable.svg)](https://packagist.org/packages/jabranr/php-curl) [![Total Downloads](https://poser.pugx.org/jabranr/php-curl/downloads.svg)](https://packagist.org/packages/jabranr/php-curl)

A simple PHP client for cURL operations.

> __Migrating from v1?__ Beware that v2 has breaking changes! Some of the API methods names have changed.

Simply import the library into your project. The best way to do so is to use [Composer](http://getcomposer.org) as following. Otherwise it can simply be downloaded from GitHub and added to the project.

```shell
$ composer require jabranr/php-curl
```

Start using it straight away. (Following example assumes that it was installed via Composer)

```php
<?php

require 'path/to/vendor/autoload.php';

use Jabran\HttpUtil\HttpCurlRequest;
use Jabran\HttpUtil\Exception\HttpCurlException;

# Start new cURL request
$curl = new HttpCurlRequest('http://jabran.me');
```

Setting cURL options
```php
<?php

# Set options - method 1
$curl->setOption(CURLOPT_RETURNTRANSFER, true);
$curl->setOption(CURLOPT_FOLLOWLOCATION, true);

# Set options - method 2
$curl->setOptions(array(
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => true
));

# Execute request, get response and close connection
try {
    $response = $curl->execute();
} catch(HttpCurlException $e) {
    $curl->getErrorCode(); // -> cURL error number
    $curl->getErrorMessage(); // -> cURL error message

    # OR

    $e->getMessage(); // -> cURL error: [ErrorCode] ErrorMessage
}

# OR get more info and close connection manually
try {
    $response = $curl->execute(false);
} catch(HttpCurlException $e) { }

# Get response later
$response = $curl->getResponse();

#
$info = $curl->getInfo();

# Close request
$curl->close();
```

# API

The cURL class exposes following API:

#### `getInfo`

Get cURL request info. `$option` needs to be a valid cURL constant. If none given then it will return an associative array.

```php
$curl->execute(false);
$curl->getInfo($option = null);
$curl->close();
```

#### `getError`

Get cURL request error message.

```php
$curl->getError();
```

#### `getErrorCode`

Get cURL request error code.

```php
$curl->getErrorCode();
```

#### `getErrorMessage`

Get cURL request error message.

```php
$curl->getErrorMessage();
```

#### `getHttpCode`

Get cURL request HTTP status code.

```php
$curl->getHttpCode();
```

#### `getTotalTime`

Get total time taken for a cURL request.

```php
$curl->getTotalTime();
```

#### `getResponse`

Get response for a cURL request.

```php
$curl->getResponse();
```

# License
Feel free to use and send improvements via pull requests. Licensed under the MIT License.

© Jabran Rafique – 2016 – 2017

repository: jabranr/php-curl

branch_name: refs/heads/develop

gha_language: PHP

repo_name: jabranr/php-curl


text:
# LiquidFiles Unix Command Line Utility
## Introduction
liquidfiles_unix is UNIX command line utility, to work with [LiquidFiles](https://www.liquidfiles.com/) server, for sending files, listing messages, downloading files, etc.

LiquidFiles Unix command line utility extends the functionality of your LiquidFiles server to command line use and scripting from supported
Unix and Linux servers.

Liquidfiles Unix is fully based on [LiquidFiles public API](https://man.liquidfiles.com/api/) and uses [libcurl](http://curl.haxx.se/) to send and receive data from LiquidFiles server.

This document consists of the following sections:

1. Installation - describes the typical installation steps including dependent libraries.
2. Usage of tool - contains full description of commands, their arguments as well as usage examples.

## Installation
LiquidFiles can be installed statically or to use shared libraries where all system dependencies are met. LiquidFiles relies heavily on OpenSSL
and Curl dependencies, so you will need to ensure all system dependencies are installed. It is recommended to use the latest supported versions
of both OpenSSL and Curl.

Both installation options work in the same way and provide the same supported functionality, while the static executable can be copied to another
identical machine and executed there, offering portability for larger or more controlled environments. Shared installations operate on the
installed system only.

These instructions use the following keys for substituting user defined values:
* `<xxx-VERSION>`  (downloaded_version_filename)
* `$PATH_X`  (user_defined_path).

### Installing shared
Shared build will need to be performed on each system you wish to run LiquidFiles command line utility from. The following instructions assume
you will use default installation paths.

#### Installing dependencies
If you already have OpenSSL or Curl libraries installed, you may skip some of the below steps.  If your system has OpenSSL or Curl installed in
the default paths, you will not require the prefix option that allows user specified path for installation.

Install OpenSSL first:

1. Download latest OpenSSL version from official site.
2. Extract archive (`tar -xz <openssl-VERSION>.tar.gz`)
3. Go to directory (`cd <openssl-VERSION>`)
4. `./config shared`
5. `make`
6. `make install`

After installing OpenSSL, you need to install Curl:

1. Download latest curl version from official site.
2. Extract archive (`tar -xz <curl-VERSION>.tar.gz`)
3. Go to directory (`cd <curl-VERSION>`)
4. `./configure`
5. `make`
6. `make install`

> If your OpenSSL is installed in a non-system path, then you need to specify --with-ssl=$PATH_SSL option. Refer to OpenSSL installation instructions and options for further information.

#### Installing liquidfiles command line utility
1. Download LiquidFiles [Source Code] (https://github.com/liquidfiles/liquidfiles_unix) and unpack the files, then enter the directory
2. `./configure`
3. `make`
4. `make install`

> If your OpenSSL and Curl is installed in non-system path, then you need to specify using the install options `--with-curl=$PATH_CURL` and/or `--with-ssl=$PATH_SSL`

### Installing static
The benefit of building statically is that you do not necessarily have to install OpenSSL and Curl into default system
path for use by other applications or when you have a different version installed on your build system.  The static
installation creates a single, executable file that can be used on any other identical environment to the build system
without the need to install the system dependencies at all.

Static build is similar to shared in that the compiling of OpenSSL and Curl that are heavily depended on, so you need
to have dependent libraries to be installed statically and using the --enable-static configure option to build
LiquidFiles statically.

This method also requires in some instances that a shared installation of OpenSSL is also present on the build system.
It is highly recommended to use an external path (e.g. /home/Static) for BOTH OpenSSL and Curl static installations.
Then specify this single path for building the LiquidFiles package into a directory of your preference. The instructions
assume this is the case to provide a reliable installation option.

#### Installing dependencies
To install OpenSSL

1. Download latest OpenSSL version from official site.
2. Extract archive (`tar -xz <openssl-VERSION>.tar.gz`)
3. Go to directory (`cd <openssl-VERSION>`)
4. Configure shared libs (`./config shared --prefix=$PATH_X`)
5. `make`
6. `make install`
7. `make clean`
8. Configure static libs (`./config no-shared --prefix=$PATH_X`)
9. `make`
10. `make install`

> For some cases, Curl static build is also not passed with only static OpenSSL.  In these cases you need to build OpenSSL both statically and shared, in some instances you may be able to skip step 7-10 above, if in doubt do both.**

After having OpenSSL, you need to install curl

1. Download latest curl version from official site.
2. Extract archive (`tar -xz <curl-VERSION>.tar.gz`)
3. Go to directory (`cd <curl-VERSION>`)
4. Configure static files (`./configure --with-static --prefix=$PATH_X --with-ssl=$PATH_X --disable-shared`)
5. `make`
6. `make install`

> Using these instructions, you will need the external path however if your OpenSSL is on system default paths, then you may not need to specify --with-ssl option, or if you have specified custom path you need to substitute.

#### Installing liquidfiles
1. Download LiquidFiles Unix CLI Source
2. Configure static LiquidFiles (e.g. `./configure --with-curl=$EXT_PATH --prefix=$LF_EXT_PATH --enable-static`)
3. `make`
4. `make install`

> Using these instructions, you will need the external path however if your Curl is on system default paths, then
you don't need to specify --with-curl option.

#### Alternative build with CMake
1. Download LiquidFiles Unix CLI Source
2. `mkdir build && cd build`
3. `cmake ../`
4. `make`
4. `make install`

## Usage
Liquidfiles is command line utility. It invokes one command per session and exits. General usage is the following:

    liquidfiles <command> <command_args>

The list of supported commands is:
* __attach__  Uploads given files to server.
* __attach_chunk__ Uploads given chunk of file to server.
* __delete_attachments__ Deletes the given attachments.
* __delete_filelink__ Deletes the given filelink.
* __download__ Download given files.
* __file_request__ Sends the file request to specified user.
* __filedrop__ Sends the file(s) by filedrop.
* __filelink__ Uploads given file and creates filelink on it.
* __filelinks__ Lists the available filelinks.
* __get_api_key__ Retrieves api key for the specified user.
* __messages__ Lists the available messages.
* __send__ Sends the file(s) to specified user.

To get command's detailed description, options and usage 'help' command can be used:

    liquidfiles help <command>

Below subsections contain detailed descriptions of commands

### attach
Description:

    Uploads the given file(s) to the liquidfiles server and returns the id(s) of uploaded file(s).

Usage:

	liquidfiles attach [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] <file> ...

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	<file> ...
	    File path(s) to upload.

### attach_chunk
Description:

	Uploads given chunk of file to server.

Usage:

	liquidfiles attach_chunk [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] --chunk=<int> --chunks=<int> --filename=<string> <file>

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--chunk
	    ID of current chunk.

	--chunks
	    Whole count of chunks.

	--filename
	    Name of target file.

	<file>
	    File chunk path to upload.

### delete_attachments
Description:

	Deletes the given attachments.

Usage:

	liquidfiles delete_attachments [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] [--message_id=<id>] [<id> ...]

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--message_id
	    Message id to delete attachments of it.

	<id> ...
	    Id(s) of attachments to delete.

### delete_filelink
Description:

	Deletes the given filelink.

Usage:

	liquidfiles delete_filelink [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] --filelink_id=<id>

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--filelink_id
	    ID of filelink to delete.

### download
Description:

	Downloads given files.
    This command gives 2 ways to download files from liquidfiles.
    First way to by specifying direct url to file(s) by unnamed arguments. In this case command downloads the specified files from the url.
    Second way is by specifying message(s) by '--message_id' argument or by '--sent_in_the_last' or '--sent_after'. In this case command retrieves the message(s) and downloads all the files attached to it.

Usage:

	liquidfiles download [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] [--download_to=<path>] [--message_id=<id>] [--sent_in_the_last=<HOURS>] [--sent_after=YYYYMMDD] [<url> ...]

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--download_to
	    Directory path to download files there.
	    Default value: "".

	--message_id
	    Message id to download attachments of it.

	--sent_in_the_last
	    Download files sent in the last specified hours.

	--sent_after
	    Download files sent after specified date.

	<url> ...
	    Url(s) of files to download.

### file_request
Description:

	Sends the file request to specified user.

Usage:

	liquidfiles file_request [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] --to=<username> [--subject=<string>] [--message=<string>]

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--to
	    User name or email, to send file request.

	--subject
	    Subject of composed email.
	    Default value: "".

	--message
	    Message text of composed email.
	    Default value: "".

	--message_file
	    The file in which contained message text of composed email.
	    Only one of --meassage and --message_file arguments must be given.

### filedrop
Description:

	Sends the file(s) by filedrop.

Usage:

	liquidfiles filedrop --server=<url> [-k] [--report_level=<level>] --from=<username> [--subject=<string>] [--message=<string>] [-r] <file> ...

Arguments:

	--server
	    The URL of the filedrop in server - <ServerURL>/filedrop/<FiledropName>.

	-k
	    If specified, do not validate server certificate.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--from
	    User who sends the files

	--subject
	    Subject of composed email.
	    Default value: "".

	--message
	    Message text of composed email.
	    Default value: "".

	-r
	    If specified, it means that unnamed arguments are attachment IDs, otherwise they are file paths.

	<file> ...
	    File path(s) or attachments IDs to send to user.

### filelink
Description:

	Creates filelink.
    This command creates filelink for the given files. It can upload given file and create link on it or get already uploaded file ID and create link on it.
    If '-r' option is specified, it means that given unnamed argument is ID of already uploaded file, so command just creates link on it.
    If '-r' is not specified, then given unnamed argument is file path, and command uploads that file and creates link on it.

Usage:

	liquidfiles filelink [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] [--expires=<YYYY-MM-DD>] [-r] <file>

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--expires
	    Expire date for the filelink.

	-r
	    If specified, it means that unnamed argument is attachment ID, otherwise it is file path.

	<file>
	    File path or attachment id to create filelink.

### filelinks
Description:

	Lists the available filelinks.
    The output of this command is list of filelinks. The format of output depends on '--output_format' argument.
    If '--output_format' is table, then table is printed. Each row of table represents one filelink.
    If '--output_format' is csv, then output is csv format. All the filelinks are separated by comma.

Usage:

	liquidfiles filelinks [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] [--output_format=<format>] [--limit=<number>]

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--output_format
	    Specifies output string format.
	    Valid values: table, csv.
	    Default value: "table".

	--limit
	    Limit of filelinks list.

### get_api_key
Description:

	Retrieves api key for the specified user.

Usage:

	liquidfiles get_api_key [-k] --server=<url> --username=<email> --password=<password> [-s] [--report_level=<level>]

Arguments:

	-k
	    If specified, do not validate server certificate.

	--server
	    The server URL.

	--username
	    Username.

	--password
	    Password.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and retrieved key.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

### messages
Description:
	Lists the available messages.
    The output of this command is list of messages. The format of output depends on '--output_format' argument.
    If '--output_format' is table, then table is printed. Each row of table represents one message.
    If '--output_format' is csv, then output is csv format. All the messages are separated by comma.

Usage:
	liquidfiles messages [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] [--output_format=<format>] [--message_id=<id>] [--sent_in_the_last=<HOURS>] [--sent_after=YYYYMMDD]

Arguments:
	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--output_format
	    Specifies output string format.
	    Valid values: table, csv.
	    Default value: "table".

	--message_id
	    Message id to show.

	--sent_in_the_last
	    Show messages sent in the last specified hours.

	--sent_after
	    Show messages sent after specified date.

### send
Description:

	Sends the file(s) to specified user.
	This command can upload given files or files in given directories and send them by message or get already uploaded file IDs and send them.

Usage:

	liquidfiles send [--server=<url>] [--api_key=<key>] [-k] [-s] [--report_level=<level>] --to=<username> [--subject=<string>] [--message=<string>] [--message_file=<string>] [--file_type=<file_type>] <file> ...

Arguments:

	--server
	    The server URL. If not specified, tries to retrieve from saved credentials.

	--api_key
	    API key of liquidfiles, to login to system. If not specified, tries to retrieve from saved credentials.

	-k
	    If specified, do not validate server certificate. If not specified, tries to retrieve from saved credentials.

	-s
	    If specified, saves current credentials in cache. Credentials to save are - '-k', '--server' and '--api_key'.

	--report_level
	    Level of reporting.
	    Valid values: silent, normal, verbose.
	    Default value: "normal".

	--to
	    User name or email, to send file.

	--subject
	    Subject of composed email.
	    Default value: "".

	--message
	    Message text of composed email.
	    Default value: "".

	--message_file
	    The file in which contained message text of composed email.

	--file_type
	    It specifies the type of file must be send to user.
	    Valid values: file_names, directory, attachments.
	    Default value: "file_names".
        values:
	        file_names : given unnamed arguments are file paths, and command uploads that files and sends them.
	        directory :  given unnamed arguments are directory paths, and command uploads files in that directory and sends them.
	        attachements :   given unnamed arguments are IDs of already uploaded files, so command just sends them.

	<file> ...
	    File path(s),  attachments IDs or directories to send to user.


text:
---
name: Translation requests
about: For requesting the translation of a ruleset
title: ''
labels: translation
assignees: ''

---

**Ruleset**
Which ruleset are you requesting be translated?

**Language**
Which language are you requesting that rulesets be translated to?

**Resources**
Please provide resources supporting why the ruleset should be translated including information about the game's esports scene in the requested language and existing rulesets in the requested language.

repository: openruleset/OpenRuleset

repo_name: openruleset/OpenRuleset


text:
# Versions
* 2 EoL (2020)
* 3
---

# Packages
* pip
* Virtual Environments
* Conda

---

# Pros
* Data Science Ecosystem
* Not Memory Intensive
* Easy to Learn
* Fast to Develop

---

# Cons
* Slow

repository: Microshak/MicroNotes

repo_name: Microshak/MicroNotes


text:
# Contributing

:warning: Before you [file a new](https://github.com/FanrayMedia/Fanray/issues/new/choose) Bug Report or Feature Request, please first seach both **[Open](https://github.com/FanrayMedia/Fanray/issues)** and **[Closed](https://github.com/FanrayMedia/Fanray/issues?q=is%3Aissue+is%3Aclosed)** issues and PRs to ensure there hasn't been anything similar already filed.

## Bug Report

**Detail is the key!** It's really important for you to provide as much detail as you can, attach screenshots, provide links to online references etc. for people to easily reproduce the bug and examine possible fixes.

## Feature Request

**Please review the [Roadmap](https://github.com/FanrayMedia/Fanray/wiki/Roadmap)!** Take a moment to find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's maintainer of the merits of this feature.

## Pull Request

**Please communicate first!** After forking the repository please create a pull request before embarking on any significant fix. This way we can talk about how the fix will be implemeted. This will greatly increase your chance of your patch getting merged into the code base.

## License

By contributing your code, you agree to license your contribution under the [Apache 2.0 License](LICENSE).

repository: flyznex/Fanray

repo_name: flyznex/Fanray