text:
---
layout: post
title: "UDEV rules for devices without serial number"
date: "2017-10-11 20:57:09 -0400"
---

I have and update about how to create UDEV rules for devices that doesn't have serial number. I bought this serial to USB adapters from a company called prolific and tried to create UDEV rules for it like [this](http://vncprado.github.io/udev-rules-for-ttyusb/):

    SUBSYSTEM=="usb-serial", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", ATTRS{serial}=="0000:00:1d.0", SYMLINK+="cyberglove.right"
    SUBSYSTEM=="usb-serial", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", ATTRS{serial}=="0000:00:1a.0", SYMLINK+="cyberglove.left"

But I couldn't, because that `ATTRS{serial}=="0000:00:1a.0"` is not the correct serial to be used in UDEV rules.

There is a solution [here](https://gist.github.com/cbrake/4337154) if you're using only one device:

    # single blue USB serial adapter, prolific devices don't seem to have a serial number that I can find
    SUBSYSTEM=="tty", DRIVERS=="pl2303", SYMLINK+="ttyUSB_panda"

But in my case there is two serial to USB adapters, one for each glove.
There is one workaround for it too. [Here](https://askubuntu.com/questions/49910/how-to-distinguish-between-identical-usb-to-serial-adapters), they use the position on the USB hub to create a `NAME` tag:

    KERNEL=="ttyUSB*", KERNELS=="1-8.1.5", NAME="ttyUSB0"

I only change `NAME` and use `SYMLINK` instead:

    KERNEL=="ttyUSB*", KERNELS=="1-1.3", SYMLINK+="ttyUSB.cyberglove.left"
    KERNEL=="ttyUSB*", KERNELS=="1-1.4", SYMLINK+="ttyUSB.cyberglove.right"

In this way you can use both adapters at the same time defining `tty` links to it. You only have to keep the device always at the same USB port or change the rule.

**BONUS:** How to reload UDEV rules without reboot:

    sudo udevadm control --reload-rules && udevadm trigger

Plug and unplug the device.


text:
---
layout: post
title: Big Visible Charts
date: 2016-03-24 04:23
author: burhaan
comments: true
categories: [Uncategorized]
---
One of the XP values is Communication. There are many ways of communicating within the team, and with people outside the team. We generally prefer conversation for most purposes, but when it comes to trends, history, or sensitive subjects, a good approach can be what we in XP call a Big Visible Chart, or what Alistair Cockburn (Agile Software Development) calls an Information Radiator. A simple chart on the wall can bring important information to the attention of the team, the customer, and everyone else who passes through the area. The chart can provide important information, even politically sensitive information, without getting personalities involved or hurting feelings.

Read more: Big Visible Charts.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Sokoban
The Japanese puzzle video game created for Android.

## Overview

This is a 2D puzzle game developed using Java. The game supports the following features:
* Choosing levels from a list
* Moving the player and crates around with WASD keys or on-screen controls
* Accurate Completed Targets count
* Move count
* Timer for elapsed time in a level that can be paused and un-paused
* Playing sound and turning it off

## Areas for improvement and New features to be added:
* Touchscreen support
* Support for different screen sizes
* Ability to add new and edit existing levels in-game

repository: daria-prn/Sokoban

branch_name: refs/heads/main

repo_name: daria-prn/Sokoban


text:
# Using the OAuth 2 Controllers #

## Introduction ##

[OAuth 2](http://wiki.oauth.net/w/page/25236487/OAuth-2) is a protocol allowing
your application to obtain authorization to read or modify a user’s files or
data on an external server.

The server generates a web page for the user to sign in with her name and
password, including a button explicitly granting access to some of her data.
Upon successful authentication, the server gives tokens to your application
representing the user's authorization.

With the Objective-C OAuth 2 controllers, the web page can be presented as an
iOS view or a Mac sheet within your application. The controllers also provide an
authentication object that simplifies your application's future requests for the
user's data.

There is also a [gtm-oauth](https://github.com/google/gtm-oauth) library for the
older OAuth 1 protocol. Most applications should use the OAuth 2 library for
services that support OAuth 2.

## Using the iOS and Mac OS X OAuth 2 Controllers ##

The OAuth 2 controllers are useful for authenticating both to Google servers and
to other services.

There are example iOS and Mac applications using the OAuth 2 controllers in the
library's
[Examples directory](https://github.com/google/gtm-oauth2/tree/master/Examples).

Controller methods with "Google" in the name are for use only with Google
services.

## Adding the Controllers to Your Project ##

The project has targets for building a static library for iOS and a framework
for Mac OS X. Alternatively, the source files and xibs may be dragged directly
into your project file and compiled with your application.

The source files required are:

| _iOS and Mac OS X_ | _iOS_ | _Mac OS X_ |
| ------------------ | ----- | ---------- |
| GTMOAuth2Authentication.h/m GTMOAuth2SignIn.h/m GTMHTTPFetcher.h/m | GTMOAuth2ViewControllerTouch.h/m GTMOAuth2ViewTouch.xib | GTMHTTPFetchHistory.h/m GTMOAuth2WindowController.h/m GTMOAuth2Window.xib |

Add the
[standard frameworks](https://developer.apple.com/library/ios/#recipes/xcode_help-project_editor/Articles/AddingaLibrarytoaTarget.html)
`Security.framework`, `SystemConfiguration.framework`, and `Webkit.framework` to your project.

When linking against a static library build of the controller, specify the
[-ObjC build option](http://developer.apple.com/mac/library/qa/qa2006/qa1490.html')
for the application target's "Other Linker Flags".

### ARC Compatibility ###

When the controller source files are compiled directly into a project that has
ARC enabled, then ARC must be disabled specifically for the controller source
files.

To disable ARC for source files in Xcode 4, select the project and the target in
Xcode. Under the target "Build Phases" tab, expand the Compile Sources build
phase, select the library source files, then press Enter to open an edit field,
and type `-fno-objc-arc`  as the compiler flag for those files.

### System Requirements ###

The Mac controller is compatible with Mac OS X 10.5 and later. The iOS
controller is compatible with iPhone OS 3 and later.

The sample applications use Objective-C blocks, so are intended for iOS 4 and
Mac OS X 10.6.

### Threading and Queues ###

Sign-in calls should be made on the main thread. Authorizing a request is best
done on the main thread as well.

Authorizing a request may be done on a background thread if the thread has a
spinning run loop. Alternatively, a `GTMOAuth2Authentication` object may be
assigned a `GTMHTTPFetcherService` object, where the fetcher service object has
a delegateQueue property indicating the queue to be used for calling back to the
application. Note that delegateQueue support requires iOS 6 or Mac OS X 10.7.

## Signing In to Google Services ##

### Registering Your Application ###

To sign in to Google services with the Objective-C OAuth 2 controllers, first
obtain a client ID and secret from the [API Console](https://console.developers.google.com/).

In the console, create a project, then click "API Access" in the left column.
Create a new Client ID for an **Installed Application** (not a web application)
type **other** (not iOS).  This will provide Client ID and Secret strings to be
used with the controller.

Click "Services" in the left column, and check the list of APIs to verify that
the needed APIs are turned on for the project.  Any Google APIs not listed in
the console do not need to be turned on individually.

### Displaying the Controllers ###

**iOS:** To display a sign-in view, your iOS application makes these calls to
push the view:

```Objective-C
#import "GTMOAuth2ViewControllerTouch.h"

static NSString *const kKeychainItemName = @"OAuth2 Sample: Google+";

NSString *kMyClientID = @"abcd";     // pre-assigned by service
NSString *kMyClientSecret = @"efgh"; // pre-assigned by service

NSString *scope = @"https://www.googleapis.com/auth/plus.me"; // scope for Google+ API

GTMOAuth2ViewControllerTouch *viewController;
viewController = [[[GTMOAuth2ViewControllerTouch alloc] initWithScope:scope
             clientID:kMyClientID
         clientSecret:kMyClientSecret
     keychainItemName:kKeychainItemName
             delegate:self
     finishedSelector:@selector(viewController:finishedWithAuth:error:)] autorelease];

[[self navigationController] pushViewController:controller
                                       animated:YES];
```

Each service will provide developers with **Client ID** and **Client Secret**
strings intended to be hardcoded as constants into applications.  Google
services issue the strings via the [Google API Console](https://console.developers.google.com/).

**Mac:** A Mac application would display sign-in as a sheet on the current
window, like this:

```Objective-C
#import "GTMOAuthWindowController.h"

GTMOAuth2WindowController *windowController;
windowController = [[[GTMOAuth2WindowController alloc] initWithScope:scope
              clientID:kMyClientID
          clientSecret:kMylientSecret
      keychainItemName:kKeychainItemName
        resourceBundle:nil] autorelease];

[controller signInSheetModalForWindow:currentWindow
                             delegate:self
                     finishedSelector:@selector(windowController:finishedWithAuth:error:)];
```

The **scope** is a string identifying what access is being requested. For access
to more than one scope, separate the scopes with a space, or use the convenience
method `scopeWithStrings:` in the class  `GTMOAuth2Authentication`.

The **keychain item name** is used to save the token on the user’s keychain, and
should identify both your application name and the service name(s). If
keychainItemName is nil, the token will not be saved, and the user will have to
sign in again the next time the application is run.

When the user signs in successfully or cancels signing in, the view or window
controller will invoke your finishedSelector’s method:

```Objective-C
- (void)viewController:(GTMOAuth2ViewControllerTouch *)viewController
      finishedWithAuth:(GTMOAuth2Authentication *)auth
                 error:(NSError *)error {
 if (error != nil) {
   // Authentication failed
 } else {
   // Authentication succeeded
 }
}
```

If `[error code]` is `kGTMOAuthErrorWindowClosed` (-1000), then the user closed
the sign-in view before completing authentication. Otherwise, any error reflects
the server response in validating the user's access.

The controllers also support Objective-C block completion handlers as
alternatives to the delegate and finished selectors.

### Using the Authentication Tokens ###

If authentication succeeds, your application should retain the authentication
object. It can be used directly to authorize NSMutableURLRequest objects:

```Objective-C
[auth authorizeRequest:myNSURLMutableRequest
              delegate:self
     didFinishSelector:@selector(authentication:request:finishedWithError:)];
```

The authentication object may need to fetch a refreshed access token before
authorizing the request, so the authorization call is asynchronous, though it
will often authorize the request and call the callback immediately.

If the error passed to the callback is nil, then the request was authorized:

```Objective-C
- (void)authentication:(GTMOAuth2Authentication *)auth
               request:(NSMutableURLRequest *)request
     finishedWithError:(NSError *)error {
 if (error != nil) {
   // Authorization failed
 } else {
   // Authorization succeeded
 }
}
```

Authorization may also be done with a block callback:

```Objective-C
[auth authorizeRequest:myNSURLMutableRequest
     completionHandler:^(NSError *error) {
  if (error == nil) {
    // the request has been authorized
  }
}];
```

With the [GTM HTTP Fetcher](https://github.com/google/gtm-http-fetcher), the
authentication object can be attached to the fetcher, making the authorization
step transparent:

```Objective-C
[fetcher setAuthorizer:auth];
```

Similarly, in the
[Google APIs Client library](https://github.com/google/google-api-objectivec-client)
and the [Google Data APIs library](https://github.com/google/gdata-objectivec-client)
the authentication object can be stored in a library service object to authorize
future API requests:

```Objective-C
[[self contactService] setAuthorizer:auth];
```

**Note:** To avoid sending authorization tokens insecurely, authorization should
be added only to requests with the https scheme. To authorize a request that has
any other URL scheme, the authentication object property
`shouldAuthorizeAllRequests` must first be set to `YES` to override the https
requirement and avoid the error `kGTMOAuth2ErrorUnauthorizableRequest`.

### Retrieving Authorization from the Keychain ###

If your application saves the authorization to the keychain (by setting the
controller's keychainItemName), it can be retrieved the next time the
application launches:

```Objective-C
- (void)awakeFromNib {
  // Get the saved authentication, if any, from the keychain.
  GTMOAuth2Authentication *auth;
  auth = [GTMOAuth2ViewControllerTouch authForGoogleFromKeychainForName:kKeychainItemName
                                                               clientID:kMyClientID
                                                           clientSecret:kMyClientSecret];

  // Retain the authentication object, which holds the auth tokens
  //
  // We can determine later if the auth object contains an access token
  // by calling its -canAuthorize method
  [self setAuthentication:auth];
}
```

If no authorization was saved, then “auth” will still be a valid authorization
object but will be unable to authorize requests:

```Objective-C
BOOL isSignedIn = [auth canAuthorize]; // returns NO if auth cannot authorize requests
```

### Signing Out ###

To completely discard the user’s authorization, use the view or window
controller calls to remove the keychain entry and to ask the Google server to
revoke the token:

```Objective-C
 [GTMOAuth2ViewControllerTouch removeAuthFromKeychainForName:kKeychainItemName];

 [GTMOAuth2ViewControllerTouch revokeTokenForGoogleAuthentication:auth];
```

Finally, release the authorization object.

## Signing in to non-Google Services ##

### Registering Your Application ###

Check the API documentation for the service to determine how to obtain a client
ID and secret.

If the service supports installed applications with the redirect URI
"urn:ietf:wg:oauth:2.0:oob", then register your application as an installed
application.

Otherwise, register as a normal web application, and if the registration
requires that you also specify a redirect URI, supply some **invalid** URL at
your domain. The controllers will look for loading of the redirect URI as an
indication that sign-in has completed, but will not attempt to load the URL.

### Displaying the Controllers ###

To sign in to a non-Google service, you should consult the service's API
documentation to obtain client ID and client secret strings, to find the
required scope string for API operations, and to determine the API endpoints
(URLs) for authorization and for obtaining tokens.

To use the OAuth 2 controllers with services other than Google APIs, your
application should create an authentication object with the appropriate
constants, like this:

```Objective-C
NSString *kMyClientID = @"abcd";     // pre-assigned by service
NSString *kMyClientSecret = @"efgh"; // pre-assigned by service

- (GTMOAuth2Authentication *)myCustomAuth {

  NSURL *tokenURL = [NSURL URLWithString:@"https://api.example.com/oauth/token"];

  // We'll make up an arbitrary redirectURI.  The controller will watch for
  // the server to redirect the web view to this URI, but this URI will not be
  // loaded, so it need not be for any actual web page.
  NSString *redirectURI = @"http://www.google.com/OAuthCallback";

  GTMOAuth2Authentication *auth;
  auth = [GTMOAuth2Authentication authenticationWithServiceProvider:@"Custom Service"
                                                           tokenURL:tokenURL
                                                        redirectURI:redirectURI
                                                           clientID:kClientID
                                                       clientSecret:kClientSecret];
  return auth;
}
```

Displaying the sign-in view with a custom auth also requires providing the OAuth
2 endpoints (URLs) and scope string to the controller, as shown here:

```Objective-C
- (void)signInToCustomService {
  [self signOut];

  GTMOAuth2Authentication *auth = [self authForCustomService];

  // Specify the appropriate scope string, if any, according to the service's API documentation
  auth.scope = @"read";

  NSURL *authURL = [NSURL URLWithString:@"https://api.example.com/oauth/authorize"];

  // Display the authentication view
  GTMOAuth2ViewControllerTouch *viewController;
  viewController = [[[GTMOAuth2ViewControllerTouch alloc] initWithAuthentication:auth
        authorizationURL:authURL
        keychainItemName:kKeychainItemName
                delegate:self
        finishedSelector:@selector(viewController:finishedWithAuth:error:)] autorelease];

  // Now push our sign-in view
  [[self navigationController] pushViewController:viewController animated:YES];
}
```

The keychain item name is used to save the token on the user’s keychain, and
should identify both your application name and the service name(s). If
keychainItemName is nil, the token will not be saved, and the user will have to
sign in again the next time the application is run.

When the user signs in successfully or cancels signing in, the view or window
controller will invoke your finishedSelector’s method:

```Objective-C
- (void)viewController:(GTMOAuthViewControllerTouch *)viewController
      finishedWithAuth:(GTMOAuthAuthentication *)auth
                 error:(NSError *)error {
 if (error != nil) {
   // Sign-in failed
 } else {
   // Sign-in succeeded
 }
}
```

If `[error code]` is `kGTMOAuth2ErrorWindowClosed` (-1000), then the user closed
the sign-in view before completing authorization. Otherwise, any error reflects
the server response in validating the user's access.

The controllers also support Objective-C block completion handlers as
alternatives to the delegate and finished selectors.

### Using the Authentication Tokens ###

If authentication succeeds, your application should retain the authentication
object. It can be used directly to authorize NSMutableURLRequest objects:

```Objective-C
[auth authorizeRequest:myNSURLMutableRequest
              delegate:self
     didFinishSelector:@selector(authentication:request:finishedWithError:)];
```

The authentication object may need to fetch a refreshed access token, so the
authorization call is asynchronous, though it will often authorize the request
and call the callback immediately.

If the error passed to the callback is nil, then the request was authorized:
```Objective-C
- (void)authentication:(GTMOAuth2Authentication *)auth
               request:(NSMutableURLRequest *)request
     finishedWithError:(NSError *)error {
 if (error != nil) {
   // Authorization failed
 } else {
   // Authorization succeeded
 }
}
```

Authorization may also be done with a block callback:
```Objective-C
[auth authorizeRequest:myNSURLMutableRequest
     completionHandler:^(NSError *error) {
  if (error == nil) {
    // the request has been authorized
  }
}];
```

With the [GTM HTTP Fetcher](https://github.com/google/gtm-http-fetcher), the
authentication object can be attached to the fetcher, making the authorization
step transparent:

```Objective-C
[fetcher setAuthorizer:auth];
```

**Note:** To avoid sending authorization tokens insecurely, authorization should
be added only to requests with the https scheme. To authorize a request that has
any other URL scheme, the authentication object property
`shouldAuthorizeAllRequests` must first be set to `YES` to override the https
requirement and avoid the error `kGTMOAuth2ErrorUnauthorizableRequest`.

### Retrieving Authorization from the Keychain ###

If your application saves the authorization to the keychain (by setting the
controller's keychainItemName), it can be retrieved the next time the
application launches:

```Objective-C
- (void)awakeFromNib {
  // Get the saved authentication, if any, from the keychain.
  GTMOAuth2Authentication *auth = [self myCustomAuth];
  if (auth) {
    BOOL didAuth = [GTMOAuth2ViewControllerTouch authorizeFromKeychainForName:@"My App: Custom Service"
                                                               authentication:auth];
  }

  // Retain the authentication object, which holds the auth tokens
  //
  // We can determine later if the auth object contains an access token
  // by calling its -canAuthorize method
  [self setAuthentication:auth];
}
```

If no authorization was saved, then “auth” will still be a valid authorization
object but will be unable to authorize requests:

```Objective-C
BOOL isSignedIn = [auth canAuthorize]; // returns NO if auth cannot authorize requests
```

### Signing Out ###

To completely discard the user’s authorization, use the view or window
controller calls to remove the keychain entry:

```Objective-C
[GTMOAuthViewControllerTouch removeAuthFromKeychainForName:kKeychainItemName];
```

Finally, release the authorization object.

# Design Notes #

The library's classes are designed in three layers.

> *Window/View Controller* :: user interface & application API, including keychain

> *Sign-In* :: OAuth sign-in sequence & WebView handling

> *Authentication* :: data handling, token fetches

Classes are written to be independent of the layers above them.

The window and view controllers are retained only during the user's sign-in
interaction.

The sign-in object is typically not used directly by the client application.

The authentication object must be retained by the client app to authorize
NSMutableURLRequests. It is also used to save authentication to and read
authentication from the keychain.

# Questions and Comments #

You can learn more about the OAuth 2 protocol for desktop and mobile
applications at
[Google's documentation](http://code.google.com/apis/accounts/docs/OAuth2.html).

Additional documentation for the controllers is available in the header files.

If you have any questions or comments about the library or this documentation,
please join the [discussion group](http://groups.google.com/group/gtm-oauth2).

gha_language: Objective-C


text:
# CHANGELOG

## 0.4 - 2015-05-04
* Adds authentication support
* Removes HTTPAdapterBundle as dependency, because it is not available in a current enough version. The Firebase library
  will guess the best fitting HTTP client from the available clients in your project.

## 0.3.1 - 2015-01-28
### FEATURE
* Ability to specify HTTP adapter

### CLEANUP
* Removed unused USE statements
* Text files should contain line endings

## 0.2.4 - 2015-01-23
### FIX
* fixed autoloading namespace

###Added
* Initial commit, version is in-sync with the firebase-php lib for convenience
* Here we go.

repository: danidelalin/firebase-bundle

repo_name: danidelalin/firebase-bundle


text:
# Push to WNS sample

This sample is useful when you want to test the end to end flow between client app and WNS without Azure Notification Hubs in the picture. This helps in validating that your client app is set up correctly as well that you have the correct Package SID & Secret that you are configuring in the Azure Notification Hubs. In case the PNS responds with an error then you also get to see the exact error from the WNS itself providing additional information.

One of the common Notification errors you will get help in debugging with this application is this - *The Token obtained from the Token Provider is wrong*. This error happens because of either invalid channelURI (because the client app wasn't properly configured) or invalid secret/package SID values.

This is based on the [Quickstart - send WNS push notification].

###Steps:###

1. Provide the values for `secret` & Package SID (as `sid`) that you get from [Windows Dev Center] for your application. These are the values which are also configured in Azure Notification Hubs.

2. Provide the values for the `xml` (payload), `notificationType` & `contentType`. You can find more information on this here - [WNS Notification Types]. Example for sending a toast notification you use the following:

	    string xml = @"<toast><visual><binding template=""ToastText01""><text id=""1"">Hello there!</text></binding></visual></toast>";
	    string notificationType = "wns/toast";
	    string contentType = "text/xml";

3. Provide the `channelUri` you receive on the client app when you registered with WNS. E.g. when you execute the following on the Windows app:

		var channelUri = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

4. In case of an error, you will see detailed PNS feedback like the following:

    ![][1]

<!-- Links -->
[Quickstart - send WNS push notification]: http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh868252.aspx
[Windows Dev Center]: http://go.microsoft.com/fwlink/p/?linkid=266582&clcid=0x409
[WNS Notification Types]: http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh868245.aspx#pncodes_x_wns_type

<!-- Images -->
[1]: ./media/Error.png


text:
---
layout: post
title: "Guy Fawkes Night and Fireworks 2011"
permalink: /archives/2011/10/guy_fawkes_night_and_fireworks_2011.html
commentfile: 2011-10-27-guy_fawkes_night_and_fireworks_2011
category: around_town
date: 2011-10-27 22:16:37
image: "/assets/images/2011/fireworks-thumb.jpg"
excerpt: |

    ### Friday 4th November 2011

    #### Kingsmeadow Athletics Stadium - Kingston

    _The Kingston fireworks display promises to be a massive London fireworks event, with a huge display, family attractions and more kicking off at Kingsmeadow Athletics Stadium._

    * gates 6.30pm, display 8pm
    * Admission: Adults £6.00, children aged 5-11 £4.00
    ** Advance Tickets: Adults £4.00, children aged 5-11 £3.00

---

### Friday 4th November 2011

#### Kingsmeadow Athletics Stadium - Kingston

*The Kingston fireworks display promises to be a massive London fireworks event, with a huge display, family attractions and more kicking off at Kingsmeadow Athletics Stadium.*

-   gates 6.30pm, display 8pm
-   Admission: Adults £6.00, children aged 5-11 £4.00
    -   Advance Tickets: Adults £4.00, children aged 5-11 £3.00

### Saturday 5th November 2011

#### Barnes Sports Club

*Head to the Barnes fireworks display for a huge bonfire, live music, hot food and plenty of family friendly entertainment.*

-   gates 5.30pm, display 7:45pm
-   Admission: £10.00 adults, £5.00 children. Kids under 5 go free. Family ticket £20.00

#### Imber Court Sports Club

*Fun fair, food and more...*

-   gates 5pm, display 7.30pm
-   Admision: £7 adults, £4 children. Kids under 14: £3. Family ticket: £16
-   Ember Lane, East Mosley, KT8 0BT
-   [imbercourtsportsclub.co.uk/imber/index.php?option=com\_content&task=view&id=87&Itemid=238](http://imbercourtsportsclub.co.uk/imber/index.php?option=com_content&task=view&id=87&Itemid=238)

#### Kempton Park Racecourse

*Lighting up the skies above Sunbury on Thames, the Kempton Park fireworks display is one of the biggest Bonfire Night events in West London.*

-   gates 5:30pm, display: 7:45pm
-   Admission: £6.00 in advance, £8.00 on the night

### Sunday 6th November 2011

#### Richmond Athletics Ground

*The Richmond fireworks display is back again, bringing a spectacular collection of fireworks and fun to West London. A real favourite for locals, the Richmond fireworks display remains incredibly popular thanks to a family friendly atmosphere and a display that's always of the highest quality.*

-   gates 5pm, display 7pm
-   Admission: Advance tickets are £8.00 for adults, £5.00 for children over 5 and £25.00 for a family ticket. Tickets bought on the night cost £10.00 for adults, £5.00 for kids in advance and £30.00 for a family ticket.
-   Call (020) 8940 0397 to book tickets

### Saturday 12th November 2010

#### Lord Mayors Show London

*The Lord Mayors Show London celebrates an 800 year London tradition in grand, historic style. Take to the streets on Saturday 12th November to enjoy, parades, festivities, fireworks and more in an historic London event.*

-   display: 5pm
-   River Thames, between Waterloo Bridge and Blackfriars Bridge
-   Admission: Free

repository: pmahnke/stmgrts

gha_language: HTML

repo_name: pmahnke/stmgrts


text:
# Control Repo for Deploy Tickstack with Puppet
Written by [Adrian Moen](https://github.com/amojamo). and [Askil Olsen](https://github.com/askilao). for IMT3004 Infrastructure as Code project fall 2018

This repo is not used when deploying the stack, but is used my the server provisioning tool to install and configure the TICK stack.
The service is deployed using the [Openstack HEAT template](https://github.com/amojamo/IaC-heat-k8s).

Here's a visual representation of the structure of this repository:

```
control-repo/
├── data/                                 # Hiera data directory.
│   ├── nodes/                            # Node-specific data goes here.
│   └── common.yaml                       # Common data goes here.
├── manifests/
│   └── site.pp                           # The "main" manifest that contains a default node definition.
├── scripts/
│   ├── code_manager_config_version.rb    # A config_version script for Code Manager.
│   ├── config_version.rb                 # A config_version script for r10k.
│   └── config_version.sh                 # A wrapper that chooses the appropriate config_version script.
├── site/                                 # This directory contains site-specific modules and is added to $modulepath.
│   ├── profile/                          # The profile module.
│   └── role/                             # The role module.
├── LICENSE
├── Puppetfile                            # A list of external Puppet modules to deploy with an environment.
├── README.md
├── environment.conf                      # Environment-specific settings. Configures the moduelpath and config_version.
└── hiera.yaml                            # Hiera's configuration file. The Hiera hierarchy is defined here.

branch_name: refs/heads/production

gha_language: Ruby


text:
# de.holisticon.dependencies:junit-mockito
[![Build Status](https://secure.travis-ci.org/holisticon/java-test-deps.png)](https://travis-ci.org/holisticon/java-test-deps)
## Introduction
This is just a dead simple pom that aggregates test dependencies. These are:

- [junit](https://github.com/junit-team/junit/wiki) as a general purpose testing framework.
- [hamcrest](https://code.google.com/p/hamcrest/) for better asserts.
- [equalsverifier](https://code.google.com/p/equalsverifier/) to test equals and hashcode methods.
- [mockito](https://code.google.com/p/mockito/) for convenient mocking.
- [tempus-fugit](http://tempusfugitlibrary.org/) for concurrent testing
- [fest-assert](https://code.google.com/p/fest/) for fluent assertions

in their current version. That's it.

## Getting started
Put it in your pom and be happy. ;)

```
<dependency>
	<groupId>de.holisticon.dependencies</groupId>
	<artifactId>junit-mockito</artifactId>
	<version>1.0</version>
	<scope>test</scope>
	<type>pom</type>
</dependency>
```

## Contribution
Have a neat tool for testing that is not in here? Let us know.

## Sponsoring
This project is sponsored and supported by [holisticon AG](http://holisticon.de/cms/About/Startseite)

## License
This project is released under the revised BSD License (s. [License](license.txt)).

repository: neaos/java-test-deps

repo_name: neaos/java-test-deps


text:
# ["Mock" Garlic Mashed Potatoes](http://www.foodnetwork.com/recipes/mock-garlic-mashed-potatoes-recipe.html)
![alt text](http://foodnetwork.sndimg.com/content/dam/images/food/fullset/2004/5/10/0/ll1a03_garlic_mashed_potatoes1.jpg.rend.sni12col.landscape.jpeg)
### Ingredients

####
* 1 medium head cauliflower
* 1 tablespoon cream cheese, softened
* 1/4 cup grated Parmesan
* 1/2 teaspoon minced garlic
* 1/8 teaspoon straight chicken base or bullion (may substitute 1/2 teaspoon salt)
* 1/8 teaspoon freshly ground black pepper
* 1/2 teaspoon chopped fresh or dry chives, for garnish
* 3 tablespoons unsalted butter

### Instructions
* Set a stockpot of water to boil over high heat.
* Clean and cut cauliflower into small pieces. Cook in boiling water for about 6 minutes, or until well done. Drain well; do not let cool and pat cooked cauliflower very dry between several layers of paper towels.
* In a bowl with an immersion blender, or in a food processor, puree the hot cauliflower with the cream cheese, Parmesan, garlic, chicken base, and pepper until almost smooth.
* Garnish with chives, and serve hot with pats of butter.
* Hint: Try roasting the garlic and adding a little fresh
* rosemary for a whole new taste.
* Chef: George Stella

repository: Brooke-white/RecipeParser

path: /Recipes/"Mock" Garlic Mashed Potatoes.md

filename: "Mock" Garlic Mashed Potatoes.md

repo_name: Brooke-white/RecipeParser


text:
# day-of-year

  get the day of year because javascript has no tm_yday

## Installation

  Install with [component(1)](http://component.io):

    $ component install stephenmathieson/day-of-year

## API

### `dayOfYear(date)`

get the day of the year from the given `date`

### `dayOfYear()`

get the current day of the year

## License

  MIT


text:
---
date: 2020-05-17
time: 22h:30min
duration: "01:44:48"
title: "Self-Taught Developers"
tags: ["self-taught", "software engineering", "career"]
category: "career"
isNext: false
video: "2971727423053675"
youtube: https://www.youtube.com/watch?v=EOnbBm31kiA
published: true
featured: false
url: ""
podcastUrl: https://www.facebook.com/geeksblabla/videos/2971727423053675/
---

In this episode of GeeksBlabla, we discuss with self-taught developers about their experience, how they get started and how they made it professionally.

## Guests

[Abderrahim Soubai Elidrissi](https://www.facebook.com/zizwar0nline)

[Youness Hakky](https://www.facebook.com/younes.hakky)

[Ismail Ghallou](https://twitter.com/smakosh)

## Notes

0:00:00 - Introduction

0:05:00 - If you don’t have a CS degree, how did you learn to code?

0:08:00 - Did you do any particular courses or bootcamps?

0:12:00 - Was the learning path difficult at the beginning?

0:18:00 - How can you stay motivated while learning to code?

0:24:00 - Is it okay to start building an online presence as newbie web dev?

0:28:00 - How can a junior developer get out of the "tutorial cycle" ?

0:33:00 - Since things evolve very rapidly, how do you decide on what is worth learning ?

0:36:00 - What kind of projects should we work on ? should this projects be something really special and unique, or just take personal ideas and keep working on them and sharing them?

0:37:00 - How did you get your first programming job/ freelance work?

0:43:00 - How has your life changed since becoming a professional programmer?

0:49:00 - Has anyone ever asked about your coding qualifications when you have been talking to clients?

0:51:00 - Do you think a CS degree is unnecessary now?

0:57:00 - Did you still learn after you got your first job

1:00:00 - Do you have tips for getting a remote job as a junior developer?

1:02:00 - What advice do you have for someone who wants to get their first programming job but they don’t have the time or money for a CS degree?

1:32:00 - Is there something that most self-taughts have over "classic" engineers ?

1:35:00 - Does security background helps in cracking interviews and landing jobs as a developer?

1:42:00 - Will you go after fundamentals (Data types, patterns, algorithms...etc) Or you just learn things directly and try hard to go for it?

1:44:00 - Wrap up and Goodbye.

## Prepared and Presented by :

- [Mohammed Aboullaite](https://www.facebook.com/aboullaite)

- [Meriem Zaid](https://www.facebook.com/MeriemZaid)

gha_license_id: MIT


text:
# Jupyter Notebook + RStudio
Base container for people who need jupyter notebook and RStudio in the same image.

# Main stack
(based on [base-notebook](https://github.com/jupyter/docker-stacks/tree/master/base-notebook))
- Jupyer Notebook
- RStudio Server <IP_ADDRESS>3
- R (3.6.2)

# Python libraries
- scipy
- scanpy
- python-igraph
- louvain
- bbknn
- rpy2
- leidenalg
- pandas

# Run
```
docker run --name jovyan-studio --detach --publish 80:8888 --env GRANT_SUDO=yes --user root --volume ${PWD}:/home/jovyan prete/jupyter-rstudio:3.2.6
```

To get the token for log in in use `docker logs jovyan-studio` and it will show the output of the jupyter launch command that is used to start the notebook.

## Jupyter notebook config file
Create a new jupyter configuration file and place it inside {VOLUME_PATH}/.jupyter/jupyter_notebook_config.py
For quick and **UNSECURE** access you can set `c.NotebookApp.token = ''`. Read more about [securing a notebook server](https://jupyter-notebook.readthedocs.io/en/stable/public_server.html#securing-a-notebook-server) on the official documentation.

# Disclaimer
There are probably a whole bunch of  python libraries or system packages that you don't really need (fuse/sshfs/openjdk) but they make my life easier.

repository: prete/jupyter-rstudio

repo_name: prete/jupyter-rstudio


text:
# Note Taker

![](https://img.shields.io/static/v1?label=license&message=MIT&color=green)

## Table of Contents
* [Description](#description)
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Contributions](#contributions)
* [Tests](#tests)
* [Contact Me](#contact-me)

## Description
Note taker is designed to be a personal assistant where the user can type a note in the right side and it will have a persistent save in a .json file on the web server.

## Installation
To install this project, you must have a computer with npm, express, and heroku on it.  Then clone the project from github, npm init it, install it to heroku, and go crazy writing notes.

## Usage
The user would type a title in to the the title box, then a note to correspond to the title and click on the save icon.  Once the note became old, they can delete it by clicking on the trash can to the right of the not title.

![](./public/assets/images/notetaker-index.jpg)
![](./public/assets/images/notetaker-notes.jpg)

## License
MIT License

Copyright (c) 2020 Brent Feuerbacher

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

## Contributions
I am not accepting contributions at this time.

## Tests
There are no instructions for testing this project at this time.

## Contact Me
*<EMAIL_ADDRESS>
* [GitHub](https://www.github.com/feuerbacherb)

repository: feuerbacherb/notetaker

repo_name: feuerbacherb/notetaker


text:
# HomeKit Heater 🔥

This is a project that aims to control a simple panel heater that can be turned
on with a simple 5V signal through HomeKit.

## Setup

This project requires the tools from Espressif to be set up on your computer.
Please follow the instructions here:
https://docs.espressif.com/projects/esp-idf/en/stable/get-started/

When everything is installed, make sure you've checked out all the submodules:

```sh
git submodule update --init --recursive
```

Then you need to create an `wifi.h` in the project root with the following
contents:

```c
#define WIFI_SSID "<your wifi ssid>"
#define WIFI_PASSWORD "<your wifi mypassword>"
```

After that you can run `make` to compile the project.

repository: ljodal/esp-homekit-heater

gha_language: C

repo_name: ljodal/esp-homekit-heater


text:
# jwk-tool

Command line tools for operating JSON Web Key

# Install

    gem install jwk-tool

# Usage

The following command generate key pairs, private key 'key' and public key 'key.pub' into the current folder.

    jwk_tool -g -k key
    jwk_tool --generate --key=key

To use the keys as JSON Web Key (JSON::JWK) defined in json-jwk, just read files, parse them and then pass to the initialization method.

An encryption example at sender node using public key.

```ruby
require 'json/jwt'
# read public key from file
jwk_pub = JSON::JWK.new(JSON.parse(open('key.pub').read))
# encrypt plain text "hogehogefoofoo"
jwe = JSON::JWE.new("hogehogefoofoo")
# choose block cipher algorithm
jwe.enc = :A128GCM
# choose cipher algorithm for encrypting block cipher key (symmetric cipher key)
jwe.alg = :RSA1_5
# encryption
jwe.encrypt!(jwk_pub.to_key)
# output the result in JSON format
json = jwe.as_json.to_json
```

A decryption example at receiver node using private key.

```ruby
require 'json/jwt'
# read private key from file
jwk = JSON::JWK.new(JSON.parse(open('key').read))
# decrypt JSON format cipher data
jwe_dec = JSON::JWE.decode_json_serialized(JSON.parse(json), jwk.to_key)
# obtain the original plain text
jwe_dec.plain_text
```

repository: toyokazu/jwk-tool

repo_name: toyokazu/jwk-tool


text:
# Introdution

## About *Gaia*

*Gaia* is a micro-services developement kit including basic functional modules, a platform and a framework.

The mainly supported language is C++, but some component of the platform maybe written in other languages, such as C# and Java.

## About *Gaia Connections*

*Gaia Connections* is a series of C++ libraries providing interprocess communication ability.

Main communication methods are TCP, UDP, and shared memory. *Gaia Connections* only provide their basic encapsulation.

# Collaborators

Thank you for your contribution. *Gaia* is a huge and complex project which can only be developed and improved with the effort of the open-source community. The administration committee sincerely appreciate your issues and pull requests.

To make it fast, stable, and easy to use, there is still much work to do, but the committee deeply believe that step by step the goal will be achieved if we all do our part.

## File Extension Types

*Gaia* may contained some modules desgined for embedded devices, and those modules will be written in C and no C++ feature is allowed. To distinguish the C and C++ files especially header files, file extensions are specified in the following table.

| Type | Extension |
|:----:|:---------:|
| C++ Source File | .cpp |
| C++ Header File | .hpp |
| C Source File | .c |
| C Header File | .h |
| CUDA Source File | .cu |
| CUDA Header File | .cuh |

## Naming Style

To make the source code uniformed and easy to read, please use the naming style specified in the following table.

| Type | Style |
|:-----|:-----:|
| File | BigCamel |
| Namespace | BigCamel |
| Class | BigCamel |
| Class Memeber Variable | BigCamel |
| Class Member Function | BigCamel |
| Global Function | BigCamel |
| Global Variable | BigCamel |
| Macro | BIG_SNAKE |
| Macro Functions | BIG_SNAKE or BigCamel |
| Local Variable | smallCamel_underscore_tolerant |
| Function Parameter | smallCamel_underscore_tolerant |
| Template Parameter | BigCamel

## Comment and Document

Part of the document is converted from the comments in the code. Please use *Doxygen* comment style, for example:
```C++
/**
 @brief Write the brief introdution here.
 @details Write detialed information here.
 @param parameter_name Descibe how this variable will be used
 @return Describe what will be returned
 */
 int Foo();
```

As for functions, please comment the parameters, return value,  the brief introduction, and exceptions if it will throw, and other detials to which users should pay attention to.

As for classes and structures, besides the brief introduction and detials, please comment its author's name, real name or nick name. Also, you have the right to keep anonymous, but this may cause unnecessary trouble if other developers want to contact the author of a class or structure.

## Contribute and Contact

You are welcomed to open issues and make pull requests. The administer on duty will try to contact you in e-mail if there is any problem.

As for languages, you can contact the committee in English and Chinese, but we do recommend you write *Issues*, *Commit Comment* and *Pull Request Comment* in English. Text written in other languages will be translated with online translation tools, thus it may cause misunderstanding or other unnecessary trouble.

repository: qhtLucifer/GaiaConnections

repo_name: qhtLucifer/GaiaConnections


text:
---
layout: page
title: Results
nav_order: 4
description: >-
    Results of smoothiebot project
---

# Results
{:.no_toc}

## Table of contents
{: .no_toc .text-delta }

1. Performance
2. Demo
{:toc}

---

## Performance

As seen in the video, the SmoothieBot begins by prompting the user for a recipe which defines what fruit are desired. Once the transformations are captured between the RealSense camera, the table’s AR tags, and the Baxter robot, the fruit are placed on the table in front of the camera. The point cloud is captured and used to classify the fruit and the system picks a fruit that is specified in the recipe to target. From there, the robot reaches forward, grabs the fruit, and drops it in the blender. This process, starting at capturing the table’s pointcloud, is repeated for every fruit in the recipe.  Once the recipe is complete and all desired fruit have been added to the blender, the robot grabs the blender lid and drops it onto the blender.

## Demo

[![demo](https://img.youtube.com/vi/gyzpliYOKKU/0.jpg)](https://www.youtube.com/watch?v=gyzpliYOKKU)

[![demo](https://img.youtube.com/vi/VEV4oVUFBEc/0.jpg)](https://www.youtube.com/watch?v=VEV4oVUFBEc)

repository: brentsienko/SmoothieBot

repo_name: brentsienko/SmoothieBot


text:
# CircularRatingWithAvatar
A custom android component to show rating with colorful circular view
### Samples
|   |   |
|:-:|:-:|
  |  |
|

[![](https://jitpack.io/v/BarOvda/CircularRatingWithAvatar.svg)](https://jitpack.io/#BarOvda/CircularRatingWithAvatar/1.1)

## Setup

Step 1. Add the JitPack repository to your build file
Add it in your root build.gradle at the end of repositories:

	allprojects {
		repositories {
			...
			maven { url 'https://jitpack.io' }
		}
	}
Step 2. Add the dependency

	dependencies {
	        implementation 'com.github.BarOvda:CircularRatingWithAvatar:Tag'
	}

## XML
```
    <com.example.circularratingwithavatarlibrary.ProgressTextView
        android:id="@+id/circular_rating_bar"
        android:layout_width="184dp"
        android:layout_height="150dp"
        android:layout_marginStart="84dp"
        android:layout_marginLeft="84dp"
        android:layout_marginTop="204dp"
        app:current_rating="8"
        app:mid_color = "@color/mid_color"
        app:low_color = "@color/min_color"
        app:high_color = "@color/high_color"
        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toTopOf="parent"
        app:max_rating="10">
    </com.example.circularratingwithavatarlibrary.ProgressTextView>

```

Here is the list of properties you can use to configure this view:
 1. app:max_rating (float)  ==> sets the maximum value of rating (deafult value:100)
 2. app:current_rating (float) ==> sets the rating (deafult value:0)
 3. app:low_color (color)  ==> sets the maximum value of rating (deafult value:#FFDC1D1D)
 4. app:mid_color (color) ==> sets the rating (deafult value:#FFB5B208)
 5. app:high_color (color)  ==> sets the maximum value of rating (deafult value:#FF20BA05)

## License
 Copyright 2019-2020 Bar Ovda

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

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

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

repository: BarOvda/CircularRatingWithAvatar

gha_language: Java

repo_name: BarOvda/CircularRatingWithAvatar


text:
[[breadcrumb /dnd/general/Adventuring#downtime-activities|Downtime Activities]]

<script type="module">
    import {init_gm_notes_inserts} from "/static/js/common/gm_notes.js";
    init_gm_notes_inserts("dnd");
</script>

This page lists extra Downtime Activities options gathered from other source books. Not all of these options will be available to you during your campaign, and your DM has the final say on how any of the mechanics work, regardless of what the text below may say.

# Dungeon Master's Guide

*Source: Dungeon Master's Guide, p. 128*

The Player's Handbook describes a few downtime activities to fill the void between adventures. Depending on the style of your campaign and the particular backgrounds and interests of the adventurers, you can make some or all of the following additional activities available as options.

## Building a Stronghold

A character can spend time between adventures building a stronghold. Before work can begin, the character must acquire a plot of land. If the estate lies within a kingdom or similar domain, the character will need a royal charter (a legal document granting permission to oversee the estate in the name of the crown), a land grant (a legal document bequeathing custody of the land to the character for as long as he or she remains loyal to the crown), or a deed (a legal document that serves as proof of ownership). Land can also be acquired by inheritance or other means.

Royal charters and land grants are usually given by the crown as a reward for faithful service, although they can also be bought. Deeds can be bought or inherited. A small estate might sell for as little as 100 gp or as much as 1,000 gp. A large estate might cost 5,000 gp or more, if it can be bought at all.

Once the estate is secured, a character needs access to building materials and laborers. The Building a Stronghold table shows the cost of building the stronghold (including materials and labor) and the amount of time it takes, provided that the character is using downtime to oversee construction. Work can continue while the character is away, but each day the character is away adds 3 days to the construction time.

***Building A Stronghold***

||~ Stronghold ||~ Construction Cost ||~ Construction Time ||
|| Abbey || 50,000 gp || 400 days ||
|| Guildhall, town or city || 5,000 gp || 60 days ||
|| Keep or small castle || 50,000 gp || 400 days ||
|| Noble estate with manor || 25,000 gp || 150 days ||
|| Outpost or fort || 15,000 gp || 100 days ||
|| Palace or large castle || 500,000 gp || 1,200 days ||
|| Temple || 50,000 gp || 400 days ||
|| Tower, fortified || 15,000 gp || 100 days ||
|| Trading post || 5,000 gp || 60 days ||

## Running a Business

Adventurers can end up owning businesses that have nothing to do with delving into dungeons or saving the world. A character might inherit a smithy, or the party might be given a parcel of farmland or a tavern as a reward. If they hold on to the business, they might feel obliged to spend time between adventures maintaining the venture and making sure it runs smoothly.

A character rolls percentile dice and adds the number of days spent on this downtime activity (maximum 30), then compares the total to the Running a Business table to determine what happens.

If the character is required to pay a cost as a result of rolling on this table but fails to do so, the business begins to fail. For each unpaid debt incurred in this manner, the character takes a -10 penalty to subsequent rolls made on this table.

**Running a Business**

||~ d100 ||~ Result ||
|| 01-20 || You must pay one and a half times the business's maintenance cost for each of the days. ||
|| 21-30 || You must pay the business's full maintenance cost for each of the days. ||
|| 31-40 || You must pay half the business's maintenance cost for each of the days. Profits cover the other half. ||
|| 41-60 || The business covers its own maintenance cost for each of the days. ||
|| 61-80 || The business covers its own maintenance cost for each of the days. It earns a profit of 1d6 x 5 gp. ||
|| 81-90 || The business covers its own maintenance cost for each of the days. It earns a profit of 2d8 x 5 gp. ||
|| 91 or higher || The business covers its own maintenance cost for each of the days. It earns a profit of 3d10 x 5 gp. ||

## Sowing Rumors

Swaying public opinion can be an effective way to bring down a villain or elevate a friend. Spreading rumors is an efficient, if underhanded, way to accomplish that goal. Well-placed rumors can increase the subject's standing in a community or embroil someone in scandal. A rumor needs to be simple, concrete, and hard to disprove. An effective rumor also has to be believable, playing off what people want to believe about the person in question.

Sowing a rumor about an individual or organization requires a number of days depending on the size of the community, as shown in the Sowing Rumors table. In a town or city, the time spent must be continuous. If the character spreads a rumor for ten days, disappears on an adventure for another few days and then returns, the rumor fades away without the benefit of constant repetition.

***Sowing Rumors***

||~ Settlement Size ||~ Time Required ||
|| Village || 2d6 days ||
|| Town || 4d6 days ||
|| City || 6d6 days ||

The character must spend 1 gp per day to cover the cost of drinks, social appearances, and the like. At the end of the time spent sowing the rumor, the character must make a DC 15 Charisma (Deception or Persuasion) check. If the check succeeds, the community's prevailing attitude toward the subject shifts one step toward friendly or hostile, as the character wishes. If the check fails, the rumor gains no traction, and further attempts to propagate it fail.

Shifting a community's general attitude toward a person or organization doesn't affect everyone in the community. Individuals might hold to their own opinions, particularly if they have personal experience in dealing with the subject of the rumors.

# Xanathar's Guide to Everything

*Source: Xanathar's Guide to Everything, p. 125*

Downtime activities are tasks that usually take a workweek (5 days) or longer to perform. These tasks can include buying or creating magic items, pulling off crimes, and working at a job. A character selects a downtime activity from among those available and pays the cost of that activity in time and money. You, as DM, then follow the rules for the activity to resolve it, informing the player of the results and any complications that ensue.

Consider handling downtime away from the game table. For example, you could have the players pick their downtime activities at the end of a session, and then communicate about them by email or text, until you next see them in person.

### Resolving Activities

The description of each activity tells you how to resolve it. Many activities require an ability check, so be sure to note the character's relevant ability modifiers. Follow the steps in the activity, and determine the results.

Most downtime activities require a workweek (5 days) to complete. Some activities require days, weeks (7 days), or months (30 days). A character must spend at least 8 hours of each day engaged in the downtime activity for that day to count toward the activity's completion.

The days of an activity don't need to be consecutive; you can spread them over a longer period of time than is required for the activity. But that period of time should be no more than twice as long as the required time; otherwise you should introduce extra complications (see below) and possibly double the activity's costs to represent the inefficiency of the character's progress.

### Complications

The description of each activity includes a discussion of complications you can throw at the characters. The consequences of a complication might spawn entire adventures, introduce NPCs to vex the party, or give the characters headaches or advantages in any number of other ways.

Each of these sections has a table that offers possible complications. You can roll to determine a complication randomly, pick one from the table, or devise one of your own, and then share it with the player.

## Example Downtime Activities

The following activities are suitable for any character who can afford to pursue them. As DM, you have the final say on which activities are available to the characters. The activities you allow might depend on the nature of the area where the characters are located. For example, you might disallow the creation of magic items or decide that the characters are in a town that is too isolated from major markets for them to buy such items.

[[div class="homebrew-note"]]

**Downtime Activities Summary Table**

||~ Activity ||~ Cost ||~ Summary ||
|| Arena Fighting || Free || Fight in the Gladiator Arena for fame and profit ||
|| Buying a Magic Item || 100 gp+ || Seek out magic items available for purchase ||
|| Carousing || 10 gp/50 gp/250 gp || Carouse with the lower/middle/upper class, possibly gaining new NPC contacts ||
|| Crafting an Item || 50 gp || Create a non-magical or magical item ||
|| Crime || 25 gp || Commit a crime, possibly making a profit ||
|| Gambling || 10 gp to 1,000 gp || Go gambling, possibly making a profit ||
|| Manage a Business (homebrew) || Free || Gain +10 to +30 to the roll for business profits ||
|| Relaxation || Free || Recover from a disease, poison, or other long-lasting effect ||
|| Religious Service || Free || Offer your time to a temple or other religious group, possibly earning favors ||
|| Renovate a Business (homebrew) || 5 gp || Gain up to +20 to the roll for business profits ||
|| Research || 50 gp+ || Learn information on a particular topic of interest ||
|| Scribing a Spell Scroll || 15 gp to 500 gp || Scribe a spell scroll using one of the spells you know ||
|| Selling a Magic Item || 25 gp || Seek out a buyer for a magic item you own ||
|| Training || 25 gp || Learn a new language, gain a new tool proficiency, or retrain a skill proficiency or feat ||
|| Work || Free || Make an honest living ||

**Note:** The below Downtime Activities have been altered from their format in the book to more easily provide a reference for both players and DMs. The reference text intended for players is in plain text. Any resolution details and possible complications the DM should be aware of are kept behind collapsed texts.

[[/div]]

### Arena Fighting

Arena fighting includes boxing, wrestling, and other nonlethal forms of combat in an organized setting with predetermined matches.

***Resources.*** Engaging in this activity requires one workweek of effort from a character.

***Resolution.*** The character must make a series of checks, with a DC determined at random based on the quality of the opposition that the character runs into. A big part of the challenge in arena fighting lies in the unknown nature of a character's opponents.

The character makes three checks: Strength (Athletics), Dexterity (Acrobatics), and a special Constitution check that has a bonus equal to a roll of the character's largest Hit Die (this roll doesn't spend that die). If desired, the character can replace one of these skill checks with an attack roll using one of the character's weapons. The DC for each of the checks is determined by the DM. Consult the Arena Fighting Results table to see how the character did.

||~ Result ||~ Value ||
|| 0 successes || Lose your bouts, earning nothing. ||
|| 1 success || Win 50 gp. ||
|| 2 successes || Win 100 gp. ||
|| 3 successes || Win 200 gp. ||

[[gm_notes Arena Fighting]]

### Buying a Magic Item

Purchasing a magic item requires time and money to seek out and contact people willing to sell items. Even then, there is no guarantee a seller will have the items a character desires.

***Resources.*** Finding magic items to purchase requires at least one workweek of effort and 100 gp in expenses, if you are seeking items of rarity Uncommon or above. Spending more time and money increases your chance of finding a high-quality item.

***Resolution.*** A character seeking to buy a magic item makes a Charisma (Persuasion) or Intelligence (Investigation) check to determine the quality of the seller found. The character gains a +1 bonus on the check for every workweek beyond the first that is spent seeking a seller and a +1 bonus for every additional 100 gp spent on the search, up to a maximum bonus of +10. The monetary cost includes a wealthy lifestyle, for a buyer must impress potential business partners.

The total of the check dictates what magic items are likely to be found, with a higher check resulting in more valuable (i.e. expensive) items. If a character is looking for a more specific value of magic item, the DM will adjust the results to match, assuming the character rolls high enough.

If the character seeks a specific magic item, the desired item may be included among the items for sale on a check total of 10 or higher if the item is common, 15 or higher if it is uncommon, 20 or higher if it is rare, 25 or higher if it is very rare, and 30 or higher if it is legendary.

[[gm_notes Buying a Magic Item]]

### Carousing

Carousing is a default downtime activity for many characters. Between adventures, who doesn't want to relax with a few drinks and a group of friends at a tavern?

***Resources.*** Carousing covers a workweek of fine food, strong drink, and socializing. A character can attempt to carouse among lower-, middle-, or upper-class folk. A character can carouse with the lower class for 10 gp to cover expenses, or 50 gp for the middle class. Carousing with the upper class requires 250 gp for the workweek and access to the local nobility.

A character with the noble background can mingle with the upper class, but other characters can do so only if the character has made sufficient contacts. Alternatively, a character might use a disguise kit and the Deception skill to pass as a noble visiting from a distant city.

***Resolution.*** After a workweek of carousing, a character stands to make contacts within the selected social class. The character makes a Charisma (Persuasion) check using the Carousing table.

**Carousing**

||~ Check Total ||~ Result ||
|| 1-5 || Character has made a hostile contact. ||
|| 6-10 || Character has made no new contacts. ||
|| 11-15 || Character has made an allied contact. ||
|| 16-20 || Character has made two allied contacts. ||
|| 21+ || Character has made three allied contacts. ||

Contacts are NPCs who now share a bond with the character. Each one either owes the character a favor or has some reason to bear a grudge. A hostile contact works against the character, placing obstacles but stopping short of committing a crime or a violent act. Allied contacts are friends who will render aid to the character, but not at the risk of their lives.

Lower-class contacts include criminals, laborers, mercenaries, the town guard, and any other folk who normally frequent the cheapest taverns in town.

Middle-class contacts include guild members, spellcasters, town officials, and other folk who frequent well-kept establishments.

Upper-class contacts are nobles and their personal servants. Carousing with such folk covers formal banquets, state dinners, and the like.

Once a contact has helped or hindered a character, the character needs to carouse again to get back into the NPC's good graces. A contact provides help once, not help for life. The contact remains friendly, but doesn't come with a guarantee of help.

Alternatively, you can make an NPC into a contact on the spot, after carousing. When the characters are in the area in which they caroused, a player can expend an allied contact and designate an NPC they meet as a contact, assuming the NPC is of the correct social class based on how the character caroused. The player should provide a reasonable explanation for this relationship and work it into the game, and the DM is the final arbiter if this explanation is sufficient.

At any time, a character can have a maximum number of unspecified allied contacts equal to 1 + the character's Charisma modifier (minimum of 1).

[[gm_notes Carousing]]

### Crafting an Item

A character who has the time, the money, and the needed tools can use downtime to craft armor, weapons, clothing, or other kinds of nonmagical gear.

***Resources and Resolution.*** In addition to the appropriate tools for the item to be crafted, a character needs raw materials worth half of the item's selling cost. To determine how many workweeks it takes to create an item, divide its gold piece cost by 50. A character can complete multiple items in a workweek if the items' combined cost is 50 gp or lower. Items that cost more than 50 gp can be completed over longer periods of time, as long as the work in progress is stored in a safe location.

Multiple characters can combine their efforts. Divide the time needed to create an item by the number of characters working on it. The DM determines how many characters can collaborate on an item. A particularly tiny item, like a ring, might allow only one or two workers, whereas a large, complex item might allow four or more workers. NPC hirelings can help with the crafting, but more skilled NPCs will require more expensive wages.

A character needs to be proficient with the tools needed to craft an item and have access to the appropriate equipment. Everyone who collaborates needs to have the appropriate tool proficiency.

||~ Proficiency ||~ Items ||
|| Herbalism kit || Antitoxin, potion of healing ||
|| Leatherworker's tools || Leather armor, boots ||
|| Smith's tools || Armor, weapons ||
|| Weaver's tools || Cloaks, robes ||

If all the above requirements are met, the result of the process is an item of the desired sort. A character can sell an item crafted in this way at its listed price.

***Crafting Magic Items.*** Creating a magic item requires more than just time, effort, and materials. It is a long-term process that involves one or more adventures to track down rare materials and the lore needed to create the item.

_Potions of healing_ and _spell scrolls_ are exceptions to the following rules. For more information, see "Brewing Potions of Healing" later in this section and the "Scribing a Spell Scroll" activity.

To start with, a character needs a formula for a magic item in order to create it. The formula is like a recipe. It lists the materials needed and steps required to make the item.

A magic item invariably requires an exotic material to complete it. This material can range from the skin of a yeti to a vial of water taken from a whirlpool on the Elemental Plane of Water. Finding that material will involve a side quest, or may come up as part of the normal adventure.

In addition to requiring an exotic material, creating an item comes with a gold piece cost covering other materials, tools, and so on, based on the item's rarity. Those values, as well as the time a character needs to work in order to complete the item, are shown on the Magic Item Crafting Time and Cost table. Halve the listed price and creation time for any consumable items.

**Magic Item Crafting Time and Cost**

||~ Item Rarity ||~ Workweeks* ||~ Cost* ||
|| Common || 1 || 50 gp ||
|| Uncommon || 2 || 200 gp ||
|| Rare || 10 || 2,000 gp ||
|| Very rare || 25 || 20,000 gp ||
|| Legendary || 50 || 100,000 gp ||

\*Halved for a consumable item like a potion or scroll

To complete a magic item, a character also needs whatever tool proficiency is appropriate, as for crafting a nonmagical object, or proficiency in the Arcana skill.

If all the above requirements are met, the result of the process is a magic item of the desired sort.

***Brewing Potions of Healing.*** Potions of healing fall into a special category for item crafting, separate from other magic items. A character who has proficiency with the herbalism kit can create these potions. The times and costs for doing so are summarized on the following table.

||~ Type ||~ Amount Healed ||~ Time ||~ Cost ||
|| Healing || 2d4 + 2 || 1 day || 25 gp ||
|| Greater healing || 4d4 + 4 || 1 workweek || 100 gp ||
|| Superior healing || 8d4 + 8 || 3 workweeks || 1,000 gp ||
|| Supreme healing || 10d4 + 20 || 4 workweeks || 10,000 gp ||

[[gm_notes Crafting an Item]]

### Crime

Sometimes it pays to be bad. This activity gives a character the chance to make some extra cash, at the risk of arrest.

***Resources.*** A character must spend one week and at least 25 gp gathering information on potential targets before committing the intended crime.

***Resolution.*** The character must make a series of checks, with the DC for all the checks chosen by the character according to the amount of profit sought from the crime.

The chosen DC can be 10, 15, 20, or 25. Successful completion of the crime yields a number of gold pieces, as shown on the Loot Value table.

**Loot Value**

||~ DC ||~ Value ||
|| 10 || 50 gp, robbery of a struggling merchant ||
|| 15 || 100 gp, robbery of a prosperous merchant ||
|| 20 || 200 gp, robbery of a noble ||
|| 25 || 1,000 gp, robbery of one of the richest figures in town ||

To attempt a crime, the character makes three checks: Dexterity (Stealth), Dexterity using thieves' tools, and the player's choice of Intelligence (Investigation), Wisdom (Perception), or Charisma (Deception).

If none of the checks are successful, the character is caught and jailed. The character's punishment is subject to the laws of the location the crime was committed in, or whoever ended up arresting the character, subject to DM discretion.

If only one check is successful, the heist fails but the character escapes.

If two checks are successful, the heist is a partial success, netting the character half the payout.

If all three checks are successful, the character earns the full value of the loot.

[[gm_notes Crime]]

### Gambling

Games of chance are a way to make a fortune -- and perhaps a better way to lose one.

***Resources.*** This activity requires one workweek of effort plus a stake of at least 10 gp, to a maximum of 1,000 gp. Higher stakes may be acceptable in exceptional cases.

***Resolution.*** The character must make a series of checks, with a DC determined at random based on the quality of the competition that the character runs into. Part of the risk of gambling is that one never knows who might end up sitting across the table.

The character makes three checks: Wisdom (Insight), Charisma (Deception), and Charisma (Intimidation). If the character has proficiency with an appropriate gaming set, that tool proficiency can replace the relevant skill in any of the checks. The DM will determine the DC for each of the checks. Consult the following table to see how the character did.

The business gains +10 to its roll for determining its profits if at least one character spends their downtime managing it. For every consecutive workweek spent managing the business, gain an extra +10, up to a maximum of +30. Multiple characters managing the business at once do not provide extra bonuses.

[[gm_notes Managing a Business]]

### Relaxation

Sometimes the best thing to do between adventures is relax. Whether a character wants a hard-earned vacation or needs to recover from injuries, relaxation is the ideal option for adventurers who need a break. This option is also ideal for players who don't want to make use of the downtime system.

***Resources.*** Relaxation requires one week. A character needs to maintain at least a modest lifestyle while relaxing to gain the benefit of the activity.

***Resolution.*** Characters who maintain at least a modest lifestyle while relaxing gain several benefits. While relaxing, a character gains advantage on saving throws to recover from long-acting diseases and poisons. In addition, at the end of the week, a character can end one effect that keeps the character from regaining hit points, or can restore one ability score that has been reduced to less than its normal value. This benefit cannot be used if the harmful effect was caused by a spell or some other magical effect with an ongoing duration.

[[gm_notes Relaxation]]

### Religious Service

Characters with a religious bent might want to spend downtime in ser vice to a temple, either by attending rites or by proselytizing in the community. Someone who undertakes this activity has a chance of winning the favor of the temple's leaders.

***Resources.*** Performing religious service requires access to, and often attendance at, a temple whose beliefs and ethos align with the character's. If such a place is available, the activity takes one workweek of time but involves no gold piece expenditure.

***Resolution.*** At the end of the required time, the character chooses to make either an Wisdom (Religion) check or a Charisma (Persuasion) check. The total of the check determines the benefits of service, as shown on the following table.

||~ Check Total ||~ Result ||
|| 1-10 || No effect. Your efforts fail to make a lasting impression. ||
|| 11-20 || You earn one favor. ||
|| 21+ || You earn two favors. ||

A favor, in broad terms, is a promise of future assistance from a representative of the temple. It can be expended to ask the temple for help in dealing with a specific problem, for general political or social support, or to reduce the cost of cleric spellcasting by 50 percent. A favor could also take the form of a deity's intervention, such as an omen, a vision, or a minor miracle provided at a key moment. This latter sort of favor is expended by the DM, who also determines its nature.

Favors earned need not be expended immediately, but only a certain number can be stored up. A character can have a maximum number of unused favors equal to 1 + the character's Charisma modifier (minimum of one unused favor).

[[gm_notes Religious Service]]

### Renovating a Business (homebrew)

When running a business, it's important to keep on top of maintenance, and even moreso to work to update and improve your business to keep your customers' interest. Renovations can consist of planting a garden, fixing holes in the wall, replacing wallpaper, or even adding a disco dance area to the attic.

***Resources.*** Regardless of what the renovation entails, it always requires 5 gp in materials or hired labor per workweek spent. Some types of renovation may require multiple weeks of work to complete.

***Resolution.*** The character decides what kind of renovation they're performing. At the end of the workweek, the character makes an appropriate ability check, plus any skill or tool proficiencies that can apply. Consult the Renovation Result table to determine what bonus is gained on the business's roll for determining its profits for that week.

**Renovation Result**

||~ Check ||~ Result ||
|| 9 or lower || The renovations are botched and need to be redone. No bonus. ||
|| 10-14 || +5 ||
|| 15-20 || +10 ||
|| 21+ || +20 ||

If renovations are left uncompleted, the business suffers a -10 penalty for every week thereafter until the renovations are complete. Multiple characters can work on renovations for the business at once, and their bonuses stack.

[[gm_notes Renovating a Business]]

### Research

Forewarned is forearmed. The research downtime activity allows a character to delve into lore concerning a monster, a location, a magic item, or some other particular topic.

***Resources.*** Typically, a character needs access to a library or a sage to conduct research. Assuming such access is available, conducting research requires one workweek of effort and at least 50 gp spent on materials, bribes, gifts, and other expenses.

***Resolution.*** The character declares the focus of the research -- a specific person, place, or thing. After one workweek, the character makes an Intelligence check with a +1 bonus per 50 gp spent beyond the initial 50 gp, to a maximum of +6. In addition, a character who has access to a particularly well-stocked library or knowledgeable sages gains advantage on this check. Determine how much lore a character learns using the following table.

||~ Check Total ||~ Outcome ||
|| 1-5 || No effect. ||
|| 6-10 || You learn one piece of lore. ||
|| 11-20 || You learn two pieces of lore. ||
|| 21+ || You learn three pieces of lore! ||

Each piece of lore is the equivalent of one true statement about a person, place, or thing. Examples include knowledge of a creature's resistances, the password needed to enter a sealed dungeon level, the spells commonly prepared by an order of wizards, and so on.

[[gm_notes Research]]

### Scribing a Spell Scroll

With time and patience, a spellcaster can transfer a spell to a scroll, creating a _spell scroll_.

***Resources.*** Scribing a _spell scroll_ takes an amount of time and money related to the level of the spell the character wants to scribe, as shown in the Spell Scroll Costs table. In addition, the character must have proficiency in the Arcana skill and must provide any material components required for the casting of the spell. Moreover, the character must have the spell prepared, or it must be among the character's known spells, in order to scribe a scroll of that spell.

If the scribed spell is a cantrip, the version on the scroll works as if the caster were 1st level.

**Spell Scroll Costs**

||~ Spell Level ||~ Time ||~ Cost ||
|| Cantrip || 1 day || 15 gp ||
|| 1st || 1 day || 25 gp ||
|| 2nd || 3 days || 250 gp ||
|| 3rd || 1 workweek || 500 gp ||
|| 4th || 2 workweeks || 2,500 gp ||
|| 5th || 4 workweeks || 5,000 gp ||
|| 6th || 8 workweeks || 15,000 gp ||
|| 7th || 16 workweeks || 25,000 gp ||
|| 8th || 32 workweeks || 50,000 gp ||
|| 9th || 48 workweeks || 250,000 gp ||

[[gm_notes Scribing a Spell Scroll]]

### Selling a Magic Item

Selling a magic item is by no means an easy task. Con artists and thieves are always looking out for an easy score, and there's no guarantee that a character will receive a good offer even if a legitimate buyer is found.

***Resources.*** A character can find a buyer for one magic item by spending one week and 25 gp, which is used to spread word of the desired sale. A character must pick one item at a time to sell.

***Resolution.*** A character who wants to sell an item must make a Charisma (Persuasion) check to determine what kind of offer comes in. The character can always opt not to sell, instead forfeiting the week of effort and trying again later. Use Magic Item Base Prices table to determine the base sale price (halved for consumable items). The result of your check will determine whether a buyer is willing to pay above or below the base sale price.

||~ Rarity ||~ Base Price\* ||
|| Common || 100 gp ||
|| Uncommon || 400 gp ||
|| Rare || 4,000 gp ||
|| Very rare || 40,000 gp ||
|| Legendary || 200,000 gp ||

\*Halved for a consumable item like a potion or scroll

[[gm_notes Selling a Magic Item]]

### Training

Given enough free time and the services of an instructor, a character can learn a language, pick up proficiency with a tool, or retrain an existing skill proficiency to another skill proficiency.

***Resources.*** Receiving training in a language or tool typically takes at least ten workweeks, but this time is reduced by a number of workweeks equal to the character's Intelligence modifier (an Intelligence penalty doesn't increase the time needed). Training costs 25 gp per workweek.

If the character is retraining a skill and has chosen an Expertise in that skill proficiency, they can choose to change that Expertise to match the new skill they're retraining into.

[[gm_notes Training]]

### Work

When all else fails, an adventurer can turn to an honest trade to earn a living. This activity represents a character's attempt to find temporary work, the quality and wages of which are difficult to predict.

***Resources.*** Performing a job requires one workweek of effort.

***Resolution.*** To determine how much money a character earns, the character makes an ability check: Strength (Athletics), Dexterity (Acrobatics), Intelligence using a set of tools, Charisma (Performance), or Charisma using a musical instrument. Consult the following table to see how much money is generated according to the total of the check.

||~ Check Total ||~ Earnings ||
|| 9 or lower || Poor lifestyle for the week ||
|| 10-14 || Modest lifestyle for the week ||
|| 15-20 || Comfortable lifestyle for the week ||
|| 21+ || Comfortable lifestyle for the week + 25 gp ||

[[gm_notes Work]]


text:
# Stanhughesia Constant. GENUS

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Constantinescu, Holm & Holm, Stud. Mycol. 31: 71 (1989)

#### Original name
Stanhughesia Constant.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
[![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg?style=flat-square)](https://saythanks.io/to/DanielAndreasen)

[![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)

[![Build Status](https://travis-ci.org/DanielAndreasen/SWEETer-Cat.svg?branch=master)](https://travis-ci.org/DanielAndreasen/SWEETer-Cat)

[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/da52b2a1511a4226a810d82a3fcee346)](https://www.codacy.com/app/daniel.andreasen/SWEETer-Cat?utm_source=github.com&utm_medium=referral&utm_content=DanielAndreasen/SWEETer-Cat&utm_campaign=Badge_Coverage)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/da52b2a1511a4226a810d82a3fcee346)](https://www.codacy.com/app/daniel.andreasen/SWEETer-Cat?utm_source=github.com&utm_medium=referral&utm_content=DanielAndreasen/SWEETer-Cat&utm_campaign=Badge_Grade)
[![Coverage Status](https://coveralls.io/repos/github/DanielAndreasen/SWEETer-Cat/badge.svg?branch=master)](https://coveralls.io/github/DanielAndreasen/SWEETer-Cat?branch=master)

[![Updates](https://pyup.io/repos/github/DanielAndreasen/SWEETer-Cat/shield.svg)](https://pyup.io/repos/github/DanielAndreasen/SWEETer-Cat/)
[![Python 3](https://pyup.io/repos/github/DanielAndreasen/SWEETer-Cat/python-3-shield.svg)](https://pyup.io/repos/github/DanielAndreasen/SWEETer-Cat/)

[![Known Vulnerabilities](https://snyk.io/test/github/danielandreasen/sweeter-cat/badge.svg?style=flat-square)](https://snyk.io/test/github/danielandreasen/sweeter-cat)

# SWEETer-Cat
Make [SWEET-Cat](https://www.astro.up.pt/resources/sweet-cat/) sweet again

This is an effort to modernise and update SWEET-Cat with plotting capabilities.

## Installation

Install and use this tool

    git clone https://github.com/DanielAndreasen/SWEETer-Cat
    cd SWEETer-Cat
    pip install -r requirements.txt
    cd sweetercat
    export SC_secret=<random chars>
    python app.py

Open up http://<IP_ADDRESS>:5000/ in your browser.

repository: sourcery-ai-bot/SWEETer-Cat

repo_name: sourcery-ai-bot/SWEETer-Cat


text:
{% unless include.minimal == false %}
For a minimal configuration, add the following to your `.travis.yml`:

```yaml
deploy:
  provider: gae
  project: <project>
  edge: true # opt in to dpl v2
```
{: data-file=".travis.yml"}

{{ include.content }}
{% endunless %}

## Status

Support for deployments to Google App Engine is in **beta**. Please see [Maturity Levels](/user/deployment-v2#maturity-levels) for details.
## Known options

Use the following options to further configure the deployment.

| `project` | Project ID used to identify the project on Google Cloud — **required**, type: string |
| `keyfile` | Path to the JSON file containing your Service Account credentials in JSON Web Token format. To be obtained via the Google Developers Console. Should be handled with care as it contains authorization keys. — type: string, default: `service-account.json` |
| `config` | Path to your service configuration file — type: string or array of strings, default: `app.yaml` |
| `version` | The version of the app that will be created or replaced by this deployment. If you do not specify a version, one will be generated for you — type: string |
| `verbosity` | Adjust the log verbosity — type: string, default: `warning` |
| `promote` | Whether to promote the deployed version — type: boolean, default: `true` |
| `stop_previous_version` | Prevent the deployment from stopping a previously promoted version — type: boolean, default: `true` |
| `install_sdk` | Whether to install the Google Cloud SDK — type: boolean, default: `true` |

### Shared options

| `cleanup` | Clean up build artifacts from the Git working directory before the deployment — type: boolean |
| `run` | Commands to execute after the deployment finished successfully — type: string or array of strings |

gha_language: CSS


text:
## Docstring inheritance decorator
Originally published: 2009-07-28 13:42:32
Last updated: 2009-07-28 13:42:32
Author: Shai Berger

In many cases, a subclass overrides a method in a parent class, just to change its implementation; in such cases, it would be nice to preserve the overridden method's docstring. The decorator below can be used to achieve this without explicit reference to the parent class. It does this by replacing the function with a descriptor, which accesses the parent class when the method is accessed as an attribute.

gha_language: Python


text:
---
name: Issue report
about: Something doesn't work correctly.
title: ''
labels: ''
assignees: ''

---

**Describe the issue**
A clear and concise description of what the issue is.

**To Reproduce**
Include a detailed step by step process for recreating your issue.

**Expected behavior**
A clear and concise description of what you expected to happen.

**Log**
Include the log by creating a [gist](https://gist.github.com/) with the content of the file created by `--log={...}` (or the terminal output if you only used `--log`) and pasting the link here.

**Additional context**
Add any other context about the problem here.
- What build are you using / what release version?
- What system-version were you updating from/to?

license: ISC

repository: switchbrew/contents-delivery-manager

repo_name: switchbrew/contents-delivery-manager


text:
---
layout: single-card
title: Kudo wall
image: /craft-challenges/assets/images/practices/kudo-wall.png
category: practices
description: Some companies call them HERO awards, others Rippas or Hugs, in Management 3.0 it is called Kudos. Kudo means Thank you in japanese.
---

## What ?
Some companies call them HERO awards, others Rippas or Hugs, in Management 3.0 it is called Kudos.
Kudo means "Thank you" in japanese.
A kudo card is a written and public recognition of a colleague for something he/she has contributed to the team.
`A Kudo is not just given from the top down, but peer-to-peer and bottom-up.` Across departments and organizations, anyone can recognize someone else’s work.
**It’s a way to break down hierarchical limitations and to encourage everyone to offer instant positive feedback.**

> Kudo Cards are small gestures of gratitude.

## Why ?
This tool has a lot of benefits amongst them :
* It promotes engagement
    * Praise gives people pleasure and encourages them to engage with management
    * Increases the chances that employees will share new ideas and point out problem areas in the business
* Boost Performance
* It encourages wanted behaviors
    * Encourages behaviors that each employees wants to see repeated

## How ?
* Print [Kudo cards](https://1qjpt15fhlq3xjfpm2utibj1-wpengine.netdna-ssl.com/wp-content/uploads/2018/02/Management30-KudoCards-2017-self-print-A4.pdf)
* Create space on a wall
* Name it Kudo wall
* Invite people to offer each other tokens of appreciation by putting them on this wall

![Kudo wall]({{ site.baseurl }}/assets/images/kudo-wall-sample.jpg)

## Resources
* [Management 3.0 - Kudo cards](https://management30.com/product/kudo-cards/)
* [Appreciation cards, Kudo wall And Kudo box](http://www.plays-in-business.com/appreciation-cards-kudo-wall-and-kudo-box/)
* [Managing for happinness book](https://www.amazon.com/Managing-Happiness-Games-Practices-Motivate/dp/1119268680/ref=sr_1_1?ie=UTF8&qid=1534415261&sr=8-1&keywords=managing+for+happiness)

repository: stephanhuez/craft-challenges

repo_name: stephanhuez/craft-challenges