text:
# binary-tree-printer

Print binary tree in extremely small area.

## About

When I was practicing algorithms on [leetcode](https://leetcode.com/) the other day, I found that leetcode provides a user-friendly tree-visualizer, which can convert a [leetcode-style level order array](https://support.leetcode.com/hc/en-us/articles/360011883654-What-does-1-null-2-3-mean-in-binary-tree-representation) to a binary tree and then display it. One amazing thing about the tree-visualizer is that it can adjust the position of each node so that the tree won't take too much space.

The tree-visualizer did help me a lot when I'was trying to solve some tree-related problems. But then I thought, why not write one by myself? So that's how this project began.

## What can it do?

- convert a level order array (leetcode-style or typical) to a binary tree
- print a binary tree in extremely small area by calculating the position of each node dynamically
- print any Class in addition to Integer

## Usage

This project has been released to maven repository, simply add dependency as below:

```xml
<dependency>
    <groupId>com.github.afkbrb</groupId>
    <artifactId>binary-tree-printer</artifactId>
    <version>1.0.0</version>
</dependency>
```

## Example

Print random BST.

```java
BTPrinter.printRandomBST(100, 100);
```

```
                              38
                              / \
                             /   \
                            /     \
                           /       \
                          /         \
                         /           \
                        /             \
                       /               \
                      /                 \
                     /                   \
                    /                     \
                   /                       \
                  /                         \
                 /                           \
                /                             \
               /                               \
              28                               82
             / \                               / \
            /   \                             /   \
           /     \                           /     \
          /       \                         /       \
         5        31                       /         \
        / \       / \                     /           \
       /   \     30 36                   /             \
      /     \   /   / \                 /               \
     /       \ 29  33 37               /                 \
    /         \   / \                 /                   \
   /           \ 32 35               65                   95
  1            14   /               / \                   / \
 / \           / \ 34              /   \                 94 97
0   2         /   \               /     \               /   / \
     \       12   24             /       \             93  96 98
      3     / \   / \           /         \           /         \
       \   9  13 16 25         /           \         84         99
        4 / \   / \   \       /             \       / \
         7  10 15 23  26     59             74     83 86
        / \   \   /     \   / \             / \       / \
       6   8  11 22     27 56 60           73 76     85 91
                /         / \   \         /   / \       / \
               20        /   \  61       67  75 79     88 92
              / \       40   58   \     / \     / \   / \
             18 21     / \   /    62   66 72   78 80 87 89
            / \       39 54 57      \     /   /     \     \
           17 19         / \        64   69  77     81    90
                        50 55       /   / \
                       / \         63  68 70
                      /   \                 \
                     /     \                71
                    47     53
                   / \     /
                  /   \   52
                 42   49 /
                / \   / 51
               41 43 48
                    \
                    46
                    /
                   45
                  /
                 44
```

Print tree from leetcode-style level order array, '#' means a path terminator where no node exists below.

```java
BTPrinter.printTree("1,2,3,4,5,#,#,6,7,8,1,#,#,#,#,#,#,2,3,4,5,6,7,8,9,10,11,12,13,14,15");
```

```
        1
       / \
      2   3
     / \
    /   \
   4     5
  / \   / \
 6   7 8   1
          / \
         /   \
        /     \
       /       \
      /         \
     2           3
    / \         / \
   /   \       /   \
  4     5     6     7
 / \   / \   / \   / \
8   9 10 11 12 13 14 15
```

Print tree from typical level order array.

```java
BTPrinter.printTreeLevelOrder("1,#,2,#,#,#,3,#,#,#,#,#,#,#,4");
```

```
1
 \
  2
   \
    3
     \
      4
```

Print objects.

```java
BTPrinter.printTree("root", 2, 333, null, null, null, new Foo(), null, new Foo(), null, "end");
```

```
           root
            / \
           2  333
                \
com.github.afkbrb.btp.Foo@646d64ab
                  \
   com.github.afkbrb.btp.Foo@59e5ddf
                    \
                    end
```

Notice that we can override Foo's `toString` method, so that the output won't be that ugly.

For more examples, see [Example](/src/test/java/com/github/afkbrb/btp/Examples.java) and [Test](/src/test/java/com/github/afkbrb/btp/BTPrinterTests.java).

## API

|Method|Description|
|-|-|
|printTree(String s)|Print a tree from a leetcode-style level order expression. '#' means a path terminator where no node exists below.|
|printTreeLevelOrder(String s)|Print a tree from a typical level order expression. '#' means null.|
|printTree(Object... objs)|Print a tree from a leetcode-style level order array. Notice that you can input instances with different types at the same time, the algorithm will always work. The value of each tree node will equal to the String value of the corresponding obj, i.e. String.valueOf(obj). **A null object means a path terminator where no node exists below.**|
|printTreeLevelOrder(Object... objs)|Print a tree from a typical level order array. Notice that you can input instances of different Classes at the same time, the algorithm will always work. The value of each tree node will equal to the String value of the corresponding obj, i.e. String.valueOf(obj).|
|printRandomBST(int n, int bound)|Print a random binary search tree. `n` is the node count of the BST, `bound` is the bound of the val of a tree node. Both `n` and `bound` must be positve, and `n` shouldn't be larger than `bound`.|

## License

[The Unlicense](LICENSE)

Feel free to use it.

## Contribute

Issues and PRs are welcomed!

Stars are welcomed, too 😄!

repository: afkbrb/binary-tree-printer

repo_name: afkbrb/binary-tree-printer


text:
# idbkv-chunk-store
[![Greenkeeper badge](https://badges.greenkeeper.io/KayleePop/idbkv-chunk-store.svg)](https://greenkeeper.io/)
[![Travis badge](https://travis-ci.org/KayleePop/idbkv-chunk-store.svg?branch=master)](https://travis-ci.org/#)
[![standard badge](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
[![npm](https://img.shields.io/npm/v/idbkv-chunk-store.svg)](https://www.npmjs.com/package/idbkv-chunk-store)

Abstract chunk store implementation built on [idb-kv](https://github.com/kayleepop/idb-kv): a small IndexedDB wrapper that automatically batches for performance.

[![abstract chunk store](https://cdn.rawgit.com/mafintosh/abstract-chunk-store/master/badge.svg)](https://github.com/mafintosh/abstract-chunk-store)

## Install

```
npm install idbkv-chunk-store
```

## Usage

See [abstract-chunk-store](https://github.com/mafintosh/abstract-chunk-store)

``` js
var IdbkvChunkStore = require('idbkv-chunk-store')
var store = new IdbkvChunkStore(10,
  {
    name: 'example', // data will persist to future instances with this same name Default='idbkv-chunk-store'
    length: 37, // allows partial final chunks Default=Infinity
    batchInterval: 10 // sets batch interval for idb-kv Default=10ms
  }
)

store.put(0, Buffer.from('0123456789'), (err) => {
  if (err) throw err
  store.get(0, (err, chunk) => {
    if (err) throw err
    console.log(chunk) // outputs '0123456789' as a buffer
  })
})
```

## Blobs

There's also a new option for get() that allows a Blob to be returned instead of a Buffer.
```js
store.get(0,
  {returnBlob: true}, // default is false to return a Buffer
  (err, blob) => console.log(blob instanceof Blob) // outputs true
)
```

This is beneficial because indexedDB returns a pointer to the data in a stored blob instead of loading it all into memory immediately.

## Compatibility

[idb-kv](https://github.com/kayleepop/idb-kv) uses [async functions](https://caniuse.com/#search=async%20functions), so those need to be supported to use this library.

license: MIT

repository: peerflix/idbkv-chunk-store

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: peerflix/idbkv-chunk-store


text:
# Step 4: Display Product Data in the JJ. Esquire Demo Application

In the last section you learned that each page of the JJ. Esquire demo application is viewed, it calls the JavaScript library file \(**s\_code.js**\) with the data connectors JavaScript code. This code retrieves the Partner data which can be used in the Customer application.

Now, you will take the Twitter handle from the data connectors product data and display it on the JJ. Esquire Product List page.

1.  Return to the **s\_code.js** file.
2.  Before the Integrate module **setVars\(\)** method, define a new variable named **s\_author** and assign a value of " ". This variable will be used to display the Twitter handle on the JJ. Esquire demo application Product List page.
3.  At the end of the code In the Integrate module **setVars\(\)** function, assign the **s\_author** variable a value of **p.twitter\_handle**. You are assigning the **s\_author** variable to the Twitter handle retrieved from the data connectors product data.

```
s_author variable

s.loadModule("Integrate");
s.Integrate.add("JJEsquireTwitterPod");
var s_author = " ";
s.Integrate.JJEsquireTwitterPod.setVars=function(s,p)
{
      eval(getTwitterData());
      p.twitter_handle = s_1_Integrate_twitterexample_get_0.author_handle;
      p.twitter_followers = s_1_Integrate_twitterexample_get_0.followers;
s.eVar3 = p.twitter_handle;
      s.events = "event3";
s.products = ";follower_count;;;event3=" + p.twitter_followers;
s_author = p.twitter_handle;
}
```

1.  Open the **list.html** file and locate the comment which states, "**Add the JavaScript code to display the s\_author variable here**".
2.  Copy the JavaScript code below and paste it in the **list.html** file after the comment mentioned above.

```
JavaScript code to display the s_author variable

<script language="JavaScript" type="text/javascript"><!--
      document.write(s_author);
 //--></script>.
```

This will display the Twitter handle in the **Follow on Twitter** pod on the Product List page of the JJ. Esquire demo application.

![](graphics/integrate009.jpg)

In the next section, you will step through the demo application which will retrieve data connectors product data, display the Twitter handle on the Product List web page, and pass the Twitter handle and number of Twitter followers to the Adobe Data Collection Layer**.**

**Parent topic:** [3. Integrate Partner Data Tutorial](c_Integrate_Data_Connectors_Partner_Data_into_Customer_Application.md)


text:
# Peter's Partially Perfect Pizza Palace

#### This program takes the user's pizza prefrences and gives them an appropriate price for their pizza.

#### By **Nathan Barrett**

## Description

This is a website for a pizza shop where a user can choose toppings and size to seesee the final cost.

 - the user chooses toppings and size for the pizza they'd like to order.
 - Create a pizza object constructor with properties for different toppings and size.
 - Create a prototype method for the cost of a pizza

### Specs
| Spec | Input | Output |
| :-------------     | :------------- | :------------- |
| **Accept order for pizza size and return price"** | small pizza no topping  | $6.00|
| **Accept order for pizza any size and one topping** | Small Pizza with Pepperoni | $8.00|
| **Accept order for pizza any size and any toppings**|  small pizza with 2 veggie toppings and 1 meat toppings and 1 special topping |  $12.00 |

## Setup/Installation Requirements

1. Clone the files from my GitHub https://github.com/nathan-barrett/pizzashop.git
2. Open index.html in your chosen browser.

## Known Bugs
* No known bugs at this time.

## Technologies Used
* JavaScript
* CSS
* HTML
* Bootstrap 4
* Jquery 3.2.1.

### License

*{This software is licensed under the MIT license}*

Copyright (c) 2017 **_{Nathan Barrett}_**

repository: nathan-barrett/pizzashop

repo_name: nathan-barrett/pizzashop


text:
# InlineQueryResultVideo

Represents a link to a page containing an embedded video player or a video file. By default, this video file will be sent by the user with an optional caption. Alternatively, you can use input_message_content to send a message with the specified content instead of the video.

## Properties

- `$type`: _Type of the result, must be video_
- `$id`: _Unique identifier for this result, 1-64 bytes_
- `$video_url`: _A valid URL for the embedded video player or video file_
- `$mime_type`: _Mime type of the content of video url, “text/html” or “video/mp4”_
- `$thumb_url`: _URL of the thumbnail (jpeg only) for the video_
- `$title`: _Title for the result_
- `$caption`: _Optional. Caption of the video to be sent, 0-1024 characters after entities parsing_
- `$parse_mode`: _Optional. Mode for parsing entities in the video caption. See formatting options for more details._
- `$caption_entities`: [`Array of MessageEntity`](MessageEntity.md) _Optional. List of special entities that appear in the caption, which can be specified instead of parse_mode_
- `$video_width`: _Optional. Video width_
- `$video_height`: _Optional. Video height_
- `$video_duration`: _Optional. Video duration in seconds_
- `$description`: _Optional. Short description of the result_
- `$reply_markup`: [`InlineKeyboardMarkup`](InlineKeyboardMarkup.md) _Optional. Inline keyboard attached to the message_
- `$input_message_content`: [`InputMessageContent`](InputMessageContent.md) _Optional. Content of the message to be sent instead of the video. This field is required if InlineQueryResultVideo is used to send an HTML-page as a result (e.g., a YouTube video)._

repository: FraSharp/FraSharpBot

branch_name: refs/heads/main

gha_language: PHP

repo_name: FraSharp/FraSharpBot


text:
# OTA Challenge Bot

[![CircleCI (development)](https://circleci.com/gh/OpenToAllCTF/OTA-Challenge-Bot/tree/development.svg?style=svg)](https://circleci.com/gh/OpenToAllCTF/OTA-Challenge-Bot/tree/development)

The OTA challenge bot is a helper tool to be used during CTF events
through the Slack platform.

## Features

Main features :
- Tracking CTFs
- Tracking CTF challenges
- Tracking member participation in challenges
- Displaying announcements upon solving a challenge

Secondary features :
- Syscall table for arm, armthumb, x64 and x86

## Usage

```
!ctf addctf <ctf_name>                                          (Adds a new ctf)
!ctf addchallenge <challenge_name> <challenge_category>         (Adds a new challenge for current ctf)
!ctf tag [<challenge_name>] <tag> [..<tag>]                     (Adds a tag to a challenge)
!ctf workon [challenge_name]                                    (Show that you're working on a challenge)
!ctf status                                                     (Show the status for all ongoing ctf's)
!ctf solve [challenge_name] [support_member]                    (Mark a challenge as solved)
!ctf renamechallenge <old_challenge_name> <new_challenge_name>  (Renames a challenge)
!ctf renamectf <old_ctf_name> <new_ctf_name>                    (Renames a ctf)
!ctf reload                                                     (Reload ctf information from slack)
!ctf removetag [<challenge_name] <tag> [..<tag>]                (Remove a tag from a challenge)
!ctf archivectf                                                 (Archive the challenges of a ctf)
!ctf addcreds <ctf_user> <ctf_pw> [ctf_url]                     (Add credentials for current ctf)
!ctf showcreds                                                  (Show credentials for current ctf)
!ctf postsolves <title>                                         (Post current solve status to git)
!ctf unsolve [challenge_name]                                   (Remove solve of a challenge)

!syscalls available                                             (Shows the available syscall architectures)
!syscalls show <arch> <syscall name/syscall id>                 (Show information for a specific syscall)

!bot ping                                                       (Ping the bot)
!bot intro                                                      (Show an introduction message for new members)
!bot version                                                    (Show git information about the running version of the bot)

!admin show_admins                                              (Show a list of current admin users)
!admin add_admin <user_id>                                      (Add a user to the admin user group)
!admin remove_admin <user_id>                                   (Remove a user from the admin user group)
!admin as <@user> <command>                                     (Execute a command as another user)

!wolfram ask <question>                                         (Ask wolfram alpha a question)
```

## Retrieving the API token

Bot applications are not allowed to access all api methods from Slack. Thus, if
you create a bot integration on slack, the bot won't be able to create new
channels for example. To get around this restriction, you have to create a real
slack user and generate an authentication token for it, which can then be used
instead of a bot token.

1. Create a new user in slack (this will be the bot user, so give it an appropriate username)
2. Log into slack with this newly created user
3. Navigate to https://api.slack.com/custom-integrations/legacy-tokens
  * The user should show up there together with your slack workspace
5. Press "Create token"
  * This should create a token starting with "xoxp-"
7. Use this token as the `api_key` for the bot
8. Logout and login with your regular user again.

After restarting the bot, the bot user should now show up in your slack workspace.

## Installation

1. Copy `config/config.json.template` to `config/config.json`
2. Fill the API token and bot name in the config.json file.
3. Add your user id (slack id, not the username) to `admin_users` group in `config/config.json`
4. If you want to use the wolfram alpha api, register a valid app id on http://products.wolframalpha.com/api/ and set `wolfram_app_id` in `config/config.json`
5. Copy `intro_msg.template` to `intro_msg` and set a proper introduction message, which can be shown with `!intro`
6. `docker build -t ota-challenge-bot .`
7. `docker run -it --rm --name live-ota-challenge-bot ota-challenge-bot`

## Development

1. Copy `config/config.json.template` to `config/config.json`
2. Fill the API token and bot name in the config.json file.
3. Create a virtual env: `python3 -m venv .venv`
4. Enter the virtual env: `source .venv/bin/activate`
5. Install requirements: `pip install -r requirements.txt`

## Using git support for uploading solve updates

1. Copy `config/config_solvetracker.json.template` to `config/config_solvetracker.json`.
2. Configure the git account, the local repo and the remote path, which should be used to access your git repository.

Example:
```
{
    "git_repopath" : "/home/ota_bot/OTA_Upload",
    "git_repouser" : "otabot",
    "git_repopass" : "password",
    "git_remoteuri" : "github.com/ota_bot/OTA_Upload.git",
    "git_branch" : "master",
    "git_baseurl" : "https://ota.github.io/SolveTracker"
}
```

Alternatively, you may decide to omit the "git_repopass" entry. In such an event (or if the entry is left blank) then the handler will attempt to push to the configured "git_remoteuri" using the `git` protocol, including using any SSH identities you may have configured.
Note: If you configure the solvetracker this way, you need to make sure you are using an SSH identity without a passphrase.

3. Update the templates in `templates` according to your preferences (or go with the default ones).
4. Make sure that there's a `_posts` and `_stats` folder in your git repository.
5. You should be good to go now and git support should be active on the next startup. You can now use the `postsolves` command to push blog posts with the current solve status to git.

## Using Link saver

1. Setup a github repo with jekyll and staticman (e.g. https://github.com/ujjwal96/links).
2. Copy `config/config_savelink.json.template` to `config/config_savelink.json`.
3. Configure the git repo and branch to be used.
4. Add the decrypted staticman-token used in `staticman.yml` in the config.
5. Add a link to your repo, so people can look it up via `showlinkurl`

Example:
```
{
    "git_repo": "reponame/links",
    "git_branch": "gh-pages",
    "staticman-token": "9d837771-945a-489d-cd80-13abcdefa112",
    "allowed_users": [],
    "repo_link_url": "https://reponame.github.io/links/"
}
```

## Archive reminder

To enable archive reminders set an offset (in hours) in `config/config.json` for `archive_ctf_reminder_offset`. Clear or remove the setting to disable reminder handling.

If active, the bot will create a reminder for every bot admin on `!endctf` to inform him, when the ctf was finished for the specified time and it should be archived.

Example (for being reminded one week after the ctf has finished):
```
{
    ...
    "archive_ctf_reminder_offset" : "168"
}
```

## Log command deletion

To enable logging of deleting messages containing specific keywords, set `delete_watch_keywords` in `config/config.json` to a comma separated list of keywords.
Clear or remove the setting to disable deletion logging.

Example
```
{
    "delete_watch_keywords" : "workon, reload, endctf"
}

repository: OpenToAllCTF/OTA-Challenge-Bot

gha_language: Python

repo_name: OpenToAllCTF/OTA-Challenge-Bot


text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "Automated Rainout Shelter"
summary: "Automatically move a greenhouse-like structure on a slope, on top of a research plot during a precipitation event."
authors: []
tags: []
categories: []
date: 2019-10-04T15:50:13-07:00

# Optional external URL for project (replaces project detail page).
external_link: ""

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
## Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: "Rainout shelter structure before motor installation."
  focal_point: ""
  preview_only: false

# Custom links (optional).
#   Uncomment and edit lines below to show custom links.
# links:
# - name: Follow
#   url: https://twitter.com
#   icon_pack: fab
#   icon: twitter

url_code: ""
url_pdf: ""
url_slides: ""
url_video: ""

# Slides (optional).
#   Associate this project with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides: ""
---

# Research usage

* Simulate the precipitation-reducing effect that climate change may cause in the Sierra Foothills and quantify the change in forage yield

# Personal involvement

* Research prior rainout shelter designs for automated movement method
* Design a tracked wheel assembly that prevents lift-up in windy conditions using Solidworks
* Design a rack-and-pinion style, electric drivetrain to move rainout shelter up and down a slope with chain and wire cable
* Program a Campbell Scientific datalogger (CR300) to trigger a subroutine in a separate, primary PLC during precipitation event
* Program a primary/secondary PLC network over 4-20mA analog signal to issue deploy/retract commands to an array of 16 rainout shelters
* Program secondary PLC logic for safe deployment of rainout shelter
* Plan radio network for remote data collection and datalogger control over hilly terrain using LOGGERNET
* Suggest best practices for integration of hydraulic motor and PLC automation
* Order building material from local vendors

repository: kylezoa/academic-kickstart

repo_name: kylezoa/academic-kickstart


text:
README
======

This provides a `requirements.txt` for [pip](https://pip.pypa.io/en/stable/) to install an environment for [Keras](https://keras.io) with a [TensorFlow](https://www.tensorflow.org) backend.

It's recommended to use [virtualenv](https://virtualenv.pypa.io/en/stable/) and Python 3 (tested with 3.6.5).

# Setup

```bash
$ python3 -m venv .venv
$ source .venv/bin/activate
$ pip install -r requirements.txt
```

verify that in `~/.keras/keras.json` the `backend` is set to `tensorflow` and `image_data_format` is set to `channels_last`.

repository: Puppim/python-keras-tf-env

repo_name: Puppim/python-keras-tf-env


text:
# Resting Ducks

REST conventions for single tree stores.

[![Build Status](https://travis-ci.org/masylum/resting-ducks.svg?branch=master)](https://travis-ci.org/masylum/resting-ducks)

![](https://media.giphy.com/media/b9QBHfcNpvqDK/giphy.gif)

## Installation

```
npm install resting-ducks --save
```

## Example

```js
import { Duck, Api} from 'resting-ducks'

const client = new Api({host: 'http://localhost:8000', resource: 'tasks'})
const tasks = Duck(client, {})('myTasks')
const store = createStore(tasks.reducer)

store.dispatch(
  task.create({id: 10, name: 'Clean the windows', resolved: false})
).then(() => {
  task.update({resolved: true}, 10, {patch: true})
})
```

## Immutable

The state is stored using [immutable.js](https://facebook.github.io/immutable-js)

## API

### `Duck`

The constructor accepts two arguments:

  - `client` an API to interact with your server. You can use
  the one provided by default in `resting-ducks` wich uses [fetch-please](https://github.com/albburtsev/fetch-please)
  for promise and canceleable requests.
  - `options`
    - `indexes` An array of attributes you would like your model indexed by.
    Defaults to `['id']`

```js
import { Duck, Api} from 'resting-ducks'

const client = new Api({host: 'http://localhost:8000', resource: 'tasks'})
const tasks = Duck(client, {
  indexes: ['id', 'project_id']
})('myTasks')
const store = createStore(tasks.reducer)
```

### `Api`

Defines how you interact with your server.
Must implement `fetch`, `post`, `put`, and `del`.

Options:

  - `host` Mandatory. The host of your server
  - `resource` Mandatory. The name of your resource
  - `base` Defaults to `/`. The prefix (for instance versioning) of your API

```js
import { Api } from 'resting-ducks'

const client = new Api({
  host: 'http://localhost:3000',
  resource: 'users',
  base: '/v2'
})

const {xhr, promise} = client.fetch()

promise.then((data) => {
  console.log(data)
})

// Timeout of 500ms
setTimeout(() => {
  xhr.abort()
}, 500)
```

### `Duck API`

**Resting ducks** come with all the common *REST* actions so you don't
have to re-implement them over and over in your stores.

### Reducer

##### `reducer(state, action)`

The reducer for your resource. Add this one to your store and you are all set!

### Actions creators

##### `set(resources, id|cid = null)`

Replace the current resources with the given ones.

If a `id`/`cid` is given, it applies only to the given resource

##### `patch(attributes, id|cid)`

Patch the resource with the given attributes.

##### `request({label, xhr}, id|cid = null)`

Marks the current duck as having an
ongoing cancelable request. You can use this to represent a loading
transaction and cancel it if needed.

If a `id`/`cid` is given, it applies only to the given resource

##### `error({label, error}, id|cid = null)`

Marks the current duck as having an
error. You can use this to represent it.

If a `id`/`cid` is given, it applies only to the given resource.

##### `add(attributes)`

Append a new resource on the duck.

##### `remove(id|cid)`

Remove a resource.

##### `fetch()`

Retrieve your models from your server.

It marks the `request` object so you can track progress and cancel
it if needed.

In case of error it marks the `error` object.

##### `create(attributes, options)`

Send a new resource to your server. The new resource
is optimistically added on the client.

It marks the `request` object so you can track progress and cancel
it if needed.

In case of error it marks the `error` object.

##### `udpate(attributes, id, options)`

Send new attributes for your resource to your server.
The new attributes are optimistically set on the client.

It marks the `request` object so you can track progress and cancel
it if needed.

In case of error it marks the `error` object.

Extra options:

  - `patch`: Wether the attributes are a patch or a full representation
  of the resource. Defaults to false.

`TODO` Add support for `PATCH`

##### `destroy(id, options)`

Destroy a resource on your server. The resource is optimistically
removed on the client.

It marks the `request` object so you can track progress and cancel
it if needed.

In case of error it marks the `error` object.

### Options

`create`, `update` and `destroy` are optimistic by default. You can
disable that behaviour passing the `optimistic` flag to `false`.

## Tree schema

Your tree will have the following schema:

```js
resources: [
  {                    // Information at the resource level
    cid: String,       // Client side id. Used for optimistic updates
    request: {         // An ongoing request
      label: String,   // Examples: 'updating', 'creating', 'fetching', 'destroying' ...
      xhr: Object,     // The xhr object. You can abort it with `xhr.abort()`
    },
    error: {           // A failed request
      label: String,   // Examples: 'updating', 'creating', 'fetching', 'destroying' ...
      error: String,   // A string representing the error
    },
    attributes: Object // The resource attributes
  }
]                      // Information at the collection level
cid: String,           // The latest Client id generated
request: {             // An ongoing request
  label: String,       // Examples: 'updating', 'creating', 'fetching', 'destroying' ...
  xhr: Object,         // The xhr object. You can abort it with `xhr.abort()`
},
error: {               // A failed request
  label: String,       // Examples: 'updating', 'creating', 'fetching', 'destroying' ...
  error: Object,       // A string representing the error
}
```

## License

(The MIT License)

Copyright (c) 2016 Pau Ramon<EMAIL_ADDRESS>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: masylum/resting-ducks

gha_language: JavaScript

repo_name: masylum/resting-ducks


text:
# stlrug_mlr3
materials for Saint Louis R User Group 10/2/2019  presentation on mlr3

## Presentation is in this order:

### mlr3_slides.Rmd --> requires 'xaringan' package to knit
  - intro, mlr3 overview
  - html output is included if you don't want to knit yourself
  - the `00_Extras` folder contains `mlr3.css` - put this file in:
    - `R Library Path` `/xaringan/rmarkdown/templates/xaringan/resources`

## Demo / Walkthroughs
### 01_basics.Rmd
  - intro to basic tasks, learners

### 02_Resampling.Rmd
  - adding in cross-validation, holdout, etc.

### 03_Tuning.Rmd
  - tuning hyperparameters manually and with AutoTune

### 04_Pipelines.Rmd
  - putting it all together for a complete workflow

### 05_Extras.Rmd
  - small example using MaridaDB (MySQL) as a data backend.


text:
---
date: 2017-02-22
title: معظم صيغ وامتدادات الملفات في العالم
type: blog
layout: post
description: معظم صيغ وامتدادات الملفات مع شرحها والبرامج التي تنتجها موجودة في جدول هنا وبالترتيب الأبجدي - almost all file formats
comments: true
tags: [تقنية, أنظمة]
feature: /assets/posts/documents.png
caption: Image by OpenClipart-Vectors from Pixabay
---

ستجد في الجداول أدناه معظم صيغ وامتدادات ملفات الحاسوب مرتبة أبجدياً مع شرح كل امتداد والبرنامج التابع له.
<!--more-->

* Toc
{:toc}

# A

ABK  |	Corel Draw AutoBackup
ACL  |	Corel Draw 6 keyboard accelerator
ACM 	|Used by Windows in the system directory
ACP |	Microsoft Office Assistant Preview file
ACT |	Microsoft Office Assistant Actor file
ACV |	OS/2 drivers that compress and decompress audio data
AD |	After Dark screensaver
ADB |	Appointment database used by HP 100LX organizer
ADD |	OS/2 adapter drivers used in the boot process
ADM |	After Dark MultiModule screensaver
ADP |	Used by FaxWorks to do setup for fax modem interaction
ADR |	After Dark Randomizer screensaver
AFM |	Adobe font metrics
AF2 |	ABC Flowchart file
AF3 |	ABC Flowchart file
AI |	Adobe Illustrator drawing
AIF |	Apple Mac AIFF sound
ALB |	JASC Image Commander album
ALL |	Arts & Letters Library
AMS |	Velvert Studio music module (MOD) file
ANC |	Canon Computer Pattern Maker file that is a selectable list of pattern colors
ANI |	Animated Cursor
ANS |	ANSI text
API |	Application Program Interface file; used by Adobe Acrobat
APR |	Lotus Approach 97 file
APS |	Microsoft Visual C++ file
ARC |	LH ARC (old version) compressed archive
ARJ |	Robert Jung ARJ compressed archive
ART |	Xara Studio drawing
ART |	Canon Crayola art file
ASA |	Microsoft Visual InterDev file
ASC |	ASCII text
ASD |	WinWord AutoSave
ASM |	Assembler language source file
ASP |	Active Server Page (an HTML file containing a Microsoft server-processed script)
ASP |	Procomm Plus setup and connection script
AST |	Claris Works "assistant" file
ATT |	AT&T Group 4 bitmap
AVI |	Microsoft Video for Windows movie
AWD |	FaxView document

# B

BAK |	Backup file
BAS |	BASIC code
BAT |	Batch file
BFC |	Windows 95 Briefcase document
BG |	Backgammon for Windows game
BI |	Binary file
BIF |	GroupWise initialization file
BIN |	Binary file
BK |	Sometimes used to denote backup versions
BK$ |	Also sometimes used to denote backup versions
BKS |	An IBM BookManager Read bookshelf
BMK |	An A bookmark file
BMP |	Windows or OS/2 bitmap
BM1 |	Apogee BioMenace data file
BRX |	A file for browsing an index of multimedia options
BSP |	Quake map
BS1 |	Apogee Blake Stone data file
BTM |	Batch file used by Norton Utilities
B4 |	Helix Nuts and Bolts file

# C

C |	C code
CAB| 	Microsoft cabinet file (program files compressed for software distribution)
CAL| 	CALS Compressed Bitmap
CAL| 	Calendar schedule data
CAS| 	Comma-delimited ASCII file
CAT| 	IntelliCharge categorization file used by Quicken
CB |	Microsoft clean boot file
CCB| 	Visual Basic Animated Button configuration
CCF| 	Multimedia Viewer configuration file used in OS/2
CCH|	Corel Chart
CCM |	Lotus CC:Mail "box" (for example, INBOX.CCM)
CDA |	CD Audio Track
CDF |	Microsoft Channel Definition Format file
CDI |	Phillips Compact Disk Interactive format
CDR |	Core Draw drawing
CDT |	Corel Draw template
CDX |	Corel Draw compressed drawing
CEL |	CIMFast Event Language file
CFB |	Comptons Multimedia file
CFG |	Configuration file
CGI |	Common Gateway Interface script file
CGM |	Computer Graphics Metafile
CH |	OS/2 configuration file
CHK |	File fragments saved by Windows Disk Defragmenter or ScanDisk
CHP |	Ventura Publisher chapter
CIL |	Clip Gallery download package
CIM |	Sim City 200 file
CIN |	OS/2 change control file that tracks changes to an INI file
CK1 |	iD/Apogee Commander Keen 1 data file
CK2 |	iD/Apogee Commander Keen 2 data file
CK3 |	iD/Apogee Commander Keen 3 data file
CK4 |	iD/Apogee Commander Keen 4 data file
CK5 |	iD/Apogee Commander Keen 5 data file
CK6 |	iD/Apogee Commander Keen 6 data file
CLASS| 	Java class
CLP |	Windows Clipboard file
CLS |	Visual Basic Class Module
CMD |	Command file for Windows NT (similar to a DOS .BAT file)
CMD |	DOS CP/M command file
CMD |	dBase-II program file
CMF |	Corel Metafile
CMP |	JPEG Bitmap
CMP |	Address document
CMV |	Corel Move animation
CMX |	Corel Presentation Exchange image
CNF |	Configuration file used by Telnet, Windows, and other applications
CNM |	Windows application menu options and setup file
CNQ |	Compuworks Design Shop file
CNT |	Windows (or other) system content files for the help index and other purposes
COB |	trueSpace2 object
COD |	Microsoft C compiler output as displayable assembler with original C as comments
COM |	Command file (program)
CPD |	Fax Cover document
CPE |	Fax Cover document
CPI |	Microsoft MS-DOS code page information file
CPL |	Control Panel extension
CPL |	Corel colour palette
CPP |	C++ code
CPR |	Corel Presents Presentation
CPT |	Corel Photo-Paint image
CPX |	Corel Presentation Exchange Compressed drawing
CRD |	Cardfile file
CRP |	Corel Presents Run-Time Presentation
CRT |	Certificate file
CSC |	Corel Script
CSP |	PC Emcee On-Screen image
CSV |	Comma-separated values file
CT |	Scitex CT Bitmap
CTL |	Used in general to mean a file containing control information.
CUE |	Microsoft Cue Cards data
CUR |	Windows Cursor
CUT |	Dr Halo bitmap
CV |	Corel Versions archive
CV |	Microsoft CodeView information screen
CWK |	Claris Works data file
CWS |	Claris Works template
CXX |	C++ source code file

# D

DAT |	Data file
DAT |	WordPerfect Merge Data
DBF |	Aston-Tate dBASE database
DBX |	DataBeam image
DCR |	Shockwave file
DCS |	Desktop Color Separation file
DCX |	Fax image (based on PCX)
DDF |	BTRIEVE database
DEF |	SmartWare II data file
DEF |	C++ Definition
DER |	Certificate file
DIB |	Device-Independent Bitmap
DIC |	Dictionary
DIF |	Data Interchange Format spreadsheet
DIR |	Macromedia Director file
DIZ |	Description file
DLG |	C++ Dialogue Script
DLL |	Dynamic-Link Library
DMF |	X-Trakker music module (MOD) file
DOC |	FrameMaker or FrameBuilder document
DOC |	WordStar document
DOC |	WordPerfect document
DOC |	Microsoft Word document
DOT |	Microsoft Word document Template
DPR |	Borland Delphi project header file
DRV |	Driver
DRW |	Micrografx Designer/Draw
DSG |	DooM saved game
DSM |	Dynamic Studio music module (MOD) file
DSP |	Microsoft Developer Studio project
DSQ |	Corel QUERY file
DSW |	Microsoft Developer Studio workspace
DWG |	AutoCAD drawing eXchange format
DXF |	AutoDesk Drawing Interchange format

# E

EMF |	Enhanced Windows Metafile
ENC |	Encore file
EPS |	Encapsulated PostScript image
ER1 |	ERWin file
ERX |	ERWin file
EVY |	Envoy document
EWL |	Microsoft Encarta document
EXE |	Executable file (program)

# F

F |	FORTRAN file
F77 |	FORTRAN file
F90 |	FORTRAN file
FAR |	Farandole Composer music module (MOD) file
FAV |	Microsoft Outlook navigation bar
FAX |	FAX Type image
FH3 |	Aldus Freehand 3 drawing
FIF |	Fractal image file
FITS |	CCD camera image
FLC |	AutoDesk FLIC animation
FLI |	AutoDesk FLIC animation
FLT |	Corel filter
FLT |	StarTrekker music module (MOD) file
FMB |	Oracle binary source code for form, version 4.0 and later
FMT |	Oracle text format of form, version 4.0 and later
FMT |	Microsoft Schedule+ print file
FMX |	Oracle executable form, version 4.0 and later
FOG |	Fontographer font
FON |	System font
FOR |	FORTRAN file
FOT |	Font-related file
FP |	FileMaker Pro file
FP1 |	Flying Pigs for Windows data file
FP3 |	FileMaker Pro file
FPX |	FlashPix bitmap
FRM |	Form
FRM |	FrameMaker or FrameBuilder document
FRM |	Oracle executable form version 3.0 and earlier
FRM |	Visual Basic form
FRM |	WordPerfect Merge form
FRX |	Visual Basic form stash file

# G

GAL |	Corel Multimedia Manager album
GCP |	Ground Control Point file used in image processing of remote sensing data .
GED |	Graphic Environment Document (drawing)
GEM |	GEM metafile
GEN |	Ventura-Generated text file
GFC |	Patton&Patton Flowcharting 4 flowchart file
GFI |	Genigraphics Graphics Link presentation
GFX |	Genigraphics Graphics Link presentation
GID |	Windows 95 global index file (containing help status)
GIF |	CompuServe bitmap
GIM |	Genigraphics Graphics Link presentation
GIX |	Genigraphics Graphics Link presentation
GNA |	Genigraphics Graphics Link presentation
GNX |	Genigraphics Graphics Link presentation
GRA |	Microsoft Graph
GRD |	Grid file, used in image processing of remote sensing data often to form map projections.
GRP |	Program Manager Group
GTK |	Graoumftracker (old) music module (MOD) file
GT2 |	Graoumftracker (new) music module (MOD) file
GWX |	Genigraphics Graphics Link presentation
GWZ |	Genigraphics Graphics Link presentation
GZ |	Unix Gzip compressed file

# H

H |	C program header
HED |	HighEdit document
HEL |	Microsoft Hellbender saved game
HEX |	Macintosh BinHex 2.0 file
HGL |	HP Graphics Language drawing
HLP |	Help file
HOG |	Lucas Arts Dark Forces WAD file
HPJ |	Visual Basic Help Project
HPP |	C++ program header
HQX |	Macintosh BinHex 4.0 file
HST |	History file
HT |	HyperTerminal
HTM |	Hypertext document
HTML| 	Hypertext document
HTX |	Extended HTML template

# I

ICA |	Citrix file
ICB |	Targa bitmap
ICM |	Image Color Matching profile file
ICO |	Windows Icon
IDD |	MIDI Instrument Definition
IDQ |	Internet Data Query file
IFF |	Amiga ILBM
IGF |	Inset Systems metafile
IIF |	QuickBooks for Windows interchange file
IMA |	WinImage file
IMG |	GEM image
INC |	Assembler language or Active Server include file
INF |	Information file
INI |	Initialization file
INP |	Oracle source code for form, version 3.0 and earlier
INS |	InstallShield install script
INS |	X-Internet sign-up file
ISO |	Lists the files on a CD-ROM; based on the ISO 9660 CD-ROM file system standard
ISP |	X-Internet sign-up file
ISU |	InstallShield uninstall script
IT |	Impulse Tracker music module (MOD) file
IW |	Idlewild screensaver

# J

JAR |	Java ARchive file (a compressed file for applets and related files)
JAVA |	Java source code
JBF |	Paint Shop Pro image browser file
JFF |	JPEG bitmap
JIF |	JPEG bitmap
JMP |	SAS JMPDiscovery chart-to-statistics file
JN1 |	Epic MegaGames Jill of the Jungle data file
JPEG |	JPEG bitmap
JPG |	JPEG bitmap
JS |	JavaScript source code
JTF |	JPEG bitmap

# K

KDC |	Kodak Photo-Enhancer
KFX |	KoFax Group 4 image
KYE |	Kye game data

# L

LBM |	Deluxe Paint bitmap
LDB |	Microsoft Access lock file
LEG |	Legacy document
LHA |	Alternate file suffix for LZH
LIB |	Library
LIS |	Output file produced by a Structured Query Reporting (SQR) program
LOG |	1. Log file
LOG |	2. Log file used by pokerstars for errors in their poker software
LPD |	Helix Nuts and Bolts file
LRC |	Intel Video Phone file
LST |	List file
LWO |	Lightwave Object file
LWP |	Lotus Wordpro 96/97 file
LZH |	LH ARC compressed archive
LZS |	Skyroads data file

# M

M3D |	Corel Motion 3D animation
MAC |	MacPaint image
MAD |	Microsoft Access module
MAF |	Microsoft Access Form
MAK |	Visual Basic or MS Visual C++ Project
MAM |	Microsoft Access Macro
MAP |	Map file
MAP |	Duke Nukem 3D WAD game file
MAQ |	Microsoft Access Query
MAR |	Microsoft Access Report
MAS |	Lotus Freelance Graphics Smartmaster file
MAT |	Microsoft Access Table
MAX |	Paperport file
MAZ |	Hover maze data
MB1 |	Apogee Monster Bash data file
MCC |	Dialer10 calling card
MCS |	MathCAD image
MCW |	Microsoft Word for Macintosh document
MDA |	Microsoft Access add-in
MDB |	Microsoft Access database
MDE |	Microsoft Access MDE file
MDL |	Digital Tracker music module (MOD) file
MDL |	Quake model file
MDN |	Microsoft Access blank database template
MDW |	Microsoft Access Workgroup
MDZ |	Microsoft Access wizard template
MED |	Music Editor, OctaMED music module (MOD) file
MER |	Format for interchanging spreadsheet/database data; recognized by Filemaker, Excel, and others
MET |	Presentation Manager metafile
MI |	Miscellaneous
MIC |	Microsoft Image Composer file
MID |	MIDI music
MMF |	Microsoft Mail File
MMM |	Microsoft Multimedia Movie
MOD |	FastTracker, StarTrekker, Noise Tracker (etc.) music module file
MOD |	Microsoft Multiplan spreadsheet
MOV |	QuickTime for Windows movie
MPE |	MPEG animation
MPEG| 	MPEG animation
MPG |	MPEG animation
MPP |	Microsoft Project file
MPP |	CAD drawing file format
MP3 |	MPEG Audio Layer 3 (AC3) file
MSG |	Microsoft Mail message
MSN |	Microsoft Network document
MSP |	Microsoft Paint bitmap
MTM |	MultiTracker music module (MOD) file
MUS |	Music
MVB |	Microsoft Multimedia Viewer file
MWP |	Lotus Wordpro 97 Smartmaster file

# N

NAP |	NAP Metafile
NCB |	Microsoft Developer Studio file
NSF |	Lotus Notes database
NST |	Noise Tracker music module (MOD) file
NTF |	Lotus Notes database template

# O

OBD |	Microsoft Office binder template
OBD |	Microsoft Office Binder
OBJ |	Object file
OBZ |	Microsoft Office Binder Wizard
OCX |	Microsoft Object Linking and Embedding custom control
OFN |	Microsoft Office FileNew file
OFT |	Microsoft Outlook template
OKT |	Oktalyzer music module (MOD) file
OLB |	OLE Object Library
OLE |	OLE object
OPT |	Microsoft Developer Studio file
ORG |	Lotus Organiser file
OR2 |	Lotus Organiser 2 file
OR3 |	Lotus Organiser 97 file

# P

P10 |	Tektronix Plot 10 drawing
PAB |	Microsoft Personal Address Book
PAK |	Quake WAD file
PAL |	Windows colour palette
PAT |	Corel Draw pattern
PBK |	Microsoft Phonebook
PBM |	Portable Bitmap
PCD |	Kodak Photo-CD image
PCL |	HP Laserjet bitmap
PCS |	PICS animation
PCT |	Macintosh PICT drawing
PCX |	ZSoft PC Paintbrush bitmap
PDF |	Adobe Acrobat Portable Document Format or Netware Printer Definition File
PDF |	Package Definition File from Microsoft Systems Management Server
PDQ |	Patton&Patton Flowcharting PDQ Lite file
PFA |	Type 1 font (ASCII)
PFB |	Type 1 font (binary)
PFC |	PF Component
PFM |	Printer Font Metrics
PGL |	HP Plotter drawing
PGM |	Portable Graymap (bitmap)
PIC |	PC Paint bitmap
PIC |	Lotus picture
PIC |	Macintosh PICT drawing
PIF |	Program Information File
PIF |	IBM PIF drawing
PIG |	Lucas Arts Dark Forces WAD file
PIN |	Epic Pinball data file
PIN |	Epic Pinball data file
PIX |	Inset Systems bitmap
PJ |	MKS Source Integrity file
PKG |	Microsoft Developer Studio application extension (similar to a DLL file)
PL |	Perl program
PLT |	HPGL Plotter drawing
PLT |	AutoCAD Plot drawing
PM5 |	Pagemaker 5.0 file
PM6 |	Pagemaker 6.0 file
P65 |	Pagemaker 6.5 file
PNG |	Portable Network Graphics bitmap
PNG |	Paint Shop Pro Browser catalogue
PNT |	MacPaint graphic file
POT |	Microsoft PowerPoint Template
PP4 |	Picture Publisher 4 bitmap
PPA |	Microsoft PowerPoint Add-in
PPM |	Portable Pixelmap bitmap
PPS |	Microsoft PowerPoint slide show
PPT |	Microsoft PowerPoint presentation
PRE |	Lotus Freelance presentation
PRF |	Windows system file
PRN |	Print Table (space delimited text)
PRS |	Harvard Graphics for Windows presentation
PRZ |	Lotus Freelance Graphics 97 file
PS |	Postscript Interpreted drawing
PSD |	Adobe Photoshop bitmap
PST |	Microsoft Outlook Personal Folder File
PTM |	Polytracker music module (MOD) file
PUB |	Ventura Publisher publication
PUB |	Microsoft Publisher document
PWD |	Microsoft Pocket Word document
PWZ |	Microsoft PowerPoint Wizard
PXL |	Microsoft Pocket Excel spreadsheet

# Q

QAD |	PF QuickArt Document
QBW |	QuickBooks for Windows file
QDT |	Quick Books data file from the Quicken UK Accountancy/Tax/Invoice program
QLB |	Quick Library
QRY |	Microsoft Query
QT |	QuickTime Movie
QTM |	QuickTime Movie
QXD |	Quark XPress file

# R

R |	Pegasus Mail resource file
RA |	Real Audio sound
RAM| 	Real Audio sound
RAS| 	Sun Raster Images bitmap
RAW| 	Raw File Format (bitmap)
RC |	Microsoft Visual C++ Resource Script
REC| 	Recorder macro
REG| 	Registration file
RES| 	Microsoft Visual C++ Resource
RFT |	RFT-DCA
RLE |	Run-Length Encoded bitmap
RM |	Real Audio video file
RMI |	MIDI music
ROV |	Rescue Rover data file
RPT |	Microsoft Visual Basic Crystal Reports file
RTF |	Rich Text Format document
RTM |	Real Tracker music module (MOD) file

# S

SAM |	Ami Professional document
SAV |	Saved game file
SCC |	Microsoft Source Safe file
SCD |	Matrix/Imapro SCODL slide image
SCD |	Microsoft Schedule+ 7
SCH |	Microsoft Schedule+ 1
SCN |	trueSpace2 scene
SCP |	Dial-Up Networking Script
SCR |	Windows screensaver
SCR |	Fax image
SCT |	Scitex CT bitmap
SC2 |	Microsoft Schedule+ 7
SDL |	SmartDraw library
SDR |	SmartDraw drawing
SDT |	SmartDraw template
SEA |	Self-expanding archive (used by Stuffit for Mac files and possibly by others)
SEP |	Tagged Image File Format (TIFF) bitmap
SHB |	Corel Show presentation
SHB |	Document shortcut file
SHG |	Hotspot bitmap
SHS |	Shell scrap file
SHW |	Corel Show presentation
SIT |	Stuffit archive of Mac files
SLK |	Symbolic Link (SYLK) spreadsheet
SND |	NeXT sound
SND |	Mac Sound Resource
SQC |	Structured Query Language (SQR) common code file
SQR |	Structured Query Language (SQR) program file
STM |	Scream Tracker music module (MOD) file
STY |	Ventura Publisher style sheet
SVX |	Amiga 8SVX sound
SYS |	System file
S3M |	Scream Tracker 3 music module (MOD) file

# T

TAR |	Tape Archive
TAZ |	Unix Gzip/Tape Archive
TEX |	Texture file
TGA |	Targa bitmap
TGZ |	Unix Gzip/Tape Archive
THEME |	Windows 95 Desktop Theme
THN |	Graphics Workshop for Windows thumbnail
TIF |	Tag Image File Format (TIFF) bitmap
TIFF |	Tag Image File Format (TIFF) bitmap
TIG |	Tiger file, used by US government to distribute maps
TLB |	OLE Type Library
TMP |	Windows temporary file
TRM |	Terminal file
TRN |	MKS Source Integrity project usage log
TTF |	TrueType font
TWF |	TabWorks file
TWW |	Tagwrite Template
TX8 |	MS-DOS Text
TXT |	Text
T2T |	Sonata CAD modelling software file

# U

UDF |	Windows NT Uniqueness Database File
ULT |	Ultratracker music module (MOD) file
URL |	Internet shortcut
USE |	MKS Source Integrity file

# V

VBP |	Visual Basic Project
VBW |	Microsoft Visual Basic workspace
VBX |	Visual Basic custom control
VCF |	Vevi Configuration File; defines objects for use with Sense8's WorldToolKit
VDA |	Targa bitmap
VI |	Virtual Instrument file from National Instruments LABView product
VLB |	Corel Ventura Library
VOC |	Creative Labs Sound Blaster sound
VP |	Ventura Publisher publication
VSD |	Visio drawing (flow chart or schematic)
VST |	Targa bitmap
VSW |	Visio Workspace file
VXD |	Microsoft Windows virtual device driver

# W

WAD |	Large file for Doom game containing video, player level, and other information
WAV |	Windows Waveform sound
WB1 |	QuattroPro for Windows spreadsheet
WB2 |	QuattroPro for Windows spreadsheet
WBK |	Microsoft Word Backup
WBL |	Argo WebLoad II upload file
WCM |	WordPerfect Macro
WDB |	Microsoft Works database
WEB |	CorelXara Web document
WGP |	Wild Board Games data file
WID |	Ventura width table
WIL |	WinImage file
WIZ |	Microsoft Word Wizard
WK1 |	Lotus 123 versions 1 & 2 spreadsheet
WK3 |	Lotus 123 version 3 spreadsheet
WK4 |	Lotus 123 version 4 spreadsheet
WKS |	Lotus 123 Worksheet spreadsheet
WKS |	Microsoft Works document
WLF |	Argo WebLoad I upload file
WLL |	Microsoft Word Add-In
WMF |	Windows Metafile
WOW |	Grave Composer music module (MOD) file
WP |	WordPerfect document
WPW |	Novel PerfectWorks document
WP4 |	WordPerfect 4 document
WP5 |	WordPerfect 5 document
WP6 |	WordPerfect 6 document
WPD |	WordPerfect Demo
WPD |	WordPerfect Document
WPG |	WordPerfect Graphic
WPS |	Microsoft Works document
WPT |	WordPerfect Template
WQ1 |	QuattroPro/DOS spreadsheet
WQ2 |	QuattroPro/DOS version 5 spreadsheet
WRI |	Write document
WRL |	Virtual Reality model
WS1 |	WordStar for Windows 1 document
WS2 |	WordStar for Windows 2 document
WS3 |	WordStar for Windows 3 document
WS4 |	WordStar for Windows 4 document
WS5 |	WordStar for Windows 5 document
WS6 |	WordStar for Windows 6 document
WS7 |	WordStar for Windows 7 document
WSD |	WordStar 2000 document
WVL |	Wavelet Compressed Bitmap

# X

XAR |	Corel Xara drawing
XLA |	Microsoft Excel add-in
XLB |	Microsoft Excel toolbar
XLC |	Microsoft Excel chart
XLD |	Microsoft Excel dialogue
XLK |	Microsoft Excel backup
XLM |	Microsoft Excel macro
XLS |	Microsoft Excel worksheet
XLT |	Microsoft Excel template
XLV |	Microsoft Excel VBA module
XLW |	Microsoft Excel workbook / workspace
XM |	FastTracker 2, Digital Tracker music module (MOD) file
XR1 |	Epic MegaGames Xargon data file
XTP |	XTree data file
XY3 |	مستند XYWrite III
XY4 |	مستند XYWrite IV
XYP |	مستند XYWrite III Plus
XYW |	مستند XYWrite لويندوز 4.0

# Y

YAL |	مكتبة القصاصات الفنية لبرنامج Arts & Letters
YBK |	Microsoft Encarta Yearbook

# Z

Z |	ملف مضغوط في يُنِكس
ZIP| 	ملف مضغوط
ZOO |	صيغة قديمة لملف مضغوط

# أرقام ورموز

000-999 |	تستخدم لترقيم الإصدارات القديمة من الملفّات وملفّات البيانات المتعلّقة بالأرقام.
12M |	 ملف Lotus 123 97 Smartmaster
123 |	ملف Lotus 123 97
2GR and 3GR |	VGA مُشغِّل الرسوميات/ملفات الإعدادات على منصّة ويندوز
386 |	ملف للاستخدام ضمن معالج 80386 أو أعلى
669 |	Composer 669, Unis Composer music mod file
\#01 أو أكثر |	طريقة لترقيم الصور لتتابع فيلم تم مسحه (تحليله)
$$$ |	يستخدم من قبل نظام OS/2 لتعقّب الملفات المؤرشفة
@@@ |	ملفات عرض تستخدم أثناء التنصيب ولعرض تعليمات استخدام التطبيقات

**هذه المقالة منقولة مع بعض التعديلات، يمكنك الاطلاع على [المصدر](http://ace.net.nz/tech/TechFileFormat.html)**

path: /_posts/2017-02-22-معظم-امتدادات-وصيغ-الملفات-في-العالم.md

gha_license_id: NOASSERTION


text:
## Password Recovery with Gmail account

In order for the Gmail account to be "enabled" to send the Password Recovery email, you need to enable the access to less secure Apps. The page on which you can make this choice is the following, activating this setting for the Gmail account set in the *email.from* parameter.

References: Less secure Apps.

The fields you need to set up in order to have the Password Recovery service work on Gmail accounts are the following:

+  email.from: the sender of the Password Recovery email (your Gmail address);
+  network.smtp.authentication: to be set to TRUE if the server requires authentication, and Gmail does;
+  network.smtp.host: IP ADDRESS or fully qualified name of the SMTP server, in this case smtp.gmail.com;
+  network.smtp.password: the password of the sender's Gmail account;
+  network.smtp.port: the port used by the SMTP server: SSL (465) or TLS (587);
+  network.smtp.ssl:TRUE/FALSE according to the use of SSL or TLS ;
+  network.smtp.tls:TRUE/FALSE according to the use of SSL or TLS;
+  network.smtp.user: MUST be the same account of the email.from field (INCLUDING THE DOMAIN @GMAIL.COM);

**N.B. IT IS NOT POSSIBLE TO HAVE BOTH THE NETWORK.SMTP.SSL AND NETWORK.SMTP.TLS FIELDS SET TO TRUE, ONE OF THEM HAS TO BE SET TO FALSE.**


text:
# ep_wrtc_heading
Video Headings Plugin for Etherpad.

WebRTC video/audio, a dedicated chat room for each headlines (h tags).

> Note: for better expriance use [ep_heading2](https://github.com/ether/ep_headings2), [ep_profile_modal](https://github.com/samirsayyad/ep_profile_modal)

## Installing

```bash
$ npm install ep_wrtc_heading
```

## Settings
To set a custom stun server, set ep_wrtc_heading.iceServer in your settings.json:
```json
"ep_wrtc_heading" : {
    "iceServers":[
        {"url": "stun:stun.l.google.com:19302"}
    ]
}
```

To ensure reliable connectivity we recommend setting both a STUN and TURN server. We don't set this by default and below are just example servers, you should ensure you use reliable STUN and TURN servers.
```json
"ep_wrtc_heading" : {
  "iceServers":[
    {
      "urls": [ "stun:<IP_ADDRESS>:3478", "stun:<IP_ADDRESS>:19302", "stun:[2a00:1450:400c:c08::7f]:19302" ]
    }
      ,
    {
      "urls": [ "turn:numb.viagenie.ca" ],
      "credential": "muazkh",
      "username"<EMAIL_ADDRESS>    },
    {
      "urls": ["turn:<IP_ADDRESS>:3478?transport=udp"],
      "credential": "JZEOEt2V3Qb0y27GRntt2u2PAYA=",
      "username": "28224511:1379330808"
    }

    ],
}
```

To set a custom small and/or large size in pixels, for the video displays, set one or both of the following in your settings.json:
```json
"ep_wrtc_heading": {
  "video": {
    "sizes": {
      "small": 200,
      "large": 400
    }
  }
}
```

To set Limitation for video-chat room:
```json
"ep_wrtc_heading": {
  "videoChatLimit": 4 // default
}
```

## Metrics
You can see metrics for various errors that users have when attempting to connect their camera/microphone:

* `ep_webrtc_err_Hardware`: Some sort of hardware-related connection problem on the users' computer.
* `ep_webrtc_err_NotFound`: Could not find user's camera/microphone.
* `ep_webrtc_err_Abort`: Some sort of other, non-hardware related connection problem on the user's computer.
* `ep_webrtc_err_NotSupported`: User's environment does not support webrtc.
* `ep_webrtc_err_Permission`: User did not grant permission to their camera/microphone
* `ep_webrtc_err_SecureConnection`: Etherpad is not set up on a secure connection, which is requried for webrtc
* `ep_webrtc_err_Unknown`: Some other unspecified error. Perhaps a bug in this plugin.

## License
This project is licensed under the [MIT License](./LICENSE).

> Inspire and use [ep_webrtc](https://github.com/ether/ep_webrtc)

If you have any further questions, please don’t hesitate to contact us.
<marzban98@gmail.com>


text:
# Part 2 - User Authentication

In [Part 1](/experiences/walkthrough/part1/) of this guide, we learned how to create users for the lōm mobile application. In this part, we'll learn how those users can log in to the app and authenticate against the lōm API.

<img style="width: 225px; margin: 0 auto; display: block;" src="/images/experiences/walkthrough/part-2/main-screen.jpg" alt="Main Screen" />

All authentication against Experience Endpoints is done using a token. Each token is specific to a user and grants access to any endpoint that you've specified in the [endpoint configuration](/experiences/endpoints/) or the [user group configuration](/experiences/groups/).

The process of logging in is to simply check a user's email and password and return a token if they're valid. That token can then be used to request API endpoints on behalf of that user. Losant automatically authorizes a token against endpoints and will return a [401 (Unauthorized)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401) error back to the client if the token doesn't allow access to an endpoint.

The first-time setup automatically creates a `POST /auth` route that we can use to get a user's token. Below is a screenshot of the workflow that is automatically generated.

![Auth Workflow](/images/experiences/walkthrough/part-2/auth-workflow.png "Auth Workflow")

The `/auth` requires the user's email and password to be sent as POST data. It then uses the [Authenticate node](/workflows/experience/authenticate/) to check if an Experience User has an identical email and password. If the authentication fails, a [401 (Unauthorized)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401) is returned to the client. If the email and password are valid, the token and the user object, both of which are added to the payload by the Authenticate node, are returned to the client.

You can test this by requesting `/auth` using one of the Experience Users you created in Part 1.

```text
curl -H "Content-Type: application/json" -X POST \
  -d '{"email":"test@example.com","password":"my-password"}' \
  https://example.onlosant.com/auth
```

```json
{
  "token": "THE_USER_TOKEN",
  "user": { ... }
}
```

Now whenever a lōm user enters their email and password on the main screen, the client will POST them to `/auth` and obtain a token in order to make authenticated requests against the API.

Using the `/auth` route is the most common way users will authenticate against your API. For convenience, let's also modify the workflow we created in Part 1 to return a token whenever a user is registered. This removes the need to register the user and then make an additional API request to get the user's token.

![Token Workflow](/images/experiences/walkthrough/part-2/token-workflow.png "Token Workflow")

1. Add a [Generate Token node](/workflows/experience/generate-token/) and insert it after the Create User node.
1. Set the `ID or Email Template` to `{{ data.body.email }}`. The Generate Token node works by accepting the ID or email of an existing Experience User and then creates a token for that user.
1. Set the `Result Path` to `data.newUser.token`.

As we saw above, the Authenticate node automatically creates a token, however you can use the Generate Token node to create a token whenever you want. This provides a way to implement custom authentication mechanisms if needed. With this, in addition to the `POST /users` endpoint, whenever a new user is registered, the client will be returned the new user object and its token as the result.

```json
{
  "email"<EMAIL_ADDRESS>  "firstName": "Jane",
  "lastName": "Smith",
  ...
  "token": "THE_USER_TOKEN"
}
```

You can test endpoint authentication by using the `/me` route that is automatically generated by the first-time setup. First, get a token using the `/auth` route.

```text
curl -H "Content-Type: application/json" -X POST \
  -d '{"email":"test@example.com","password":"my-password"}' \
  https://example.onlosant.com/auth
```

```json
{
  "token": "THE_USER_TOKEN",
  "user": { ... }
}
```

You can use this token to request the authenticated `GET /me` route.

```text
curl -H "Content-Type: application/json" \
  -H "Authorization: Bearer THE_USER_TOKEN" \
  https://example.onlosant.com/me
```

```json
{ "user": { ... } }
```

Requesting authenticated routes is done by providing the token in one of three ways. The example above placed the token in the `Authorization` header. More details can be found on the [endpoint documentation](/experiences/endpoints/#passing-authorization-tokens).

At this point, the lōm mobile app has everything it needs to successfully register users and allow those users to log in to the app. This concludes Part 2 of the application Experience walkthrough. The next part will describe how devices can be registered and associated with an Experience User.

**[Continue to Part 3](/experiences/walkthrough/part3/)**: Device Registration

repository: InconceivableDuck/losant-docs

repo_name: InconceivableDuck/losant-docs


text:
# Terminology Used

### ABI
The Application Binary Interface (ABI) is a JSON-based description on how to convert user actions between their JSON and binary representations. The ABI may also describe how to convert the database state to/from JSON. Once you have described your contract via an ABI this allows developers and users to interact with your contract seamlessly via JSON.

---

### Account
An account is a unique identifier and a requirement to interact with CyberWay blockchain. Unlike most other cryptocurrencies, transfers are sent to a human readable account name instead of a public key, while keys attributed to the account are used to sign transactions.

---

### Account Name
An account name is a human-readable identifier that is stored on the blockchain. Account names can consist of individual parts separated by the symbol "dot". Wherein, two "dot" symbols near each other are not allowed. Account names can only contain the alphanumeric characters, the "hyphen" symbol can be used as well, but should not be at the beginning or end of any account name part. Capital letters in an account user name are unacceptable.

---

### Action
Functionality exposed by a smart contract that is exercised by passing the correct parameters via an approved transaction to CyberWay network.

---

### Bandwidth
Bandwidth represents resources allocated to an account for performing a transaction, as well as for storing its personal information. Bandwidth resources include CPU, RAM, NET, and Storage.

---

### Block
A special structure for recording a group of transactions in the Bitcoin system and similar ones. A block consists of a header and a list of transactions. The block header includes its own hash, the hash of the previous block, transaction hashes, and additional overhead information.

---

### Blockchain
A strictly structured database with certain rules for building chains of transactions and access to information that excludes data theft, fraud, violation of property rights, etc.

---

### Blockchain Application
A blockchain application is a software application that has integrated a blockchain in its architecture as the storage layer for part of, or, all of its data. This includes software applications that do not own their own contract on the blockchain and instead only interact with the system contracts of the blockchain.

---

### Block Log
The block log is an append only log of blocks written to disk and contains all the irreversible blocks.

---

### Community
A group of persons formed around some point of interest. Community can be created by any user or group of users. Each community has its own point and parameters.

---

### Community leader
A person registered in the Commun application as a leader and is on top-leaders list of the same community. Leader is responsible for setting community parameters and moderating message content. Community leaders are elected by users of the same community through endless voting.

---

### Community user
A person is considered a community user if the person is registered in the Commun application and has a balance with points of same community. A user can be a member of several communities simultaneously if the user has balances with points of the same communities. Community user able to perform the following operations: posting, voting for a content and a leader, creating a community.

---

### Container
An object created using a Docker image and containing all the necessary components for the operation of the application. The container is a secure platform for the operation of the application.

---

### CPU
CPU is processing power granted to an account by a CyberWay based blockchain. The amount of CPU an account has is measured in microseconds, and represents the amount of processing time an account has at its disposal when executing its actions. CPU is recalculated after each block is produced, based on the amount of system tokens the account staked for CPU bandwidth in proportion to the amount of total system tokens staked for CPU bandwidth at that time.

---

### Chain State
The chain state or database is a memory mapped file, storing the blockchain state of each block (account details, deferred transactions, transactions, data stored using multi index tables in smart contracts, etc.). Once a block becomes irreversible the chain state is not cached anymore.

---

### Cleos
(`cleos` = `command line` + `eos`) `cleos` is a command line tool that interfaces with the REST API exposed by nodeos. `cleos` contains documentation for all of its commands. For a list of all commands known to `cleos`, simply run it with no arguments.

### Confirmed Transaction
On completion of the transaction, a transaction receipt is generated. Receiving a transaction hash does not mean that the transaction has been confirmed, it only means that the node accepted it without error, which also means that there is a high probability other validators will accept it. A transaction is considered confirmed when a nodeos instance has received, processed, and written it to a block on the blockchain, i.e. it is in the head block or an earlier block.

---

### Cryptographic Hash
A cryptographic hash function is a hash function which takes an input (or `message`) and returns a fixed-size alphanumeric string. The alphanumeric string is called the `hash value`, `message digest`, `digital fingerprint`, `digest` or `checksum`.

---

### Daemon
A program on Linux systems, launched by the system itself and running in the background without direct user interaction.

---

### Deferred Action
Deferred actions are actions sent to a peer action that are scheduled to run, at best, at a later time, at a block validator's discretion. There is no guarantee that a deferred action will be executed. From the perspective of the originating action, i.e., the action that creates the deferred action, it can only determine whether the create request was submitted successfully or whether it failed (if it fails, it will fail immediately). Deferred actions carry the authority of the contract that sends them. A deferred action can also be cancelled by another action.

---

### Deserialization
Deserialization is the reverse process of serialization. It turns a stream of bytes into an object in memory. CyberWay structures are enhanced with two operators which implement the serialization and deserialization of data to and from the database.

---

### Digital Signature
A digital signature is a mathematical scheme for verifying the authenticity of digital messages or documents. A valid digital signature, where the prerequisites are satisfied, gives a recipient very strong reason to believe that the message was created by a known sender (authentication), and that the message was not altered in transit (integrity). Digital signatures are a standard element of most cryptographic protocol suites, and are commonly used for software distribution, financial transactions, contract management software, and in other cases where it is important to detect forgery or tampering.

---

### Dispatcher
Every smart contract must provide an `apply` action handler. The `apply` action handler is a function that listens to all incoming actions and performs the desired behavior. In order to respond to a particular action, code is required to identify and respond to specific action requests. `apply` uses the `receiver`, `code`, and `action` input parameters as filters to map to the desired functions that implement particular actions. To simplify the work for contract developers, CyberWay provides the CYBERWAY_/EOSIO_DISPATCH macro, which encapsulates the lower level action mapping details of the apply function, enabling developers to focus on their application implementation.

---

### Docker
Software to automate the installation of the application in the virtualization environment at the operating system level. Provides installation of an application with all its environments and dependencies into a container that can be ported to any Linux system with cgroups support in the kernel, and also provides a container management environment.

---

### Docker-compose
Command line tool for managing multiple Docker multi-container applications.

---

### Docker-file
A file containing instructions and parameters for creating a Docker image for specific tasks.

---

### Docker image
Docker platform template, available only by reading and used to create containers.

---

### DPoS (Delegated Proof-of-Stake)
DPoS stands for "Delegated Proof of Stake" and is a consensus algorithm initially developed by Daniel Larimer in 2013 for Bitshares. It's sometimes referred to as "Democracy as Proof of Stake".

---

### Gallery
A collection of mosaics united by the same theme. Each community has its own gallery.

---

### Gem
User's opinion about an entity presented for discussion. Opinion can be expressed in the form of positive or negative comment, vote or other forms of attitude to the entity. The strength (weight) of opinion depends on number of points allocated to it by the user.

---

### Genesis (Greek genesis)
The beginning of the formation of any object or subject and the subsequent process of its development, which led to a certain state.

---

### Genesis Block
The genesis block is the very first block in the CyberWay blockchain. The subsequent block added after the genesis block becomes block `1` and continues the sequence. The genesis block lays the foundation for other blocks to be added to form a blockchain.

---

### Genesis Node
The genesis node is the first node in the blockchain network. The genesis node is used to perform a set of actions such as creating system accounts, initializing system, and token contracts in order to create a fully-functional blockchain with varying capabilities such as governance, resource allocation, and more.

---

### Head Block
The head block is the last block written to the blockchain, stored in reversible_blocks.

---

### Indices
In the context of a multiple index table, an index is a particular ordering of the elements in the table. Multiple index indices allow the same data in one table to be viewed as different data structures by specifying the specific index on the table.

---

### Inline Action
Inline actions request other actions that need to be executed as part of the original calling action. Inline actions operate with the same scopes and authorities of the original transaction, and are guaranteed to execute with the current transaction. These can effectively be thought of as nested transactions within the calling transaction. If any part of the transaction fails, the inline actions will unwind with the rest of the transaction.

---

### Irreversible Block
A block is considered irreversible (i.e. immutable) on blockchain when (2/3rd + 1) of the currently elected validators have acknowledged it.

---

### Keosd
(`key` + `eos` = `keosd`) A component that securely stores keys in wallets.

---

### Key
A string of characters (bit string) used by the cryptographic algorithm for encrypting and decrypting messages, setting and verifying a digital signature, as well as identification. Keys are symmetric (the same key is used for encryption and decryption) and asymmetric (public and private).

---

### Mosaic
Data table of the entity discussion process from the moment of its publication to the reward completion moment to all participants in this process. An author at the time of publication creates a mosaic and inserts the first gem into it. Each user, leaving a comment or voting for the post, contributes a gem to this mosaic. Once the discussion and payments are terminated, this mosaic collapses.

---

### Multi-Index
CyberWay wraps the boost multi-index library to provide in memory data persistence. A subset of the functionality provided by the boost multi-index is provided in the CyberWay multi-index.

---

### Multisig
`Multisig` or `msig` is a short term for multiple signatures. It is used to describe the case in which one requires more than one account's permission to execute a transaction. CyberWay provides the system account, which can be used to push onto the blockchain the `multisig` proposals and their corresponding account's permission required to approve the proposal. `Multisig`, when used properly, increases the security of an account, the security of a smart contract, and it's also the method by which validators are able to affect changes within blockchain.

---

### NET
NET required to store transactions on CyberWay blockchain. The amount of NET an account has is measured in bytes, representing the amount of transaction storage an account has at its disposal when creating a new transaction. NET is recalculated after each block is produced, based on the system tokens staked for NET bandwidth by the account. NET measures the size of the transactions and not contract state.

---

### Node
A separate (software) device that is connected to the blockchain network according to the client-server scheme. Nodes are active elements and form the basis of the blockchain network technology.

---

### Nodeos
(`node` + `eos` = `nodeos`) the basic daemon of the CyberWay node, which can be configured using plug-ins to start the node. Examples of use: block production, dedicated API endpoints, and local development.

---

### Opus
Mosaic description type. It indicates what the mosaic describes, such as a post or comment.

---

### Packed Transaction
In order to transfer transaction content between nodes faster and to save storage space when storing transaction content in database, the transactions are `converted` from `json` into a packed form which is smaller in size. To get the packed version of a transaction one can use the `cleos` convert command.

---

### Pending Block
The pending block is the block currently being built by each node. Transactions are added to the pending block as they are received and processed. The pending block becomes the head block once it is written to the blockchain. Note that a head block is initially reversible.

---

### Permission
A weighted security mechanism that determines whether or not a message is properly authorized by evaluating its signature(s) authority. Every account has two default permissions, `owner` and `active`, but can also have custom permissions to further secure communications from an account to contracts. Every permission name has a "parent". Parents possess the authority to change any of the permissions settings for any and all of their children.

---

### Permission Threshold
The sum of permission weights necessary for a signature to be considered valid.

---

### Permission Weight
A permission weight is a value given to an account for authorization purposes. This is typically used in the context of a mutli-sig to give one or more accounts more control over a multi-sig than others.

---

### Permission level
Permissions are arbitrary names used to define the requirements for a transaction sent on behalf of that permission. Permissions can be assigned for authority over specific contract actions by "linking authorization" or linkauth. Every account has two native named permissions, `owner` and `active`.

---

### Plugin
A software component, made as a separate module and being an addition to the main program.

---

### Point
Main payment unit used for payments within a separate community. Point is not a token and can not be used in exchange trading. Points are used as coins to encourage community members and applied only within the community.

---

### Private key
A code string with which you can access your wallet or bitcoin address. Required for transactions.
A private key is a secret key used to sign transactions. In CyberWay, a private key's authority is determined by it's mapping to a CyberWay account name.

---

### Proxy account
An account empowered with a specific voting authorization during the voting process. A proxy account can be declared by any user who is ready to accept votes from other users and vote for the validators on their behalf.

---

### Proxy account level
A conditional division of users into categories. The highest level of proxy account is zero, which is assigned only to validators. The first and further levels in ascending order are assigned to users who have declared themselves proxy accounts. The number of levels (categories) of proxy accounts is not limited. The number of proxy accounts of the same level is also not limited. The last level of proxy account is assigned to the ordinary user.

---

### Public key
A publicly available key that can be authorized to permissions of an account and can be used to identify the origin transaction. A public key can be inferred from a signature.

---

### P2P
A peer-to-peer computer network in which all participants (nodes) are equal in rights and can interact with each other, being a client and server simultaneously.

---

### RAM
RAM is a part of the bandwidth resources allocated to an account for the duration of a transaction for storing consensus information.

---

### Reversible Block
Any block on blockchain with a block number greater than the last irreversible block. Reversible blocks are blocks that are not currently guaranteed to be on the blockchain.

---

### Safe
Functionality allowing a user to manipulate funds in order to preserve them, namely to lock funds and withdrawal operations on them, including transfer, selling points to buy tokens. Access to funds is possible only after they are unlocked by the safe owner.

---

### Scope
Scope is a region of data within a contract. Contracts can only write to regions in their own contracts but they can read from any other contract's regions. Proper scoping allows transactions to run in parallel for the same contract because they do not write to the same regions. Scope is not to be conflated with an account name, but contracts can use the same value for both for convenience.

---

### Serialization
Serialization is the process of turning an object in memory into a stream of bytes so it can be stored on disk or sent over the network.

---

### Signature
A signature is a mathematical scheme for demonstrating the authenticity of digital messages or documents.

---

### Smart Contract
A smart contract is a computer protocol intended to facilitate, verify, or enforce the negotiation or performance of a contract.

---

### Stake
A share of bandwidth resources (RAM, NET, CPU and Storage) allocated to a user. The user can manage the share of resources allocated to him both independently and entrust its use to another user (delegate the share of resources).

---

### Staked tokens
Tokens allocated for a stake acquisition that can’t be used for anything else in this state. The user can stake active tokens listed on his/her balance or deposit them. Also, the user can perform the reverse operation — withdraw tokens from the staked state to active.

---

### Storage
Storage is a part of the bandwidth resources allocated to an account for storing personal account information.

---

### System Contract
The design of the CyberWay blockchain calls for a number of smart contracts that are run at a privileged permission level in order to support functions such as validator registration and voting, token staking for CPU and network bandwidth, RAM purchasing, multi-sig, etc. These smart contracts are referred to as the system contracts and are the following, `bios`, `domain-names` `govern`, `multi-signature`, `stake` and `tokens` contracts.

---

### Tables
Tables in CyberWay blockchain are achieved via Multiple Index Table.

---

### Test Network
A test network or `testnet` is an instantiation of the CyberWay platform that is intended for testing purposes. Generally, the native token has no value and is given away to developers so they can test. Some features of a testnet may be disabled such as consensus and governance.

---

### Transaction
A complete all-or-nothing change to the Blockchain. A combination of one or more actions. Usually the execution result of a Smart Contract.

---

### Token CMN
Main coin registered in the system of CyberWay and introduced to exchange of funds between communities, as well as between Commun and Cyberway blockchain.

---

### Tracery
Mosaic identifier, which is a hash sum generated from post author name and publication title.

---

### Trusted Community Client
A person appointed by commun leaders to make decisions within the dApp application.

---

### Unconfirmed Transaction
A transaction is considered unconfirmed as long as no `nodeos` instance has received, processed, and written it to a block on the blockchain, i.e. it is not in the head block or a block earlier than the head block.

---

### Validator
A validator (or a block producer) is an identifiable entity composed of one or more individuals that express interest in participating in running CyberWay network. By participating it is meant these entities will provide a full node, gather transactions, verify their validity, add them into blocks, and propose and confirm these blocks. A block producer is generally required to have experience with system administration and security as it is expected that their full-node have constant availability.

---

### Validator Schedule
The list of validators who currently have the possibility of being selected to produce the next block. This list changes with every new block.

---

### WASM (Web-Assembly Machine)
WASM stands for WebAssembly. WASM is an emerging web standard with widespread support of Google, Microsoft, Apple, and others.

---

### WIF
WIF stands for Wallet Import Format and is an encoding for a private key. The following is an example of a WIF Private Key: 5HprTdeuiow57FgeRt39Bnmf4nEB3kEsreAbuatmU.

---

### Wallet
Wallets are clients that store keys that may or may not be associated with the permissions of one or more accounts. Ideally a wallet has a locked (encrypted) and unlocked (decrypted) state that is protected by a high entropy password.

---


text:
# Cracking Codes with Python

Working through this book

[Cracking Codes with Python](https://inventwithpython.com/cracking)

Trying to do same exercises in Rust, we will see how that goes.

## Creating virtual environments¶

``` shell
#
python3 -m venv .env
source .env/bin/activate
# Install https://pypi.org/project/black/ code formatter
pip install -U black
```

Getting longer content to encrypt from:

- [poetryfoundation](https://www.poetryfoundation.org)
- [gutenberg.org](https://www.gutenberg.org/catalog/)
- [GitHub - english words](https://github.com/dwyl/english-words)

repository: srufle/cracking-codes

repo_name: srufle/cracking-codes


text:
# Eden Web App

This is the frontend that you see when you access the Eden portal. We use Next.js to have Server Side Rendering capabilities and performance niceties.

While it depends on a server now we intend this to be a thin PWA client or Electron App not being dependent in any external infra as we evolve.

## Web App Settings

### Setting Environment Variables

When running the webapp you can setup all of the configuration using environment variables. Any environment variable prefixed with `NEXT_PUBLIC_` are exposed to the client; secrets should never use this prefix.

Environment variables are defined `.env` file. Most should be self-explanatory. When running locally, these can be overridden on a variable-by-variable basis in a `.env.local` file. This is a good place to include any secrets as those should not be checked in.

When deployed for production, environment variables can be overridden by setting environment variables in your host. In Vercel, for example, environment variables can be set individually for production, development and preview (branch) environments.

### Helpful Local Environment Variables

-   `NEXT_PUBLIC_AA_COLLECTION_NAME` and `NEXT_PUBLIC_EDEN_CONTRACT_ACCOUNT`: Change these to point to a different contract. For example, `"test2.edev"`.
-   `NEXT_PUBLIC_AA_FETCH_AFTER`: Seeing more NFTs than members in a test environment? It may be because the contract has been reset and you're seeing members from past tests. To filter those out, set the `NEXT_PUBLIC_AA_FETCH_AFTER` environment variable in your `.env.local` file to the approximate UNIX timestamp, in milliseconds, of the new contract deployment. (\_E.g., `NEXT_PUBLIC_AA_FETCH_AFTER="1626286021000"`.
-   `NEXT_PUBLIC_DEV_USE_FIXTURE_DATA`: If you want to test against hard-coded fixture data (for certain features currently under development), set this to `true`: `NEXT_PUBLIC_DEV_USE_FIXTURE_DATA="true"`.

### IPFS Upload Handlers

There are currently two options for managing IPFS upload and pinning:

#### Infura + NextJS + pinata.cloud

The client uploads the file directly to Infura's free (but limited) IPFS service. Once uploaded, our app's Next.js serverless `ipfs-upload` API handler pins the file using pinata.cloud (to guarantee the file remains available for download via the IPFS network.)

This is fine for getting started, but it does hae some limitations. For example, Infura's free service seems to have a cap at 100 MB per file. We anticipate election video recordings to surpass that limit, though. Furthermore, Infura is an extra dependency that we have no control over.

To use this option:

-   `NEXT_PUBLIC_BOX_UPLOAD_IPFS` should be set to `false`
-   `IPFS_PINATA_JWT` should be set to an API JWT provided by Pinata. Set up a new API key in pinata.cloud with permissions to the Pinning Services API's `addPinObject`, `getPinObject` and `listPinObject`.

#### Eden Box + pinata.cloud

The client uploads the file to our own [Eden Box](../box) service, which, in turn, uploads and pins the file to the IPFS network via pinata.cloud. The file is uploaded together with the related signed transaction so that it can be validated against the transaction and a whitelist prior to pinning.

This is nice because we remove the dependency on Infura, but there is a bit more complexity in running the Eden Box service. More info on that [here](../box/README.md).

To use this option:

-   `NEXT_PUBLIC_BOX_UPLOAD_IPFS` should be set to `true`
-   `NEXT_PUBLIC_BOX_ADDRESS` must point to your box, wherever it's deployed
-   The `IPFS_PINATA_JWT` is _not_ needed in the webapp enviroment

When running the Eden application locally using `yarn dev --stream`, the Box service will start up on its configured port (default 3032) and can be accessed by the local frontend directly. To do so, set `NEXT_PUBLIC_BOX_ADDRESS` in your `.env.local` file to point to your local box port (_e.g._, `http://localhost:3032`).

A pinata.cloud API JWT will still be needed, but that's set in the Box environment variables, and instead requires the pinata.cloud `pinFileToIPFS` permission.

#### Other Considerations

If you want to enable uploads greater than 100 MB, use the Eden Box option. And we recommend a paid account with [pinata.cloud](https://pinata.cloud).

If the future, we will explore ways to remove our dependency on pinata.cloud too.


text:
[comment]: # ( Copyright Contributors to the Open Cluster Management project )
# Release Content

### Additions
- Add the command `delete token` from [clusteradm](https://github.com/open-cluster-management-io/clusteradm)
### Breacking changes
- Fix [Manual import failed because klusterlet crd not ready yet](https://github.com/open-cluster-management/cm-cli/issues/30).
Two files are generated instead of one and the command to apply to manual import is like `kubectl apply -f import_crd.yaml;sleep 10;kubectl apply -f import_yaml.yaml`
with `import` being the `--import-file` parameter value.

### Bug fixes

repository: skeeey/cm-cli

repo_name: skeeey/cm-cli


text:
# GFM's Ludum Dare #38 Entry

My entry for Ludum Dare #38.

The template was based on my
[Meeting Jam 2017 entry](https://github.com/SirGFM/meeting17/tree/84a48b7bd595eb307d3e0f462b49c72182c14d67)
and my current main project, [JJAT+](https://github.com/SirGFM/jjat_2/tree/v0.5.1).

## Compile instructions

This game has the following dependencies:

* [SDL 2](https://www.libsdl.org/)
* [GFraMe - v2.4.1](https://github.com/SirGFM/GFraMe/tree/v2.4.1)
* [c_synth - v1.0.2.c](https://github.com/SirGFM/c_synth/tree/v1.0.2.c)

After building/installing the dependencies, run:

```
make RELEASE=yes
```

Compiling on Windows is still terrible documented... I'll fix that, eventually...
Cross-compiling for Windows, on the other hand, is somewhat easy when using
[MXE](https://github.com/mxe/mxe).

license: Zlib


text:
autoSJIS-HexChat
================

HexChat version of the autoSJIS plugin.

Loading
-------

This will require Python 3.x support on Hexchat.

 - Stick both `sjis.py` and `sjis.dat` in `~/.config/hexchat/addons/autosjis/` (UNIX) or `%APPDATA%\HexChat\addons\autosjis\` (Windows).
 - Do `/load autosjis/sjis.py`.

Usage
-----

 - `/sjislist` will show a list of all emojis and their triggers.
 - `/sjis <trigger without colons>` will say that particular emoji.
 - Using `:trigger:` in the chat in general will auto-replace inline.

license: Unlicense

repository: Knifa/autoSJIS-HexChat

repo_name: Knifa/autoSJIS-HexChat


text:
M_PiPhone - 10th birthday gift to my son.
=======

DIY phone/computer based on Raspberry Pi, PiTFT, GMS module and Lithium ion battery from Adafruit referencing [Dave's Blog](http://www.davidhunt.ie/piphone-a-raspberry-pi-based-smartphone/)

I changed the phone orientation from the original program since it is still nice to use it more than just a phone.  Raspberry Pi is basically a computer, so the kid could use it for many other things and it is easier to work with Raspberry Pi with 90 degree orientation. Before I learn to use 3D printer, I added phone/computer case using shoe box cardboard for now.  For the phone program, close, mom, dad and home speed dial buttons are added to the touchscreen interface.

![M Phone](https://github.com/koodlelab/M_PiPhone/blob/master/20150209_175716.jpg)

![M Phone2](https://github.com/koodlelab/M_PiPhone/blob/master/20150210_170352.jpg)


text:
# MacOS Theme Toggler

Toggles Mojave's Theme based on the time of day. Feel free to contribue to the project. This is my first real rust project, so the code quality may not be up to standards.

## Running the software
### Building
First you must build it before you can use it. This will change in the future, but for now as long as you have cargo installed just run
```bash
cargo build --release
```
After it builds the binary will be in `macos_theme_toggler/target/macos_theme_toggler` from there you can just run the program with the following command
```bash
./macos_theme_toggler/target/macos_theme_toggler [latitude: float] [longitude: float]
```

# Roadmap
* Add a way to run it at startup
* Maybe put it on homebrew so it is easier to install
* Maybe add a way to auto configure the lat and long based on the users IP, maybe use seomthing like https://ipinfo.io/json since they do not require an API key.
* Clean up the code a bit I guess ¯\\\_(ツ)_/¯

repository: wheatjs/macos-theme-toggler

repo_name: wheatjs/macos-theme-toggler


text:
## Using Storybook

You can demo your changes by running the storybook demo locally with the following commands:

```sh
yarn install
yarn build
yarn storybook
```

The Storybook will
[automatically build from the source code](https://github.com/apache-superset/superset-ui/blob/master/packages/superset-ui-demo/.storybook/main.js#L49-L58)
when package names start with `@superset-ui/`.

repository: AxiataADA/superset-ui

gha_language: TypeScript

repo_name: AxiataADA/superset-ui


text:
---
layout: essay
type: essay
title: Assignment 3 Checkpoint
date: 2020-05-09
labels:
  - My Progress
  - Checkpoint
  - Blog Entry
  - Assignment 3
---
Checkpoint A:

Describe your design for your site's shopping cart. That is, will it be a separate page that the user can view and edit, or will it be integrated into the product pages? If so, describe in detail how this will work on your site. Provide several examples of using the cart.

 - The shopping cart is a separate page that the user can view and edit.  On each product page, the user has the ability to “add to cart” for each tour.  Those tour quantities will be saved in a session as the user continues to navigate throughout the pages and add more tours.  The user can access the cart at any time and edit the tour amounts.  Once pressing the purchase button on the shopping cart page, if the user is not already logged in, he/she will be redirected to a login page, and after logging in (or registering), they will be taken to the invoice page.  This will thank them personally for their purchase and show the invoice from their purchase (also giving a notification that an email copy has been sent to them at their email address).

Checkpoint B:

Explain specifically how you will use sessions to manage your shopping cart. In particular, what shopping cart data will be stored in the session, what data format will be used (NOT what data type, but the format like with the data format used for your registration data). Use code examples showing what data structures (such as arrays and their keys) you will use to manage the shopping cart data and how they will be used in $_SESSION.

  - When the customer clicks “Add to Cart” I will save that data to a session as a JSON object.

Checkpoint C:

How will you avoid access to your application when the user has not logged in or registered? What are the particular security concerns you must address?

  - I will do a verification on the server to check cookies to verify that the user has an account, or if not, I will direct them to the registration page.  The particular security concern is that a non-member would get to the purchase page, so I will set an if-statement on the server-side to redirect to the login page if there is no user information about the person trying to access the page.

Checkpoint D:

Upon a successful login, how do you provide personalization in your UI? Explain how you did or will do this (paste code if necessary):

  - I will welcome the user by their name (or username if a name is not given).  When they are sent to the invoice page, I will specifically list their email address so they know that the invoice was sent to the correct place.

Checkpoint E:

If you are working with partners, how will you split up the work in your team so that you are working in parallel as effectively as possible? That is, who is doing what and when?

 - I am working solo.

Checkpoint F:

How are you approaching Assignment 3 differently than Assignment 2?

 - I am doing a similar approach as in Assignment 2 where I write down the immediate next steps I need to take.  For example, if I need to stop a user from accessing the invoice page, I would write down to “verify the user by requesting and verifying cookie when they press ‘purchase’”.  This helps keep me focused on the immediate task when there seems like a million and one things could be worked on.

path: /essays/Checkpoint Assignment 3.md

filename: Checkpoint Assignment 3.md


text:
This package is designed to enable quick and easy development of
experiments in psychology/neuroscience. Most experiment scripts are coded
up with a fairly ad-hoc `for t in trials` approach, which generally leads
to inaccurate timing, accumulation of lag over trials, and in catastrophic
cases, failure to log all the experimental parameters and responses of
interest. It can also be surprisingly difficult to achieve more
sophisticated presentation schemes (e.g., presenting a video while
collecting keyboard responses and monitoring MRI scanner pulses) if you are
coding everything up from scratch.

# Install
clone this repo and do `python setup.py install`. A reasonably recent
version should also be on [pypi](https://pypi.python.org/pypi/expcontrol)
so try `pip install expcontrol`.

# Do I need [psychopy](http://psychopy.org)?
It's not a dependency, but at the moment you won't be able to use the package
for much without it. All the psychopy-dependent code is in the psychopydep
module, so psychopy can be swapped out for another timing/opengl/response
logging solution as desired.

# TO DO
* Tests
* Auditory events

# License
ISC. See [separate file](LICENSE).

license: ISC

repository: jooh/py-expcontrol

repo_name: jooh/py-expcontrol