text:
---
title: MapsIndoors for Web - Part 2

---

## Trying the Showcase Web App

A [showcase app is available on GitHub](https://github.com/MapsIndoors/Showcase-Web-App), free to use and adapt to your needs.

### To try it out right away:
Make sure nodejs, npm and gulp is installed on your system
Using a terminal/shell in the project folder, run the following commands:

* npm install -g browser-sync
* gulp build
* browser-sync start --server
* If on Windows and prompted, allow server to use your PC network
* Open your browser at http://localhost:3000/app (or whatever port browser-sync chooses per default)

## Create a Search and Suggestions box

If you need to facilitate search functionality to your MapsIndoors solution, you can use the Suggestions UI component. Add the suggestions stylesheet as a starting point for the design.

```html
<link href="https://app.mapsindoors.com/mapsindoors/js/sdk/ui/Suggestions.css" rel="stylesheet" />
```

Add the following html somewhere in your document.

```html
<div id="search-box" class="mapsindoors search-container">
    <input type="search" placeholder="Search rooms and facilites..." class="mapsindoors search">
    <ul class="mapsindoors suggestions"></ul>
</div>
```

Given the above code, here is a simple example on how to use the component.

```javascript
// Div containing an input search element
var searchDiv = document.getElementById('search-box');

// If needed, insert the div element as a map control
googleMap.controls[google.maps.ControlPosition.TOP_LEFT].push(searchDiv);

// Instantiates suggestions object
var suggestions = new mapsindoors.Suggestions(searchDiv);

// Listen for user interaction - returns the selected location
google.maps.event.addListener(suggestions, 'location_changed', function (location) {
    console.dir(location);
});
```

### Setting the floor

Sets the current visible floor. This will make visible the corresponding floorplans and the icons on top of it. If the floor index provided does not correlate to any building floor, then the “nearest” floor will be activated. E.g. providing `setFloor(4)` on a three story building (with floor-indexes 0, 1, 2) will make the topmost floorplan visible (with floor-index 2).
Although floors may have names (“G” for 0, “M1” for 1, “M2” for 2 etc.) you need to set the floor using the index-value.

```javascript
mapsIndoors.setFloor(4)
```

### Getting the floor

Returns current floor index number (integer), e.g. 0 for ground floor, -1 for basement.

```javascript
mapsIndoors.getFloor()
```

## Using the directionsRenderer

Constructor. Takes directions render options as required parameter.

```javascript
var directionsRenderer = new mapsindoors.DirectionsRenderer(
{
   mapsindoors: mapsIndoors,     // The MapsIndoors instance
}
);
```
### setting the style of the direction renderer

Sets the directions rendering style. For twaeking style of route polylines we use the [Google Maps v3 API PolylineOptions](https://developers.google.com/maps/documentation/javascript/reference#PolylineOptions) format. The methods first parameter refers to a style type that can be either the travel mode for outdoor routes or the type of way for indoor routes. The possible style types include:

* default – The default style, will be used for all non-specified styles.
* driving – Style for driving travel mode.
* walking – Style for walking travel mode.
* transit – Style for transit travel mode.
* bicycling – Style for transit travel mode.
* footway – Style for regular indoor ways.
* steps – Style for steps/stairs.
* elevator – Style for elevators.
* escalator – Style for elevators.
* travellator – Style for travellators.
* residential – Style for roads at a venue.

```javascript
var directionsRenderer = new mapsindoors.DirectionsRenderer();

directionsRenderer.setStyle('default',
{
   clickable:  boolean                                 // Indicates whether this Polyline handles mouse events. Defaults to true.
   icons: Array<IconSequence>                          // The icons to be rendered along the polyline.
   path: MVCArray<LatLng>|Array<LatLng|LatLngLiteral>  // The ordered sequence of coordinates of the Polyline. This path may be specified using either a simple array of LatLngs, or an MVCArray of LatLngs. Note that if you pass a simple array, it will be converted to an MVCArray Inserting or removing LatLngs in the MVCArray will automatically update the polyline on the map.
   strokeColor: string                                 // The stroke color. All CSS3 colors are supported except for extended named colors.
   strokeOpacity: number                               // The stroke opacity between 0.0 and 1.0.
   strokeWeight: number                                // The stroke width in pixels.
   visible: boolean                                    // Whether this polyline is visible on the map. Defaults to true.
   zIndex: number                                      // The rendering index in relation to other polylines
}
);
```
### Setting the direction

Renders the route result using the applied render options. Used in conjunction with a DirectionsService, this is an example of displaying a route on the map.

```javascript

var directionsService = new mapsindoors.DirectionsService();
var renderer = new mapsindoors.DirectionsRenderer({ mapsIndoors: myMapsIndoors });

directionsService.route(
   {
      origin: {
         lat: 55.687791059149376,
         lng: 12.571580452361996,
         floor: 0
      },
      destination: {
         lat: 55.687476568798,
         lng: 12.568619293609554,
         floor: 0
      },
      travelMode: "WALKING"
      avoidStairs: true
   }
).then(function (result) {
   renderer.setDirections(result);
});
```
### Getting the location using queries

Get locations from MapsIndoors using a query object (optional). With no query parameter, all published locations will be fetched.

```javascript
var locations = new mapsindoors.LocationsService();

locations.getLocations(
{
   q: "lounge",         //Search for matches in location name or aliases
   building: "34",      //Fetch from specific building, using the administrative id of the building
   venue: "VenueA",     //Fetch from specific venue, using name of venue
   floor: 1,                     //Fetch from 1st floor
   take: 10,                     //Fetch only 10 locations
   skip: 10,                     //Skip first 10 in result
   near: {lat:57.5, lng: 12.9}   //Sort by proximity to geographic point
   radius: 50,           //Fetch only nearest within meters from near
   orderBy: "name"      //Sort by name (possible values are Name, Floor,
                        //Building, Venue, Type and RoomId)
}
).then(function(data) {
   // returns an array of locations that matches the criteria
});
```
### Clearing

Clear the current route rendering.

```javascript
directionsRenderer.clear();
```
## Using the directionsService

Constructor. Instantiates a service that can be used for making route requests.

```javascript
route( request:DirectionsRequest )
```

Request routing from a point to another. The request object aligns to the [Google Maps V3 API DirectionsRequest object specification](https://developers.google.com/maps/documentation/javascript/3.exp/reference#DirectionsRequest), but with floor properties on origin and destination. Furthermore, avoidStairs boolean can be set to request routes for both disabled users and users without disabilities.

```javascript
var directionsService = new mapsindoors.DirectionsService();

directionsService.route(
{
   origin: {lat:57.5, lng: 12.9, floor: 0},
   destination: {lat:57.5, lng: 12.9, floor: 0},
   // MapsIndoors options
   avoidStairs: true,
   // Google Directions options
   travelMode: google.maps.TravelMode,
   transitOptions: {...},
   avoidFerries: true,
   ...
}
).then(function(routeResult) {
   // Result will contain possible routes or none if routing failed.
});
```

## Using the LocationService

Constructor.

```javascript
LocationsService()
```
### Getting the categories

Get the unique categories and their translation used by published locations. Typically, this can be used to build a menu for list or map filtering of locations.

```javascript
var locations = new mapsindoors.LocationsService();

locations.getCategories().then(function(categories) {
   // Returns localized category list with structure { office: "Office", ... } e.g. for english.
});
```
### Getting the types

A set of location types is defined for every MapsIndoors solution. The current list of types can be retrieved like this:

```javascript
var locations = new mapsindoors.LocationService();

locations.getTypes().then(function(types) {
   // returns array of types with format { name:string, icon:string }
});
```

### Getting the location details

Get the full details object of a single location. Pass the MapsIndoors id string present in any location object at `location.id`.

```javascript
var locations = new mapsindoors.LocationsService();
// Get all locations
locations.getLocations().then(function(data) {
   locations.getLocationDetails(data[0].id).then(function(detailedData) {
      // Returns a full-detail location object
   });
});
```


text:
# Android Immersive mode (Full-Screen)

This app create a floating widget to enable and disable
Immersive mode (Full Screen without status bar and home button bar)

Developed using Eclipse and Android Plugin

Actually: is not fully working, with some bugs on whatsapp and touch events
over other apps.

Basically it creates an invisible activity that is on top of every view.

## License

* [Apache Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html)

![](/LICENCE)

## Contributing

Please fork this repository and contribute back using pull requests.

Any contributions, large or small, major features, bug fixes, additional
language translations, unit/integration tests are welcomed and appreciated
but will be thoroughly reviewed and discussed.

## About

+ MakinGIANTS
+ http://www.makingiants.com
+ here.makin.giants@gmail.com

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Coroutines

The main feature of tconcurrent is the coroutines. `async_resumable` runs a
coroutine asynchronously and returns a future with the return value of the
coroutine.

This is similar to Boost ASIO's `co_spawn` except that `async_resumable` takes a
callable instead of an awaitable.

## How to use them

A coroutine function must return a `cotask` which is an awaitable lightweight
object templated on the return value. It must use `TC_RETURN` instead of return.
To await a result (another `cotask` or a `future`), it must use `TC_AWAIT`.

```c++
tc::cotask<int> receive_value();
tc::cotask<void> send_value();

int main()
{
  tc::future<int> f = tc::async_resumable([]() -> tc::cotask<int> {
    int const val = TC_AWAIT(receive_value());
    TC_AWAIT(send_value(val * 2));
    TC_RETURN(42);
  });
  f.get();
}
```

## C++20 and the coroutines-TS

tconcurrent has two compatible implementations of coroutines so that the same
code can be compiled in two flavors.

The first one is a stackful implementation in `stackful_coroutine.hpp`. It
relies on Boost Context to allocate stacks and switch between them.

The second one is a stackless implementation in `stackless_coroutine.hpp`. It
relies on C++20's coroutines. With this implementation, the `TC_AWAIT` and
`TC_RETURN` macros expand to `co_await` and `co_return` respectively.

Note that C++20's only brings building blocks for coroutines, but a library is
needed to implement what's needed to have usable coroutines, so tconcurrent is
still needed in a C++20 environment.

To choose between the two implementations, the code only needs to include
`tconcurrent/coroutine.hpp`, and the build system needs to define the macro
`TCONCURRENT_COROUTINES_TS` to `1` to switch to the stackless implementation.

Important: The two implementation are not ABI-compatible. Do not link code using
both implementations in the same binary!

## Cancelation

tconcurrent coroutines can only be run on single-threaded execution contexts.
They can also only be canceled from an executor bound to the execution context
they are running on.

This gives the guarantee to tconcurrent that a coroutine can only be canceled on
a suspension point, and further allows tconcurrent to synchronously cancel
coroutines.

When `request_cancel()` is called on a future linked to a coroutine, the
coroutine is immediately destroyed. In the stackful implementation, the
coroutine is resumed and the suspension point will throw an `abort_coroutine`
exception which must not be caught. This will allow all the destructors to run.
In the stackless implementation, `coroutine_handle::destroy()` is called.

## Pitfalls

### Differences between the stackful and stackless implementation

In the stackful coroutines mode, a coroutine method called but not awaited will
run, `TC_AWAIT` is almost a no-op.

In the stackless coroutines mode, a coroutine method called but not
awaited will have no effect.

In other words, stackful coroutines are hot-start and stackless coroutines are
cold-start coroutines.

```c++
tc::cotask<void> print_hello();

tc::cotask<void> work()
{
  // If you forget TC_AWAIT, this code will just work in stackful mode. However,
  // in stackless mode, print_hello will *not* be called.
  print_hello();
}
```

In stackless mode, some compiler will issue a warning if you forget to use the
returned `cotask`.

### Storing a cotask

To avoid life-time errors, it is recommended to never do anything else than
`TC_AWAIT` with a `cotask`, especially not storing it, moving it or returning
it. Doing such things can lead to use-after-free or use-after-return errors with
the arguments of the called function.

This is not a limitation of tconcurrent but rather a limitation of C++20's
coroutines.

In the stackless implementation, the following code is undefined behavior.

```c++
tc::cotask<void> print(std::string const& s)
{
  std::cout << s;
  TC_RETURN();
}

tc::cotask<void> work()
{
  // This line will allocate a temporary std::string, store a cotask and destroy
  // the std::string
  auto task = print("test");

  // This will run the print function, which has captured by address the now
  // destroyed std::string
  TC_AWAIT(task); // CRASH!

  // It is thus recommended to not store cotasks
  TC_AWAIT(print("test")); // safe
}
```

### Other caveats

It is not legal to call `TC_AWAIT` in a `catch` clause. This will not compile
with the coroutines-TS on compliant compilers. In stackful mode, such a code
will trigger an assertion failure.

Due to a limitation in Boost Context, canceling a coroutine from a `catch`
clause is also impossible and will trigger an assertion failure. Note that this
works fine with the stackless coroutines.

It is not legal either to call `TC_AWAIT` in a destructor since a destructor
cannot return a `cotask`. In stackless mode, it will not compile. In stackful
mode, it may trigger undefined behavior.

repository: TankerHQ/tconcurrent

repo_name: TankerHQ/tconcurrent


text:
```
BOYCOTT on russia! Don't buy, sell, support - HELP TO STOP WAR!
«Русский военный корабль, иди на хуй!» (c) Grybov, Ukrainian Frontier Guard

ATTENTION: This is a demo - use it as you wish. Reference is appriciated.
If you want to thank - buy me coffee: https://secure.wayforpay.com/donate/asperi
```

Q: SwiftUI: Unable to animate images (by Master AgentX)

A: Here is possible approach. I simplified it for a demo purpose and less posting code, but idea should be clear and easy transferrable to your real code

Result demo (really it is much fluent than on gif):

![ezgif com-gif-maker-47](https://user-images.githubusercontent.com/62171579/175868380-3935e6bf-0db3-4b33-a7ea-e4f515501a22.gif)

Modified model

    enum SpeakerSymbol: Int, CaseIterable { // Inherited from Int for convenient below

        case speakerEmpty, speaker1, speaker2, speaker3

        var image: some View {
            var name: String
            switch self {
            case .speakerEmpty: name = "speaker.slash.fill"
            case .speaker1: name = "speaker.1.fill"
            case .speaker2: name = "speaker.2.fill"
            case .speaker3: name = "speaker.3.fill"
            }
            return Image(systemName: name).font(.largeTitle)
        }
    }

Animatable modifier for SpeakerSymbol, required to let SwiftUI animation know that changed SpeakerSymbol value is able to animate

    struct SpeakerModifier: AnimatableModifier {
        var symbol: SpeakerSymbol

        init(symbol: SpeakerSymbol) {
            self.symbol = symbol
            self.animating = Double(symbol.rawValue) // enum to Double
        }

        private var animating: Double // Double supports Animatable
        var animatableData: Double { // required part of Animatable protocol
            get { animating }
            set { animating = newValue }
        }

        func body(content: Content) -> some View {
            return SpeakerSymbol(rawValue: Int(animating))!.image // Double -> enum
        }
    }

Demo of usage

    struct TestSpeakerModifier: View {
        @State private var speaker: SpeakerSymbol = .speakerEmpty

        var body: some View {
            VStack {
                Color.clear // << just holder area
                    .modifier(SpeakerModifier(symbol: speaker))
                    .frame(width: 60, height: 60, alignment: .leading)
                Divider()
                Button("Toggle") {
                    withAnimation { // animates between enum states
                        self.speaker =
                           (self.speaker == .speakerEmpty ? .speaker3 : .speakerEmpty)
                    }
                }
            }
        }
    }

license: MIT

gha_language: Swift

gha_license_id: MIT


text:
# Silverback

An extremely simple to use Decorator style Scala function measure tool.

## Introduction

Measure, profile and monitor your Scala functions and methods using Annotations.
This will give Python like decorator capabilities enabling you to monitor the performance of your functions without altering your code.

This project will also give you the possibility to add a custom function in which you can define whatever you want to do with the metrics. For example print the metrics, store them in a database or datalake, or send them to your monitor system.

This project has been tested with Spark structured streaming. You can decorate the functions used by your udf's . For each microbatch or call metrics will be processed.

##Installation
```
In your build.sbt:
addCompilerPlugin("org.scalameta" % "paradise" % "3.0.0-M5" cross CrossVersion.full)

In the silerback project:
sbt assembly
Move the fat jar into your classpath.

Note: Soon we will try to get this into maven so you can use SBT dependencies.
```

## Example usage without custom function, will provide some default text in Standard output

```
@MeasureTime("plusOne")
  private def plusOne (x : Int) : Int = {
    Thread.sleep(500)
    x + 1
  }

val x = plusOne(4)

Time measurement for metric : plusOne
Start,- and End-time :<PHONE_NUMBER>351 and<PHONE_NUMBER>851
Elapsed time : 500ms!!
```

## Example usage with custom function . In this example we will just print, but you can do anything eg store in a database or send events towards your monitor system.
```
(MetricName : String,startTime : Long, endTime : Long,elapsedMsTime : Long) => Unit

private def printStats(metricsName : String,startTime : Long,endTime : Long,elapsedMsTime : Long): Unit = {
    println("Custom output for metric " + metricsName + ": " + startTime + ", " + endTime + "," + elapsedMsTime + " ms")
}

@MeasureTime("michelfunction",printStats)
  private def callThis(x : Int) : Int = {
    Thread.sleep(x)
    x
  }

val x = callThis(400)
val y = callThis(500)

Custom output for metric michelfunction:<PHONE_NUMBER>411,<PHONE_NUMBER>812,401 ms
Custom output for metric michelfunction:<PHONE_NUMBER>833,<PHONE_NUMBER>334,501 ms

```

repository: michelnossin/silverback

repo_name: michelnossin/silverback


text:
2021 @aleperf

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Source: http://opensource.org/licenses/ISC

#### Credits

PLEASE NOTE: the original designs and images (where not differently specified) are from [Frontend Mentor](https://www.frontendmentor.io) and not owned by the author of this software.
The social icons (facebook, twitter and instragram) are from [Font Awesome](https://fontawesome.com/)

license: ISC

repository: aleperf/fylo-dark-theme-landing-page

branch_name: refs/heads/main

repo_name: aleperf/fylo-dark-theme-landing-page


text:
## Cloud Functions
Have a read at https://docs.microsoft.com/en-us/azure/azure-functions/functions-create-first-java-gradle

```bash
./gradlew :functions:build
```

Run the function locally
```bash
./gradlew :functions:jar --info
./gradlew :functions:azureFunctionsRun
```

Deploy manually to Azure
```bash
./gradlew :functions:azureFunctionsDeploy
```

repository: lrohner/microservice-kubernetes-cluster

repo_name: lrohner/microservice-kubernetes-cluster


text:
## Advanced Lane Finding
[![Udacity - Self-Driving Car NanoDegree](https://s3.amazonaws.com/udacity-sdc/github/shield-carnd.svg)](http://www.udacity.com/drive)

The Project
----

The goals / steps of this project are the following:

* Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.
* Apply a distortion correction to raw images.
* Use color transforms, gradients, etc., to create a thresholded binary image.
* Apply a perspective transform to rectify binary image ("birds-eye view").
* Detect lane pixels and fit to find the lane boundary.
* Determine the curvature of the lane and vehicle position with respect to center.
* Warp the detected lane boundaries back onto the original image.
* Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.

Software Requirements
-------
     The project is done using python 3.6.2.
     OpenCV version 3.1.0 is used.
Python version less than 3.6.0 will not work properly because in my code I used f-string which is a new feature.

Folder Specification
-------
    1. The images for camera calibration are stored in the folder called camera_cal.
    2. The images in test_images are for testing pipeline on single frames.
    3. The outputs after finding the chase board corner are in camera_cal_output.
    4. The binary outputs after color and gradient transformation of test_images
       are in test_images_transformed folder.
    5. The binary outputs after bird's eye view perspective transform of test_images
       are in test_images_wraped folder.
    6. The test_output folder contains all the test images after applying final pipeline function.
    7. Resources folder contains some images for purpose of writing README.md file.
    8. The output video after applying the pipeline to project_video.mp4 is output.mp4.

**Note**: All codes are self explanatory. Comments and function documentation has been given where needed.

#### Finding chess board corner
---

**The code for this step is contained in the fourth code cell of the IPython notebook advanced_lane_finding.ipynb.**

I start by preparing "object points", which will be the (x, y, z) coordinates of the chessboard corners in the world. Here I am assuming the chessboard is fixed on the (x, y) plane at z=0, such that the object points are the same for each calibration image.  Thus, `objp` is just a replicated array of coordinates, and `objpoints` will be appended with a copy of it every time `cv2.findChessboardCorners()` detects all chessboard corners in a test image.  `imgpoints` will be appended with the (x, y) pixel position of each of the corners in the image plane with each successful chessboard detection.

Then draw the chess board corners by `cv2.drawChessboardCorners()`. Here is an example of chessboard corner drawn .

**Chess Board Corners**

![Image](./resources/chsbrdcrnr.png)

#### Calibrating camera and calculation of camera matrix and distortion coefficients
`undistort_image()` function is used to undistort a image, the previous output `objpoints` and `imgpoints` have been used
to compute the camera calibration and distortion coefficients using the `cv2.calibrateCamera()` function.  I applied this distortion correction to the input image using the `cv2.undistort()` function .

**Undistorted Chess board image**

![Undistorted Chess Board](./resources/undist_chsbrd.png)

### Pipeline (single images)
---

#### Example of distortion corrected image.

To demonstrate this step, I will describe how I apply the distortion correction to one of the test images like this one:

**Undistorted test image**
![Undistorted Test](./resources/undist_testimg.png)

#### Applying gradient and color thresolding
I used a combination of color and gradient thresholds to generate a binary image .

        1. compute the sobel magnitude  then take a thresolding range b/w 20 and 255.
        2. select_yellow() and select_white() aretwo functions to extract the yellow
           and white lane lines the combine it by bitwise or.
        3. Then combine it with sobel magnitude calculated.

**Transformed image after applying gradient and color thresolding**
![Thresolded Image](./resources/trnsfrm.png)

#### Perspective transformation and getting a birds eye view perspective

I used a `wrap()` function to get a birds eye view using perspective transform. It takes an image , source points and destination points and returns the wraped image transformation matrix and it's inverse .

| Source        | Destination   |
|:-------------:|:-------------:|
| 710, 460      | 990,0         |
| 1090, 720     | 990, 720      |
| 200, 720      | 300, 720      |
| 580, 460      | 300, 0        |

I verified that my perspective transform was working as expected by drawing the `src` and `dst` points onto a test image and its warped counterpart to verify that the lines appear parallel in the warped image.

![Perspective Transform](./resources/birdseyeview.png)

#### Finding lane line pixel and fitting polynomial

     1. Divide the thresolded binary transformed image into n=9 horizontal strips of equal height.
     2. Compute the histogram of each strip using np.sum().
     3. Identify two peaks where histogram computed are maximums.

**Birds eye view of a test transformed image and histogram drawn**

![Image 1st](./resources/hist.png)
![Image 2nd](./resources/hist1.png)

     4. Get the pixels in that horizontal strip that have x coordinates close to the two
        peaks of x coordinates.

**Rectangles are drawn where lane line pixels are detected**

![Image 3rd](./resources/poslane.png)

     5. Fit a second order polynomial to each lane line using np.polyfit() function.

**Polynomial fitted to birds-eye-view image**

![Image 4th](./resources/poly1.png)
![Image 5th](./resources/ploy2.png)

#### Calculation of radius of curvature.

    left_curverad = ((1 + (2*left_fit_cr[0]*y_eval*ym_per_pix + left_fit_cr[1])**2)**1.5)\
                     / np.absolute(2*left_fit_cr[0])
    right_curverad = ((1 + (2*right_fit_cr[0]*y_eval*ym_per_pix + right_fit_cr[1])**2)**1.5)\
                     / np.absolute(2*right_fit_cr[0])

    curvature = (left_curverad + right_curverad)/2

#### Example on a test image.

The final `pipeline_func()` contains all the necessary steps for finding and plotting the lane lines. Here is an example of my result on a test image:

![Output Image](./test_output/test2.jpg)

---

### Pipeline (video)
I applied my `image_pipeline()` function to the project_video. It detect's lane lines reasonably well but under a
curved shadowed path it once showing some deviation.
**Here's the link of my [Output Video](./output.mp4)**

---

### Discussion
    This pipeline will not actually work rather than this project video. The source and destination
    points have been chosen manually for birds eye view perspective transformation. Which indeed
    is the most important step for finding lane line pixels.

    The color and gradient thresolding and identifying lane lines is a computing intensive work
    and a maximum speed of 1.5 iteration/s achieved in these case will not work in realtime.

    But this pipeline detects lane lines moderately well on different colored , shaded highway path.


text:
# ComplexVisual

A julia package for visualizing holomorphic and meromorphic functions.

I used it for explanations in a complex analysis course in summer 2021.

## Why this package?

I wanted

* to try out some programming concepts (e.g. [composition](./docs/composition.md))
  with julia
* to have a tool for interactively showing/explaining meromorphic functions
  (see [examples](./examples#user-content-examples))
* to have fun programming in julia

## How to install this package?

There is a very thin "layer" to show the functions in a `GtkDrawingArea` in a native window (using Gtk) in an extra package [ComplexVisualGtk.jl](https://github.com/luchr/ComplexVisualGtk.jl).

This package can also be used "standalone" (without windows and interactivity) to save the visualizations as images.

```julia
using Pkg
Pkg.add(PackageSpec(url="https://github.com/luchr/ComplexPortraits.jl", rev="master"))
Pkg.add(PackageSpec(url="https://github.com/luchr/ComplexVisual.jl", rev="master"))
Pkg.add(PackageSpec(url="https://github.com/luchr/ComplexVisualGtk.jl", rev="master"))
```

## Documentation

The layout concept, styles and painters and more are documented in the
[docs directory](./docs#user-content-overview) together with a index
of the functions/methods.

As so often, I hadn't time for more documentation. This is a open todo.

One remark: The documentation was prepared with my utility
[DocGenerator.jl](./docs/DocGenerator.jl) that I wrote, because I
wanted to have automatically generated cross references (without
an additional syntax), an easy syntax for the inclusion of doc-strings,
an easy syntax for the inclusion of parts of the source-code
and the simple generation of an index.  That escaleted quickly!


text:
# FIND ME | SOUTH AFRICA
Is a location based application, designed to help courier services, more accurately, find client locations.

- A user signs up
- Then chooses their exact location on a local map that packages will be delivered to (user must agree to location services)
- A QR code is then generated that when scanned takes the deliverer of your package to a page that shows the exact location to be delivered to, as well as a means to contact the client by call or whatsapp.

repository: chaddanker/find-me

repo_name: chaddanker/find-me


text:
Box Model Test

 Testing the box model in css - 5/28/20

A brief test of the box model function in css to ensure proper knowledge and ease of use is brought forward

Installation Requirements

None

Known Bugs

None

For support please contact<EMAIL_ADDRESS>
Technologies Used
VisualStudioCode

## License
MIT

repository: Zentraxius/boxmodel

repo_name: Zentraxius/boxmodel


text:
---
name: Feature add proposal
about: If you're contributing to this repo, do use this and make a PR
title: "[FIX]"
labels: 'Status: :vertical_traffic_light: Awaiting'
assignees: alphaX86

---

### Describe what actually your code does
<!-- Content here -->

### Does it pass all tests in PR?
<!-- Yes or No -->

### Does this close any issue? If so please, mention using #<Issue no>
<!-- Answer here -->


text:
## SN74LS47N BCD-To-Seven Segment Decoder/Driver
### Pins defintion
  - BI = Blanking input(BI)/Ripple blanking output(RBO)
  - RBI = Ripple blanking input
  - LT = Lamp test
  - Pins D_PIN=11, C_PIN=10, B_PIN=9, A_PIN=8, RBI_PIN=7, BI_PIN=6, 	LT_PIN=5

		int pins[8]={5, 6, 7, 8, 9, 10, 11,0};

  ### Characters and operating modes
   - Operation RBI: turns off the segments. It needs
     LT pin set to HIGH and everything else set to LOW

   - Operation BI: turns off the segments. It needs
     BI pin set to LOW regardless of the state of any other pin

   - Operation LT: turns on all segments (test mode). It needs
     LT pin set to LOW and BI pin set to HIGH

    enum{
          CHAR_0=0, CHAR_1=1, CHAR_2=2, CHAR_3=3, CHAR_4=4,
          CHAR_5=5, CHAR_6=6, CHAR_7=7, CHAR_8=8, CHAR_9=9,
          CHAR_10=10, CHAR_11=11, CHAR_12=12, CHAR_13=13,
          CHAR_14=14, CHAR_15=15, OP_BI=16, OP_RBI=17, OP_LT=18 };

- Pins states expressed in bits from least significant bit (right most)
  to most significant bit (left most) according to the order they are
  connected to the arudino, which is defined in the enum above, **for example:**
#### character 0 = 0b0000111

|0b|0|0|0|0|1|1|1|
| :----: |  :----: | :----: | :----: | :----: | :----: | :----: | :----: |
||D|C|B|A|RBI|BI|LT|

#### character 1 = 0b0001x11

|0b|0|0|0|1|x|1|1|
| :----: | :----:| :----: | :----: | :----: | :----: | :----: | :----: |
||D|C|B|A|RBI|BI|LT|

* note: x means that the IC does not care about the state of that pin


text:
## Intent
Balking Pattern is used to prevent an object from executing certain code if it is an
incomplete or inappropriate state

Balking Pattern用于防止对象在状态不完整或不适当时执行某些代码

![alt text](etc/balking.png "Balking")

## Applicability
Use the Balking pattern when

* you want to invoke an action on an object only when it is in a particular state
* objects are generally only in a state that is prone to balking temporarily
but for an unknown amount of time

在以下情况下使用Balking模式

* 您只想在对象处于特定状态时才对其调用操作
* 对象通常仅处于易于暂时停止但状态未知的状态

## Related patterns
* Guarded Suspension Pattern
* Double Checked Locking Pattern

repository: shoukai/pattern-journey

gha_language: Java

repo_name: shoukai/pattern-journey


text:
# What is it?
This is a simple clock works by moment.js.
The project made for my study.

![Animation](https://user-images.githubusercontent.com/57584264/120002558-eb521680-c00f-11eb-83db-834cce17882b.gif)

# Installation
Download index.html and open a web blowser.
Or access [Github pages](https://ykaito39.github.io/web-mini-projects/moment/).

# Lisence
This project is licensed under the MIT License.


text:
---

layout: recipe
title:  "Pumpkin and Peanut Curry"
image: pumpkin-peanut-curry.jpg
tags: vegan main

ingredients:
- 100g raw peanuts, roasted, skinned and crushed (or use crunchy peanut butter)
- 1 tbsp tomato purée
- Zest and juice of 1 lime
- 1 tbsp soy sauce
- 1 tsp sugar
- ---
- Small handful fresh coriander, with roots (if possible)
- 2 red chillies, halved and deseeded
- 4 garlic cloves
- 1cm piece fresh ginger
- ---
- 2 tbsp vegetable oil
- 2 red onions, cut into thin wedges
- 800g pumpkin or butternut squash, peeled, deseeded and roughly diced
- 400ml can coconut milk

directions:
- Stir the crushed peanuts into a jug containing 100ml hot water. Stir in the purée, lime zest and juice, soy or fish sauce and sugar. Set aside.
- Remove the leaves from the coriander and set aside. Chop the stalks and roots as finely as you can, along with the chilli, garlic and ginger.
- Heat the oil in a wok or good-sized pan and fry the onions quite briskly for a few minutes, so that they catch slightly. As soon as this starts to happen, add the pumpkin and stir-fry for a few minutes. Stir in the chilli mixture for 1 minute, then add the coconut milk. Stir, then add the peanut mix. Cook at a brisk simmer for 15-20 minutes, until the sauce has thickened slightly and the pumpkin is tender. Season to taste or add more soy or fish sauce, as you like. Garnish with coriander leaves and serve with cooked rice.

comments:
- Serves 4.
---

Shown here with [Tofu Stir-fry](https://lynda365.github.io/tofu-stir-fry.html)

Source [Delicious Magazine](https://www.deliciousmagazine.co.uk/recipes/pumpkin-and-peanut-curry/)

license: Unlicense


text:
# Continuous Integration

## SonarCloud

80% code coverage is enforced, and coverage is currently over 90%. Security and static analysis checks (in addition to NET Analyzers) are checked via [SonarCloud](https://www.sonarsource.com/products/sonarcloud).

## Dogfooding

All analyzers are run on the code as part of the CI process. No analyzers are disabled. Violations block integration.

## Performance

The performance of all analyzers are measured as part of the dogfooding process, and reported in the Job Summary.
![image](https://user-images.githubusercontent.com/57269455/215766356-6d6ee7b8-5c15-474b-b69d-15291b2fa0b0.png)

## GitHub CodeQL

We also run GitHub's [CodeQL](https://codeql.github.com). (This is currently disabled as it has yet to find issues and significantly slows down the CI pipeline.)

## Markdown Links

Markdown links are checked for dead links.

## GitHub Action Version Pinning

All actions are pinned to the git SHA using [ratchet](https://github.com/sethvargo/ratchet).
Once versions are pinned, dependabot checks for updates.

## Prereleases

Every commit will create artifacts, 1 per Analyzer, having a 1 day retention period. The analyzers can be downloaded and tested with a local nuget.config file against repos as desired.  However, Prerelease versions of modified Nuget packages are also published with each commit.

GitHub Prereleases and Tags are not created with each merge to trunk.

# Deployments

To Deploy to production, manually invoke the [Prep for Release](https://github.com/philips-software/roslyn-analyzers/actions/workflows/prep-release.yml) workflow. This will create a PR containing automatic updates to one file, the CHANGELOG.md. Merging the PR will trigger creation of the following:
* GitHub Release
* GitHub Tag
* Nuget Release

repository: philips-software/roslyn-analyzers

gha_language: C#

repo_name: philips-software/roslyn-analyzers


text:
# $536. [中等] 从字符串生成二叉树

**题目链接：**[https://leetcode-cn.com/problems/construct-binary-tree-from-string](https://leetcode-cn.com/problems/construct-binary-tree-from-string)

---

<Cards card="leetcode_536_construct-binary-tree-from-string"></Cards>

---

```java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode str2tree(String s) {

    }
}
```

repository: gujiacun/Leetcode-Hub

repo_name: gujiacun/Leetcode-Hub


text:
# BatchProcessor
A lightweight cross-platform, cloud vendor independent library for Batch Processing in .NET Core (Initial commit, working prototype), part of a final project to achieve MSc in Advanced Software Engineering (distinction), @ University of Leicester, UK.

Initial version of Nuget packages can be found here:
https://www.nuget.org/profiles/mssawan

repository: sakher-sawan/BatchProcessor

repo_name: sakher-sawan/BatchProcessor


text:
# WHATWG Streams Reference Implementation Licensing

For the reference implementation and tests for the WHATWG Streams Standard.

This code is dual-licensed under CC0 and the MIT license. You can choose which one you want to use.

## CC0

To the extent possible under law, the authors have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty.

You should have received a copy of the CC0 Public Domain Dedication along with this software. If not, see https://creativecommons.org/publicdomain/zero/1.0/.

## MIT

Copyright (c) 2013–2015 Streams Standard Reference Implementation Authors

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.

repository: twovs/signature

repo_name: twovs/signature


text:
# About sections

*sections* is a Python package for calculating physical properties of planar
shapes. The physical properties include area, position of centre of gravity,
moments of inertia and more.

The package comes with several predefined basic shapes (e.g. polygon,
circle, rectangle, etc.) and some more complex shapes (e.g. I-profiles,
RHS-profiles). They can be easily combined to create any shape you might need.

The package depends on numpy and matplotlib for creating plots of the shapes.
Other than that there are no dependencies.

repository: iamlikeme/sections

repo_name: iamlikeme/sections


text:
# IITM Netaccess

This extension will help you do the verification in just one click.
1) Install the extension
2) Fill in all the details in options page. You can got to options page by right clicking the icon or from extensions menu.
3) Click the icon when you want to verify. Sit tight and wait, It might take 5-8 sec to complete the process.

### Update
- Usage will be shown right on top of the icon itself.
- You will be updated when you have 200MB left.
- Usage status will be updated every 15 minutes.

Please rate the extension in chrome webstore if you like it.\
[Link to the extension in chrome webstore]

### Version
2.5.0

License
-------

MIT

**Free Software, Hell Yeah!**

[//]: # (These are reference links used in the body of this note and get stripped out when the markdown processor does its job. There is no need to format nicely because it shouldn't be seen. Thanks SO - http://stackoverflow.com/questions/4823468/store-comments-in-markdown-syntax)

   [Link to the extension in chrome webstore]: https://chrome.google.com/webstore/detail/iitm-netaccess/njfilkfnapknliopadgeiopdhenfkape

repository: arunrdd/iitm-netaccess

repo_name: arunrdd/iitm-netaccess


text:
# lambdapack
Bundles modules for the AWS Lambda Node.js runtime (using webpack).

## Overview

lambdapack simply mechanizes running webpack with the configuration needed
for the AWS Lambda Node.js runtime and then creating a zip file of the
webpack output.

Use for most Lambda function implementations is hopefully straightforward:

```
$ npm install -D @sspiff/lambdapack
$ node_modules/.bin/lambdapack
```

will install lambdapack and run it.  This should produce a zip file named
after the local package and containing the output from running webpack on
the local package entry point.  The webpack bundle file within the zip file
will have the same name as the entry point.

For example, with a `package.json` containing:

```
  "name": "my-lambda",
  "main": "index.js"
```

lambdapack will run webpack on `index.js` and produce `my-lambda.zip`
containing a webpack-bundled `index.js`.  `my-lambda.zip` is the deployment
package that should be uploaded to AWS Lambda, and the handler setting
for the Lambda would be `index.HANDLER` (where `HANDLER` is the name of a
function exported by `index.js`).

## Invoking lambdapack

### Synopsis:

node_modules/.bin/lambdapack
  [-o OUTZIP]
  [-MD [-MP] [-MF OUTDEPS]
       [-MT TARGET] [-MR SRCPREFIX] ]

### General Options:

`-o` *`OUTZIP`*

Use *`OUTZIP`* as the output zip file name.
Default is `` `${PACKAGE.name}.zip` ``.

### `make` Dependency Generation Options:

`-MD`

Enables `make` dependency generation.

`-MP`

Adds an empty phony target for each dependency.  This can prevent
errors from `make` if a dependency is later removed.

`-MF` *`OUTDEPS`*

Write the rules to the file *`OUTDEPS`*.  Defaults to the name of
the output zip file with `.d` appended.

`-MT` *`TARGET`*

The target to define in the generated rules.  Defaults to the name of the
output zip file.

`-MR` *`SRCPREFIX`*

Prepend *`SRCPREFIX`* to each dependency in the generated rules.  This can
be useful if lambdapack is invoked in a directory different from where
`make` is run.

## webpack Configuration

lambdapack uses the following default webpack configuration:

{
  mode: 'production',
  optimization: { minimize: false },
  entry: PACKAGE.main,
  output: {
    filename: path.basename(PACKAGE.main),
    path: '/zipcontents',
    libraryTarget: 'commonjs2'
  },
  target: 'node'
}

where `PACKAGE` is the contents of the local `package.json`.
The output zip file will be named `` `${PACKAGE.name}.zip` ``
(unless overridden by `-o`).

By default,`mode` is set to `production` to enable tree shaking, while
`optimization.minimize` is set to `false` to facilitate debugging in the AWS
console.

The webpack configuration parameters in **bold** are fixed.  Others can be
customized by including them in a block in `package.json`, for example:

```
  ...
  "lambdapack": {
    "webpack": {
      "optimization": { "minimize": true }
    }
  },
  ...
```

## `make` Dependency Generation

lambdapack is capable of outputting dependency information as rules for `make`
using the stats data provided by webpack.  This can be useful in AWS projects
with multiple lambdas that share common (but unpackaged) project-specific
modules.

The generated rules will include the zip file as a target with the webpack
bundle's assets' source files as the zip's dependencies.  However, any assets
from `node_modules` will be represented by a single dependency on
`node_modules` itself.

Dependency generation is configured using command line options.
See **Invoking lambdapack** above.

## Additional Notes

### ES6 and webpack Optimization

lambdapack is intended for use with ES6-style module imports and exports
(though their use may not be required).  It is known to work when the Lambda
handler is exported from the main/entry file as an ES6 named export.

For optimizing deployment package size, lambdapack relies entirely on related
features of webpack, including tree shaking.  As tree shaking requires ES6
module syntax, better results may be had with shake-friendly modules:
those that use `import`/`export` and that accurately advertise `sideEffects`.

**Note** that lambdapack enables webpack tree shaking but disables minimizing
by default (see **webpack Configuration** above).

### Build Reproducibility

Some AWS tooling, such as `aws cloudformation package`, uses hashes of
Lambda deployment packages to (effectively) determine if a function
implementation has changed and needs to be updated.

Zip archives have a timestamp for each file that they contain.  Even if the
constituent files' contents are identical, differences in the timestamps will
cause the overall zip file to appear different.  This can trigger unnecessary
CloudFormation updates to the Lambda function.

To mitigate this, lambdapack applies a fixed timestamp to the files in the
zip archive.  If the webpack output does not change from one run to the next,
the zip archives produced by lambdapack should be identical.

repository: sspiff/lambdapack

gha_language: JavaScript

gha_license_id: ISC

repo_name: sspiff/lambdapack


text:
# Router adapter

This package provides common classes for the ellipse router adapters.

**Require** php >= 7.1

**Installation** `composer require ellipse/router-adapter`

**Run tests** `./vendor/bin/kahlan`


text:
pseudonitzchia
==============

Biodiversity informatics code relevant to the Encyclopedia of Life

names_json_1.py
Version 1 of a program that uses the EOL and GNRD APIs to generate a list of species that
interact with each other. The theory behind this idea is that if a species is mentioned
in a text data object under the associations chapter of a taxon page, the mentioned
species can be assumed to have an interaction with the topic taxon. This version of the
program does not work on every taxon.

names_json_2.py
Version 2 is the same as Version 1, but it is cleaner (had some superfluous stuff
deleted) and works across all taxa.

eco_terms_all_json.py
Version 1 of a program that annotates EOL text objects with DBpedia URIs.

replace_dict.txt
Version 1 of a dictionary that is used by the names_json program.

biodict.txt
Version 1 of a dictionary that is used by the eco_terms_all_json program.

associations_all_revised.txt
The results from names_json_2.py only processing species level taxon pages. The numbers
represent EOL taxon IDs. The first column is the EOL taxon ID for the taxon page that was
mined. The second column is the EOL taxon ID for the taxon that was found in a text object
on the taxon page for the taxon in the first column. There is an implied interaction
between the two taxa in each row. The type of interaction is unknown.

Ready for discovery through http://globalbioticinteractions.org .

repository: EOL/pseudonitzchia

gha_language: Python

repo_name: EOL/pseudonitzchia


text:
# former

Simple transformer implementation from scratch in pytorch. See http://peterbloem.nl/blog/transformers for an in-depth
explanation.

# Limitations

The current models are designed to show the simplicity of transformer models and self-attention. As such
they will not scale as far as the bigger transformers. For that you'll need a number of tricks that
complicate the code (see the blog post for details).

All models so far are a single stack of transformer blocks (that is, no encoder/decoder structures). It
turns out that this simple configuration often works best.

# Use

You can clone the code and run the experiments from the root directory. E.g.

```
python experiments/classify.py
```

Hyperparameters are passed as command line arguments. The defaults should work well. The classification data is
automatically downloaded, the wikipedia data is included in the repository.

You should be able to install as a package as well, with
```
pip install git+https://github.com/pbloem/former
```
but I haven't tried this. It's probably easier to just copy over the code you need. Let me know if you need this for anything and it doesn't work.

## Requirements

Python 3.6+ is required.

The following should install all requirements
```pip install torch tb-nightly tqdm numpy torchtext```

You may also need
```pip install future```
depending on the exact python version.

### conda environment

The file ```environment.yml``` describes a complete conda environment with all dependencies. After cloning or downloading the project, you create the environment as follows:

```
conda env create -f environment.yml --name former
conda activate former
```

repository: jplasser/former

repo_name: jplasser/former


text:
# aao :: Sorting Algorithms Analysis
[para Português clique aqui](https://github.com/ddangelorb/aao/blob/master/README.md)

When we develop an algorithm to fix a problem it is essential to ask the quality of this algorithm, we should ask ourselves: Apart from fix the problem, does the algorithm take a reasonable execution time? How long does the algorithm execute and what is its complexity? How can we improve this algorithm? Algorithms Analysis Studies give us the answears to these questions in a teorical and pratical manner.

One important field of Algorithms Analysis Studies is Sorting Algorithms. There are many techniques around Sorting Algorithms with many studies in the last decades, improvements and even new proposals. This project aims to run experiments around Sorting Algorithms and its execution times using the methods: BinaryInsertionSort, BubbleSort, BucketSort, CountingSort, HeapSort,
InsertionSort, MergeSort, QuickSort, RadixSort e SelectionSort.

All documentation is written in Portuguese, but I do believe it's easy to figure out the methods and main idea here ;-)

Dependencies
------------
* [Java 8](https://docs.oracle.com/javase/8/docs/technotes/guides/install/install_overview.html)

Running experiment
------------
Assuming you already have Java 8 installed run the following commands.

    $ java -version
    $ git clone https://github.com/ddangelorb/aao.git
    $ mkdir bin
    $ javac -d bin -classpath aao/lib/\* aao/src/aao/algoritmos/*.java aao/src/aao/testes/*.java
    $ java -ea -Xms15g -Xmx15g -Xss5g -jar aao/lib/junit-platform-console-standalone-1.5.2.jar --class-path bin -c aao.testes.ExperimentosTests

Find out more
------------
The sorting algorithms source-code and tests are available [here](https://github.com/ddangelorb/aao/blob/master/src).

Technical documentation is available using javadoc [here](https://github.com/ddangelorb/aao/blob/master/doc/index.html).

Full documentation including all sorting algorithms explanation, javadoc and source-code is available [here](https://github.com/ddangelorb/aao/blob/master/doc_exp.pdf)

License
------------
MIT [license](https://github.com/ddangelorb/aao/blob/master/LICENSE)

Author
------

[Daniel D'Angelo R. Barros](https://github.com/ddangelorb)

repository: ddangelorb/aao

repo_name: ddangelorb/aao


text:
# Challenge

## Background

There is a publishing house, which publishes the "Layer Weekly" magazine. The management of the publishing house all of a sudden decided to switch their employees to fully remote positions. In the process of establishing how the company would handle it, the management came up with a solution to exchange articles by e-mail. Unfortunately, the process was long and error-prone, so the Editor in Chief decided that they need a collaboration tool to ease the process of drafting and publishing articles. "IT to the rescue"! — our story begins here.

## User Stories

1. As an editor in chief, I add a list of topics for the new edition of a magazine.
2. As a journalist, I submit a draft article for publishing to a given topic
3. As a copywriter, I suggest changes to the draft article I'm assigned to
4. As a journalist, I respond to suggestions by making the suggested changes
5. As a copywriter, I resolve suggestions that the journalist applied
6. As a journalist, I can publish the article after all suggestions are resolved

### Details

- An article is a simple text with a title and some headings
- The draft article:
    - needs to have title and content
    - can be connected to multiple topics
- Journalists cannot change each other's drafts
- Copywriters can only suggest changes to article they were assigned to.
- Suggested changes can be considered as comments to the whole article. They should be non-empty chunks of text.
- Once the article is published, suggestions are no longer allowed.

## Task

In your preferred language write an application that covers 3 of the user stories from above. You can choose freely which ones you want to implement.

## **Evaluation criteria**

The most important part for us is the domain model. We appreciate DDD solutions. Technology stack is up to you but please remember that it's not the technicalities that impress us.

Consider the challenge as you would do it at work, with all best practices you know. Feel free to use any input for the domain logic you feel is needed. API, CLI, Acceptance tests etc.

### What we judge

- Your modelling skills. Is it possible to understand the problem from the code?
- You follow best practices appropriate to your language of choice
- Code is organised, clean and readable.
- Code is maintainable.

### What is irrelevant

- We don't judge GUI so please do not focus on that.
- Your implementation can stop at application level. Do not focus on the REST or GraphQL controllers.
- Please do not focus on persistence or database. If you wish it also can be skipped altogether.

## Steps

- First, think about a challenge, and before you start coding [schedule a 20 minute check-in call](https://meetings.hubspot.com/ernests/20-minute-check-in) with Ernests to go through questions you might have and present your approach to the challenge.
- Also, during the call we will expect you to tell us when you will send in the result. However, faster is not necessarily better. The time you take won't affect the evaluation.
- The challenge itself shouldn't take more than 6 hours in total of your time.

## Deliverables

- **Create a private repository** on GitHub (they are free). When you finish the challenge, invite `bez4pieci` as a collaborator to the repository you created and send a notification e-mail to [careers<EMAIL_ADDRESS>(reply to the email where you received the code challenge).
- Write your solution in code, and use multiple commits.
- It is not required but if you like you can attach all documents, mockups, or diagrams which help you develop the code.
- We will appreciate additional information about
    - how you gathered all required information for architecting the domain model
    - how you came up with assumptions

Happy solving!

repository: amolrv/layer-assignment

repo_name: amolrv/layer-assignment


text:
## Query Metric Service

[![Apache License][li]][ll] ![Build Status](https://github.com/NationalSecurityAgency/datawave-query-metric-service/workflows/Tests/badge.svg)

The Query Metric service allows query services to store and update query metrics.
Callers must have the Administrator role to call either updateMetric operations.
When running multiple service instances and using a Hazelcast cache, successive metric updates
can be made on any of the service instances.

Any user can call the id/{queryId} operation, but users who do not have the metric admin role
can only retrieve a query metric for a query that they ran.

### Query Metric API V1

*https://host:port/querymetric/v1/*

| Method | Operation     | Description                           | Request Body                |
|:---    |:---           |:---                                   |:---                         |
| `POST` | updateMetric  | Update a single BaseQueryMetric       | BaseQueryMetric             |
| `POST` | updateMetrics | Update a list of BaseQueryMetric      | List<BaseQueryMetric> |
| `GET`  | id/{queryId}  | Retrieve a BaseQueryMetric by queryId | N/A                         |

* See [QueryMetricOperations](src/main/java/datawave/microservice/querymetric/QueryMetricOperations.java)
  class for details

---
### Design

The Query Metric service is designed so that metric updates can be sent to any running instance of
the service.  This is accomplished by using two Hazelcast distributed map data structures.

- incomingQueryMetrics - A write-behind String-BaseQueryMetric map where metrics are placed as
soon as they are received.  When a new metric is received, this map is llocked and checked for
an existing entry.  The new metric is combined with any existing entry (PageMetrics can get lengthy and
are often truncated) and then placed in the map.  The write-behind feature allows several quick updates
to take place for each Accumulo write.  A configured MapStore is periodically called on one of the service
instances to write updated metrics to Accumulo.  It can also retrieve a metric from Accumulo that is asked for
but missing from the map.

- lastWrittenQueryMetrics - A read-through String-BaseQueryMetric map that is used by incomingQueryMetrics's
MapStore to determine which keys in Accumulo need to be deleted when a new metric is written to Accumulo. As a
read-through map, it can retrieve a metric from Accumulo that is asked for but missing from the map.

---

### Getting Started

1. First, refer to [services/README](https://github.com/NationalSecurityAgency/datawave-microservices-root/blob/master/README.md#getting-started)
   for launching the config service.

2. Launch this service as follows:

   ```
   java -jar target/query-metric-service*-exec.jar --spring.profiles.active=dev
   ```

   See [sample_configuration/querymetric-dev.yml.example](https://github.com/NationalSecurityAgency/datawave-microservices-root/blob/master/sample_configuration/querymetric-dev.yml.example)
   and configure as desired.

[li]: http://img.shields.io/badge/license-ASL-blue.svg
[ll]: https://www.apache.org/licenses/LICENSE-2.0

repository: billoley/datawave-query-metric-service

repo_name: billoley/datawave-query-metric-service


text:
## Facebook-User-Information

[![forthebadge](http://forthebadge.com/images/badges/made-with-python.svg)](http://forthebadge.com) [![forthebadge](https://forthebadge.com/images/badges/for-you.svg)](https://forthebadge.com)

[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=shields)](http://makeapullrequest.com) [![MIT Licence](https://badges.frapsoft.com/os/mit/mit.png?v=103)](https://opensource.org/licenses/mit-license.php) ![Python](https://img.shields.io/badge/python-3.6-blue.svg)

![GitHub open pull requests](https://img.shields.io/github/issues-pr/ujjaldas132/facebook-User-Information.svg)
![GitHub open issues](https://img.shields.io/github/issues/ujjaldas132/facebook-User-Information.svg)

[![forthebadge](https://forthebadge.com/images/badges/check-it-out.svg)](https://forthebadge.com)

> **Know how you use FACEBOOK.**

## Table of Contents

- [Facebook-User-Information](#Facebook-User-Information)
  - [Table of Contents](#table-of-contents)
  - [Getting the data](#getting-the-data)
  - [How To Use](#How-To-Use)
    - [Posts](#Posts)

  - [Contributing](#contributing)
  - [Features](#features)
    - [Your Posts](#Your-posts)
  - [Observations](#observations)
  - [Why](#why)
  - [License](#license)

## Getting the data

1.  Head on to [Facebook > Settings > General Settings > Your facebook information](https://www.facebook.com/settings?tab=your_facebook_informations).

2. Download the file as JSON file.

  ## How To Use
  Install requirements with `pip install -r requirements.txt`

  ### Posts

   > Updated soon

  ## contributing
  > Updated soon

 ## features
 > Updated soon

 ### Your posts
 > Updated soon

 ## observations
 > Updated soon

 ## why
 > Updated soon

 ## license
 The MIT License (MIT) 2018 - [Ujjal Das](https://github.com/ujjaldas132). Please have a look at the [LICENSE](LICENSE) for more details.

repository: gitter-badger/facebook-User-Information

repo_name: gitter-badger/facebook-User-Information


text:
##Tech-Blog

##Colors
###d3d3d3
###242424

##Template
Start Bootstrap - Grayscale

##Assembly
To generate the website, run the "build.py" file. This will generate the site
from the files within /content, apply the template to these html files from
/templates and inject specific values to update the title of each page. It then
publishes those files into the /docs directory where the site is housed.

repository: deScriber/Tech-Blog

gha_language: HTML

repo_name: deScriber/Tech-Blog


text:
# Change Log

Notable changes to this repository are documented in this file.

This project adheres to semantic versioning.

## [0.4.1] - 2021-01-30

Improves documentation

### Changed

### Added

- Better documentation:
  - install instructions
  - clearer options
  - roadmap features
  - tested code snippets

### Fixed

- Fixed `no-import-allowed` documentation.

### Chore

## [0.4.0] - 2020-01-26

Allows the package to be used in projects.

### Changed

### Added

- Added the main export for using the rules.

### Fixed

- Fixed `no-import-allowed` documentation.

### Chore

## [0.3.0] - 20201-01-25

Added the `no-import-allowed` rule.

### Changed

### Added

- `no-import-allowd`

### Fixed

### Chore

## [0.2.1] - 20201-01-25

Fixed documentation inaccuracies regarding options for `no-inter-module-imports`.

### Changed

### Added

### Fixed

- fixes documentation in `no-inter-module-imports`
- changed `prepublish` to `prepare` in `package.json`

### Chore

## [0.2.0] - 2021-01-25

### Changed

### Added

- `no-inter-module-imports`

### Fixed

### Chore

- Roadmap of future features added to changelog
- Adds tooling for pre-publish validation

## [0.1.0] - 2021-01-25

Added `no-parent-imports` and development tooling

### Changed

### Added

- `no-parent-imports`
- ESLint as a dev dependency
- Prettier as a dev dependency
- Mocha as a dev dependency

### Fixed


text:
# _next-tinacms-github_

This package provides helpers for managing the **GitHub auth token** for requests, as well as
providing helpers for **loading content from the Github API**.

## Installation

```bash
yarn add next-tinacms-github
```

Any functions in the `pages/api` directory are mapped to `/api/*` endpoints. The below helpers tend to be added to the `pages/api` directory in a Next.js project.

### `authHandler`

Helper for creating a `authHandler` server function.

**pages/api/create-github-access-token.ts**

```js
import { createAuthHandler } from 'next-tinacms-github'

export default createAuthHandler(
  process.env.GITHUB_CLIENT_ID,
  process.env.GITHUB_CLIENT_SECRET,
  process.env.SIGNING_KEY
)
```

_See [Next's documentation](https://nextjs.org/docs/api-reference/next.config.js/environment-variables) for adding environment variables_

[See here](https://tinacms.org/guides/nextjs/github-open-authoring/github-oauth-app) for instructions on creating a Github OAuth App to generate these **Client ID** & **Client Secret** variables and setting up the **Signing Key**.

### `apiProxy`

Proxies requests to GitHub, attaching the GitHub access token in the process.

**pages/api/proxy-github.ts**

```ts
import { apiProxy } from 'next-tinacms-github'

export default apiProxy(process.env.SIGNING_KEY)
```

### `previewHandler`

Handles setting the the Nextjs [preview data](https://nextjs.org/docs/advanced-features/preview-mode) from your cookie data.

**pages/api/preview.ts**

```ts
import { previewHandler } from 'next-tinacms-github'

export default previewHandler(process.env.SIGNING_KEY)
```

### Loading content from Github

The `preview` data, which gets set by calling your [preview function](#previewhandler), will be accessible through `getStaticProps` throughout your app.

Below is an example of the conditional data fetching, from the local environment or _Working GitHub Repository_ based on the preview environment:

**/blog/slug.ts**

```ts
import {
  getGithubPreviewProps
  parseMarkdown,
} from 'next-tinacms-github'

// ...

export const getStaticProps: GetStaticProps = async function({
  preview,
  previewData,
  ...ctx
}) {
  if (preview) {
    return getGithubPreviewProps({
      ...previewData,
      fileRelativePath: 'src/content/home.json',
      parse: parseMarkdown
    });
  }
  return {
    props: {
      error: null,
      preview,
      file: {
        fileRelativePath: 'src/content/home.json',
        data: (await import('../content/home.json')).default,
      },
    },
  };
}
```

### _getGithubPreviewProps_

The `getGithubPreviewProps` function accepts this preview data:

```ts
interface PreviewData<Data> {
  github_access_token: string
  working_repo_full_name: string
  head_branch: string
  fileRelativePath: string
  parse(content: string): Data
}
```

It then fetches the content from the _Working GitHub Repository_ and returns a `props` object with this shape:

```js
return {
  props: {
    file,
    repoFullName: workingRepoFullName,
    branch: headBranch,
    preview: true,
    error,
  },
}
```

#### _getGithubFile

In some cases you'll need to load multiple files from Github. For this reason the underlying `getGithubFile` function is exposed, which uses the same interface as `getGithubPreviewProps`.

```ts
import {
  getGithubFile,
  parseJson,
  parseMarkdown,
} from 'next-tinacms-github'

export const getStaticProps: GetStaticProps = async function({
  preview,
  previewData,
  ...ctx
}) {
  const githubOptions = {
    working_repo_full_name: previewData?.working_repo_full_name || 'https://github.com/youre/respository',
    head_branch: previewData?.head_branch || 'master',
    github_access_token: previewData?.github_access_token || '',
  }

  const homeFile = await getGithubFile({
    ...githubOptions,
    fileRelativePath: "content/index.md
    parse: parseMarkdown
  })

  const navigationFile = await getGithubFile({
    ...githubOptions,
    fileRelativePath: "data/navigation.json
    parse: parseJson
  })

  return {
    preview,
    homeFile,
    navigationFile,
  }
}
```

### Parsing Data

`next-tinacms-github` provides two content parsing options available, for Markdown — `parseMarkdown` or JSON — `parseJson`. Or you could pass in a custom parser.

## _NextGithubMediaStore_

`next-tinacms-github` includes a media store for managing media files with GitHub. Based on [GithubMediaStore](https://tinacms.org/packages/react-tinacms-github/#githubmediastore), it includes **logic for serving uploads from the `public/` directory**.

This media store is initialized similar to `GithubMediaStore`:

```ts
import { TinaCMS } from 'tinacms'
import { GithubClient } from 'react-tinacms-github'
import { NextGithubMediaStore } from 'next-tinacms-github'

const githubClient = new GithubClient({
  proxy: '/api/proxy-github',
  authCallbackRoute: '/api/create-github-access-token'
  clientId: process.env.GITHUB_CLIENT_ID,
  baseRepoFullName: process.env.REPO_FULL_NAME
})

const mediaStore = new NextGithubMediaStore(githubClient)

const cms = new TinaCMS({
  apis: {
    github: githubClient // equivalent to cms.registerApi('github', githubClient)
  },
  media: mediaStore
})

```

### _previewSrc_

_NextGithubMediaStore_ handles `previewSrc` so you **shouldn't need to set this** on individual image fields. However, if you do need to override `previewSrc` for a specific field, you need to get the full url to the source GitHub repository. The return value should connect to an actual path in a GitHub repo where the image is hosted.

```js
// Exmaple image field config
const formOptions = {
  fields: [
    {
      label: 'Hero Image',
      name: 'frontmatter.hero_image',
      component: 'image',
      parse: media => `/${media.filename}`,
      uploadDir: () => '/public/',
      previewSrc: fieldValue => {
        const githubClient = useGithubClient()

        return githubClient.getDownloadUrl(path.join('public', fieldValue))
      },
    },
  ],
  //...
}
```

> The reason why the full GitHub url needs to be provided is that new images are uploaded to the repository on a particular branch. If you are working locally, this can be a bit confusing because the path saved to the source file will be different than this `previewSrc` url. Remember when developing locally with this package that `previewSrc` urls are connecting to GitHub repository and not your local file paths.

You still need to set uploadDir to 'public' if you want the media manager to open directly from that folder, otherwise it will open from and upload to the repository root.

repository: bshackelford/tinacms

repo_name: bshackelford/tinacms


text:
![RoboND](https://camo.githubusercontent.com/0f51a1a655e13e62c95e95dfe5850bf2c20b1dd6/68747470733a2f2f73332d75732d776573742d312e616d617a6f6e6177732e636f6d2f756461636974792d726f626f746963732f45787472612b496d616765732f526f626f4e445f666c61672e706e67)

NASA Search and Sample Return
---
[//]: # (Image References)

[image1]: ./misc/rover_image.jpg
[image2]: ./calibration_images/example_grid1.jpg
[image3]: ./calibration_images/example_rock1.jpg
[vision]: ./misc/rover_vision.png
[notebook]: ./misc/rover_notebook.png
[formulas]: ./misc/sample_formulas.png

![alt text][image1]

### **Autonomous Navigation / Mapping**

#### Notebook Analysis

The Jupyter notebook contains methods for robotic perception. In each step this perception method splits the area into
drivable part (pink), part with obstacles (blue) and samples (green):

[![Video](misc/rover_notebook.PNG)](https://raw.githubusercontent.com/squared9/Robotics/master/Rover-Search_and_Sample_Return/output/test_mapping.mp4)

**Notebook implementation:**

*process_image()* was extended to do the following:

- find drivable area & corresponding mask based on RGB threshold corresponding to expected drivable surface
- find obstacle area that is negative of drivable area
- all drivable pixels were converted to rover-centric and then to world coordinates and added to map's channel 2
- all obstacle pixels were converted to rover-centric and then to world coordinates and added to map's channel 0
- all samples that might have been on the screen are found using *mark_rocks()* method
- the sample pixel whose world coordinates are closest to rover is taken and set on map's channel 1
- all three detected channels from the current rover camera image are displayed in the bottom right corner
- additional stats are displayed over the bottom right corner

A new method *mark_rocks()* was added that searches for all pixels that might be samples.

Method *perspect_transform()* was extended to return binary mask of thresholded pixels as well.

#### Autonomous Navigation and Mapping

The perception and mapping works as depicted on the following picture:

![vision][vision]

- rover's camera observes the world
- camera image is projected to a "map" view with fidelity decreasing by the distance from rover
- map view image is then thresholded by color corresponding to drivable area
- all possible driving angles are considered and their median is taken as a current direction

#### Autonomous mode

![alt text][image2] ![alt text][image3]

**The following principles were used for reasonably working autonomous mode:**

- the driving direction selection was based on the median angle from all unhindered angles
- when vehicle goes into looping mode, after a certain number of frames (if it either turns only left or only right)
  it is forced to drive forward for a certain number of frames
- if the vehicle slows down considerably for a certain number of frames, it is assumed it got stuck and
  it is forced to rotate in one random direction for a random number of frames. This should allow vehicle to
  get "unstuck" after a while
- when rover is near a sample to collect, its steering angle is influenced by required angle to reach the sample
  exponentially; the following formula depicts the computation:
  ![formulas][formulas]

  where yaw is the rover's yaw angle, sample_angle is the angle from rover to sample, sample_distance
  is the distance from the rover to the sample and median_angle is the median angle from all possible drivable angles.
  This formula should help reaching samples and overriding dominant median angle selection while not affecting
  steering when distance from nearest sample is large
- to maintain required fidelity, only a narrow range of roll and pitch values are allowed to contribute to mapping

**Implementation:**

Method *perception_step()* in *perception.py* is composed the following way:

- at **line 107** fidelity of the mapping is ensured by restricting effective roll and pitch angle to a tiny range
- from **line 115** source and destination is defined that is used to prepare a helicopter view of the world around rover
- at **line 122** the camera image is projected to helicopter view and a corresponding binary mask of effective area is obtained as well
- at **lines 125** and **126** drivable area and obstacle (negative) area are estimated using RGB thresholds
- at **line 133** and **134** rover's vision image is updated; the channel 0 with obstacles and channel 2 with drivable area
- at **lines 138** and **139** both drivable areas and obstacles are converted to rover-centric coordinates
- at **lines 145** and **146** are these converted to world coordinates
- from **line 153** if fidelity is high the world map is updated with both obstacles (channel 0) and drivable areas (channel 2)
- at **line 162** the drivable area's rover-centric coordinates are converted to polar coordinates and set to a rover's property
- from **line 166** the samples are first detected with **mark_rock()**, then the nearest rock's coordinate is picked
and world map (channel 1) updated (if fidelity is high)

Method *decision_step()* in *decision.py* is structured as follows:

- from **line 71** it uses new method *nearest_sample()* to find which detected sample is nearest to rover, disregarding
 locations of already picked samples
- from **line 77** the code handles the situation when rover is considered to be stuck at place. In such case rover
turns in the prescribed direction (see next description) for prescribed duration. Rover is expected to be in 'stop_slow'
mode and after time expires, it moves to 'forward' mode
- from **line 89** there is a detection if rover indeed is stuck for some time period. In such case the mode changes
 to 'stop_slow', turn direction as well as turn duration is randomly chosen and rover is expected to begin turning in
 order to recover
- from **line 103** the rover is recovering from a cycle; at the end of cycle it moves back to 'forward' mode
- from **line 115** there is a sample nearby; rover tries to apply brake and disengage throttle
- from **line 121** rover stands still near a sample and is initiating a pick up
- from **line 128** rover counts number of consecutive left and right turns in order to detect a cycle
- from **line 138** the code tries to detect if rover ended up in  a cycle; this can happen if there are many consecutive
turns in exactly one of left or right direction. In such case rover is set to mode 'force_forward' and is expected
to drive forward for certain number of frames
- from **line 150** rover is deciding on the next direction; by default it tries to take average angle of all available
 directions; however if there is insufficient number, rover moves to the 'stop' mode at **line 177**. The interesting
 part here starts from **line 171** where direction to nearest sample influences rover exponentially the closer
 to a sample it is
- from **line 187** rover handles standing still and it first applies brakes to stop from **line 190**, tries
 to turn around from **line 197** if there is insufficient number of available forward directions, or sets the mode
 to 'forward' from **line 205** if there is a sufficient number of available forward directions at the current yaw angle

**Issues:**

- sometimes rover gets stuck for a long while until it releases itself
- sample localization is rather inaccurate, causing issues while trying to pick up samples
- path planning is very inaccurate; clothoids with velocity would be much better for that
- rover often drives back to already explored parts of map due to topography and its preference of median angles
- some parts of the map are difficult to navigate due to small gradient between obstacles and road


text:
# Lepiota cristulata Rick SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Brotéria 18(2): 48 (1920)

#### Original name
Lepiota cristulata Rick

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# WIP: Contactsd (for macOS)

A small daemon and utility that help to export adata from the macOS contacts
application. Allows direct access to all contacts, their vcards, photos and
details in json format.

**TODO:**

- Make it daemonize
- Secure it using a secret
- Export group information as well

## Usage

Simply start the daemon using

    nohup ./exe/contactsd &

Goto [http://localhost:5000/](http://localhost:5000/) and explore the RESTful
API.

More information on configuration can be found using:

    ./exe/contactsd help
    ./exe/contactsd help serve

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'contactsd'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install contactsd

## Development

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

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

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/threez/contactsd.

repository: threez/contactsd

repo_name: threez/contactsd


text:
# Stack MEVN with authentication - Backend

This backend use authentication with access tokens using JWT. Besides, use Refresh Tokens for refresh the access tokens. All tokens are stored via httpOnly cookies.

## Installation
This project use npm for packet management. For install al dependencies run in a terminal
```bash
npm install
```

## Initial configuration
Copy `.env.example` to `.env` and modify the variables.
```bash
MONGO_URI= # URI for mongo connect. Ex. mongodb://localhost:27017/database
JWT_SECRET= # String used for sign JWT tokens. This must be a strong string
COOKIE_SECRET= # String used for sign cookies. This must be a strong string
PORT= # Port number to listen on. Ex. 3000
```

## Start project

For start the project in developer mode you can run in a terminal
```bash
npm run dev
```
For production mode run
```bash
npm start
```

# License
This project use [Apache License V2](./license)

repository: DarkMaper/mevn-jwt-backend

repo_name: DarkMaper/mevn-jwt-backend


text:
### 2015-04-26

#### objective-c
* [
      KittenYang
      /
      KYGooeyMenu
](https://github.com/KittenYang/KYGooeyMenu):
      Gooey Effects 带粘性的扇形菜单

* [
      JV17
      /
      JVMenuPopover
](https://github.com/JV17/JVMenuPopover):
      Simple popover menu in Objective-C

* [
      forkingdog
      /
      UITableView-FDTemplateLayoutCell
](https://github.com/forkingdog/UITableView-FDTemplateLayoutCell):
      Template auto layout cell for automatically UITableViewCell height calculating

* [
      nst
      /
      RuntimeBrowser
](https://github.com/nst/RuntimeBrowser):
      Objective-C Runtime Browser, for Mac OS X and iOS

* [
      shaojiankui
      /
      IOS-Categories
](https://github.com/shaojiankui/IOS-Categories):
      IOS中的各种Category, A collection of useful categories extending functionality of some built in iOS and Cocoa objects

* [
      CoderMJLee
      /
      MJExtension
](https://github.com/CoderMJLee/MJExtension):
      The fastest, most convenient and most nonintrusive conversion between JSON and model. Your model class don't need to extend another base class. You don't need to modify any model file. Nonintrusive, convenient.

* [
      Huohua
      /
      HHRouter
](https://github.com/Huohua/HHRouter):
      Yet another URL Router for iOS.

* [
      forkingdog
      /
      UIView-FDCollapsibleConstraints
](https://github.com/forkingdog/UIView-FDCollapsibleConstraints):
      Builds to collapse a view and its relevant layout constraints, simulating a "Flow Layout" mode

* [
      LoganWright
      /
      Genome
](https://github.com/LoganWright/Genome):
      A set of classes meant to simplify mapping models to and from json!

* [
      boycechang
      /
      BCMagicTransition
](https://github.com/boycechang/BCMagicTransition):
* [
      ResearchKit
      /
      ResearchKit
](https://github.com/ResearchKit/ResearchKit):
      ResearchKit is an open source software framework that makes it easy to create apps for medical research or for other research projects.

* [
      AFNetworking
      /
      AFNetworking
](https://github.com/AFNetworking/AFNetworking):
      A delightful iOS and OS X networking framework

* [
      xmartlabs
      /
      XLPagerTabStrip
](https://github.com/xmartlabs/XLPagerTabStrip):
      Android PagerTabStrip for iOS.

* [
      bkoc
      /
      BKAsciiImage
](https://github.com/bkoc/BKAsciiImage):
      Convert any UIImage to ascii art

* [
      SnapKit
      /
      Masonry
](https://github.com/SnapKit/Masonry):
      Harness the power of AutoLayout NSLayoutConstraints with a simplified, chainable and expressive syntax. Supports iOS and OSX Auto Layout

* [
      hackers-painters
      /
      samurai-native
](https://github.com/hackers-painters/samurai-native):
      Bring web standards to native platform

* [
      MatthewYork
      /
      DateTools
](https://github.com/MatthewYork/DateTools):
      Dates and times made easy in Objective-C

* [
      Roobiq
      /
      RBQFetchedResultsController
](https://github.com/Roobiq/RBQFetchedResultsController):
      Drop-in replacement for NSFetchedResultsController backed by Realm.

* [
      realm
      /
      realm-cocoa
](https://github.com/realm/realm-cocoa):
      Realm is a mobile database: a replacement for Core Data & SQLite

* [
      jessesquires
      /
      JSQMessagesViewController
](https://github.com/jessesquires/JSQMessagesViewController):
      An elegant messages UI library for iOS

* [
      robbiehanson
      /
      XMPPFramework
](https://github.com/robbiehanson/XMPPFramework):
      An XMPP Framework in Objective-C for Mac and iOS

* [
      smileyborg
      /
      PureLayout
](https://github.com/smileyborg/PureLayout):
      The ultimate API for iOS & OS X Auto Layout — impressively simple, immensely powerful. Objective-C and Swift compatible.

* [
      CEWendel
      /
      SWTableViewCell
](https://github.com/CEWendel/SWTableViewCell):
      An easy-to-use UITableViewCell subclass that implements a swippable content view which exposes utility buttons (similar to iOS 7 Mail Application)

* [
      eczarny
      /
      spectacle
](https://github.com/eczarny/spectacle):
      Spectacle allows you to organize your windows without using a mouse.

* [
      JadenGeller
      /
      Helium
](https://github.com/JadenGeller/Helium):
      A floating browser window for OS X

#### go
* [
      kabukky
      /
      journey
](https://github.com/kabukky/journey):
      A blog engine written in Go, compatible with Ghost themes.

* [
      codahale
      /
      sneaker
](https://github.com/codahale/sneaker):
      A tool for securely storing secrets on S3 using Amazon KMS.

* [
      docker
      /
      docker
](https://github.com/docker/docker):
      Docker - the open-source application container engine

* [
      albrow
      /
      jobs
](https://github.com/albrow/jobs):
      A persistent and flexible background jobs library for go.

* [
      syncthing
      /
      syncthing
](https://github.com/syncthing/syncthing):
      Open Source Continuous File Synchronization

* [
      Scalingo
      /
      acadock-monitoring
](https://github.com/Scalingo/acadock-monitoring):
      Monitor docker containers to get real time CPU/Memory

* [
      golang
      /
      go
](https://github.com/golang/go):
      The Go programming language

* [
      gizak
      /
      termui
](https://github.com/gizak/termui):
      Golang terminal dashboard

* [
      unrolled
      /
      secure
](https://github.com/unrolled/secure):
      HTTP middleware for Go that facilitates some quick security wins.

* [
      avelino
      /
      awesome-go
](https://github.com/avelino/awesome-go):
      A curated list of awesome Go frameworks, libraries and software

* [
      GoogleCloudPlatform
      /
      kubernetes
](https://github.com/GoogleCloudPlatform/kubernetes):
      Container Cluster Manager from Google

* [
      mailgun
      /
      godebug
](https://github.com/mailgun/godebug):
      A cross-platform debugger for Go.

* [
      jinzhu
      /
      gorm
](https://github.com/jinzhu/gorm):
      The fantastic ORM library for Golang, aims to be developer friendly

* [
      spf13
      /
      hugo
](https://github.com/spf13/hugo):
      A Fast and Flexible Static Site Generator built with love by spf13 in GoLang

* [
      gogits
      /
      gogs
](https://github.com/gogits/gogs):
      Gogs(Go Git Service) is a painless self-hosted Git Service.

* [
      github
      /
      git-lfs
](https://github.com/github/git-lfs):
      Git extension for versioning large files

* [
      google
      /
      cadvisor
](https://github.com/google/cadvisor):
      Analyzes resource usage and performance characteristics of running containers.

* [
      mitchellh
      /
      packer
](https://github.com/mitchellh/packer):
      Packer is a tool for creating identical machine images for multiple platforms from a single source configuration.

* [
      vrischmann
      /
      envconfig
](https://github.com/vrischmann/envconfig):
      Small library to read your configuration from environment variables

* [
      google
      /
      cayley
](https://github.com/google/cayley):
      An open-source graph database

* [
      go-martini
      /
      martini
](https://github.com/go-martini/martini):
      Classy web framework for Go

* [
      hashicorp
      /
      consul
](https://github.com/hashicorp/consul):
      Consul is a tool for service discovery, monitoring and configuration.

* [
      youtube
      /
      vitess
](https://github.com/youtube/vitess):
      vitess provides servers and tools which facilitate scaling of MySQL databases for large scale web services.

* [
      boltdb
      /
      bolt
](https://github.com/boltdb/bolt):
      A low-level key/value database for Go.

* [
      dvyukov
      /
      go-fuzz
](https://github.com/dvyukov/go-fuzz):
      Randomized testing for Go

#### javascript
* [
      vicapow
      /
      explained-visually
](https://github.com/vicapow/explained-visually):
* [
      SamyPesse
      /
      betty
](https://github.com/SamyPesse/betty):
      Open source Google Voice with Receptionist abilities, built on top of Twilio

* [
      yhat
      /
      rodeo
](https://github.com/yhat/rodeo):
      A data centric IDE for Python

* [
      postcss
      /
      postcss
](https://github.com/postcss/postcss):
      Transforming CSS with JS plugins

* [
      bendc
      /
      sprint
](https://github.com/bendc/sprint):
      A tiny, lightning fast jQuery-like library for modern browsers.

* [
      gorhill
      /
      uBlock
](https://github.com/gorhill/uBlock):
      uBlock Origin - An efficient blocker for Chromium and Firefox. Fast and lean.

* [
      tholman
      /
      elevator.js
](https://github.com/tholman/elevator.js):
      Finally, a "back to top" button that behaves like a real elevator.

* [
      bevacqua
      /
      dragula
](https://github.com/bevacqua/dragula):
      Drag and drop so simple it hurts

* [
      luin
      /
      ioredis
](https://github.com/luin/ioredis):
      A delightful, performance-focused and full-featured Redis client for Node and io.js.

* [
      facebook
      /
      react
](https://github.com/facebook/react):
      A declarative, efficient, and flexible JavaScript library for building user interfaces.

* [
      mikeflynn
      /
      egg.js
](https://github.com/mikeflynn/egg.js):
      A simple javascript library to add easter eggs to web pages.

* [
      mbostock
      /
      d3
](https://github.com/mbostock/d3):
      A JavaScript visualization library for HTML and SVG.

* [
      angular
      /
      angular.js
](https://github.com/angular/angular.js):
      HTML enhanced for web apps

* [
      getify
      /
      You-Dont-Know-JS
](https://github.com/getify/You-Dont-Know-JS):
      A book series on JavaScript. @YDKJS on twitter.

* [
      airbnb
      /
      javascript
](https://github.com/airbnb/javascript):
      JavaScript Style Guide

* [
      babel
      /
      babel
](https://github.com/babel/babel):
      Babel is a compiler for writing next generation JavaScript.

* [
      postcss
      /
      autoprefixer
](https://github.com/postcss/autoprefixer):
       Parse CSS and add vendor prefixes to rules by Can I Use

* [
      Semantic-Org
      /
      Semantic-UI
](https://github.com/Semantic-Org/Semantic-UI):
      Semantic is a UI component framework based around useful principles from natural language.

* [
      facebook
      /
      react-native
](https://github.com/facebook/react-native):
      A framework for building native apps with React.

* [
      jquery
      /
      globalize
](https://github.com/jquery/globalize):
      A JavaScript library for internationalization and localization that leverages the official Unicode CLDR JSON data

* [
      driftyco
      /
      ionic
](https://github.com/driftyco/ionic):
      Advanced HTML5 mobile development framework and SDK. Build incredible hybrid apps with web technologies you already know and love. Best friends with AngularJS.

* [
      antimalware
      /
      manul
](https://github.com/antimalware/manul):
      Antimalware tool for websites

* [
      callmecavs
      /
      layzr.js
](https://github.com/callmecavs/layzr.js):
      A small, fast, modern, and dependency-free library for lazy loading.

* [
      meteor
      /
      meteor
](https://github.com/meteor/meteor):
      Meteor, an ultra-simple, database-everywhere, data-on-the-wire, pure-Javascript web framework.

* [
      chrisaljoudi
      /
      uBlock
](https://github.com/chrisaljoudi/uBlock):
      uBlock: a fast, lightweight, and lean blocker for Chrome, Firefox, and Safari.

#### ruby
* [
      bydmm
      /
      Startup-Game
](https://github.com/bydmm/Startup-Game):
      创业者的游戏： 中关村启示录

* [
      rails
      /
      rails
](https://github.com/rails/rails):
      Ruby on Rails

* [
      Homebrew
      /
      homebrew
](https://github.com/Homebrew/homebrew):

 The missing package manager for OS X.

* [
      thbar
      /
      kiba
](https://github.com/thbar/kiba):
      Lightweight ETL for Ruby

* [
      reactjs
      /
      react-rails
](https://github.com/reactjs/react-rails):
      Ruby gem for automatically transforming JSX and using React in Rails.

* [
      jekyll
      /
      jekyll
](https://github.com/jekyll/jekyll):
      Jekyll is a blog-aware, static site generator in Ruby

* [
      sotownsend
      /
      BooJS
](https://github.com/sotownsend/BooJS):
      Unix swiss army knife for headless browser javascript

* [
      caskroom
      /
      homebrew-cask
](https://github.com/caskroom/homebrew-cask):
      A CLI workflow for the administration of Mac applications distributed as binaries

* [
      ruby
      /
      ruby
](https://github.com/ruby/ruby):
      The Ruby Programming Language

* [
      remiprev
      /
      her
](https://github.com/remiprev/her):
      Her is an ORM (Object Relational Mapper) that maps REST resources to Ruby objects. It is designed to build applications that are powered by a RESTful API instead of a database.

* [
      eliotsykes
      /
      rspec-rails-examples
](https://github.com/eliotsykes/rspec-rails-examples):
      RSpec cheatsheet & Rails app: Learn how to expertly test Rails apps from a model codebase

* [
      janlelis
      /
      productive-sublime-snippets-ruby
](https://github.com/janlelis/productive-sublime-snippets-ruby):
      Ruby Snippets for Sublime Text

* [
      twbs
      /
      bootstrap-sass
](https://github.com/twbs/bootstrap-sass):
      Official Sass port of Bootstrap

* [
      discourse
      /
      discourse
](https://github.com/discourse/discourse):
      A platform for community discussion. Free, open, simple.

* [
      jordansissel
      /
      fpm
](https://github.com/jordansissel/fpm):
      Effing package management! Build packages for multiple platforms (deb, rpm, etc) with great ease and sanity.

* [
      sass
      /
      sass
](https://github.com/sass/sass):
      Sass makes CSS fun again.

* [
      capitainetrain
      /
      stations
](https://github.com/capitainetrain/stations):
      List of stations and associated metadata

* [
      rapid7
      /
      metasploit-framework
](https://github.com/rapid7/metasploit-framework):
      Metasploit Framework

* [
      carrierwaveuploader
      /
      carrierwave
](https://github.com/carrierwaveuploader/carrierwave):
      Classier solution for file uploads for Rails, Sinatra and other Ruby web frameworks

* [
      sferik
      /
      rails_admin
](https://github.com/sferik/rails_admin):
      RailsAdmin is a Rails engine that provides an easy-to-use interface for managing your data

* [
      troessner
      /
      reek
](https://github.com/troessner/reek):
      Code smell detector for Ruby

* [
      cantino
      /
      huginn
](https://github.com/cantino/huginn):
      Build agents that monitor and act on your behalf. Your agents are standing by!

* [
      empirical-org
      /
      Empirical-Core
](https://github.com/empirical-org/Empirical-Core):
      Empirical-Core is our web app for managing students, assigning activities, and viewing results. Core seamlessly incorporates 3rd party applications via the Empirical API.

* [
      serverspec
      /
      specinfra
](https://github.com/serverspec/specinfra):
      Command Execution Framework for serverspec, itamae and so on

* [
      cloudfoundry
      /
      java-buildpack
](https://github.com/cloudfoundry/java-buildpack):
      Cloud Foundry buildpack for running Java applications

repository: josephyzhou/github-trending

gha_language: Go

repo_name: josephyzhou/github-trending


text:
# Slot: predicate

the direction is always from regulator to regulated

URI: [biolink:gene_regulatory_relationship_predicate](https://w3id.org/biolink/vocab/gene_regulatory_relationship_predicate)

## Domain and Range

[GeneRegulatoryRelationship](GeneRegulatoryRelationship.md) →  1..1 [PredicateType](types/PredicateType.md)

## Parents

 *  is_a: [predicate](predicate.md)

## Children

## Used by

 * [GeneRegulatoryRelationship](GeneRegulatoryRelationship.md)

repository: pabloalarconm/linkml

repo_name: pabloalarconm/linkml