text:
# PDM Plugins

PDM is aiming at being a community driven package manager.
It is shipped with a full-featured plug-in system, with which you can:

- Develop a new command for PDM
- Add additional options to existing PDM commands
- Change PDM's behavior by reading additional config items
- Control the process of dependency resolution or installation

## What should a plugin do

The core PDM project focuses on dependency management and package publishing. Other
functionalities you wish to integrate with PDM are preferred to lie in their own plugins
and released as standalone PyPI projects. In case the plugin is considered a good supplement
of the core project it may have a chance to be absorbed into PDM.

## Write your own plugin

In the following sections, I will show an example of adding a new command `hello` which reads the `hello.name` config.

### Write the command

The PDM's CLI module is designed in a way that user can easily "inherit and modify". To write a new command:

```python
from pdm.cli.commands.base import BaseCommand

class HelloCommand(BaseCommand):
    """Say hello to the specified person.
    If none is given, will read from "hello.name" config.
    """

    def add_arguments(self, parser):
        parser.add_argument("-n", "--name", help="the person's name to whom you greet")

    def handle(self, project, options):
        if not options.name:
            name = project.config["hello.name"]
        else:
            name = options.name
        print(f"Hello, {name}")
```

First, let's create a new `HelloCommand` class inheriting from `pdm.cli.commands.base.BaseCommand`. It has two major functions:

- `add_arguments()` to manipulate the argument parser passed as the only argument,
  where you can add additional command line arguments to it
- `handle()` to do something when the subcommand is matched, you can do nothing by writing a single `pass` statement.
  It accepts two arguments: an `pdm.project.Project` object as the first one and the parsed `argparse.Namespace` object as the second.

The document string will serve as the command help text, which will be shown in `pdm --help`.

Besides, PDM's subcommand has two default options: `-v/--verbose` to change the verbosity level and `-g/--global` to enable global project.
If you don't want these default options, override the `arguments` class attribute to a list of `pdm.cli.options.Option` objects, or
assign it to an empty list to have no default options:

```python hl_lines="3"
class HelloCommand(BaseCommand):

    arguments = []
```

!!! note
    The default options are loaded first, then `add_arguments()` is called.

### Register the command to the core object

Write a function somewhere in your plugin project. There is no limit on what the name of the function is,
but the function should take only one argument -- the PDM core object:

```python hl_lines="2"
def hello_plugin(core):
    core.register_command(HelloCommand, "hello")
```

Call `core.register_command()` to register the command. The second argument as the name of the subcommand is optional.
PDM will look for the `HelloCommand`'s `name` attribute if the name is not passed.

### Add a new config item

Let's recall the first code snippet, `hello.name` config key is consulted for the name if not passed via the command line.

```python hl_lines="11"
class HelloCommand(BaseCommand):
    """Say hello to the specified person.
    If none is given, will read from "hello.name" config.
    """

    def add_arguments(self, parser):
        parser.add_argument("-n", "--name", help="the person's name to whom you greet")

    def handle(self, project, options):
        if not options.name:
            name = project.config["hello.name"]
        else:
            name = options.name
        print(f"Hello, {name}")
```

Till now, if you query the config value by `pdm config get hello.name`, an error will pop up saying it is not a valid config key.
You need to register the config item, too:

```python hl_lines="5"
from pdm.project.config import ConfigItem

def hello_plugin(core):
    core.register_command(HelloCommand, "hello")
    core.add_config("hello.name", ConfigItem("The person's name", "John"))
```

where `ConfigItem` class takes 4 parameters, in the following order:

- `description`: a description of the config item
- `default`: default value of the config item
- `global_only`: whether the config is allowed to set in home config only
- `env_var`: the name of environment variable which will be read as the config value

### Other plugin points

Besides of commands and configurations, the `core` object exposes some other methods and attributes to override.
PDM also provides some signals you can listen to.
Please read the [API reference](../reference/api.md) for more details.

### Tips about developing a PDM plugin

When developing a plugin, one hopes to activate and plugin in development and get updated when the code changes.

You can achieve this by installing the plugin in editable mode. To do this, specify the dependencies in `tool.pdm.plugins` array:

```toml
[tool.pdm]
plugins = [
    "-e file:///${PROJECT_ROOT}"
]
```

Then install it with:

```bash
pdm install --plugins
```

After that, all the dependencies are available in a project plugin library, including the plugin itself, in editable mode. That means any change
to the codebase will take effect immediately without re-installation. The `pdm` executable also uses a Python interpreter under the hood,
so if you run `pdm` from inside the plugin project, the plugin in development will be activated automatically, and you can do some testing to see how it works.

### Testing your plugin

PDM exposes some pytest fixtures as a plugin in the [`pdm.pytest`](fixtures.md) module.
To benefit from them, you must add `pdm[pytest]` as a test dependency.

To enable them in your test, add `pdm.pytest` as a plugin. You can do so by in your root `conftest.py`:

```python title="conftest.py"
# single plugin
pytest_plugins = "pytest.plugin"

# many plugins
pytest_plugins = [
    ...
    "pdm.pytest",
    ...
]
```

You can see some usage examples into PDM own [tests](https://github.com/pdm-project/pdm/tree/main/tests), especially the [conftest.py file](https://github.com/pdm-project/pdm/blob/main/tests/conftest.py) for configuration.

See the [pytest fixtures documentation](fixtures.md) for more details.

## Publish your plugin

Now you have defined your plugin already, let's distribute it to PyPI. PDM's plugins are discovered by entry point types.
Create an `pdm` entry point and point to your plugin callable (yeah, it doesn't need to be a function, any callable object can work):

**PEP 621**:

```toml
# pyproject.toml

[project.entry-points.pdm]
hello = "my_plugin:hello_plugin"
```

**setuptools**:

```python
# setup.py

setup(
    ...
    entry_points={"pdm": ["hello = my_plugin:hello_plugin"]}
    ...
)
```

## Activate the plugin

As plugins are loaded via entry points, they can be activated with no more steps than just installing the plugin.
For convenience, PDM provides a `plugin` command group to manage plugins.

Assume your plugin is published as `pdm-hello`:

```bash
pdm self add pdm-hello
```

Now type `pdm --help` in the terminal, you will see the new added `hello` command and use it:

```bash
$ pdm hello Jack
Hello, Jack
```

See more plugin management subcommands by typing `pdm self --help` in the terminal.

## Specify the plugins in project

To specify the required plugins for a project, you can use the `tool.pdm.plugins` config in the `pyproject.toml` file.
These dependencies can be installed into a project plugin library by running `pdm install --plugins`.
The project plugin library will be loaded in subsequent PDM commands.

This is useful when you want to share the same plugin set with the contributors.

```toml
# pyproject.toml
[tool.pdm]
plugins = [
    "pdm-packer"
]
```

Run `pdm install --plugins` to install and activate the plugins.

Alternatively, you can have project-local plugins that are not published to PyPI, by using editable local dependencies:

```toml
# pyproject.toml
[tool.pdm]
plugins = [
    "-e file:///${PROJECT_ROOT}/plugins/my_plugin"
]
```

repository: pdm-project/pdm

repo_name: pdm-project/pdm


text:
=======
PhotoShoter
===========

Application for sending photo to users on map. Server for this application: https://github.com/yoman07/geo-server

Contributors
-------

- [Bartłomiej Gołuszka aka `bbaloo`](https://github.com/bbaloo)
- [Roman Barzyczak aka `yoman07`](https://github.com/yoman07)

Events
-------

####Getting images

For getting images you need subscribe to Bus with method: `public  void onEvent(ImageEvent imageEvent)` , `imageEvent` contain method `getLocation()` - positon where image was made, `getBase64image()` - base64 image, you can convert it by using `ImageHelper.bitmapFromBase64Format(base64String)`, `getSenderId` - method for get user id, who made a photo.

Example:
```
public  void onEvent(ImageEvent imageEvent) {
        Log.i(TAG, "Got imageEvent with data" + imageEvent.toString());
        Bitmap bitmap = ImageHelper.bitmapFromBase64Format(imageEvent.getBase64image());
        Log.i(TAG, "Bitmap " + bitmap.toString());
    }
```

####Sending images

You can sending image to specific user by post event `MyImageEvent` which containt `base64image` - image in base64 format ( you can convert bitmap to base64 by using `ImageHelper.base64FormatFromBitmap(bm)` ), `receiverId` - user who should receive image

```
    private void sendImageEvent(Bitmap bm, Location location, String receiverId) {
            MyImageEvent imageEvent = new MyImageEvent(ImageHelper.base64FormatFromBitmap(bm),location, receiverId);
            EventBus.getDefault().post(imageEvent);
    }
```

License
-------

Copyright (c) 2014 Roman Barzyczak & Bartłomiej Gołuszka

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.

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Java

license_type: permissive


text:
# Change Log

Team membership:  Teresa (Captain) & Jayden (Mate)
Team conventions: Allman notation, markdown for changelog
Changelog format: [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)

## *Version 1.0.1*

### 2017-09-23. (Teresa)
- Added merged develop branch with team repo.

## *Version 1.0.0*

### 2017-09-22. (Jayden)
- Improvement on templates
  - generate content for images using a table cell template.

### 2017-09-22. (Teresa)
- Updated Base Controller
- Updated 4 views:
  - template.php
  - about.php
  - welcome.php
  - gallery.php

### 2017-09-21. (Jayden)
- Added two pages:
  - About
  - Gallery
- Added CodeIgniter framework to the project.
- This is our initial additional to our changelog.

repository: Rainbow-Sprinkles/rainbow-gallery

branch_name: refs/heads/develop

repo_name: Rainbow-Sprinkles/rainbow-gallery


text:
# Unity Skeleton Visualizer

## Description

A simple unity package that will allow you to visualize Skeleton json data within Unity.

## How-To

First, copy the rig2cs folder from riggingtools repo into your unity project.

Example: Scripts/rig2cs

Then:

Add the git URL to your unity project by going to Window > Package Manager > Click + > Add package from git URL > Paste URL

OR

Pull repo and point to the package.json by going to Window > Package Manager > Click + > Add package from file > navigate to package.json

## Additional Information

Create a StreamingAssets folder in the root of the Assets folder. Place all or any of your skeleton.json files within that folder and then update the file name in the PluginLoader.cs script within the inspector.

Check Packages/Skeleton Loader/Runtime/Scenes/SampleScene_SkeletonPlayer for demo setup.

EXPERIMENTAL_SkeletonPlayerEditor is experimental. Still needs work, but allows you to preview and manipulate the skeletons using Unity's Timeline window within the Editor.

repository: intel/riggingtools

gha_license_id: MIT

repo_name: intel/riggingtools


text:
### [1027\. Longest Arithmetic Sequence](https://leetcode.com/problems/longest-arithmetic-sequence/)

Difficulty: **Medium**

Given an array `A` of integers, return the **length** of the longest arithmetic subsequence in `A`.

Recall that a _subsequence_ of `A` is a list `A[i_1], A[i_2], ..., A[i_k]` with `0 <= i_1 < i_2 < ... < i_k <= A.length - 1`, and that a sequence `B` is _arithmetic_ if `B[i+1] - B[i]` are all the same value (for `0 <= i < B.length - 1`).

**Example 1:**

```
Input: [3,6,9,12]
Output: 4
Explanation:
The whole array is an arithmetic sequence with steps of length = 3.
```

**Example 2:**

```
Input: [9,4,7,2,10]
Output: 3
Explanation:
The longest arithmetic subsequence is [4,7,10].
```

**Example 3:**

```
Input: [20,1,15,3,10,5,8]
Output: 4
Explanation:
The longest arithmetic subsequence is [20,15,10,5].
```

**Note:**

1.  `2 <= A.length <= 2000`
2.  `0 <= A[i] <= 10000`

#### Solution

Language: **JavaScript**

```javascript
/**
 * @param {number[]} A
 * @return {number}
 */
var longestArithSeqLength = function(A) {
    const dp = Array(A.length).fill()
        .map(() => ({}))

    let result = 0
    for (let i = 0; i < A.length; i += 1) {
        for (let j = 0; j < i; j += 1) {
            const diff = A[i] - A[j]
            dp[i][diff] = (dp[j][diff] || 1) + 1
            result = Math.max(result, dp[i][diff])
        }
    }

    return result
};
```


text:
# Contributing to WHMCS-Slack

🎉 Thanks for taking the time to contribute! 🎉

To lay out some guidelines and rules on how to contribute I decided to write this page.
I want to make it as easy as possible to contribute while still keeping the code in a
good state.

- Please submit bug reports with a clear and descriptive title along with a detailed
description on how the problem can be reproduced.

- Ideas, check if there are any existing issues with the same idea first and if there
are none, simply open a new issue with a detailed description of the idea you have.

- Adding or fixing code, please fork this repository and do a pull request. I will do my
best to review the pull request within a few days. Please add a clear description of what
the code should do or fix.

All code contributed falls under the MIT license. If you have any questions feel free to contact me.


text:
# react-flaxs

[![Build Status](https://travis-ci.org/jcperez-ch/react-flaxs.svg?branch=master)](https://travis-ci.org/jcperez-ch/react-flaxs)
[![npm version](https://img.shields.io/npm/v/react-flaxs.svg?style=flat-square)](https://www.npmjs.com/package/react-flaxs)

Connect Flaxs implementation with your React application.

### Connect Decorator

Simple way to connect to the master store in flaxs using a decorator pattern:

```javascript
import { connect } from 'react-flaxs';

@connect(state => ({
  ...state.something,
  somethingElse: state.else.something,
}))
export default class ConnectedComponent extends React.Component {

}
```

You can redefine the final props of your component based on the given props using a second connect function.
Example, let's say that if you want your component `ConnectedComponent` to ignore the `somethingElse` state if you specify a `ignore` attribute in the parent component using this form:

```javascript
@connect(mapMasterStateToProps, mapOwnProps)
```

Here an example:

```javascript
// ParentComponent
<ConnectedComponent ignore={true} />

// ConnectedComponent
import { connect } from 'react-flaxs';

@connect(state => ({
  ...state.something,
  somethingElse: state.else.something,
}), (stateProps, ownProps) => {
  const { somethingElse, ...otherStateProps } = stateProps;
  let finalProps = {
    ...otherStateProps,
  };
  if (!ownProps.ignore) {
    finalProps = {
      ...finalProps,
      somethingElse,
    };
  }
  return finalProps;
})
export default class ConnectedComponent extends React.Component {

}
```

### Multi Connect Decorator
If you are connecting states from stores outside the master store, then you might need a `multiConnector` (currently not available)

```javascript
import { connect } from 'react-flaxs';

@multiConnect(stores => ({
  ...stores.flags.state,
  user: stores.session.user.username,
  totalResults: stores.search.results.length
}), {
  flags: OptionsStore,
  session: SessionStore,
  search: SearchStore,
})
export default class ConnectedComponent extends React.Component {

}
```

You can specify the final props of your component based on the given props using a second connect function as a third parameter.

```javascript
@multiConnect(mapStateToProps, connectedStoresObject, mapOwnProps)
```

repository: jcperez-ch/react-flaxs

gha_language: JavaScript

repo_name: jcperez-ch/react-flaxs


text:
---
title:  "Declare multiple versions dependency in Gradle"
modified: 2020-02-28T23:00:00+07:00
permalink: /how-to/declare-multiple-versions-denpendency-in-gradle
categories:
  - How To
tags:
  - Gradle
  - Gradle Build
  - Dependency Multiple Versions
  - Dependency Management
  - TestNG
  - Allure
  - Java
---

Software projects rarely work in isolation. In most cases, a project relies on reusable functionality in the form of libraries or is broken up into individual components to compose a modularized system. Dependency management is a technique for declaring, resolving and using dependencies required by the project in an automated fashion.

So, what if I want to use the latest version while there is already a dependency using the old version?

{% include base_path %}
{% include toc title="Table of Contents" %}

## What using in demonstration
> **OS**: macOS 10.14.5

> **Java**: 1.8.0_211

> **Gradle**: 6.2.1

## Assumptions
I have a build.gradle file with `dependencies {}` script.
- TestNG: `7.1.0`
- Allure TestNG: `2.13.1`

```gradle
dependencies {
    implementation('org.testng:testng:7.1.0')
    implementation('io.qameta.allure:allure-testng:2.13.1')
}
```

And, a test method using above 2 libraries.
```java
package io.github.ngoanh2n;

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class DemonstrationTest {

    @Test
    void test() {
        Allure.step("This is test", () -> {
            System.out.println("Today is 2020-02-28");
        });
    }
}
```

**[SOURCE]** Source code illustrates on Github:

[gradle-multiple-version-dependency-conflict](https://github.com/ngoanh2n/blog-demo/tree/master/gradle-multiple-version-dependency-conflict){:target="_blank"}
{: .notice--success}

## Facing the problem
### Try to test
Let's see the error and solve it!
1. Navigate to the root of this demonstration

    ```console
    cd gradle-multiple-version-dependency-conflict
    ```

2. Try to run test method `DemonstrationTest.test`

    ```bat
    ./gradlew clean test --tests *DemonstrationTest.test
    ```

3. Watch detailed error generated by Gradle

    Open `index.html` file in `build/reports/tests/test/`

    Of course you will see errors: `java.lang.NoClassDefFoundError: org/testng/IInvokedMethodListener2`

    ```console
    Caused by: java.lang.NoClassDefFoundError: org/testng/IInvokedMethodListener2
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
        at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
        at java.net.URLClassLoader.defineClass(URLClassLoader.java:468)
        ...
    Caused by: java.lang.ClassNotFoundException: org.testng.IInvokedMethodListener2
        at java.net.URLClassLoader.findClass(URLClassLoader.java:382)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
        at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
        at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ```

### Trace the error
This error caused by not finding `org.testng.IInvokedMethodListener2` class.
Let check dependencies tree by following command:
```bat
./gradlew :dependencies
```

> **[TIP]** You can also check on [Maven Repository](https://mvnrepository.com){:target="_blank"}:

> Access [io.qameta.allure:allure-testng:2.13.1](https://mvnrepository.com/artifact/io.qameta.allure/allure-testng/2.13.1){:target="_blank"}

> Scroll to `Runtime Dependencies` to see denpendencies version and check it's up to date or not.
{: .notice--info}

And the results:
```
testRuntimeClasspath - Runtime classpath of source set 'test'.
+--- org.testng:testng:7.1.0
|    +--- com.beust:jcommander:1.72
|    +--- com.google.inject:guice:4.1.0
|    |    +--- javax.inject:javax.inject:1
|    |    +--- aopalliance:aopalliance:1.0
|    |    \--- com.google.guava:guava:19.0
|    \--- org.yaml:snakeyaml:1.21
\--- io.qameta.allure:allure-testng:2.13.1
     +--- io.qameta.allure:allure-java-commons:2.13.1
     |    +--- io.qameta.allure:allure-model:2.13.1
     |    |    \--- com.fasterxml.jackson.core:jackson-databind:2.9.8
     |    |         +--- com.fasterxml.jackson.core:jackson-annotations:2.9.0
     |    |         \--- com.fasterxml.jackson.core:jackson-core:2.9.8
     |    +--- org.slf4j:slf4j-api:1.7.25
     |    +--- com.fasterxml.jackson.core:jackson-databind:2.9.8 (*)
     |    +--- org.apache.tika:tika-core:1.20
     |    \--- org.jooq:joor-java-8:0.9.10
     \--- org.testng:testng:6.14.3 -> 7.1.0 (*)
```

Reason:
- You can see `io.qameta.allure:allure-testng:2.13.1` is using `org.testng:testng:6.14.3`
- Meanwhile, I'm deliberately using `org.testng:testng:7.1.0` for this project
- Because source code of `org.testng:testng:6.14.3` was not compliled, `org.testng:testng:7.1.0` is used for compiling into group `org.testng`. And `IInvokedMethodListener2` class was removed in version 7.1.0 of TestNG

## Solving problem
You have to keep multi versions of TestNG:
- `6.14.3` for `allure-testng:2.13.1`
- `7.1.0` as a main test framework for this project

### Declare configurations
Add `implementationTestNG6` and `implementationTestNG7` to `congigurations {}` script by the following:

```gradle
configurations {
    implementationTestNG6
    implementationTestNG7
}
```

### Download both versions
```gradle
/*
* Download dependencies through configurations 'implementationTestNG6'
* and 'implementationTestNG7' into 'libs' folder
*/
task libs(type: Sync) {
    from configurations.testCompile
    from configurations.implementationTestNG6
    from configurations.implementationTestNG7
    into "$buildDir/libs"
}

/*
* Run task 'libs' automatically when resolving dependencies
*/
classes.dependsOn libs
```

### Declare dependencies using configurations
```gradle
dependencies {
    implementationTestNG7('org.testng:testng:7.1.0')
    implementationTestNG6('org.testng:testng:6.14.3')
    implementation files("$buildDir/libs/testng-6.14.3.jar")
}
```

Now try to run test method `DemonstrationTest.test` again
```bat
./gradlew clean test --tests *DemonstrationTest.test
```

**[SOURCE]** Source code illustrates on Github:

[gradle-multiple-version-dependency-conflict-resolved](https://github.com/ngoanh2n/blog-demo/tree/master/gradle-multiple-version-dependency-conflict-resolved){:target="_blank"}
{: .notice--success}

**[REFERENCES]** Gradle Docs:

[https://docs.gradle.org](https://docs.gradle.org){:target="_blank"}
{: .notice--info}


text:
[![Code Climate](https://codeclimate.com/repos/53f5b6fde30ba068dd034555/badges/d0219a23c6ea84745443/gpa.svg)](https://codeclimate.com/repos/53f5b6fde30ba068dd034555/feed)

SpoutBrain
=======

<!-- ![image](images/sprouts.png) -->
![alt tag](http://www.gonatural.co.za/wp-content/uploads/2013/10/6_litre_Kitchen.jpg)

Hydroponic sustainable food supply.

###Getting Started

##### Materials:
- glass jars
- mesh screen, rubber bands
- container stand
- removable tray
- seeds
- fresh water
- airtight containers for storage

##### Step 1:
Place container stand over drainage tray provided. Put enough seeds (1 to 2 tsbsp. or 3 to 4 tsps., approximately 16-30 grams, depending on the seeds), to lightly cover the bottom surface of the upright jar(s).

##### Step 2:
Cover with mesh screen and secure with rubber band.

##### Step 3:
Rinse seeds of dirt and dust. Cover the seeds with about 2-4cm water and soak for a full 6-8 hours or overnight by leaving jars with the mouth up on the drainage tray.

##### Step 4:
Drain the water and rinse in fresh water swirling gently, while draining to disperse seeds across the bottom and sides of the jar.

##### Step 5:
Place jar(s) at angle with mouth down in container stand.

##### Step 6:
Rinse 2-3 times twice a day in cool water and put the jars back in the container stand in the same way.

##### Step 7:
Place jar in bright light (but not direct sunlight) to provide more greenery shortly before harvest to allow additional chlorophyll to form. Do not be afraid to experiment for optimal taste.

##### Step 8:
Enjoy in three to seven days. For a continuous suply of fresh sprouts sow new seeds every 2 to 3 days.

##### Step 9:
Drain well and to harvest cover the jar with a lid, or transfer to an airtight container. Refrigerate to store.

### Tips:
- Sprouts should smell clean and fresh, so be suspicious of unpleasant odors.
- Not all seeds will sprout.
- When rinsing the sprouts, be sure that the rinsed water is clear.
- Place mesh in a taut manner.

### Information:
www.kitchengarden.co.za

<EMAIL_ADDRESS>
Thank you for reading!

License
=================

![Platform45](http://imgur.com/3fORK1g.png)

SproutBrain is maintained and funded by Platform45. Follow [@platform45](http://twitter.com/platform45) on Twitter for updates.

repository: shaunrich/sproutbrain

repo_name: shaunrich/sproutbrain


text:
## Send an HTML email with embedded image and plain text alternate
Originally published: 2011-06-12 18:38:47
Last updated: 2011-06-12 18:38:47
Author: soham vaghela

HTML is the method of choice for those wishing to send emails with rich text, layout and graphics. Often it is desirable to embed the graphics within the message so recipients can display the message directly, without further downloads.

Some mail agents don't support HTML or their users prefer to receive plain text messages. Senders of HTML messages should include a plain text message as an alternate for these users.

This recipe sends a short HTML message with a single embedded image and an alternate plain text message.

gha_language: Python


text:
# Equilibrium Algorithm

This algorithm find the equilibrium point in an array of integers.

## See it working
[Front end test deploy](https://tests-c624c.web.app)

[Backend test deploy](https://nesspo.pythonanywhere.com/api/find/index?str=2,%202,%202,%202,%202,%202,%202,%206,%2010,%203,%201,%205,%202,%205,%203,%201,%203,%2014)

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: CesarArdilaB/ea

branch_name: refs/heads/main

repo_name: CesarArdilaB/ea


text:
# DownloadYoutubeMP3
Downloads all the right mp3 from youtube from a given artist(s) and/or song name

## INSTALLATION
Clone the project (although it would be preferable to fork it so that you can contribute & fix issues)
```bash
$git clone git@github.com:bettkd/DownloadYoutubeMP3.git
```

To install dependancies, run the following on the terminal
```bash
$sudo pip install -r requirements.txt
```

## USAGE:

```bash
Usage:
	$python downloadmp3.py -i <playlistFile> -o <outputDirectory>
	or
	$python downloadmp3.py -a <artist> -t <title> -o <outputDirectory>
Options:
	-i	specify input (path to a playlist file)
	-o	provide the destination folder other (default: ~/Downloads/YoutubeDownload/)
	-t	specify the title (default: "Jason Mraz")
	-a 	specify artist (default: "I'm yours")
	-h	help
```

### Example text file ```playlist.txt```
|				Song   			                 	|
|:----------------:--------------------------------:|
|MercyMe          Greater                           |
|Newsboys         We Believe                        |
|MercyMe          I Can Only Imagine                |
|Chris Tomlin     Amazing Grace (My Chains Are Gone)|
|Matt Redman      "10,000 Reasons"                  |
|Newsboys         God's Not Dead                    |
|Chris Tomlin     How Great Is Our God              |
|MercyMe          Word ofGod Speak                  |
|Casting Crowns   Who Am I                          |
|Matthew West     "Hello, My Name Is"               |

> Test Run
```bash
	python downloadmp3.py -i Playlists/playlist_top100Kenya_2016.txt -o ~/Desktop/KENYAN_MUSIC
```

## STORY
I love listening to contemporary christian music. So I went online to find the top 100 music to download, but all I found was a list. An amazing list of all the songs I wanted on my iPod. Now the challenge what do I do so that I can download not just all the songs in the list, but the best/verified versions of the songs. Popular web apps such as http://www.youtube-mp3.org/ need approximately 3-4 minutes to per video. That is the time I have tp download 100 songs. I know, right? Instinctively, I wrote these scripts to automate the proccess. Now all I need is the list of songs I want, and I got it in MP3 format! Yaay!

I hope this hack can help you too..


text:
# zischr

zischr is a self-service point-of-sale & accounting solution for groups of 15-20 people.

![Alt](https://github.com/hadiko-i6/zischr/wiki/screenshots/main-screen.png)

## Deployment on Raspberry Pi 3

(This assumes the Pi has the single purpose of running zischr. Otherwise, you should consider a better isolation strategy. We're happy about a PR with scripts / Dockerfiles / whatever for the `deployment/` directory).

Install Raspbian Stretch on your Raspberry Pi 3 ([Official Guide](https://www.raspberrypi.org/documentation/installation/installing-images/README.md)).
Change the password of the default `pi`.
Afterwards, run the following commands as **root**:

```
apt-get install git
cd /root
git clone https://github.com/hadiko-i6/zischr.git /root/zischrdb_checkout
mkdir /root/zischrdb
/root/zischrdb_checkout/deployment/raspi3/deploy.sh
```

This installs build & runtime dependencies and deploys a **copy** of the relvant runtime files ot `/zischr`.
`deploy.sh` also removes everythin in `/zischr` (the fsdb is kept in `/root/zischrdb`, no worries).

To keep a Git history of zischrdb, take a look into the hook functionality of the `backend server` command in the `zischr-backend.service` file.

### Updating
```
cd /root/zischrdb_checkout
git pull --ff-only
deployment/raspi3/deploy.sh
```

repository: pauloalcobia/zischr

repo_name: pauloalcobia/zischr


text:
# Capistrano::Passenger::Restart
[![Gem Version](https://badge.fury.io/rb/capistrano-passenger-restart.svg)](https://badge.fury.io/rb/capistrano-passenger-restart)

Restart Passenger support for Capistrano v3

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'capistrano', '~> 3.0'
gem 'capistrano-passenger-restart'
```

And then execute:

    $ bundle

## Usage

Require in Capfile to use the default task:

```ruby
# Capfile
require 'capistrano/passenger/restart'
```

Use task for restart Passenger in your deploy configuration:

```ruby
# config/deploy.rb
namespace :deploy do
  after  :finishing,    :restart

  task :restart do
    on roles(:app) do
      invoke 'passenger:restart'
    end
  end
end
```

And you should be good to go!

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/shved270189/capistrano-passenger-restart. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

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


text:
---
abstract: How do you foster new developers within the community? How do you ensure
  that marginalized people feel welcome? I will tell you how I grew PyLadies Boston
  from zero to a thousand by focusing primarily on beginners and by creating a group
  where women felt welcome.
accepted: true
category: talk
date: 2018-10-16 17:30:00 -0500
difficulty: All
layout: session-details
permalink: /talk/building-a-community-for-all-people/
presenters:
- bio: I'm the founder of PyLadies Boston, an organization dedicated to bringing more
    women into the open-source community in Boston, growing it from zero to a thousand.
    I have also been an organizer of PyLadies Atlanta, Boston Ruby Women, and Code
    & Supply. I currently work as a software developer at Stitch Fix, but my passion
    is teaching women how to code. I currently organize All The Nerdy Ladies Pittsburgh.
  company: Stitch Fix
  github: ''
  name: Jennifer Konikowski
  photo_url: '/static/img/speakers/jennifer-konikowski.jpg'
  twitter: jenkoni
  website: http://www.jenniferkonikowski.com
published: true
room: 'Salon F-H'
sitemap: false
slides_url: ''
summary: ''
title: Building a Community for All People
track: t1
video_url: ''
---

Are you having trouble getting beginners to stick around in your user group? What’s the best way to help people who are just getting started with Django and Python? Are you finding it difficult to attract and keep a diverse audience? Since I started PyLadies Boston in 2013, I’ve learned a few lessons about the best way to help out beginners and cultivate a welcoming community for marginalized folks. In this talk, I will cover:

* Starting a group with the intention to be beginner-friendly
* Creating a welcoming environment
* Beginner friendly meeting topics
* Finding the best way to teach people to code
* Being a good ally

This talk will benefit anyone who is currently running or thinking of starting a user group.

gha_license_id: NOASSERTION


text:
+++
title = "What I read this week (November 8 - 14)"
date = 2020-11-14
categories = ["what I read"]
draft = false
+++

On rules engines and machine learning, graph theory for COVID vaccinations, MLflow and PyTorch, and grad school.

<!--more-->

**[The vulnerable can wait. Vaccinate the superspreaders first.](https://www.wired.com/story/covid-19-vaccine-super-spreaders/) on WIRED, by Christopher Cox.**

This article explores two competing ideas in distributing a future (but now, much closer!) COVID-19 vaccine.
Most discussions and plans have said to vaccinate the most vulnerable populations first---the elderly, the immunocompromised, healthcare workers, other essential employees.
This article makes the point that if your goal is to *reduce transmission,* you should vaccinate the superspreaders first.

This creates a need for a "utilitarian calculus," as the author writes.
In reality, you'll want a combination of the two.
You might argue that we have a moral imperative to protect those most at risk individually; you might just as easily argue that we have a moral imperative to reduce transmission as much as possible (which will also protect those at risk, but will favor many who are not).

> Marc Lipsitch, an epidemiologist at Harvard's School of Public Health, says the CDC committee is grappling with a fundamental question. “Essentially there are two approaches to using a vaccine,” he says. “One is to protect individuals by vaccinating them, and the other is to reduce transmission and therefore protect the population.”

**Bonus**: how do you even find superspreaders?
Use the [Friendship paradox](https://en.wikipedia.org/wiki/Friendship_paradox)---the idea that, on average, a person has fewer friends than their friends do.
Take a random sample of the population, ask them to name someone they know, and vaccinate that person.

---

**[Combining rule engines and machine learning](https://nlathia.github.io/2020/10/ML-and-rule-engines.html) by Neal Lathia** talks about how machine learning can be used to complement, not replace, rule engines.
In the author's view, this can happen when your goal is to *optimise* a process that can't be fully enumerated with rules (as opposed to *control* one that can).

Some examples are:
 * use machine learning to design new rules (then put the model away and just implement what you learned)
 * use ML as one sub-problem of a larger system
 * use ML to make a decision based on the outputs of rules

Great, actionable advice.

---

**[What color is this? Part 2 (the computational parts)](https://multithreaded.stitchfix.com/blog/2020/10/13/what-color-is-this-part-2) by Dan Tasse (StitchFix)** is a folllow up to a [previous post](https://multithreaded.stitchfix.com/blog/2020/09/02/what-color-is-this/) about finding the colors of clothes from images.
The team clusters pixels of an image into "superpixels," then uses a graph algorithm to merge nearby superpixels with the same color.
I particularly appreciated how the post went into detail about ideas they tried that *didn't* work---that's a huge part of the research process that we never get to see.

---

**[Machine learning at Monzo](https://nlathia.github.io/2020/10/Monzo-ML.html) by Neal Lathia** (again!) is a doc answering "what does machine learning at my company look like?"
They wrote this post for prospective candidates, answering questions like "How do you decide what to work on?" and "How is your impact measured?"
I would love to see more teams writing up their apporaches to ML in this way,

---

**[MLflow and PyTorch - where cutting edge AI meets MLOps](https://medium.com/pytorch/mlflow-and-pytorch-where-cutting-edge-ai-meets-mlops-1985cf8aa789) by Geeta Chauhan and Joe Spisak** discusses the changing relationship between PyTorch and MLflow.
MLflow is a platform to manage the machine learning lifecycle, including tracking model runs, managing deployments, monitoring, and more.

This post outlined some of the capabilities of the two ecosystems:
 * saving and loading TorchScript models using MLflow
 * deploying models from MLflow through the TorchServe plugin
 * autologging via models written in PyTorch Lightning

I *really* want to get more experience with deploying and monitoring models.
I am thinking about what kind of projects I could work on to get this experience, but don't really know.
If anyone has any ideas, I'd love to hear them!

---

**[I did what I wanted during my PhD and I regret nothing](https://kimberlyhirsh.com/2020/11/13/i-did-what.html) by Kimberly Hirsh** talks about the different, non-academic activities that the author did during her PhD.
Producing an improv group, hosting a *Buffy the Vampire Slayer* podcast, and creating her own blog all helped her to grow personally and *have more fun*.
Great advice to keep in mind.

---

gha_language: HTML


text:
{ useLocationState, useQueryState }

[![npm (tag)](https://img.shields.io/npm/v/use-location-state/latest.svg)](https://www.npmjs.com/package/use-location-state)
[![codecov badge](https://img.shields.io/codecov/c/github/xiel/use-location-state/master.svg?color=hotpink)](https://codecov.io/gh/xiel/use-location-state)
![GitHub top language](https://img.shields.io/github/languages/top/xiel/use-location-state.svg)
[![lerna](https://img.shields.io/badge/maintained%20with-lerna-cc00ff.svg)](https://lerna.js.org/)

store and retrieve state into/from the browsers [location history](https://developer.mozilla.org/en-US/docs/Web/API/History) using modern hooks

## ✨ Features

- makes it easy to provide a nice UX to your users, by restoring part of the app state after navigation actions
- makes it easy to share the application in a customizable state
- **`useLocationState(name, defaultValue)`**
  - restores the latest value after navigation actions (back/forward), by keeping value in `history.state`
  - supported value types: `string | number | boolean | Date | Array | Object`
  - handles complex & nested values - all values that can be serialized are supported
- **`useQueryState(name, defaultValue)`**
  - restores the latest value from URL (`location.href`) and after navigation actions (back/forward)
  - supported value types: `string | number | boolean | Date | string[]`
  - handles stringification and parsing from query string of for supported value types
  - invalid entries from the query string are discarded and the component will receive the defaultValue instead

## Installation

```bash
yarn add use-location-state
```

Using **`react-router`** or another popular router? For the best experience install one of the [router integrations](#router-integration-optional).

## Usage

`useLocationState()` and `useQueryState()` work similar to the `useState()` [hook](https://reactjs.org/docs/hooks-overview.html#state-hook), as they also return the current value and a update function in a tuple `[currentValue, updateValueFn]`.

The _important difference_ is that **you must pass a name** before your **default value** for your state.

```javascript
const [commentText, setCommentText] = useLocationState('commentText', '')
const [priceMax, setPriceMax] = useQueryState('priceMax', 30)
```

The `defaultValue` works as a fallback and is returned when there is no value in the query or location state for this parameter.

The `defaultValue` can not be changed after the first render, so that same url always provides the same state.

### useLocationState()

`useLocationState()` is perfect, when you want to store a state that should not be reflected in the URL or in case of a complex data structure like a nested object/array.

```javascript
const [commentText, setCommentText] = useLocationState('commentText', '')
```

The name you pass, in this case `'commentText'`, will be used as a key when storing the value. So when you use the same name (and default value) in another component, you will get the same state.

```javascript
setCommentText('Wow, this works like a charm!')
```

The updated state will be restored when the pages reloads and after the user navigated to a new page and comes back using a back/forward action.

### useQueryState()

`useQueryState()` is a great, when you want to store information about the current state of you app in the URL.

```javascript
const [value, setValue] = useQueryState('itemName', 'default value')
```

The name you pass will be used as a parameter name in the query string, when setting a new value:

```javascript
setValue('different value')
```

After calling the update function `setValue()` with a new value, the state will be saved withing the query string of the browser, so that the new state is reproducable after reloads or history navigation (using forward / back button) or by loading the same URL anywhere else.

```
http://localhost:3000/#itemName=different+value
```

useQueryState() uses the browsers `location.hash` property by default.
Check out the router integrations to use `location.search` instead.

### Push

In cases where you want the updated state to be represented as a **new entry in the history** you can pass a options object to the set function, with the method property set to `'push'`.

```javascript
setValue('a pushed value', { method: 'push' })
```

This changes the way this state change is handled when the user navigates. When the user now clicks the Back-Button, this state gets popped and the previous state is restored (instead of eg. navigating away).

### Example

```javascript
import { useQueryState } from 'use-location-state'

function MyComponent() {
  const [active, setActive] = useQueryState('active', true)
  return (
    <div>
      <button type="button" onClick={() => setActive(!active)}>
        Toggle
      </button>
      {active && <p>Some active content</p>}
    </div>
  )
}
```

### Example with multiple useQueryState hooks in one component

```javascript
import { useQueryState } from 'use-location-state'

function MyComponent() {
  const [name, setName] = useQueryState('name', 'Sarah')
  const [age, setAge] = useQueryState('age', 25)
  const [active, setActive] = useQueryState('active', false)
  // ...
}
```

## Router Integration (optional)

In case you want use [`location.search`](https://developer.mozilla.org/en-US/docs/Web/API/Location/search) (after the question mark in the url) you need to use one of these extended versions of the package.

We plan to provide clean and easy-to-use integrations for all popular routers.
At the moment we provide integrations for:

### Next.js

Import from `use-location-state/next` to use the router build into Next.js, which enables you to use the query state also during **SSR**.

```javascript
import { useQueryState } from 'use-location-state/next'

export { getServerSideProps } from 'use-location-state/next' // [1]

export default function Page() {
  const [count, setCount] = useQueryState('count', 0)
  //...
}
```

[1] Page must be server rendered (SRR), otherwise React warns about a hydration mismatch, when your initial rendering depends on the query state. Export your own `getServerSideProps` function or the provided empty one.

### react-router<EMAIL_ADDRESS>
Install & import the package for react-router

```bash
yarn add react-router-use-location-state
```

```javascript
import {
  useLocationState,
  useQueryState,
} from 'react-router-use-location-state'
```

Usage works the same as described above, except that the URL will look like this now:

```
http://localhost:3000/?itemName=different+value
```

### Gatsby & @reach/router

Gatsby & Reach Router are supported. Gatsby currently always scrolls up on location (state) changes. To keep the scroll position, when you update location state using the update function of `useLocationState`, add these lines to the **gatsby-browser.js** file in gatsby root folder.

```javascript
// keeps same scroll pos when history state is pushed/replaced (same location === same position)
// see: https://www.gatsbyjs.org/docs/browser-apis/#shouldUpdateScroll
exports.shouldUpdateScroll = ({ routerProps, getSavedScrollPosition }) => {
  const currentPosition = getSavedScrollPosition(routerProps.location)
  return currentPosition || true
}
```

### More routers soon - work in progress

Your favorite router is missing? Feel free to [suggest a router](https://github.com/xiel/use-location-state/issues).

## Compatibility

Tested in current versions Chrome, Firefox, Safari, Edge, and IE11. This library relies on new, yet stable ECMAScript features, so you might need to include a [polyfill](https://www.npmjs.com/package/react-app-polyfill#polyfilling-other-language-features) if you want to support older browsers like IE11:

```javascript
import 'react-app-polyfill/ie11'
import 'react-app-polyfill/stable'
```

repository: xiel/use-location-state

gha_language: TypeScript

repo_name: xiel/use-location-state


text:
# Single Number II
Given a non-empty array of integers, every element appears three times except for one, which appears exactly once. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

## Explaining To Grandma
### Understanding the Question
* We're finding the one and only number.
*

### The Answer
*


text:
### 1. How long did you spend on the technical test? What would you add to your solution if you had more time? If you didn't spend much time on the technical test then use this as an opportunity to explain what you would add.
It took me 2.5 hours to finish the technical test.  Finish the last 2 test scripts by designing the keywords and finding the locators.
2. Create a separate file to store input data, such as URL, Environment variables, User account credentials.
3. Complete the README file adding deploy environment section, version section.

### 2. What do you think is the most interesting trend in test automation?
- DevOps being part of QA. QA will need to embrace DevOps fundamentals so that we can blend automation tests in the very early stage of each project along with CI/CD. It is pretty much like "CT" (continuous testing). Since more and more companies adopt AWS and/or Google Cloud as a standard cloud platform to deploy their services and apps, we as QA specialist should definitely join with DevOps team to figure out the perfect test flow with automation (code check, UI testing, Unit testing, performance testing, runscope, etc.)
- AI and machine learning enhanced automation testing (i.e. https://www.testcraft.io/product/) will be a trend for sure. With the help of AI and machine learning, we could even automate the generation of automation test codes and eventually lead to codeless automation test.

### 3. How would you implement test automation in a legacy application?
- Create templates and frameworks to make it easier to create and maintain automated tests.
- Create a small number of automated smoke tests might be 5–10. These  tests should exercise the basic functionality of the system.
- Start with creating integration and component tests.
- Focus the first automated tests on areas of the codebase that produce the most bugs.
- Eliminate that manual testing that automation have covered, which would save time and money without sacrificing quality.
- Include automated tests as part of code reviews.
- Integrate the automated tests into the build pipeline

Unfortunately, I do not have chance to work on a legacy application in my previous company. We worked in an Agile team so the code is very updated. But we did have a chance to work on some features after the developer had left. For this situation, I also applied the above strategy and it worked really well for me.

### 4. How would you improve the customer experience of the JUST EAT website?
I think there are several things we can improve user's experience:
- Website can detect user location by IP address, so when the first time user lands on the homepage, the nearby restaurants information can display for people to browse and choose from skipping entering postcode steps.
- "Name" label on the Sign up page could be changed to "Full Name",  so the user could register the form more quickly with entering valid credentials.
- Improve UI design and consistency. Some Restaurant logo images on the homepage did not load successfully.

### 5. Please describe yourself using JSON.
{
    "First Name": "Grace",
    "Last Name": "Li",
    "Gender": Female,
    "Education Background":{
        "College": "Hohai University",
        "Degree": "Bachelor of Engineering"
    },
    "Work Experience" :{
        "Occupation": "Software QA Tester",
        "Years": 2,
        "Domain":"Web & Mobile"
    },
    "Hobbies":{
        "Favourite TV show": "Friends",
        "Favourite book": "Dream of the Red Chamber",
        "Currently learning": "Baking"
     }
}

path: /Answers to technical questions.md

filename: Answers to technical questions.md


text:
# FastCapture
Free and Open Source screen capture app for Yosemite written in Swift.

Login with your Imgur account to have full access to your screenshots!

## Download
[Here!](https://github.com/franciscocgoncalves/FastCapture/raw/master/FastCapture.zip)

## Running the project
  1. Clone the repo: git clone git@github.com:franciscocgoncalves/FastCapture.git
  2. Enter the directory: cd FastCapture
  3. Install the dependencies: pod install
  4. Create file Keys.plist
  5. Register an Imgur(http://api.imgur.com/oauth2/addclient) application.
  7. Generate both anonymous and authenticated with callback keys
  8. Add following keys to Keys.plist: "anonymousClientId", "authenticatedClientId", "authenticatedSecret"

## Installation
  If you get an error saying that I'm not an Identified Developer, please try to open the app with Alt+Click or follow [this]( https://support.apple.com/kb/PH14369?viewlocale=en_US&locale=pt_PT ) instructions.

## Usage
Hit Command-Shift-3 to take a screenshot of the screen.

Hit Command-Shift-4 to take a screenshot of a part of the screen.

## Issues

Please, be aware that there might be conflicts if you have another screen capture app running. On future updates I'll try to fix that.

When trying to login with Twitter, you might run into problems.
Cause: Twitter callback to Imgur is causing an [error](http://i.imgur.com/pX6DY2p.png).

Workaround:
Go to Imgur website login with Twitter and then hit the login button on Fast Capture.
Hit me up if you want to contribute or if you find any bug!

repository: franciscocgoncalves/FastCapture

gha_language: Swift

repo_name: franciscocgoncalves/FastCapture


text:
# Setup

## MacOS/Linux

* `npm install`
* `npm start`

## Windows

* `npm install`
* `npm run build-watch` to start the webpack process
* Open another terminal window; from there, `npm run start-server` to start the server process

repository: bananalark/tinkering

repo_name: bananalark/tinkering


text:
---
layout: page
#
# Content
#
#subheadline: "Dummy"
title: "Download docker images from docker hub"
#teaser: "...."
categories:
  - blog
tags:
  - deegree
  - java
  - cloud
  - docker
---
Get current deegree release versions from [docker hub](https://hub.docker.com/r/deegree/deegree3-docker/):

* 3.5 - `docker pull deegree/deegree3-docker:3.5`
* 3.4 - `docker pull deegree/deegree3-docker:3.4`

To pull the latest docker image use `docker pull deegree/deegree3-docker:latest`. This will pull the latest image which is currently 3.5.x! To stick with a specific bugfix version use `docker pull deegree/deegree3-docker:3.5.1`. Only the tags for the last recent versions are updated.

To start a docker container with the name deegree on port 8080 run the following command:

`docker run -p 8080:8080 --name deegree --rm deegree/deegree3-docker`

The Dockerfile is available at [https://github.com/deegree/deegree3-docker](https://github.com/deegree/deegree3-docker).

Older versions of deegree Docker images are available from [https://hub.docker.com/r/tfr42/deegree/](https://hub.docker.com/r/tfr42/deegree/). The related Dockerfile is available at [https://github.com/tfr42/deegree-docker](https://github.com/tfr42/deegree-docker).

---

_Update 2019-10-26:_
Updated links to official deegree docker repository and versions.

_Update 2023-08-17:_
Updated image tags and versions for 3.5.


text:
# Project :Fossee Steel Application

----

> This is a Steel Desktop application build in python that allows user to access data of a steel ...see its various types and features
also add a new steel to the Steel database
## TASK
 > Displaying the properties of the steel section from the given database.
 Appending properties of new steel section(s) to the current database.
---

## Table of Contents
You're sections headers will be used to reference location of destination.

- [Description](#description)
- [Run Setup](#run-setup)
- [Installer for Windows](#installer-for-windows)
- [Use of Badges](#use-of-badges)
- [Features](#features)
- [Tools Installation](#tools-installation)
- [Code Snippet](#code-snippet)
- [Tools](#tools)

---

## Description
> Fosse Steel is build in python using `Pyqt5` library specifically `QtCore`  `QtGui`  `QtWidgets` for **GUI** development and `SqliteStudio` for **Back end database connectivity**.

---

## Run Setup
* Click on the drive link https://drive.google.com/open?id=11Oc9WW46NQdwIQxk0StbKs3ldKyl0m3r
* Download the setup folder
* Open the setup folder and Run the setup.exe file
* Hurray !! ...you are done...Enjoy the application

## Installer for Windows
* Click on the drive link https://drive.google.com/open?id=11Oc9WW46NQdwIQxk0StbKs3ldKyl0m3r
* Download the Installer folder
* Install the  My Application-0.1-amd64.msi file
* You are good to go !!! ... Enjoy

### Use of Badges

[![Build Status](http://img.shields.io/travis/badges/badgerbadgerbadger.svg?style=flat-square)](https://travis-ci.org/badges/badgerbadgerbadger) [![Github Issues](http://githubbadges.herokuapp.com/badges/badgerbadgerbadger/issues.svg?style=flat-square)](https://github.com/badges/badgerbadgerbadger/issues)  [![Badges](http://img.shields.io/:badges-9/9-ff6799.svg?style=flat-square)](https://github.com/badges/badgerbadgerbadger)

- For more on these wonderful `badges`, refer to <a href="http://badges.github.io/badgerbadgerbadger/" target="_blank">`badgerbadgerbadger`</a>.

![steel1](https://user-images.githubusercontent.com/40792388/54923502-6307f080-4f30-11e9-8c97-4fd396085bb4.gif)

## Features
  * Open a specific steel
  * Select among various types of steels
  * View various features of steel selected
  * Add a new steel entry to the database

## Tools Installation
* install `PyQt5` python library using pip
```python
pip3 install PyQt5

```
* install `xlrd` library using pip
```python
pip3 install xlrd

```
* Install SqliteStudio accessing database "Steel_section.sqlite"

- Download Sqlite Studio - [Sqlitestudio](https://sqlitestudio.pl/index.rvt)

![steel2](https://user-images.githubusercontent.com/40792388/54923689-c1cd6a00-4f30-11e9-97ff-477af28fff30.gif)

## Code Snippet

```python
        sql="select Designation from Channels"
            channels=[]
            cur=conn.execute(sql)
            for row in cur:
                channels.append(row[0])

            channel_option, ok=QtWidgets.QInputDialog.getItem(MainWindow,"Steel","Choose a Designation from Channels Section",channels,0,False)
            if ok and channel_option:
                self.lineEdit_6.setText(channel_option)

```

---

![steel3](https://user-images.githubusercontent.com/40792388/54923730-df023880-4f30-11e9-9359-fa412884a033.gif)

## Tools
### References
* [Atom](https://atom.io/)
* [SqliteStudio](https://sqlitestudio.pl/index.rvt)
* [Python](https://www.python.org/)

---

## License
---
[![CC0](https://licensebuttons.net/p/zero/1.0/88x31.png)](https://creativecommons.org/publicdomain/zero/1.0/)


text:
# Codeforces :rocket:

[![Watchers](https://img.shields.io/github/watchers/Chromicle/codeforces.svg?style=social&label=Watchers&maxAge=2592000)](https://github.com/Chromicle/codeforces/watchers/)
[![Star Gazers](https://img.shields.io/github/stars/Chromicle/codeforces.svg?style=social&label=Stars&maxAge=2592000)](https://GitHub.com/Chromicle/codeforces/stargazers/)
[![Forks](https://img.shields.io/github/forks/Chromicle/codeforces.svg?style=social&label=Forks&maxAge=2592000)](https://GitHub.com/Chromicle/codeforces/network/members/)

[![Travis CI](https://travis-ci.com/chromicle/codeforces.svg?branch=master)](https://travis-ci.com/chromicle/codeforces)

[![Android Studio](https://img.shields.io/badge/android%20studio-v3.4.1-blue.svg?cacheSeconds=2592000)](https://developer.android.com/studio/)
[![Gradle](https://img.shields.io/badge/gradle-v5.1.1-green.svg?cacheSeconds=2592000)](https://docs.gradle.org/5.1.1/release-notes.html)

## About

Codeforces is an unofficial Android version of Codeforces web. This app is made to integrate all the available Codeforces API into this app. This way the users can have a mobile version of their handle and can get key information on the go.

## How it Works?

On the [Codeforces](https://codeforces.com/) official web page, they provide various API which we access to get data in machine-readable JSON format. Then by using HttpURLConnection values of each column are parsed and set into the model to display the data.

When the app is opened, the user is required to enter his preferred handle (Username). After submitting the handle, all the contest that the Handel is associated it is displayed. Upon opening, this screen user can perform the following operation -

* On clicking on the contest, it will redirect the user to the official contest page on the Codeforces.com
* User can filter the contest based on the positive and negative.
* User can view its profile.

## Libraries Used
- [Architecture Components](https://developer.android.com/topic/libraries/architecture/)
- [DebugDB](https://github.com/amitshekhariitbhu/Android-Debug-Database)
- [GSON](https://github.com/google/gson)
- [MaterialDrawer](https://github.com/mikepenz/MaterialDrawer)
- [Logger](https://github.com/orhanobut/logger)
- [Picasso](https://square.github.io/picasso/)

## API's Used
- [Codeforces User rating](https://codeforces.com/api/user.rating?handle=sandeshghanta)
- [Codeforcees User Info](https://codeforces.com/api/user.info?handles=sandeshghanta)

## Screenshots

Home Screen

Contest History Screen

User Info

## Workflow of app
```
.......
codeforces
 ┣ Activities
 ┃ ┣ HomeFeedActivity.java
 ┃ ┣ MainActivity.java
 ┃ ┣ ProfileActivity.java
 ┃ ┗ WebViewActivity.java
 ┣ Adapter
 ┃ ┗ ContestsAppearedAdapter.java
 ┣ BottomSheet
 ┃ ┗ SortBottomSheetView.java
 ┣ Listeners
 ┃ ┣ ContestItemClickListener.java
 ┃ ┗ SortClickListener.java
 ┣ Model
 ┃ ┗ Contest.java
 ┣ Utils
 ┃ ┣ RatingAsync.java
 ┃ ┣ RatingLoader.java
 ┃ ┗ StringUtils.java
 ┗ Constants.java
 ```

 ## Getting Started

These instructions will get you a copy of the project up and be running on your local machine for development and testing purposes.

### Prerequisites

[Android Studio](https://developer.android.com/studio), with a recent version of the Android SDK.

### Setting up your development environment

- Download and install Git.

- Fork the [Codeforces project](https://github.com/Chromicle/Codeforces)

- Clone your fork of the project locally. At the command line:
    ```
    $ git clone https://github.com/YOUR-GITHUB-USERNAME/Codeforces.git
    ```

If you prefer not to use the command line, you can use Android Studio to create a new project from version control using
```
https://github.com/YOUR-GITHUB-USERNAME/Codeforces.git
```

Open the project in the folder of your clone from Android Studio and build the project. If there are any missing dependencies, install them first by clicking on the links provided by the Android studio. Once the project is built successfully, run the project by clicking on the green arrow at the top of the screen.

## PR Instruction

This project uses [Travis CI](https://travis-ci.org/Chromicle/codeforces) for checking pull requests. So before committing your changes, open Terminal via android studio and run the following commands:

For Windows:
- `gradlew clean` then
- `gradlew assembleDebug assembleRelease` then
- `gradlew check` then
- `gradlew build` finally
- `gradlew spotlessCheck`

NOTE: Currently sever is not working but update the features in the app
Currently I am updating the resources for CSE and ECE departments only and that too for semester 3 only. Once I get all the resources, I will update in all departments.
You can freely contribute to the project on the note that 'contributing guidelines' of the project are followed.
New ideas and suggestions are welcomed.
Happy Coding :)


text:
MyContacts App

An app made in flask to store and manage contacts.

   * [About](#about)
   * [Features](#features)
   * [Getting Started](#getting-started)
      * [Prerequisites](#prerequisites)
      * [Install and Run](#install-and-run)
   * [Technologies](#Technologies)
   * [Autor](#autor)
   * [License](#license)

## About
This is a project created to apply my studies acquired during the semester.

It's an application developed in Python designed to store and manage contacts of multiple users.

![exemple](resources/demo.gif)

## Features

- [x] User registration
- [x] Contact registration
- [x] Contact management
- [ ] Import/Export contacts
- [ ] Search contact

You can see a demo in the link below:

- link

## 🚀 Getting Started

These instructions will allow you to obtain a copy of the project on your local machine for development and testing purposes.

### 📋 Prerequisites

You need to have Python3.6+ installed on your machine

### 🔧 Install and Run

Clone the project
```sh
$ git clone
```

Install the dependencies
```sh
$ cd contacts_app
$ pip install -r requirements.txt
```

generate a secret key
```sh
$ python3
$ import os
$ os.urandom(12).hex
```

Insert the secret key into __init__.py
```py
app.config['SECRET_KEY'] = '->HERE<-'
```

If you want, create a sqlite database with some examples using the db_init()
```sh
$ python3
$ from run_app import db_init
$ db_init()
```

Run the flask app
```sh
$ python3 run_app.py
```

The application should be up and running at [http://localhost:5000](http://localhost:5000)

## 🛠 Technologies

* [SQLite](https://www.sqlite.org/)
* [Flask](https://flask.palletsprojects.com/)
* [SQLAlchemy](https://flask-sqlalchemy.palletsprojects.com/)
* [WTForms](https://flask-wtf.readthedocs.io/)
* [Bcrypt](https://flask-bcrypt.readthedocs.io/)

## Autor

 Ruy Araujo

[](https://www.linkedin.com/in/ruy-araujo)
[<img src="https://img.shields.io/badge/Medium-12100E?style=for-the-badge&logo=medium&logoColor=white"<EMAIL_ADDRESS>

## 📄 License

This project is under MIT-license - see file [LICENSE.md](https://github.com/usuario/projeto/licenca) for details.

repository: Ruy-Araujo/Contacts-App

repo_name: Ruy-Araujo/Contacts-App


text:
# slam
Surface anaLysis And Modeling

[![Build Status](https://travis-ci.org/gauzias/slam.svg?branch=master)](https://travis-ci.org/gauzias/slam)
[![Coverage Status](https://coveralls.io/repos/github/gauzias/slam/badge.svg?branch=master)](https://coveralls.io/github/gauzias/slam?branch=master)

slam is a pure Python library for analysing and modeling surfaces represented as a triangular mesh.
It is an extension of Trimesh, which is an open source python module dedicated to general mesh processing:
https://github.com/mikedh/trimesh

Look at the doc!
https://gauzias.github.io/slam/

The present module will consist of extensions to adapt Trimesh for the purpose of surface analysis of brain MRI data.

## Visbrain is recommended for visualization
visbrain repos is here: https://github.com/EtienneCmb/visbrain

------------------
Installation:
------------------

/home/toz/miniconda3/envs/trimesh_visbrain/bin/python setup.py develop

1. clone the current repo

2.move to slam folder and type python steup.py install or develop

7. try example scripts located in examples folder

------------------
Features (added value compared to Trimesh):
------------------

. io: read/write gifti (and nifti) file format

. generate_parametric_surfaces: generation of parametric surfaces with random sampling

. geodesics: geodesic distance computation using gdist and networkx

. differential_geometry: several implementations of graph Laplacian (conformal, authalic, FEM...), texture Gradient

. mapping: several types of mapping between the mesh and a sphere, a disc...

. distortion: distortion measures between two meshes, for quantitative analysis of mapping properties

. remeshing: projection of vertex-level information between two meshes based on their spherical representation

. topology: mesh surgery (boundary indentification, hole closing will be added in the future)

. vertex_voronoi: compute the voronoi of each vertex of a mesh, usefull for numerous applications

. texture: a class to manage properly vertex-level information.

. plot: extension of pyglet and visbrain viewers to visualize slam objects

------------------
For contributors:
------------------

1. intall flake8 and autopep8
    ```
    pip install -U autopep8 flake8
   ```

2. install pytest
    ```bash
    pip install -U pytest
    ```

repository: EtienneCmb/slam

repo_name: EtienneCmb/slam


text:
### Eleventy Shiki Twoslash

Sets up markdown code blocks to run through [shiki](https://shiki.matsu.io) which means it gets the VS Code quality
syntax highlighting mixed with the twoslash JavaScript tooling from the TypeScript website.

#### Setup

1. **Install the dependency**: `yarn add eleventy-plugin-shiki-twoslash`
1. **Include `"eleventy-plugin-shiki-twoslash"` in the plugins section** of `.eleventy.js`

   ```ts
   const shikiTwoslash = require("eleventy-plugin-shiki-twoslash")

   module.exports = function (eleventyConfig) {
     eleventyConfig.addPlugin(shikiTwoslash, { theme: "nord" })
   }
   ```

1. **Go read [npmjs.com/package/remark-shiki-twoslash](https://www.npmjs.com/package/remark-shiki-twoslash)** to see the next steps, and what is available, this module leaves all the heavy work to that module.

repository: knowler/twoslash

repo_name: knowler/twoslash


text:
## CSC 413(Software Development)- Final Project game #1(Tank Game)

### Student Name : Ahmad El Shakoushy

### IDE Used: IntelliJ IDEA
### Version of Java: 10.0.2

***Note on Documentation: Please note that the documentation for this game is included within the repo, and the documentation
  goes into great detail in explaining both parts of my Final Project(both the Tank Game and the Pyramid Panic game)***

 **How to import the game:**

   1. Go to the "Project Structure" menu within IntelliJ and select the following:

      - Set the Github repo("csc413-tankgame-aelshako") as the content root
      - Set "src" folder as a source folder
      - Set the "src/resources" folder as a resource folder

 **How to run the game:**
 1. The easiest way to run the game is to simply copy the jar file("csc413-tankgame-aelshako.jar") found in the /jar folder.
 2. Execute the jar file by either:

    - double clicking file.
    -  by using the command line(something similar to Windows PowerShell). Please note
    that you will need to have Java installed in order to run the game.

 **Controls:**
   - **NOTE**: The controls will be listed below, BUT please note that they can also be accessed in the Main Menu of the game by pressing the "HELP" button.
    I personally feel that the controls are easier to follow in the help screen, because their layout is shown in a visual and color-coded fashion.

   ---- Player1 controls ----
   - W: Move Forwards
   - A: Rotate left
   - S: Move Backwards
   - D: Rotate right
   - Q: Shoot

   ---- Player2 controls -----
   - UP key: Move Forwards
   - LEFT key: Rotate Left
   - DOWN key: Move Backwards
   - RIGHT key: Rotate Right
   - ENTER key: Shoot

 **How to play the game:**

   - **NOTE**: a brief version of how to play the game can also be found within the HELP screen of the main menu.

   - The purpose of Tank Wars is for two players to fight till the end. A player emerges as victorious when the lives of their opponent have run out.
   - Each player has 2 lives, and will respawn until they have no more lives(at which point the game is over).
   - PowerUps can be found within the eyes and mouth of the humanoid wall structure which is at the center of the map.
   - There are two types of walls(breakable and unbreakable); all walls not surrounding the entire game map are breakable and will destruct when shot by 2 bullets.
   - There are 2 types of PowerUps: SpeedBoost and Health; the SpeedBoost PowerUp will boost a player's speed for a total of 5 seconds while the Health PowerUp will
     fully replenish a player's health.


text:
##The Dynamo User Interface

The User Interface (UI) for Dynamo is organized into five main regions, the largest of which is the workspace where we compose our visual programs.

![User Interface Regions](images/2-2/01-UI-Regions.png)

>1. Menus
2. Toolbar
3. Library
4. Workspace
5. Execution Bar

Let's dive deeper into the UI and explore the functionality of each region.

####Menus

The Dropdown Menus are a great place to find some of the basic functionality of the Dynamo application. Like most Windows software, actions related to managing files and operations for selection and content editing are found in the first two menus. The remaining menus are more specific to Dynamo.

![Dropdown Menus](images/2-2/02-Menus.png)
> 1. File
2. Edit
3. View
4. Packages
5. Settings
6. Help
7. Notifications

####Toolbar

Dynamo's Toolbar contains a series of buttons for quick access to working with files as well as Undo [Ctrl + Z] and Redo [Ctrl + Y] commands. On the far right is another button that will export a snapshot of the workspace, which is extremely useful for documentation and sharing.

![Needs Update-split location Toolbar](images/2-2/03-Toolbar.png)

> 1. New - Create a new .dyn file
2. Open - Open an existing .dyn (workspace) or .dyf (custom node) file
3. Save/Save As - Save your active .dyn or .dyf file
4. Undo - Undo your last action
5. Redo - Redo the next action
6. Export Workspace as Image - Export the visible workspace as a PNG file

####Library
The Library contains all of the loaded Nodes, including the default Nodes that come with the installation as well as any additionally loaded Custom Nodes or Packages. The Nodes in the Library are organized hierarchically within libraries, categories, and, where appropriate, sub-categories based on whether the Nodes **Create** data, execute an **Action**, or **Query** data.

#####Browsing
By default, the **Library** will contain eight categories of Nodes. **Core** and **Geometry** are great menus to begin exploring as they contain the largest quantity of Nodes.  Browsing through these categories is the fastest way to understand the hierarchy of what we can add to our Workspace and the best way to discover new Nodes you haven't used before.

> We will focus on the default collection of Nodes now, but note that we will extend this Library with Custom Nodes, additional libraries, and the Package Manager later.

![NEEDS UPDATE-full width - Library Categories](images/2-2/04-LibraryCategories.png)
>1. Dictionary
2. Display
3. Geometry
4. ImportExport
5. Input
6. List
7. Math
8. Revit
9. Script
10. String
11. Add-ons

Browse the Library by clicking through the menus. Click the Geometry > Curves > Circle. Note the new portion of the menu that is revealed and specifically the **Create** and **Query** Labels.

![Browsing the Library](images/2-2/05-LibraryBrowsing.png)
>1. Library
2. Category
3. Subcategory: Create/Actions/Query
4. Node
5. Node Description and properties - this appears when hovering over the node icon.

From the same Circle menu, hover your mouse over **ByCenterPointRadius**. The window reveals more detailed information about the Node beyond its name and icon. This offers us a quick way to understand what the Node does, what it will require for inputs, and what it will give as an output.

![Node Pop Up Window](images/2-2/06-NodePopup.png)
>1. Description - plain language description of the Node
2. Icon - larger version of the icon in the Library Menu
3. Input(s) - name,  data type, and data structure
4. Output(s) - data type and structure

#####Searching
If you know with relative specificity which Node you want to add to your Workspace, the **Search** field is your best friend. When you are not editing settings or specifying values in the Workspace, the cursor is always present in this field. If you start typing, the Dynamo Library will reveal a selected best fit match (with breadcrumbs for where it can be found in the Node categories) and a list of alternate matches to the search. When you hit Enter, or click on the item in the truncated browser, the highlighted Node is added to the center of the Workspace.

![Searching the Library](images/2-2/07-LibrarySearching.png)
>1. Search Field
2. Best Fit Result / Selected
3. Alternate Matches

###Settings
From geometric to user settings, these options can be found in the **Settings** menu. Here you can opt in or out for sharing your user data to improve Dynamo as well as define the application's decimal point precision and geometry render quality.

![show menu](images/2-2/08-Settings.png)

>1. Enabling Reporting - Options for sharing user data to improve Dynamo.
2. Show Run Preview - Preview the execution state of your graph. Nodes scheduled for execution will be highlighted in your graph.
3. Number Format Options - Change the document settings for decimals.
4. Render Precision - Raise or lower the document render quality.
5. Geometry Scaling - Select range of geometry you are working on.
6. Isolate Selected Geometry - Isolated background geometry based on your node selection.
7. Show/Hide Geometry Edges - Toggle 3D geometry edges.
8. Show/Hide Preview Bubbles - Toggle data preview bubbles below nodes.
9. Manage Node and Package Paths - Manage file paths to make nodes and packages show up in the Library.
10. Enabling Experimental Features - Use beta features new in Dynamo.

###Help
If you're stuck, check out the **Help** Menu. Here you can find the sample files that come with your installation as well as access one of the Dynamo reference websites through your internet browser. If you need to, check the version of Dynamo installed and whether it is up to date through the **About** option.

![show menu](images/2-2/09-Help.png)

>1. Getting Started - A brief introduction to using Dynamo.
2. Samples - Reference example files.
3. Open Dynamo Dictionary - Resource with documentation on all nodes.
4. Report A Bug - Open an Issue on GitHub.
5. Go To Project Website - View the Dynamo Project on GitHub.
6. Go To Project Wiki - Visit the wiki for learning about development using the Dynamo API, supporting libraries and tools.
7. Display Start Page - Return to the Dynamo start page when within a document.
8. About - Dynamo Version data.

repository: DynamoDS/DynamoPrimer

gha_language: CSS

repo_name: DynamoDS/DynamoPrimer


text:
---
layout: post
title: Latest java 1.8.60 on firefox 41 on fedora 22
---

I updated my java to the latest 1.8.60 on my fedora 22.
After the latest java update, I lost the java firefox plugin.
The browser did not detect any local java at all.
The [java detection](http://www.java.com/en/download/installed.jsp?detect=jre) failed to detect any java.
I reinstalled the java rpm but to no avail. A reboot did not help either.
I then used the [documentation](http://www.oracle.com/technetwork/java/javase/manual-plugin-install-linux-136395.html) to create a manual symlink at ~/.mozilla/plugin and voila. It all started working fine :)


text:
# Errors

The Paycargo API uses the following error codes:

Error Code | Meaning
---------- | -------
400 | Bad Request -- Your request is invalid.
401 | Unauthorized -- Your API token is wrong.
403 | Forbidden -- The user associates with the token does not have sufficient permissions
404 | Not Found -- The specified resource could not be found.
422 | Unprocessable Entry -- Please change your request parameters
500 | Internal Server Error -- We had a problem with our server. Try again later.
503 | Service Unavailable -- We're temporarily offline for maintenance. Please try again later.

Transaction Creation Response codes:

Error Code | Meaning
---------- | -------
411 | Transaction type does not exist: transaction cannot be created
414 | Payer/Vendor/User does not exist: transaction cannot be created
415 | Transaction number already exists: transaction cannot be created
416 | Has arrived field invalid: transaction cannot be created
430 | Payer is not active: transaction cannot be created
431 | Vendor is not active: transaction cannot be created
441 | Missing Vendor Credit Account: transaction cannot be created
201 | Transaction Created
200 | Transaction Created and Paid (when makePayment: true)

Transaction Make Payment Response codes:

Error Code | Meaning
---------- | -------
411 | Transaction is not status created or proofed, cannot be approved
412 | Overnight availability reached, insufficient funds, cannot be approved
414 | Transaction does not exist, cannot be approved
431 | Vendor is not active, cannot be approved
432 | Payer is not client registered, cannot be approved
433 | Vendor is not client registered, cannot be approved
441 | Missing Vendor Credit Account, cannot be approved
442 | Missing Payer Debit Account, cannot be approve
451 | Please check credit missing parameters, cannot be approved
452 | Missing Payer Finance Account, cannot be approved
453 | Credit availability reached, insufficient funds, cannot be approved
200 | Transaction paid

Freight Correction Response codes:

Error Code | Meaning
---------- | --------
411 | Transaction not in a Created, Proofed or Approved status can''t be corrected
413 | Total amount cannot be greater than original amount
414 | Transaction does not exist
415 | Payment date cannot be superior to original payment date
423 | Some payments have different status than pending
424 | Payments for this approved transaction don't exist
200 | Transaction freight corrected

repository: PayCargo/Docs

repo_name: PayCargo/Docs


text:
# Contributor Guidelines

## General Workflow

This is the process for committing code into master. There are of course exceptions to these rules, for example minor changes to comments and documentation, fixing a broken build etc.

1. Make sure you have signed the [Typesafe CLA](http://www.typesafe.com/contribute/cla), if not, sign it online.
2. You should always perform your work in a Git feature branch or
GitHub fork. The branch should be given a descriptive name that explains its intent.
3. When the feature or fix is completed you should open a [Pull Request](https://help.github.com/articles/using-pull-requests) on GitHub.
4. The Pull Request should be reviewed (and merged when ready) by
one of the project maintainers. Anyone should feel free to chime
in on pull requests.
5. After the review you should fix the issues as needed (pushing a new commit for new review etc.), iterating until the reviewers give their thumbs up.
6. Once the code has passed review the Pull Request can be merged
into the master branch. The feature branch should be deleted at
that time.

## Pull Request Requirements

For a Pull Request to be considered at all it has to meet these requirements:

1. Live up to the current code standard:
   - Not violate [DRY](http://programmer.97things.oreilly.com/wiki/index.php/Don%27t_Repeat_Yourself).
   - [Boy Scout Rule](http://programmer.97things.oreilly.com/wiki/index.php/The_Boy_Scout_Rule) needs to have been applied.
2. There should be tests if feasible and appropriate. For
Activator we don't have a good way to test the HTML/JS UI unfortunately.
3. Copyright:
   -  All source files in the project must have a Typesafe copyright header in the style of ``Copyright (C) 2011-2013 Typesafe Inc. <http://www.typesafe.com>``. Never delete or change existing copyright notices, just add additional info.

If these requirements are not met then the code should **not** be merged into master, or even reviewed - regardless of how good or important it is. No exceptions.

## External Dependencies

All the external runtime dependencies for the project, including
transitive dependencies, must have an open source license that is
equal to, or compatible with,
[Apache 2](http://www.apache.org/licenses/LICENSE-2.0).

## Creating Commits And Writing Commit Messages

Follow these guidelines when creating public commits and writing commit messages.

1. If your work spans multiple local commits (for example; if you do safe point commits while working in a feature branch or work in a branch for long time doing merges/rebases etc.) then please do not commit it all but rewrite the history by squashing the commits into a single big commit which you write a good commit message for (like discussed in the following sections). For more info read this article: [Git Workflow](http://sandofsky.com/blog/git-workflow.html). Every commit should be able to be used in isolation, cherry picked etc.
2. First line should be a descriptive sentence what the commit is doing. It should be possible to fully understand what the commit does by just reading this single line. It is **not ok** to only list the ticket number, type "minor fix" or similar. Include reference to ticket number, prefixed with #, at the end of the first line.  If not, go to 3.
3. Following the single line description should be a blank line followed by an enumerated list with the details of the commit.
4. Add keywords for your commit (depending on the degree of automation we reach, the list may change over time):
    * ``Review by @gituser`` - if you want to notify someone on the team. The others can, and are encouraged to participate.
    * ``Fix/Fixing/Fixes/Close/Closing/Refs #ticket`` - if you want to mark the ticket as fixed in the issue tracker (Assembla understands this).
    * ``backport to _branch name_`` - if the fix needs to be cherry-picked to another branch (like 2.9.x, 2.10.x, etc)

Example:

    Adding monadic API to Future. Fixes #2731

      * Details 1
      * Details 2
      * Details 3

repository: zoosky/activator

gha_language: Scala

repo_name: zoosky/activator


text:
---
layout: post
title: Objective C - copy, assign, retain
date: 2023-02-24 23:15:00
comment_id: 233
categories: [iOS, Objective-C]
tags: [MRC]
---

## copy

Specifies that a copy of the object should be used for assignment.

The previous value is sent a release message.

The copy is made by invoking the copy method. This attribute is valid only for object types, which must implement the NSCopying protocol.

### Memo

- Difference between `copy` and `retain` is, `retain` will reference pointer address, where `copy` is copy the element itself. When property is be `retain`, and change some property, the related will be changed together. For `copy`, it will not effect others.

## assign

Specifies that the setter uses simple assignment. This attribute is the default.

You use this attribute for scalar types such as NSInteger and CGRect.

### Memo

- `assign` will not increasing the reference, when the property de-allocated, it will be released. Even other variable call it, they cannot keep it, it will only cause crash. Even it is released, the pointer still exist, because wild pointer, when new variable assign to this address, it will crash.
- So only use this attribute for scalar types, because they will be assign to stack, and be processed by system, which will not cause wild pointer.

## retain

Specifies that retain should be invoked on the object upon assignment.

The previous value is sent a release message.

In OS X v10.6 and later, you can use the **attribute** keyword to specify that a Core Foundation property should be treated like an Objective-C object for memory management:

```objective-c
@property(retain) __attribute__((NSObject)) CFDictionaryRef myDictionary;
```

### Memo

- `retain` will count the reference. When be referenced, count +1, when be released ,count -1. Even though this variable been released, if there is other variable call it, it will be kept. Only when count be 0, it will be dealloc.

#### References

- <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjectiveC/Chapters/ocProperties.html>


text:
# ReachOut

#### An app that allows a user to be in the loop about everything happening in the Health Sector stats through viewing  and adding approved stats/collected data.

### By Sheilla Njoroge

### Project Image

## Setup/Installation Requirements

- To run the app, install `Python3`
- Then use these commands:
     1. `git clone https://github.com/sheillanjoroge/Reach-Out.git`
     2. `cd reachout`
     3. `python -m venv virtual` to create a virtual environment named `virtual`
     4. `source virtual/bin/activate` to activate the virtual environment
     5. `psql` then `CREATE DATABASE reachout` to create a postgres database
     6. `pip install -r requirements.txt` to install dependencies
     7. `python3 manage.py makemigrations reachout` then `python3 manage.py migrate` to create database migrations
     8. `python3 manage.py runserver` to run the app
     9. `python3 manage.py test reachout` to run the tests

## Known Bugs

No known bugs.

## Technologies Used

Django
Python3
Bootstrap4
HTML
CSS
Heroku

## Support and contact details

Incase of any issues drop me an email at<EMAIL_ADDRESS>
### License

MIT License

Copyright (c) 2021 Reach-Out

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. **Sheilla Njoroge**

repository: sheillanjoroge/Reach-Out

repo_name: sheillanjoroge/Reach-Out


text:
# Botframework MultiPrompt

The existing node.js botframework [Prompt](https://docs.microsoft.com/en-us/bot-framework/nodejs/bot-builder-nodejs-dialog-prompt) class is only able to process one input type, whether its a text, attachment or anything else. Such functionality is limiting and requires users to make muliple linear requests to recieve the information they want using an image or text as input.

This module provides a custom [Prompt](https://docs.microsoft.com/en-us/bot-framework/nodejs/bot-builder-nodejs-dialog-prompt)  implementation allows dynamic processing of either text or attachments with one unified query.

## Usage
[Usage example](src/README.md)

## Sample code
Launch the bot located in the 'sample' directory.
When the user speaks with the bot, the bot will answer 'text!' if the user entered a text and 'attachment!' if the user sent an image.


text:
## 5 kyu | Human Readable Time
[Codewars Kata Link](https://www.codewars.com/kata/52685f7382004e774f0001f7/train/javascript)

**Description:**

Write a function, which takes a non-negative integer (seconds) as input and returns the time in a human-readable format `(HH:MM:SS)`

`HH` = hours, padded to 2 digits, range: `00 - 99`
`MM` = minutes, padded to 2 digits, range: `00 - 59`
`SS` = seconds, padded to 2 digits, range: `00 - 59`
The maximum time never exceeds `359999 (99:59:59)`

**Examples:**
```
  humanReadable("5") == '00:00:05'
  humanReadable("60") == '00:01:00'
  humanReadable("86399") == '23:59:59'
```

repository: CanerSezgin/codewars

repo_name: CanerSezgin/codewars


text:
# Simple Journal

Simple Journal is a Ruby on Rails designed web application for quickly and easily keeping track of your life.

Users can create an account and sign in manually or login through their Google account.

## Prerequisites
The setups steps expect following tools installed on the system.

Github

Ruby 2.6.1

Rails 6.1.3

## Clone the Repository

```bash
git clone https://github.com/stacysorey/Phase_3_Rails_Project
```

## Installation

Upon initiliazation:

```bash
bundle install
```

## Usage

To open web application:

```
rails s
```

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
ParallelArch
============

Some parallel program stuff for school

-> PA1: Seq vs Parallel speedup of 2.33x without compiler optimizations

	Timing:
	Sequential: 544617 microseconds
	Parallel:   233167 microseconds

-> PA2: Seq vs Parallel N-Queens speedup of 5x over 8 processors for queens in the range 8-15

	Timing:
	Sequential: 6.45s (1proc, 15 queens)
	Parallel: 6.83s (1proc, 15 queens)

repository: sudov/ParallelArch

repo_name: sudov/ParallelArch


text:
---
layout: relation
title:  'det'
shortdef : 'determiner'
udver: '2'
---

The relation `det` is used for the relation within a nominal phrase between the nominal head and its determiner.
Guajajara lacks articles, all of its determiners are demonstratives. The determiners always precede the nominal head.

~~~ sdparse
Aʔe tuaʔu . \n That old man .
det(tuaʔu, aʔe)
~~~

<!-- Interlanguage links updated Út 9. května 2023, 20:04:11 CEST -->

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


text:
## Theme files for the [ace editor](https://github.com/ajaxorg/ace)

### Files in this folder are automatically generated!

**Do not touch files manually.**

To build these files you must first install dev dependencies:
```bash
$npm bootstrap
```

And then you can run build:
```bash
$ npm build-ace
```

repository: DinkDonk/dinkdonk-scheme

repo_name: DinkDonk/dinkdonk-scheme


text:
| Supported Targets | ESP32 | ESP32-S3 |
| ----------------- | ----- | -------- |

# HC-SR04 Example

(See the README.md file in the upper level 'examples' directory for more information about examples.)

The capture module in MCPWM peripheral is designed to accurately log the time stamp on the hardware side when an event happens (compared to GPIO ISR which requires a software-based logging method). Each capture unit has three channels, which can be used together to capture IO events parallelly.
This example shows how to make use of the HW features to decode the pulse width signals generated from a common HC-SR04 sonar range finder -- [HC-SR04](https://www.sparkfun.com/products/15569).

The signal that HC-SR04 produces (and what can be handled by this example) is a simple pulse whose width indicates the measured distance. A pulse is required to send to HC-SR04 on `Trig` pin to begin a new measurement. Then the pulse described above will be sent back on `Echo` pin for decoding.

Typical signals:

```
Trig       +-----+
           |     |
           |     |
      -----+     +-----------------------
Echo                   +-----+
                       |     |
                       |     |
      -----------------+     +-----------

 +--------------------------------------->
                Timeline
```

## How to Use Example

### Hardware Required

* An ESP development board
* HC-SR04 module

Connection :

```
        +------+              +---------------------------------+
+-------+      |              |                                 |
|       |  VCC +--------------+ 5V                              |
+-------+      |              |                                 |
        + Echo +----=====>----+ GPIO18 (internal pull up)       |
        |      |              |                                 |
        + Trig +----<=====----+ GPIO19                          |
+-------|      |              |                                 |
|       |  GND +--------------+ GND                             |
+-------|      |              |                                 |
        +------+              +---------------------------------+
```

### Build and Flash

Run `idf.py -p PORT flash monitor` to build, flash and monitor the project.

(To exit the serial monitor, type ``Ctrl-]``.)

See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects.

## Example Output

```
I (314) hc-sr04: HC-SR04 example based on capture function from MCPWM
I (324) hc-sr04: Echo pin configured
I (324) gpio: GPIO[19]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
I (334) hc-sr04: Trig pin configured
I (344) hc-sr04: trig task started
I (444) hc-sr04: Pulse width: 419us, Measured distance: 7.22cm
I (544) hc-sr04: Pulse width: 419us, Measured distance: 7.22cm
I (644) hc-sr04: Pulse width: 416us, Measured distance: 7.17cm
I (744) hc-sr04: Pulse width: 415us, Measured distance: 7.16cm
I (844) hc-sr04: Pulse width: 415us, Measured distance: 7.16cm
I (944) hc-sr04: Pulse width: 416us, Measured distance: 7.17cm
I (1044) hc-sr04: Pulse width: 391us, Measured distance: 6.74cm
```

This example runs at 10Hz sampling rate. out of range data is dropped and only valid measurement is printed.

## Troubleshooting

For any technical queries, please open an [issue] (https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you soon.

repository: igrr/esp-idf

gha_language: C

repo_name: igrr/esp-idf


text:
# dom-events

Binds Dom Events to actions on Highcharts elements.

This fork was created to reduce the doubleclick wait delay.

### Usage

Add event handler as any other event handler in Highcharts:
```javascript
events: {
    contextmenu: function(e) {
        ...
    }
}
```

### Supported events per element

Events       | Plot Area | Series | Point
------------ | --------- | ------ | -----
dblclick     | -         | -      | -
mousedown    | -         | -      | -
mouseup  	 | -         | -      | -
mousemove 	 | -         | -      | -
mouseout	 | -         | -      | -
mouseenter 	 | -         | -      | -
mouseleave	 | -         | -      | -
wheel		 | +         | -      | -
contextmenu	 | +         | +      | +

repository: jasundst/dom-events

repo_name: jasundst/dom-events


text:
# cairo-gobject

Cairo binding for use with Gdk and Gtk widgets.
It is extension for compile-time generated bindings to "libcairo-gobject2" library.
This bindings is generated "gobject" shard (https://github.com/jhass/crystal-gobject).
I used mainly code from "cairo-cr" shard ,
so it is a fork "cairo-cr" shard (https://github.com/TamasSzekeres/cairo-cr)

## Installation

First install cairo:
```bash
sudo apt-get install libgirepository1.0-dev libgtk-3-dev libcairo-gobject2
```

1. Add the dependency to your `shard.yml`:

   ```yaml
   dependencies:
     cairo-gobject:
       github: viachpaliy/cairo-gobject
   ```

2. Run `shards install`

## Usage

```crystal
require "gobject/gtk"
require "cairo"
```
For more details see the sample in [/samples](/samples) folder.

## Samples

Run sample :
```shell
  cd cairo-gobject
  shards install
  crystal run samples/sample_name.cr
```

## Development

TODO: Write development instructions here

## Contributing

1. Fork it (<https://github.com/your-github-user/cairo-gobject/fork>)
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 a new Pull Request

## Contributors

- [viachpaliy](https://github.com/your-github-user) - creator and maintainer

repository: keidax/cairo-gobject

repo_name: keidax/cairo-gobject


text:
---
id: get-recommend
title: Get Recommendations
---

:::note

This tutorial assumes you already have a server.py file with Python Flask and PyMongo set up. If you haven't already, read the [Overview](endpoint-summary.md) before reading this section.

:::

When a user wants to view recommended games, we retrive the information with the following steps:

1. The request passes the user's email as a query.
2. Use MongoDB's `find_one` to find the user by email. Return 404 error if not found.
3. Else, return the result of the `predict` function.

The code will be as follows:

```python
@app.route('/game', methods=["GET"])
def get_game():
    email = request.args.get('email') #user ID

    user = User.find_one({'email': email})
    if not user:
        abort(404)

    # get new recommendations
    return jsonify(predict(email))
```

repository: steffy-lo/Gameo

repo_name: steffy-lo/Gameo