text:
tidyjson
================

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

[![CRAN_Status_Badge](http://www.r-pkg.org/badges/version/tidyjson)](https://cran.r-project.org/package=tidyjson)
[![Build
Status](https://travis-ci.org/colearendt/tidyjson.svg?branch=master)](https://travis-ci.org/colearendt/tidyjson)
[![Coverage
Status](https://codecov.io/github/colearendt/tidyjson/coverage.svg?branch=master)](https://codecov.io/github/colearendt/tidyjson?branch=master)

[![CRAN
Activity](http://cranlogs.r-pkg.org/badges/tidyjson)](https://cran.r-project.org/package=tidyjson/index.html)
[![CRAN
History](http://cranlogs.r-pkg.org/badges/grand-total/tidyjson)](https://cran.r-project.org/package=tidyjson/index.html)

![tidyjson
graphs](https://cloud.githubusercontent.com/assets/2284427/18217882/1b3b2db4-7114-11e6-8ba3-07938f1db9af.png)

tidyjson provides tools for turning complex [json](http://www.json.org/)
into
[tidy](https://cran.r-project.org/package=tidyr/vignettes/tidy-data.html)
data.

## Installation

Get the released version from CRAN:

``` r
install.packages("tidyjson")
```

or the development version from github:

``` r
devtools::install_github("colearendt/tidyjson")
```

## Examples

The following example takes a character vector of 500 documents in the
`worldbank` dataset and spreads out all objects.
Every JSON object key gets its own column with types inferred, so long
as the key does not represent an array. When `recursive=TRUE` (the
default behavior), `spread_all` does this recursively for nested objects
and creates column names using the `sep` parameter (i.e. `{"a":{"b":1}}`
with `sep='.'` would generate a single column: `a.b`).

``` r
library(dplyr)
library(tidyjson)

worldbank %>% spread_all
#> # A tbl_json: 500 x 9 tibble with a "JSON" attribute
#>    ..JSON        docum…¹ board…² closi…³ count…⁴ proje…⁵ regio…⁶ total…⁷ _id.$…⁸
#>    <chr>           <int> <chr>   <chr>   <chr>   <chr>   <chr>     <dbl> <chr>
#>  1 "{\"_id\":{\…       1 2013-1… 2018-0… Ethiop… Ethiop… Africa   1.3 e8 52b213…
#>  2 "{\"_id\":{\…       2 2013-1… <NA>    Tunisia TN: DT… Middle…  0      52b213…
#>  3 "{\"_id\":{\…       3 2013-1… <NA>    Tuvalu  Tuvalu… East A…  6.06e6 52b213…
#>  4 "{\"_id\":{\…       4 2013-1… <NA>    Yemen,… Gov't … Middle…  0      52b213…
#>  5 "{\"_id\":{\…       5 2013-1… 2019-0… Lesotho Second… Africa   1.31e7 52b213…
#>  6 "{\"_id\":{\…       6 2013-1… <NA>    Kenya   Additi… Africa   1   e7 52b213…
#>  7 "{\"_id\":{\…       7 2013-1… 2019-0… India   Nation… South …  5   e8 52b213…
#>  8 "{\"_id\":{\…       8 2013-1… <NA>    China   China … East A…  0      52b213…
#>  9 "{\"_id\":{\…       9 2013-1… 2018-1… India   Rajast… South …  1.6 e8 52b213…
#> 10 "{\"_id\":{\…      10 2013-1… 2014-1… Morocco MA Acc… Middle…  2   e8 52b213…
#> # … with 490 more rows, and abbreviated variable names ¹document.id,
#> #   ²boardapprovaldate, ³closingdate, ⁴countryshortname, ⁵project_name,
#> #   ⁶regionname, ⁷totalamt, ⁸`_id.$oid`
```

Some objects in `worldbank` are arrays, which are not handled by
`spread_all`. This example shows how to quickly summarize the top level
structure of a JSON collection

``` r
worldbank %>% gather_object %>% json_types %>% count(name, type)
#> # A tibble: 8 × 3
#>   name                type       n
#>   <chr>               <fct>  <int>
#> 1 _id                 object   500
#> 2 boardapprovaldate   string   500
#> 3 closingdate         string   370
#> 4 countryshortname    string   500
#> 5 majorsector_percent array    500
#> 6 project_name        string   500
#> 7 regionname          string   500
#> 8 totalamt            number   500
```

In order to capture the data in the `majorsector_percent` array, we can
use `enter_object` to enter into that object, `gather_array` to stack
the array and `spread_all` to capture the object items under the array.

``` r
worldbank %>%
  enter_object(majorsector_percent) %>%
  gather_array %>%
  spread_all %>%
  select(-document.id, -array.index)
#> # A tbl_json: 1,405 x 3 tibble with a "JSON" attribute
#>    ..JSON                  Name                                    Percent
#>    <chr>                   <chr>                                     <dbl>
#>  1 "{\"Name\":\"Educat..." Education                                    46
#>  2 "{\"Name\":\"Educat..." Education                                    26
#>  3 "{\"Name\":\"Public..." Public Administration, Law, and Justice      16
#>  4 "{\"Name\":\"Educat..." Education                                    12
#>  5 "{\"Name\":\"Public..." Public Administration, Law, and Justice      70
#>  6 "{\"Name\":\"Public..." Public Administration, Law, and Justice      30
#>  7 "{\"Name\":\"Transp..." Transportation                              100
#>  8 "{\"Name\":\"Health..." Health and other social services            100
#>  9 "{\"Name\":\"Indust..." Industry and trade                           50
#> 10 "{\"Name\":\"Indust..." Industry and trade                           40
#> # … with 1,395 more rows
```

## API

### Spreading objects into columns

- `spread_all()` for spreading all object values into new columns, with
  nested objects having concatenated names

- `spread_values()` for specifying a subset of object values to spread
  into new columns using the `jstring()`, `jinteger()`, `jdouble()` and
  `jlogical()` functions. It is possible to specify multiple parameters
  to extract data from nested objects (i.e. `jstring('a','b')`).

### Object navigation

- `enter_object()` for entering into an object by name, discarding all
  other JSON (and rows without the corresponding object name) and
  allowing further operations on the object value

- `gather_object()` for stacking all object name-value pairs by name,
  expanding the rows of the `tbl_json` object accordingly

### Array navigation

- `gather_array()` for stacking all array values by index, expanding the
  rows of the `tbl_json` object accordingly

### JSON inspection

- `json_types()` for identifying JSON data types

- `json_length()` for computing the length of JSON data (can be larger
  than `1` for objects and arrays)

- `json_complexity()` for computing the length of the unnested JSON,
  i.e., how many terminal leaves there are in a complex JSON structure

- `is_json` family of functions for testing the type of JSON data

### JSON summarization

- `json_structure()` for creating a single fixed column data.frame that
  recursively structures arbitrary JSON data

- `json_schema()` for representing the schema of complex JSON, unioned
  across disparate JSON documents, and collapsing arrays to their most
  complex type representation

### Creating tbl_json objects

- `as.tbl_json()` for converting a string or character vector into a
  `tbl_json` object, or for converting a `data.frame` with a JSON column
  using the `json.column` argument

- `tbl_json()` for combining a `data.frame` and associated `list`
  derived from JSON data into a `tbl_json` object

- `read_json()` for reading JSON data from a file

### Converting tbl_json objects

- `as.character.tbl_json` for converting the JSON attribute of a
  `tbl_json` object back into a JSON character string

### Included JSON data

- `commits`: commit data for the dplyr repo from github API

- `issues`: issue data for the dplyr repo from github API

- `worldbank`: world bank funded projects from jsonstudio

- `companies`: startup company data from jsonstudio

## Philosophy

The goal is to turn complex JSON data, which is often represented as
nested lists, into tidy data frames that can be more easily manipulated.

- Work on a single JSON document, or on a collection of related
  documents

- Create pipelines with `%>%`, producing code that can be read from left
  to right

- Guarantee the structure of the data produced, even if the input JSON
  structure changes (with the exception of `spread_all`)

- Work with arbitrarily nested arrays or objects

- Handle ‘ragged’ arrays and / or objects (varying lengths by document)

- Allow for extraction of data in values or object names

- Ensure edge cases are handled correctly (especially empty data)

- Integrate seamlessly with `dplyr`, allowing `tbl_json` objects to pipe
  in and out of `dplyr` verbs where reasonable

## Related Work

Tidyjson depends upon

- [magrritr](https://github.com/tidyverse/magrittr) for the `%>%` pipe
  operator
- [jsonlite](https://github.com/jeroen/jsonlite) for converting JSON
  strings into nested lists
- [purrr](https://github.com/tidyverse/purrr) for list operators
- [tidyr](https://github.com/tidyverse/tidyr) for unnesting and
  spreading

Further, there are other R packages that can be used to better
understand JSON data

- [listviewer](https://github.com/timelyportfolio/listviewer) for
  viewing JSON data interactively

repository: colearendt/tidyjson

gha_language: R

repo_name: colearendt/tidyjson


text:
# _Vendor and Order Tracker_

#### _Epicodus C# Week 3 solo project, 3/13/2020_

#### By _Matt Taylor_

## Description

_This application project is an exercise in C# using the MVC framework._

## Behavior Driven Development
| Behavior | Input | Output |
|----|----|-----|
|User navigates to the site and is greeted with a splash page|'localhost:5000'|Splash page is displayed|
|User fills out a vendor form to create a new vendor|User types in name and clicks submit|Entered name is added to a list of vendors|
|User clicks a link that displays a list of entered vendors|'Click on link'|Vendor list page is displayed|
|User clicks a vendor name to see that vendor's orders|User clicks on a vendor name in the list|Link redirects to a page displaying that vendor's orders|
|User fills out an order form that is saved to a specific vendor id|loaves of bread, 2|Suzie's Cafe, loaves of bread, 2|
|Progam generates a total order cost based on bread for $2 and pastries for $1|User enters an order of 12 loaves and 12 pastries|$36|

## Setup/Installation Requirements

* Open Terminal
* Type ``$ git clone https://github.com/mtaylorpdx/OrderTracker.Solution``
* Navigate to the directory WordCounter.Solution/WordCounter
* Type ``$ dotnet run``
* Open your browser and enter the address ``localhost:5000``

## Support and contact details

Email [@Matt <EMAIL_ADDRESS>
## Technologies Used

* Git
* C#
* .NET Core
* ASP.NET Razor

### License

*Licensed under the MIT License*

Copyright (c) 2020 **_Matt Taylor_**

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# The QUIC protocol
[QUIC][QUIC] is a general-purpose network protocol built on top of UDP.
The protocol is still under development and standardized by the [IETF][IETF].
Quinn strives to implement the latest [draft][draft] but may lag a bit behind. Although QUIC is still in a draft phase,
the protocol is used for all connections from Chrome web browsers to the Google servers.

QUIC solves a number of transport-layer and application-layer problems experienced by modern web applications.
It is very similar to TCP+TLS+HTTP2, but implemented on top of UDP.
Having QUIC as a self-contained protocol allows innovations which aren’t
possible with existing protocols as they are hampered by legacy clients and middleboxes.

Key advantages of QUIC over TCP+TLS+HTTP2 include:
* Improved connection establishment speed (0-rtt).
* Improved congestion control by moving congestion control algorithms into the user space at both endpoints.
* Improved bandwidth estimation in each direction to avoid congestion.
* Improved multiplexing without head-of-line blocking.
* Contains forward error correction (FEC).

While QUIC's intentions are originally web-oriented, it offers interesting opportunities in other areas like game networking.
One thing is for sure, QUIC has many great potentials and will serve us in the future with HTTP/3.

In the upcoming chapter we will be discussing various aspects of QUIC also in relation to Quinn.

[draft]: https://datatracker.ietf.org/doc/draft-ietf-quic-transport/
[IETF]: https://www.ietf.org/
[QUIC]: https://en.wikipedia.org/wiki/QUIC

repository: imp/quinn

gha_language: Rust

repo_name: imp/quinn


text:
# Rich Text Editor (RTE) Configurations

Under the RTE Configs tab you can manage all configuration sets for any installed RTEs.

![RTE Configs Grid](img/rte_configs_grid.png)

RTE configs must have a unique name, which is used in [data-fred-rte-config](/elements/attributes/#data-fred-rte-config) attribute to determin which RTE to use, if any.

Make sure RTE configs are valid JSON; you can use [JSON Lint](https://jsonlint.com/) as an external service or the [ACE editor](https://modx.com/extras/package/ace) MODX Extra which shows invalid JSON in the line-number columns as a white X in a red box.

## Default Configs

If you create a config with a same name as your RTE, for example `TinyMCE`, this config will be used as a default one (instead of the one TinyMCE is shipped with).

### Overriding Default Configs

Each option set can specify which RTE to use for the entire Element. In addition, a [data-fred-rte-config](/elements/attributes/#data-fred-rte-config) attribute on an HTML element with a `content-editable="true"` attribue set will override both the Default and Option set specified settings.

repository: rthrash/fred

gha_license_id: MIT

repo_name: rthrash/fred


text:
### Regex Basics

* [abc] A single character: a, b or c
* [^abc] Any single character but a, b, or c
* [a-z] Any single character in the range a-z
* [a-zA-Z] Any single character in the range a-z or A-Z
* [1-9] any number between 1 and 9
* ^ Start of line
* $ End of line
* \A Start of string
* \z End of string

### Shortcuts (meta characters)

* . Any single character
* \s Any whitespace character
* \S Any non-whitespace character
* \d Any digit
* \D Any non-digit
* \w Any word character (letter, number, underscore)
* \W Any non-word character
* \b Any word boundary character

### Groups
* (...) Capture everything enclosed
* (a|b) a or b
* ? Zero or one of a
* \* Zero or more of a
* \+ One or more of a
* {3} Exactly 3 of a
* {3,} 3 or more of a
* a{3,6} Between 3 and 6 of a

### Characters that needs to be escaped.
* They are escaped with a backward slash \\\
* Characters are:

```
. | ( ) [ ] { } + \ ^ $ * ?
```

repository: javasop/regex

repo_name: javasop/regex


text:
# Postgres Examples, part B (14)

## Verify Docker is up and running:

```r
result <- system2("docker", "version", stdout = TRUE, stderr = TRUE)
result
```

```
##  [1] "Client:"
##  [2] " Version:           18.06.1-ce"
##  [3] " API version:       1.38"
##  [4] " Go version:        go1.10.3"
##  [5] " Git commit:        e68fc7a"
##  [6] " Built:             Tue Aug 21 17:21:31 2018"
##  [7] " OS/Arch:           darwin/amd64"
##  [8] " Experimental:      false"
##  [9] ""
## [10] "Server:"
## [11] " Engine:"
## [12] "  Version:          18.06.1-ce"
## [13] "  API version:      1.38 (minimum version 1.12)"
## [14] "  Go version:       go1.10.3"
## [15] "  Git commit:       e68fc7a"
## [16] "  Built:            Tue Aug 21 17:29:02 2018"
## [17] "  OS/Arch:          linux/amd64"
## [18] "  Experimental:     true"
```
verify pet DB is available, it may be stopped.

```r
result <- system2("docker", "ps -a", stdout = TRUE, stderr = TRUE)
result
```

```
## [1] "CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                     PORTS               NAMES"
## [2] "ccdfda6d6d71        postgres:10         \"docker-entrypoint.s…\"   29 seconds ago      Exited (0) 2 seconds ago                       sql-pet"
```

```r
any(grepl('Up .+pet$',result))
```

```
## [1] FALSE
```
Start up the `docker-pet` container

```r
result <- system2("docker", "start sql-pet", stdout = TRUE, stderr = TRUE)
result
```

```
## [1] "sql-pet"
```

now connect to the database with R

```r
con <- wait_for_postgres(user = Sys.getenv("DEFAULT_POSTGRES_USER_NAME"),
                         password = Sys.getenv("DEFAULT_POSTGRES_PASSWORD"),
                         dbname = "dvdrental",
                         seconds_to_test = 10)
```
All of the material from this file has moved to files 71, 72, and 73.

Clean up

```r
# dbRemoveTable(con, "cars")
# dbRemoveTable(con, "mtcars")
# dbRemoveTable(con, "cust_movies")

# diconnect from the db
dbDisconnect(con)

result <- system2("docker", "stop sql-pet", stdout = TRUE, stderr = TRUE)
result
```

```
## [1] "sql-pet"
```

repository: deemuni/sql-pet

gha_language: HTML

repo_name: deemuni/sql-pet


text:
# first-bootstrap
================================
![img](https://github.com/lPinchol/first-bootstrap/blob/master/R-Proyect/img/BoobsPrev.png)
Starting to play with Bootstrap. Gathering information and making teaching examples.

## Tools

* [Sublime Text 2](http://www.sublimetext.com/2)
* [Trello](https://trello.com)
* [Git 2.7.4](https://git-scm.com/)
* [GitHub](https://github.com/lPinchol/first-bootstrap)
* [Bootstrap **3.3.6**](http://getbootstrap.com/)

## Info

* [Trello](https://trello.com/b/gAm6carF/play-bootstrap)

repository: ninpl/first-bootstrap

repo_name: ninpl/first-bootstrap


text:
# Add Book Mutation

**Challenge** Create an addBook mutation.

Next we are going to create our second mutation that will create a new book. Open up your schema.js file and create your second mutation and call it addBook. This mutation will have the exact same structure as the addBook mutation. It will have a type of BookType. There are three arguments:
* name
* genre
* authorId

Make sure in the resolve function you return the book.save(). Your new mutation should look like this:

```js
addBook: {
    type: BookType,
    args: {
        name: { type: GraphQLString },
        genre: { type: GraphQLString },
        authorId: { type: GraphQLID }
    },
    resolve(parent, args){
        let book = new Book({
            name: args.name,
            genre: args.genre,
            authorId: args.authorId
        });
        return book.save();
    }
}
```

## Add Books

We can test out our new mutation to add books just like we did for addAuthor. This time instead of entering a dummy entry like we initially did with addAuthor instead I want you to add the books we had in our dummy data. In your mutation for the authorId you need to copy the id that MongoDB automatically created for that author.

```js
mutation {
  addBook (name: "Name of the Wind",genre: "Fantasy", authorId: "5c3138351460cb218bdbf86e") {
    name,
    genre
  }
}
```
## Verify Book Was Created
After you run the mutation, go to mLab and go to your home page. Click on your database. You should now see two collections in your database. one for authors and now one for books. Click on books. You should see the book that you just created in the collection.

Now take the time to add in all 6 of our books from our dummy data into the databse. When you are finished comment out the books array in your dummy data in the schema.js file.

repository: ratracegrad/graphql-workshop

gha_language: JavaScript

repo_name: ratracegrad/graphql-workshop


text:
## TEAMCITY

JetBrains TeamCity is a build server not unlike Jenkins, Team Foundation Server, Cruise Control, or Bamboo.  TeamCity is [free](https://www.jetbrains.com/teamcity/buy/) for up to 3 build agents and 20 build configurations, making it ideal for small companies.

### Setup

We'll need a Windows account to run the TeamCity website and build agent.  Technically these can run under the `SYSTEM` account, but there's cases where you'll want to login as the TeamCity account to install certificates or adjust registry keys.  Better to run TeamCity as a regular user.

You could choose to make this a domain user rather than a local user.

1. Right click on `This PC` (formerly `My Computer`), and choose Manage.

2. Choose Local Users and Groups then Users.

3. Right-click in the main window and choose `New User`.

4. Enter necessary user details.

  ![New User](images/08-teamcity/1-teamcity-user.png)

5. Ensure `User must change password` is **not** checked, `User cannot change password` is checked, and `Password never expires` is checked.

6. Click `Create`.

7. Open the newly created user, choose `Member Of`, and add `Administrators`.  The user may stop and start services, configure IIS settings, or other behaviors restricted to administrative users, so best to give this account access up front.

### Install

1. Download [TeamCity](https://www.jetbrains.com/teamcity/download/)

2. Launch `TeamCity-bunch_of_numbers.exe`.

3. Click next until it installs TeamCity.

4. Change the port to `8080` because IIS runs on port 80 by default.

  ![Change Port](images/08-teamcity/3-change-port.png)

5. No changes are needed on this page, but grab a screen shot for reference later.  The TeamCity documentation refers to , but the TeamCity documentation makes reference to the `System Directory`, `Work Directory`, and the `Data Directory` which is not shown here, but stored in `C:\ProgramData\JetBrains\TeamCity`.

  ![Build Agent Properties](images/08-teamcity/4-build-agent-properties.png)

6. For both the TeamCity Server and TeamCity Agent, choose to run under a user account.

  ![User Account](images/08-teamcity/5-run-as-user-account.png)

7. Enter the account details for the user created above.

  ![User Credentials](images/08-teamcity/6-user-credentials.png)

8. Choose to Open the TeamCity UI after setup is finished, which will open [http://localhost:8080/](http://localhost:8080/) in your default browser.

### Configuration Setup

TeamCity will connect via JDBC username/password to SQL Server, so let's set up a database and user.

1. Start -> SQL Server Management Studio (SSMS)

2. Connect to the local database using Windows Authentication.

3. Right-click on Databases, and choose `New Database`.

  ![New Database](images/08-teamcity/7-new-database.png)

4. Enter a Database Name, and click Create.

  ![Database Name](images/08-teamcity/8-database-name.png)

5. Inside Security, right-click on Logins and choose `New Login`.

  ![New Login](images/08-teamcity/9-new-login.png)

6. Enter the Login Name, password, uncheck `Enforce password policy`, and change the Default database to the database created above.

  ![New User](images/08-teamcity/10-database-user.png)

7. Switch to the `User Mapping` page, and set:

  a. Check the database created above.

  b. Set default schema to `dbo`.

  c. Check `db_owner` because TeamCity will create tables.

  ![User Mapping](images/08-teamcity/11-database-user-mapping.png)

  (Technically you only need `db_owner` as you first configure TeamCity and whenever you upgrade to a new TeamCity version.)

8. Click `OK` to create the user.

### Configure

1. If it didn't launch already, open [http://localhost:8080/](http://localhost:8080/) in your favorite browser.

2. Click Proceed.

3. Configure the database connection by choosing:

   a. `MS SQL Server` as the database type.

   b. Download [Microsoft JDBC Driver](https://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=11774)

   c. Unzip `sqljdbc_6.0.8112.100_enu.exe` to a convinient directory.

   d. Copy `sqljdbc42.jar` from the `enu\jre8` folder to `C:\ProgramData\JetBrains\TeamCity\lib\jdbc`

   e. Back on the TeamCity website, click `Refresh JDBC drivers`.

   f. Enter the database name you created above.

   g. Enter the username and password you created above.

   ![Database Configuration](images/08-teamcity/12-database-configuration.png)

   h. Click Proceed.

3. Click next a few times.

4. Create the Administrator account -- the first user login to TeamCity.

5. You may choose to set your name and email address, or skip it by hitting the TeamCity logo on the top-left.

6. Choose Administration on the top-right.

7. In Global Settings, change the `Default VCS trigger quiet period` to `1` second -- the time after it notices changes before it starts building.  The quiet period allows the server to wait for other commits and build them all together.  60 seconds is great for a real build server, but you won't want to wait a minute after pushing changes before the build kicks up.

8. In Global Settings, change the `Default VCS changes check interval` to `5` seconds.  60 seconds is great for a real build server, but you won't want to wait a minute after pushing changes before the build server notices.

TeamCity is now setup and ready to add new builds.


text:
---
layout: default
---

# 1996-11-09 - allow me to state the obvious....

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 4b89efca2f725fa98685bf1ecee65290a1798dc3694596f916fd672518890cc6

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-11-09 09:11:21 UTC

Raw Date: Sat, 9 Nov 1996 01:11:21 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Sat, 9 Nov 1996 01:11:21 -0800 (PST)
To<EMAIL_ADDRESS>Subject: allow me to state the obvious....
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

i am your average joe who uses the computer for work and e-mail and the
occasional jaunt into the internet. going along reading this whole
crypto-anarchy thing makes me want to cry. the whole point of cryptography
is getting info from my eyes to yours. period. you can say that "illegal"
information passes along the internet, but hello people - illegalities have
been going on since long before the invention of the computer (or even the
notion of cryptography - if i may stop to point out the obvious).  the only
reason _i_ use encrypted stuff is because i don't want my nosy sysadmin
reading my mail.  its that simple.  think about it.  how many times is your
e-mail handed off?  when sent it naturally follows the most convenient path
to its destination, and even anonymous re-mailers (can) keep a hard copy of
the messages that cross their connections with the original address
included.  you can go off into spoofing address and so on, but your average
joe may (or may not) have the time or knowledge (much less the motivation)
to do that.  keep that in mind before you go saying that crypto is a
good/bad thing.

----------------------<EMAIL_ADDRESS>-----------------------
  a calculated risk based on the possible consequence of an action
 is better than a haphazard one based on poor judgment or ignorance
---------------------------------------------------------------------
Don't confuse my views with those of the DoD or the United States Navy

{% endraw %}
```

## Thread

+ Return to [November 1996](/archive/1996/11)

+ Return to "["Mark M." <markm@voicenet.com>](/authors/mark_m__markm_at_voicenet_com_)"
+ Return to "[SUCRUM22_at_INDY-ADP@smtp-gw.cv62.navy.mil](/authors/sucrum22_at_indyadp_at_smtpgw_cv62_navy_mil)"
+ Return to "[Ted Garrett <teddygee@visi.net>](/authors/ted_garrett_teddygee_at_visi_net_)"
+ Return to "["Timothy C. May" <tcmay@got.net>](/authors/timothy_c_may_tcmay_at_got_net_)"
+ Return to "["William F. Towey" <liam@webspan.net>](/authors/william_f_towey_liam_at_webspan_net_)"

+ 1996-11-09 (Sat, 9 Nov 1996 01:11:21 -0800 (PST)) - allow me to state the obvious.... -<EMAIL_ADDRESS>  + 1996-11-09 (Sat, 9 Nov 1996 11:40:13 -0800 (PST)) - [Re: allow me to state the obvious....](/archive/1996/11/6e3bd8cffa01b340980449fefd462d04d0a7ae2c5883fe4136cc5092dfd578df) - _"Timothy C. May"<EMAIL_ADDRESS>    + 1996-11-10 (Sat, 9 Nov 1996 16:52:54 -0800 (PST)) - [Re: allow me to state the obvious....](/archive/1996/11/0735e32b5950377f0f278c5ef6110890ec08056e873840de0a306ee547dc7395) - _"William F. Towey"<EMAIL_ADDRESS>      + 1996-11-10 (Sun, 10 Nov 1996 07:51:50 -0800 (PST)) - [Re: allow me to state the obvious....](/archive/1996/11/dea9dd83758a8aadc09195e65c0eba4f8257b1a6579a2de74a91a03b3d6ce6ac) - _Ted Garrett<EMAIL_ADDRESS>  + 1996-11-09 (Sat, 9 Nov 1996 12:09:09 -0800 (PST)) - [Re: allow me to state the obvious....](/archive/1996/11/8dea89aa7a725a50a5dddecbac8448f74804da17d619fe0cae8b31129384ba30) - _"Mark M."<EMAIL_ADDRESS>


text:
# Branch deploy integrator

The builds that deploy ~atlaskit~ atlassian-frontend branch deploys into products.
We deploy these plans to https://engservices-bamboo.internal.atlassian.com/browse/ABDPI.

## How it works

Background info: https://product-fabric.atlassian.net/wiki/spaces/AFP/pages/966233273/Run+product+tests+against+Atlaskit+PR+s

## Adding a new product

1. Copy-pasta a existing product's groovy file
2. Update the product names in the groovy file
3. update the file with the right settings for the branch-deploy-integrator CLI
4. Check the file in and push it
5. Add a "Plan Template Execution" to https://engservices-bamboo.internal.atlassian.com/build/admin/edit/editBuildTasks.action?buildKey=ABDPI-BDIG-JOB1. Make sure it points to your new groovy.
6. Boom done, if you wanna test it while in development set the jobs running strategy to: "Execute on both Master and Branches". But make sure to switch this back to "Execute on Master, validate only on Branches" when you are done.

repository: darshgun/atlaskit

repo_name: darshgun/atlaskit


text:
---
title: "AppSync"
linkTitle: "AppSync"
categories: ["LocalStack Pro"]
description: >
  AppSync
---

Basic support for AppSync is included in LocalStack Pro. The local AppSync API allows you to spin up local GraphQL APIs and directly expose your data sources (e.g., DynamoDB tables) to external clients.

For example, you can create a DynamoDB table `"posts"` with a key attribute `id`, and define a GraphQL schema in a file `schema.graphql` like this:
```
schema {
    query: Query
}
type Query {
    getPosts: [Post!]!
}
type Post {
    id: DDBString!
}
type DDBString {
    S: String!
}
```
... and then use the AppSync API (or CloudFormation) to create the following entities:

1. a GraphQL API
2. a data source of type `AMAZON_DYNAMODB` that references the `"posts"` DynamoDB table
3. a request mapping template with a content like this:
```json
{
    "version" : "2017-02-28",
    "operation" : "Scan"
}
```
4. a response mapping template with a content like this:
```javascript
$util.toJson($context.result["Items"])
```

Once things have been wired up properly, and assuming the ID of your GraphQL API is `"api123"`, you should be able to run the following GraphQL query to retrieve all items from the `"posts"` DynamoDB table:
{{< command >}}
$ curl -d '{"query":"query {getPosts{id{S}}}"}' http://localhost:4605/graphql/api123
{{< / command >}}

For more details, please refer to the self-contained sample published in [this Github repository](https://github.com/localstack/localstack-pro-samples/tree/master/appsync-graphql-api).

repository: larkinwc/docs

branch_name: refs/heads/main

repo_name: larkinwc/docs


text:
---
layout: post
title: Church encoding products and coproducts
---

In a [previous
post](http://jobjo.github.io/2015/02/04/existensially-quantified-types-fsharp.html)
I gave an example of how to represent algebraic data types using church
encoding. In this post I'll pick up the thread and show how this technique can
be used to mimic any type.

There are two ways of constructing new types in functional programming
languages; Either by using a sum type or a product type. Products are
composite types such a records and tuples. Sum types are for representing data that can take
different shapes and are usually described using an algebraic data type
(know as discriminated unions in OCaml or FSharp).

### Products
In category theory, the universal property of products states that any two
products $$P$$ and $$Q$$ with the same set of projection arrows must have unique morphisms
between them such that any diagram of the following type commutes:

$$
\begin{array}[c]{ccccc}

T_1 & \leftarrow & P        & \rightarrow  & T_2 \\
    & \nwarrow   & \uparrow \downarrow  & \nearrow    \\
    &            & Q

\end{array}
$$

To give a concrete example, in the category of types and functions in ML, the
tuple type `int * string` can be safely substituted with a record type:

```ocaml
type person = {name : string; age : int}
```

Proving this is trivial, one simply needs to define a function for converting
a tuple to a person:

```ocaml
let to_person (name,age) = { name = name; age = age }
```

And show that:

```ocaml
(to_person t).name = fst t
(to_person t).age  = snd t
```

`name`, `age`, `fst` and `snd` are the projection arrows. The equations
expresses commutativity in one direction.

Products of more than two components can be expressed as nested binary
products. For instance a three component product: $$A \times B \times C$$ is
isomorphic to $$A \times (B \times C)$$.

The following signature captures all there is to know about products,
abstracting over the concrete type:

```ocaml
module type Product = sig
    (* The type of the product. *)
    type ('a, 'b) product

    (* Creates a product given the components.*)
    val mk : 'a -> 'b -> ('a, 'b) product

    (* Extracts the first component. *)
    val fst : ('a, 'b) product -> 'a

    (* Extracts the second component. *)
    val snd : ('a, 'b) product -> 'b
end;;
```

First, let's implement the interface using tuples:

```ocaml
module Tuple_Product : Product = struct
    type ('a, 'b) product = 'a * 'b
    let mk x y = (x,y)
    let fst (x,_) = x
    let snd (_,y) = y
end;;
```

Can this interface be realized with simple functions, i.e. without resorting
to tuples or records for representing multiple properties? Church encoding
demonstrates that the answer is yes! A product type is isomorphic to a higher
order function where the function parameter accepts one argument per component
of the product. To give a concrete example, the product `'a * 'b` can be
encoded as a function `'('a -> 'b -> 'c) -> 'c`. It's clear that in order to
return a value of type `'c`, the function must invoke the continuation,
passing it an `'a` and a `'b` value. The particular values are captured within the closure of the
function. Here is the complete church implementation of the `Product`
signature:

```ocaml

module Church_Product : Product = struct
    type ('a , 'b) product = { run : 'c. ('a -> 'b -> 'c) -> 'c}
    let mk x y = { run = fun f -> f x y }
    let fst p = p.run @@ fun x _ -> x
    let snd p = p.run @@ fun _ y -> y
end;;
```

A nice thing with OCaml, comparing with F#, is the support for polymorphic
record properties (here needed for `run`).

### Coproducts
Coproduts in category theory look like products with all arrow reversed.
Instead of having arrows from a coproduct to other objects there are morphisms
from other objects to the coproduct. The following diagram depicts two
coproducts $$C$$ and $$U$$:

$$
\begin{array}[c]{ccccc}

T_1 & \rightarrow & C        & \leftarrow  & T_2 \\
    & \searrow   & \uparrow \downarrow  & \swarrow    \\
    &            & U

\end{array}
$$

Just like with products, the diagram must commute. In functional programming,
each arrow to coproduct type can be represented by a constructor of an
algebraic data type. For example:

```ocaml
type contact =
    | Email of string
    | Address of address
    | Phone of string
```
corresponds to two morphisms (`string -> contact`), for the `Email` and
`Phone` constructors and another (`address -> contact`) for the `Adress`
constructor.

Again, sum types with more than two constructors can be achieved by nesting,
so in order to define a generalized signature we only need to worry about the
binary case:

```ocaml
module type Coproduct = sig
    (* Type representing coproducts. *)
    type ('a, 'b) coproduct

    (* Constructs a value of the first shape. *)
    val left : 'a -> ('a, 'b) coproduct

    (* Constructs a value of the second shape. *)
    val right : 'b -> ('a, 'b) coproduct

    (* Runs a value given two continuations. *)
    val run : ('a, 'b) coproduct -> ('a -> 'c) -> ('b -> 'c) -> 'c
end;;
```

Following is an implementation using discriminated unions:

```ocaml
module DU_Coproduct = struct
    type ('a, 'b) coproduct = | Left of 'a | Right of 'b
    let left x = Left x
    let right x = Right x
    let run cp l r =
        match cp with
        | Left x  -> l x
        | Right x -> r x
end;;
```

A church encoded representation of a coproduct type with two constructors is
given by a function accepting one continuation per constructor. A function of
type `'('a -> 'c) -> ('b -> 'c) -> 'c`, can invoke either one of the passed
arguments and is equivalent to a discriminated union type with two cases.

### Implementing lists
To see how the generalized interfaces for product and coproduct can be used,
consider defining a simple list structure. First look at the standard
implementation of lists using a discriminated union:

```ocaml
let 'a list =
    | Nil
    | Cons of ('a * 'a list)
```

This can be translated to the following type in terms of the `Product` and
`Coproduct` signatures:

```ocaml
type 'a ch_list =
    { ext : (unit, ('a, 'a ch_list) product) coproduct }
```

The unit type is used to represent the `Nil` case. The non-empty case consists
of a product with value of type `a` and the rest of the list.

In order to simplify the creation of lists, here are a couple of helper
functions:

```ocaml

(* Helper for construct a list. *)
let mk_list v = { ext = v }

(* Empty list constructor. *)
let empty = mk_list @@ left ()

(* Cons list constructor.  *)
let cons x xs = mk_list @@ right @@ mk x xs
```

`empty` corresponds to `[]` in Ocaml and `cons` is equivalent to `(::)`.

We can also define a utility method for simulating pattern matching:

```ocaml
let rec match_list lst nil cons =
  run lst.ext
    nil
    (fun p -> cons (fst p) (snd p))
```

With these definitions, the standard `List.map` can be ported to:

```ocaml
let rec map f xs =
  match_list xs
    (fun _    -> empty)
    (fun x xs -> cons (f x) (map f xs))
```

A better implementation would use tail recursion but the principal is the same as with
ordinary lists.

At last, following are the conversion functions required for showing that the two
versions of lists are indeed isomorphic:

```ocaml

(* Convert to ordinary list. *)
let rec to_list lst =
  match_list lst
    (fun _    -> [])
    (fun x xs -> x :: (to_list xs))

(* Convert from ordinary list. *)
let rec from_list = function
  | []      -> empty
  | x :: xs -> cons x (from_list xs)
```


text:
# JIRA to Mattermost Integration

A Helm chart for https://github.com/int128/jira-to-slack.

## Prerequisites

- Kubernetes 1.9+ with Beta APIs enabled

## Getting Started

To install the chart with the release name `jira-to-slack`:

```sh
helm install ./jira-to-slack --name jira-to-slack
```

To upgrade to a more recent version of jira-to-slack:

```sh
helm upgrade jira-to-slack
```

To delete the release `jira-to-slack`:

```sh
helm delete jira-to-slack
```

## Configuration

The following table lists the configurable parameters of the chart and their default values.

Parameter | Description | Default
----------|-------------|--------
`ingress.enabled` |	Enable ingress controller resource.	| `false`
`ingress.hosts`	| Hostnames. | `[jira-to-slack.example.com]`
`resources.limits` | Pod resource limits. | `{}`
`resources.requests` | Pod resource requests. | `{}`
`nodeSelector` | Node labels for pod assignment | `{}`

gha_language: Smarty


text:
## OVERVIEW

Forked from [mlaihk/docker-dehydrated-Lexicon](https://github.com/mlaihk/docker-dehydrated-Lexicon)
to update with latest dns-lexicon(3.1.7).

This project is designed to be a small docker to Create/Renew Let's Encrypt Certs by making use of
the greate Dehydrated script by lukas2511 and Lexicon by AnalogJ. The image is based on Python:Alpine to make it as small as possible.
It also borrowed from idea from csmith that the domains.txt will be monitor realtime for changes.
The docker will need a volume /letsencrypt for storing app data and certs.
It will also require the following environment variables for dehydrated and the normal environment variables for Lexicon:

```
EMAIL: <Your email passed to Let's Encrypt for notifications>
PROVIDER: <Designate provider for Lexicon>
LEXICON_<PROVIDER>USERNAME: <Username to use for Lexicon to connect to your DNS provider>
LEXICON<PROVIDER>TOKEN: <API Key from your DNS provider>
LEXICON<PROVIDER>_PASSWORD: <Account password for your DNS provider>
For example:
PROVIDER: cloudflare
<EMAIL_ADDRESS>LEXICON_CLOUDFLARE_TOKEN: asdf1231239182309af
Optional Environment Variable:
KEY_ALGO: {rsa|prime256v1|secp384r1}
```
This will tell dehydrated what algorithm to use for generating the private key. If not defined, will assume rsa for general
cert issuance.

## USAGE for AWS route53

Create `certs/letsencrypt/domains.txt` file for domains that need Let's Encrypt certs.

Define the following environment variables. AWS_PROFILE will be used to pull AWS credentials
and set LEXICON_ROUTE53_AUTH_ACCESS_KEY and LEXICON_ROUTE53_AUTH_ACCESS_SECRET in `do_it.sh`.

```console
export EMAIL=<Your email passed to Let's Encrypt for notifications>
export AWS_PROFILE=<AWS configuration profile in ~/.aws/credentials>
export DOMAINS=<list of delegated domains>
./do_it
```

repository: xueshanf/docker-dehydrated-Lexicon

repo_name: xueshanf/docker-dehydrated-Lexicon


text:
# Rebalance Portfolio
This is a practice mini-project for myself to learn HTML, JavaScript and WebAssembly.

Nonlinear optimizaiton is used to rebalance the finantial portfolio, where MATLAB's fmincon is implemented as a form of WebAssembly, through "Generate JavaScript Using MATLAB Coder" version 2.0.2 by Geoff McVittie. The tool allows you to create JavaScript/WebAssembly libraries from MATLAB projects using MATLAB Coder.

You can find the tool here:
https://jp.mathworks.com/matlabcentral/fileexchange/69973-generate-javascript-using-matlab-coder

### Step 1. Creating your portfolio

Option 1: You can start from [Upload Sample Data] and then add/delete to create your own.

Option 2: Upload csv file. See sampleData2Upload.csv for file format.

You can modify "ticker", "qty", and "target%" only. When modifying or add 'ticker' the price updates itself.

### Step 2. Setting budget

Specify the amount that you would like to spend on this rebalancing. Please note that rebalancing will be achieved by buying only.

### Step 3. Perform optimization

Click [Relabance]

![Step1toStep3](https://github.com/minoue-xx/rebalance_portfolio/blob/master/portolioRebalance_videoEN.gif)


text:
# Otidea phlebophora (Berk. & Broome) Sacc., 1889 SPECIES

#### Status
SYNONYM

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

#### Published in
Syll. fung. (Abellini) 8: 97 (1889)

#### Original name
Peziza phlebophora Berk. & Broome, 1866

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Pezizomycetes/Pezizales/Pyronemataceae/Otidea/Flavoscypha phlebophora/ Syn. Otidea phlebophora/README.md

repo_name: mdoering/backbone


text:
# Move to Bifravst GitHub organization

The [initial fork](./why-fork.md) was made to a personal GitHub account
(`coderbyheart`), this however does not reflect the ownership of the project.
Therefore the project is moved to a GitHub organization which is owned by Nordic
Semiconductor ASA: `bifravst`.

branch_name: refs/heads/saga

gha_language: TypeScript

gha_license_id: NOASSERTION


text:
# Mycosphaerella flagellariae Alcorn, 1978 SPECIES

#### Status
ACCEPTED

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

#### Published in
Qd Nat. 22(1-4): 58 (1978)

#### Original name
Mycosphaerella flagellariae Alcorn, 1978

### Remarks
null


text:
# Clock

An example clock component using jade & sass.

## Build

    npm install && grunt

## Demo

    npm run quickstart

NB. Depending on timing you may have to reload the localhost:3008
address after grunt has started the local dev sever.

repository: shadowmint/iwc-clock

repo_name: shadowmint/iwc-clock


text:
---
title: "Objective-C Resources"
date: 2012-08-29 00:00
---

<import>
I had a reader contact me this week looking for a list of blogs that I follow for Objective-C advice. I had to dig through my Google Reader list for a while to come up with a filtered list, since some good resources like my friend Jason's blog, are great developer resources, but also serve as personal blogs. I think my site, as it exists today, would also fall into this "in-between" category, though I'm hoping to move it towards stricter technical material

This list is anything but complete, but I thought I'd publish a succinct set of resources with helpful Objective-C advice.

http://speirs.org

http://mattgemmell.com

http://www.mikeash.com/pyblog/

http://nshipster.com

http://www.objectivesee.com

http://www.fruitstandsoftware.com/blog/

of course, https://developer.apple.com/news/

These are older and less frequently updated, but still good:

http://www.cimgf.com

http://cocoawithlove.com

If you have any resources you find helpful, please get in touch on twitter and let me know.
</import>

repository: orta/blog

extension: markdown

repo_name: orta/blog


text:
# API

## Contents

Creating Loggers

Logging HTTP Calls

Setting Default Rules

Setting Default URL

Enabling and Disabling Loggers

## Creating Loggers

To get started, first you'll need to create a `HttpLogger` instance. Here there are options to specify a URL (for where JSON
messages will be sent) and/or a specific set of logging rules (for what privacy
protections to apply). Default values will be used for either of these if specific values are not provided.

```python
from usagelogger import HttpLogger

# with default url and rules
logger = HttpLogger()

# with specific url and default rules
logger = HttpLogger(url='https://...')

# with specific url and rules
logger = HttpLogger(url='https://...', rules='include strict')

# with specific url and rules from local file
logger = HttpLogger(url='https://...', rules='file://./rules.txt')
```

## Logging HTTP Calls

Now that you have a logger instance, let's do some logging. Here you can pass standard request/response objects, as well
as response body and request body content when these are available.

```python
from usagelogger import HttpMessage

# with standard objects
HttpMessage.send(logger, request, response)

# with response body
HttpMessage.send(logger, request, response, response_body='my-response-body')

# log with response and request body
HttpMessage.send(logger, request, response, response_body='my-response-body', request_body='my-request-body')
```

If standard request and response objects aren't available in your case, create mock implementations to pass instead.

```python
from usagelogger import HttpRequestImpl, HttpResponseImpl

# define request to log
request = HttpRequestImpl()
request.body = 'some json'
request.headers['Content-Type'] = 'application/json'
request.method = 'POST'
request.params['B'] = '234'  # POST param
request.url = 'http://resurface.io'

# define response to log
response = HttpResponseImpl()
response.body = 'some html'
response.headers['Content-Type'] = 'text/html; charset=utf-8'
response.status = 200

# log objects defined above
HttpMessage.send(logger, request, response)
```

## Setting Default Rules

If no rules are provided when creating a logger, the default value of
`include strict` will be applied. A different default value can be specified as shown below.

```python
HttpRules.set_default_rules('include debug')
```

When specifying multiple default rules, put each on a separate line. This is most easily done with a multi-line string.

```python
HttpRules.set_default_rules("""
    include debug
    sample 10
""")
```

## Setting Default URL

If your application creates more than one logger, or requires different URLs for different environments (development vs
testing vs production), then set the `USAGE_LOGGERS_URL` environment variable as shown below. This value will be applied if no
other URL is specified when creating a logger.

```bash
# from command line
export USAGE_LOGGERS_URL="https://..."

# for Heroku cli
heroku config:set USAGE_LOGGERS_URL=https://...
```

## Enabling and Disabling Loggers

Individual loggers can be controlled through their `enable` and `disable` methods. When disabled, loggers will
not send any logging data, and the result returned by the `log` method will always be true (success).

All loggers for an application can be enabled or disabled at once with the `UsageLoggers` class. This even controls
loggers that have not yet been created by the application.

```python
from usagelogger import UsageLoggers

UsageLoggers.disable()    # disable all loggers
UsageLoggers.enable()     # enable all loggers
```

All loggers can be permanently disabled with the `USAGE_LOGGERS_DISABLE` environment variable. When set to true,
loggers will never become enabled, even if `UsageLoggers.enable()` is called by the application. This is primarily
done by automated tests to disable all logging even if other control logic exists.

```bash
# from command line
export USAGE_LOGGERS_DISABLE="true"

# for Heroku app
heroku config:set USAGE_LOGGERS_DISABLE=true
```

---
© 2016-2023 Graylog, Inc.

repository: resurfaceio/logger-python

gha_language: Python

repo_name: resurfaceio/logger-python


text:
---
type: rule
archivedreason:
title: Do you avoid having important content in JavaScript?
guid: 858c0408-33bb-4366-b9d7-effa775c9c42
uri: avoid-content-in-javascript
created: 2015-11-10T19:28:08.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
- title: Andreas Lengkeek
  url: https://ssw.com.au/people/andreas-lengkeek
related: []
redirects:
- do-you-avoid-having-important-content-in-javascript

---

JavaScript is becoming more and more in common the sites we build everyday. We use them for fancy menus, dropdowns or scroll overs, even the whole website can be written in JavaScript.

However, sometimes search engines can't read JavaScript in all of our pages. It's known that Google can index some content inside JavaScript, but not all. If you keep important information that should show up in Google searches, you must make sure it is placed inside normal HTML so that you know it will be indexed. This keeps the code clean and helps search engines index pages.

<!--endintro-->


text:
kissDev Overseer Package [Deprecated]
===================
[![Laravel 5.3](https://img.shields.io/badge/Laravel-5.3-red.svg?style=flat-square)](http://laravel.com)
[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](https://tldrlegal.com/license/mit-license)

Structure Based: [caffeinated/shinobi](https://github.com/caffeinated/shinobi)

Overseer provides a simple profile-based permissions system to Laravel's built in Auth system. Overseer provides support for the following ACL structure:

- Every user can have zero or more profiles.
- Every profile can have zero or more permissions.

Permissions are then inherited to the user through the user's assigned profiles.

The package follows the FIG standards [PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md), [PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md), and [PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md).
This package is not unit tested, but is planned to be covered.

Documentation
-------------
Wiki: [KissDev Overseer Wiki](https://github.com/folivaresrios/overseer/wiki)

Requirements
------------
The master branch has the following requirements:

* Laravel 5.* or greater.
* PHP 5.6.4 or greater.

How to Install?
---------------
_[Using [Composer](http://getcomposer.org/)]_

Add the plugin to your project's `composer.json` - something like this:

```javascript
{
  "require": {
    "folivaresrios/overseer": "^1.0"
  }
}
```

or through command line

```
composer require folivaresrios/overseer
```

### Service Provider and Facade
Once this operation is complete, simply add the service provider and alias to your project's `config/app.php` file and run the provided migrations against your database.
```php
'providers' => [
    //...
    KissDev\Overseer\OverseerServiceProvider::class,
    //...
];
```
```php
'aliases' => [
    // ...
    'Overseer' => KissDev\Overseer\Facades\Overseer::class,
    // ...
],
```

### Migrations
You'll need to run the provided migrations against your database. Publish the migration files using the `vendor:publish` Artisan command and run `migrate`:

```
php artisan vendor:publish
php artisan migrate
```

### Route Middleware
Add the following middleware to the $routeMiddleware array in app/Http/Kernel.php BEFORE the EncryptCookies middleware:

```php
protected $routeMiddleware = [
    //...
    'profile.overseer' => \KissDev\Overseer\Middleware\UserHasProfile::class,
    'permissions.overseer' => \KissDev\Overseer\Middleware\UserHasPermission::class,
    //...
];
```

## Reporting Issues

If you have a problem with Overseer please open an issue on [GitHub](https://github.com/folivaresrios/overseer/issues).

## Contributing

If you'd like to contribute to Overseer creating something you'd like added, send a [pull
requests](https://help.github.com/articles/using-pull-requests) or open
[issues](https://github.com/folivaresrios/overseer/issues).

repository: folivaresrios/overseer

repo_name: folivaresrios/overseer


text:
---
title: GitExtensions - The last Git GUI you will ever need
categories: [Blog]
tags: [Blog, Review, OpenSource]
---
[GitExtensions](http://gitextensions.github.io/) is a free and open source GUI for the popular source-control solution Git.

![GitExtensions Screenshot](http://gitextensions.github.io/images/commitlog205.png "GitExtensions Screenshot")
**Pros:**
* Very capable Git GUI
* Manages reposatory submodules really well
* Surprisingly fast and responsive
* Easy to use, very intuitive

**Cons:**
* The installation can be a bit confusing (Need to install Git and KDiff3 separately)

**Engineer Suku's Awards:**
* "The Solution" Award (Won)
* Great Open-Source Effort (Won)

<!--
**Giftcam**

[GifCam](http://blog.bahraniapps.com/gifcam/) is a free screen-capture software that exports high quality GIF animations.
* Pros: Very easy to use, includes some basic editing functionality.
* Cons: The menu needs some getting used to.

-->


text:
[simple-reactivemongo](https://github.com/hmrc/simple-reactivemongo) provides simple case class serialization for [ReactiveMongo](http://reactivemongo.org) - reactive, asynchronous and non-blocking Scala driver for MongoDB.

This is part of HMRC Digital Platform where we are coding in the open.

https://github.com/hmrc

repository: hmrc/simple-reactivemongo

gha_language: Scala

repo_name: hmrc/simple-reactivemongo


text:
# Graph Representation Learning via Graphical Mutual Information Maximization

```
@inproceedings{gmi_www20,
author = {Peng, Zhen and Huang, Wenbing and Luo, Minnan and Zheng, Qinghua and Rong, Yu and Xu, Tingyang and Huang, Junzhou},
title = {Graph Representation Learning via Graphical Mutual Information Maximization},
year = {2020},
booktitle = {Proceedings of The Web Conference (WWW)},
pages = {259–270}
}
```

links
- [arXiv](https://arxiv.org/abs/2002.01169)
- [acm](https://dl.acm.org/doi/abs/10.1145/3366423.3380112)
- [code](https://github.com/zpeng27/GMI)
- [video](https://youtu.be/NyKvRwuQMyI?list=PLJNwhMK_V7Exb_YwrTbmcr9du2pEzAGM7)

gha_language: Jupyter Notebook


text:
Learning RxJava for Android by example
==============

I've read and watched a lot on Rx. Most examples either use the J8 lambda notations/Scala/Groovy or some other awesome language that us Android developers are constantly envious of.

Unfortunately i could never find real-world simple examples in Android, that could show me how to use RxJava in Android. This repo is a solution to that problem. Below are a list of examples with a little more deatils on the approach:

## Examples:

### 1. Concurrency using schedulers

A common requirement is to offload lengthy heavy I/O intensive operations to a background thread (non-UI thread), and feed the results on completion, back into the UI/main thread. This is a demo of how long running operations can be offloaded to a background thread. After the operation is done, we resume back on the main thread. All using RxJava!

The long operation is simulated by a blocking Thread.sleep call. But since it's in a background thread, our UI is never interrupted.

To really see this shine. Hit the button multiple times and see how the button click which is a ui operation is never blocked because the long operation only runs in the background

### 2. Accumulate calls using buffer (wip)

This is a demo of how events can be accumulated using the "buffer" operation.

A button is provided and we accumulate the number of clicks on that button, over a span of time and then spit out the final results.

If you hit the button once. you'll get message saying the button was hit once. If you hit it 5 times continuosly within a span of 2 seconds, then you get a single log, saying you hit that button 5 times (vs 5 individual logs saying Button hit once).

### 3. Instant/Auto searching (using a subject and debounce)

This is a demo of how events can be swallowed in a way that only the last one is respected. A typical example of this is instant search result boxes. As you type the word "Bruce Lee", you don't want to execute searches for B, Br, Bru, Bruce, Bruce , Bruce L ... etc. But rather intelligently wait for a couple of moments, make sure the user has finished typing the whole word, and then shoot out a single call for "Bruce Lee".

As you type in the input box, it will not shoot out log messages at every single input character change, but rather only pick the lastly emitted event (i.e. input) and log that. \n\nThis is the debounce/throttleWithTimeout method in RxJava.

### 4. Working examples of github from JakeWharton's Retrofit preso at Netflix (wip)

https://www.youtube.com/watch?v=aEuNBk1b5OE#t=2480
https://speakerdeck.com/jakewharton/2014-1

### 5. Pagination (zip) (wip)

a. Simple pagination
b. Optimized pagination

### 6. Replacing your event Bus (wip)

http://stackoverflow.com/questions/19266834/rxjava-and-random-sporadic-events-on-android


text:
---
id: api-provider
title: Provider
original_id: api-provider
---

A Provider defines an specific resource of a data origin.

When we create a Provider, we'll get a provider instance that should be alive during the whole live of our application, as it is going to be at charge of the cache, avoiding unnecessary resources consumption while the data origin has not changed.

> The Provider class should not be used directly to create providers. It is the base from which specific origins implementations should extend. Here are described the arguments and options that are common to all origins addons. For specific options of each addon please read its own documentation.

## `Provider(id, [options])`

### Arguments

1. __`id`__ _(String)_: Id for the provider instance. It is used internally as namespace in the store. It is also useful for debugging purposes, and can be used for configuring the provider instance [using the `providers` object](api-providers.md).

2. __`options`__ _(Object)_: Options will differ depending of the type of origin. Here are described the properties in the options object that are common to all origins addons. For specific options of different origin addons, please refer to its own documentation.
	* __`cache`__ _(Boolean)_: If `false`, will disable the cache, and the `readMethod` defined by the origin will be called always, which could result in a negative performance impact. It is `true` by default, and normally should not be disabled.
	* __`tags`__ _(Array of Strings)_: Defines tags for the provider instance, which can be used afterwards to manage groups of providers [using the `providers` object](api-providers.md). _Origin addons should usually automatically add his own tag to the beginning of the provided array, to allow configuring easily all providers of a same type._
	* __`initialState`__ _(Object)_: Object containing `loading`, `error` and `data` properties, which will define the initial state of the provider, before its `read` method is executed for the first time. This is useful to give a default value for the data, so you don't have to make extra format checks in your views _(`data && data.map`)_. It is also useful to define the initial loading state, which can be defined as true, which will save extra renders _(as the read method is executed normally by the views theirself, the first time a selector is read it should have `loading` state as false, then immediately `true`, then `false` when data is retrieved. Setting `initialState.loading` property to `true` will save that extra render in the initialization)._

### Returns

A `provider` instance, which methods are described in the [providers and selectors methods](api-providers-and-selectors-methods.md) page of these docs.

### Example

```javascript
import { Axios } from "@data-provider/axios";

const provider = new Axios("example", {
  url: "/foo-url",
  tags: ["foo-tag"],
  initialState: {
  	loading: true,
  	data: []
  }
});

console.log(provider.id);
// example

console.log(provider.options);
// { cache: true, tags: ["axios", "foo-tag"], url: "/foo-url" }

console.log(provider.state);
// { loading: true, data: [], error: null }

```

### Tips

* Use clear identifiers in your providers. It will improve the development experience, as Data Provider and addons usually use them when printing messages into the console.
* When an `id` is duplicated, Data Provider will automatically append a suffix to it and will print a warning.
* Define always the `initialState`, it will save you extra format checks in your views, and will save an initial extra render, as described in the Arguments API.

repository: data-provider/website

repo_name: data-provider/website


text:
[![Build Status](https://travis-ci.org/astj/p6-Crust-Middleware-WrapPSGI.svg?branch=master)](https://travis-ci.org/astj/p6-Crust-Middleware-WrapPSGI)

NAME
====

Crust::Middleware::WrapPSGI - An wrapper middleware for legay PSGI apps

SYNOPSIS
========

    # An legacy PSGI app
    my $psgi-app = -> %env {
        (200, [ 'Content-Type' => 'text/plain' ], [ 'Hello World' ]);
    };
    my $wrapped-app = builder {
        # You can add other middlewares which expects Promise as response here.
        enable "WrapPSGI";
        # And you can add other *legacy* middlewares which expects Capture as response here.
        $psgi-app;
    };

DESCRIPTION
===========

Crust::Middleware::WrapPSGI is a simple wrapper middleware for legacy PSGI applications. [P6W](P6W) (formally known as PSGI) Version 0.7.Draft expects P6W apps to implement "request-response" protocol. Under the protocol, P6W apps must return a Promise which is kept with a Capture with 3-elements response.

This middleware enables "legacy" PSGI applications which directly returns Capture (that means the application can respond to only psgi protocol) to work with "request-response" protocol.

AUTHOR
======

Asato Wakisaka<EMAIL_ADDRESS>
COPYRIGHT AND LICENSE
=====================

Copyright 2017 Asato Wakisaka

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


text:
---
layout: sidebar-right
title: "Celebrate National Poetry Day 2017 with some of the best children's poetry books of the year"
date: 2017-09-28
author: sophie-green
category: childrens-ya-books
excerpt: "This year's children’s poetry books include new editions of old favourites, wonderfully illustrated collections, and exciting debuts."
featured-image: /images/featured/featured-national-poetry-day-2017.jpg
featured-alt: "How to be a Tiger, The Lost Words, Overheard in a Tower Block"
featured-link-text: "Check out our list of great poetry for children."
breadcrumb: childrens-ya-books
---

![How to be a Tiger, The Lost Words, Overheard in a Tower Block](/images/featured/featured-national-poetry-day-2017.jpg)

This year's children’s poetry books include new editions of old favourites, wonderfully illustrated collections, and exciting debuts.

## [The Lost Words: a spell book, by Robert Macfarlane & Jackie Morris](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2257444)

Due in early October, this promises to be a beautiful book to read and look at:

> "From bestselling [Landmarks](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=1956933) author Robert Macfarlane - an illustrated collection of spell-poems to re-wild the language of children."

## [Eighty Best Poems, by Roger McGough](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2254686)

Also due out in October, from one of our best-loved poets:

> "There are 80 of Roger McGough's wonderful poems in this hugely enjoyable collection, gathered into a new volume to celebrate his 80th birthday! The poems have been specially chosen to reflect Roger's unique sense of humour, his wit and wisdom and sharp observations on all aspects of life. New, quirky illustrations by the author himself add further enjoyment!"

## [Message from the Moon and other poems, by Hilda Offen](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2157215)

> "Hilda Offen's new collection is a mixture of imaginative, thoughtful and funny poems. Meet the killer caterpillar on the prowl, the robber rabbit who is a criminal all-rounder, the reading dogs - and a troll who is not afraid to speak out about those Billy-Goats Gruff. There are poems about nature and the seasons and a look at our planet from the moon."

According to Wordery, this is 'a mix of imaginative, thoughtful and funny poems with accessible and intriguing themes.'

## [How to be a Tiger, by George Szirtes & Tim Archbold](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2095046)

> "Leap with hares, call out to the sun, run with the wind, pull silly faces with monkeys, watch out for the bear in the bathroom and meet a burping princess! These poems are perfect for curious young minds, ready for adventures."

## [Little Lemur Laughing, by Joshua Seigal & Chris Piascik](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2114973)

> "A dragon's sneeze, a dinosaur, a wizard's spell, a monster's claw. All these things and many more - that's what's in a poem. An exciting collection of poems from talented young poet Joshua Seigal, perfect for introducing children to poetry."

## [Rhyme Stew, by Roald Dahl & Quentin Blake](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=1926817)

Reprint of an old favourite, originally published in 1989:

> "This title presents a collection of irreverent rhymes featuring characters from fairy tales, fables, and nursery rhymes - as you've never seen them before!"

## [New and Collected Poems for Children, by Carol Ann Duffy and Alice Stevenson](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2124318)

New edition of this 2009 collection:

> "Carol Ann Duffy, the Poet Laureate, is one of our most read and best-loved poets both in and out of the classroom. This edition of her poems brings together work from her four award-winning collections for children, and sprinkles in a generous helping of new poems to match."

## [A Child's Garden of Verses, by Robert Louis Stevenson & Michael Foreman](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2207335)

Due in mid-October:

> "Robert Louis Stevenson's collection of poems celebrates his memories of a bright and happy childhood, but they have a timeless appeal for each new generation of children."

## [A Rocketful of Space Poems, by John Foster & Korky Paul](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2102130)

> "Fly into space, drive to the moon, meet an asteroid dog and a flurb blurp and then play intergalactic Squibble-Ball. There are wizards and witches in space, as well as Peter Pluto's fast-food superstore - and the worst monster in the universe. What are you waiting for?"

[Winnie the Witch](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2043331) illustrator Korky Paul really brings this collection to life.

## [The Dictionary of Dads, by Justin Coe & Steve Wells](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2144324)

> "There are more than 50 different dads in The Dictionary of Dads. Find your favourite - but watch out for exploding dad! This is a brilliant and funny debut collection from a poet who performs his work in schools and theatres across the UK, with witty illustrations by Steve Wells."

## [All Aboard the London Bus, by Patricia Toht & Sam Usher](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2151732)

> "As a family of four spend a day exploring London, fun, child-friendly poems introduce readers to our wonderful capital city, and all its secrets. Well-known landmarks like Buckingham Palace, Big Ben and the London Eye, plus inescapable features like rain and taking tea, all get Patty Toht's witty treatment. Non-fiction facts provide more information about the subjects, while rising star Sam Usher brings them to life with his signature style and humour."

## [All the Wild Wonders: poems of our Earth, by Wendy Cooling (ed.) & Piet Grobler](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2152325)

> "In this celebration of our Earth, distinguished anthologist Wendy Cooling has chosen poems to make children look, think, and ask questions. Why are trees so important? How are motorways damaging our countryside? What can we do about rubbish? What can we do to protect our Earth for the future?"

## [My Mum's Growing Down, by Laura Dockrill & David Tazzyman](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2185136)

> "Mum is a gamer, a party animal and a free spirit making life hard work for her nine year old son.  The poems are bold, brave, funny and sometimes very moving.

According to Books For Keeps, 'these poems celebrate the unconventional, they are full of warmth, humour and loving advice, 'you get on with being you and I'll get on with loving you.''

## [The World's Greatest Space Cadet, by James Carter & Ed Boxall](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2082936)

> "Join well loved poet James Carter on a journey through time and space: from Vikings to a marauding cat and from the edges of the universe to the world's greatest space cadet."

According to Andrea Reece from LoveReading4Kids, 'his poems will work their magic on all readers, and each one finds something new to say, ans the perfect way to say it. A treat from first page to last.'

## [Overheard in a Tower Block, by Joseph Coelho & Kate Milner](https://suffolk.spydus.co.uk/cgi-bin/spydus.exe/ENQ/OPAC/BIBENQ?BRN=2168959)

> "Gazing at the stars from five storeys up, smelling the bins from five storeys below. Overheard arguments, overheard laughter. A disappearing father and a Mermaid-Queen mother; statues that sing for flesh and blood; bullies who kick you under the table; perfect red trainers - and the things that lurk in the library. Award-winning poet Joseph Coelho's new collection is a powerful and moving poetic narrative about growing up in the city."

According to Booktrust, 'many of these poems are sad or angry or bristle with an edginess that young teens may find refreshing when compared to other poetry aimed at them.'

repository: suffolklibraries/sljekyll

repo_name: suffolklibraries/sljekyll


text:
# Gotoh-algorithm
Implementation in python of the Gotoh algorithm for making pairwise alignments of sequences using affine gap penalties
Input needs to be a .fasta file containing both sequences (as seen in seq.fasta as an example), and a substitution matrix, that MUST have the same
format as the matrix.txt file (added as an example).

repository: pereperi/Gotoh-algorithm

repo_name: pereperi/Gotoh-algorithm


text:
# AWS EBS Snapshot Publicly Exposed

![OffensiveTerraform](https://img.shields.io/badge/hack-success)
![OffensiveTerraform](https://img.shields.io/badge/offensive-terraform-blueviolet)
![OffensiveTerraform](https://img.shields.io/badge/aws-important)

Offensive Terraform module which copies publicly exposed EBS snapshot to us-east-1 region in attacker's AWS account and creates EBS volume from the copied EBS snapshot. After that, the module attaches and mounts the EBS volume to an EC2 instance. Finally, attacker can ssh into an EC2 instance and inspect a mounted volume "/usr/src/hack".

![Attack Diagram](https://raw.githubusercontent.com/offensive-terraform/terraform-aws-ebs-snapshot-publicly-exposed/master/diagram.jpg)

## Usage
```
provider "aws" {
  region = "us-east-1"
}

module "ebs-snapshot-publicly-exposed" {
    source  = "offensive-terraform/ebs-snapshot-publicly-exposed/aws"

    public_snapshot_id = "snap-000000000000"
    public_snapshot_region = "us-west-2"
}

output "ssh_private_key" {
  value = module.ebs-snapshot-publicly-exposed.ssh_private_key
}

output "ssh_ec2_connect" {
  value = module.ebs-snapshot-publicly-exposed.ssh_ec2_connect
}

output "ebs_volume_mount_path" {
  value = module.ebs-snapshot-publicly-exposed.ebs_volume_mount_path
}
```

## Author
Module managed by https://github.com/iganbold


text:
# ColorIt
A simple library to add color to your output.

Have you ever wanted to print colors to the console? I certainly have. There comes a time when you realize it is a necessity. That's why I created ColorIt. ColorIt is a super simple way to print color to the console.

## How it works

Interally, the library creates custom ANSI sequences with RGB values. This means there will never be a problem where a color changes. For example if I were to use pre-defined ANSI sequence, `\033[34m`, it would not print blue as it previously did. But, this problem is avoided because it doesn't use predefined values, each one is custom made.

## Installation
There are two ways to install ColorIt, I strongly reccomend the scond method

* Install the file into each of you project's directories. **This method doesn't allow repeated use, you have to do it for each project.**

* Install the `ColorIt.py` file into your `<Directory to python>\Python\<python version folder>\Lib\site-packages` path. **This method allows repeated use, you only have to do it once.**

## How to use it

To use ColorIt:

```python
from ColorIt import *

# Use this to ensure that ColorIt will be usable by certain command line interfaces
initColorIt()

# Foreground
print (color ('This text is red', colors.RED))
print (color ('This text is orange', colors.ORANGE))
print (color ('This text is yellow', colors.YELLOW))
print (color ('This text is green', colors.GREEN))
print (color ('This text is blue', colors.BLUE))
print (color ('This text is purple', colors.PURPLE))
print (color ('This text is white', colors.WHITE))

# Background
print (background ('This text has a background that is red', colors.RED))
print (background ('This text has a background that is orange', colors.ORANGE))
print (background ('This text has a background that is yellow', colors.YELLOW))
print (background ('This text has a background that is green', colors.GREEN))
print (background ('This text has a background that is blue', colors.BLUE))
print (background ('This text has a background that is purple', colors.PURPLE))
print (background ('This text has a background that is white', colors.WHITE))

# Custom
print (color ("This color has a custom grey text color", (150, 150, 150))
print (background ("This color has a custom grey background", (150, 150, 150))

# Combination
print (background (color ("This text is blue with a white background", colors.BLUE), colors.WHITE))

```

As output you get:

![](ImagesInReadMe/demo.png)

If you would like to try this for yoyr self, you can download `demo.py` and try it out.

And that's it. That's really all there is to it.

## Release Log
* Released the first version of ColorIt (v1.0.0)
* Added a license

## Support me on patreon!
Here is the link to my patreon page: https://www.patreon.com/supermazingcoder :D

repository: davidjmstewart/ColorIt

repo_name: davidjmstewart/ColorIt


text:
# Changelog

## [1.4.3](https://github.com/googleapis/google-cloud-python/compare/google-cloud-certificate-manager-v1.4.2...google-cloud-certificate-manager-v1.4.3) (2023-07-05)

### Bug Fixes

* Add async context manager return types ([#11445](https://github.com/googleapis/google-cloud-python/issues/11445)) ([98bddda](https://github.com/googleapis/google-cloud-python/commit/98bdddafc821e2fc6e86a31965da0c46899aa229))

## [1.4.2](https://github.com/googleapis/python-certificate-manager/compare/v1.4.1...v1.4.2) (2023-03-23)

### Documentation

* Fix formatting of request arg in docstring ([#116](https://github.com/googleapis/python-certificate-manager/issues/116)) ([7507e2a](https://github.com/googleapis/python-certificate-manager/commit/7507e2a664428de6cacc762cda9d64392a5b1bc8))

## [1.4.1](https://github.com/googleapis/python-certificate-manager/compare/v1.4.0...v1.4.1) (2023-03-01)

### Documentation

* Corrected information about the limit of certificates that can be attached to a Certificate Map Entry ([#113](https://github.com/googleapis/python-certificate-manager/issues/113)) ([415b36a](https://github.com/googleapis/python-certificate-manager/commit/415b36a2ef7ae9311db75d0b4fd36e6997b9cc27))

## [1.4.0](https://github.com/googleapis/python-certificate-manager/compare/v1.3.1...v1.4.0) (2023-02-27)

### Features

* Enable "rest" transport in Python for services supporting numeric enums ([#109](https://github.com/googleapis/python-certificate-manager/issues/109)) ([d63d706](https://github.com/googleapis/python-certificate-manager/commit/d63d7068b82568b45c66f2000d73658ae66c8424))

## [1.3.1](https://github.com/googleapis/python-certificate-manager/compare/v1.3.0...v1.3.1) (2023-01-20)

### Bug Fixes

* Add context manager return types ([81cfbf9](https://github.com/googleapis/python-certificate-manager/commit/81cfbf9986c4d48c8859bf4777c8a5ad67420fc3))

### Documentation

* Add documentation for enums ([81cfbf9](https://github.com/googleapis/python-certificate-manager/commit/81cfbf9986c4d48c8859bf4777c8a5ad67420fc3))

## [1.3.0](https://github.com/googleapis/python-certificate-manager/compare/v1.2.0...v1.3.0) (2023-01-10)

### Features

* Add support for python 3.11 ([#101](https://github.com/googleapis/python-certificate-manager/issues/101)) ([4e38d00](https://github.com/googleapis/python-certificate-manager/commit/4e38d002b4ecb6f786255a80d27ecc2663e10471))

## [1.2.0](https://github.com/googleapis/python-certificate-manager/compare/v1.1.1...v1.2.0) (2022-12-15)

### Features

* Add support for `google.cloud.certificate_manager.__version__` ([7ba10a7](https://github.com/googleapis/python-certificate-manager/commit/7ba10a7a3c7b35b10fce05d7e61cb9a180040faf))
* Add typing to proto.Message based class attributes ([7ba10a7](https://github.com/googleapis/python-certificate-manager/commit/7ba10a7a3c7b35b10fce05d7e61cb9a180040faf))

### Bug Fixes

* Add dict typing for client_options ([7ba10a7](https://github.com/googleapis/python-certificate-manager/commit/7ba10a7a3c7b35b10fce05d7e61cb9a180040faf))
* **deps:** Require google-api-core >=1.34.0, >=2.11.0  ([2cb2cff](https://github.com/googleapis/python-certificate-manager/commit/2cb2cff75b04a8a4462d7400d43b4c1c1768485d))
* Drop usage of pkg_resources ([2cb2cff](https://github.com/googleapis/python-certificate-manager/commit/2cb2cff75b04a8a4462d7400d43b4c1c1768485d))
* Fix timeout default values ([2cb2cff](https://github.com/googleapis/python-certificate-manager/commit/2cb2cff75b04a8a4462d7400d43b4c1c1768485d))

### Documentation

* **samples:** Snippetgen handling of repeated enum field ([7ba10a7](https://github.com/googleapis/python-certificate-manager/commit/7ba10a7a3c7b35b10fce05d7e61cb9a180040faf))
* **samples:** Snippetgen should call await on the operation coroutine before calling result ([2cb2cff](https://github.com/googleapis/python-certificate-manager/commit/2cb2cff75b04a8a4462d7400d43b4c1c1768485d))

## [1.1.1](https://github.com/googleapis/python-certificate-manager/compare/v1.1.0...v1.1.1) (2022-10-07)

### Bug Fixes

* **deps:** Allow protobuf 3.19.5 ([#90](https://github.com/googleapis/python-certificate-manager/issues/90)) ([b934abd](https://github.com/googleapis/python-certificate-manager/commit/b934abd11780af4b9ada0781f852a8faa7167c3f))

## [1.1.0](https://github.com/googleapis/python-certificate-manager/compare/v1.0.1...v1.1.0) (2022-10-03)

### Features

* Added support for Private Trust to Certificate Manager API ([#88](https://github.com/googleapis/python-certificate-manager/issues/88)) ([5cf35e2](https://github.com/googleapis/python-certificate-manager/commit/5cf35e2e9bb8a6c15daf006451ef0cefe4b20b6f))

## [1.0.1](https://github.com/googleapis/python-certificate-manager/compare/v1.0.0...v1.0.1) (2022-09-29)

### Bug Fixes

* **deps:** Require protobuf >= 3.20.2 ([#86](https://github.com/googleapis/python-certificate-manager/issues/86)) ([fa93aa2](https://github.com/googleapis/python-certificate-manager/commit/fa93aa2b21be386a905998c4d3484d98e6033634))

## [1.0.0](https://github.com/googleapis/python-certificate-manager/compare/v0.2.1...v1.0.0) (2022-08-15)

### Features

* bump release level to production/stable ([#68](https://github.com/googleapis/python-certificate-manager/issues/68)) ([dfdfff8](https://github.com/googleapis/python-certificate-manager/commit/dfdfff87145f90b9b921fc4ec1085407a99777c5))

## [0.2.1](https://github.com/googleapis/python-certificate-manager/compare/v0.2.0...v0.2.1) (2022-08-15)

### Bug Fixes

* **deps:** allow protobuf < 5.0.0 ([#72](https://github.com/googleapis/python-certificate-manager/issues/72)) ([414f5c5](https://github.com/googleapis/python-certificate-manager/commit/414f5c55c069df7614074973a243af47de8fb4aa))
* **deps:** require proto-plus >= 1.22.0 ([414f5c5](https://github.com/googleapis/python-certificate-manager/commit/414f5c55c069df7614074973a243af47de8fb4aa))

## [0.2.0](https://github.com/googleapis/python-certificate-manager/compare/v0.1.3...v0.2.0) (2022-07-16)

### Features

* add audience parameter ([72eba35](https://github.com/googleapis/python-certificate-manager/commit/72eba358c16ac170e40da995cab963cb8c4a0d94))

### Bug Fixes

* **deps:** require google-api-core>=1.32.0,>=2.8.0 ([72eba35](https://github.com/googleapis/python-certificate-manager/commit/72eba358c16ac170e40da995cab963cb8c4a0d94))
* Removed resource definition of Compute API resources and incorrect resource references that used them ([#62](https://github.com/googleapis/python-certificate-manager/issues/62)) ([72eba35](https://github.com/googleapis/python-certificate-manager/commit/72eba358c16ac170e40da995cab963cb8c4a0d94))
* require python 3.7+ ([#64](https://github.com/googleapis/python-certificate-manager/issues/64)) ([62b2303](https://github.com/googleapis/python-certificate-manager/commit/62b23030f8f6fe35b822f55044393d9d40adef7c))

## [0.1.3](https://github.com/googleapis/python-certificate-manager/compare/v0.1.2...v0.1.3) (2022-06-03)

### Bug Fixes

* **deps:** require protobuf <4.0.0dev ([#55](https://github.com/googleapis/python-certificate-manager/issues/55)) ([14a09d2](https://github.com/googleapis/python-certificate-manager/commit/14a09d2bfd6920632250ad8b3c8dac3b80884273))

## [0.1.2](https://github.com/googleapis/python-certificate-manager/compare/v0.1.1...v0.1.2) (2022-03-30)

### Bug Fixes

* Updated resource patterns to comply with https://google.aip.dev/123#annotating-resource-types ([#17](https://github.com/googleapis/python-certificate-manager/issues/17)) ([71f74bf](https://github.com/googleapis/python-certificate-manager/commit/71f74bf5e25c732f51ac6db32bc204e6116cbad2))

## [0.1.1](https://github.com/googleapis/python-certificate-manager/compare/v0.1.0...v0.1.1) (2022-03-05)

### Bug Fixes

* **deps:** require google-api-core>=1.31.5, >=2.3.2 ([4565ece](https://github.com/googleapis/python-certificate-manager/commit/4565ece4e6e08a07d902ef4371887c22c774a717))

## 0.1.0 (2022-02-16)

### Features

* generate v1 ([695fff9](https://github.com/googleapis/python-certificate-manager/commit/695fff9677e02f256f4eeb4e8abc875167848c10))

repository: googleapis/google-cloud-python

repo_name: googleapis/google-cloud-python


text:
# nCov_Info_Share
Information sharing portal about nCov/SARS/MERS for drug discovery

URL of the online portal: https://ghddi-ailab.github.io/nCov_Info_Share/

## A Short Tutorial for Content Contributor
### Contribute Content
Write your contents in markdown format and save them in `/docs` folder, with file extention **.md**

### Organize Pages
Specify your content in `mkdocs.yml`, section `nav` as follows:
```
    - nCov:
      - todo I: todo_I.md
      - todo II: todo_II.md
```
in which `nCov` will be top level folder, and `todo I` and `todo II` will be the second level pages

### Publish to Github Pages
just by `mkdocs gh-deploy`

### Markdown Format Specification
https://guides.github.com/features/mastering-markdown/


text:
# Linear Algebra Swift
Refresh study of Linear Algebra using Swift

To manipulate vectors I'm using the great library [VectorMath](https://github.com/nicklockwood/VectorMath) from [nicklockwood](https://github.com/nicklockwood)

### Topics

##### Vector Sum [code](https://github.com/ezefranca/linear-algebra-swift/tree/master/Vector_Sum)

![](https://raw.githubusercontent.com/ezefranca/linear-algebra-swift/master/Vector_Sum/sum.png)

repository: ezefranca/linear-algebra-swift

repo_name: ezefranca/linear-algebra-swift


text:
## Description

This test checks to ensure that when a standard generate policy with data type and sync enabled is used, deletion of the generated/downstream resource causes Kyverno to re-create the resource.

## Expected Behavior

If the resource is recreated, the test passes. If it is not, the test fails.

## Reference Issue(s)

N/A

repository: kyverno/kyverno

gha_language: Go

repo_name: kyverno/kyverno


text:
# Sequel::Schema::Dot::Generator

Sequel database structure Dot language generator

[![Gem Version](https://badge.fury.io/rb/sequel-schema-dot-generator.png)](http://badge.fury.io/rb/sequel-schema-dot-generator)

## Installation

Add this line to your application's Gemfile:

    gem 'sequel-schema-dot-generator'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install sequel-schema-dot-generator

## Usage

    require 'sequel/schema/dot/generator'

    dot_db = Sequel::Schema::Dot::Generator::Generator
      .new({  db:     DB
           }
      )

    puts dot_db.generate

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

## Changelog

### 0.0.4
- Module structure flattened
- Dir structure flattened
- active_support -> activesupport, smaller adjustments
- Transition to Ruby 2.0 and .ruby-version files for gem development

### 0.0.3
- Associations detection from model (`params[:schema_source_type] = :model`)
- New homepage

### 0.0.2
- optional colored association edges to distinguish them in big intersections (`params[:colored_associations]`)
- multiple foreign table support
- columns has written types in diagram

repository: roolo/sequel-schema-dot-generator-gem

repo_name: roolo/sequel-schema-dot-generator-gem


text:
![git logo](images/git.png)

# Intro to Git Workshop

#### Contact Info
Presenter:  Reshama Shaikh
Blog:  https://reshamas.github.io
LinkedIn:  https://www.linkedin.com/in/reshamas
Twitter:  https://twitter.com/reshamas
GitHub:  https://github.com/reshamas
Email<EMAIL_ADDRESS>

#### About Me
* Data Scientist (Statistician, MBA)
* Organizer of WiMLDS meetup group
     - [NYC Women in Machine Learning & Data Science](http://www.meetup.com/NYC-Women-in-Machine-Learning-Data-Science/)
     - http://wimlds.org/
* Organizer of [NYC PyLadies meetup group](https://www.meetup.com/NYC-PyLadies/)

#### Event
[Git Workshop for Women Who Code, Jan 30, 2018](https://www.meetup.com/WomenWhoCodeNYC/events/245921277/)

#### Host
* BounceX:  https://www.bouncex.com
* NYC Women Who Code:  https://www.womenwhocode.com/nyc

#### Helpers
* [Nilufer Polat](https://www.linkedin.com/in/niluferpolat/)
* [Lindsey Dragun](https://www.linkedin.com/in/ldragun/)
* [Kate Eldridge](https://www.linkedin.com/in/kateeldridge/)
* [Monica Powell](https://www.linkedin.com/in/monicampowell/)
* [Ruiye Ni](https://www.linkedin.com/in/ruiye-ni-43a23516/)
---

### Installation
This workshop covers Git CLI (command line interface).  [It does not use Git GUI.]
* [Getting Started:  Installing Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)

### Prerequisites
* Create a GitHub account (save your user ID & password somewhere that is easy to find)
* Unix access (Mac / Ubuntu-Linux) or shell access for Windows
* Git Installation
  - Install Git
  - Confirm installation with `git --version`

### Objectives
* Introduction to Git & GitHub
     - GitHub browser
     - Settings
     - Navigating page
* Individual account
     - learn to create a repo on GitHub and update via Git
     - clone a repository (copy from GitHub browser to local machine using Git)
     - add collaborators
     - create a branch and work from it
     - undo Git changes


text:
---
    project: furuta
    type: subsect
    section: Connection
    title: Enabling B0 CLient Side (Matlab)
---

Once enabled this API by Coppelia, it will run the middleware and allows Matlab to connect with the robotic simulator to call built-in or user-defined Coppelia lua functions. In Matlab it is necessary to include in the same folder of the main program the class b0RemoteApi which will instantiate the client. This class also requires some other .dll libraries(since Windows it has been used) or .so libraries (if using Linux) to work.

The constructor is called to create the client:

client=b0RemoteApi('b0RemoteApi_matlabClient','b0RemoteApiAddOn');

This command creates the client. The first string is just a symobolic name to the newly created object client, while the second identifies the channel name (see previous step).

After creating the client, it is possible to use the The B0-based remote API functions. Before starting the simulation, we want to enable a syncronous communication between Matlab and Coppelia, otherwise the system will contnue evolving while Matlab computing the control input.

To enable Synchronous operation:

client.simxSynchronous(true); %Enable the synchronous mode

After this command the physic engine will need a trigger from the client before computing the following step. We can now safely start the simulation without having the system evolving:

client.simxStartSimulation(client.simxDefaultPublisher());

And give the simulator the trigger to go to the first step:

client.simxSynchronousTrigger();

It is possible to call the Coppelia functions mainly in two modes: **blocking** and **non-blocking mode**. We use the non-blocking mode when we don't expect a response from the server(starting the simulation or feeding the control input voltage), so the main can continue execute the code leading to fast performance. The blocking mode is used when a return value is required to execute the subsequent line of code(for example when asking for the state of the system).

To call in a non-blocking mode the method  client.simxDefaultPublisher() is used, whilst for the blocking mode the method client.simxServiceCall() is called. This method will create a topic over which publish the messages.

For example, to start the simulation we would do:

client.simxStartSimulation(client.simxDefaultPublisher()); %It starts the simulation. The function is called in a non-blocking mode

or to feed the voltage Vm:

client.simxCallScriptFunction('input_voltage@Frame',1,Vm,client.simxDefaultPublisher());

client.simxStartSimulation calls a built.in function. In this case the function starts the simulation.

client.simxCallScriptFunction, will call a user-defined lua script. So it is necessary to pass it the name of function and the object parent(the child belongs to) as well as, the identifier to the type of script(1 for Customization Script, 6 for Non-Threaded Script).

To measure the state x the corresponding function will be called in a non-blocking mode.

state=client.simxCallScriptFunction('measure_state@Dummy',6,-1,client.simxServiceCall());


text:
# Csud::Bowl::Kata

Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/csud/bowl/kata`. To experiment with that code, run `bin/console` for an interactive prompt.

TODO: Delete this and the text above, and describe your gem

This is based on my original [bowling kata code](https://github.com/claresudbery/bowling-kata-ruby).

The kata is described [here](https://learn.madetech.com/katas/bowling).

I am following [this tutorial](https://learn.madetech.com/guides/06-Gem-Packaging/) for creating a Ruby gem.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'csud-bowl-kata'
```

And then execute:

    $ bundle install

Or install it yourself as:

    $ gem install csud-bowl-kata

## Usage

TODO: Write usage instructions here

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/csud-bowl-kata. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/csud-bowl-kata/blob/master/CODE_OF_CONDUCT.md).

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## Code of Conduct

Everyone interacting in the Csud::Bowl::Kata project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/csud-bowl-kata/blob/master/CODE_OF_CONDUCT.md).

repository: claresudbery/csud-bowl-kata

repo_name: claresudbery/csud-bowl-kata


text:
---
layout: page
title:
excerpt: #no idea what this is for
modified: 2014-08-08T19:44:38.564948-04:00

---

__James Golick__ was a developer who was passionate about promoting diversity in the tech industry. Before his much too early passing in 2014, James showed a strong commitment to supporting women in tech, taking particular interest in mentoring and encouraging female programmers. We sadly never had the chance to meet James, but we are proud to honor his memory and to celebrate his ideas and visions for a more diverse tech industry. We highly support [The James Golick Grant for Women in Computology](https://jamesgolick.bitmakerlabs.com/), a wonderful grants program that funds education for women in tech, such as the Rails Girls Summer of Code program that we are participating in this summer.

![James](/images/james.jpg)

James is an inspiration to all of us and we are happy to celebrate his lifes' work as we hone our skills and discover our enthusiasm for programming. If you'd like to celebrate James Golick's vision for a more diverse tech industry, please consider making a [donation](https://jamesgolick.bitmakerlabs.com/) to the The James Golick Grant for Women in Computology  <3.

![James](/images/jamesherz.png)


text:
Initial incident details should be the name of the reporting person, or ID of the SIEM alert/incident, and description of the lost device.

Labels:
 - User: the owner of the device

## Dependencies
This playbook uses the following sub-playbooks, integrations, and scripts.

### Sub-playbooks
This playbook does not use any sub-playbooks.

### Integrations
This playbook does not use any integrations.

### Scripts
This playbook does not use any scripts.

### Commands
This playbook does not use any commands.

## Playbook Inputs
---
There are no inputs for this playbook.

## Playbook Outputs
---
There are no outputs for this playbook.

## Playbook Image
---
![lost_stolen_device](https://raw.githubusercontent.com/demisto/content/1bdd5229392bd86f0cc58265a24df23ee3f7e662/docs/images/playbooks/Lost_Stolen_Device_Playbook.png)

repository: demisto/content

repo_name: demisto/content


text:
# Linaro's Linux Kernel Functional Testing (LKFT) Tools

### Kernel best practices

* [Create and send a patch](https://github.com/Linaro/lkft-tools/blob/master/kernel-docs/create-and-send-a-patch.md)
* [LTS backporting](https://github.com/Linaro/lkft-tools/blob/roxell-test/kernel-docs/lts-backporting.md)

repository: mwasilew/lkft-tools

repo_name: mwasilew/lkft-tools


text:
---
layout: default
---

# 1998-02-10 - Re: FCPUNX:comp.html

## Header Data

From: "James A. Donald"<EMAIL_ADDRESS>To: Jim Choate<EMAIL_ADDRESS>Message Hash: 5a709ebbd6876bfbeef541270af44a7406835284fde65d4ee48750790213ba43

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-02-10 23:30:19 UTC

Raw Date: Wed, 11 Feb 1998 07:30:19 +0800

## Raw message

```
{% raw  %}From: "James A. Donald"<EMAIL_ADDRESS>Date: Wed, 11 Feb 1998 07:30:19 +0800
To: Jim Choate<EMAIL_ADDRESS>Subject: Re: FCPUNX:comp.html
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

    --
At 03:14 PM 1/28/98 -0600, Jim Choate wrote:
>   Recently, an algorithm was developed for factoring
>   numbers on a quantum computer which runs in steps where
>   is small [1]. This is roughly quadratic in the input
>   size, so factoring a 1000 digit number with such an
>   algorithm would require only a few million steps. The
>   implication is that public key cryptosystems based on
>   factoring may be breakable.

However quantum computers so far envisaged (but not yet
built) can only do a few steps before they lose quantum
coherence.

So far factoring a four bit number is well beyond the state
of the art in quantum computation.

    --digsig
         James A. Donald
     6YeGpsZR+nOTh/cGwvITnSR3TdzclVpR0+pr3YYQdkG
     W7fOL2Uec3TpIWpLT+xcgrKGVfoQL3gmNdcADrkN
     41SXVwnn/Gy+C42ptPxygaLgt1miSt2a1T/6/b9p8
 ---------------------------------------------------------------------
We have the right to defend ourselves and our property, because of
the kind of animals that we are. True law derives from this right,
not from the arbitrary power of the state.

http://www.jim.com/jamesd/

{% endraw %}
```

## Thread

+ Return to [February 1998](/archive/1998/02)

+ Return to "["James A. Donald" <jamesd@echeque.com>](/authors/james_a_donald_jamesd_at_echeque_com_)"

+ 1998-02-10 (Wed, 11 Feb 1998 07:30:19 +0800) - Re: FCPUNX:comp.html - _"James A. Donald"<EMAIL_ADDRESS>