text:
# WebfactoryShortcodeBundle

A Symfony bundle to resolve `[shortcode]` markup in Twig templates, using the [thunderer/Shortcode](https://github.com/thunderer/Shortcode) library.

It allows you to define shortcodes and their replacements in a jiffy. Shortcodes are special text fragments that can be replaced with other content or markup. E.g. a user could use the following in a comment:

```
[image url="https://upload.wikimedia.org/wikipedia/en/f/f7/RickRoll.png"]
[text color="red"]This is red text.[/text]
```

In analogy to living style guides, this bundle provides a shortcode guide that lists all registered shortcodes with an optional description and example.

## Installation

As usual, install via [Composer](https://getcomposer.org/) and register the bundle in your application:

    composer require webfactory/shortcode-bundle

```php
<?php
// config/bundles.php

public function registerBundles()
{
    return [
        // ...
        Webfactory\ShortcodeBundle\WebfactoryShortcodeBundle::class => ['all' => true],
        // ...
    ];
    // ...
}
```

## Usage

### Twig Filter

The bundle will set up a `shortcodes` Twig filter. What you pass through this filter will be processed by the `Processor` class (see [docs](https://github.com/thunderer/Shortcode#processing)).

```twig
{% apply shortcodes %}
    [image url="https://upload.wikimedia.org/wikipedia/en/f/f7/RickRoll.png"]
    [text color="red"]This is red text.[/text]
{% endapply %}
{{ some_content |shortcodes }}
```

### Using Controllers as Shortcode Handlers

This bundle comes with a helper class that allows to use Symfony's [Fragment Sub-Framework](https://symfony.com/blog/new-in-symfony-2-2-the-new-fragment-sub-framework) and the technique of [embedding controllers](https://symfony.com/doc/current/templates.html#embedding-controllers) to have controllers generate the replacement output for shortcodes.

To give an example, assume the following configuration:

```yaml
# config.yml
webfactory_shortcodes:
    shortcodes:
        image: AppBundle\Controller\EmbeddedImageController::show
```

Then, when doing something like this in Twig:

```twig
{{ '[image url="https://upload.wikimedia.org/wikipedia/en/f/f7/RickRoll.png"]' |shortcodes }}
```

... the `AppBundle\Controller\EmbeddedImageController::show()` controller method will be called. Additional shortcode attributes, like `url` in the above example, will be passed as parameters to the controller. The response returned by the controller will be used to replace the shortcode in the given content. The controller can generate the response directly, or use Twig to render a template to create it.

#### Rendering with Edge Side Includes

You can also use [ESI rendering](https://symfony.com/doc/current/http_cache/esi.html) for particular shortcodes. The advantage of ESI is that single shortcode replacements can be stored in edge caches and/or reverse proxies like Varnish and possibly be reused on multiple pages.

⚠ Take care: Due to the way ESI works, the (master) `Request` visible to controllers is no longer the one where the shortcode was used. Keep that in mind wehn you, for example, want to log the URLs where shortcodes are beiung used.

To use ESI-based embedding for a particular shortcode, use the following configuration:

```yaml
# config.yml
webfactory_shortcodes:
    shortcodes:
        image:
            controller: AppBundle\Controller\EmbeddedImageController::showAction
            method: esi
```

### Registering Handlers as Services

In the [thunderer/Shortcode](https://github.com/thunderer/Shortcode) package, _handlers_ transform shortcodes into desired replacements. You can register services from the Symfony Dependency Injection Container to be used as shortcode handlers by tagging them with `webfactory.shortcode` and adding a `shortcode` attribute to the tag indicating the shortcode name.

```yaml
services:
    My\Shortcode\Handler\Service:
        tags:
            - { name: 'webfactory.shortcode', shortcode: 'my-shortcode-name' }
```

### Removing `<p>` Tags around Shortcodes

By default, the `RemoveWrappingParagraphElementsEventHandler` contained in this bundle will be used to remove `<p>...</p>` tags around shortcodes, if the shortcode is the only text content in that paragraph.

## Activating the Shortcode Guide

The optional Shortcode Guide is a controller providing an overview page of all configured shortcodes. For every shortcode, there is also a detail page including a rendered example.

To use the Shortcode Guide, include the routing configuration from<EMAIL_ADDRESS>
⚠ You probably want to do this only for your Symfony `dev` and/or `test` environment, and possibly restrict access in your security configuration in addition to that.

```yaml
# src/routing.yml
_shortcode-guide:
    prefix: /shortcodes
    resource<EMAIL_ADDRESS>```

With the route prefix defined as above, visit `/shortcodes/` to see a list of all defined shortcodes. If you want to add descriptions to shortcodes and/or provide the example shortcode that shall be rendered on the detail page, you can add this information when configuring shortcodes:

```yaml
# config.yml
webfactory_shortcodes:
    shortcodes:
        image:
            controller: AppBundle\Controller\EmbeddedImageController::showAction
            description: "Renders an image tag with the {url} as it's source."
            example: "image url=https://upload.wikimedia.org/wikipedia/en/f/f7/RickRoll.png"
```

### Other Configuration Parameters

In most cases, the default values should work fine. But you might want to configure something else, e.g. if the default
parser needs too much memory for a large snippet. See thunderer's documentation on [parsing](https://github.com/thunderer/Shortcode#parsing)
and [configuration](https://github.com/thunderer/Shortcode#configuration) so you understand the advantages,
disadvantages and limitations:

```yaml
# config.yml

webfactory_shortcode:
    parser: 'regex'      # default: regular
    recursion_depth: 2   # default: null
    max_iterations: 2    # default: null
```

## Testing your Shortcodes

This section provides a few hints and starting pointers on testing your shortcode handlers and bundle configuration.

### Direct Unit Tests

In general, try to start with unit testing your shortcode handlers directly.

No matter whether your handler is a simple class implementing the `__invoke` magic method or a Symfony Controller with one or several methods: Direct unit tests are the easiest way to have full control over the handler's (or controller's) input, and to get immediate access to its return value. This allows you to test also a broader range of input parameters and verify the outcomes. In this case, you will typically use Mock Objects to substitute some or all other classes and services your handler depends upon.

If your shortcode handler produces HTML output, the [Symfony DomCrawler](https://symfony.com/doc/current/components/dom_crawler.html) might be helpful to perform assertions on the HTML structure and content.

### Functional Tests for shortcode-handling Controllers

When using a controller to handle a shortcode, and the controller uses Twig for rendering, you might want to do a full functional (integration) test instead of mocking the Twig engine.

The Symfony documentation describes how [Application Tests](https://symfony.com/doc/current/testing.html#write-your-first-application-test) can be performed. This approach, however, is probably not suited for your shortcode controllers since these typically _are not_ reachable through routes and so you cannot perform direct HTTP requests against them.

Instead, write an [integration test](https://symfony.com/doc/current/testing.html#integration-tests) where you retrieve the controller as a service from the Dependency Injection Container and invoke the appropriate method on it directly. Then, just like described in the section before, perform assertions on the Response returned by the controller.

Here is an example of what a test might look like.

```php
<?php

use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;

class MyShortcodeControllerTest extends KernelTestCase
{
    public function test_renderImageAction_returns_img(): void
    {
        // Assume the controller is used to turn `[img id=42]` into some HTML markup

        // create fixture/setup image with ID 42 in the database or similar
        // ...

        // Exercise controller method
        $container = static::getContainer();
        $controller = $container->get(MyShortcodeController::class);
        $response = $controller->renderImageAction(42);

        // Verify outcome
        self::assertStringContainsString('<img src="..." />', (string) $response->getContent());
    }
}
```

### Testing Configuration

After you have written some tests that verify your handlers work as expected for different input parameters or other circumstances (e. g. database content), you also want to make sure a given handler is registered correctly and connected with the right shortcode name. Since we are now concerned with how this bundle, your configuration and your handlers all play together, we're in the realm of integration testing. These tests will be slower, since we need to boot a Symfony Kernel, fetch services from the Dependency Injection Container and test how various parts play together.

This bundle contains the `\Webfactory\ShortcodeBundle\Test\ShortcodeDefinitionTestHelper` class and a public service of the same name. Depending on the degree of test specifity you prefer, you can use this service to verify that...

* A given shortcode name is known, i. e. a handler has been set up for it
* Retrieve the handler for a given shortcode name, so you can for example perform assertions on the class being used
* When using controllers as shortcode handlers, test if the controller reference for a given shortcode can be resolved (the controller actually exists)
* Retrieve an instance of the controller to perform assertions on it.

For all these tests, you probably need to use `KernelTestCase` as your test base class ([documentation](https://symfony.com/doc/current/testing.html#integration-tests)). Basically, you will need to boot the kernel, then get the `ShortcodeDefinitionTestHelper` from the container and use its methods to check your shortcode configuration.

Maybe you want to have a look at [the tests for `ShortcodeDefinitionTestHelper` itself](tests/Functional/ShortcodeDefinitionTestHelperTest.php) to see a few examples of how this class can be used.

Remember – this type of test should not test all the possible inputs and outputs for your handlers; you've already covered that with more specific, direct tests. In this test layer, we're only concerned with making sure all the single parts are connected correctly.

### Full End-to-End Tests

If, for some reason, you would like to do a full end-to-end test for shortcode processing, from a given string containing shortcode markup to the processed result,  have a look at the `\Webfactory\ShortcodeBundle\Test\EndToEndTestHelper` class.

This helper class can be used in integration test cases and will do the full shortcode processing on a given input, including dispatching sub-requests to controllers used as shortcode handlers.

A test might look like this:

```php
<?php

use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Webfactory\ShortcodeBundle\Test\EndToEndTestHelper;

class MyFullScaleTest extends KernelTestCase
{
    /** @test */
    public function replace_text_color(): void
    {
        self::bootKernel();

        $result = EndToEndTestHelper::createFromContainer(static::$container)->processShortcode('[text color="red"]This is red text.[/text]');

        self::assertSame('<span style="color: red;">This is red text.</span>', $result);
    }
}
```

Assuming that your application configuration registers a handler for the `text` shortcode, which might also be a controller, this test will perform a full-stack test.

## Credits, Copyright and License

This bundle was started at webfactory GmbH, Bonn.

- <https://www.webfactory.de>
- <https://twitter.com/webfactory>

Copyright 2018-2022 webfactory GmbH, Bonn. Code released under [the MIT license](LICENSE).

repository: webfactory/WebfactoryShortcodeBundle

gha_language: PHP

repo_name: webfactory/WebfactoryShortcodeBundle


text:
+++
Talk_date = ""
Talk_start_time = ""
Talk_end_time = ""
Title = "Provisioning is Magic - A Declarative Approach to AWS Infrastructure"
Type = "talk"
Speakers = ["jason-m-salberblack"]
youtube = "4JB1A6Pn4dY"
+++

Choosing appropriate tooling for the provisioning of virtual infrastructure such as servers, storage, and networking components is a challenge due to the variety of available tools. These tools range from provider-native services such as AWS CloudFormation to multi-provider technologies such as Hashicorp's Terraform. Between the native and non-native solutions is a family of light-weight tools that operate directly on provider-native template files. I will briefly review the trade-offs between the different types of tooling, discuss why we chose the CloudFormation template-generating library SparkleFormation to meet our specific goals, and conclude with a tour of our SparkleFormation implementation.

repository: KrisBuytaert/devopsdays-web

branch_name: refs/heads/master

extension: md

gha_license_id: NOASSERTION

license_type: permissive

repo_name: KrisBuytaert/devopsdays-web


text:
---
layout:     post
title:      "NSOperation class"
date:       2011-07-30 21:00:00
author:     "Daniel Vela"
header-img: "img/post-bg-02.jpg"
locale:       en
lang-ref:   nsoperation-class
---

NSOperation is useful for asynchronous executions:

{% highlight objc %}
@interface MyOp : NSOperation
@end
@implementation MyOp
-(void) main {
// Your work goes here
}
@end
{% endhighlight %}
Sample usage:

{% highlight objc %}
NSOperationQueue = [[NSOperationQueue alloc] init];
MyOp* op = [[MyOp alloc] init];
[queue addOperation:op];
{% endhighlight %}

20110324.21

extension: markdown

gha_language: JavaScript


text:
# URLHandlers elsewhere, awareness, and other shareable URLs

* [YouTube: ARTtech seminar: Your privacy is protected by .. what exactly](https://www.youtube.com/watch?v=-51nIz8pz08)
  * [Presentation slides](http://hack.urlhandlers.info/assembly/)
  * Previous version of the video colloected 500+ views
  * [YouTube: Juhani Eronen interview - URLHandlers and infosec in general](https://www.youtube.com/watch?v=I_zQa0atqkk)
* [YouTube URLHandlers playlist](https://www.youtube.com/playlist?list=PL1fscFAejNoCk_iEHN9Urvl7SSB2xG-AR)
* [Tweet by @mikko](https://twitter.com/mikko/status/767971883610505217)

license: MIT

repository: ouspg/urlhandlers

repo_name: ouspg/urlhandlers


text:
# unchained

Vagrant and ansible setup to create a minimum viable Django project. This project templates creates a basic Django application that has a Foundation based index.html and associated toolchains to make changes.

Vagrant environment runs following  environment:
* Ngingx / supervisor
* Postgresql

Unchained also contains ansible-playbook to deploy the project to an AWS instance and Procfile for Heroku deployment.

## Prerequisites

Vagrant, Virtualbox and Ansible are required to setup this system. Other components will be installed by configuring the Vagrant box.

## Setup

Clone the repository and run following command:

	vagrant up

This will automatically setup and run basic environment for you.

## Configuration

## Starting a project

## Running a Development Environment

## Deploying to Heroku

## Deploying to AWS

repository: timokoola/unchained

repo_name: timokoola/unchained


text:
# Kubernetes Ops Box

Kubernetes Ops Box is the docker image with necessary tools for kubernetes operations including build, template, package, lint, analyze and security audit. This Kubernetes Ops Box is especially made to do operations in kubernetes that brings set of standards together on develop and managing kubernetes environment.

- [Kubernetes Ops Box](#kubernetes-ops-box)
  - [How to pull image?](#how-to-pull-image)
  - [How to run the image?](#how-to-run-the-image)
  - [Tools](#tools)
  - [Build and Ship](#build-and-ship)
    - [Docker CLI, Kubectl, KubeAdm](#docker-cli-kubectl-kubeadm)
    - [Linting Docker files - Hadolint](#linting-docker-files---hadolint)
    - [Analyzing Docker Layers - Dive](#analyzing-docker-layers---dive)
    - [Dev tools](#dev-tools)
  - [Infrastructure as code](#infrastructure-as-code)
    - [Terraform](#terraform)
  - [Package management](#package-management)
    - [Helm](#helm)
  - [Monitor](#monitor)
    - [Kube Shell](#kube-shell)
    - [Kubebox](#kubebox)
  - [Static analysis / Audit tool](#static-analysis--audit-tool)
    - [Kube Score](#kube-score)
    - [Kube Audit](#kube-audit)
  - [Contributing](#contributing)
  - [Pull Request Process](#pull-request-process)
  - [Credits](#credits)

The github package registry contains three different docker images

| Image | URL                                                      | Tag    | Description                                                                  |
| ----- | -------------------------------------------------------- | ------ | ---------------------------------------------------------------------------- |
| Base  | docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops     | latest | This image contains kubectl, kubeadm, terraform, helm and etc.               |
| EKS   | docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops-eks | latest | This contains the base tools and AWS CLI to do aws cloud cli operations.     |
| AKS   | docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops-aks | latest | This contains the base tools and Azure CLI to do Azure cloud cli operations. |

## How to pull image?

1. Create a github personal access token with read packages permission.
2. Login in docker using below command.
   ```
   docker login -u <github_user_name> -p <personal_access_token>
   ```
3. Pull the required images.
   ```
   docker pull docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops:latest
   ```

## How to run the image?

1. Run the image with the below command.

 ```bash
 docker run -it -v /var/run/docker.sock:/var/run/docker.sock -v /YOUR_LOCAL_FOLDER/.kube:/root/.kube docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops:latest
 ```

2. If you want to connect with EKS, run the image with the below command

```bash

 docker run -it -v /var/run/docker.sock:/var/run/docker.sock -v /YOUR_LOCAL_FOLDER/.kube:/root/.kube -v /YOUR_LOCAL_FOLDER/.aws:/root/.aws docker.pkg.github.com/ksivamuthu/k8s-ops-box/k8s-ops-eks:latest
```

## Tools

## Build and Ship

### Docker CLI, Kubectl, KubeAdm

This *k8s-ops-box* includes docker cli, kubectl and kubeadm installed. It still uses host docker to build the images. You've to mount docker.sock when you are running this box to give access to docker-cli to build the images.

### Linting Docker files - Hadolint

Do you want to lint your dockerfile? Hadolint is the superpower lint tool that lints the docker file and suggests the best practices to follow and to avoid security issues.

```
hadolint <Dockerfile>
```

### Analyzing Docker Layers - Dive

A most useful tool for exploring a docker image, layer contents, and discovering ways to shrink the size of your Docker/OCI image.

![](https://github.com/wagoodman/dive/blob/master/.data/demo.gif)

Run the below command to analyze docker layers.

```bash
dive <image_name>
```

### Dev tools

This *k8s-ops-box* comes with necessary dev tools or command line tools that requires kubernetes operations. It has vim editor, jq for JSON parsing, curl for requests, git for version control, unzip/tar for unzipping files and python3/pip installed for basic operations.

## Infrastructure as code

### Terraform

Terraform is the infrastructure-as-code tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions.

## Package management

### Helm

Helm is a tool that streamlines installing and managing Kubernetes applications. Think of it like apt/yum/homebrew for Kubernetes.

## Monitor

### Kube Shell

An integrated shell for working with the Kubernetes CLI is installed in this *k8s-ops-box* and that's the main entrypoint of the docker image. This kube-shell includes auto completion, fish style command support and other cool features. This is one of the must have tool when you are using lot of kubectl commands to query your cluster.

![](https://camo.githubusercontent.com/6dd81f81976c3abf550dddbed8dcc1fa93d86595/687474703a2f2f692e696d6775722e636f6d2f6466656c6b4b722e676966)

### Kubebox

Terminal console for Kubernetes. Check memory/cpu, logs of all your pods from the command line.

```bash
kubebox
```
![](https://camo.githubusercontent.com/f657bda0847eeaf09459f6d3c045af177f6c6f28/68747470733a2f2f6173746566616e757474692e6769746875622e696f2f6b756265626f782f6b756265626f782e737667)

## Static analysis / Audit tool

### Kube Score

kube-score is a tool that performs static code analysis of your Kubernetes object definitions. The output is a list of recommendations of what you can improve to make your application more secure and resilient.

Checks:
* Container limits (should be set)
* Pod is targeted by a NetworkPolicy, both egress and ingress rules are recommended
* Deployments and StatefulSets should have a PodDisruptionPolicy
* Deployments and StatefulSets should have host PodAntiAffinity configured
* Container probes, both readiness and liveness checks should be configured, and should not be identical
* Container securityContext, run as high number user/group, do not run as root or with privileged root fs
* Stable APIs, use a stable API if available (supported: Deployments, StatefulSets, DaemonSet)

Example with helm:

```
helm template my-app | kube-score score -
```

Static yamls:

```
kube-score score my-app/*.yaml
```

### Kube Audit

kubeaudit is a command line tool to audit Kubernetes clusters for various different security concerns: run the container as a non-root user, use a read only root filesystem, drop scary capabilities, don't add new ones, don't run privileged, ... You get the gist of it and more on that later.

```
kubeaudit all
```

![](https://478h5m1yrfsa3bbe262u7muv-wpengine.netdna-ssl.com/wp-content/uploads/2019/07/kubeaudit_k8s_security.png)

## Contributing

When contributing to this repository, please first discuss the change you wish to make via issue, email, or any other method with the owners of this repository before making a change.

Please note we have a code of conduct, please follow it in all your interactions with the project.

## Pull Request Process

* Ensure the docker images is built successfully
* Make sure, the new tool we are adding in this kubernetes box is evaluated.
* Update the README.md with details of changes to the interface, this includes new environment variables, exposed ports, useful file locations and container parameters.
* You may merge the Pull Request in once you have the sign-off of one other developer, or if you do not have permission to do that, you may request the second reviewer to merge it for you.

## Credits

Credits go to these all fantastic open-source tools that help this kubernetes development lot easier. This repository is just the docker box with all useful tools installed. In the future, the custom script may be added to this box to enhance our kubernetes ops.


text:
# CurtainBlock.js
### Developed by Jessica Alouette
### v1.2.2
#### A simple, flat, native way to block content from view until the user wants to see it.

## About CurtainBlock.js

CurtainBlock.js was devised initially as a method to hide all the content on a given page from anyone who might come stumbling onto a given page and not be willing to see the content on it. I primarily think people will use this for adult blogs or whatever.

## Demo

A demo of this script can be [found here](http://owlet57.github.io/CurtainBlock.js)

## Requirements

* A browser that runs JS
* localStorage support (most if not all modern browsers have this)
* jQuery (I used 2.0.3 in development but you can use whatever)

## Features

* Lightweight
* Easy to add to your existing code
* 2 minute setup!
* Uses localStorage() for persistent confirm.

## Setup

The easiest method is just to add these 3 lines of code in at the end of the `<body>`:

Add this to your `<head>`:

	<link rel="stylesheet" href="//owlet57.github.io/CurtainBlock/CurtainBlock.css">

And create the relevant divs and buttons:

        This website requires Javascript.
        <button class="CurtainBlockConfirm"></button>
        <button class="CurtainBlockDeny"></button>

And you're done!

Oh, and in case you've set up CurtainBlock.js to be in your HTML, but forget to initialize it, it will give you a friendly reminder to initialize it in the console.

## What's new in v1.2

* Easier starter call, with all your options on one line!
* Hopefully a bit faster and more efficient
* Cleaner code

## Options

CurtainBlock.js, as of v1.2, now just passes options in it's first call.  To set your options, just set them between the brackets.

### Persistent

Sets the use of persistence (via localStorage) to either on or off, so you can avoid displaying alerts to users who have already visited and accepted the warning.

* **Default:** *false*
* **Options:** *true, false*

*Example:*

	CurtainBlock(true)

### Transparent

Sets up a transparency option, so a user can see some of the content on your page if you want them to.

* **Default:** *false*
* **Options:** *true, false*

*Example:*

	CurtainBlock(true,true)

### Redirect URL

Sets a url for CurtainBlock to redirect to in the event the user does not want to continue ahead.

* **Default:** *about:blank*
* **Options:** *string*

*Example:*

	CurtainBlock(true,true,"http://blog.owlet57.com")

***

##### Special Thanks to The M Machine, Porter Robinson, and KOAN Sound for keeping me going while I wrote this.
##### Additional thanks to Jaybud for helping me test and work on this.


text:
Basic usage
===========

## Introduction

Including DocTester into your build is dead simple.

This creates documentation when you run the testcase, and also gives you
access to a range of useful commands.

You can see best how DocTester works by looking at the following example:

public class ApiControllerDocTest extends DocTester {

    String GET_ARTICLES_URL = "/api/{username}/articles.json";
    String POST_ARTICLE_URL = "/api/{username}/article.json";

    @Test
    public void testGetAndPostArticleViaJson() {

        sayNextSection("Retrieving articles for a user (Json)");

        say("Retrieving all articles of a user is a GET request to " + GET_ARTICLES_URL);

        Response response = sayAndMakeRequest(
               Request
                    .GET().url(testServerUrl().path((GET_ARTICLES_URL.replace("{username}", USER)))));

        ArticlesDto articlesDto = response.payloadAs(ArticlesDto.class);

        sayAndAssertThat("We get back all 3 articles of that user ", 3, equalTo(articlesDto.articles.size()));

		}
}

This in turn generates the following documentation:

![A screenshot of the generated html output](../images/doctester_example_output.png)

## What DocTester generates

Once your ran your testcase that extends DocTester you can find two files inside
directory **target/site/doctester**. One file is named after your test.

For instance the doctest of class com.mycompany.ApiControllerDocTest will be written to a file
**target/site/doctester/com.mycompany.ApiControllerDocTest.html**.

The second file named **index.html** contains a listing of all DocTests
you executed. This comes in handy if you want to publish your DocTests on a website.
You can simply point the users to the index.html and they have access to all
DocTester documentation of your project.

## The Api of DocTester and what it means

The basic idiom of DocTester is **say**. If you write DocTests always have in mind
that you are not writing a traditional test, but documentation for the user.
Therefore your tests should depict a typical usecase. Getting data, querying and
interface, posting data and so on.

Always use natural language inside your say commands.

And a bonus tip: Please actually read the documentation DocTester generates.
It should make sense and should really help to understand your application and your
interface.

### sayNextSection(String string)

Renders a headline with html formatting <h1> to your page.

### say(String string)

Renders a paragraph with html formatting <p> to your page.

### say(String string)

Renders a paragraph with html formatting <p> to your page.

### sayRaw(String string)

Renders the provided string directly into the document. Nice if you want
to render supercustom html.

### sayAndAssertThat(...)

This is a typical Hamcrest assert. Simply add a message and use any
matchers like

sayAndAssertThat("We get back all 3 articles of that user ", 3, equalTo(articlesDto.articles.size()));.

The big difference between a DocTester assert and a Hamcrest assert is that
DocTester renders a green box with the message.

You can of course skip using DocTesters sayAndAssert and simply use
the regular assertThat.

But sometimes it is just nice to assert something important visually.

### sayAndMakeRequest(Request request)

This method executes a request via a headless browser. You can configure
the Request yourself by providing url, path, query parameters and payload.

The cool thing is that DocTester automatically generates a nice box that
will document the request (headers, cookies etc) and the response
(headers, payload...).

This means users of your Api can easily see what is going on and what they
can expect from your Api.

sayAndMakeRequest has a little cousin called makeRequest which works exactly
the same way, but does not document anything.
Sometimes handy when you want to do stuff you don't want to document all the
time like logging into your Api for instance.

Some examples.

Performing a **GET** request:

//Let's assume we want to list all user via our Api.
Response response = sayAndMakeRequest(
               Request
                    .GET().url(testServerUrl().path("/api/users")));

Users users = response.payloadAs(Users.class);

Performing a **GET** request with query parameters:

//Let's assume we want to list all user via our Api
// and add a query parameter:
Response response = sayAndMakeRequest(
               Request
                    .GET().url(testServerUrl().path("/api/users")
														.addQueryParameter("search", "Bob Mossley"));

Users users = response.payloadAs(Users.class);

Performing a **POST** request:

// Let's say we want to create a new user:
User user = new User("username");

Response response = sayAndMakeRequest(
               Request
                    .POST().url(testServerUrl().path("/api/user"))
                    .contentTypeApplicationJson()
                    .payload(username));

The Api should be fluent and your IDE will help you to discover
how you can modify requests and inspect responses.

### More

There are more methods, and you can easily find out more about them via
code completion and JavaDocs in your favorite IDE.

## Some more information

You usually should extend DocTester and overwrite at least **testServerUrl()**.

public Url testServerUrl() {

	return Url.host("http://localhost:xxxx");
}

That way you can use nice chaining when assembling your calls via makeRequest(...)
and sayAndMakeRequest(...).

Please find more information in chapter advanced integration.

repository: sirmc/doctester

repo_name: sirmc/doctester


text:
# Electrode OTA Server

The Electrode OTA Server provides a way to hot deploy android and ios React Native™ and Cordova™ apps. The server
is API compatible with [code-push-cli](https://microsoft.github.io/code-push/docs/cli.html), the
[Code Push React Native SDK](https://microsoft.github.io/code-push/docs/react-native.html) and the [Code Push Cordova SDK](https://microsoft.github.io/code-push/docs/cordova.html).

[Documentation](https://docs.electrode.io/other/powerful-electrode-tools/react-native-and-over-the-air)

## Requirements

- Node ^8.16.0

![OTA: Overview](./docs/img/OV1.png)

## Installation

For configuration instructions visit the [electrode.io](http://www.electrode.io/docs/electrode_react_native_over_the_air_electron.html)

```
 npm i electrode-ota-server
```

## Example

Check the `example` folder.  See the [Readme](example/README.md)

## Releases
### Version 4.3.0

Various bug fixes.

### Version 4.0.0

Rewrite of mariadb module; simplify needed configuration to use the mariadb module.

```json
        "electrode-ota-server-dao-plugin" : {
            "module" : "electrode-ota-server-dao-mariadb",
            "options": {
                "clusterConfig" : {
                    "canRetry" : true,
                    "defaultSelector" : "ORDER",
                    "removeNodeErrorCount" : 5,
                    "restoreNodeTimeout" : 0,
                },
                "poolConfigs" : [{
                    "database": "electrode_ota",
                    "host": "localhost",
                    "password": "ota",
                    "port": 33060,
                    "user": "ota",
                }],
            }
        },
```

The underlying implementation uses the npm module [mysql](https://www.npmjs.com/package/mysql). The options are described in further detail in the module's [readme](./electrode-ota-server-dao-mariadb/README.md).

The schema for mariadb is in the [electrode-ota-mariadb-schema folder](./electrode-ota-mariadb-schema/README.md). The module does not use sequelize anymore, and the schema is created separately using liquibase.

### Version 3.2.1

Version 3.2.1 is deprecated. Please use Version 3.3.0 instead.

### Version 2

Version 2 adds partial update support. To do this it requires some alterations to the cassandra database. This
will happen automatically, unless the configuration to the electrode-ota-dao-cassandra is configured as

```json
 "electrode-ota-server-dao-cassandra": {
                "options": {
                    ...
                    "disableTTYConfirmation": false,
                    //this is alter by default.
                    "migration": "safe",
                }
            }
 }
```

Make sure to backup your data, while not known to cause data loss, it is possible.

## Development

To run tests, make sure you have `localhost.walmart.com` mapped to <IP_ADDRESS> loopback.
Make sure you have cassandra installed. Cassandra is required for testings.

```sh
> docker pull cassandra
> docker run -p 9042:9042 cassandra
```

To build..

```
> npm install -g lerna yarn
> lerna bootstrap
> lerna run build
```

To run all tests (will rebuilds all) ..

```
> yarn test
```

To run a package test...

```
> cd electrode-ota-model-app
> yarn test
```

To run a sample app, check the example app in the example folder.

## Packages

| Package | Description |
| :------ | :---------- |
| electrode-ota-mariadb-schema | Schema for MariaDB |
| electrode-ota-server | Main server module |
| electrode-ota-server-auth | Contains all the authentication strategies. |
| electrode-ota-server-auth-basic | Provides basic authentication |
| electrode-ota-server-auth-github | Provides Github-based authentication |
| electrode-ota-server-auth-validate | Provides session support |
| electrode-ota-server-boot | Server startup module |
| electrode-ota-server-dao-cassandra | Implementation of `electrode-ota-server-dao-plugin` that supports Cassandra |
| electrode-ota-server-dao-mariadb | Implementation of `electrode-ota-server-dao-plugin` that supports MariaDB / MySQL |
| electrode-ota-server-dao-plugin | Defines the interface for the backend datastore(s) |
| electrode-ota-server-default-config | Default config |
| electrode-ota-server-diregister | Utility for registering various modules |
| electrode-ota-server-errors | Common errors (@hapi/boom wrapper) |
| electrode-ota-server-fileservice-download | Handles download of packages |
| electrode-ota-server-fileservice-upload | Handles upload of packages|
| electrode-ota-server-logger | Logger |
| electrode-ota-server-manager | Route handlers for /manager/* endpoints |
| electrode-ota-server-model-account | Account model |
| electrode-ota-server-model-acquisition | Acquisition model |
| electrode-ota-server-model-app | App model |
| electrode-ota-server-model-manifest | Manifest model |
| electrode-ota-server-model-weighted | Weighting utility |
| electrode-ota-server-public | Route handler for static endpoints |
| electrode-ota-server-routes-accesskeys | Route handler for access keys endpoints |
| electrode-ota-server-routes-acquisition | Route handler for (client) acquisition endpoints |
| electrode-ota-server-routes-apps | Route handler for app endpoints |
| electrode-ota-server-routes-auth | Route handelr for authentication/session endpoints |
| electrode-ota-server-service-errors | Handles endpoint errors |
| electrode-ota-server-service-fileservice | Deprecated |
| electrode-ota-server-service-management | Deprecated |
| electrode-ota-server-test-support | Test utilities |
| electrode-ota-server-util | Utilities |
| electrode-ota-server-util-dev | Developer utilities |
| electrode-ota-server-view | Deprecated |
| electrode-ota-ui | OTA UI shared with desktop/web UIs |

### Custom Data store

`electrode-ota-server-dao-plugin` defines the interface for the database, along with the expected Data Access Objects.

To create your own data store, create a module with the same factory methods as `electrode-ota-server-dao-plugin`.  See `electrode-ota-server-dao-cassandra` and `electrode-ota-server-dao-mariadb` for examples.

In your config file, specify the new module.  Pass any required options.
```json
    "electrode-ota-server-dao-plugin" : {
        "module" : "electrode-ota-server-dao-mariadb",
        "options": {
            ...
        }
    },
```

Package content is saved to the specified datastore (MariaDB or Cassandra).  If you want to save to disk, override `electrode-ota-server-fileservice-download` and `electrode-ota-server-fileservice-upload` with your custom module.
```json
    "electrode-ota-server-fileservice-upload": {
        "module": "my-object-store",
        "options": { "upload": true }
    },
    "electrode-ota-server-fileservice-download": {
        "module": "my-object-store",
        "options": { "upload": false }
    }
```

## HowTos

#### Upload Size and Timeout

To increase the max upload size, add this to your configuration:
Likewise, you can set the timeout if upload is timing out.

```json
"electrode-ota-server-routes-apps" : {
    "options" : {
        "payload" : {
            "maxBytes" : 94371840,
            "timeout": 119999
        }
    }
}
```

#### Change log level
Update the log level in the options of electrode-ota-server-logger

```json
{
    "plugins": {
        "electrode-ota-server-logger": {
            "options": {
                "level": "info"
            }
        }
    }
}
```

#### Add a new package

Use Lerna to create the package

```sh
% lerna create <package-name>
```

This creates a base project.  Update `package.json` to match other projects.

Apache-2.0 © WalmartLabs
<br>
Built with :heart: by [Team Electrode](https://github.com/orgs/electrode-io/people) @WalmartLabs.


text:
生成指纹值。

**别名** : [ `tf.compat.v1.fingerprint` ](/api_docs/python/tf/fingerprint), [ `tf.compat.v2.fingerprint` ](/api_docs/python/tf/fingerprint)

```
 tf.fingerprint(    data,    method='farmhash64',    name=None)
```

Generates fingerprint values of  `data` .

Fingerprint op considers the first dimension of  `data`  as the batch dimension,and  `output[i]`  contains the fingerprint value generated from contents in `data[i, ...]`  for all  `i` .

Fingerprint op writes fingerprint values as byte arrays. For example, thedefault method  `farmhash64`  generates a 64-bit fingerprint value at a time.This 8-byte value is written out as an [ `tf.uint8` ](https://tensorflow.google.cn/api_docs/python/tf#uint8) array of size 8, inlittle-endian order.

For example, suppose that  `data`  has data type [ `tf.int32` ](https://tensorflow.google.cn/api_docs/python/tf#int32) and shape (2, 3, 4),and that the fingerprint method is  `farmhash64` . In this case, the outputshape is (2, 8), where 2 is the batch dimension size of  `data` , and 8 is thesize of each fingerprint value in bytes.  `output[0, :]`  is generated from12 integers in  `data[0, :, :]`  and similarly  `output[1, :]`  is generated fromother 12 integers in  `data[1, :, :]` .

Note that this op fingerprints the raw underlying buffer, and it does notfingerprint Tensor's metadata such as data type and/or shape. For example, thefingerprint values are invariant under reshapes and bitcasts as long as thebatch dimension remain the same:

```
 tf.fingerprint(data) == tf.fingerprint(tf.reshape(data, ...))
tf.fingerprint(data) == tf.fingerprint(tf.bitcast(data, ...))

```

For string data, one should expect  `tf.fingerprint(data) !=tf.fingerprint(tf.string.reduce_join(data))`  in general.

#### 参数：
- **`data`** : A  `Tensor` . Must have rank 1 or higher.
- **`method`** : A  `Tensor`  of type [ `tf.string` ](https://tensorflow.google.cn/api_docs/python/tf#string). Fingerprint method used by this op.Currently available method is  `farmhash64` .
- **`name`** : A name for the operation (optional).

#### 返回：
A two-dimensional  `Tensor`  of type [ `tf.uint8` ](https://tensorflow.google.cn/api_docs/python/tf#uint8). The first dimension equals to `data` 's first dimension, and the second dimension size depends on thefingerprint algorithm.

repository: veaba/tensorflow-docs

repo_name: veaba/tensorflow-docs


text:
# Spilosticta geranii (Fr.) Petr. SPECIES

#### Status
SYNONYM

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

#### Published in
Reliquiae Petrakianae (Graz), fasc. <b>VII</b> (1201-1400) no. 1397

#### Original name
Sphaeria geranii Fr., 1817

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Venturiaceae/Venturia/Venturia geranii/ Syn. Spilosticta geranii/README.md

repo_name: mdoering/backbone


text:
# Notes from 2022-09-22

## Attendees
- Shane Lee (@twangboy)
- Dafydd (@dafyddj)
- Maki

## Agenda
- Welcome
- New date/time for Windows Working Group meetings
- Followup Items:
  - TODO Items
- Community Issues and Discussion

## Discussed
- Issue 62479: Done and Merged
- Issue 62734: LGPO Caching
- Issue 62480: win_pkg debug logging
- Issues with WinRepo:
  - Issue with the inability to do Jinja tests because it is a Linux Runner and
    much of the jinja has Windows stuff in it
  - Issue with the 7zip definition where the indentation is wrong, causing only
    the first portion to be validated
  - Issue with the cache location and how to obtain that from salt in the
    definition file. Best to use `config.get root_dir`
  - The solution to all of this is to migrate to a Windows Runner, so we can
    include some Jinja parsing tests

## TODO
- Twangboy: https://github.com/saltstack/salt-windows-nsis/issues/15
  - `/move-config` options works from the GUI, but not Silently
- Twangboy: Test: https://github.com/saltstack/salt-windows-nsis/issues/11
  - I'm sure there are tests for this
- Dafydd: Work on transitioning the winrepo tests to run on a Windows Runner
  - Migrating to requests from pycurl in the tests
  - Look into implementing the tests as a salt extension
- Twangboy: Test giving Non-Admin user to registry key
  - This may be working now... needs further testing
  - Need to be able to start the minion as a standard non-privileged user

repository: saltstack/community

repo_name: saltstack/community


text:
# EasyFlickrBackup
Easy to use application to download and backup all your photos in original size from flickr.

* Current version: 1.2
* License: MIT License

![Screenshot](https://c2.staticflickr.com/2/1701/25533200184_1d88bdfa68_o.png)

## System requirements
* Operating system: Windows, Linux, Mac OS X
* Software: Java Runtime Environment >= 8.0 ([Download](https://www.java.com/download/))

## Download & Installation

* Download: https://github.com/lutana-de/easyflickrbackup/raw/master/EasyFlickrBackup.jar

Please make sure your computer meets the system requirements. After the download has finished, click on the EasyFlickrBackup.jar file.

If it doesn't work as expected try to run it via command line with the working diretory being the folder where the EasyFlickrBackup.jar is located in: `java -jar EasyFlickrBackup.jar`

repository: m-mohr/easyflickrbackup

repo_name: m-mohr/easyflickrbackup


text:
# phalcon-codeception-docker

Basic docker container with the latest phalcon and codeception to use cmd line

## Terminal approach
Starts a container and mounts your working dir and enter a sh console

$ docker run -v ${PWD}:/project -it --entrypoint=sh --rm ruudboon/phalcon-codeception

repository: ruudboon/phalcon-codeception-docker

gha_license_id: MIT

repo_name: ruudboon/phalcon-codeception-docker


text:
## Adjoint Sensitivity Analysis

### General remarks:

This feature provides the framework to compute sensitivities of structural responses (e.g. displacements, strain energy or stresses) with respect to different types of design variables (e.g. nodal coordinates, material or cross-sectional properties or load intensity) with the adjoint approach. An adjoint system has to be solved for each responsefunciton. The sensitivities are then computed in a post-processing step.

*Please note:*
- This feature currently only works for linear problems (exception: geometric nonlinear problems exclusively modeled with TrussElement3D2N)
- This feature makes use of the HDF5Application

### Features:

Provided is a **scheme** to solve the adjoint problem and a **replacement process** which replaces all elements and conditions of a model with its adjoint equivalents and vice versa.

| Response Function | Semi-analytic | Analytic | Static | Transient |
| ----------------- |  ---------------- | -------- | ------- | ----------|
|  Linear strain energy|    x   |          |      x   |         |
|  Displacement or rotation of a node      |       |    x    |      x    |         |
|  Stress resultant of a single element |    x   |          |      x   |         |
*In the table above, the first two columns (Semi-analytic, Analytic) refer to the way, the partial  derivative of the response is calculated.*

| Structural Condition | Adjoint Condition | Design Variables | Semi-analytic | Analytic | Static | Transient |
| -------------------- | ----------------- | ------------------- |  ---------------- | -------- | ------- | ----------|
| PointLoadCondition | PointLoadAdjointCondition¹ | POINT_LOAD |    x   |          |      x   |         |
|                      |                             | SHAPE_SENSITIVITY     |    x   |          |      x    |     |

| Structural Element | Adjoint Element | Design Variables | Semi-analytic | Analytic | Static | Transient |
| -------------------- | ----------------- | ------------------- |  ---------------- | -------- | ------- | ----------|
| ShellThinElement3D3N | AdjointFiniteDifferencingShellElement¹ | THICKNESS² |    x   |          |      x   |         |
|                      |                             | SHAPE_SENSITIVITY     |    x   |          |      x    |
| CrBeamElementLinear3D2N | AdjointFiniteDifferenceCrBeamElement¹ | I22²|    x   |          |      x   |         |
|                      |                             | SHAPE_SENSITIVITY     |    x   |          |      x   |          |
| TrussElement3D2N | AdjointFiniteDifferenceTrussElement¹ | CROSS_AREA²|    x   |   x³       |      x   |         |
|                      |                             | SHAPE_SENSITIVITY     |    x   |          |      x   |          |
| TrussLinearElement3D2N | AdjointFiniteDifferenceTrussLinearElement¹ | CROSS_AREA²|    x   |         |      x   |         |
|                      |                             | SHAPE_SENSITIVITY     |    x   |          |      x   |          |

¹ The adjoint elements and conditions wrap elements/conditions of the Structural Mechanics Application and can call its public functions.  The main task of the adjoint elements/conditions is to derive different quantities (e.g. the right hand side or post-processing results like stresses) with respect to the design variable or state.

² In principle the adjoint elements are able to compute sensitivities w.r.t. to all properties which are available at a specific element. ```THICKNESS``` and ```I22``` are possible examples. One only has to ensure that a corresponding Kratos-Variable for the sensitivity result is defined (e.g. for the design variable ```THICKNESS``` a corresponding variable called ```THICKNESS_SENSITIVITY``` is necessary). This additional variable is necessary to store the results of the sensitivity analysis. See also the paragraph Post-Processing.

³ the nonlinear adjoint truss element is able to compute its stress-displacement-derivative analytically. All other derivatives are computed by finite-difference approximation on element level.

### Usage:
In order to perform a sensitivity analysis for one response function, the solution of two problems is necessary: The primal and the adjoint problem.

*Please note:*
For the solution of the two problems different kind of variables are used in order to store the results. For the primal problem the usual variables ```DISPLACEMENT``` and ```ROTATION``` and for the adjoint problem ```ADJOINT_DISPLACEMENT``` and ```ADJOINT_ROTATION``` are used.

#### Definition of the Primal Problem
The primal problem can be defined by the regular input files which are needed for standard analysis. As only difference the output process of the HDF5Application has to be added in the project parameters. An example for a possible file is:
*StructuralMechanicsApplication/tests/adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_parameters.json*

#### Definition of the Adjoint Problem
In order to define the adjoint problem an additional \*.json-file for the adjoint project parameters is necessary. This input file is in principle very similar to the respective file of the primal analysis. In comparison to a regular file for a linear static analysis three points have to be modified:
- ```solver_settings``` by using the ```adjoint``` as ```solver_type``` and by the definition of the ```response_function_settings```
- The input process of the HDF5Application has to be added in order to read the primal solution
- When defining *Dirichlet* conditions ```ADJOINT_DISPLACEMENT``` respective ```ADJOINT_ROTATION``` instead of ```DISPLACEMENT``` respective ```ROTATION``` have to be used.

An example for a possible input file is:
*StructuralMechanicsApplication/tests/adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_local_stress_adjoint_parameters.json*

#### How to run the analysis:

If all necessary input files are defined, the analysis can be performed with a simple python script by calling the primal and afterwards the adjoint analysis. The sensitivities are computed in a post-processing of the adjoint problem.

A possible python workflow can be found in:
*StructuralMechanicsApplication/tests/test_adjoint_sensitivity_analysis_beam_3d2n_structure.py*

#### Possible ```response_function_settings```:

Independent from the chosen response function the following definitions are always necessary:

- ```gradient_mode```: Currently there is only ```semi_analytic``` available.
- ```step_size``` is the perturbation measure for finite difference computations within the semi-analytic approach.
- ```sensitivity_model_part_name```: The name of the model part for which components sensitivities have to be computed (e.g. if the chosen design parameter is ```THICKNESS``` then for each element in this model part the sensitivity w.r.t. this variable is calculated).
- ```nodal_solution_step_sensitivity_variables```: Currently only ```SHAPE_SENSITIVITY``` is available. Doing this the sensitivities w.r.t. to the x-, y- and z-coordinate of all nodes in the ```sensitivity_model_part_name``` are computed.
- ```element_data_value_sensitivity_variables```: Here sensitivities with respect to the properties of the elements are computed. For that the respective name of the Kratos-Variable has to be given (e.g. ```THICKNESS```, ```I22``` or ```YOUNG_MODULUS```)
- ```condition_sensitivity_variables```: Here sensitivities with respect to the properties of the conditions are computed. Currently there is only ```POINT_LOAD``` available.

**Important, please note:**
In order to use an element or condition design variable one has to ensure that a corresponding Kratos-Variable for the sensitivity is defined (e.g. for the design variable ```THICKNESS``` a corresponding variable called ```THICKNESS_SENSITIVITY``` is necessary). This additional variable is necessary to store the results of the sensitivity analysis.

There are currently three different types of response functions available which can be chosen as ```response_type```. For each of them specific settings are necessary:
- ```adjoint_nodal_displacement```: The response is the displacement or rotation of a single node. Necessary additional settings are:
    * ```traced_node_id```: ID of the traced node
    * ```traced_dof```: Define the traced DOF (e.g. ```DISPLACEMENT_Z``` or ```ROTATION_X```)

- ```adjoint_linear_strain_energy```: The response is the linear strain energy. No additional settings are necessary.

- ```adjoint_local_stress```: The response is the stress or stress-resultant of a single element. Necessary additional settings are:
    * ```traced_element_id```: ID of the element which should be traced
    * ```stress_type```: Stress type which should be traced (e.g. FX, MY, FXX or MXX)
    * ```stress_treatment```: There are three possibilities:
        * ```node``` (Takes the response value at the position of a defined node of the element. Only available for beam element.),
        * ```GP``` (Takes the response value at a defined Gauss-Point of the element.)
        * ```mean``` (The response is the mean value of all Gauss-Point results of the traced stress type.)
    * ```stress_location```: Only necessary if ```node``` or ```GP``` is chosen as ```stress_treatment```. Local index of the gauss point or node where the stress should be traced respectively. E.g. if the stress resultant of a beam element should be traced at the first of the two nodes ```stress_location``` has to be 1)

Exemplary input files:
- StructuralMechanicsApplication/tests/adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_local_stress_adjoint_parameters.json
- StructuralMechanicsApplication/tests/adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_nodal_disp_adjoint_parameters.json
- StructuralMechanicsApplication/tests/adjoint_sensitivity_analysis_tests/adjoint_beam_structure_3d2n/beam_test_strain_energy_adjoint_parameters.json

### Post-Processing

The results of the sensitivity analysis are accessible in the post-processing as ```nodal_results``` (currently only ```SHAPE_SENSITIVITY``` and ```POINT_LOAD_SENSITIVITY```) and ```gauss_point_results``` (sensitivities for elemental design variables like ```THICKNESS_SENSITIVITY``` or ```I22_SENSITIVITY```).
```python
    "nodal_results"       : ["ADJOINT_DISPLACEMENT", "SHAPE_SENSITIVITY", "POINT_LOAD_SENSITIVITY"],
    "gauss_point_results" : ["THICKNESS_SENSITIVITY"]
```

repository: KratosMultiphysics/Kratos

repo_name: KratosMultiphysics/Kratos


text:
---
title: RiiConnect24 vWii Guide
---

{% include toc title="Inhaltsverzeichnis" %}

Solltest du hinsichtlich dieses Tutorials Hilfe benötigen, trete bitte dem [RiiConnect24 Discord-Server](https://discord.gg/rc24) bei (empfohlen), oder kontaktiere uns [per E-Mail unter support@riiconnect24.net](mailto:support@riiconnect24.net).
{: .notice--info}

![RiiConnect24-Logo](/images/WiiRC24Logo.jpg)

Guide to installing [RiiConnect24](https://rc24.xyz) on vWii (Virtual Wii on Wii U).

[RiiConnect24](https://rc24.xyz/) allows you to use discontinued services from WiiConnect24, which include the News, Forecast, Everybody Votes, Nintendo and Check Mii Out Channel, along with Wii Mail.

{% capture notice-1 %}
This guide is for vWii (Wii Mode on Wii U) only.

- Follow [this tutorial](riiconnect24-wii) if you'd like to install RiiConnect24 on a Wii.
- Follow [this tutorial](riiconnect24-dolphin) if you'd like to install RiiConnect24 on Dolphin Emulator.

{% endcapture notice-1 %}

{{ notice-1 | markdownify }}

It's recommended to set your Wii to the current time before proceeding. Follow [this tutorial](rtc) in order to set it.
{: .notice--warning}

DO NOT INSTALL RIICONNECT24 ON A WII MINI! It will not work and it will brick the system.
{: .notice--danger}

#### Warnings

We are **NOT** responsible if you brick, or damage your console in any way whatsoever. If you follow this guide exactly, you shouldn't have any problems.
{: .notice--warning}

#### What you need

- Eine SD-Karte oder ein USB-Laufwerk
- A computer
- A Wii U console with an Internet connection that's capable of launching the Homebrew Launcher (either via the web browser exploit, Haxchi or Coldboot Haxchi).

If you do not have a softmodded Wii U console, please follow [this guide](https://wiiu.hacks.guide), as well as the [virtual Wii modding guide](https://wiiuguide.xyz/#/vwii-modding) and then come back.
{: .notice--warning}

- [RiiConnect24 Patcher (Windows, Mac and Linux)](https://github.com/RiiConnect24/RiiConnect24-Patcher/releases)
- [RiiConnect24 Mail Patcher](https://hbb1.oscwii.org/hbb/Mail-Patcher/Mail-Patcher.zip)

{% capture notice-2 %}
After following the vWii modding guide linked above, you should have:

- A vWii NAND backup and keys stored safely
- The Homebrew Channel installed
- d2x cIOS installed (IOS249, IOS250 and IOS251)
- IOS80 patched

{% endcapture notice-2 %}

{{ notice-2 }}

#### Anleitung

##### Section I - Running the patcher

If you can't run RiiConnect24 Patcher, please join [the RiiConnect24 Discord server](https://discord.gg/rc24) (recommended) or [e-mail us at support<EMAIL_ADDRESS>for further assistance.
{: .notice--info}

1. Click the RiiConnect24 Patcher link above to go to the GitHub page where the patcher is.
2. Download `RiiConnect24Patcher.bat` if you are on Windows, and `RiiConnect24Patcher.sh` if you are on a Unix system
3. On Windows run `RiiConnect24Patcher.bat`. On Unix systems, open Terminal and type `bash`, then drag `RiiConnect24Patcher.sh` into the terminal then press enter. It should look like this: `bash RiiConnect24Patcher.sh`.
4. Press 1 to choose "`Start`" and confirm your selection by pressing `ENTER`. (NOTE: These screenshots are from the Windows version of the patcher.) ![RiiConnect24 Patcher Main Screen](/images/RC24_Patcher/1.JPG)
5. Select the device you're patching for. ![Select your device](/images/RC24_Patcher/2.JPG)
6. For this guide, choose "`Install RiiConnect24 on your Wii`" ![Install RiiConnect24](/images/RC24_Patcher/3.JPG)
7. Choose "`Express (Recommended)`". It will give you everything you need. ![Express Settings](/images/RC24_Patcher/4.JPG)
8. Wähle deine Region. ![Select your region](/images/RC24_Patcher/5.JPG)
9. While you're at it, RiiConnect24 Patcher can additionally download some other optional channels that do not use RiiConnect24. `[X]` represents the options that selected. Just press 5 and `ENTER` if you're not interested. ![Additional optional channels](/images/RC24_Patcher/6.JPG)
10. Connect your SD Card or USB Drive to your computer and select "`1`". ![Enable copying to SD Card](/images/RC24_Patcher/7.JPG)
11. If your device was detected successfully, select "`1`". If not, make sure there's a folder called `apps` on your SD Card or USB Drive and try again. ![Successfully detected](/images/RC24_Patcher/8.JPG)
12. Be patient... ![It's patching!](/images/RC24_Patcher/9.JPG)
13. After it's done, we would appreciate if you take a minute to send anonymous feedback to us. If you don't want to, close the patcher. All the files should already be on your SD Card. ![It's done!](/images/RC24_Patcher/10.JPG) ![Files copied](/images/RC24_Patcher/11.PNG)
14. If it did not copy everything automatically to your SD Card or USB Device, copy the `WAD` and `apps` folder next to `RiiConnect24Patcher.bat` to your SD Card or USB Device.

##### Abschnitt 2 - WADs Installieren

You will now install the patched IOS and Channel WADs that are required to use RiiConnect24.

1. Put your SD card or USB drive in your Wii U.
2. Launch the Homebrew Channel on your Wii U.
3. Launch Wii Mod Lite.
4. Using the +Control Pad on your Wii Remote, navigate to `WAD Manager`, and then navigate to the `wad` folder.
5. Highlight all the WADs in the folder by pressing the + Button to select them. When all of the WADs are selected, press A twice to install the WADs.
6. If you get an error saying a title with a higher version is already installed (error -1035), go back to the WAD selection menu and press the - Button on the highlighted WAD to uninstall it, then try installing it again.
7. After they are successfully installed, press the HOME Button to exit back to the Homebrew Channel.

##### Section III - Patching nwc24msg.cfg

You will now patch your `nwc24msg.cfg` file which is required in order to use Wii Mail.

1. Launch the RiiConnect24 Mail Patcher from the Homebrew Channel.
2. It should only take a few seconds to patch your nwc24msg.cfg. When it's done, press the HOME Button to exit.

If you were unable to patch your nwc24msg.cfg correctly, please join [the RiiConnect24 Discord server](https://discord.gg/rc24) (recommended) or [e-mail us at support<EMAIL_ADDRESS>for further assistance.
{: .notice--info}

##### Section IV - Using RiiConnect24

1. Launch the `Load Priiloader` application from the Homebrew Channel.
1. In the Priiloader menu, go to `System Menu Hacks`. ![System menu hacks](/images/Priiloader/system_menu_hacks.png)
1. Scroll through the list until you see `Always enable WiiConnect24 for vWii` and `Create message via Calendar button`, and press `A` on both to enable them.
1. Scroll down to `save settings`, press `A`, then press `B` to go back.
1. Select `System Menu.`
1. Return to the Wii U Menu, then go right back to Wii Mode.

#### What's currently working?

The following RiiConnect24 services are **working** on the vWii:

- Forecast Channel
- News Channel
- Everybody Votes Channel
- Nintendo Channel
- Check Mii Out Channel / Mii Contest Channel
- Wii Mail (requires Priiloader's `Create message via Calendar button` hack)
  {: .notice--success}

Most services that utilize WiiConnect24 will be able to work if you leave vWii running for several hours. There's no standby mode on the console.
{: .notice--warning}

gha_language: SCSS


text:
# NerfCADKit

This is a repository of common components for use in Nerf CAD development.

# Attributions
The FTW Solenoid was obtained from [FlywheelTheWorld's Thingiverse](https://www.thingiverse.com/thing:3518739)

# Contributing
The project was designed using Fusion 360, under their hobbyist license. Upon updating or creating a new design, export and upload the requisite STEP files. Keep individual components in separate STEP files. This makes it easy to insert components into designs and allows each part to have a separate file history.

repository: Ansuzalgiz/NerfCADKit

repo_name: Ansuzalgiz/NerfCADKit


text:
# Gravity Transmitter for Microsoft SQL Server

The gravity transmitter is used to write data to MSSQL database.

## Installation

You can compile gravity-transmitter-mssql with the following commands:

```shell
go build ./cmd/gravity-transmitter-mssql
```

## License

Licensed under the MIT License

## Authors

Copyright(c) 2020 Fred Chien<EMAIL_ADDRESS>
Copyright(c) 2020 Jhe Sue<EMAIL_ADDRESS>

repository: BrobridgeOrg/gravity-transmitter-mssql

repo_name: BrobridgeOrg/gravity-transmitter-mssql


text:
---
title: Pulse Concepts
---

## Structure

Pulse was designed to take all business logic out of components, meaning your React/Vue/Angular components are essencially puppets for Pulse to orchestrate. The benifit of keeping logic seperate to visual components is versitility, upgradablity and cleanliness. An example would be with Notify's codebase, the majority of the business logic is in a repository called `notify-core` and our components are purely React code with hooks into the core. This allows us the freedom to build different components for different platforms that all behave the same way.

## Reactivity

Reactive data is state that will react to mutations in order to cause component re-renders. Components can subscribe to Pulse state and will be updated when the state changes.

## Thesaurus

:::tip How we refer to our own classes
In these docs we will refer to our classes with a capital first letter. When you see "state" we're referring to the programming concept `state`, but when you see `State` we're referring to our [State]() class.
:::

- **Pulse Instance**: The result of initializing Pulse, a refrence to your Pulse application.
- **The Core**: You library of State, Collections and Controllers in a single object.
- **Reactivity**: The concept of state mutations causing component re-renders automatically.
- **Declaration**: Refers to logic as it is declared in the code, the opposite of this would be runtime.
- **Runtime**: When Pulse is fully initialized and the core is ready, runtime begins. Runtime handles queuing state changes.
- **Primary Key**: Refers to the identifier used to index data items within a Collection, a `string` or `number`. Also known as "pk" or "id".

repository: pulse-framework/pulse

gha_language: TypeScript

repo_name: pulse-framework/pulse


text:
### These documents are quick highlights of python features.
#### For new python users, the following order is suggested:
 * [Parameters](https://github.com/pryano/python_docs/blob/master/parameters.md)
 * [List Comprehensions and Generator Expressions](https://github.com/pryano/python_docs/blob/master/list_comps_and_gen_exp.md)
 * [Setup and Distribution](https://github.com/pryano/python_docs/blob/master/setup_and_distribution.md)
 * [Decorators](https://github.com/pryano/python_docs/blob/master/decorators.md)

#### And the following are for reference as needed:
 * [Pytest](https://github.com/pryano/python_docs/blob/master/pytest_doc.md)
 * [MongoEngine](https://github.com/pryano/python_docs/blob/master/mongoengine.md)
 * [Tox](https://github.com/pryano/python_docs/blob/master/tox.md)


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

Nothing so far.

## [0.7.0] - 2020-08-04

I've tested the library for production use at SBT Instruments.
This uncovered a bunch of bugs and missing features that I've adressed
in this release. We are approaching a 1.0.0 release. Let me know
if you want something changed before that via the issue tracker on GitHub.

### Added
- Add support for MQTTv5.
- Add `will` keyword argument to `Client`.
- Add `MqttConnectError` with specific error messages for connection failures.
- Add `Client.id` property that returns the client ID (or `None` if
  the client ID was not specified during construction).

### Fixed
- Fix unhandled exception error.
- Fix "Task was destroyed but it is pending" error.
- Fix compatibility with `asyncqt`'s event loop.
- Fix race condition in `Client.connect` that raised an `AttributeError`.
- Fix "[asyncio] Future exception was never retrieved" debug message.
- Fix support for python 3.6.
  Contributed by [Derrick Lyndon Pallas (@pallas)](https://github.com/pallas) in [#12](https://github.com/sbtinstruments/asyncio-mqtt/pull/12)

## [0.6.0] - 2020-06-26
### Changed
- No longer logs exception in `Client.__aexit__`. It's perfectly valid
  to exit due to, e.g., `asyncio.CancelledError` so let's not treat it as an
  error.

## [0.5.0] - 2020-06-08
### Added
- Add support for python 3.6.
  Contributed by [Derrick Lyndon Pallas (@pallas)](https://github.com/pallas) in [#7](https://github.com/sbtinstruments/asyncio-mqtt/pull/7) (1/2).
- Add `client_id` and `tls_context` keyword arguments to the `Client` constructor.
  Contributed by [Derrick Lyndon Pallas (@pallas)](https://github.com/pallas) in [#7](https://github.com/sbtinstruments/asyncio-mqtt/pull/7) (2/2).
- Add `timeout` keyword argument to both `Client.connect` and `Client.disconnect`. Default value of `10` seconds (like the other functions).

### Changed
- Propagate disconnection errors to subscribers. This enables user code to detect if a disconnect occurs. E.g., due to network errors.

## [0.4.0] - 2020-05-06
### Changed
- **BREAKING CHANGE:** Forward the [MQTTMessage](https://github.com/eclipse/paho.mqtt.python/blob/1eec03edf39128e461e6729694cf5d7c1959e5e4/src/paho/mqtt/client.py#L355)
  class from paho-mqtt instead of just the `payload`. This applies to both
  `Client.filtered_messages` and `Client.unfiltered_messages`.

  This way, user code not only gets the message `payload` but also the `topic`, `qos` level, `retain` flag, etc.

  Contributed by [Matthew Bradbury (@MBradbury)](https://github.com/MBradbury) in [#3](https://github.com/sbtinstruments/asyncio-mqtt/pull/3).

## [0.3.0] - 2020-04-13
### Added
- Add `username` and `password` keyword arguments to the `Client` constructor.
  Contributed by [@gluap](https://github.com/gluap) in [#1](https://github.com/sbtinstruments/asyncio-mqtt/pull/1).

### Fixed
- Fix log message context for `Client.filtered_messages`.

## [0.2.1] - 2020-04-07
### Fixed
- Fix regression with the `Client._wait_for` helper method introduced in the latest
  release.

## [0.2.0] - 2020-04-07
### Changed
- **BREAKING CHANGE:** Replace all uses of `asyncio.TimeoutError` with `MqttError`.

  Calls to `Client.subscribe`/`unsubscribe`/`publish` will no longer raise `asyncio.TimeoutError.`

  The new behaviour makes it easier to reason about, which exceptions the library
  throws:
  - Wrong input parameters? Raise `ValueError`.
  - Network or protocol failures? `MqttError`.
  - Broken library state? `RuntimeError`.

## [0.1.3] - 2020-04-07
### Fixed
- Fix how keyword arguments are forwarded in `Client.publish` and `Client.subscribe`.

## [0.1.2] - 2020-04-06
### Fixed
- Remove log call that was erroneously put in while debugging the latest release.

## [0.1.1] - 2020-04-06
### Fixed
- Add missing parameters to `Client.publish`.
- Fix error in `Client.publish` when paho-mqtt publishes immediately.

## [0.1.0] - 2020-04-06
Initial release.

repository: madnadyka/asyncio-mqtt

repo_name: madnadyka/asyncio-mqtt


text:
![NPM](https://img.shields.io/npm/dt/cham.svg)

# cham
cham is a presentation and transformation layer for complex REST APIs build in JS. It's inspirated by [Fractal](https://github.com/thephpleague/fractal).

## Installation
Via NPM:
```
npm i --save cham
```

Via Yarn:
```
yarn add cham
```

## Usage
### Creating transformers
```javascript
import { TransformerAbstract } from 'cham'
import CommentTransformer from './CommentTransformer'

export default class UserTransformer extends TransformerAbstract {
  includes = [
    'comments',
  ]

  transform(object) {
    return {
      name: object.name,
      fullName: `${object.name} ${object.lastName}`
    }
  }

  includeComments(object) {
    return this.collection(object.comments, new CommentTransformer);
  }
}
```

### Transform
```javascript
import { Manager, Resource } from 'cham'
import UserTransformer from './Transformers/UserTransformer'

var manager = new Manager()

var users = new Resource.Collection(usersFromDB, new UserTransformer)

// Transformed users ready for API output
manager.createData(users)
```

repository: milanvanschaik/cham

repo_name: milanvanschaik/cham


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# mypackage

<!-- badges: start -->

[![R-CMD-check](https://github.com/LouMamalis/mypackage/workflows/R-CMD-check/badge.svg)](https://github.com/LouMamalis/mypackage/actions)
<!-- badges: end -->

The goal of mypackage is to …

## Installation

You can install the development version of my package from GitHub

``` r
devtools::install_github("LouMamalis/mypackage")
```

## Example

This is a basic example which shows you how to print a generic greeting:

``` r
library(mypackage)
## basic example code
hello()
#> [1] "Hello, world from Lou!"
#>
#>  -----
#> Hello world from Lou!
#>  ------
#>     \
#>      \
#>        '\__
#>       (o )     ___
#>       <>(_)(_)(___)
#>         < < > >
#>         ' ' ` `  [nosig]
#>
```

This is a basic example which shows you how to print a personalised
greeting:

``` r
library(mypackage)
## basic example code
hello(name = "Bella")
#> [1] "Hello, world from Lou!"
#>
#>  -----
#> Hello Bella from Lou!
#>  ------
#>     \
#>      \
#>       \
#>          __
#>         /o \
#>       <=   |         ==
#>         |__|        /===
#>         |   \______/  =
#>         \     ====   /
#>          \__________/     [ab]
```

repository: LouMamalis/mypackage

repo_name: LouMamalis/mypackage


text:
# Unit 20 React Homework: React Portfolio

Now that I've worked with React and have multiple projects to share, I'll be updating my portfolio and other materials to build toward being employer competitive. Creating a portfolio using React will help set me apart from other developers whose portfolios do not use some of the latest technologies.

## Demo Link

https://watch.screencastify.com/v/QKR3k46YamJRQ8MrnWuS

## Instructions

- [Updated Portfolio](#updated-portfolio)

- [Design](#design)

- [React](#react)

- [Updated LinkedIn Profile](#updated-linkedin-profile)

branch_name: refs/heads/main