text:
---
title: "PowerTalk"
date: "2016-06-21"
description: "PowerTalk automatically speaks any presentation or slide show running in Microsoft PowerPoint for Windows.  You just download and install PowerTalk and while you open and run the presentation as usual it speaks the text on your slides. The advantage over other generic \'Text To Speech\' programs is that PowerTalk is able to speak text as it appears and can also speak hidden text attached to images. Speech is provided by the standard synthesised computer voices that are provided with Windows. Note: The \"\"Latest version\"\" information here is not currently maintained. Select the external download link to Sourceforge for the latest versions!"
type: "Software"
tags: ['Text to Speech','Alternative and Augmentative Communication','Communication','Viewing the screen','Learning and Education' ]
image: "images/full/1.png"
thumb: "images/thumbs/1.png"
project_url: ""
download_url: "http://sourceforge.net/projects/powertalk/files/powertalk/"
---

### Links:
- Help
- <a<EMAIL_ADDRESS>Address
- Project Home Page

### Download: http://sourceforge.net/projects/powertalk/files/powertalk/


text:
# Unirx Playground
A Unity playground for [UniRx](https://github.com/neuecc/UniRx "UniRx Repository") visualization inspired by [rxmarbles.com](https://rxmarbles.com/ "RxMarbles").

### Usage
After downloading the source code simply press play on the [MainScene](../main/Assets/MainScene.unity). The default choice is a SelectMany visualization which is one of the prepared examples. Check out other prepared examples in the [Example](../main/Assets/Scripts/Examples/Example.cs) script. You can write your own examples in this class and run them by changing _exampleId_ in the inspector.

![Select Many Example Visualization](https://github.com/Jacykow/Unirx-Playground/blob/main/select_many.png?raw=true "Select Many")

### How does this work?
Observable usage normally would look something like this:
```csharp
SomeObservable
    .UniRxExtensionMethod1()
    .UniRxExtensionMethod2()
    .Subscribe(value => OnNext(value))
    .AddTo(this);
```
To visualize an observable you need to convert it to ```IObservable<RxMessageVisualizationData>```. Any observable of this type can be visualized by the ```Visualize``` extension method.
```csharp
SomeObservable
    .UniRxExtensionMethod1()
    .UniRxExtensionMethod2()
    .AsVisualizationDataObservable()
    .Visualize("Timeline Title")
    .Subscribe()
    .AddTo(RxTimelineManager.Main.DisposeBag);
```
The conversion to ```IObservable<RxMessageVisualizationData>``` can be done easily via the ```AsVisualizationDataObservable``` extension method. Without any given parameters the color will be a random color chosen at the beginning and the shown number will be an increasing integer starting from 1. If you want to keep any of the information that was contained in the original message you need to provide a selector method that will put it into the integer value or color of a message node.

There is no need to catch any messages in the subscription since all callbacks are visualized but it can still be used for debug purposes.

All subscriptions have to be destroyed at the end of the visualization in order to stop displying incoming messages. This can be ensured by adding them to ```RxTimelineManager.Main.DisposeBag```.

All of this is necessary for the [RxTimelineManager](../main/Assets/Scripts/Visualization/RxTimelineManager.cs) to properly invoke the ```Do```, ```DoOnCompleted``` and ```DoOnError``` methods and add put corresponding markers on correct timelines.

license: MIT

repository: Jacykow/Unirx-Playground

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: Jacykow/Unirx-Playground


text:
---
layout: post
title: "Wedding recap: the rings"
date: 2012-03-23 12:49
comments: true
categories:
tags: wedding
author: Lois
published: true
---
{% img left /images/2012/03/rings.jpg 381 both rings in my hand (photo by Gerald Deo) %}

The rings were mainly Matt's doing. So I'll just post a couple of pictures and describe them generally, and let him tell you all about them (either as a blog post later or when you come over for dinner!).

My ring is also the engagement ring. It has nine stones, three each of sapphires, white diamonds and black diamonds, set to nine interlocking fishes.

Matt's ring is a moebius strip, with a line of rose gold that traces one of the two surfaces (there are two surfaces because it has thickness). Acorns and oak leaves are hand-engraved on the opposite surface.

Our rings match in their wavy shape. I think we have the coolest rings ever, and I love that they are one-of-a-kind, yet they belong together.

{% img /images/2012/03/rings2.jpg 789 our hands (photo by Gerald Deo) %}

repository: fishtron/threeofakind

branch_name: refs/heads/master

extension: markdown

repo_name: fishtron/threeofakind


text:
# ExportHtml

## 2.17.5

- **FIX**: Remove unnecessary dependencies.
- **FIX**: Fix typo in settings configuration.

## 2.17.4

- **FIX**: Fix `jinja2` import error.

## 2.17.3

- **FIX**: Fix a scheme loading related issue.
- **FIX**: Ensure ExportHTML will work with Package Control 4.0 (compatibility issues with latest `mdpopups` needed for
  Package Control 4.0).

## 2.17.2

- **FIX**: Fix a regression where custom defined schemes are not used.

## 2.17.1

- **FIX**: Fix issues with Sublime 4095 `auto` light/dark color scheme option (legacy converter).
- **FIX**: Reduce dependencies by relying on the `coloraide` in `mdpopups`.
- **FIX**: Fix some color filter cases.

## 2.17.0

- **NEW**: Drop BBCode support.
- **NEW**: Use recent Sublime API commands, such as `view.style()` and `view.style_for_scope()` instead of old legacy
  method.
- **NEW**: Use `coloraide` dependency for color handling.
- **FIX**: Recent changes should allow `min-contrast` usage in themes to work.
- **FIX**: Recent changes should allow for handling invalid color in color schemes better.
- **FIX**: Recent changes should fix some issues with hashed schemes.

## 2.16.1

- **FIX**: Fix issue with quick start doc not showing images proper.

## 2.16.0

- **NEW**: Add `glow` and `underline` support in Sublime syntax color schemes.

## 2.15.1

- **FIX**: ST4 now handles `HSL` properly, remove workaround for build 4069.
- **FIX**: `+`/`-` have to be followed by spaces in `saturation`, `lightness`, and `alpha` or they should be treated as
  part of the number following them. `*` does not need a space.
- **FIX**: Add support for `deg` unit type for the hue channel with `HSL` and `HWB`.
- **FIX**: Sublime will ignore the unit types `rad`, `grad`, and `turn` for `HSL` and `HWB`, but add support for them in
  case Sublime ever does.

## 2.15.0

- **NEW**: Support `lightness()` and `saturation()` in color mod functions.
- **NEW**: Properly support `alpha(+value)`, `alpha(-value)`, `alpha(*value)`, and `alpha(value)`.
- **NEW**: Suppport `foreground_adjust`.

## 2.14.4

- **FIX**: Fix references to internal color schemes in settings. Color schemes wouldn't load proper as the color scheme
  names were wrong.

## 2.14.3

- **FIX**: Mimic Sublime in regards to hue blending.

## 2.14.2

- **FIX**: Fix `HWB` exception.

## 2.14.1

- **FIX**: Fix some regressions in regard to blending colors.
- **FIX**: Fix issue where `HWB` blending was used when it shouldn't be.

## 2.14.0

- **NEW**: Respect `no_bold` and `no_italic` options in `font_options`.
- **NEW**: Default themes converted to `sublime-color-scheme` format.
- **NEW**: Handle blending in `HSL` and `HWB` color space.
- **FIX**: Improved color blending.

## 2.13.0

- **NEW**: Add support for `hwb()` and `alpha()`/`a()`.
- **FIX**: Handle `hsl()` in `blend()`.

## 2.12.1

- **FIX**: Allow `-` in variables names. Write color translations to main scheme object and ensure filtering is done after color translations.

## 2.12.0

- **NEW**: Better tab conversion algorithm. Converts tabs to spaces based on tab stops (though it doesn't account for character width).
- **NEW**: Using `disable_nbsp` will insert real tabs or spaces.
- **NEW**: Settings are gathered from the view under conversion, not the global preferences.
- **NEW**: Default provided print setups now disables `nbsp` by default to use the exact whitespace in a file.
- **FIX**: Font in HTML not being displayed correctly.

## 2.11.0

- **NEW**: Add support for `.hidden-color-scheme`.
- **FIX**: Update dependencies.

## 2.10.2

- **FIX**: Create fallback file read for resource race condition.

## 2.10.1

- **FIX**: Parse legacy `foregroundSelection` properly.

## 2.10.0

- **NEW**: Add support `.sublime-color-scheme` hashed syntax highlighting.
- **FIX**: `.sublime-color-scheme` merge logic.

## 2.9.1

- **FIX**: Parse color scheme with unexpected extension correctly.

## 2.9.0

- **NEW**: Add support for rendering output without tables (Default CSS did change, so if overriding it, you may need to update).
- **FIX**: Support for irregular `.sublime-color-scheme` values.

## 2.8.0

- **NEW**: Add support for per scope selection foreground.
- **FIX**: Some general color scheme parsing and tweaking issues.

## 2.7.0

- **NEW**: Add support for `.sublime-color-scheme` files.
- **NEW**: Drop option to include scheme in output.

## 2.6.0

- **NEW**: Upgrade theme_tweaker and rgba lib which adds the ability to adjust contrast.
- **FIX**: Don't include document build folder.

## 2.5.0

- **NEW**: Add document and settings to the command palette.
- **FIX**: Quick start image links.

## 2.4.1

- **FIX**: Hopefully more reliable browser opening (#47).

## 2.4.0

- **NEW**: Limit popups to 3124+.
- **FIX**: Better scope matching.

## 2.3.1

- **FIX**: Skip processing popupCss and phantomCss.

## 2.3.0

- **NEW**: Handle X11 named colors in color schemes (#44).
- **NEW**: By default, don't include color scheme plist in output (to reduce size of output).
- **NEW**: Quickstart guide available in menu.
- **NEW**: Links to repo issues and documentation available in menu.

## 2.2.2

- **FIX**: Fix changelog links

## 2.2.1

- **Fix**: Fix incorrect changelog title (#43).

## 2.2.0

- **NEW**: Add `disable_nbsp` option.
- **Fix**: JS not loading into HTML.

## 2.1.0

- **NEW**: New dependencies.
- **NEW**: Added changelog and support info command in menu.
- **NEW**: CSS template is now handled by Jinja2.
- **NEW**: Add `export_css` setting to specify custom CSS.

## 2.0.0

- **NEW**: Arbitrary jump to 2.0.0 version number
- **NEW**: Upgrade color libs
- **NEW**: Get current scheme from view settings instead of global

repository: facelessuser/ExportHtml

gha_language: Python

repo_name: facelessuser/ExportHtml


text:
# Spark-NLP Databricks

## Databricks Notebooks

You can view all the Databricks notebooks from this address:

[https://johnsnowlabs.github.io/spark-nlp-workshop/databricks/index.html](https://johnsnowlabs.github.io/spark-nlp-workshop/databricks/index.html)

Note: You can import these notebooks by using their URLs.

## How to use Spark-NLP library in Databricks

1- Right-click the Workspace folder where you want to store the library.

2- Select Create > Library.

3- Select where you would like to create the library in the Workspace, and open the Create Library dialog:

![Databricks](https://databricks.com/wp-content/uploads/2015/07/create-lib.png)

4- From the Source drop-down menu, select **Maven Coordinate:**
![Databricks](https://databricks.com/wp-content/uploads/2015/07/select-maven-1024x711.png)

5- Now, all available **Spark Packages** are at your fingertips! Just search for **JohnSnowLabs:spark-nlp:version** where **version** stands for the library version such as: `1.8.4` or `2.2.1`
![Databricks](https://databricks.com/wp-content/uploads/2015/07/browser-1024x548.png)

6- Select **spark-nlp** package and we are good to go!

More info about how to use 3rd [Party Libraries in Databricks](https://databricks.com/blog/2015/07/28/using-3rd-party-libraries-in-databricks-apache-spark-packages-and-maven-libraries.html)


text:
# pawn-moves

## Instructions for building and running the code
###
In app/src
1. mkdir out/dev/app
2. javac -d out/dev/app app/src/pawntour/\*.java app/src/\*.java

In out/dev/app
    - java Solution 10 true

    Usage: java Solution <length> <printBoard>
    <length> is the length of square (integer value)
    <printBoard> takes the value of 'true' or 'false' (without quotes)
    and prints the board for a tour

    Output looks like this (for length = 6)
    --------------------------------------------
    34 11 18 35 10 19
    16 26 08 13 27 07
    23 03 29 24 04 30
    33 12 17 36 09 20
    15 25 05 14 28 06
    22 02 32 21 01 31

    27 tours found starting with coordinates [(0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 5), (2, 1), (2, 3), (2, 5), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 2), (5, 3), (5, 4)]
    01 closed tours found starting with coordinates [(3, 0)]

## Solution
### Approach #1:
In this approach, I tried backtracking for all the legal moves for pawn given the constraints.
I would visit a coordinate and then visit all the adjacent ones and their adjacent ones, till the point where
one path may end up in visiting all cells. This was working fine for square lengths till 6. From 7 onwards it started
taking huge time. The complexity was - O(8^(n^2)) - worst case, where n is the is number of squares
on the edge (length of square).The algorithm worked fine for n = 6, but time taken to compute hereafter,
increased exponentially.

### Approach #2:
There was an optimization which I did on previous solution.
I applied [Warnsdorff's rule](https://en.wikipedia.org/wiki/Knight%27s_tour#Warnsdorff.27s_rule).
It states that we build heuristics for each cell and visit cell next which has least out degree (moves from this cell).
This sped in execution as we are visiting nodes which have lower outdegree first than nodes with higher outdegree.
I also tried to generate closed tour as fun part. In the end I print all the possible tours and all
possible closed tours count along with their origin point.

repository: ankit-mnnit/pawn-moves

repo_name: ankit-mnnit/pawn-moves


text:
# gPodder Extension for Spotify

The goal is to be able to add podcasts on Spotify to gPodder. Downloading the episodes will *not* be possible, but being notified of new episodes.

## Tested with

* gPodder 3.10.16 on Ubuntu 18.04 with Python 3.6.9/3.8.0
* gPodder 3.10.1 on Ubuntu 18.04 with Python 3.6.9/3.8.0

## Install

1. Copy `spotify.py` to `$HOME/gPodder/Extensions/`. Create the directory if it does not exist.
2. Create a Spotify account if you don't have one.
3. Create an application entry on: https://developer.spotify.com/dashboard/applications
4. From your application copy the Client ID and Client Secret and assign them in `spotify.py` to the variables `SPOTIFY_CLIENT_ID` and `SPOTIFY_CLIENT_SECRET` respectively.

## Uninstall

1. Remove the file `spotify.py` from `$HOME/gPodder/Extensions/`.
2. Remove the file `spotify_cache` from `$HOME/gPodder/`.

## TODO

* Load *all* episodes of a show, not just the last 50
	* The show info response contains the total number of episodes as "total"
* Login window: Close after success, show message
* "gtk-open" in context menu should not mark an episode as played (remove entry altogether?)
* Test again with gPodder 3.10.16

repository: sebadorn/gpodder-spotify-extension

repo_name: sebadorn/gpodder-spotify-extension


text:
# Integrations

Integrations are components that provide integration to other services in the Castle stack. At present there are two integrations available in MonoRail:

* [ActiveRecord Integration](activerecord-integration.md)
* [Windsor Integration](windsor-integration.md)

repository: qinfengzhu/MonoRail

repo_name: qinfengzhu/MonoRail


text:
# Auto Where MySQL for PHP

This package to create the where part of your MySQL queries from a simple form submission, and everything automatically.

## Install

```
composer require virgiliopontes/autowheremysql
```
<!--
## Introduction

This package aims to be a solution to compile and process JasperReports (.jrxml & .jasper files).

### Why?

Did you ever had to create a good looking Invoice with a lot of fields for your great web app?

I had to, and the solutions out there were not perfect. Generating *HTML* + *CSS* to make a *PDF*? WTF? That doesn't make any sense! :)

Then I found **JasperReports** the best open source solution for reporting.

### What can I do with this?

Well, everything. JasperReports is a powerful tool for **reporting** and **BI**.

**From their website:**

> The JasperReports Library is the world's most popular open source reporting engine. It is entirely written in Java and it is able to use data coming from any kind of data source and produce pixel-perfect documents that can be viewed, printed or exported in a variety of document formats including HTML, PDF, Excel, OpenOffice and Word.

I recommend using [Jaspersoft Studio](http://community.jaspersoft.com/project/jaspersoft-studio) to build your reports, connect it to your datasource (ex: MySQL), loop thru the results and output it to PDF, XLS, DOC, RTF, ODF, etc.

*Some examples of what you can do:*

* Invoices
* Reports
* Listings -->

## Examples

### The *Hello World* example.

Go to the examples directory in the root of the repository (`vendor/virgiliopontes/autowheremysql/examples`).

Open the `index.php` with your favorite text editor and take a look at the source code.

#### Open the browser

Navigate to the directory where the `index.php` is allocated.

**Exemple**
```
http://<IP_ADDRESS>/vendor/virgiliopontes/autowheremysql/
```

**Note:** You need to replace `<IP_ADDRESS>` with the machine address where the example is

## Installation

### Composer

Install [Composer](http://getcomposer.org) if you don't have it.

```
composer require virgiliopontes/autowheremysql
```

Or in your `composer.json` file add:

```javascript
{
    "require": {
		"virgiliopontes/autowheremysql": "~2",
    }
}
```

And the just run:

	composer update

and thats it.

### Using

Uses in Controller by adding `use AutoWhere/AutoWhereMysql` after namespace
```php
<?php
namespace App\Controllers;

use AutoWhere\AutoWhereMysql; //<--- Here

class YourClass
{
	//...

    public function YourMethod()
    {
        $autoWhereMysql = new AutoWhere\AutoWhereMysql();
        if(isset($_POST['campofiltro'])){
            $where = $autoWhereMysql->make_where($_POST['campofiltro'],$_POST['operador'],$_POST['valorfiltro']);
            echo $where;
        }

    }
}
```
<!--
## Performance

Depends on the complexity, amount of data and the resources of your machine (let me know your use case).

I have a report that generates a *Invoice* with a DB connection, images and multiple pages and it takes about **3/4 seconds** to process. I suggest that you use a worker to generate the reports in the background.

## Thanks

Thanks to [Cenote GmbH](http://www.cenote.de/) for the [JasperStarter](http://jasperstarter.sourceforge.net/) tool.
 -->
## Questions?

Call me on Twitter [@virgiliopontes](https://twitter.com/virgiliopontes).

## License

MIT

repository: virgiliopontes/autowheremysql

repo_name: virgiliopontes/autowheremysql


text:
# Connectwise::BoardExcludedMembersApi

All URIs are relative to *https://api-na.myconnectwise.net/v4_6_release/apis/3.0*

Method | HTTP request | Description
------------- | ------------- | -------------
[**service_boards_id_excluded_members_count_get**](BoardExcludedMembersApi.md#service_boards_id_excluded_members_count_get) | **GET** /service/boards/{id}/excludedMembers/count |
[**service_boards_id_excluded_members_excluded_member_id_delete**](BoardExcludedMembersApi.md#service_boards_id_excluded_members_excluded_member_id_delete) | **DELETE** /service/boards/{id}/excludedMembers/{excludedMemberId} |
[**service_boards_id_excluded_members_excluded_member_id_get**](BoardExcludedMembersApi.md#service_boards_id_excluded_members_excluded_member_id_get) | **GET** /service/boards/{id}/excludedMembers/{excludedMemberId} |
[**service_boards_id_excluded_members_get**](BoardExcludedMembersApi.md#service_boards_id_excluded_members_get) | **GET** /service/boards/{id}/excludedMembers |
[**service_boards_id_excluded_members_post**](BoardExcludedMembersApi.md#service_boards_id_excluded_members_post) | **POST** /service/boards/{id}/excludedMembers |

# **service_boards_id_excluded_members_count_get**
> Count service_boards_id_excluded_members_count_get(id, opts)

Get Excluded Members Count

### Example
```ruby
# load the gem
require 'connectwise-ruby-sdk'
# setup authorization
Connectwise.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'YOUR USERNAME'
  config.password = 'YOUR PASSWORD'
end

api_instance = Connectwise::BoardExcludedMembersApi.new

id = 56 # Integer |

opts = {
  conditions: "conditions_example" # String |
}

begin
  result = api_instance.service_boards_id_excluded_members_count_get(id, opts)
  p result
rescue Connectwise::ApiError => e
  puts "Exception when calling BoardExcludedMembersApi->service_boards_id_excluded_members_count_get: #{e}"
end
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Integer**|  |
 **conditions** | **String**|  | [optional]

### Return type

[**Count**](Count.md)

### Authorization

[BasicAuth](../README.md#BasicAuth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

# **service_boards_id_excluded_members_excluded_member_id_delete**
> service_boards_id_excluded_members_excluded_member_id_delete(id, excluded_member_id)

Delete Excluded Member By Id

### Example
```ruby
# load the gem
require 'connectwise-ruby-sdk'
# setup authorization
Connectwise.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'YOUR USERNAME'
  config.password = 'YOUR PASSWORD'
end

api_instance = Connectwise::BoardExcludedMembersApi.new

id = 56 # Integer |

excluded_member_id = 56 # Integer |

begin
  api_instance.service_boards_id_excluded_members_excluded_member_id_delete(id, excluded_member_id)
rescue Connectwise::ApiError => e
  puts "Exception when calling BoardExcludedMembersApi->service_boards_id_excluded_members_excluded_member_id_delete: #{e}"
end
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Integer**|  |
 **excluded_member_id** | **Integer**|  |

### Return type

nil (empty response body)

### Authorization

[BasicAuth](../README.md#BasicAuth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: Not defined

# **service_boards_id_excluded_members_excluded_member_id_get**
> ExcludedMember service_boards_id_excluded_members_excluded_member_id_get(id, excluded_member_id)

Get Excluded Member By Id

### Example
```ruby
# load the gem
require 'connectwise-ruby-sdk'
# setup authorization
Connectwise.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'YOUR USERNAME'
  config.password = 'YOUR PASSWORD'
end

api_instance = Connectwise::BoardExcludedMembersApi.new

id = 56 # Integer |

excluded_member_id = 56 # Integer |

begin
  result = api_instance.service_boards_id_excluded_members_excluded_member_id_get(id, excluded_member_id)
  p result
rescue Connectwise::ApiError => e
  puts "Exception when calling BoardExcludedMembersApi->service_boards_id_excluded_members_excluded_member_id_get: #{e}"
end
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Integer**|  |
 **excluded_member_id** | **Integer**|  |

### Return type

[**ExcludedMember**](ExcludedMember.md)

### Authorization

[BasicAuth](../README.md#BasicAuth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

# **service_boards_id_excluded_members_get**
> Array<ExcludedMember> service_boards_id_excluded_members_get(id, opts)

Get Excluded Members

### Example
```ruby
# load the gem
require 'connectwise-ruby-sdk'
# setup authorization
Connectwise.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'YOUR USERNAME'
  config.password = 'YOUR PASSWORD'
end

api_instance = Connectwise::BoardExcludedMembersApi.new

id = 56 # Integer |

opts = {
  conditions: "conditions_example" # String |
  order_by: "order_by_example", # String |
  page: 56, # Integer |
  page_size: 56 # Integer |
}

begin
  result = api_instance.service_boards_id_excluded_members_get(id, opts)
  p result
rescue Connectwise::ApiError => e
  puts "Exception when calling BoardExcludedMembersApi->service_boards_id_excluded_members_get: #{e}"
end
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Integer**|  |
 **conditions** | **String**|  | [optional]
 **order_by** | **String**|  | [optional]
 **page** | **Integer**|  | [optional]
 **page_size** | **Integer**|  | [optional]

### Return type

[**Array<ExcludedMember>**](ExcludedMember.md)

### Authorization

[BasicAuth](../README.md#BasicAuth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

# **service_boards_id_excluded_members_post**
> ExcludedMember service_boards_id_excluded_members_post(id, excluded_member)

Create Excluded Member

### Example
```ruby
# load the gem
require 'connectwise-ruby-sdk'
# setup authorization
Connectwise.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'YOUR USERNAME'
  config.password = 'YOUR PASSWORD'
end

api_instance = Connectwise::BoardExcludedMembersApi.new

id = 56 # Integer |

excluded_member = Connectwise::ExcludedMember.new # ExcludedMember |

begin
  result = api_instance.service_boards_id_excluded_members_post(id, excluded_member)
  p result
rescue Connectwise::ApiError => e
  puts "Exception when calling BoardExcludedMembersApi->service_boards_id_excluded_members_post: #{e}"
end
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Integer**|  |
 **excluded_member** | [**ExcludedMember**](ExcludedMember.md)|  |

### Return type

[**ExcludedMember**](ExcludedMember.md)

### Authorization

[BasicAuth](../README.md#BasicAuth)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

repository: jordanbyron/connectwise-ruby-sdk

repo_name: jordanbyron/connectwise-ruby-sdk


text:
# TLS Server

This codebase is currently an experiment in writing a simple TLS server, using OpenSSL, pThreads, and Epoll.

## Building the TLS Server

### Requirements

OpenSSL-Headers (openssl-dev), make, lex (flex), yacc (bison), and a C compiler.

### Compiling

    make

or

    PERF=1 make

The ladder turning on some serious code optimizations.

repository: dmolik/tls-server

repo_name: dmolik/tls-server


text:
---
layout: article
titles:
  en      : &EN       Typing bacteria using MLST (via UNIX)
  en-GB   : *EN
  en-US   : *EN
  en-CA   : *EN
  en-AU   : *EN
key: page-Typing-MLST
---

*	In this worksheet you will learn how to use the MLST tool to type a bacterial genome via UNIX/Conda

## Suggested prerequisites
* It is recommended that you have followed the [Concepts in Computer Programming](https://conmeehan.github.io/PathogenDataCourse/ConceptsInComputerProgramming) and [UNIX tutorial (basics)](https://conmeehan.github.io/UNIXtutorial) tutorials before starting.
* A knowledge of the MLST tool is useful. You can access the manuals [here](https://github.com/tseemann/mlst)
* Installing MLST through conda is easiest so its suggested you have followed the [Setting up and using conda](https://conmeehan.github.io/PathogenDataCourse/CondaInstallAndUse) tutorial.

## Dataset
*	This demonstration uses the output of [Assembling a genome from short reads (e.g. Illumina) using SPAdes](https://conmeehan.github.io/PathogenDataCourse/Worksheets/GenomeAssembly_SPAdes) worksheet but this will work on any assembly, such as that created in the [Assembling a genome from long reads (e.g. ONT) using Flye](https://conmeehan.github.io/PathogenDataCourse/Worksheets/GenomeAssembly_Flye) worksheet. Thus, it is suggested you run at least one of these assembly methods first.
	* You can download the example scaffolds output file of the SPAdes worksheet here: [DRR187559_scaffolds.fasta](https://conmeehan.github.io/PathogenDataCourse/Datasets/DRR187559_scaffolds.fasta)

## Steps
1. Create a directory for your analyses and step into it

```c
mkdir mlst_demo
cd mlst_demo
```

2. Copy your assembled genome into this folder or download the [sample data](https://conmeehan.github.io/PathogenDataCourse/Datasets/DRR187559_scaffolds.fasta)
* You can save this directly to your terminal current working directory by using the wget command ([wget](https://anaconda.org/anaconda/wget) can be installed via conda).

```c
wget https://conmeehan.github.io/PathogenDataCourse/Datasets/DRR187559_scaffolds.fasta
```

3. Install MLST using conda
  * It is recommended to always install packages in their own environments so here will we create an enironment and install MLST in one step.

```c
mamba create -n mlst -c bioconda mlst -y
mamba activate mlst
```

4. Run MLST on the scaffolds file
* MLST auto detects the correct species scheme to use for your data
	* You can specify a scheme by adding the `--scheme` option. You can see a list of all schemes using `mlst --longlist`
* `--threads` is the number of threads to dedicate to the process. My computer has 8 threads so I am dedicating 7
* The `>` redirect will put the resulting allele calls to the `_mlst.tsv` file

```c
mlst --threads 7 DRR187559_scaffolds.fasta >DRR187559_mlst.tsv
```

5. View the resulting file
* You will see the sample name, the scheme used (s. aureus 764 in this case) and then the list of the MLST genes and the allele number associated with your input genome
```c
cat DRR187559_mlst.tsv
```
* Guidance on tweaking this output and running multiple genomes at once can be found in the [github page for MLST](https://github.com/tseemann/mlst)

6. Deactivate your mamba environment when finished
```c
mamba deactivate
```


text:
# morph

[![Build Status](https://dev.azure.com/reason-native-web/morph/_apis/build/status/reason-native-web.morph?branchName=master)](https://dev.azure.com/reason-native-web/morph/_build/latest?definitionId=1&branchName=master)

A tiny framework for developing HTTP stuff in reason native using Httpaf and H2.

## Documentation

https://reason-native-web.github.io/

_The documentation is not as fleshed out as it should be, the repos is under heavy development._

## Build and run examples

```
esy install
esy build
esy examples
$(esy examples-path)/hello_world.exe
$(esy examples-path)/with_router.exe
$(esy examples-path)/simple_proxy.exe
```

## Example

**Server:**

```ocaml
let http_server = Morph_server_http.make();
Morph.start(~servers=[http_server], _request => Http.Response.Ok.make)
|> Lwt_main.run;
```

Slightly larger example using ocaml-routes: https://github.com/reason-native-web/morph/blob/master/examples/with_router.re

## Sponsors

Thank you to [@imbsky](https://github.com/imbsky) for sponsoring my work on Morph

repository: reason-native-web/morph

gha_language: Reason

gha_license_id: MIT

repo_name: reason-native-web/morph


text:
# Return statement outside function
In JavaScript, `return` statements are not allowed outside functions in most cases, the main exception being event handler code in HTML attributes. On the other hand, `return` is not allowed in `javascript:` URLs, and will cause a runtime exception on many browsers.

## Recommendation
Investigate the code to see whether the `return` statement should be nested in a function.

## Example
In the following HTML snippet, a developer has implemented a function `validateForm` that should be invoked when the form is submitted to check its contents for wellformedness, and prevent submission if validation fails. The developer attempts to achieve this by invoking `validateForm` through a `javascript:` URL in the form's `action` attribute:

```html
<form name="f" action="javascript:return validateForm(this);" method="post">
    <!--  form contents -->
</form>
```
This will not work in practice, since the `return` causes a syntax error. Instead, the validation should be moved to the `onsubmit` event handler, where a `return` statement is legal:

```html
<form name="f" onsubmit="return validateForm(this);" method="post">
    <!--  form contents -->
</form>
```

## References
* Mozilla Developer Network: [Return](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return).


text:
---
title: FuseBox 1,1
layout: post
author: henry.barnard
permalink: /fusebox-1,1/
source-id: 1WwWugrEW3msd2dVBoVLmMEFd9QzOJRgWIs8sGIua358
published: true
---

    Title
    Fuse Week 2
    Date
    13/09/16

    Starting point:
    Fuse 1-1

    Target for the lesson?
    Understanding the basics - BASIC

    Did I reach my target?
(add details to "Lesson Review")
    Yes I did because now I understand the basics so I can do harder activities

    Lesson Review

    How did I learn? What strategies were effective?

    I learnt by reading the booklet and by talking to my partner and then we typed the answer/ solution up onto our monitor. I found this useful and effective. I found it effective because we talked about it so we we very positive about us having the right answer.

    What limited my learning? Which habits do I need to work on?

    I think I took too long and that is why I had very limited learning time to do the work. Luckily we finished the task set with a few minutes to spare. But next lesson I would want to cover a lot more in the lesson but to do so I have to be a lot quicker.

    What will I change for next time? How will I improve my learning?

    I will improve my learning by getting the fusebox ready quicker because we got the fusebox up and running after 8 minutes. That needs to be a lot shorter next time because if it takes 8 minutes to get set up, then it takes 8 minutes to pack up then it takes 16 minutes all together. This is bad because it takes a quarter of the lesson to get ready and pack up. This takes away our learning time quickly and therefore we don't learn as much.


text:
---
layout: post
title:  "How to setup a Serilog OutputTemplate and Console Theme"
date:   2020-09-05  12:00:00 +0200
categories: Serilog .Net Core JSON
---
Sometimes it is hard to read a kestrel console log and find errors or warnings when you are debugging your app.
With Serilog you can set themes for the console and it can color code what the important identifiers can be.
But also you can format the order of the different pieces of information shown on each logline.

{% highlight js %}
"outputTemplate": "[{Timestamp:o} {Level:u4}] {{{RequestId}}} {Message} {NewLine}{Exception}"
{% endhighlight %}

The output template would be an argument that you can use in the ```appsettings.json```
and it would be used to show exactly what formats the logline from left to right.
\
[Click here for more info on output templates](https://nblumhardt.com/2014/05/serilog-output-template-formatting-changes)
\
Also within the arguments block, you can set up a couple of different themes.
The one I enjoy is the ```AnsiConsoleTheme``` it showcases the colors red for error and yellow for warning really well.

{% highlight js %}
"theme":"Serilog.Sinks.SystemConsole.Themes.AnsiConsoleTheme::Code, Serilog.Sinks.Console"
{% endhighlight %}
\
[Click here for more info on console themes](https://nblumhardt.com/2017/06/ansi-console)
\
So with both of these settings, you can combine them in a Serilog JSON object to output to a console.

{% highlight js %}
"Serilog": {
  "WriteTo": [
    {
      "Name": "Console",
      "Args": {
        "theme":"Serilog.Sinks.SystemConsole.Themes.AnsiConsoleTheme::Code, Serilog.Sinks.Console",
        "outputTemplate": "[{Timestamp:o} {Level:u4}] {{{RequestId}}} {Message} {NewLine}{Exception}"
      }
    }
  ]
}
{% endhighlight %}

Of course you can adjust the parameters listed in the outputTemplate to show the way you like in the logs.


text:
---
title: Additional items for IBlogIt
disqus_identifier: 2003-04-additional-items-for-iblogit
comments: true
---

Greg brings up some [valid points][1]. A few ideas I have are detailed below.

In the case of MovableType, as Im sure is the case with other blog software, there are numerous properties available when submitting a new post. Take for example:

* Category
* Convert Line Breaks
* Allow Comments
* Allow Pings
* Additional Entry Text
* Excerpt Entry Text
* Keywords

Given this, and the fact that the aggregator should be able to display its own interface in the case of HasEditingGUI() returning false, should there be some method allowed to make these properties and whatever values available via this interface as well?

Im thinking something along the lines of:

``` csharp
public interface IBlogThisEx : IBlogThis
{
  ///...
  BlogPropertyCollection Properties { get; set; }
}

public class BlogPropertyCollection : CollectionBase
{
  ///...
}

public class BlogProperty
{
    private string _name;
    private IEnumerable _values;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public IEnumerable Values
    {
        get { return _values; }
        set { _values = value; }
    }
}
```

Secondly, since exceptions are likely to be thrown back to the aggregator, perhaps there should be a common Exception-derived object that the aggregator can expect. For example:

``` csharp
public class BlogThisException : Exception
{
    // Implementation goes in here
}
```

[1]:http://www.rassoc.com/gregr/weblog/archive.aspx?post=578

gha_language: JavaScript


text:
# CHSesame2Status
```Swift
    noSignal
    receiveBle
    connecting
    reset
    waitgatt
    logining
    readytoRegister
    locked
    unlocked
    moved
    nosetting
```
## If unregistered

| action/status | noSignal  | receiveBle  | connecting    | readytoRegister | nosetting  |
|:-------------:|:---------:|:-----------:|:-------------:|:---------------:|:----------:|
|  close to Sesame2 |receiveBle |             |               |                 |            |
|  connect      |           | connecting  |               |                 |            |
|  connecting   |           |             |readytoRegister|                 |            |
|  register     |           |             |               | nosetting       |            |
|  configureLockPosition    |    |        |               |                 | locked/unlocked(registered)|
|  disconnect   |           |             |            |    noSignal     | noSignal   |

## If registered
| action/status | noSignal  | receiveBle  | connecting  | waitgatt | logining | locked/unlocked  |nosetting  |
|:-------------:|:---------:|:-----------:|:-----------:|:--------:|:---------------:|:----------:|:----------:|
|  close to Sesame2 |receiveBle |             |             |          |                 |            |            |
|  connect      |           | connecting  |             |          |                 |            |            |
|  connecting   |           |             | waitgatt    |          |                 |            |            |
|  waitgatt     |           |             |             | logining |                 |            |            |
|  logining     |           |             |             |         | locked/unlocked/nosetting |   |            |
|  lock         |           |             |             |         |                 | unlocked         |  |
|  unlock       |           |             |           |        |                 | locked         |  |
|  toggle       |           |             |           |        |                 | unlocked/locked   |  |
|  disconnect   |            |            |           |          | noSignal   |noSignal   |noSignal   |


text:
Powered by the Crunchy [PostgreSQL Operator](https://github.com/CrunchyData/postgres-operator), Crunchy PostgreSQL
for Kubernetes automates and simplifies deploying and managing open source PostgreSQL clusters on Kubernetes by providing the
essential features you need to keep your PostgreSQL clusters up and running, including:

- **PostgreSQL Cluster Provisioning**: [Create, Scale, & Delete PostgreSQL clusters with ease][provisioning],
while fully customizing your Pods and PostgreSQL configuration!
- **High-Availability**: Safe, automated failover backed by a [distributed consensus based high-availability solution][high-availability].
Uses [Pod Anti-Affinity][anti-affinity] to help resiliency; you can configure how aggressive this can be!
Failed primaries automatically heal, allowing for faster recovery time. You can even create regularly scheduled
backups as well and set your backup retention policy
- **Disaster Recovery**: Backups and restores leverage the open source [pgBackRest][] utility
and [includes support for full, incremental, and differential backups as well as efficient delta restores][disaster-recovery].
Set how long you want your backups retained for. Works great with very large databases!
- **Monitoring**: Track the health of your PostgreSQL clusters using the open source [pgMonitor][] library.
- **Clone**: Create new clusters from your existing clusters with a simple [`pgo clone`][pgo-clone] command.
- **Full Customizability**: Crunchy PostgreSQL for Kubernetes makes it easy to get your own PostgreSQL-as-a-Service up and running on
and lets make further enhancements to customize your deployments, including:
  - Selecting different storage classes for your primary, replica, and backup storage
  - Select your own container resources class for each PostgreSQL cluster deployment; differentiate between resources applied for primary and replica clusters!
  - Use your own container image repository, including support `imagePullSecrets` and private repositories
  - Bring your own trusted certificate authority (CA) for use with the Operator API server
  - Override your PostgreSQL configuration for each cluster

and much more!

[anti-affinity]: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#inter-pod-affinity-and-anti-affinity
[disaster-recovery]: https://access.crunchydata.com/documentation/postgres-operator/latest/architecture/disaster-recovery/
[high-availability]: https://access.crunchydata.com/documentation/postgres-operator/latest/architecture/high-availability/
[pgo-clone]: https://access.crunchydata.com/documentation/postgres-operator/latest/pgo-client/reference/pgo_clone/
[provisioning]: https://access.crunchydata.com/documentation/postgres-operator/latest/architecture/provisioning/

[pgBackRest]: https://www.pgbackrest.org
[pgMonitor]: https://github.com/CrunchyData/pgmonitor

## Before You Begin

There are a few manual steps that the cluster administrator must perform prior to installing the PostgreSQL Operator.
At the very least, it must be provided with an initial configuration.

First, select a namespace in which to install the PostgreSQL Operator. PostgreSQL clusters will also be deployed here.
If it does not exist, create it now.

```
export PGO_OPERATOR_NAMESPACE=pgo
kubectl create namespace "$PGO_OPERATOR_NAMESPACE"
```

Next, clone the PostgreSQL Operator repository locally.

```
git clone -b v${PGO_VERSION} https://github.com/CrunchyData/postgres-operator.git
cd postgres-operator
```

### PostgreSQL Operator Configuration

Edit `conf/postgres-operator/pgo.yaml` to configure the deployment. Look over all of the options and make any
changes necessary for your environment. A [full description of each option][pgo-yaml-reference] is available in the documentation.

[pgo-yaml-reference]: https://access.crunchydata.com/documentation/postgres-operator/${PGO_VERSION}/configuration/pgo-yaml-configuration/

When the file is ready, upload the entire directory to the `pgo-config` ConfigMap.

```
kubectl -n "$PGO_OPERATOR_NAMESPACE" create configmap pgo-config \
  --from-file=./conf/postgres-operator
```

### Secrets

Configure pgBackRest for your environment. If you do not plan to use AWS S3 to store backups, you can omit
the `aws-s3` keys below.

```
kubectl -n "$PGO_OPERATOR_NAMESPACE" create secret generic pgo-backrest-repo-config \
  --from-file=config=./conf/pgo-backrest-repo/config \
  --from-file=sshd_config=./conf/pgo-backrest-repo/sshd_config \
  --from-file=aws-s3-ca.crt=./conf/pgo-backrest-repo/aws-s3-ca.crt \
  --from-literal=aws-s3-key="<your-aws-s3-key>" \
  --from-literal=aws-s3-key-secret="<your-aws-s3-key-secret>"
```

### Certificates (optional)

The PostgreSQL Operator has an API that uses TLS to communicate securely with clients. If you have
a certificate bundle validated by your organization, you can install it now.  If not, the API will
automatically generate and use a self-signed certificate.

```
kubectl -n "$PGO_OPERATOR_NAMESPACE" create secret tls pgo.tls \
  --cert=/path/to/server.crt \
  --key=/path/to/server.key
```

Once these resources are in place, the PostgreSQL Operator can be installed into the cluster.

## After You Install

Once the PostgreSQL Operator is installed in your Kubernetes cluster, you will need to do a few things
to use the [PostgreSQL Operator Client][pgo-client].

[pgo-client]: https://access.crunchydata.com/documentation/postgres-operator/latest/pgo-client/

Install the first set of client credentials and download the `pgo` binary and client certificates.

```
PGO_CMD=kubectl ./deploy/install-bootstrap-creds.sh
PGO_CMD=kubectl ./installers/kubectl/client-setup.sh
```

The client needs to be able to reach the PostgreSQL Operator API from outside the Kubernetes cluster.
Create an external service or forward a port locally.

```
kubectl -n "$PGO_OPERATOR_NAMESPACE" expose deployment postgres-operator --type=LoadBalancer

export PGO_APISERVER_URL="https://$(
  kubectl -n "$PGO_OPERATOR_NAMESPACE" get service postgres-operator \
    -o jsonpath="{.status.loadBalancer.ingress[*]['ip','hostname']}"
):8443"
```
_or_
```
kubectl -n "$PGO_OPERATOR_NAMESPACE" port-forward deployment/postgres-operator 8443

export PGO_APISERVER_URL="https://<IP_ADDRESS>:8443"
```

Verify connectivity using the `pgo` command.

```
pgo version
# pgo client version ${PGO_VERSION}
# pgo-apiserver version ${PGO_VERSION}
```


text:
+++
title = "Python: Tuble"
weight = 3
+++

In this article, you'll learn everything about Python tuples. More specifically, what are tuples, how to create them, when to use them and various methods you should be familiar with.

A tuple in Python is similar to a  [list](https://www.programiz.com/python-programming/list). The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas we can change the elements of a list.

----------

## Creating a Tuple

A tuple is created by placing all the items (elements) inside parentheses  `()`, separated by commas. The parentheses are optional, however, it is a good practice to use them.

A tuple can have any number of items and they may be of different types (integer, float, list,  [string](https://www.programiz.com/python-programming/string), etc.).

```py
# Different types of tuples

# Empty tuple
my_tuple = ()
print(my_tuple)

# Tuple having integers
my_tuple = (1, 2, 3)
print(my_tuple)

# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
print(my_tuple)

# nested tuple
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)
```

**Output**
```text
()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))
```
A tuple can also be created without using parentheses. This is known as tuple packing.

```py
my_tuple = 3, 4.6, "dog"
print(my_tuple)

# tuple unpacking is also possible
a, b, c = my_tuple

print(a)      # 3
print(b)      # 4.6
print(c)      # dog
```

**Output**
```text
(3, 4.6, 'dog')
3
4.6
dog
```
Creating a tuple with one element is a bit tricky.

Having one element within parentheses is not enough. We will need a trailing comma to indicate that it is, in fact, a tuple.

```py
my_tuple = ("hello")
print(type(my_tuple))  # <class 'str'>

# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple))  # <class 'tuple'>

# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple))  # <class 'tuple'>
```

**Output**
```text
<class 'str'>
<class 'tuple'>
<class 'tuple'>
```
----------

## Access Tuple Elements

There are various ways in which we can access the elements of a tuple.

### 1. Indexing

We can use the index operator  `[]`  to access an item in a tuple, where the index starts from 0.

So, a tuple having 6 elements will have indices from 0 to 5. Trying to access an index outside of the tuple index range(6,7,... in this example) will raise an  `IndexError`.

The index must be an integer, so we cannot use float or other types. This will result in  `TypeError`.

Likewise, nested tuples are accessed using nested indexing, as shown in the example below.

```py
# Accessing tuple elements using indexing
my_tuple = ('p','e','r','m','i','t')

print(my_tuple[0])   # 'p'
print(my_tuple[5])   # 't'

# IndexError: list index out of range
# print(my_tuple[6])

# Index must be an integer
# TypeError: list indices must be integers, not float
# my_tuple[2.0]

# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# nested index
print(n_tuple[0][3])       # 's'
print(n_tuple[1][1])       # 4
```

**Output**
```text
p
t
s
4
```
----------

### 2. Negative Indexing

Python allows negative indexing for its sequences.

The index of -1 refers to the last item, -2 to the second last item and so on.

```py
# Negative indexing for accessing tuple elements
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')

# Output: 't'
print(my_tuple[-1])

# Output: 'p'
print(my_tuple[-6])
```

**Output**
```text
t
p
```
----------

### 3. Slicing

We can access a range of items in a tuple by using the slicing operator colon  `:`.

```py
# Accessing tuple elements using slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')

# elements 2nd to 4th
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])

# elements beginning to 2nd
# Output: ('p', 'r')
print(my_tuple[:-7])

# elements 8th to end
# Output: ('i', 'z')
print(my_tuple[7:])

# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])
```

**Output**
```text
('r', 'o', 'g')
('p', 'r')
('i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
```
Slicing can be best visualized by considering the index to be between the elements as shown below. So if we want to access a range, we need the index that will slice the portion from the tuple.

![Element Slicing in Python](https://cdn.programiz.com/sites/tutorial2program/files/element-slicling.jpg "Element Slicing")

Element Slicing in Python

----------

## Changing a Tuple

Unlike lists, tuples are immutable.

This means that elements of a tuple cannot be changed once they have been assigned. But, if the element is itself a mutable data type like list, its nested items can be changed.

We can also assign a tuple to different values (reassignment).

```py
# Changing tuple values
my_tuple = (4, 2, 3, [6, 5])

# TypeError: 'tuple' object does not support item assignment
# my_tuple[1] = 9

# However, item of mutable element can be changed
my_tuple[3][0] = 9    # Output: (4, 2, 3, [9, 5])
print(my_tuple)

# Tuples can be reassigned
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)
```

**Output**
```text
(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
```
We can use  `+`  operator to combine two tuples. This is called  **concatenation**.

We can also  **repeat**  the elements in a tuple for a given number of times using the  `*`  operator.

Both  `+`  and  `*`  operations result in a new tuple.

```py
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))

# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)
```

**Output**
```text
(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat')
```
----------

## Deleting a Tuple

As discussed above, we cannot change the elements in a tuple. It means that we cannot delete or remove items from a tuple.

Deleting a tuple entirely, however, is possible using the keyword  [del](https://www.programiz.com/python-programming/keyword-list#del).

```py
# Deleting tuples
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# can't delete items
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]

# Can delete an entire tuple
del my_tuple

# NameError: name 'my_tuple' is not defined
print(my_tuple)
```

**Output**
```text
Traceback (most recent call last):
  File "<string>", line 12, in <module>
NameError: name 'my_tuple' is not defined
```
----------

## Tuple Methods

Methods that add items or remove items are not available with tuple. Only the following two methods are available.

Some examples of Python tuple methods:

```py
my_tuple = ('a', 'p', 'p', 'l', 'e',)

print(my_tuple.count('p'))  # Output: 2
print(my_tuple.index('l'))  # Output: 3
```

**Output**
```text
2
3
```
----------

## Other Tuple Operations

### 1. Tuple Membership Test

We can test if an item exists in a tuple or not, using the keyword  `in`.

```py
# Membership test in tuple
my_tuple = ('a', 'p', 'p', 'l', 'e',)

# In operation
print('a' in my_tuple)
print('b' in my_tuple)

# Not in operation
print('g' not in my_tuple)
```

**Output**
```text
True
False
True
```
----------

### 2. Iterating Through a Tuple

We can use a  `for`  loop to iterate through each item in a tuple.

```py
# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
    print("Hello", name)
```

**Output**
```text
Hello John
Hello Kate
```
----------

### Advantages of Tuple over List

Since tuples are quite similar to lists, both of them are used in similar situations. However, there are certain advantages of implementing a tuple over a list. Below listed are some of the main advantages:

-   We generally use tuples for heterogeneous (different) data types and lists for homogeneous (similar) data types.
-   Since tuples are immutable, iterating through a tuple is faster than with list. So there is a slight performance boost.
-   Tuples that contain immutable elements can be used as a key for a dictionary. With lists, this is not possible.
-   If you have data that doesn't change, implementing it as tuple will guarantee that it remains write-protected.

> Source : https://www.programiz.com/python-programming/tuple

repository: yo-sarawut/markdown

repo_name: yo-sarawut/markdown


text:
Puppet module for installing the Pypy from the official PPA.
This module is also available on the [Puppet
Forge](https://forge.puppetlabs.com/garethr/pypy)

[![Build
Status](https://secure.travis-ci.org/garethr/garethr-pypy.png)](http://travis-ci.org/garethr/garethr-pypy)

## Usage

The module includes a single class:

    include 'pypy'

By default this sets up the PPA and installs the pypy package. If you
want to keep up-to-date with the latest version, or specific a specific
version, you can do so:

    class { 'pypy':
      version => latest,
    }

repository: garethr/garethr-pypy

repo_name: garethr/garethr-pypy


text:
# Assignments

Assignments are listed below. Unless otherwise stated, they should be submitted
via Moodle.

  - [Graduate Project](graduate-project.html)

## Homework

  1. [Homework 0](homework-00.html)
  2. [Homework 1](homework-01.html)
  3. [Homework 2](homework-02.html)
  4. [Homework 3](homework-03.html)

repository: esther-lyondelsordo/missing-course

repo_name: esther-lyondelsordo/missing-course


text:
popcount
========

This script is used to count the popularity for each package in `nixpkgs`, by
determining how many other packages depend on it.

It skips over all packages that fail to build, are not cached or are unfree -
but these omissions do not meaningfully affect the statistics.

It currently does not evaluate nested attribute sets (such as
`haskellPackages`).

## Usage

1. Generate a list of all top-level attributes in `nixpkgs`:

   ```shell
   nix eval '(with builtins; toJSON (attrNames (import <nixpkgs> {})))' | jq -r | jq > all-top-level.json
   ```

2. Run `./popcount > all-runtime-deps.txt`

3. Collect and count the results with the following magic incantation:

   ```shell
   cat all-runtime-deps.txt \
     | sed -r 's|/nix/store/[a-z0-9]+-||g' \
     | sort \
     | uniq -c \
     | sort -n -r \
     | awk '{ print "{\"" $2 "\":" $1 "}"}' \
     | jq -c -s '. | add | with_entries(select(.value > 1))' \
     > your-output-file
   ```

   In essence, this will trim Nix's store paths and hashes from the output,
   count the occurences of each package and return the output as JSON. All
   packages that have no references other than themselves are removed from the
   output.

repository: glittershark/nixery

repo_name: glittershark/nixery


text:
# SQL exporter (free) configuration

To enable [sql_exporter by free](https://github.com/free/sql_exporter) include role task: sql_exporter_free

The configuration content. The example below utilizes a file named 'sql_exporter_free.yml' in your Ansible root directory's 'files' directory. If no configuration content is defined, a default configuration file is utilized. You will want to customize your configuration file content!:

    prometheus_sql_exporter_free_cfg: '{{ lookup("file", "../files/sql_exporter_free.yml") | from_yaml }}'

Alternatively, the configuration file can be defined directly:

    prometheus_sql_exporter_free_cfg:
      global:
        # Subtracted from Prometheus' scrape_timeout to give us some headroom and prevent Prometheus from
        # timing out first.
        scrape_timeout_offset: 500ms
        # Minimum interval between collector runs: by default (0s) collectors are executed on every scrape.
        min_interval: 0s
        # Maximum number of open connections to any one target. Metric queries will run concurrently on
        # multiple connections.
        max_connections: 3
        # Maximum number of idle connections to any one target.
        max_idle_connections: 3

      # The target to monitor and the list of collectors to execute on it.
      target:
        # Data source name always has a URI schema that matches the driver name. In some cases (e.g. MySQL)
        # the schema gets dropped or replaced to match the driver expected DSN format.
        data_source_name: 'sqlserver://prom_user:prom_password@dbserver1.example.com:1433'

An array of additional flags to pass to the sql_exporter daemon:

    prometheus_sql_exporter_free_extra_opts: []

The version of sql_exporter_free to install. The default version can be found in the [sql_exporter_free variables file](../vars/software/sql_exporter_free.yml) and the default version can be overridden using the following variable:

    prometheus_sql_exporter_free_version: "v1.0.0"

Allow the use of prerelease versions (beta, test, development, etc versions), defaults to 'false':

    prometheus_sql_exporter_free_use_prerelease: true

Port and IP to listen on. Defaults to listening on all available IPs on port 9399:

    prometheus_sql_exporter_free_host: "<IP_ADDRESS>"
    prometheus_sql_exporter_free_port: 9399

repository: mesaguy/ansible-prometheus

gha_language: Ruby

repo_name: mesaguy/ansible-prometheus


text:
# Bandai - WonderSwan/Color (Beetle Cygne)

## Background

Standalone port of Mednafen WonderSwan to libretro, itself a fork of Cygne.

### Author/License

The Beetle Cygne core has been authored by

- Dox
- [Mednafen Team](https://mednafen.github.io/)

The Beetle Cygne core is licensed under

- [GPLv2](https://github.com/libretro/beetle-wswan-libretro/blob/master/COPYING)

A summary of the licenses behind RetroArch and its cores can be found [here](../development/licenses.md).

## Extensions

Content that can be loaded by the Beetle Cygne core have the following file extensions:

- .ws
- .wsc
- .pc2 (Benesse Pocket Challenge v2 files)

## Databases

RetroArch database(s) that are associated with the Beetle Cygne core:

- [Bandai - WonderSwan](https://github.com/libretro/libretro-database/blob/master/rdb/Bandai%20-%20WonderSwan.rdb)
- [Bandai - WonderSwan Color](https://github.com/libretro/libretro-database/blob/master/rdb/Bandai%20-%20WonderSwan%20Color.rdb)

## Features

Frontend-level settings or features that the Beetle Cygne core respects.

| Feature           | Supported |
|-------------------|:---------:|
| Restart           | ✔         |
| Screenshots       | ✔         |
| Saves             | ✔         |
| States            | ✔         |
| Rewind            | ✔         |
| Netplay           | ✔ (not link-cable emulation)         |
| Core Options      | ✕         |
| RetroAchievements | ✔         |
| RetroArch Cheats  | ✕         |
| Native Cheats     | ✕         |
| Controls          | ✔         |
| Remapping         | ✔         |
| Multi-Mouse       | ✕         |
| Rumble            | ✕         |
| Sensors           | ✕         |
| Camera            | ✕         |
| Location          | ✕         |
| Subsystem         | ✕         |
| [Softpatching](../guides/softpatching.md) | ✔         |
| Disk Control      | ✕         |
| Username          | ✕         |
| Language          | ✕         |
| Crop Overscan     | ✕         |
| LEDs              | ✕         |

### Directories

The Beetle Cygne core's internal core name is 'Beetle WonderSwan'

The Beetle Cygne core saves/loads to/from these directories.

**Frontend's Save directory**

- 'content-name'.srm (Cartridge backup save)

**Frontend's State directory**

- 'content-name'.state# (State)

### Geometry and timing

- The Beetle Cygne core's core provided FPS is 75.47
- The Beetle Cygne core's core provided sample rate is 44100 Hz
- The Beetle Cygne core's core provided aspect ratio is 14/9

## Controllers

The Beetle Cygne core supports the following device type(s) in the controls menu, bolded device types are the default for the specified user(s):

### User 1 device types

- None - Doesn't disable input.
- **RetroPad** - Joypad
- RetroPad w/Analog - There is no reason to switch to this.

### Controller tables

#### Joypad

| User 1 Remap descriptors     | RetroPad Inputs                           |
|------------------------------|-------------------------------------------|
| B                            | ![](../image/retropad/retro_b.png)    |
| Rotate screen + active D-Pad | ![](../image/retropad/retro_select.png)     |
| Start                        | ![](../image/retropad/retro_start.png)      |
| X Cursor Up                  | ![](../image/retropad/retro_dpad_up.png)    |
| X Cursor Down                | ![](../image/retropad/retro_dpad_down.png)  |
| X Cursor Left                | ![](../image/retropad/retro_dpad_left.png)  |
| X Cursor Right               | ![](../image/retropad/retro_dpad_right.png) |
| A                            | ![](../image/retropad/retro_a.png)    |
| Y Cursor Left                | ![](../image/retropad/retro_l1.png)         |
| Y Cursor Right               | ![](../image/retropad/retro_r1.png)         |
| Y Cursor Down                | ![](../image/retropad/retro_l2.png)         |
| Y Cursor Up                  | ![](../image/retropad/retro_r2.png)         |

## Compatibility

| Game      | Issue                                                                        |
|-----------|------------------------------------------------------------------------------|
| Tonpuusou | Title screen announcer voice missing. Softlocks after picking a menu option. |

## External Links

- [Official Mednafen Website](https://mednafen.github.io/)
- [Official Mednafen Downloads](https://mednafen.github.io/releases/)
- [Libretro Beetle Cygne Core info file](https://github.com/libretro/libretro-super/blob/master/dist/info/mednafen_wswan_libretro.info)
- [Libretro Beetle Cygne Github Repository](https://github.com/libretro/beetle-wswan-libretro)
- [Report Libretro Beetle Cygne Core Issues Here](https://github.com/libretro/beetle-wswan-libretro/issues)
- [Gameplay Videos](https://www.youtube.com/playlist?list=PLRbgg4gk_0IdmXFd9hF4bXjsk_zKwT8Yz)

repository: libretro/docs

gha_language: TeX

repo_name: libretro/docs


text:
# Pixpy

[Pixpy live][live]

[live]: http://www.pixpy.tech/

Pixpy is a full-stack photo-sharing web application. It utilizes Django + Django REST Framework for the backend Web API, a PostgreSQL database, and React.js with a Redux architecture on the frontend.

The following is a (not necessarily exhaustive) enumeration of the technologies we build upon:

**Frontend**

* [React](https://github.com/facebook/react)
* [React Router](https://github.com/rackt/react-router)
* [JSON Web Token](https://www.npmjs.com/package/jsonwebtoken) JSON Web Token for API authentication
* [Babel](http://babeljs.io) for ES6 and ES7 magic
* [Webpack](http://webpack.github.io) for bundling
* [Webpack Dev Middleware](http://webpack.github.io/docs/webpack-dev-middleware.html)
* [Redux](https://github.com/rackt/redux)'s [Flux](https://facebook.github.io/react/blog/2014/05/06/flux.html) implementation
* [Redux Dev Tools](https://github.com/rackt/redux-devtools) for next generation DX (developer experience). Watch [Dan Abramov's talk](https://www.youtube.com/watch?v=xsSnOQynTHs)
* [Redux Thunk](https://github.com/gaearon/redux-thunk) Thunk middleware for Redux - used in async actions
* [React Router Redux](https://github.com/rackt/react-router-redux) Ruthlessly simple bindings to keep react-router and redux in sync
* [fetch](https://github.com/github/fetch) A window.fetch JavaScript polyfill
* [style-loader](https://github.com/webpack/style-loader), [sass-loader](https://github.com/jtangelder/sass-loader) and [less-loader](https://github.com/webpack/less-loader) to allow import of stylesheets in plain css, sass and less,
* [font-awesome-webpack](https://github.com/gowravshekar/font-awesome-webpack) to customize FontAwesome, and
* [ESLint](http://eslint.org), [Airbnb Javascript/React Styleguide](https://github.com/airbnb/javascript), [Airbnb CSS / Sass Styleguide](https://github.com/airbnb/css) to maintain a consistent code style

**Backend**

* [Django](https://www.djangoproject.com/)
* [Django REST framework](http://www.django-rest-framework.org/) Django REST framework is a powerful and flexible toolkit for building Web APIs
* [Django REST framework JSON Web Token](http://getblimp.github.io/django-rest-framework-jwt/) JSON Web Token Authentication support for Django REST Framework
* [WhiteNoise](http://whitenoise.evans.io/en/latest/django.html) to serve files efficiently from Django

## Features & Implementation

### Single-Page App

Pixpy is a single-page app; all content is delivered on one static page. The UI is designed to be elegant and intuitive with a straightforward layout.

### Albums

Users can see and create photo `Album`s from the `AlbumView` page.

New albums show a default "empty album" cover photo. The first photo uploaded to an album is automatically set as the new album cover photo on the backend.

When a new album is created, the user is immediately directed to the `AlbumDetailView` where they can upload photos to the album. All albums belong to a user via `user_id`. Only the user who initially created an album can upload photos to that album.

### Photos

Users can see and add `Photo`s from the `AlbumDetailView`. Photos are hosted on Cloudinary, and hold a foreign key to the `album_id` they belong to. When a photo is uploaded, a modal pops up displaying the photo and asks for an optional `caption`. Focus is automatically placed on the caption input field, which can be submitted either using the Enter key or by clicking the return button.

From the `AlbumDetailView`, when a user clicks on a photo, it opens in a modal displaying both the image and caption. Clicking anywhere off of the modal closes the modal.

Users can browse and view all albums and photos, but can only add photos to their albums. This restriction is reinforced both on the frontend (the button is not displayed) as well as the backend (the photo will not be saved if the current user is not the creator of the album).

### User Authentication

Pixpy uses a JSON Web Token (JWT) authentication scheme.  JWTs are a compact, self-contained mechanism for securely transmitting information between parties as digitally signed JSON objects.

When a user successfully logs in using her credentials, a JSON Web Token will be returned and persisted to local storage.  This token is then passed in the `Authorization` header of all HTTP requests against protected resources.

Because the token is "self-contained", we are able to write stateless APIs on the backend--after validating the JWT signature, user information is read from the token and protected resources are served appropriately.

repository: rajansg/Pixpy

repo_name: rajansg/Pixpy


text:
---
title: "API"
linkTitle: "API"
date: 2017-01-05
description: >
  A short lead descripton about this content page. It can be **bold** or _italic_ and can be split over multiple paragraphs.
---

# Open Match APIs

This directory contains the API specification files for Open Match. API documenation will be produced in a future version, although the protobuf files offer a concise description of the API calls available, along with arguments and return messages.

* [Protobuf .proto files for all APIs](./protobuf-spec/)

These proto files are copied to the container image during `docker build` for the Open Match core components.  The `Dockerfiles` handle the compilation for you transparently, and copy the resulting `SPEC.pb.go` files to the appropriate place in your final container image.

References:

* [gRPC](https://grpc.io/)
* [Language Guide (proto3)](https://developers.google.com/protocol-buffers/docs/proto3)

Manual gRPC compilation commmand, from the directory containing the proto:
```protoc -I . ./<filename>.proto --go_out=plugins=grpc:.```

# REST compatibility
Follow the guidelines at https://cloud.google.com/endpoints/docs/grpc/transcoding
to keep the gRPC service definitions friendly to REST transcoding. An excerpt:

"Transcoding involves mapping HTTP/JSON requests and their parameters to gRPC
methods and their parameters and return types (we'll look at exactly how you
do this in the following sections). Because of this, while it's possible to
map an HTTP/JSON request to any arbitrary API method, it's simplest and most
intuitive to do so if the gRPC API itself is structured in a
resource-oriented way, just like a traditional HTTP REST API. In other
words, the API service should be designed so that it uses a small number of
standard methods (corresponding to HTTP verbs like GET, PUT, and so on) that
operate on the service's resources (and collections of resources, which are
themselves a type of resource).
These standard methods are List, Get, Create, Update, and Delete."

It is for these reasons we don't have gRPC calls that support bi-directional streaming in Open Match.


text:
---
title: Glossary
...

# Glossary

Inserting a glossary of terms into a document is a common task.  One of the challenging things is
that the terms are inserted all across the document and as a document writer you don't want to have
to add redundant definition information regarding those terms at each place.

Using the glossary plugin, you can define terms anywhere in the document, usually in a glossary
section, and the plugin will do the work of post-processing the document and inserting the necessary
hyperlinks to the terminology documentation and also will add hover over bubbles to enable the
reader to quickly see the meaning of the term.

The glossary definition specification looks like the following. The definitions are marked by `==
term` and below the term you can insert any markdown syntax to explain it, including pictures or
diagrams. This call will define terms and place them into the global glossary build dictionary and
it **will not insert the glossary inline to the existing text**.  The typical usage model is for a
user to explicitly declare the glossary in one place in the document, at the top or the bottom. Each
section of chapter document can append to the list of glossary terms and then the glossary can be
appended at the end as defined in [Printing the Glossary].

The parser will find exact matches of the string. They must be preceded by a space and followed by a
space or punctuation. The search is case-sensitive, so if the word is the first in the sentence, and
it is declared as lower case, it may be ignored.

Supercalifragilisticexpialidocious will be ignored, but supercalifragilisticexpialidocious will be
annotated with a definition. Jabberwocky will be defined, but jabberwocky will not.

When describing an acronym, it is useful to additionally include the expansion of that acronym. The
syntax for this is `== acronym | expansion`. E.g., for this TLA, we will get the expansion in bold
and the rest of the definition below.

## Defining Terms

```glossary
== terminology

The body of terms used with a particular technical application in a subject of study, theory,
profession, etc.

== supercalifragilisticexpialidocious

Used as a nonsense word by children to express approval or to represent the longest word in English.

== hyperlink

A link from a hypertext file or document to another location or file, typically activated by
clicking on a highlighted word or image on the screen.

== TLA | Three Letter Acronym

Commonly used in the corporate environment, knowing this term is critical.

```

The glossary is then rendered as follows (i.e., *it is not rendered by default*).

```glossary
== terminology

The body of terms used with a particular technical application in a subject of study, theory,
profession, etc.

== supercalifragilisticexpialidocious

Used as a nonsense word by children to express approval or to represent the longest word in English.

== hyperlink

A link from a hypertext file or document to another location or file, typically activated by
clicking on a highlighted word or image on the screen.

== TLA | Three Letter Acronym

Commonly used in the corporate environment, knowing this term is critical.

```

## Printing the Glossary

As you can tell from the rendered output, this first instantiation of the glossary is not actually
printed. To get it to print, you must explicitly request the glossary to be shown as follows. In
this example, we have added an extra term to demonstrate how all of the glossary items are collected
into the final output.

```glossary(show=True)
== rendered

verb (used with object)
1.  to cause to be or become; make: to render someone helpless.
2.  to do; perform: to render a service.
3.  to furnish; provide: to render aid.
4.  to exhibit or show (obedience, attention, etc.).
5.  to present for consideration, approval, payment, action, etc., as an account.
6.  to return; to make (a payment in money, kind, or service) as by a tenant to a superior: knights rendering military service to the lord.
7.  to pay as due (a tax, tribute, etc.).

```

```glossary(show=True)
== Jabberwocky

1. A playful imitation of language consisting of invented, meaningless words; nonsense; gibberish.
2. An example of writing or speech consisting of or containing meaningless words.

```

## Parser Corner Cases

The following conditions are all supported:

* Jabberwocky

In parenthesis: (Jabberwocky)

Jabberwocky at the start of the line and at the end: Jabberwocky

With various punctuations: Jabberwocky, Jabberwocky! Jabberwocky. Jabberwocky? "Jabberwocky" and
'Jabberwocky'.

Inside tables:

Term        	 Definition
----        	 ----
Jabberwocky 	 Silliness


text:
# Message

Message is an object that contains the data of a message, plus some info about the message itself. Message is used both for sending and receiving, so it has some *polymorphic* logic in place.

*polymorphic - logic that serves different purposes in different scenarios*

*Explain the construction of messages and how they work...*

## Properties

### ```Message.BufferSize```
```const int BufferSize = 1024```

The default size of the message buffer.

### ```Message.buffer```
```byte [] buffer { get; set; }```

The raw buffer containing the raw bytes. Do not modify this unless you know what you're doing. Consider using the ```encoder``` instead.

### ```Message.endPoint```
```IPEndPoint endPoint { get; set; }```

If the message is meant to be sent, then this is the target's IP address and port. If the message is received, then this is the sender's IP address and port.

### ```Message.encoder```
```MessageEncoder encoder { get; }```

The encoder used for encoding/decoding messages. This is the object that you're going to use to read/write data to your messages. It's really neat to use.

Take a look at [MessageEncoder](MessageEncoder.md) for more info.

## Methods

### ```Message ()```
Constructor for Message.

**Since the message class has polymorphic behaviour, it is very important to use the correct constructor.**

 ```Message (IPEndPoint endPoint, int bufferSize = 1024)```

[SEND] Use this constructor if the message is to be sent.

- Parameters:
	- ```endPoint``` - The IP address and port of the target remote receiver.
	- ```bufferSize``` - The space allocated for the message. It's recommended that you keep that as low as possible to save memory. Perfect scenario would be if you know exactly how many bytes you're going to write to that message. **However, this parameter does not set how many bytes are going to be sent. The actual sent message is being trimmed to only include the written data. The buffer size only helps to save memory locally.**

```Message (IPEndPoint endPoint, byte [] data)```

[RECEIVE] Use this constructor if the message is received. In a normal scenario you wouldn't (and preferrably shouldn't) use this constructor as the message will already be created for you by the ```MessageManager.Receive ()```.

- Parameters:
	- ```endPoint``` - The IP address and port of the sender.
	- ```byte [] data``` - The data.

Use this constructor if the message is received.

### ```Message.Encode ()```
Encodes an object that implements the ```IEncodable``` interface. You can read more about it [here](IEncodable.md).

```void Encode (IEncodable encodable)```

- Parameters:
	- ```encodable``` - The object to encode.

### ```Message.Decode ()```
Decodes an object that implements the ```IEncodable``` interface. You can read more about it [here](IEncodable.md).

```void Decode (IEncodable encodable)```

- Parameters:
	- ```encodable``` - The object to decode.

### ```Message.ToString ()```
Returns an array representation of the message as a string.

```string ToString ()```

- Returns:
	- ```string``` - The array representation string.

repository: powersupersport/net-transport

repo_name: powersupersport/net-transport


text:
# Swagger-UI
The `api.yaml` file is an YAML file specifying the Tosca REST API using OpenAPI 3.1.
To view the API, either load the file into the online [Swagger editor](https://editor.swagger.io/)
(useful for modifications), or run `docker-compose up` to host Swagger-UI on port `8080`.

repository: KlasafGeijerstam/Tosca

gha_language: Rust

repo_name: KlasafGeijerstam/Tosca