text:
# hyperlinker [![Build Status](https://travis-ci.org/jamestalmage/hyperlinker.svg?branch=master)](https://travis-ci.org/jamestalmage/hyperlinker) [![codecov](https://codecov.io/gh/jamestalmage/hyperlinker/badge.svg?branch=master)](https://codecov.io/gh/jamestalmage/hyperlinker?branch=master)

> Write hyperlinks in the terminal.

Terminal emulators are [starting to support hyperlinks](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda). While many terminals have long detected URL's and linkified them, allowing you to Command-Click or Control-Click them to open a browser, you were forced to print the long unsightly URL's on the screen. As of spring 2017 [a few terminals](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda) began supporting HTML like links, where the link text and destination could be specified separately.

This module will create hyperlinks when printed to a supported terminal.

## Install

```
$ npm install hyperlinker
```

## Usage

```js
const hyperlinker = require('hyperlinker');

console.log(hyperlinker('some text', 'https://example.com') + '   <--- command + click here!');
// some text    <-- command + click here!

```

Note that this module does not check to see if hyperlinks are supported in the current Terminal. In unsupported terminals, users will likely only see the `text` command. You should use module [`supports-hyperlinks`](https://github.com/jamestalmage/supports-hyperlinks) if you want to provide an alternate presentation based on Terminal support.

```js
const supportsHyperlinks = require('supports-hyperlinks');
const hyperlinker = require('hyperlinker');

if (supportsHyperlinks.stdout) {
    console.log(hyperlinker('click here', 'https://example.com'));
} else {
    console.log('Copy and paste the following in your browser: \n\t https://example.com');
}
```

## API

### hyperlinker(text, uri, [params])

#### text

Type: `string`

The text that will be visible in the link. This is equivalent to the text between the opening `<a>` and closing `</a>` tags in HTML.

#### uri

Type: `string`

A URI (i.e `https://example.com`) where the link will point to. This is equivalent to the context of the `href` attribute in an HTML `<a>` tag.

#### params

Type: `Object`<br>
*Optional*

A collection of key value pairs, that will be printed as hidden `params`. There's not a lot of use for these right now, except for maybe [an id param](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda#hover-underlining-and-the-id-parameter). It is intended to allow extension of the spec in the future.

## Related

  * [`supports-hyperlinks`](https://github.com/jamestalmage/supports-hyperlinks): Detect hyperlink support for the running terminal.

## License

MIT © [James Talmage](https://github.com/jamestalmage)

repository: jamestalmage/hyperlinker

repo_name: jamestalmage/hyperlinker


text:
# Multicore VS Multiprocessor

## pediaa [Difference Between Multicore and Multiprocessor](https://pediaa.com/difference-between-multicore-and-multiprocessor/)

The **main difference** between multicore and multiprocessor is that the **multicore refers to a single CPU with multiple execution units while the multiprocessor refers to a system that has two or more CPUs.**

## superuser [What's the difference between multicore proc and multiproc system?](https://superuser.com/questions/13107/whats-the-difference-between-multicore-proc-and-multiproc-system)

[A](https://superuser.com/a/13418)

Multiple processors let your computer do literally two things at once (instead of only seemingly doing two things at once, but actually just swapping between tasks extremely rapidly).

**Multiple cores** are the same. The advantage of multiple cores over multiple processors is that they share some bits of the CPU, e.g. the second level cache, which makes it possible for them to work even more efficiently if they have some shared data. This makes them much cheaper to manufacture. A single dual-core CPU also takes up less room than two single-core CPUs, which is an important factor these days with everyone moving to laptops.

> NOTE:
>
> 一、multiple core 相较于 multiple processor的优势:
>
> 1、share L2 cache，more efficient
>
> 2、more cheaper to manufacture
>
> 3、take less room

There may be some performance differences, but nothing you're likely to notice.

[A](https://superuser.com/a/214361)

See this image that shows the difference between **Multi Processor**, **Hyper Threaded** and **Multi Core**:

![enter image description here](https://i.stack.imgur.com/STuQI.png)

> NOTE: 总结地非常好

##  superuser [What is the difference between MultiCore and MultiProcessor?](https://superuser.com/questions/214331/what-is-the-difference-between-multicore-and-multiprocessor)

repository: dengking/Hardware

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: dengking/Hardware


text:
Download stock symbol historical data from yahoo finance in a json format (dictionary) beginners friendly.

When initialize the module it will create the cache folder inside the module if it do not exists.
The cache folder it's use to cache data if that data was fetched on current day, it will make the script run faster since the data is already downloaded.

# Usage

``` python
from ydata import Ydata
# The first parameter is the stock symbol TSLA
yd = Ydata('TSLA')
```

# Get historical data
``` python
historicalResp = yd.historical('2020-01-01','2020-02-01')
print(historicalResp)
```

# Get current price
``` python
price = yd.currentPrice()
print(price)
```

# Get one week data
``` python
data = yd.oneWeek()
print(data)
```

# Get two weeks data
``` python
data = yd.twoWeeks()
print(data)
```

# Get two months data
``` python
data = yd.twoMonths()
print(data)
```

license: MIT

branch_name: refs/heads/main


text:
---
layout: default
---

I am a final year Engg. undergrad at [BITS Pilani Goa](http://universe.bits-pilani.ac.in/Goa/) majoring in Electrical and Electronics Engineering with a slight flavour of Computer Science [[courses](/courses.html)].

My research interests broadly lie in Computer Vision and Computer Graphics. In particular, I have a very keen interest in photo-realistic rendering and GPGPU and generally enjoy anything that exploits GPUs.

I am originally from a [beautiful village](http://en.wikipedia.org/wiki/Kudayathoor) in Kerala but have lived most of my life in the vicinity of a nuclear power plant ([Kaiga](http://en.wikipedia.org/wiki/Kaiga_Atomic_Power_Station)).

Here's a picture with a few friends:

<img style="float: center; width: 720px; " src="/img/self.png">
(Anubhav, Devavrat, Prajwal, me, Arjun, Jatin - 23rd Nov, 2014)

license: Unlicense


text:
# Yelp194

## *Renasha Mishra*

**Yelp194** displays a list of search results from the Yelp API and displays the results in a scrollable list.

Time spent: **4** hours spent in total

## Functionality

The following **required** functionality is completed:

* [x] Ability to query the Yelp API to get results from a search query
* [x] The search results are displayed in a RecyclerView

The following **extensions** are implemented:
* [x] Added Functionality to allow user to search Yelp for custom description and location
* [x] Added Yelp Logo
* [x] Custom Color Pallette

## Video Walkthrough

Here's a walkthrough of implemented user stories:

<img src='Yelp194.gif' title='Video Walkthrough' width='' alt='Video Walkthrough' />

GIF created with [LiceCap](http://www.cockos.com/licecap/).

## Notes

Describe any challenges encountered while building the app.

## License

    Copyright [2020] [Renasha Mishra]

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


text:
#Fbook AutoWish

###Automatically wishes happy birthday to friends.

Yeah - I'm too lazy to remember to visit fbook daily…AND I think wishing old acquaintances happy birthday is a nice thing to do. This takes care of that problem.  Oh yeah, and thanks to @jonallured - I also added a googled birthday image to the fbook message for good measure.

####Setup

  	git clone https://github.com/adennis4/fb-bday.git
	mv non_wish_list.example.yml non_wish_list.yml
	mv config.example.yml config.yml

######config.yml

	email<EMAIL_ADDRESS>	password: YourPassword

######non_wish_list.yml

	- Lionel Messi
	- Xavi
	- Andres Iniesta

####Run

	ruby birthday.rb

####MIT License


text:
## About

gospapy is a Python implementation of the generalized optimal sub-pattern assignment (GOSPA), introduced by [1], also see [2] for a presentation. It is compatible with Python 2.7 and 3.7.

See [abusajana/GOSPA](https://github.com/abusajana/GOSPA) for a Matlab implementation. This implementation has been verified with the example script provided there, see the script in the example folder.

In addition to the GOSPA metric, the method returns the target-to-track assignment and the decomposed cost. See the example folder for usage, and the docstring of the module.

The Euclidian distance is used as a cost function by default, but any function that takes two elements and return an assignment cost can be used. See the example file `custom_class.py` for how to use this with your own classes.

## Installation

Clone the repo, navigate into it and run `pip install -e .`. The `-e`-flag installs this as editable, which is reccomended if you need to modify it.

## Usage
A typical usage is
```Python
import gospapy
gospa, assignment, loc_err, miss_err, false_err = gospapy.calculate_gospa(
    current_targets, current_tracks, cutoff_distance, order)
```

See the examples for more use cases. Most of the code is documented inline.

## References
[1] A. S. Rahmathullah, A. F. Garcia-Fernandez, and L. Svensson. Generalized optimal sub-pattern assignment metric. In 20th International Conference on Information Fusion (FUSION), July 2017. Available online: https://arxiv.org/abs/1601.05585

[2] L. Svensson, Generalized optimal sub-pattern assignment metric (GOSPA), presentation, 2017. Available online: https://youtu.be/M79GTTytvCM

## Contact
Bugs and suggestions can be reported as issues on Github. For code improvements, pull requests are appreciated. For additional contact info, see [ewilthil.github.io](https://ewilthil.github.io).

repository: kombozz/gospapy

repo_name: kombozz/gospapy


text:
## Array Shift

## Check the White board:

[challenge board](https://miro.com/app/board/o9J_lDn-49o=/)

![Miro](/images/codechallenge02.jpg)

![Miro2](lab03b2.jpg)

![test](insertShiftArraytest.png)

### Insert and shift an array in middle index.

### Approach & Efficiency
I took the approach of finding the middle index of the input array, the index to add the value in, and split the input array into two divisions, before the middle index and after the middle index, then declared a new array, pushed the first division, then the input value, then the second division

gha_language: JavaScript

gha_license_id: MIT


text:
# Entoloma majaloides P.D. Orton, 1960 SPECIES

#### Status
ACCEPTED

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

#### Published in
Trans. Br. mycol. Soc. 43: 230 (1960)

#### Original name
Entoloma majaloides P.D. Orton, 1960

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Change Log

This file contains highlights of what changes on each version of the StageXL_Isometric
package. This file is normally updated whenever we push a new version to pub.

#### Pub version 0.1.2
  * Added support for strong mode
  * Raised dependency to Dart SDK 1.22.0 (reason: covariant keyword)


text:
Grove RGB LED Matrix   [![Build Status](https://travis-ci.com/Seeed-Studio/Seeed_RGB_LED_Matrix.svg?branch=master)](https://travis-ci.com/Seeed-Studio/Seeed_RGB_LED_Matrix)
==============

Introduction of LED matrix.
----------------------------
This is the driver for Gvove 8X8 RGB LED matrix.
There are several examples for RGB LED matrix.
Including build-in examples:

    rgb_display_emoji
    rgb_display_animation
    rgb_display_block
    rgb_display_clockwise
    rgb_display_color_bar
    rgb_display_color_wave
    rgb_display_ledbars
    rgb_display_num
    rgb_display_string
    rgb_user_custom

Please refer to APIs of **grove_two_rgb_led_matrix.h** to get more detail.

***
This software is written by downey  for seeed studio

<EMAIL_ADDRESS>and is licensed under [The MIT License](http://opensource.org/licenses/mit-license.php). Check License.txt for more information.

Contributing to this software is warmly welcomed. You can do this basically by

[forking](https://help.github.com/articles/fork-a-repo), committing modifications and then [pulling requests](https://help.github.com/articles/using-pull-requests) (follow the links above

for operating guide). Adding change log and your contact into file header is encouraged.

Thanks for your contribution.

Seeed Studio is an open hardware facilitation company based in Shenzhen, China.

Benefiting from local manufacture power and convenient global logistic system,

we integrate resources to serve new era of innovation. Seeed also works with

global distributors and partners to push open hardware movement.


text:
# linked-list-zip

* Create zipLists method that take arguments 2 linked lists and return into one list so that the nodes alternate between the two lists

## Whiteboard Process

![linked-list-zip](./img/zipLists.PNG)

## Approach & Efficiency

* Create a Node class
* Create a Linked List class that have insert,includes and to string
* Create methods append, insertBefore , insertAfter
* Create methods kth from end
* Create zipLists


text:
# API Example Windows

*其他语言版本： [简体中文](README.zh.md)*

The API Example Windows Sample App is an open-source demo that show common API usage.

This demo is written in **C++**

## Developer Environment Requirements
* VS 2013(or higher), default is vs2017
* Windows 7(or higher)

### Obtain an App ID

To build and run the sample application, get an App ID:
1. Create a developer account at [agora.io](https://dashboard.agora.io/signin/). Once you finish the signup process, you will be redirected to the Dashboard.
2. Navigate in the Dashboard tree on the left to **Projects** > **Project List**.
3. Save the **App ID** from the Dashboard for later use.
4. Generate a temp **Access Token** (valid for 24 hours) from dashboard page with given channel name, save for later use.
5. Define the APP_ID with your App ID.

    ```
    #define APP_ID _T("Your App ID")
    #define APP_TOKEN _T("Your Token")
    ```
6. (Optional)Alternate approach to setup your APPID is to create an AppId.ini file under Debug/Release. Modify the appId value to the App ID you just applied.

    ```
    #[AppID]

    #AppID=xxxxxxxxxxxxxxxxxxx
    ```

### Build the application
**This open source sample project uses the Agora RTC SDK,DirectShow SDK, and MeidaPlayer SDK.**

You can directly run `APIExample/installThirdParty.bat` to automatically environment configuration.Once the configuration is complete, open the project with VS2017, select the x86 version to compile and run.

## Basic Scene

### LiveBroadcasting

* change client role
* support 1v1，1v3, 1v8, 1v15
* join/leave channel
* render local and remote video

## Advanced Scene

### RTMP Streaming

* Add publish stream url after join channel success
* remove publish stream url before leave channel
* show information returned by rtmp streaming callback

### Inject Stream Url

* inject stream url after join channel success
* show information returned by inject status callback
* Receive 666 jonied callback after inject stream url succeed.You can mute video and audio of 666. Also,you can render it.
* remove inject stream url before leave channel

### Video Metadata(Video SEI)

* You need enable video and joinchannel.
* Send video SEI information. The maximum is 1024 byte.
* Receive SEI information and show it.
* Clear SEI information

### Share the screen

* Enter the channel and enumerate all visible Windows
* Select a visible window
* Recording screen
* Stop recording

### Audio Profile

* Set profile
* Set scenario
* Set audio property to channel audio

### Audio Mixing

* Set the audio path
* Set the number of playback times
* Sets whether to play locally only
* Sets whether to replace the microphone audio

### Camera Capture

* Camera capture using DirectShow
* Enumerates all image acquisition devices and types
* Create image acquisition filters
* Start collecting camera data
* SDK acquires camera data
* Stop collecting camera data

### Process Raw Video Data

* Sign up as a video observer
* Process video frames in onCaptureVideoFrame

### Audio Capture

* Audio acquisition using DirectShow
* Enumerates all audio acquisition devices and types
* Create audio capture filters
* Start collecting microphone data
* SDK gets microphone data
* Stop collecting microphone data

### Process Raw Audio Data

* Register Audio Observer
* Process Audio Frames in onRecordAudioFrame

### Custom Encrypt

* Register Packet Observer
* Encrypt the audio stream before sending it in onSendAudioPacket
* Encrypt the video stream before it is sent in the onSendVideoPacket
* Decrypt the audio stream after receiving it in onReceiveAudioPacket
* Decrypt a video stream after receiving it from an onReceiveVideoPacket

## Connect Us

- For potential issues, take a look at our [FAQ](https://docs.agora.io/cn/faq) first
- Dive into [Agora SDK Samples](https://github.com/AgoraIO) to see more tutorials
- Take a look at [Agora Use Case](https://github.com/AgoraIO-usecase) for more complicated real use case
- Repositories managed by developer communities can be found at [Agora Community](https://github.com/AgoraIO-Community)
- You can find full API documentation at [Document Center](https://docs.agora.io/en/)
- If you encounter problems during integration, you can ask question in [Stack Overflow](https://stackoverflow.com/questions/tagged/agora.io)
- You can file bugs about this sample at [issue](https://github.com/AgoraIO/Basic-Video-Broadcasting/issues)

## License

The MIT License (MIT).

repository: AgoraIO/API-Examples

repo_name: AgoraIO/API-Examples


text:
# test-node-ws
Test node and websocket

## Prerequesites
 - node.js
 - yarn or npm

## Install
```
yarn install
```

## Build
```
$ yarn build
yarn build v0.20.3
$ tsc && webpack client.js bundle.js
Hash: 0ac838cd6983d6988c06
Version: webpack 2.2.1
Time: 257ms
    Asset     Size  Chunks             Chunk Names
bundle.js  63.3 kB       0  [emitted]  main
   [0] (webpack)/buildin/global.js 509 bytes {0} [built]
   [1] ./~/mithril/mithril.js 43.6 kB {0} [built]
   [2] ./ws_client.js 1.92 kB {0} [built]
   [3] ./~/process/browser.js 5.3 kB {0} [built]
   [4] ./~/setimmediate/setImmediate.js 6.47 kB {0} [built]
   [5] ./~/timers-browserify/main.js 1.36 kB {0} [built]
   [6] ./client.js 488 bytes {0} [built]
Done in 2.48s.
```

## Running
```
$ yarn start
yarn start v0.20.3
$ node server.js
Listening on: http://localhost:3000
ws_server: listening
```
Accessing http://localhost:3000 on a browser will display
a webpage with `Hello, click to reload` the reload word is
a hyperlink and clicking on it will reload the page.

It also displays two buttons `connect to server` and
`disconnect from server` which connect and disconnect respectively.

The server code outputs logs to the server console and the client
outputs logs to the browser console. For the browser you'll need
to use developement tools to see the output.

## Debugging
On the server use `yarn start:dev` or `yarn start:dbg`. If you
use `start:dbg` the server won't start until you connect the
chrome devTools to the server by using the link displayed on
the terminal.

You can also enable debugging in the client by using the
browser console to set localStorage.debug to `my-client`
and or `my-ws_client`:
```
localStorage.debug='my-client,my-ws_client'
```

repository: winksaville/test-node-ws

repo_name: winksaville/test-node-ws


text:
# SAP Fiori server with demo apps
This module - is a sample implementation of web server for local local development of UI5 fiori components.
You can find more details about express middleware here: https://github.com/ThePlenkov/express-sapui5

As illustration how it works I didn't create any apps here but just reused existing demo apps as git submodules.

One of the key features of this module - is loading all UI5 resources from CDN. This helps to improve significantly page reloading time. All ui5 resources will be cached by the browser except local ones.

## Installation
This project uses git submodules. Please read how to clone properly the project with submodules here:
https://git-scm.com/book/en/v2/Git-Tools-Submodules

As alternative way I recommend you to use Gitkraken (https://www.gitkraken.com/), the best git client which clones properly the whole project with submodules

Finally you just need to run ```npm install``` and then ```node server```.
After this you can navigate to http://localhost:3000/

## Use behind proxy
The following example supports a corporate proxy settings. You can define HTTP_PROXY variable in the .env file with your proxy address.

repository: tmundt/express-fiori-ws

repo_name: tmundt/express-fiori-ws


text:
# Agaricus fissus Leyss., 1783 SPECIES

#### Status
SYNONYM

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

#### Published in
Florae halensis, Edn 2 (1783)

#### Original name
Agaricus fissus Leyss., 1783

### Remarks
null

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Tricholomataceae/Arrhenia/Arrhenia fissa/ Syn. Agaricus fissus/README.md


text:
# phreak

Abstractions for the document.stylesheets APIs

## Installation

Download node at [nodejs.org](http://nodejs.org) and install it, if you haven't already.

```sh
npm install phreak --save
```

## Tests

```sh
npm install
npm test
```

## Dependencies

- [amp-is-undefined](https://github.com/ampersandjs/amp): is-undefined function part of http://amp.ampersandjs.com.
- [bulk-require](https://github.com/substack/bulk-require): require a whole directory of trees in bulk
- [dashify](https://github.com/jonschlinkert/dashify): Convert a camelcase or space-separated string to a dash-separated string.
- [deep-freeze](https://github.com/substack/deep-freeze): recursively Object.freeze() objects and functions
- [document-register-element](https://github.com/WebReflection/document-register-element): A stand-alone working lightweight version of the W3C Custom Elements specification
- [in-range](https://github.com/sindresorhus/in-range): Check if a number is in a specified range
- [keykey](https://github.com/git+https:/): Create a key<->value mirror. Useful for contants. Inspired by keymirror in Flux.
- [pepjs](https://github.com/jquery/PEP): Polyfill of the PointerEvents W3C spec
- [presuf](https://github.com/git+https:/): Transform a collection with a prefix or suffix
- [random-color](https://github.com/azer/random-color): Module to generate random RGB colors
- [react](https://github.com/git+https:/): React is a JavaScript library for building user interfaces.
- [reactive-elements](https://github.com/git+https:/): Allows to use React.js component as custom element

## Dev Dependencies

- [babelify](https://github.com/git+https:/): Babel browserify transform
- [beefy](https://github.com/chrisdickinson/beefy): local development server that aims to make using browserify fast and fun
- [brfs](https://github.com/substack/brfs): browserify fs.readFileSync() static asset inliner
- [browserify](https://github.com/substack/node-browserify): browser-side require() the node way
- [bulkify](https://github.com/substack/bulkify): transform inline bulk-require calls into statically resolvable require maps
- [chai](https://github.com/git+https:/): BDD/TDD assertion library for node.js and the browser. Test framework agnostic.
- [chromedriver](https://github.com/giggio/node-chromedriver): ChromeDriver for Selenium
- [eslint](https://github.com/git+https:/): An AST-based pattern checker for JavaScript.
- [eslint-plugin-react](https://github.com/git+https:/): React specific linting rules for ESLint
- [esprima-fb](https://github.com/facebook/esprima): Facebook-specific fork of the esprima project
- [jscs](https://github.com/git+https:/): JavaScript Code Style
- [jscs-jsdoc](https://github.com/git+https:/): JSCS jsdoc plugin
- [jshint](https://github.com/git+https:/): Static analysis tool for JavaScript
- [jshint-stylish](https://github.com/sindresorhus/jshint-stylish): Stylish reporter for JSHint
- [mocha](https://github.com/mochajs/mocha): simple, flexible, fun test framework
- [nightwatch](https://github.com/nightwatchjs/nightwatch): A node.js bindings implementation for selenium 2.0/webdriver
- [node-static](https://github.com/cloudhead/node-static): simple, compliant file streaming module for node
- [npm-check](https://github.com/git+https:/): Check for outdated, incorrect, and unused dependencies.
- [package-json-to-readme](https://github.com/git+https:/): Generate a README.md from package.json contents
- [rewire](https://github.com/jhnns/rewire): Easy dependency injection for node.js unit testing
- [selenium-server-standalone-jar](https://github.com/adamhooper/selenium-server-standalone-jar): A jarfile, so you don't need to include it in your repository
- [sinon](https://github.com/cjohansen/Sinon.JS): JavaScript test spies, stubs and mocks.
- [sinon-chai](https://github.com/git+https:/): Extends Chai with assertions for the Sinon.JS mocking framework.

## License

ISC

_Generated by [package-json-to-readme](https://github.com/zeke/package-json-to-readme)_

license: ISC

repository: jameswomack/phreak

repo_name: jameswomack/phreak


text:
# Train Composition

- `PYTHON` `ALGORITHMIC THINKING` `DEQUE` `PUBLIC`
- Difficulty: Hard
- Duration: 20min

A TrainComposition is built by attaching and detaching wagons from the left and the right sides, **efficiently** with respect to time used.

For example, if we start by attaching wagon 7 from the left followed by attaching wagon 13, again from the left, we get a composition of two wagons (13 and 7 from left to right). Now the first wagon that can be detached from the right is 7 and the first that can be detached from the left is 13.

Implement a TrainComposition that models this problem.

```python
class TrainComposition:

    def __init__(self):
        pass

    def attach_wagon_from_left(self, wagonId):
        """
        :param wagonId: (int) The number of the wagon to attach to the left
        """
        pass

    def attach_wagon_from_right(self, wagonId):
        """
        :param wagonId: (int) The number of the wagon to attach to the right
        """
        pass

    def detach_wagon_from_left(self):
        """
        :returns: (int) The number of the wagon detached from left
        """
        pass

    def detach_wagon_from_right(self):
        """
        :returns: (int) The number of the wagon detached from right
        """
        pass

if __name__ == "__main__":
    train = TrainComposition()
    train.attach_wagon_from_left(7)
    train.attach_wagon_from_left(13)
    print(train.detach_wagon_from_right()) # should print 7
    print(train.detach_wagon_from_left()) # should print 13
```


text:
---
title: "Does the Kinect Make Microsoft an Arts Benefactor? | Idea Channel | PBS"
date: 2012-07-11 17:30:08 00:00
permalink: /videos/1070
source: "http://www.youtube.com/watch?v=h4VMbeB5Hlk&feature=player_embedded"
featured: false
provider: "YouTube"
thumbnail: "http://i1.ytimg.com/vi/h4VMbeB5Hlk/hqdefault.jpg"
user:
  id: 1030
  username: "trinadafilipina"
  name: "Trina Dikitanan"
tags: ["kinect","arts"]
html: "<iframe width=\"640\" height=\"360\" src=\"http://www.youtube.com/embed/h4VMbeB5Hlk?wmode=transparent&fs=1&feature=oembed\" frameborder=\"0\" allowfullscreen></iframe>"
id: 1070
---

If you haven't had a chance to play with Microsoft's Kinect, you're missing out on some great video games and some amazing art!  Artists of all stripes have embraced the Kinect - using the gesture recognition technology to create some pretty amazing interactive artworks and insanely impressive visuals. These works wouldn't have existed without this amazing piece of technology, making the corporate giant Microsoft the 21st century's incarnation of Lorzeno de Medici.

repository: sawyerh/organizedwonder

extension: markdown

repo_name: sawyerh/organizedwonder


text:
# n8n notes

## API to create items on Directus
`POST /items/:collection`

e.g. to post data to metrics collection
`http://directus:8055/items/metrics`

See http://localhost:8055/admin/docs/reference/api/rest/items#create-an-item

Make sure to add the data received from the previous workflow as request body
with the expression: `{{$json}}`

# Tips and tricks

## Returning hardcoded data from n8n expression
```
return [ { json: { name: "teste", value: 42 }}];
```

## Debugging HTTP calls
use `https://webhook.site/` as target of calls to check the data

## Sample data
Use `https://jsonplaceholder.typicode.com/posts?userId=1` to get a list of post from userId 1

repository: hamilton-lima/geoffrey

repo_name: hamilton-lima/geoffrey


text:
# push_targit
Example http post endpoint with tgz extractor and shell escape

First, compile the golang code then run the binary:
```
push_targit$ make && ./post-targit
```

# Testing
Upload the file
```
push_targit$ curl --data-binary<EMAIL_ADDRESS>http://localhost:8080/
```
Verify that the tar-gzip'ed file has been uploaded and extracted properly:
```
push_targit$ find /dev/shm
/dev/shm/
/dev/shm/curl/
/dev/shm/curl/testfile
push_targit$ cat /dev/shm/curl/testfile
This is a test

```

An idea is to do something along the lines of a sparse checkout in the working folder
and then make the branch the actual system name that is being backed up...
```
git init <repo>
cd <repo>
git remote add origin <url>
git config core.sparsecheckout true
git pull --depth=1 origin master
```

From the server side you'd see:
```
push_targit$ ./post-targit
Starting server for HTTP POST of a tar to send to git (aka: tar'git)...
2020/12/22 21:00:46 Extracting file: testfile
2020/12/22 21:00:46 Git version git version <IP_ADDRESS>

```

repository: pschou/push-targit

repo_name: pschou/push-targit


text:
# TinyTrainable

## About

TinyTrainable is an Arduino library, part of the project Tiny Trainable Instruments [https://github.com/montoyamoraga/tiny-trainable-instruments](https://github.com/montoyamoraga/tiny-trainable-instruments), created by Aarón Montoya-Moraga.

This library is being written between December 2020 and August 2021, with help from undergrad researcher Peter Tone and Maxwell Wang.

## Dependencies

The dependencies of this library are specified on the [library.properties](library.properties) file and included as Git submodules on libraries/.

* [Adafruit_Thermal](https://github.com/adafruit/Adafruit-Thermal-Printer-Library): for outputs with Adafruit Thermal Printer.
* [Arduino_APDS9960](https://github.com/arduino-libraries/Arduino_APDS9960): APDS9960 sensor, to read gestures, color, proximity.
* [Arduino_KNN](https://github.com/arduino-libraries/Arduino_KNN): for machine learning with K-Nearest Neighbors algorithm.
* [Arduino_LSM9DS1](https://github.com/arduino-libraries/Arduino_LSM9DS1): LSM9DS1 IMU sensor, to read accelerometer, magnetometer, gyroscope.
* [Arduino_TensorFlowLite](https://www.arduino.cc/reference/en/libraries/arduino_tensorflowlite/): for machine learning with TensorFlow.
* [Servo](https://github.com/arduino-libraries/Servo): for outputs with servo motors.

## Documentation

The documentation is available on the website [https://montoyamoraga.github.io/TinyTrainable](https://montoyamoraga.github.io/TinyTrainable).

## License

MIT

repository: maxzwang/TinyTrainable

gha_language: C

repo_name: maxzwang/TinyTrainable


text:
# DELIFOODS RECIPES.

#### This is a web-app that allows users to search and find various food recpes as listed on the Food recipe API used.This web page was created on 10/03/2021.

#### By Brian Maina, Noel Injaga, Kevin Bett, Frank Ndung'u, Derick Sikona

## Description

The page is a directory page with directores on how to make various meals.A user can access a list of recipes with ingreadients needed and relevant steps listed in a calculated way to ensure mouth watering dishes.

## Setup/Installation Requirements

- Open terminal.
- Access the github repository for this project and clone/fork at "https://github.com/bryanares/delifood-recipes/tree/alpha"
- On search tab, enter your meal of innterest and the web will populate the relevant instructions.
-

## Known Bugs

- Internet Errors.
- Errors upon wrong url copy pasting.
- Type errors upon searching the meals -please use commmon names.
- The API is limited to only a few recipes.

## Technologies Used

- HTML5
- CSS
- Bootstrap
- Javascript
- Jquerry
- API(TheMealDB)

## Support and contact details

Please in case of technical hickups or contribution requests do not hesitate to reach us on<EMAIL_ADDRESS><EMAIL_ADDRESS>
### License

MIT License
Copyright (c) {2021} **{Brian Maina, Noel Injaga, Kevin Bett, Frank Ndung'u, Derick Sikona}**


text:
# Json Ignore for certain fields in pojo class using retrofit (Annotation style: GSON)

Sometimes we might add some extra field in our pojo class for doing certain local operations in app (like having a boolean value and so on), also we might use the same pojo as post params in retrofit calls.

#### In the below example

```
public class UserDetailsParams {

    @SerializedName("name")
    private String name;

    @SerializedName("email")
    private String email;

    @SerializedName("mobile")
    private String mobile;

    @SerializedName("location")
    private String location;

    private boolean isLoggedIn;
}
```

In the above class name, email, mobile, and location are the fields which I want to send server in RestApi. If I am using this in body params one more additional field will be added in body params as ```"isLoggedIn":false``` which I dont want to send. At the same time this class has to be Parcelable.

### To overcome this kind of problem, I found a solution of creating a custom annotation below, which is not available in Gson parsing by default, but exists in Jackson.

```@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface JsonIgnore {
}
```
* Added an interface JsonIgnore, this can used an annotation ```@JsonIgnore```
* And in retrofit object we can override ExclusionStrategy for skipping as below.

```
retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(new GsonBuilder()
                            .addSerializationExclusionStrategy(new ExclusionStrategy() {
                                @Override
                                public boolean shouldSkipField(FieldAttributes field) {
                                    return field.getAnnotation(JsonIgnore.class) != null;
                                }

                                @Override
                                public boolean shouldSkipClass(Class<?> clazz) {
                                    return false;
                                }
                            })
                            .setPrettyPrinting()
                            .setLenient()
                            .create()))
                    .client(client)
                    .build();
```

* So the pojo class with json ignore will be looks like below
```
public class UserDetailsParams {

    @SerializedName("name")
    private String name;

    @SerializedName("email")
    private String email;

    @SerializedName("mobile")
    private String mobile;

    @SerializedName("location")
    private String location;

    @JsonIgnore
    private boolean isLoggedIn;
}
```


text:
---
id: version-1.3.X-upgrade_intro
title: Orchestrator Upgrades: Introduction
hide_title: true
original_id: upgrade_intro
---

# Orchestrator Upgrades: Introduction

Orchestrator upgrades generally follow a standard pattern:

- Upgrade deployment tooling (e.g. Terraform, Helm, etc.)
- Build and publish new application artifacts
- Publish new Helm charts
- Deploy new application artifacts
- Run data migrations and other post-upgrade steps

Every new minor and major release (i.e. non-hotfix) will have a corresponding
documentation section on upgrading from the prior release. Upgrade procedures
are only documented for adjacent releases. Upgrades which skip versions
(e.g. v1.1 to v1.3) are not explicitly supported at this time.

Before every upgrade, we strongly suggest taking a DB snapshot in case you
decide that you need to roll back your application. While the application
components are stateless and can be upgraded or downgraded at any time, the
data migrations that come with each release are not always reversible.

repository: magma/magma

gha_license_id: NOASSERTION

repo_name: magma/magma


text:
---
layout: default
---

# 1997-07-08 - Re: ISP signatures on outgoing mail

## Header Data

From: Firebeard<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 8ed79ea3a1faced5fe2a5df4865520a9f65b9c9812feb1c915597813563d9028

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-07-08 05:27:52 UTC

Raw Date: Tue, 8 Jul 1997 13:27:52 +0800

## Raw message

```
{% raw  %}From: Firebeard<EMAIL_ADDRESS>Date: Tue, 8 Jul 1997 13:27:52 +0800
To<EMAIL_ADDRESS>Subject: Re: ISP signatures on outgoing mail
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

>>>>> Bill Stewart writes:

BS> At 06:14 PM 7/3/97 +0200, Anonymous wrote:
>> Anyone heard of a proposal for ISPs to automatically sign outgoing
>> mail headers?  Problem has been that spammers send email by one
>> path but forge a reply-to or from address at another location.

BS> Flat-out can't work.  The problem is that you can send SMTP
BS> directly from your machine to its destination, so the ISP only
BS> routes the IP packets and doesn't read them.

	But it could - it's simple firewall technology.  There's no MX
record for sten.tivoli.com, but any incoming email to me is
intercepted by proxy.tivoli.com, as is all other incoming traffic to
the internal tivoli.com network on port 25.  Since 'incoming' is only
a matter of definition, it would be trivial for an ISP to set up a
firewall that passed all other ports through transparently, but
redirected connections with a destination of port 25 to their own SMTP
server.

	I don't want them to, and I _certainly_ don't want the
government goons requiring ISPs to do this, but don't sit back and
relax with the notion that 'it can't be done'.

- --
#include <disclaimer.h>                               /* Sten Drescher */
Unsolicited bulk email will be stored and handled for a US$500/KB fee.
It is by caffeine alone I set my mind in motion, it is by the beans of
Java that thoughts acquire speed, the hands acquire shaking, the
shaking becomes a warning, it is by caffeine alone I set my mind in
motion. -- Carlos Nunes-Ueno, 3/29/95

-----BEGIN PGP SIGNATURE-----
Version: 2.6.2
Comment: Processed by Mailcrypt 3.4, an Emacs/PGP interface

iQBVAwUBM8HOXPCBWKvC9LiRAQH9UgH9FfIuo+i1ms0DRI/dZC9goTlULgY+HnnR
oxeAFmvAvLNBxjXGVZhQinZJs7yTob7x1ZGPIDZzaGV9FXwauBIdRA==
=lZvI
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [July 1997](/archive/1997/07)

+ Return to "[Bill Stewart <stewarts@ix.netcom.com>](/authors/bill_stewart_stewarts_at_ix_netcom_com_)"
+ Return to "["David E. Smith" <dave@bureau42.ml.org>](/authors/david_e_smith_dave_at_bureau42_ml_org_)"
+ Return to "[Firebeard <stend+cypherpunks@sten.tivoli.com>](/authors/firebeard_stendcypherpunks_at_sten_tivoli_com_)"
+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_replay_com_anonymous_)"

+ 1997-07-03 (Fri, 4 Jul 1997 00:41:34 +0800) - [ISP signatures on outgoing mail](/archive/1997/07/b2fc2d079ae2458d56e2d528e9bdc3543c4b81cddcc75ddfec51b25b36e6e62b) -<EMAIL_ADDRESS>(Anonymous)_
  + 1997-07-04 (Sat, 5 Jul 1997 01:49:15 +0800) - [Re: ISP signatures on outgoing mail](/archive/1997/07/5b3e468ce07736b430165845811ca1455a373b3d89794660a6cb00e749c00b84) - _Bill Stewart<EMAIL_ADDRESS>    + 1997-07-08 (Tue, 8 Jul 1997 13:27:52 +0800) - Re: ISP signatures on outgoing mail - _Firebeard<EMAIL_ADDRESS>      + 1997-07-08 (Tue, 8 Jul 1997 16:07:34 +0800) - [Re: ISP signatures on outgoing mail](/archive/1997/07/f70d85a389e7934171e2388b5ba5e989176eca004443bdcee151fe5564d5ed50) - _"David E. Smith"<EMAIL_ADDRESS>


text:
# Apostille documentation.

Diagram 1: The basic transaction flow for an Apostille transaction

![Apostille 2 0 presenation Tx Flow](https://user-images.githubusercontent.com/88449840/128221403-b7a93346-92db-45a7-b19f-7492cfebd286.png)

## How to derive a directory account (Steps 1-3)

Uploading a file to IPFS and then using it create a dedicated Symbol address to query more information about that file creates what we call in the Apostille systeam a "Directory Account". Let's review the process how to create a file and link it to a Directory Account.

Let’s first make a text file. This will be a file that has an ending `.txt`. In this case, we will write a simple message of the following:

`Hello Apostille. Test2.`

It is important to include the same capitalization and grammar. If the message is changed by a single space or period that is different, it can result in a completely different hash as a result. Hashing this text with sha256 creates the following hash:

`8BD07920FD4921384B1417B35418D098CFC17BE487DFA2F3909CCB436F074166`

This easily verified on a home computer hashing app, command line, or various free online sites like [coding tools](https://coding.tools/sha256).

This hash is then used to create an [IPFS](https://ipfs.io/) address via the normal [IPFS cryptographic processes](https://docs.ipfs.io/concepts/content-addressing/#cid-conversion) resulting IPFS hash in the following hash:

`QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr`

One can alternately sign up for a free IPFS account with a service like [Pinata](https://www.pinata.cloud/) and by dragging and dropping a file, the hash will be created automatically and the [file](https://gateway.pinata.cloud/ipfs/QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr) hosted on IPFS.

Next we take the IPFS hash of `QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr` and hash it again with sha256. This gives us a new hash of

`F528456FD0C857BC4A1B4E997D3FA741587E9711093D754E1B3B92C3603B2EF7`

This hash is used as a private key on the Symbol testnet network.  The subsequent address is

`TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY`

This can be verified by downloading a [Symbol Wallet](https://github.com/symbol/desktop-wallet/releases) and importing this private key for an account on the testnet or can be viewed on the [testnet explorer](http://explorer.testnet.symboldev.network/accounts/TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY).

The power of this method is quite interesting. We have now created a [file](https://gateway.pinata.cloud/ipfs/QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr) and then using cryptography were able to assign a deterministic address [TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY](http://explorer.testnet.symboldev.network/accounts/TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY) on the Symbol testnet blockchain that represents the starting place for users looking for more information related to that file.

Next up for the Directory Account, the address`TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY`, will be given basic metadata via a json in a metadata tx that follows the W3C guidelines for [Decentralized Identity](https://www.w3.org/TR/did-core/) or DID. As a part of this, it will also be put under a multisig contract with the Apostille account as its 1-of-1 owner, but that is step 5 and before that can be done, the Apostille account must be derived and created. So we will cover deriving the Apostille account first.

## How to derive an Apostille account (Step 4)

WHile the cryptographical DNA of a Directory Account is derived entirely from an original file, an Apostille account's crytpographical origins come from both the file and the initiator's private key. This is to mean that the Apostille account could have only been created by a user that had access to both the file and the private key of the initiator which is clearly demonstrating authorship.

This is done via a complicated crytpographical process where the hash of the file is signed by the initiator and then converted into a private key.

In the following case, the account initiating the transaction to create an Apostille account is the address of

`TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y`

with the public key of

`AA5D5439522E666085B720D58E60649124790603AC4C0EB292A116643D593A82`

which can be viewed on the exlorer [here](http://explorer.testnet.symboldev.network/accounts/TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y).

The code can be reviewed in Github for more details. But includes the following which can be calculated in a Google Chrome Development tool.

First do
var privateKey = CryptoJS.SHA256(ipfs).toString(CryptoJS.enc.Hex)
After that, you truncate that string to get 32 bytes private key
("0000000000000000000000000000000000000000000000000000000000000000" + privateKey.replace(/^00/, '')).slice(-64);

Applying th above cryptography, we have derived the following address which is the Apostille account!

`TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY`

Which can be viewed on the explorer [here](http://explorer.testnet.symboldev.network/accounts/TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY)

Now that the Apostille account has been derived, it can be designated as the controller of the Directory Account with a 1-of-1 multisig contract which will be discussed next.

## Attaching metadata and multisigging the Directory account (Step 5)

For the metadata formatting, we follow the W3C guidelines for [Decentralized Identity](https://www.w3.org/TR/did-core/) (DID). We will use the following format:

{
"Id": "did:apost:Directory_Account/dir/Apostille_Account”,
"Controller": "did:apost:Multisig_Owner",
}

This results in the following example for this Directory Account.

{
"Id": "did:apost:TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY/dir/TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY”,
"Controller": "did:apost:TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y",
}

Lets take a looks at the first line

`"Id": "did:apost:TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY/dir/TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY”`

The `Id` explains this is the identification.

The `did` explains we are applying a decentralized ID for the ID.

The `apost` explains we are following the guidelines laid out in version 2.0.1 of Apostille being explained in this document.

The `TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY` is indicating this is the DID ID for the account TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY

The `dir` expains that this account is a Directory Account.

The `TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY` explains where that this directory account (TBVH5MAU63DM3534QI6JDVSVXN3RB4SDCXJLREY) directs to TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY which is the Apostille account.

Next, let's review the second line:

`"Controller": "did:apost:TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y",`

The `Controller` let's us know who the controller/operator of this account should be.

The `did` and `apost` are the same as above indicating we use the "apost" methond (short for Apostille) for interpreting how to read and processes DIDs.

The `TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y` let's us know that this address should be the controller and operator of the directory account.

To enforce our controller claim made in the DID metadata above, we will need to bind this Directory Account in a 1-of-1 multisig account. Normally that would mean just applying the contract to Alice's account, but in this case we will have a small work around of actually applying it to the Apostille account address we derived in step 4. The benefits of this will be made clear and explained later.

Using the Symbol network [Typescript SDK](https://github.com/symbol/sdk-typescript), the metadata and multisig edit transactions can be applied in an aggregate transaction. Once can alternately use the [Symbol-CLI](https://github.com/symbol/symbol-cli) wallet if they are performing this manually. Using the Symbol desktop wallet to add metadata at this time will not make a metadata entry that is compatible with the explorer.

## Attaching metadata and multisigging the Apostille account (Step 6)

Much like what was done with the Directory Account above, we will follow the same process. The differences will be the content of the metadata transaction and the controller/operator of the multisig contract.

The new metadata JSON looks like the following:

{
"id": "did:apost:Apostille_account/nfa/IPFS_hash",
“file_name”: ”example.txt”,
“Sha256”: ”sha hash of the file”,
"file_size": "xx bytes",
"controller": "did:apost:Multisig_Owner",
}

In our example, it is the following:

{
"id": "did:apost:TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY/nfa/QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr",
“file_name”: ”hello apostille test2.txt”,
“Sha256”: ”8BD07920FD4921384B1417B35418D098CFC17BE487DFA2F3909CCB436F074166”,
"file_size": "23 bytes",
"controller": "did:apost:TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y",
}

The first 3 parts of the the first line folllow the same convention explained above but the last 2 parts of `"id": "did:apost:TCDSPTLZL6OUSPJUIMDDMH4EW5KIFFIOXOMOZCY/nfa/QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr"` need an introduction. "id" means this is an ID. "did" means this is the type of id. And "post" is the methody for decoding and encoding the "did".

The `nfa` explains that this is the apostille account; a non-fungible asset.

The `QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr` is the IPFS hash we derived in step 2, and strung together with a "nfa" proclaim that this Apostille account is the Non-fungible asset on the blockchain representing the file hosted at QmU3p5a8evEFLuSXM1Ls112aWrEgMXE3BvGSs5obTGsFPr.

The `file_name` represents the file name we saved our file as.

The `sha256` indicates the file hash we derived in step 2.

Once again `controller` explains who the owner/operator of this NFT is supposed to be.

`TALXYP6W5VKJXOCNBJTNJ3EY4IP2BHMI5WHW55Y` is the controller's address.

Once again to enforce the DID claim about the controller of this asset, the account is put in a 1-of-1 multisig contract enforcing which user can control/update/transfer/sign for this asset interally within the Symbol public ledger and network.

Once again, utilizing Symbol's aggregate transaction feature, the mutlisig edit transaction and metadata update transaction can be done at one time. In fact, all the transactions for both the directory account and the Apostille account can be done at the same time in one aggregate transaction that has collected Alice's signature, the Directory Account signature, and the Apostille Account signature.

Since the Apostille account is also the 1-of-1 signer of the Directory account, operator rights and priveledges trickle up to Alice.

## Conclusion

In this system that utilizing IPFS, deterministic hashes, multisignature contracts, metadata transactions, DID as a JSON, and more, we have been able to create a unique and power holistic notarization system on the Symbol blockchain.

repository: apostille-blockchain/hello-apostille

repo_name: apostille-blockchain/hello-apostille


text:
# Revature-project-0

## TO-DO-LIST

Instructions

### Download python from https://www.python.org/downloads/

### Download MongoDB from https://www.mongodb.com/download-center#community

### Install Flask & pymongo

  pip install Flask

  pip install pymongo

Before running the mongodb instance, we must create a data folder and run below command in command prompt.

"C:\Program Files\MongoDB\Server\4.0\bin\mongod.exe" --dbpath="C:\mongo-data"

Here C:\mongo-data folder is used for saving mongodb files.

By default, it is listening the port 27017.

Run app.py in Command prompt.

python app.py


text:
# Continuous Integration / Delivery

#### Branches

- `master` branch contains the latest changes. All PRs usually need to be sent to master.
- `stable` branch contains latest releases (https://github.com/hyperledger/indy-node/releases). Hotfixes need to be sent to both stable and master.
- `release-*` branches hold release candidates during release workflow
- `hotfix-*` branches hold release candidates during hotfix workflow

#### Pull Requests

- Each PR needs to be reviewed.
- PR can be merged only after all tests pass and code is reviewed.

## Continuous Integration

- for each PR we execute:
    - static code validation
    - Unit/Integration tests
- We use pipeline in code approach and Jenkins as our main CI/CD server.
- CI part of the pipeline (running tests for each PR) is defined in `Jenkinsfile.ci` file.
- CI part is run on Hyperledger and Sovrin Foundation Jenkins servers, so they are public and open as every contributor needs to see results of the tests run for his or her PR.

#### Static Code Validation

- We use flake8 for static code validation.
- It's run against every PR. PR fails if there are some static code validation errors.
- Not all checks are enabled (have a look at `.flake8` file at the project root)
- You can run static code validation locally:
    - Install flake8: `pip install flake8`
    - Run validation on the root folder of the project: `flake8 .`

## Continuous Delivery

- CD part of the pipeline is defined in `Jenkinsfile.cd` file.
- CD part is run on Sovrin Foundation Jenkins server dealing with issuing and uploading new builds.

#### Builds

What artifacts are produced after each push
- to `master` branch:
    - all artifacts include developmental release segment `devN` in their version
    - indy-plenum:
        - indy-plenum in [pypi](https://pypi.python.org/pypi/indy-plenum)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial master-latest`](https://repo.sovrin.org/lib/apt/xenial/master-latest/)
    - indy-node:
        - indy-node in [pypi](https://pypi.python.org/pypi/indy-node)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial master-latest`](https://repo.sovrin.org/lib/apt/xenial/master-latest/)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial master`](https://repo.sovrin.org/lib/apt/xenial/master/) (copied from `master-latest`)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial master`](https://repo.sovrin.org/lib/apt/xenial/master/) (copied from `master-latest`)
- to `release-*` and `hotfix-*` branches:
    - all artifacts include pre-release segment `rcN` in their version
    - indy-plenum:
        - indy-plenum in [pypi](https://pypi.python.org/pypi/indy-plenum)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial rc-latest`](https://repo.sovrin.org/lib/apt/xenial/rc-latest/)
    - indy-node:
        - indy-node in [pypi](https://pypi.python.org/pypi/indy-node)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial rc-latest`](https://repo.sovrin.org/lib/apt/xenial/rc-latest/)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial rc`](https://repo.sovrin.org/lib/apt/xenial/rc/) (copied from `rc-latest`)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial rc`](https://repo.sovrin.org/lib/apt/xenial/rc/) (copied from `rc-latest`)
- to `stable` branch:
    - indy-plenum:
        - indy-plenum in [pypi](https://pypi.python.org/pypi/indy-plenum)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial stable-latest`](https://repo.sovrin.org/lib/apt/xenial/stable-latest/)
        - indy-plenum release tag (https://github.com/hyperledger/indy-plenum/releases)
    - indy-node:
        - indy-node in [pypi](https://pypi.python.org/pypi/indy-node)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial stable-latest`](https://repo.sovrin.org/lib/apt/xenial/stable-latest/) (re-packed from `rc-latest`)
        - indy-node deb package in [`https://repo.sovrin.org/deb xenial stable`](https://repo.sovrin.org/lib/apt/xenial/stable/) (copied from `rc-latest`)
        - indy-plenum deb package in [`https://repo.sovrin.org/deb xenial stable`](https://repo.sovrin.org/lib/apt/xenial/stable/) (copied from `stable-latest`)
        - indy-node release tag (https://github.com/hyperledger/indy-node/releases)

Use cases for artifacts
- PyPI artifacts can be used for development experiments, but not intended to be used for production.
- Using deb packages is recommended way to be used for a test/production pool on Ubuntu.
    - indy-node deb package from [`https://repo.sovrin.org/deb xenial stable`](https://repo.sovrin.org/lib/apt/xenial/stable/)
    is one and the only official stable release that can be used for production (stable version).
    - indy-node deb package from [`https://repo.sovrin.org/deb xenial master`](https://repo.sovrin.org/lib/apt/xenial/master/)
    contains the latest changes (from master branch). It's not guaranteed that that this code is stable enough.

#### Packaging

##### Supported platforms and OSes

- Ubuntu 16.04 on x86_64

##### Build scripts

We use [fpm](https://github.com/jordansissel/fpm) for packaging python code into deb packages. Build scripts are placed in `build-scripts` folders:
- https://github.com/hyperledger/indy-node/blob/master/build-scripts
- https://github.com/hyperledger/indy-plenum/blob/master/build-scripts

We also pack some 3rd parties dependencies which are not presented in canonical ubuntu repositories:
- https://github.com/hyperledger/indy-node/blob/master/build-scripts/ubuntu-1604/build-3rd-parties.sh
- https://github.com/hyperledger/indy-plenum/blob/master/build-scripts/ubuntu-1604/build-3rd-parties.sh

Each `build-scripts` folder includes `Readme.md`. Please check them for more details.

#### Versioning

- Please note, that we are using versioning that satisfies [PEP 440](https://www.python.org/dev/peps/pep-0440) with release segment as `MAJOR.MINOR.PATCH` that satisfies [SemVer](https://semver.org/) as well.
- Version is set in the code (see [\_\_version\_\_.json](https://github.com/hyperledger/indy-node/blob/master/indy_node/__version__.json)).
- Version is bumped for new releases / hotfixes either manually or using [bump_version.sh](https://github.com/hyperledger/indy-node/blob/master/indy_node/bump_version.sh) script. The latter is preferred.
- During development phase version includes developmental segment `devN`, where `N` is set for CD pipeline artifacts as incremented build number of build server jobs. In the source code it is just equal to `0` always.
- During release preparation phase (release / hotfix workflows) version includes pre-release segment `rcN`, where `N>=1` and set in the source code by developers.
- Each dependency (including indy-plenum) has a strict version (see [setup.py](https://github.com/hyperledger/indy-node/blob/master/setup.py))
- If you install indy-node (either from pypi, or from deb package), the specified in setup.py version of indy-plenum is installed.
- Master and Stable share the same versioning scheme.
- Differences in master and stable code:
    - `setup.py`: different versions of indy-plenum dependency
    - different versions in migrations scripts

##### For releases `< 1.7.0` (deprecated)
- Please note, that we are using semver-like approach for versioning (major, minor, build) for each of the components.
- Major and minor parts are set in the code (see [\_\_metadata\_\_.py](https://github.com/hyperledger/indy-node/blob/master/indy_node/__metadata__.py)). They must be incremented for new releases manually from code if needed.
- Build part is incremented with each build on Jenkins (so it always increases, but may be not sequentially)
- Each dependency (including indy-plenum) has a strict version (see [setup.py](https://github.com/hyperledger/indy-node/blob/master/setup.py))
- If you install indy-node (either from pypi, or from deb package), the specified in setup.py version of indy-plenum is installed.
- Master and Stable builds usually have different versions.
- Differences in master and stable code:
    - `setup.py`:
        - dev suffix in project names and indy-plenum dependency in master; no suffixes in stable
        - different versions of indy-plenum dependency
    - different versions in migrations scripts

## Release workflow

### Feature Release

#### 1. Release Candidate Preparation

1. [**Maintainer**]
    - Create `release-X.Y.Z` branch from `stable` (during the first RC preparation only).
2. [**Contributor**]
    - Create `rc-X.Y.Z.rcN` branch from `release-X.Y.Z` (`N` starts from `1` and is incremented for each new RC).
    - Apply necessary changes from `master` (either `merge` or `cherry-pick`).
    - (_optional_) [`indy-node`] Set **stable** (just X.Y.Z) `indy-plenum` version in `setup.py`.
    - Set the package version `./bump_version.sh X.Y.Z.rcN`.
    - Commit, push and create a PR to `release-X.Y.Z`.
3. Until PR is merged:
    1. [**build server**]
        - Run CI for the PR and notifies GitHub.
    2. [**Maintainer**]
        - Review the PR.
        - Either ask for changes or merge.
    3. [**Contributor**]
        - (_optional_) Update the PR if either CI failed or reviewer asked for changes.
        - (_optional_) [**indy-node**] Bump `indy-plenum` version in `setup.py` if changes require new `indy-plenum` release.

#### 2. Release Candidate Acceptance

**Note** If any of the following steps fails new release candidate should be prepared.

1. [**Maintainer**]
    - **Start release candidate pipeline manually**.
2. [**build server**]
    - Checkout the repository.
    - Publish to PyPI as `X.Y.Z.rcN`.
    - Bump version locally to `X.Y.Z`, commit and push as the `release commit` to remote.
    - Build debian packages:
        - for the project: source code version would be `X.Y.Z`, debian package version `X.Y.Z~rcN`;
        - for the 3rd party dependencies missed in the official debian repositories.
    - Publish the packages to `rc-latest` debian channel.
    - [`indy-node`] Copy the package along with its dependencies (including `indy-plenum`)
      from `rc-latest` to `rc` channel.
    - [`indy-node`] Run system tests for the `rc` channel.
    - Create **release PR** from `release-X.Y.Z` (that points to `release commit`) branch to `stable`.
    - Notify maintainers.
    - Wait for an approval to proceed. **It shouldn't be provided until `release PR` passes all necessary checks** (e.g. DCO, CI testing, maintainers reviews etc.).
3. [**build server**]
    - Run CI for the PR and notify GitHub.
4. [**QA**]
    - (_optional_) Perform additional testing.
5. [**Maintainer**]
    - Review the PR but **do not merge it**.
    - If approved: let build server to proceed.
    - Otherwise: stop the pipeline.
6. [**build server**]
    - If approved:
        - perform fast-forward merge;
        - create and push tag `vX.Y.Z`;
        - Notify maintainers.
    - Otherwise rollback `release commit` by moving `release-X.Y.Z` to its parent.

#### 3. Publishing

1. [**build server**] triggered once the `release PR` is merged
    - Publish to PyPI as `X.Y.Z`.
    - Download and re-pack debian package `X.Y.Z~rcN` (from `rc-latest` channel) to `X.Y.Z` changing only the package name.
    - Publish the package to `rc-latest` debian channel.
    - Copy the package along with its dependencies from `rc-latest` to `stable-latest` channel.
    - [`indy-node`] Copy the package along with its dependencies (including `indy-plenum`) from `stable-latest` to `stable` channel.
    - [`indy-node`] Run system tests for the `stable` channel.
    - Notify maintainers.

#### 4. New Development Cycle Start

1. [**Contributor**]:
    - Create PR to `master` with version bump to `X'.Y'.Z'.dev0`, where `X'.Y'.Z'` is next target release version. Usually it increments one of `X`, `Y` or `Z` and resets lower parts (check [SemVer](https://semver.org/) for more details), e.g.:
        - `X.Y.Z+1` - bugfix release
        - `X.Y+1.0` - feature release, backwards compatible API additions/changes
        - `X+1.0.0` - major release, backwards incompatible API changes

### Hotfix Release

Hotfix release is quite similar except the following difference:
  - hotfix branches named `hotfix-X.Y.Z`;
  - `master` usually is not merged since hotfixes (as a rule) should include only fixes for stable code.

gha_language: Python


text:
Implement a MapSum class with `insert`, and `sum` methods.

For the method `insert`, you'll be given a pair of (string, integer). The string represents the key and the integer represents the value. If the key already existed, then the original key-value pair will be overridden to the new one.

For the method `sum`, you'll be given a string representing the prefix, and you need to return the sum of all the pairs' value whose key starts with the prefix.

**Example 1:**
```
Input: insert("apple", 3), Output: Null
Input: sum("ap"), Output: 3
Input: insert("app", 2), Output: Null
Input: sum("ap"), Output: 5
```

### [Editorial](https://leetcode.com/articles/map-sum/)

repository: liupangzi/codekata

repo_name: liupangzi/codekata


text:
---
id: 20170609
title: A Path to Build an Open-Source Software - Part 1
layout: article.jade
date: 2017-06-09
author: Charles-Henri Decultot
logo: ../../../images/CH-round.png
preview: Overview of the choices we made for the creation of Maia
image: ../../../images/heroImages/20170609-opensourceprojectpart1.jpg
---
Almost one year that we work daily with ERPNext at Dokos. The various adaptations we have made for our clients or for us have given us an excellent knowledge of Frappé, the framework on which ERPNext is built.

So, when we started to think about developing a software specific to midwifes, we didn't ask ourselves long before choosing the technology to adopt, but had more trouble with the choice of architecture.

We had several options :

**Develop a proprietary application ?**
Of course we could have, but it would have been in contradiction with our philosophy and our way to work with our clients. We really think that our difference is based on the quality of services we provide and we couldn't consider having a different approach with midwifes.

**Create an open-source application with another technology ?**
It was an option, but we would have needed to reinvent the wheel. The knowledge developed around ERPNext allows us to propose the best of ERPNext by adapting it specifically to the needs of independent midwifes. Using another technology would have implied to re-develop the billing and accounting parts with almost no added value.

**Merge Maia with ERPNext ?**
That is the big question ! Why not merge all of our developments in the source code of ERPNext and benefit from the support of the community to maintain it ? We do it regularly for our clients and encourage them strongly in that way, so why not follow our own advices ?

As you now know, we have made the choice to keep Maia in an application separated from ERPNext. It is a choice that leads to its share of difficulties because we need to maintain this application with a lot of technical constraints and make sure that it does not break with every update.
However we made this choice for several reasons:

 *A question of governance and control over the project*

In the scope of a classic deployment, our clients often ask us to modify existing modules, sometimes to create specific modules. Usually these modifications are not specific to one particular profession and can be reused by other companies in the world.
Only changes that are too specific and/or in contradiction with how ERPNext currently works are not integrated in the source code.

For Maia, we are in a situation where changes brought to ERPNext are specific only to France and to a very specific activity. To merge them into ERPNext would have required a lot of time and compromises - fully understandable by the way - to make this module more universal than it currently is.

By keeping the application separated from ERPNext, we are in control of our developments, we can send corrections in production faster and can continue to push the application forward by focusing only the needs of french midwifes (for now 😉).

 *The creation of a specific brand*

The creation of an application separated from ERPNext has allowed us to create a distinct brand that has vocation to serve as a reference for midwifes.

It will surely be subject to discussions, but I am personally convinced that using ERPNext brand would have been more difficult in a market as small as the midwife's where several brands are already well established. The notion of ERPNext does not belong in such a context and it was very important to differentiate Maia from it, especially since Maia only displays a few watered-down features of ERPNext.

The true difficulty consists indeed in simplifying to maximum the software to simplify the life of midwifes and, in that regard, ERPNext was way too complex.

 *The ongoing development of a medical module integrated to ERPNext*

During the development phase of Maia, we discovered that a team based in Kerala had developed a medical module and the merge operations had already started.
This module has a huge potential for medical centers and more important health care structures, but it was not adapted to an independent midfiwe activity.
We would have needed to completely change our delivery planning had we considered a merge with this medical module, with a least a few months delay.

We want in no way take any credit for the work done by the Frappé Team and the ERPNext community and try to mention the presence of ERPNext behind Maia as much as we can. It is common intellectual honesty. However a certain number of elements, technical and commercial, have lead us to create an application separated from ERPNext despite the evident integrations between the two software.

If the occasion present itself, we will surely think about integrating the source code of Maia directly into ERPNext, but it will require resources and a huge workload that we prefer to put today in the development of new functionalities and in the stability of Maia.

Don't hesitate to check out our demo of [Maia](https://maia-by-dokos.fr).

---
You need an analysis for your project or advices on this topic ? Don't hesitate to contact me at [DOKOS](https://www.dokos.io), I'll be happy to help you!


text:
# Contribs

```{sidebar} More contributions
Additional Evennia code snippets and contributions can be found
in the [Community Contribs & Snippets][forum] forum.
```
_Contribs_ are optional code snippets and systems contributed by
the Evennia community. They vary in size and complexity and
may be more specific about game types and styles than 'core' Evennia.
This page is auto-generated and summarizes all **49** contribs currently included
with the Evennia distribution.

All contrib categories are imported from `evennia.contrib`, such as

    from evennia.contrib.base_systems import building_menu

Each contrib contains installation instructions for how to integrate it
with your other code. If you want to tweak the code of a contrib, just
copy its entire folder to your game directory and modify/use it from there.

If you want to add a contrib, see [the contrib guidelines](./Contribs-Guidelines.md)!

[forum]: https://github.com/evennia/evennia/discussions/categories/community-contribs-snippets

## Index
| | | | | | | |
|---|---|---|---|---|---|---|
| [base_systems](#base_systems) | [full_systems](#full_systems) | [game_systems](#game_systems) | [grid](#grid) | [rpg](#rpg) | [tutorials](#tutorials) | [utils](#utils) |

| | | | | |
|---|---|---|---|---|
| [auditing](#auditing) | [awsstorage](#awsstorage) | [barter](#barter) | [batchprocessor](#batchprocessor) | [bodyfunctions](#bodyfunctions) |
| [buffs](#buffs) | [building_menu](#building_menu) | [character_creator](#character_creator) | [clothing](#clothing) | [color_markups](#color_markups) |
| [components](#components) | [containers](#containers) | [cooldowns](#cooldowns) | [crafting](#crafting) | [custom_gametime](#custom_gametime) |
| [dice](#dice) | [email_login](#email_login) | [evadventure](#evadventure) | [evscaperoom](#evscaperoom) | [extended_room](#extended_room) |
| [fieldfill](#fieldfill) | [gendersub](#gendersub) | [git_integration](#git_integration) | [godotwebsocket](#godotwebsocket) | [health_bar](#health_bar) |
| [ingame_map_display](#ingame_map_display) | [ingame_python](#ingame_python) | [llm](#llm) | [mail](#mail) | [mapbuilder](#mapbuilder) |
| [menu_login](#menu_login) | [mirror](#mirror) | [multidescer](#multidescer) | [mux_comms_cmds](#mux_comms_cmds) | [name_generator](#name_generator) |
| [puzzles](#puzzles) | [random_string_generator](#random_string_generator) | [red_button](#red_button) | [rpsystem](#rpsystem) | [simpledoor](#simpledoor) |
| [slow_exit](#slow_exit) | [talking_npc](#talking_npc) | [traits](#traits) | [tree_select](#tree_select) | [turnbattle](#turnbattle) |
| [tutorial_world](#tutorial_world) | [unixcommand](#unixcommand) | [wilderness](#wilderness) | [xyzgrid](#xyzgrid) |

## base_systems

_Systems that are not necessarily tied to a specific
in-game mechanic but which are useful for the game as a whole. Examples include
login systems, new command syntaxes, and build helpers._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-AWSStorage.md
Contrib-Building-Menu.md
Contrib-Color-Markups.md
Contrib-Components.md
Contrib-Custom-Gametime.md
Contrib-Email-Login.md
Contrib-Godotwebsocket.md
Contrib-Ingame-Python.md
Contrib-Menu-Login.md
Contrib-Mux-Comms-Cmds.md
Contrib-Unixcommand.md
```

### `awsstorage`

_Contrib by The Right Honourable Reverend (trhr), 2020_

This plugin migrates the Web-based portion of Evennia, namely images,
javascript, and other items located inside staticfiles into Amazon AWS (S3)
cloud hosting. Great for those serving media with the game.

[Read the documentation](./Contrib-AWSStorage.md) - [Browse the Code](evennia.contrib.base_systems.awsstorage)

### `building_menu`

_Contrib by vincent-lg, 2018_

Building menus are in-game menus, not unlike `EvMenu` though using a
different approach. Building menus have been specifically designed to edit
information as a builder. Creating a building menu in a command allows
builders quick-editing of a given object, like a room. If you follow the
steps to add the contrib, you will have access to an `edit` command
that will edit any default object, offering to change its key and description.

[Read the documentation](./Contrib-Building-Menu.md) - [Browse the Code](evennia.contrib.base_systems.building_menu)

### `color_markups`

_Contrib by Griatch, 2017_

Additional color markup styles for Evennia (extending or replacing the default
`|r`, `|234`). Adds support for MUSH-style (`%cr`, `%c123`) and/or legacy-Evennia
(`{r`, `{123`).

[Read the documentation](./Contrib-Color-Markups.md) - [Browse the Code](evennia.contrib.base_systems.color_markups)

### `components`

_Contrib by ChrisLR, 2021_

Expand typeclasses using a components/composition approach.

[Read the documentation](./Contrib-Components.md) - [Browse the Code](evennia.contrib.base_systems.components)

### `custom_gametime`

_Contrib by vlgeoff, 2017 - based on Griatch's core original_

This reimplements the `evennia.utils.gametime` module but with a _custom_
calendar (unusual number of days per week/month/year etc) for your game world.
Like the original, it allows for scheduling events to happen at given
in-game times, but now taking this custom calendar into account.

[Read the documentation](./Contrib-Custom-Gametime.md) - [Browse the Code](evennia.contrib.base_systems.custom_gametime)

### `email_login`

_Contrib by Griatch, 2012_

This is a variant of the login system that asks for an email-address
instead of a username to login. Note that it does not verify the email,
it just uses it as the identifier rather than a username.

[Read the documentation](./Contrib-Email-Login.md) - [Browse the Code](evennia.contrib.base_systems.email_login)

### `godotwebsocket`

_Contribution by ChrisLR, 2022_

This contrib allows you to connect a Godot Client directly to your mud,
and display regular text with color in Godot's RichTextLabel using BBCode.
You can use Godot to provide advanced functionality with proper Evennia support.

[Read the documentation](./Contrib-Godotwebsocket.md) - [Browse the Code](evennia.contrib.base_systems.godotwebsocket)

### `ingame_python`

_Contrib by Vincent Le Goff 2017_

This contrib adds the ability to script with Python in-game. It allows trusted
staff/builders to dynamically add features and triggers to individual objects
without needing to do it in external Python modules. Using custom Python in-game,
specific rooms, exits, characters, objects etc can be made to behave differently from
its "cousins". This is similar to how softcode works for MU or MudProgs for DIKU.
Keep in mind, however, that allowing Python in-game comes with _severe_
security concerns (you must trust your builders deeply), so read the warnings in
this module carefully before continuing.

[Read the documentation](./Contrib-Ingame-Python.md) - [Browse the Code](evennia.contrib.base_systems.ingame_python)

### `menu_login`

_Contribution by Vincent-lg 2016. Reworked for modern EvMenu by Griatch, 2019._

This changes the Evennia login to ask for the account name and password as a series
of questions instead of requiring you to enter both at once. It uses Evennia's
menu system `EvMenu` under the hood.

[Read the documentation](./Contrib-Menu-Login.md) - [Browse the Code](evennia.contrib.base_systems.menu_login)

### `mux_comms_cmds`

_Contribution by Griatch 2021_

In Evennia 1.0+, the old Channel commands (originally inspired by MUX) were
replaced by the single `channel` command that performs all these functions.
This contrib (extracted from Evennia 0.9.5) breaks out the functionality into
separate Commands more familiar to MU* users. This is just for show though, the
main `channel` command is still called under the hood.

[Read the documentation](./Contrib-Mux-Comms-Cmds.md) - [Browse the Code](evennia.contrib.base_systems.mux_comms_cmds)

### `unixcommand`

_Contribution by Vincent Le Geoff (vlgeoff), 2017_

This module contains a command class with an alternate syntax parser implementing
Unix-style command syntax in-game. This means `--options`, positional arguments
and stuff like `-n 10`. It might not the best syntax for the average player
but can be really useful for builders when they need to have a single command do
many things with many options. It uses the `ArgumentParser` from Python's standard
library under the hood.

[Read the documentation](./Contrib-Unixcommand.md) - [Browse the Code](evennia.contrib.base_systems.unixcommand)

## full_systems

_'Complete' game engines that can be used directly to start creating content
without no further additions (unless you want to)._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Evscaperoom.md
```

### `evscaperoom`

_Contribution by Griatch, 2019_

A full engine for creating multiplayer escape-rooms in Evennia. Allows players to
spawn and join puzzle rooms that track their state independently. Any number of players
can join to solve a room together. This is the engine created for 'EvscapeRoom', which won
the MUD Coders Guild "One Room" Game Jam in April-May, 2019. The contrib has no game
content but contains the utilities and base classes and an empty example room.

[Read the documentation](./Contrib-Evscaperoom.md) - [Browse the Code](evennia.contrib.full_systems.evscaperoom)

## game_systems

_In-game gameplay systems like crafting, mail, combat and more.
Each system is meant to be adopted piecemeal and adopted for your game.
This does not include roleplaying-specific systems, those are found in
the `rpg` category._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Barter.md
Contrib-Clothing.md
Contrib-Containers.md
Contrib-Cooldowns.md
Contrib-Crafting.md
Contrib-Gendersub.md
Contrib-Mail.md
Contrib-Multidescer.md
Contrib-Puzzles.md
Contrib-Turnbattle.md
```

### `barter`

_Contribution by Griatch, 2012_

This implements a full barter system - a way for players to safely
trade items between each other in code rather than simple `give/get`
commands. This increases both safety (at no time will one player have
both goods and payment in-hand) and speed, since agreed goods will
be moved automatically). By just replacing one side with coin objects,
(or a mix of coins and goods), this also works fine for regular money
transactions.

[Read the documentation](./Contrib-Barter.md) - [Browse the Code](evennia.contrib.game_systems.barter)

### `clothing`

_Contribution by Tim Ashley Jenkins, 2017_

Provides a typeclass and commands for wearable clothing. These
look of these clothes are appended to the character's description when worn.

[Read the documentation](./Contrib-Clothing.md) - [Browse the Code](evennia.contrib.game_systems.clothing)

### `containers`

_Adds the ability to put objects into other container objects by providing a container typeclass and extending certain base commands._

## Installation

[Read the documentation](./Contrib-Containers.md) - [Browse the Code](evennia.contrib.game_systems.containers)

### `cooldowns`

_Contribution by owllex, 2021_

Cooldowns are used to model rate-limited actions, like how often a
character can perform a given action; until a certain time has passed their
command can not be used again. This contrib provides a simple cooldown
handler that can be attached to any typeclass. A cooldown is a lightweight persistent
asynchronous timer that you can query to see if a certain time has yet passed.

[Read the documentation](./Contrib-Cooldowns.md) - [Browse the Code](evennia.contrib.game_systems.cooldowns)

### `crafting`

_Contribution by Griatch 2020_

This implements a full crafting system. The principle is that of a 'recipe',
where you combine items (tagged as ingredients) create something new. The recipe can also
require certain (non-consumed) tools. An example would be to use the 'bread recipe' to
combine 'flour', 'water' and 'yeast' with an 'oven' to bake a 'loaf of bread'.

[Read the documentation](./Contrib-Crafting.md) - [Browse the Code](evennia.contrib.game_systems.crafting)

### `gendersub`

_Contribution by Griatch 2015_

This is a simple gender-aware Character class for allowing users to
insert custom markers in their text to indicate gender-aware
messaging. It relies on a modified msg() and is meant as an
inspiration and starting point to how to do stuff like this.

[Read the documentation](./Contrib-Gendersub.md) - [Browse the Code](evennia.contrib.game_systems.gendersub)

### `mail`

_Contribution by grungies1138 2016_

A simple Brandymail style mail system that uses the `Msg` class from Evennia
Core. It has two Commands for either sending mails between Accounts (out of game)
or between Characters (in-game). The two types of mails can be used together or
on their own.

[Read the documentation](./Contrib-Mail.md) - [Browse the Code](evennia.contrib.game_systems.mail)

### `multidescer`

_Contribution by Griatch 2016_

A "multidescer" is a concept from the MUSH world. It allows for
splitting your descriptions into arbitrary named 'sections' which you can
then swap out at will. It is a way for quickly managing your look (such as when
changing clothes) in more free-form roleplaying systems. This will also
work well together with the `rpsystem` contrib.

[Read the documentation](./Contrib-Multidescer.md) - [Browse the Code](evennia.contrib.game_systems.multidescer)

### `puzzles`

_Contribution by Henddher 2018_

Intended for adventure-game style combination puzzles, such as combining fruits
and a blender to create a smoothie. Provides a typeclass and commands for objects
that can be combined (i.e. used together). Unlike the `crafting` contrib, each
puzzle is built from unique objects rather than using tags and a builder can create
the puzzle entirely from in-game.

[Read the documentation](./Contrib-Puzzles.md) - [Browse the Code](evennia.contrib.game_systems.puzzles)

### `turnbattle`

_Contribution by Tim Ashley Jenkins, 2017_

This is a framework for a simple turn-based combat system, similar
to those used in D&D-style tabletop role playing games. It allows
any character to start a fight in a room, at which point initiative
is rolled and a turn order is established. Each participant in combat
has a limited time to decide their action for that turn (30 seconds by
default), and combat progresses through the turn order, looping through
the participants until the fight ends.

[Read the documentation](./Contrib-Turnbattle.md) - [Browse the Code](evennia.contrib.game_systems.turnbattle)

## grid

_Systems related to the game world's topology and structure. Contribs related
to rooms, exits and map building._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Extended-Room.md
Contrib-Ingame-Map-Display.md
Contrib-Mapbuilder.md
Contrib-Simpledoor.md
Contrib-Slow-Exit.md
Contrib-Wilderness.md
Contrib-XYZGrid.md
```

### `extended_room`

_Contribution - Griatch 2012, vincent-lg 2019, Griatch 2023_

This extends the normal `Room` typeclass to allow its description to change with
time-of-day and/or season as well as any other state (like flooded or dark).
Embedding `$state(burning, This place is on fire!)` in the description will
allow for changing the description based on room state. The room also supports
`details` for the player to look at in the room (without having to create a new
in-game object for each), as well as support for random echoes. The room
comes with a set of alternate commands for `look` and `@desc`, as well as new
commands `detail`, `roomstate` and `time`.

[Read the documentation](./Contrib-Extended-Room.md) - [Browse the Code](evennia.contrib.grid.extended_room)

### `ingame_map_display`

_Contribution - helpme 2022_

This adds an ascii `map` to a given room which can be viewed with the `map` command.
You can easily alter it to add special characters, room colors etc. The map shown is
dynamically generated on use, and supports all compass directions and up/down. Other
directions are ignored.

[Read the documentation](./Contrib-Ingame-Map-Display.md) - [Browse the Code](evennia.contrib.grid.ingame_map_display)

### `mapbuilder`

_Contribution by Cloud_Keeper 2016_

Build a game map from the drawing of a 2D ASCII map.

[Read the documentation](./Contrib-Mapbuilder.md) - [Browse the Code](evennia.contrib.grid.mapbuilder)

### `simpledoor`

_Contribution by Griatch, 2016_

A simple two-way exit that represents a door that can be opened and
closed from both sides. Can easily be expanded to make it lockable,
destroyable etc.

[Read the documentation](./Contrib-Simpledoor.md) - [Browse the Code](evennia.contrib.grid.simpledoor)

### `slow_exit`

_Contribution by Griatch 2014_

An example of an Exit-type that delays its traversal. This simulates
slow movement, common in many games. The contrib also
contains two commands, `setspeed` and `stop` for changing the movement speed
and abort an ongoing traversal, respectively.

[Read the documentation](./Contrib-Slow-Exit.md) - [Browse the Code](evennia.contrib.grid.slow_exit)

### `wilderness`

_Contribution by titeuf87, 2017_

This contrib provides a wilderness map without actually creating a large number
of rooms - as you move, you instead end up back in the same room but its description
changes. This means you can make huge areas with little database use as
long as the rooms are relatively similar (e.g. only the names/descs changing).

[Read the documentation](./Contrib-Wilderness.md) - [Browse the Code](evennia.contrib.grid.wilderness)

### `xyzgrid`

_Contribution by Griatch 2021_

Places Evennia's game world on an xy (z being different maps) coordinate grid.
Grid is created and maintained externally by drawing and parsing 2D ASCII maps,
including teleports, map transitions and special markers to aid pathfinding.
Supports very fast shortest-route pathfinding on each map. Also includes a
fast view function for seeing only a limited number of steps away from your
current location (useful for displaying the grid as an in-game, updating map).

[Read the documentation](./Contrib-XYZGrid.md) - [Browse the Code](evennia.contrib.grid.xyzgrid)

## rpg

_Systems specifically related to roleplaying
and rule implementation like character traits, dice rolling and emoting._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Buffs.md
Contrib-Character-Creator.md
Contrib-Dice.md
Contrib-Health-Bar.md
Contrib-Llm.md
Contrib-RPSystem.md
Contrib-Traits.md
```

### `buffs`

_Contribution by Tegiminis 2022_

A buff is a timed object, attached to a game entity. It is capable of modifying values, triggering code, or both.
It is a common design pattern in RPGs, particularly action games.

[Read the documentation](./Contrib-Buffs.md) - [Browse the Code](evennia.contrib.rpg.buffs)

### `character_creator`

_Contribution by InspectorCaracal, 2022_

Commands for managing and initiating an in-game character-creation menu.

[Read the documentation](./Contrib-Character-Creator.md) - [Browse the Code](evennia.contrib.rpg.character_creator)

### `dice`

_Contribution by Griatch, 2012, 2023_

A dice roller for any number and side of dice. Adds in-game dice rolling
(like `roll 2d10 + 1`) as well as conditionals (roll under/over/equal to a target)
and functions for rolling dice in code. Command also supports hidden or secret
rolls for use by a human game master.

[Read the documentation](./Contrib-Dice.md) - [Browse the Code](evennia.contrib.rpg.dice)

### `health_bar`

_Contribution by Tim Ashley Jenkins, 2017_

The function provided in this module lets you easily display visual
bars or meters as a colorful bar instead of just a number. A "health bar"
is merely the most obvious use for this, but the bar is highly customizable
and can be used for any sort of appropriate data besides player health.

[Read the documentation](./Contrib-Health-Bar.md) - [Browse the Code](evennia.contrib.rpg.health_bar)

### `llm`

_Contribution by Griatch 2023_

This adds an LLMClient that allows Evennia to send prompts to a  LLM server (Large Language Model, along the lines of ChatGPT). Example uses a local OSS LLM install. Included is an NPC you can chat with using a new `talk` command. The NPC will respond using the AI responses from the LLM server. All calls are asynchronous, so if the LLM is slow, Evennia is not affected.

[Read the documentation](./Contrib-Llm.md) - [Browse the Code](evennia.contrib.rpg.llm)

### `rpsystem`

_Contribution by Griatch, 2015_

A full roleplaying emote system. Short-descriptions and recognition (only
know people by their looks until you assign a name to them). Room poses. Masks/disguises
(hide your description). Speak directly in emote, with optional language obscuration
(words get garbled if you don't know the language, you can also have different languages
with different 'sounding' garbling). Whispers can be partly overheard from a distance. A
very powerful in-emote reference system, for referencing and differentiate targets
(including objects).

[Read the documentation](./Contrib-RPSystem.md) - [Browse the Code](evennia.contrib.rpg.rpsystem)

### `traits`

_Contribution by Griatch 2020, based on code by Whitenoise and Ainneve contribs, 2014_

A `Trait` represents a modifiable property on (usually) a Character. They can
be used to represent everything from attributes (str, agi etc) to skills
(hunting 10, swords 14 etc) and dynamically changing things like HP, XP etc.
Traits differ from normal Attributes in that they track their changes and limit
themselves to particular value-ranges. One can add/subtract from them easily and
they can even change dynamically at a particular rate (like you being poisoned or
healed).

[Read the documentation](./Contrib-Traits.md) - [Browse the Code](evennia.contrib.rpg.traits)

## tutorials

_Helper resources specifically meant to teach a development concept or
to exemplify an Evennia system. Any extra resources tied to documentation
tutorials are found here. Also the home of the Tutorial-World and Evadventure
demo codes._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Batchprocessor.md
Contrib-Bodyfunctions.md
Contrib-Evadventure.md
Contrib-Mirror.md
Contrib-Red-Button.md
Contrib-Talking-Npc.md
Contrib-Tutorial-World.md
```

### `batchprocessor`

_Contibution by Griatch, 2012_

Simple examples for the batch-processor. The batch processor is used for generating
in-game content from one or more static files. Files can be stored with version
control and then 'applied' to the game to create content.

[Read the documentation](./Contrib-Batchprocessor.md) - [Browse the Code](evennia.contrib.tutorials.batchprocessor)

### `bodyfunctions`

_Contribution by Griatch, 2012_

Example script for testing. This adds a simple timer that has your
character make small verbal observations at irregular intervals.

[Read the documentation](./Contrib-Bodyfunctions.md) - [Browse the Code](evennia.contrib.tutorials.bodyfunctions)

### `evadventure`

_Contrib by Griatch 2023-_

```{warning}
NOTE - this tutorial is WIP and NOT complete yet! You will still learn
things from it, but don't expect perfection.
```

[Read the documentation](./Contrib-Evadventure.md) - [Browse the Code](evennia.contrib.tutorials.evadventure)

### `mirror`

_Contribution by Griatch, 2017_

A simple mirror object to experiment with. It will respond to being looked at.

[Read the documentation](./Contrib-Mirror.md) - [Browse the Code](evennia.contrib.tutorials.mirror)

### `red_button`

_Contribution by Griatch, 2011_

A red button that you can press to have an effect. This is a more advanced example
object with its own functionality and state tracking.

[Read the documentation](./Contrib-Red-Button.md) - [Browse the Code](evennia.contrib.tutorials.red_button)

### `talking_npc`

_Contribution by Griatch 2011. Updated by grungies1138, 2016_

This is an example of a static NPC object capable of holding a simple menu-driven
conversation. Suitable for example as a quest giver or merchant.

[Read the documentation](./Contrib-Talking-Npc.md) - [Browse the Code](evennia.contrib.tutorials.talking_npc)

### `tutorial_world`

_Contribution by Griatch 2011, 2015_

A stand-alone tutorial area for an unmodified Evennia install.
Think of it as a sort of single-player adventure rather than a
full-fledged multi-player game world. The various rooms and objects
are designed to show off features of Evennia, not to be a
very challenging (nor long) gaming experience. As such it's of course
only skimming the surface of what is possible. Taking this apart
is a great way to start learning the system.

[Read the documentation](./Contrib-Tutorial-World.md) - [Browse the Code](evennia.contrib.tutorials.tutorial_world)

## utils

_Miscellaneous, tools for manipulating text, security auditing, and more._

```{toctree}
:hidden:
Contribs-Guidelines.md
```
```{toctree}
:maxdepth: 1

Contrib-Auditing.md
Contrib-Fieldfill.md
Contrib-Git-Integration.md
Contrib-Name-Generator.md
Contrib-Random-String-Generator.md
Contrib-Tree-Select.md
```

### `auditing`

_Contribution by Johnny, 2017_

Utility that taps and intercepts all data sent to/from clients and the
server and passes it to a callback of your choosing. This is intended for
quality assurance, post-incident investigations and debugging.

[Read the documentation](./Contrib-Auditing.md) - [Browse the Code](evennia.contrib.utils.auditing)

### `fieldfill`

_Contribution by Tim Ashley Jenkins, 2018_

This module contains a function that generates an `EvMenu` for you - this
menu presents the player with a form of fields that can be filled
out in any order (e.g. for character generation or building). Each field's value can
be verified, with the function allowing easy checks for text and integer input,
minimum and maximum values / character lengths, or can even be verified by a custom
function. Once the form is submitted, the form's data is submitted as a dictionary
to any callable of your choice.

[Read the documentation](./Contrib-Fieldfill.md) - [Browse the Code](evennia.contrib.utils.fieldfill)

### `git_integration`

_Contribution by helpme (2022)_

A module to integrate a stripped-down version of git within the game, allowing developers to view their git status, change branches, and pull updated code of both their local mygame repo and Evennia core. After a successful pull or checkout, the git command will reload the game: Manual restarts may be required to to apply certain changes that would impact persistent scripts etc.

[Read the documentation](./Contrib-Git-Integration.md) - [Browse the Code](evennia.contrib.utils.git_integration)

### `name_generator`

_Contribution by InspectorCaracal (2022)_

A module for generating random names, both real-world and fantasy. Real-world
names can be generated either as first (personal) names, family (last) names, or
full names (first, optional middles, and last). The name data is from [Behind the Name](https://www.behindthename.com/)
and used under the [CC BY-SA 4.0 license](https://creativecommons.org/licenses/by-sa/4.0/).

[Read the documentation](./Contrib-Name-Generator.md) - [Browse the Code](evennia.contrib.utils.name_generator)

### `random_string_generator`

_Contribution by Vincent Le Goff (vlgeoff), 2017_

This utility can be used to generate pseudo-random strings of information
with specific criteria.  You could, for instance, use it to generate
phone numbers, license plate numbers, validation codes, in-game security
passwords and so on. The strings generated will be stored and won't be repeated.

[Read the documentation](./Contrib-Random-String-Generator.md) - [Browse the Code](evennia.contrib.utils.random_string_generator)

### `tree_select`

_Contribution by Tim Ashley Jenkins, 2017_

This utility allows you to create and initialize an entire branching EvMenu
instance from a multi-line string passed to one function.

[Read the documentation](./Contrib-Tree-Select.md) - [Browse the Code](evennia.contrib.utils.tree_select)

----

<small>This document page is auto-generated. Manual changes
will be overwritten.</small>

repository: evennia/evennia

repo_name: evennia/evennia