text:
# Table of Contents

1. [Description](#description)
1. [Documentation](#documentation)
    - [API](#api)
    - [Trigger Dispatcher](#trigger-dispatcher)
    - [Trigger Handler](#trigger-handler)
    - [Trigger Context](#trigger-context)
    - [Trigger Settings](#trigger-settings)
    - [Interfaces](#interfaces)
    - [Custom Metadata](#custom-metadata)
    - [Custom Settings](#custom-settings)

[Link to Code](../../force-app/commons/triggerHandler)

[Link to Examples](examples)

# Description

Trigger Handler is apex design pattern which solves a few problems which arouse around apex triggers:

1. If there's more than one trigger per SObject in org, order of trigger execution is not deterministic. Recommended practice is to have one trigger per SObject
   and delegate logic execution inside of it.
1. If above is implemented without Trigger Handler framework, each trigger file would have repeated code for checking trigger operation, ex:

```apex
 switch on Trigger.operationType {
   when BEFORE_INSERT {
      new AccountContactLinker().linkContactsToAccount(Trigger.new);
      /*...*/
   }
   when BEFORE_UPDATE {
      /*...*/
   }
   when BEFORE_DELETE {
      /*...*/
   }
   when AFTER_INSERT {
      /*...*/
   }
   when AFTER_UPDATE {
      /*...*/
   }
   when AFTER_DELETE {
      /*...*/
   }
   when AFTER_UNDELETE {
      /*...*/
   }
}
```

Trigger Handler frameworks encapsulates this implementation and provide easy to extend virtual class with `onBeforeInsert(List<SObject> newRecords)` methods.

3. Trigger file is not treated as a class, but as block of apex code - similarly to anonymous apex. Therefore it cannot extend any virtual class on it's own, it
   has to delegate everything to fully-fledged class -Trigger Handler.

# Documentation

### API
###### TriggerDispatcher
```apex
public static void runMetadataDefinedTriggers();
public static void run(TriggerHandler triggerHandler);

@TestVisible private static void runMetadataDefinedTriggers(TriggerContext triggerContext)
@TestVisible private static void run(TriggerHandler triggerHandler, TriggerContext triggerContext)
```

###### TriggerHandler
```apex
public virtual void onBeforeInsert(List<SObject> triggerNew, TriggerContext tc);
public virtual void onAfterInsert(List<SObject> triggerNew, TriggerContext tc);
public virtual void onBeforeUpdate(List<SObject> triggerNew, TriggerContext tc);
public virtual void onAfterUpdate(List<SObject> triggerNew, TriggerContext tc);
public virtual void onBeforeDelete(List<SObject> triggerOld, TriggerContext tc);
public virtual void onAfterDelete(List<SObject> triggerOld, TriggerContext tc);
public virtual void onAfterUndelete(List<SObject> triggerNew, TriggerContext tc);

public void execute(List<SObject> records, TriggerContext tc, List<Logic> triggerLogics);

public interface Logic {
   void execute(List<SObject> records, TriggerContext ctx);
}

public interface Parameterizable {
   void setParameters(String parameters);
}
```

###### Trigger Settings
```apex
public static void disableTriggers();
public static void enableTriggers();
public static void disableTrigger(SObjectType sObjectType);
public static void enableTrigger(SObjectType sObjectType);
public static Boolean isSObjectTriggerEnabled(SObjectType sObjectType);
public static TriggerLogicSelector getLogicSelector();
public static void disableAllLogic();
public static void enableAllLogic();
```

### Trigger Dispatcher

Entry point of every trigger. This class encapsulates trigger context variables into TriggerContext instance and dispatches execution to correct Trigger Handler
method. It may use Trigger Handler instance provided by developer or pull logic to run from custom metadata.

It contains 2 methods:

* `public static void runMetadataDefinedTriggers()` which runs triggers defined in custom metadata.
* `public static void run(TriggerHandler triggerHandler)` which runs concrete TriggerHandler class.

and 2 methods that are visible only in unit tests and provide ability to mock TriggerContext:

* `private static void runMetadataDefinedTriggers(TriggerContext triggerContext)`
* `private static void run(TriggerHandler triggerHandler, TriggerContext triggerContext)`

Trigger should contain only one line of code which executes trigger handler:

```apex
trigger AccountTrigger on Account (before insert, after insert, before update, after update, before delete, after delete, after undelete ) {
    TriggerDispatcher.run(new AccountTriggerHandler());
}
```

### Trigger Handler

This virtual class is the heart of framework. It contains virtual methods which should be overwritten, each one corresponding to the trigger event.
Each sObject should have a concrete trigger handler class, which extends TriggerHandler class, and override method it wants to handle in the trigger execution.
Example:
```apex
public inherited sharing class AccountTriggerHandler extends TriggerHandler {

    //Using TriggerHandler.Logic implementing classes
    public override void onAfterInsert(List<SObject> triggerNew, TriggerContext tc) {
        this.execute(triggerNew, tc, new List<Logic>{
            new AccountContactLinker()
        });
    }

    //without interface
    public override void onAfterUpdate(List<SObject> triggerNew, TriggerContext tc) {
       new AccountContactLinker().linkContactsToAccount(triggerNew, tc);
    }

}
```

### Trigger Context

This class serves following purposes:

1. It encapsulates Trigger variables into an immutable object that can be passed down to other classes.
1. It's used as marker interface which indicates that this particular method is run in Trigger context - similarly
   to `SchedulableContext, QueueableContext and BatchableContext`,
1. It contains methods that make record filtering easier and more verbose:

```apex
SObject[] getRecords();
Map<Id, SObject> getRecordsMap();
Set<Id> getRecordsIds();
SObject getOld(SObject record);
Map<Id, SObject> getOldMap();
Boolean isNew();
Boolean isChanged();
Boolean isChanged(SObject record, SObjectField field);
Boolean isChangedTo(SObject record, SObjectField field, Object toValue);
Boolean isChangedFrom(SObject record, SObjectField field, Object fromValue);
Boolean isChangedFromTo(SObject record, SObjectField field, Object fromValue, Object toValue);
```

### Trigger Settings

Settings class for manipulating trigger execution and mocking in tests. Using this class, developer can turn off trigger execution for batch data fix for
example.

1. Toggling trigger execution for SObject type:

```apex
TriggerSettings.disableTrigger(Account.SObject);
// Do Something without triggers running
TriggerSettings.enableTrigger(Account.SObject);
```

2. Toggling all logic on custom setting level for current user. Methods below perform DML to update LogicSwitch__c custom setting for current user.

```apex
TriggerSettings.disableAllLogic();
TriggerSettings.enableAllLogic();
```

3. Mocking custom metadata defined triggers:

```apex
TriggerSettings.mockMetadata(new List<TriggerLogic__mdt>{
    new TriggerLogic__mdt(Enabled__c = true, BeforeInsert__c = true, ApexClass__c = 'AccountAssistantContactLinker.cls')
});

//or mock whole selector class for more granular control

TriggerSettings.mockSelector(new CustomTriggerLogicSelector());
```

### Interfaces

Framework provides 2 interfaces that should be implemented in business logic classes. It's not a requirement, but it streamlines the code and is a good
practice.

###### TriggerHandler.Logic

```apex
public interface Logic {
    void execute(List<SObject> records, TriggerContext ctx);
}
```

TriggerHandler.Logic is a class that's implementing single business requirement. TriggerContext marker interface indicates that this method runs in Trigger and
may have to filter records for processing. TriggerContext contains methods that make filtering simpler and more verbose:

```apex
public inherited sharing class AccountContactLinker implements TriggerHandler.Logic {

   public void execute(List<SObject> records, TriggerContext ctx) {
      for (Account acc : (Account[]) records){
         if(ctx.isNew() || ctx.isChanged(acc, Account.Phone)){
            //... do logic here
            // ex. link Contacts with same phone number
         }
      }
   }
}
```

###### TriggerHandler.Parameterizable

```apex
public interface Parameterizable {
    void setParameters(String parameters);
}
```

This interface marks classes which can be parametrized through TriggerLogic__mdt.Parameters__c field. Value of the field will be passed to setParameters method.

This may come handy if we use [Custom Metadata](#custom-metadata) and want to parametrize the class - for example if we want to reuse one generic class for many
sObjects types and pass different SObjectField as parameter, we can do that through this interface.

Example:
Generic class that copies one field to another in before trigger.

Custom Metadata:
![image](https://user-images.githubusercontent.com/4470967/118978167-4bddb580-b977-11eb-921c-494de754ccf3.png)

*Example parametrizable code:*

```apex
public with sharing class FieldCopier implements TriggerHandler.Logic, TriggerHandler.Parameterizable {
    private String sourceField, targetField;

    public void setParameters(String parameters) {
        String[] fields = parameters.split(',');
        this.sourceField = fields[0].trim();
        this.targetField = fields[1].trim();
    }

    public void execute(List<SObject> records, TriggerContext ctx) {
        for (SObject sobj : records) {
            sobj.put(targetField, sobj.get(sourceField));
        }
    }
}
```

### Custom Metadata

TriggerLogic__mdt is used to define classes to run in Trigger without creating coupling/dependency between them. In standard code approach, different teams may
have to edit same Trigger/TriggerHandler file to introduce new logic, but with custom metadata each team can inject their own custom metadata without touching
any common code.

| Field            | Type           | Description  |
| ------           | ------         | ------------ |
| AfterDelete__c   | Checkbox       |              |
| AfterInsert__c   | Checkbox       |              |
| AfterUndelete__c | Checkbox       |              |
| AfterUpdate__c   | Checkbox       |              |
| ApexClass__c     | Text(255)      | Name of apex class - must be public. It can be inner class - ex. AccountFieldSetters.NameSetter             |
| BeforeDelete__c  | Checkbox       |              |
| BeforeInsert__c  | Checkbox       |              |
| BeforeUpdate__c  | Checkbox       |              |
| Description__c   | Text Area(255) |              |
| Enabled__c       | Checkbox       |              |
| Order__c         | Number(18, 0)  | Order of execution             |
| Package__c       | Text(63)       | Name/Prefix of package or workstream, used for ordering. Code is first executed by package order, then by Order field             |
| Parameters__c    | Text Area(255) | Parameters injected to the class             |
| SObject__c       | Text(255)      | API Name of SObject             |

### Custom Settings
Logic Switch custom settings can be used to disable automation from executing for selected Profiles or Users.

| Field            | Type           | Description  |
| ------           | ------         | ------------ |
| DisableProcessBuilders__c | Checkbox | Disables Process Builders (PBs have to check for this setting as first step) |
| DisableTriggers__c        | Checkbox | Disables all triggers from executing |
| DisableValidationRules__c | Checkbox | Disables Validation Rules (VRs have to check for this setting) |
| DisableWorkflowRules__c   | Checkbox | Disables Workflow Rules (WRs have to check for this setting as first step) |

repository: jdgirald/Apex-Opensource-Library

path: /docs/Trigger Handler/triggerHandler.md

repo_name: jdgirald/Apex-Opensource-Library


text:
---
description: If you are new to Auth0 start here for a list of resources that can get you started
title: Getting Started
classes: topic-page
topics:
  - auth0-101
contentType:
  - concept
  - index
useCase:
  - strategize
  - get-started
---

Getting Started

    Learn the basics of Auth0.

Welcome! If you are new to Auth0, you are in the right place.

This introduction to Auth0 covers things like:

* What we do
* How we can help you
* The basic terminology we use
* The process of implementing Auth0
* The Auth0 ecosystem
* ... and many more

Let's get started!

    Auth0 Overview

Learn what Auth0 is and how you can use it.

    Learn the Basics

Learn the basics of Auth0 and familiarize yourself with the basic terminology.

    Dashboard Overview

The Dashboard is where you configure and manage all things Auth0. This article offers a brief overview of the sections it contains and what you can do in each section.

    Deployment Models

Read about the four different deployment models that Auth0 offers.

license: MIT

repository: AdrianaMusic/docs

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: AdrianaMusic/docs


text:
**What is this ?**
----------
Very Fast, lightweight and scalable sitemap library for google written in php, it uses no extension and it has no requirement.
it almost has no overhead even on large sitemap files when updating them, what you need to do
is to provide valid data and this library will do the rest for you(including updating sitemap index file). you can easily
use it in your frameworks like Codeigniter.

This library support images. this means you can add one or more images to an item, if you want to add support for vidoes,
its pretty easy, you can check how I implemented support for images and take it from there.

Please note that this library won't use urlencode, you need to encode utf-8 part of your urls yourself, after reading README file
checkout example folder for mor examples

php 5.4+ is required to run this library

----------
**Strategies ?**
----------
1. Best strategy would be where you have a database, you can set a flag(boolean column) in the table, i.e: `in_sitemap`.
you can write a little script to feed this library with right data and put it to cronjob and forget all about sitemap,
this library is your **best** choice, for more details see example folder

2. Next strategy would be where you know never reach item limitation for a sitemap file(which is 45000 in this library
and you can change it up to 50000 if want to), this library is your **best**  choice

3. Last strategy is where you **don't** have any database and you will **reach** item limitation for a sitemap file,
there are libraries out there which **only** cover this strategy(which is not ideal at all).You can still use this
library, but you need to delete xml files before you start,
If you have a few items, this strategy is okay, but I don't recommend it at all

----------
**Quick start**
----------
```php
require_once 'Sitemap.php';
$sm = new Sitemap();
$sm->initialize('/path/to/destination/dir/usually/root/of/web/server')->
     begin()->
     set("http://example.com/gallery", "daily")->
     done()->
     mk_index("http://example.com/");
```

This quick start will create a file named `sitemap-0.xml` and add one item to it, then it will create a file named
`sitemap.xml`, which is a `sitemap index file`, you can submit the latter to google. make sure your path is absolute

Please note you can set options to override defaults, also there are more advanced use cases, please see example folder
for more details

----------
**Reference**
----------

**`initialize($path)`**: You need to call this method before everything.

`$path` is the path to the directory where you want
 to place your xml files there, this is usually the root of your web server

**`begin($current_item_size=0, $name=null, $include_img=false)`**: to prepare xml file and add item(s) to it, call this
 method,

`$current_item_size` is the size of already indexed items, you normally fetch its value from database
(i.e: `select COUNT(*) FROM table WHERE in_sitemap = 1`)

`$name` is the name of our xml site, its default is `sitemap`, note that this name won't make conflict with "sitemap index file", so don't worry

`$include_img`: will set a flag in xml files so that you can include your images in sitemap file too.

**`set($loc, $cf, $ts=null, $p='0.8', $images=null)`**: to add item to your sitemap, you need to call this method.

`$loc` is the url you want to index,

`$cf` is change frequency, its value can be: always,hourly,daily,weekly,monthly,yearly,never

`$p` is priority and its value are between 0.0 and 1.0

`$images` is an array of arrays, an example would be `[["url"=> "full_url", "title"=> "", "caption"=> "", "geo"=> "Tehran,Iran"]]`
Only url key is require and other parts are optional

> Please note that you need to call `begin()` with `$include_img=true` in order to have a valid sitemap

**`done()`**: you need to call this method when you've done adding items, this will save a valid xml

**`mk_index($full_url, $exclude=[], $xml_name='sitemap.xml')`**: using this method, you can create a sitemap index file.

`$full_url` is your full url, this url must point to the right directory. example: https://example.com

`$exclude` is an array of file names(not full path, just basename). to ignores specified xml files

`$xml_name` is the name of the sitemap index file, we recommend to leave it as is

**`remove_xml_files($exclude=[])`**: remove all files at our path

`$exclude` is an array of file names(not full path, just basename) to ignore when removing


text:
---
layout: post
title: "Toward predictive machine learning for active vision"
date: 2017-11-07 08:41:59
categories: arXiv_CV
tags: arXiv_CV Review Inference Prediction Recognition
author: Emmanuel Daucé
mathjax: true
---

* content
{:toc}

##### Abstract
We develop a comprehensive description of the active inference framework, as proposed by Friston (2010), under a machine-learning compliant perspective. Stemming from a biological inspiration and the auto-encoding principles, a sketch of a cognitive architecture is proposed that should provide ways to implement estimation-oriented control policies under a POMDP perspective. Computer simulations illustrate the effectiveness of the approach through a foveated inspection the input data. The pros and cons of the control policy are reviewed in details, showing interesting promises in term of processing compression, but also putative risks of a confirmation bias that may degrade the recognition performance if the model is too optimistic about its own predictions. The presented formalism is fully compliant with the auto-encoding framework and would deserve further developments under variational encoding architectures.

##### Abstract (translated by Google)
根据Friston（2010）的提议，我们在机器学习兼容的观点下，对主动推理框架进行了全面的描述。从生物学的启发和自动编码的原则出发，提出了一个认知架构的草图，该草图应该提供在POMDP视角下实现以估计为导向的控制策略的方法。计算机模拟通过对输入数据进行检查来说明方法的有效性。对控制策略的优缺点进行了详细的审查，在处理压缩方面表现出有意义的承诺，而且如果模型对自己的预测过于乐观，则可能会降低识别性能。所提出的形式主义完全符合自动编码框架，并将在变分编码体系结构下获得进一步的发展。

##### URL
[https://arxiv.org/abs/1710.10460](https://arxiv.org/abs/1710.10460)

##### PDF
[https://arxiv.org/pdf/1710.10460](https://arxiv.org/pdf/1710.10460)


text:
# Appendicispora gerdemannii (S.L. Rose, B.A. Daniels & Trappe) Spain, Oehl & Sieverd., 2006 SPECIES

#### Status
SYNONYM

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

#### Published in
in Spain, Sieverding & Oehl, Mycotaxon 97: 174 (2006)

#### Original name
Glomus gerdemannii. S.L. Rose, B.A. Daniels & Trappe, 1979

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Glomeromycota/Glomeromycetes/Archaeosporales/Ambisporaceae/Ambispora/Ambispora gerdemannii/ Syn. Appendicispora gerdemannii/README.md

repo_name: mdoering/backbone


text:
# Contributing
This document describes the steps needed to add a feature to this library.
The library follows Test Driven Development (TDD).

0. Write test
1. Make test pass
2. Add logging
3. Add proper error handling
4. Add documentation
5. Enhance test cases (macros?)
6. Write benchmarks
7. Optimize code

**0. Write test**

The first step is to write a test for the feature to be added.
The test should be structured and build with the syntax you want the interface to have.
This will help guaranteeing that the user will have a nice interface.
Additionally, it will help develop a consistent interface.

**1. Make test pass**

The foremost goal is to make the test pass.
This enables fast development and increase in feature sets.
During this phase it is encouraged to use simple `println!()` statements for variable states.

**2. Add logging**

After the tests are passing, proper logging should be structured.
Each logging level (`debug`, `info`, `warning` and `error`) should be used.
A good indication for proper spots for logging are the `println!()` lines from the previous steps.

**3. Add proper error handling**

A proper error handling will enable faster execution and error escalation.
Each non-trivial function should return either a `Result` or an `Option`.

**4. Add documentation**

Code is read more often than written.
Therefore, public functions facing the user should be documented thoroughly.
Should the implementation use not the obvious solution for a problem, the reasons for the decision should be written down. The author should decide what the `obvious solution' is.
The documentation must be extend, if questions arise during the review process.

**5. Enhance test cases (macros?)**

The number of test cases for each function or struct should be extended for each possible edge case. Macros should be used extensively to make this process easier.

**6. Write benchmarks**

Until now the overarching goal of each phase was to achieve correct execution of the code.
This and the next step involve in optimizing runtime and memory consumption.
Use `criterion` to write benchmarking tests.

**7. Optimize code**

Well, take the benchmarks as a reference and optimize the code.
Code readability is still important.
If the performance gain or footprint reduction is not big enough, consider not adding it.
The decision is up to the developer.
But please add a remark in the documentation on how a performance gain could be achieved
and how `little' the effect is if implemented.

repository: ucyo/rscompress

gha_language: Rust

repo_name: ucyo/rscompress


text:
# fabienb4:react-semantic-ui-components

> **This package is no longer maintained. If you have a well maintained fork, please send me an email so I can add a link to it here.**

A collection of React components to use with Semantic-UI.

> This is a work in progress and is based on react 0.14.0 which is not yet officially supported by Meteor. As soon as it is, I will make the package available on Atmosphere. Use in production is not recommended, even with a custom React package supporting 0.14.0, as there are probably some issues to address and improvements to be made. When the package is stable enough, I will bump the version to 0.1.0.

> semantic-ui is NOT included in this package, to allow you to use a customized version if you need to. If you don't use a custom version, you must add the default package `semantic:ui-css` to your meteor app.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
- [Contributing](#contributing)

## Installation

In your Meteor app directory:

```
$ meteor add fabienb4:react-semantic-ui-components
```

## Usage

You can include any component available in the ReactSUI namespace in your app.

For a list of components, see the [React Semantic-UI Component API](http://react-semantic-ui-components.meteor.com/).

To learn how to use React components, see [React Multiple Components](https://facebook.github.io/react/docs/multiple-components.html)

## License

MIT

## Contributing

Anyone is welcome to contribute. Fork, make your changes (test them!), and then submit a pull request.

Bitcoin: `34o6GtZPvVXparT46Zw2kfdxex2SWRpkGS`

[![Support via Gratipay](https://cdn.rawgit.com/gratipay/gratipay-badge/2.3.0/dist/gratipay.svg)](https://gratipay.com/fabienb4/)


text:
# atomConfig
config and packages used in Atom

To restore the config, just copy the config.cson in your .atom directory.

To restore the packages just run `apm install --packages-file package.list`.

repository: theCrius/atomConfig

repo_name: theCrius/atomConfig


text:
# C3t4 – Contao 3 to 4

This is a command line application that helps you automatically convert your Contao 3-compatible modules to Symfony-based Contao 4 bundles.

### Installation and Usage
**C3t4 requires node.js 7.6 or newer.**

The recommended way of installing this application is via Yarn or npm.
```sh
$ yarn global add @dieschittigs/c3t4
$ npm install --global @dieschittigs/c3t4
```

Then, simply run `c3t4` in your Contao 3 instance and follow the on-screen instructions.

### Roadmap
- Rename any occurences of `system/modules/.../assets` with `bundles/...` in order for bundle assets to be adjusted automatically

### Other steps for migrating from Contao 3 to 4
In our experience, the following steps are sufficient to migrate an application from Contao 3 to 4:
1. Export your Contao 3 database
2. Import the database into your new Contao 4 database
3. Install Contao 4 on your target system using the Contao Manager
4. Run the install tool and update the database to Contao 4
  _(make sure none of the `DROP COLUMN` or `DROP TABLE` fields are selected)_
5. Copy the content of your `templates` directory from Contao 3 to Contao 4
6. Copy the content of your `files` directory from Contao 3 to Contao 4
7. Upload your converted Contao 4 bundles
8. Add your local Contao 4 bundles to your `composer.json` (in the `repositories` and `require` fields, see below)
9. Run `composer update`, or update your dependencies from the Contao Manager

Expectedly, Contao 4 is not fully backwards-compatible with Contao 3. For us, this was most apparent in some template rendering changes. This tool can't fix those changes for you, so you will obviously need to make sure that everything still works in your Contao 4 installation and make some minor adjustments where needed.

##### Example `composer.json` entries
```json
{
    ...
    "require": {
        ...
        "mynamespace/mybundle": "@dev"
    },
    "repositories": [
        { "type": "path", "url": "./bundles/mybundle" }
    ]
}
```

license: ISC


text:
# rsrdp

[![Travis CI Build](https://img.shields.io/travis/douglaswth/rsrdp/master.svg?label=travis ci build&style=flat-square)][travis ci build]
[![AppVeyor Build](https://img.shields.io/appveyor/ci/douglaswth/rsrdp/master.svg?label=appveyor build&style=flat-square)][appveyor build]

[travis ci build]: https://travis-ci.org/douglaswth/rsrdp
[appveyor build]: https://ci.appveyor.com/project/douglaswth/rsrdp/branch/master

Windows Remote Desktop launcher for RightScale Instances/Servers

repository: douglaswth/rsrdp

repo_name: douglaswth/rsrdp


text:
# graphql-kotlin-types
[![Maven Central](https://img.shields.io/maven-central/v/com.expediagroup/graphql-kotlin-types.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22com.expediagroup%22%20AND%20a:%22graphql-kotlin-types%22)
[![Javadocs](https://img.shields.io/maven-central/v/com.expediagroup/graphql-kotlin-types.svg?label=javadoc&colorB=brightgreen)](https://www.javadoc.io/doc/com.expediagroup/graphql-kotlin-types)

The core types used by both client and server for communication over GraphQL. These types are annotated with [Jackson](https://github.com/FasterXML/jackson) metadata
so they can be serialized/deserialized. Instead of using this package, you may want to look at the other fully featured client and server packages in our [main README](./../README.md).

### GraphQLRequest
Provides the common format for communicating with [GraphQL over HTTP](https://graphql.org/learn/serving-over-http/#post-request).
This format is not part of the specification but it is mostly standard at this point in all server implementations as the expected format.

### GraphQLResponse
Provides a [GraphQL specification compliant response](http://spec.graphql.org/June2018/#sec-Data) class. This can be used by clients or servers.


text:
# programming languages: constructs and concepts

## ravi sethi

### at&t 1996

---

essentially a fairly technical manual about the theories of programming languages. quite useful in determining the basics of "classical" programming language theory and practice.

---

#### 1 - introduction

First and foremost, the theoretical roots of PL are in maths, in formal notation, while its practical roots are in looming machines. It seems that the main thread that runs through the book (and perhaps PL research altogether?) is *lack of ambiguity*.

PL as notations are compared to English language, since they both have constructs of different types and different scales (sonnet, essay, note, etc.). To what extent are these constructs things that can be considered *patterns*? Because then aesthetic standards could be thought of as very narrow patterns.

On a different note, languages are only meaningful at the interface between the human and the machine (cf. Galloway, Thacker, [Language, life, code](https://onlinelibrary.wiley.com/doi/abs/10.1002/ad.317)). But that still doesn't tell us if machines understand anything at all. The author seems to state that the computer only ever understands binary (quoting Goldstine, 1972).

> The art of programming is the art of organizing complexity (Djikstra)

However, is that only the case for structured programming, and less so for imperative/functional/declarative programming? (Declarative programming looks fckn crazy)

#### 2 - grammars

introduced in 1958 by Algol 58, because they were *dissatisfied with the fact that subtle semantic questions remained unanswered due to a lack of clear description*. it then seems that the basics of PL are **formal syntax** and **informal semantics**

| syntax          | semantics |
| ------          | --------- |
| formal          | informal  |
| explicit        | implicit  |
| use             | value/env |
| doing?          | being?    |
| known           | predicted |
| given           | extrapolated (from environment) |
| data procedures | data structures|

semantics imply how variables and functions "should" behave: the expectation is about the development of an external system (CPUs have, to an extent, already the ability to foresee their internal behaviour, see SPECTRE). there is also some aspect of context, of pre-existing knowledge. as such, each higher layer provides some context for the previous layer (assembly gives meaning to machine code, C gives meaning to assembly, Go gives meaning to C, etc.), and so do we reach a point where the programmer themselves are the context? is this where the magic happens (i.e. in the mind)

(implications of thesis: there is art in everything? or only in programming? that's a longer work to verify **OR** you can only find it beautiful if you can understand it)

#### 13 - semantics

there is grammar to explain the syntax of a PL (e.g. BNF), and then there is English to explain its semantics. semantics in PL consist of **values** and **environments**.

fun fact: at some moment (p.515) they mention *pre*fix notation, *in*fix notation and *post*fix notation. when it doesn't match, they call it *mix*fix notation (just for the sake of being able to categorize it all?)

so each programming language is made up of an abstract tree composed of terminals (tokens, values), non-terminals (procedures, expressions, statements) and production rules (how to get a non-terminal from a bunch of terminals).

`look(x, nil)`, like staring into the abyss.

 E.env, E.val)
- operational semantics (e.g. env(E, val(E2)))
- denotational semantics (e.g. [[E]] env == value of E inside environment env)
- natural semantics (sets of logical rules, related to declarative programming)

There are (at least) two different kinds of beauty:

- the beauty that works with Lisp and is featured in clean snippets of code in textbooks
- the beauty of including the error-checking

---

From *Programming Languages: Design and Implementation*, p.508:

> The difference among programming languages are not quantitative differences in what can be done, by only qualitative differences in how elegantly, easily and effectively things can be done.

Beautiful languages:

- clear semantics and syntactic structure
- natural representation for problem data and algorithms (**related to patterns**)
- ease of ex tension (**related to patterns**)
- efficiency

repository: periode/thesis

branch_name: refs/heads/main

repo_name: periode/thesis


text:
# Ocellularia argillacea var. argillacea Müll. Arg. VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Flora, Jena 66: 352 (1883)

#### Original name
Ocellularia argillacea var. argillacea Müll. Arg.

### Remarks
null


text:
# Scala.js typings for quantize

Typings are for version 1.0

## Library description:
A node.js module for color quantization, based on Leptonica.

|                    |                 |
| ------------------ | :-------------: |
| Full name          | quantize |
| Keywords           | image, quantize, color, node |
| # releases         | 0 |
| # dependents       | 0.0 |
| # downloads        | 661745.0 |
| # stars            | 120.0 |

## Links
- [Homepage](https://github.com/olivierlesnicki/quantize)
- [Bugs](http://github.com/olivierlesnicki/quantize/issues)
- [Repository](https://github.com/olivierlesnicki/quantize)
- [Npm](https://www.npmjs.com/package/quantize)

## Note
This library has been generated from typescript code from [DefinitelyTyped](https://definitelytyped.org).

Provided with :purple_heart: from [ScalablyTyped](https://github.com/oyvindberg/ScalablyTyped)

## Usage
See [the main readme](../../readme.md) for instructions.

repository: ScalablyTyped/Distribution

repo_name: ScalablyTyped/Distribution


text:
- Start Date: 2016-10-13
- RFC PR: 0001
- Issue: XTECH-29

# Summary

Instead of failing the entire rendering process when an error occurs during
rendering a component, we should warn the user and continue the rendering.

# Motivation

During development, it is inconvenient if the entire rendering process breaks
just because a single component causes an error.

This feature is supposed to improve the developer experience by clearly showing
which component failed during rendering and if possible, why it failed.

# Detailed design

Given that we're building Melody for `process.env.NODE_ENV !== 'production'`,
we would add `try-catch` blocks around the creation and rendering of
Melody Component. For consistency, we should do the same when calling their
`componentDidMount` and `componentWillUnmount` lifecycle hooks.

## Instance creation

If an error occurs while creating an instance of a Component, we will render an
error message instead of the Component.

The error should also be logged to `console.error`.

## Component rendering

If an error occurs while rendering a Component, we will render an error message
instead of the Component.

The error should also be logged to `console.error`.

**Caution:** We may need to rollback the rendering process to its state before
the rendering started. To do this, we need to copy the current state and reset
to it on error.

Once the state has been reset, we'd continue by replacing the Components element
with the error message.

Crashing the layout (i.e. by rendering a block element where an inline element
was expected) is not an issue.

We should display the component name, if available, and the error message. Easy
access to the stack of the error is not stricly needed.

## Errors during lifecycle hook execution

Since the component did render correctly, the best thing we can do for this is
probably to log the caught error to `console.error`.

# How We Teach This

This feature should be designed to be self-documenting and should not require
learning effort from our users. Instead, it should help them to understand why
their code failed.

# Drawbacks

There is a huge performance penalty involved in using a `try-catch` block as part
of the rendering process, especially in the specified method. Thus, this feature
can not be used as part of a `production` build.

# Alternatives

Instead of also showing an inline HTML fragment that contains details about the
error, we could just use the developer console to report the error.
This could, however, lead to confusion and frustration when a developer does not
look at the console and instead just wonders why the component does not show up.

# Unresolved questions

None.

repository: jaybyron/melody

repo_name: jaybyron/melody


text:
## [0.0.4] - 2019-09-07

* Corrected formatting of checkboxes in readme
* Corrected wrong resizing of gifs

## [0.0.3] - 2019-09-06

* Updated broken Link in README
* Added TODOs in README
* Added license to README
* Added README to example
* Added some showcase git to example
* Resized gifs
* formated all files with "flutter format"

## [0.0.2] - 2019-09-06

* Added a README file

## [0.0.1] - 2019-09-06

* This is the very first release of the color_selection_widget
* It will provide basic functionality of displaying the widget
* Select a color you like while watching a beautiful ripple animation


text:
# OpenTelemetry.Extensions.Hosting

[![NuGet](https://img.shields.io/nuget/v/OpenTelemetry.Extensions.Hosting.svg)](https://www.nuget.org/packages/OpenTelemetry.Extensions.Hosting)
[![NuGet](https://img.shields.io/nuget/dt/OpenTelemetry.Extensions.Hosting.svg)](https://www.nuget.org/packages/OpenTelemetry.Extensions.Hosting)

## Installation

```shell
dotnet add package OpenTelemetry.Extensions.Hosting
```

## Overview

The OpenTelemetry.Extensions.Hosting package provides extension methods for
automatically starting (and stopping) OpenTelemetry tracing (`TracerProvider`)
and metrics (`MeterProvider`) in [ASP.NET
 Core](https://learn.microsoft.com/aspnet/core/fundamentals/host/web-host) and
 [.NET Generic](https://learn.microsoft.com/dotnet/core/extensions/generic-host)
 hosts. These are completely optional extensions meant to simplify the
 management of the OpenTelemetry SDK lifecycle.

## Extension method reference

Targeting `Microsoft.Extensions.DependencyInjection.IServiceCollection`:

* `AddOpenTelemetry`: Registers an
  [IHostedService](https://learn.microsoft.com/dotnet/api/microsoft.extensions.hosting.ihostedservice)
  to automatically start tracing and/or metric services in the supplied
  [IServiceCollection](https://learn.microsoft.com/dotnet/api/microsoft.extensions.dependencyinjection.iservicecollection)
  and then returns an `OpenTelemetryBuilder` class.

  > **Note**
  > `AddOpenTelemetry` should be called by application host code only. Library
  authors see: [Registration extension method guidance for library
  authors](../../docs/trace/extending-the-sdk/README.md#registration-extension-method-guidance-for-library-authors).
  <!-- This comment is to make sure the two notes above and below are not merged
  -->
  > **Note**
  > Multiple calls to `AddOpenTelemetry` will **NOT** result in multiple
  providers. Only a single `TracerProvider` and/or `MeterProvider` will be
  created in the target `IServiceCollection`. To establish multiple providers
  use the `Sdk.CreateTracerProviderBuilder()` and/or
  `Sdk.CreateMeterProviderBuilder()` methods. See [TracerProvider
  configuration](../../docs/trace/customizing-the-sdk/README.md#tracerprovider-configuration)
  and [Building a
  MeterProvider](../../docs/metrics/customizing-the-sdk/README.md#building-a-meterprovider)
  for more details.

  `OpenTelemetryBuilder` methods:

  * `ConfigureResource`: Registers a callback action to configure the
  `ResourceBuilder` for tracing and metric providers.

  * `WithTracing`: Enables tracing and optionally configures the
  `TracerProvider`.

  * `WithMetrics`: Enables metrics and optionally configures the
  `MeterProvider`.

## Usage

The following example shows how to register OpenTelemetry tracing & metrics in
an ASP.NET Core host using the OpenTelemetry.Extensions.Hosting extensions.

```csharp
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;

var appBuilder = WebApplication.CreateBuilder(args);

appBuilder.Services.AddOpenTelemetry()
    .ConfigureResource(builder => builder.AddService(serviceName: "MyService"))
    .WithTracing(builder => builder.AddConsoleExporter())
    .WithMetrics(builder => builder.AddConsoleExporter());

var app = appBuilder.Build();

app.Run();
```

A fully functional example can be found
[here](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/examples/AspNetCore).

### Resources

To dynamically add resources at startup from the dependency injection you can
provide an `IResourceDetector`.
To make use of it add it to the dependency injection and they you can use the
`ISerivceProvider` add it to OpenTelemetry:

```csharp
public class MyResourceDetector : IResourceDetector
{
    private readonly IWebHostEnvironment webHostEnvironment;

    public MyResourceDetector(IWebHostEnvironment webHostEnvironment)
    {
        this.webHostEnvironment = webHostEnvironment;
    }

    public Resource Detect()
    {
        return ResourceBuilder.CreateEmpty()
            .AddService(serviceName: this.webHostEnvironment.ApplicationName)
            .AddAttributes(new Dictionary<string, object> { ["host.environment"] = this.webHostEnvironment.EnvironmentName })
            .Build();
    }
}

services.AddSingleton<MyResourceDetector>();

services.AddOpenTelemetry()
    .ConfigureResource(builder =>
        builder.AddDetector(sp => sp.GetRequiredService<MyResourceDetector>()))
    .WithTracing(builder => builder.AddConsoleExporter())
    .WithMetrics(builder => builder.AddConsoleExporter());
```

## Migrating from pre-release versions of OpenTelemetry.Extensions.Hosting

Pre-release versions (all versions prior to 1.4.0) of
`OpenTelemetry.Extensions.Hosting` contained signal-specific methods for
configuring tracing and metrics:

* `AddOpenTelemetryTracing`: Configure OpenTelemetry and register an
  [IHostedService](https://learn.microsoft.com/dotnet/api/microsoft.extensions.hosting.ihostedservice)
  to automatically start tracing services in the supplied
  [IServiceCollection](https://learn.microsoft.com/dotnet/api/microsoft.extensions.dependencyinjection.iservicecollection).

* `AddOpenTelemetryMetrics`: Configure OpenTelemetry and register an
  [IHostedService](https://learn.microsoft.com/dotnet/api/microsoft.extensions.hosting.ihostedservice)
  to automatically start metric services in the supplied
  [IServiceCollection](https://learn.microsoft.com/dotnet/api/microsoft.extensions.dependencyinjection.iservicecollection).

These methods were marked obsolete and later removed. You should migrate your
code to the new `AddOpenTelemetry` method documented above. Refer the
[old](https://github.com/open-telemetry/opentelemetry-dotnet/blob/core-1.3.2/examples/AspNetCore/Program.cs)
and
[new](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/examples/AspNetCore)
versions of the example application to assist you in your migration.

## References

* [OpenTelemetry Project](https://opentelemetry.io/)

repository: open-telemetry/opentelemetry-dotnet

gha_language: C#

repo_name: open-telemetry/opentelemetry-dotnet


text:
# HPE RTL Flask Sample Application

This application is provided as a sample application using the Flask Python WSGI framework to provide a HTML5 interface
using the pyhpeimc python library for the HPE IMC Network Management System.

This sample app is provided under an Apache2 license.

 Copyright 2016 Hewlett Packard Enterprise Development LP.

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

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

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

url: https://raw.githubusercontent.com/manpowertw/leafspine-ops/59309bed802e6d11c7c801f893adfd9b188222b6/HPE IMC Real Time Locate Flask Sample App/README.md

repository: manpowertw/leafspine-ops

repo_name: manpowertw/leafspine-ops


text:
# easy-table

A smart table for read and search in memory. You can convert it between `csv string format` and `memory format`.

Example project: https://github.com/easy-csv/easy-table-example

## Table Format

Table format in memory.

    FieldHead   :  field_1 field_2 field_3 ... field_N
    Record_1    :   cell    cell    cell   ...  cell
    Record_2    :   cell    cell    cell   ...  cell
    Record_3    :   cell    cell    cell   ...  cell
      ...
    Record_N    :   cell    cell    cell   ...  cell

When the table is generated, the system will automatically generate an index map for field_1, we can find a record based on the key of field_1.

## Data Format
In memory, the table content has three data formats, but each field can only be one of them.

Suported format:

1. num: number, integer format
2. float: floating-point format
3. text: string format

## Field Declaration

The type of field can be specified in csv string.

    	key,fv1(type=float),fv2(type=float),num1(type=num),num2(type=num),txt1(type=text),txt2

If not specified, the default field type will be 'text'.

repository: easy-csv/easy-table

repo_name: easy-csv/easy-table


text:
---
layout: default
title: Exact Matching Only

nav_order: 4
permalink: /examples/exact_matching/
parent: Examples
---

# Exact Matching
{: .fs-9 }
The DAME or FLAME algorithm can be configured to be used for exact matching, using the early stopping criteria parameter `early_stop_iterations=1`. We illustrate this below. On a dataset with 200 units and five covariates that was generated with little randomness in which most covariate values are the same, we are only interested in exactly matched units. The output generated by the `verbose=3` parameter shows that the majority of units are matched after one iteration. We visualize the treatment effect of each group, or the CATE of each group, using matplotlib [1]. We also visualize the matched groups' sizes, which shows that one group has the majority of units.

``` python
import dame_flame
import matplotlib.pyplot as plt

df,_ = dame_flame.utils.data.generate_binomial_decay_importance(num_control=100, num_treated=100,
                    num_cov=5, bernoulli_param=0.9, bi_mean=2, bi_stdev=1)

model = dame_flame.matching.FLAME(verbose=3, early_stop_iterations=1)
model.fit(holdout_data=df)
res = model.predict(df)

groups = list(range(len(model.units_per_group)))
cate_of_group = []
len_group = []
for group in model.units_per_group:
    cate_of_group.append(dame_flame.utils.post_processing.CATE(model, group[0]))
    len_group.append(len(group))

f, ax = plt.subplots(1, 2, gridspec_kw = {'width_ratios':[1, 1]}, figsize=(12,4))
ax[0].set_ylabel('Treatment Effect of Group', fontsize=14)
ax[0].set_xlabel('Matched group ID number', fontsize=14)
ax[0].set_title('Treatment Effect of Each Group of Perfectly Matched Units', fontsize=14)
ax[0].bar(groups,cate_of_group)

ax[1].set_ylabel('Number of Units in Group', fontsize=14)
ax[1].set_xlabel('Matched group ID number', fontsize=14)
ax[1].set_title('Size of Each Group of Perfectly Matched Units', fontsize=14)
ax[1].bar(groups,len_group)

plt.tight_layout()
plt.savefig('treatment_effect_size_of_groups.png')
```

![Perfect Matching](https://raw.githubusercontent.com/almost-matching-exactly/DAME-FLAME-Python-Package/master/examples/treatment_effect_size_of_groups.png "Perfect Matching")

![Perfect Matching Verbose](https://raw.githubusercontent.com/almost-matching-exactly/DAME-FLAME-Python-Package/master/examples/exact_matching_verbose.PNG "Perfect Matching Verbose")

[Download Example From GitHub](https://github.com/almost-matching-exactly/DAME-FLAME-Python-Package/tree/master/examples/exact_matching.ipynb){: .btn .btn-primary .fs-4 .mb-4 .mb-md-0 }

References

  [1]

    Matplotlib: Grouped bar chart with labels

{: .fs-6 .fw-300 }


text:
# online-course-registeration-system
Online Course Registration System

# Built Using PHP(Procedural), HTML, CSS, JS(Vanilla & Ajax)
`Online Course Registration Using *CRUTECH Computer Science Department* as a case Study`


text:
<!-- Git ignore -->

# mrm-task-gitignore

[Mrm](https://github.com/sapegin/mrm) task that adds a `.gitignore` file.

## What it does

- Creates `.gitignore`.

## Usage

```
npx mrm gitignore
```

## Changelog

The changelog can be found in [CHANGELOG.md](CHANGELOG.md).

## Contributing

Everyone is welcome to contribute. Please take a moment to review the [contributing guidelines](../../Contributing.md).

## Authors and license

[Artem Sapegin](https://sapegin.me) and [contributors](https://github.com/sapegin/mrm/graphs/contributors).

MIT License, see the included [License.md](License.md) file.

repository: sapegin/mrm

repo_name: sapegin/mrm


text:
---
layout: post
title:      "Losing Redux State on Refresh"
date:       2020-12-01 15:54:21 +0000
permalink:  losing_redux_state_on_refresh
---

 weBudget is my final project. It is an application that helps keep track of your monthly expenses and debts. It was created with a react front end and rails api. I use redux and thunk to make async calls to my back end, the data received from the fetch goes to my redux store and the updated user information is saved to localStorage. I didn’t know what localStorage was before this project. But, on page refresh I would loose my redux state. So I did some research and found out I would have to save my state there. This is also when I really understood component lifecycles. Putting a debugger everywhere helped too.

	When I was losing global state on refresh and my tables would either show no data or the error ‘can not map property undefined,’ I was so confused. I didn’t do a fetch in component did mount of my app because a user needs to log in or sign up first. So, when app mounts it wouldn’t know which users information to get. Once logged in, the route changes to the users homepage and the user container component is rendered. Global state has the users information at this time. The user container takes that global state sets it in local state, passing it down to its children components as props.

	```
	<ExpensesTable currentUser={this.state.user.id} userExpenses={this.state.user.expenses} history={this.props.history} />
	<DebtTable currentUser={this.state.user.id} userDebts={this.state.user.debts} history={this.props.history}/>
	```

 The user container has two child components, 1) expenses table 2) debts table. They receive initial state from user container as props.

```

state = {
	user_id: 0,
	expenses: this.props.userExpenses ? this.props.userExpenses : [],
	sortConfig: {
		key: 'date_due',
		direction: 'ascending'
	}
}
```

 Each table component is connected to the redux store so they can use dispatch and have access to the store when expenses or debts are added or updated.

 The issue of losing global state was happening when you would refresh the page manually or when a refresh happens after a user submits an expense/debt. I tried putting a get fetch in component did mount of the user container. But because its async I couldn’t set local state in the user container using the redux store before the children components mount. So their props were empty. Causing the error can not map property of undefined.

 My fix, in each table, the component did mount lifecycle checks for a current user in local storage. If it finds one it means a user is signed in. Then it checks to see if any state was mapped to props from the redux store, if this is the case it means an instance has been created or updated and localStorage needs to update. If no state was mapped to props from the redux store, the component will grab the current user information from localStorage and set local state using that.

 Let's say an expense was added, the expense table would see that state was mapped to props in the component did mount lifecycle. Then, the component removes current user information from local storage, sets local state with new user data from redux store and puts that updated user data in to localStorage. Now on refresh my components always have a local state.

```
componentDidMount() {
		if (localStorage.getItem("currentUser")){
			if (this.props.user_expenses) {
				const currentUser = JSON.parse(localStorage.currentUser)
				delete currentUser.expenses
				delete currentUser.debts
				localStorage.removeItem('currentUser')
				currentUser.expenses = this.props.user_expenses.expenses
				currentUser.debts = this.props.user_expenses.debts
				this.setState({
					...this.state,
					expenses: this.props.user_expenses.expenses ? this.props.user_expenses.expenses : currentUser.expenses,
					user_id: currentUser.id,
				})
				saveState(currentUser)
			} else {
				const persistedState = { user: loadState() }
				this.setState({
				expenses: persistedState.user.expenses,
				user_id: persistedState.user.id
				})
			}
		}
	}
```

 I still have some features I want to add like, I want a user to be able to enter their pay days and I want to add a complete button that saves the completed months expenses to the db. But for now i’m satisfied with what I have. If you know of a better way to approach this problem, please let me know.

extension: markdown


text:
[![Version][version-shield]][version-url]
[![Contributors][contributors-shield]][contributors-url]

[![MIT License][license-shield]][license-url]

Quantum Layout Design Environment

    The next-generation object-oriented script-based PCell design environment.

    Explore the docs »

    Report Bug
    ·
    Request Feature

## Table of Contents

* [About the Project](#about-the-project)
  * [Built With](#built-with)
* [Getting Started](#getting-started)
  * [Prerequisites](#prerequisites)
  * [Installation](#installation)
* [Usage](#usage)
* [Roadmap](#roadmap)
* [Contribute](#contribute)
* [License](#license)
* [Contact](#contact)
* [Acknowledgements](#acknowledgements)

## About The Project

![phidl example image](https://github.com/rubenvanstaden/spira/blob/master/docs/_figures/_adv_jtl_false.png)

**SPiRA** is the next-generation object-oriented script-based PCell design environment.
The framework leverages the Python programming language to effectively generate circuit layouts,
while simultaneously checking for design violations, through a novel methodology called *validate-by-design*.
Creating PCells and extracting a model from a layout requires data from the fabrication process.
A new PDK scheme is introduced, called the Rule Deck Database (RDD), that effectively connects
process data to the SPiRA framework. The design of the **RDD** revolves around the principle that
a PDK cannot be created, but rather that it evolves as our understanding of physical layout design evolves.

### Benefits of using SPiRA

* Create a PCell framework that is easy to use by designers with the focus falling on Superconducting and Quantum Integrated Circuits.
* Effectively connect process data to layout elements in a generic process-independent fashion.
* No specific programming knowledge is required.
* Easily share designs between colleagues.
* Created PCells can easily be included in a hand-designed layout.

### Features

* Define layout elements in a templated environment.
* Ability to leverage object-oriented inheritance to simply complex designs.
* Comprehensive set of commands for shape generation.
* Use port objects to connect different layout elements.
* Use routing algorithms to generate polygonal paths between devices.
* Meticulously define a technology process using Python.

A list of used resources that was helpful in the development of the SPiRA framework.

### Built With

Love

## Getting Started

This is an example of how you may give instructions on setting up your project locally.
To get a local copy up and running follow these simple example steps.

### Prerequisites

This is an example of how to list things you need to use the software and how to install them in Fedora:

```bash
sudo dnf install redhat-rpm-config
sudo dnf install gcc-c++
sudo dnf install python3-devel
sudo dnf install tkinter
sudo dnf install gmsh
```

### Installation

You can install SPiRA directly from the Python package manager *pip* using and remember to create a *virtual environment*:

```bash
python3 -m venv env
source env/bin/activate

# Install requirements
pip install -r requirements.txt

# Normal install
pip install .

# Developer install
pip install -e .
```

## Usage

_For examples, please refer to the [Documentation](https://spira.readthedocs.io/en/latest/)_

All examples can be ran from the environment directory, which is the home directory of your ``spira`` folder.
For the basic tutorial samples:

```python
python tutorials/basic/_9_stretch_1.py
```

For the more advanced example with their own defined Rule Deck Database, as
explained [here](https://spira.readthedocs.io/en/latest/).

```python
python spira/technologies/default/circuits/ytron_circuit.py
```

## Roadmap

See the [open issues](https://github.com/rubenvanstaden/spira/issues) for a list of proposed features (and known issues).
As a short overview here is the project focus over the next 12 month:

* Complete netlist extraction and device detection from a native GDSII layout.
* Add graph isomorphic checks for differences between the extracted layout netlist and that of the designed SPICE netlist.
* Implement DRC algorithms and integration support with parameter extraction engines.

## Contribute

Contributions are what make the open source community such an amazing place to be learn, inspire, and create.
Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3.  Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

Distributed under the MIT License. See `LICENSE` for more information.

## Contact

* Ruben van Staden -<EMAIL_ADDRESS>* Coenrad Fourie -<EMAIL_ADDRESS>
* Kyle Jackman -<EMAIL_ADDRESS>* Joey Delport -<EMAIL_ADDRESS>

## Acknowledgements

* [Gdspy](https://github.com/heitzmann/gdspy)
* [Phidl](https://github.com/amccaugh/phidl)
* [Clippers](http://www.angusj.com/delphi/clipper.php)

## History of changes

### Version 0.2.0 (October 4, 2019)
* Added layout netlist extraction and viewing.
* Added electrical rule checking (ERC).
* Added **filters** for advanced layout manipulation.
* Updated ports for more information descriptions. Terminals can now be separated from port definitions.
* A new concept, called **virtual modeling** (VModel) is introduced. This allows you to create multiple, virtual versions of a single layout for either debugging or fabrication purposes.
* Routing algorithms have been updated to leverage speed improvements made in the Gdspy library.
* The GDSII parser has been updated for better code structure and faster read/write operations.

### Version 0.1.1 (July 16, 2019)
* Updated the advanced tutorial documentation.
* Added developers documentations.
* Updated the expand transform algorithms, which fixes a lot of known issues.
* Updated the GDSII input parser to use new transformation parameters.
* Changed the ``ref`` parameter to ``reference`` in ``SRef``.

### Version 0.1.0 (July 10, 2019)
* Added first version of documentation.
* Renamed ``Fields`` to ``Parameters`` to overcome confusion.
* Renamed ``elemental`` to ``elements``, since ``spira.Cell`` does not inherit from ``gdspy.Cell`` anymore.
* Added parameter restrictions and preprocessing capabilities.
* Updated parameters to accept an extra restriction argument.
* Introduces ``Vector``, ``Line``, and ``Coord`` classes.
* Depricated locked ports. Instead different port purposes can now be defined.
* Introduces *process* and *purpose* parameters to layer elements.
* Introduces *derived layers* to allow for layer boolean operations. This makes the RDD more flexible for future technology changes.
* Updated the edge generation algorithms to include both an outside and inside edge.
* Updated the routing algorithms to use new ``gdspy`` features.
* Added stretching operations.
* Extended the RDD to include *display resources*.
* Fix issues with writing to a GDSII file.
* Added snap to grid functionality.
* Implemented parameters caching.
* Added port alignment operations.
* Added `PortList` class for special port filtering functionality.
* Created layer mappers.
* Changed the default coordinate system to improve port transformations.
* Updates shapes and polygons to only include single polygons. Multiple polygons are now moved to the ``PolygonGroup`` class.
* Updated ports to extend from the ``Vector``.
* Added a custom ``LayerList`` class that compares already added layers.
* Updated mixins to a single ``MixinBowl`` meta-configuration.
* Updated the datatype parameter of ports that represents primitive connects.
* Added ``NumberParameter`` which supports 'int' and 'float' parameters.
* Added ``ComplexParameter`` which supports 'int', 'float' and 'complex' parameters.
* Added automatic docstring generation.

### Version 0.0.3 (March 12, 2019)
* Added Dummy ports for crossing nodes in netlist.
* Automatically generate terminal edges for metal polygons.
* Added shape for yTron.
* Added path routing between two terminals.
* Define a route using a list of terminals.
* Device cell detection (Junction, Via, etc).
* Basic LVS implementation.

### Version 0.0.2 (Jan 11, 2019)
* Implemented Manhattan routing between terminals.
* Integrated circleci.
* Started adding unit tests using pytest.
* Updated auto doc generation for classes.
* Added MidPointField for port and terminal midpoints.
* Introduces the Shape class that allows for complex point manipulations.
* Introduces `term` which is a vertical connection port.
* Routes are defined as a Shape with two connected terminal ports.

### Version 0.0.1 (Dec 01, 2018)
* Initial release.

[version-shield]: https://img.shields.io/badge/version-0.2.0-blue
[version-url]: https://github.com/rubenvanstaden/spira/blob/master/spira/settings.py
[contributors-shield]: https://img.shields.io/github/contributors/othneildrew/Best-README-Template.svg?style=flat-square
[contributors-url]: https://github.com/rubenvanstaden/spira/graphs/contributors
[forks-shield]: https://img.shields.io/github/forks/othneildrew/Best-README-Template.svg?style=flat-square
[forks-url]: https://github.com/rubenvanstaden/spira/network/members
[issues-shield]: https://img.shields.io/github/issues/othneildrew/Best-README-Template.svg?style=flat-square
[issues-url]: https://github.com/rubenvanstaden/spira/issues`
[license-shield]: https://img.shields.io/github/license/othneildrew/Best-README-Template.svg?style=flat-square
[license-url]: https://github.com/rubenvanstaden/spira/blob/master/LICENSE
[product-screenshot]: images/screenshot.png

repository: fluxbios/spira

gha_language: Python

repo_name: fluxbios/spira


text:
# React Native Scrollview Carousel

React Native Carousel with support for both iOS and Android.

## Installation

```
npm install react-native-scrollview-carousel --save
```

## Usage

```
import Carousel from "react-native-scrollview-carousel";
//...
<Carousel>
    <Text>Hello</Text>
    <Text>World!</Text>
    <Text>From carousel</Text>
</Carousel>
```

### pageStyle

Type: `PropTypes.object`

The style that will be applied on the page. For example:

```
<Carousel pageStyle={ {backgroundColor: "white", borderRadius: 5} }>
```

### initialPage

Type: `PropTypes.number`

The index of the initial page. The first page is `0`.

### onPageChange
! TBA !

Type: `PropTypes.func`

This function will be called every time the page changes.

### sneak

Type: `PropTypes.number`

How much of the adjacent pages will display.

## License

The MIT License (MIT)

Copyright (c) 2020 Simon Holland Flarup <mail@simonflarup.dk>.

repository: SimonFlarup/react-native-carousel

repo_name: SimonFlarup/react-native-carousel


text:
Here are the design patterns I used:
Fail early and fail loud.
 - I used this to verify that the parameters of the transactions.  If the params passed do not satisfy the requirements of the transactions then fail.  E.g purchaseProduct check the qty is available.
Restrict Access.
- I used this to restrict access to functions. Only users with valid roles can execute the function.  E.g. addStoreOwner can only be called by admin.

Implement mortal design.
- This is done by inheriting the Destructible contract.  I can call the destroy function to remove the contract.

I didn't used other design patterns such as Circuit breaker because I did not have the time.  I would add the Circuit Breaker to this when withdrawing from the store and destroying the contract.


text:
---
layout: post
title: Lane Detection Basic
---

When we drive, we use our eyes to decide where to go.  The lines on the road that show us where the lanes are act as our constant reference for where to steer the vehicle.  Naturally, one of the first things we would like to do in developing a self-driving car is to automatically detect lane lines using an algorithm. Project repo can be found [here](https://jiajuns.github.io/LaneDetectionBasic/)

[This project](https://jiajuns.github.io/LaneDetectionBasic/) demonstrate how to detect lane lines in images using Python and OpenCV. OpenCV means "Open-Source Computer Vision", which is a package that has many useful tools for analyzing images.

Below is an example for land detection:

<img src="https://raw.githubusercontent.com/jiajuns/LaneDetectionBasic/master/examples/laneLines_thirdPass.jpg" width="480" alt="Combined Image" />

To start
---
**Step 1:** Set up the [CarND Term1 Starter Kit](https://classroom.udacity.com/nanodegrees/nd013/parts/fbf77062-5703-404e-b60c-95b78b2f3f9e/modules/83ec35ee-1e02-48a5-bdb7-d244bd47c2dc/lessons/8c82408b-a217-4d09-b81d-1bda4c6380ef/concepts/4f1870e0-3849-43e4-b670-12e6f2d4b7a7) if you haven't already.

**Step 2:** Open the code in a Jupyter Notebook [P1.ipynb](https://github.com/jiajuns/LaneDetectionBasic/blob/master/P1.ipynb)

Method Description
---
The pipeline consists of 5 steps.

1. Convert images to grayscale,then apply gaussian blur to smooth the image.

{% highlight python %}
def grayscale(img):
    """Applies the Grayscale transform
    This will return an image with only one color channel
    but NOTE: to see the returned image as grayscale
    (assuming your grayscaled image is called 'gray')
    you should call plt.imshow(gray, cmap='gray')"""
    return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    # Or use BGR2GRAY if you read an image with cv2.imread()
    # return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

def gaussian_blur(img, kernel_size):
    """Applies a Gaussian Noise kernel"""
    return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)

kernel_size = 5
gray = grayscale(image)
blur_gray = gaussian_blur(gray, kernel_size)
{% endhighlight %}

2. Obtain edges using canny edge detection.

{% highlight python %}
def canny(img, low_threshold, high_threshold):
    """Applies the Canny transform"""
    return cv2.Canny(img, low_threshold, high_threshold)

low_threshold = 80
high_threshold = 150
edges = canny(blur_gray, low_threshold, high_threshold)
{% endhighlight %}

3. Apply a mask to clean up the edges that are not in the interests region.

{% highlight python %}
def region_of_interest(img, vertices):
    """
    Applies an image mask.

    Only keeps the region of the image defined by the polygon
    formed from `vertices`. The rest of the image is set to black.
    """
    #defining a blank mask to start with
    mask = np.zeros_like(img)

    #defining a 3 channel or 1 channel color to fill the mask
    if len(img.shape) > 2:
        channel_count = img.shape[2]  # i.e. 3 or 4 depending on your image
        ignore_mask_color = (255,) * channel_count
    else:
        ignore_mask_color = 255

    cv2.fillPoly(mask, vertices, ignore_mask_color)
    masked_image = cv2.bitwise_and(img, mask)
    return masked_image

mask = np.zeros_like(edges)
ignore_mask_color = 255

# define a four sided polygon to mask
imshape = img.shape
vertices = np.array([[(0,imshape[0]), (imshape[1]/2, 3*imshape[0]/5), (imshape[1]/2, 3*imshape[0]/5), (imshape[1],imshape[0])]], dtype=np.int32)
masked_edges = region_of_interest(edges, vertices)
{% endhighlight %}

4. Use hough transformation to fit lanes to the image.

{% highlight python %}
def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):
    """
    `img` should be the output of a Canny transform.

    Returns an image with hough lines drawn.
    """
    lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)
    line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
    draw_lines(line_img, lines)

    return line_img

# Define the Hough transform parameters
# Make a blank the same size as our image to draw on
rho = 1 # distance resolution in pixels of the Hough grid
theta = np.pi/180 # angular resolution in radians of the Hough grid
threshold = 30     # minimum number of votes (intersections in Hough grid cell)
min_line_len = 30 #minimum number of pixels making up a line
max_line_gap = 10    # maximum gap in pixels between connectable line segments
line_image = np.copy(image)*0 # creating a blank to draw lines on

# Run Hough on edge detected image
# Output "lines" is an array containing endpoints of detected line segments
line_img = hough_lines(masked_edges, rho, theta, threshold, min_line_len, max_line_gap)
line_img = region_of_interest(line_img, vertices)
{% endhighlight %}

5. Draw fitted lanes onto the raw image.
{% highlight python %}
def draw_lines(img, lines, color=[255, 0, 0], thickness=2):
    imshape = img.shape
    for line in lines:
        for x1,y1,x2,y2 in line:
            k = (y2-y1)/(x2-x1)
            b = y2 - k*x2
            try:
                extra_x1 = int((imshape[0] - b)/k)
                extra_x2 = int((-b)/k)
                cv2.line(img, (extra_x1, imshape[0]), (extra_x2, 0), color, thickness)
            except:
                continue
{% endhighlight %}


text:
# MatchingDeclarationName

"If a Kotlin file contains a single non-private class (potentially with related top-level declarations),
its name should be the same as the name of the class, with the .kt extension appended.
If a file contains multiple classes, or only top-level declarations,
choose a name describing what the file contains, and name the file accordingly.
Use camel humps with an uppercase first letter (e.g. ProcessDeclarations.kt).

The name of the file should describe what the code in the file does.
Therefore, you should avoid using meaningless words such as "Util" in file names." - Official Kotlin Style Guide

More information at: https://kotlinlang.org/docs/coding-conventions.html

## Noncompliant Code

```kotlin
class Foo // FooUtils.kt

fun Bar.toFoo(): Foo = ...
fun Foo.toBar(): Bar = ...
```
## Compliant Code

```kotlin
class Foo { // Foo.kt
    fun stuff() = 42
}

fun Bar.toFoo(): Foo = ...
```

[Source](https://arturbosch.github.io/detekt/naming.html#matchingdeclarationname)

repository: codacy/codacy-detekt

gha_language: Scala

gha_license_id: NOASSERTION

repo_name: codacy/codacy-detekt


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

### Description

An issue was discovered in dbus-broker before 31. It depends on c-uitl/c-shquote to parse the DBus service's Exec line. c-shquote contains a stack-based buffer over-read if a malicious Exec line is supplied.

### POC

#### Reference
- https://sec-consult.com/vulnerability-lab/advisory/memory-corruption-vulnerabilities-dbus-broker/

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Tutorial

Let's write some code!

```haskell
{-# LANGUAGE TemplateHaskell     #-}
{-# LANGUAGE DataKinds           #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Tutorial where
import Language.PlutusTx
import Language.PlutusTx.Lift
import Language.PlutusCore
import Language.PlutusCore.Pretty
import Language.PlutusCore.Quote
import Language.PlutusCore.Evaluation.CkMachine
```

## Writing basic PlutusTx programs

The `CompiledCode` type is an opaque type which contains the serialized Plutus Core code
corresponding to a Haskell expression. The `compile` function takes a typed Template Haskell
`Q (TExp a)`, for any a, and produces a `Q (TExp CompiledCode)`, which we then
have to splice into our program.

The fact that `compile` takes a TH quote means that what you write inside the quote
is *just normal Haskell* - there is no PlutusTx-specific syntax, and the PlutusTx compiler will
tell you if you use any Haskell features which are not supported.

Here's the most basic program we can write: one that just evaluates to the integer `1`.

```haskell
-- |
-- >>> prettyPlcDef $ getPlc integerOne
-- (program 1.0.0
--   (con 8 ! 1)
-- )
integerOne :: CompiledCode
-- We don't like unbounded integers in Plutus Core, so we have to pin
-- down that numeric literal to an `Int` not an `Integer`.
integerOne = $$(compile [|| (1 :: Int) ||])
```

The Plutus Core program will look incomprehensible, which is fine, since you
mostly won't want to look at the output of the compiler. However, it's instructive to
look at it here just to get a vague idea of what's going on.

We can already see a few features of Plutus Core here:
- The program includes the *language version*. This ensures that we always know how to handle
  programs once they're on the chain.
- Integers have *sizes*, in this case 8 bytes (64 bits).

Both of these things are handled for us by the compiler.

Here's a slightly more complex program, namely the identity function on integers.

```haskell
-- |
-- >>> prettyPlcDef $ getPlc integerIdentity
-- (program 1.0.0
--   (lam ds [(con integer) (con 8)] ds)
-- )
integerIdentity :: CompiledCode
integerIdentity = $$(compile [|| \(x:: Int) -> x ||])
```

So far, so familiar: we compiled a lambda into a lambda.

You can also define functions locally to use inside your expression. At the moment you
*cannot* use functions that are defined outside the PlutusTx expression, although hopefully
this will be easier in future. You can, however, splice in TH quotes, which lets you define
some reusable components.

```haskell
plusOne :: Int -> Int
plusOne x = x + 1

functions :: CompiledCode
functions = $$(compile [||
    let
        plusOneLocal :: Int -> Int
        plusOneLocal x = x + 1
        -- This won't work.
        -- nonLocalDoesntWork = plusOne 1
        localWorks = plusOneLocal 1
        -- You can of course bind this to a name, but for the purposes
        -- of this tutorial we won't since TH requires it to be in
        -- another module.
        thWorks = $$([|| \(x::Int) -> x + 1 ||]) 1
    in localWorks + thWorks
    ||])
```

From this point on we're going to start dealing with more advanced features of
Haskell, like datatypes. The way these are encoded into Plutus Core is quite
tricky, so we're going to stop looking at the generated Plutus Core code, but
it's in there if you're curious.

TODO: when we store the PIR, start showing PIR at this stage (or earlier).

We can use normal Haskell datatypes and pattern matching freely:

```haskell
matchMaybe :: CompiledCode
matchMaybe = $$(compile [|| \(x:: Maybe Int) -> case x of
    Just n -> n
    Nothing -> 0
   ||])
```

This works for your own datatypes too! (See [Haskell language support](#haskell-language-support)
for some caveats.) Unlike functions, datatypes do not need to be defined inside the
expression, hence why we can use types like `Maybe` from the `Prelude`.

Here's a small example with a datatype of our own representing a potentially open-ended
end date.
```haskell
data EndDate = Fixed Int | Never

shouldEnd :: CompiledCode
shouldEnd = $$(compile [|| \(end::EndDate) (current::Int) -> case end of
    Fixed n -> n <= current
    Never -> False
   ||])
```

## Using PlutusTx builtins

PlutusTx has some builtin types and functions available, both for working with primitive
data (integers and bytestrings), and also for performing chain-specific operations.

The PlutusTx builtins are available via the `Language.PlutusTx.Builtins` module. You
shouldn't need to use the integer and bytestring builtins directly, these are mapped
to the corresponding Haskell operations on `Int` and lazy `ByteString` directly. However,
you may wish to use some of the others.

`error` deserves a special mention. `error` causes the transaction to abort when it is
evaluated, which is the way that validation failure is signalled.

## Lifting values

This is all very good for defining pieces of code *statically*, but you are
likely to want to *dynamically* produce Plutus Core programs. For example, you
might be writing the body of a transaction to initiate a crowdfunding smart contract,
which would need to be parameterized by user input determining the size of the goal,
the campaign start and end times, etc.

You can do this by writing the static code as a function, and then passing an
argument at runtime by *lifting* it and then applying the two programs together. As a
very simple example, let's write an add-one function.

```haskell
-- TODO: show PIR here too

-- |
-- >>> prettyPlcDef $ addOneToN 4
-- (program 1.0.0
--   [
--     [
--       (lam
--         addInteger
--         (fun [(con integer) (con 8)] (fun [(con integer) (con 8)] [(con integer) (con 8)]))
--         (lam ds [(con integer) (con 8)] [ [ addInteger ds ] (con 8 ! 1) ])
--       )
--       { (builtin addInteger) (con 8) }
--     ]
--     (con 8 ! 4)
--   ]
-- )

-- >>> prettyPlcDef $ runCk program
-- (con 8 ! 5)
addOneToN :: Int -> Program TyName Name ()
addOneToN n =
    let addOne = $$(compile [|| \(x:: Int) -> x + 1 ||])
    in (getPlc addOne) `applyProgram` unsafeLiftProgram n
```

Here we have lifted the Haskell value `4` into a Plutus Core term at runtime.
In order to do this, a type must have an instance of the `LiftPir` class. In
practice, you should generate these with the `makeLift` TH function from
`Language.PlutusTx.Lift`. This makes it easy to use the same types both inside your
PlutusTx program and in the external code that uses it.

(The reason we're using the "unsafe" is that we're not worrying about e.g. errors due to
unsupported Haskell features.)

The combined program just applies the compiled lambda to the lifted value
(notice that the lambda is a bit complicated now since we have compiled the addition
into a builtin). We've then used the CK evaluator for Plutus Core to evaluate
the program and check that the result was what we expected

Here's an example with our custom datatype. The mysterious output is the encoded version of `False`.

```haskell
makeLift ''EndDate

-- |
-- >>> let program = shouldEndAt Never 5
-- >>> prettyPlcDef $ runCk program
-- (abs
--   out_Bool (type) (lam case_True out_Bool (lam case_False out_Bool case_False))
-- )
shouldEndAt :: EndDate -> Int -> Program TyName Name ()
shouldEndAt end current =
    (getPlc shouldEnd)
    `applyProgram`
    unsafeLiftProgram end
    `applyProgram`
    unsafeLiftProgram current
```

This is more or less all you need to get started - from here on it should mostly
be like writing normal Haskell.

repository: nathankaiser/plutus

repo_name: nathankaiser/plutus


text:
# SecondaWeb

SecondaWeb is an asp net core site, using a Data Base Identity Framework

Add Entity Framework, SQLIte, and Identity libraries to the project.
```
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design

```
## What can it do?

- using the MS Identity library for user authentication
- use the 4 CRUD operations
- implement the following theme: https://html5up.net/spectral choosing it based on your registration number
- can Upload file

## Site :

https://pasquinellimartinasecondaweb.azurewebsites.net

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


text:
---
name: "\U0001F41B Bug Report"
about: Something isn't working as expected

---

## Bug Report

Please answer these questions before submitting your issue. Thanks!

1. What did you do? If possible, provide a recipe for reproducing the error.

2. What did you expect to see?

3. What did you see instead?

4. Versions of the cluster

    - Dumpling version (run `dumpling -V`):

        ```
        (paste Dumpling version here)
        ```

    - Source database version (execute `SELECT version();` in a MySQL client):

        ```
        (paste source database version here)
        ```

    - Other interesting information (system version, hardware config, etc):

        >
        >

5. Operation logs
   - Please upload `dumpling.log` for Dumpling if possible
   - Other interesting logs

6. Configuration of the cluster and the task
   - running command for Dumpling if possible

repository: sylzd/dumpling

gha_language: Go

repo_name: sylzd/dumpling


text:
# Checkout Bricks

Checkout Bricks is a set of user interface modules that enable a modular client-side integration through configurable, secure, and simplified unified structures.

Below are the Bricks available in the SDK.

| Brick | Description |
|---|---|
| Payment | Enables payments with various payment methods. |
| Card | Enables payments with cards. |
| Wallet | Enables payments with Mercado Pago, including installment payments without a card. |
| Status screen | Enables displaying the payment status. |

Below is an example of how to use them.

[[[
```react-jsx
import React from 'react';
import { Payment, initMercadoPago } from '@mercadopago/sdk-react'

initMercadoPago('<YOUR_PUBLIC_KEY>');

const App = () => {
 const initialization = {
   amount: '<PAYMENT_AMOUT>'
 };
 const customization = {
   paymentMethods: {
     atm: 'all',
     ticket: 'all',
     bankTransfer: 'all',
     creditCard: 'all',
     debitCard: 'all',
     mercadoPago: 'all',
   },
 };

 return (
   <Payment
     initialization={initialization}
     customization={customization}
     onSubmit={async (param) => {
       console.log(param);
     }}
   />
 );
};

export default App;

```
]]]

To integrate Checkout Bricks using the SDK, see the [Common initialization](/developers/en/docs/checkout-bricks/common-initialization) documentation.

repository: mercadopago/devsite-docs

branch_name: refs/heads/development

repo_name: mercadopago/devsite-docs


text:
# 1.1 Think About Time Reflection

I was somewhat aware of most of these techniques and have used various elements of them before. I have meditated for some years (though sporadically) and certainly know the benefits of that. And I read the book “Flow” which I really liked. Flow seems to be a kind of combination of meditation and activity. I have certainly gotten into this state before and know how productive and pleasurable it can be. I do believe our modern multi-tab open, notifications filed lifestyles make it hard to get into the flow state.

Though I think one thing I learned was just this idea of micro habits, and how effective they can be. I think the one thing that has always been hardest for me is irregular time management. Working independently and having your own business creates a situation where you don’t have external structures, timelines or accountability much of the time, so its hard to create your own structure and regular schedule if no one is doing that for you. Habits can help with this, but I have always had a hard time developing regular habits, many times because i try to change them all at once or in large ways. Micro habits can really help this. Learning about how to use those will be helpful.

What is "Time Boxing?" How can you use it in Phase 0?

Time boxing is the practice of creating limited and defined blocks of time to work in and stopping/ reviewing when those times are up, or taking a break. Instead of just working in undefined time until a task or project is done, you break it into concrete limited blocks of work time. I think this can be great in phase 0 to not get lost in any one task, which I am certainly capable of doing. I can also be used to not mentally tire or burn yourself out.

How do you manage your time currently?

Currently I don’t really manage my time in any concrete way. Which is a problem. Mostly because my work is project based, I can from times of full on intense activity to times of nebulous or low activity.

Is your current strategy working? If not, why not?

No my current strategy doesn’t work simply because it is too extreme between the pendulums. I tend to burn myself out when working on something and then being unable to get things going when I am not working on something.

Can/will you employ any of them? If so, how?

Yes I think micro habits and time blocks will be helpful. Micro habits for creating waypoints and pillars in the day to structure things around, and then time blocks for preventing burn out and allowing one to get into a flow state without distractions.

What is your overall plan for Phase 0 time management?

For phase0 I will create a series of micro morning habits that get my day started in a regular way. I will then use time blocks, and record that time to measure regular progress on tasks.

# 1.2 The Command Line Reflection

What is a shell? What is "bash?"

Shell is the command line interface to interact with the computer. Bash is the unix/osx version of shell, the command line language, I believe.

What was the most challenging for you in going through this material?

The most challenging thing was actually the typing. I need to practice and increase my typing accuracy. I do a lot of writing so I type fast but due to the leeway of autocorrect my typing is a bit sloppy.

Were you able to successfully use all of the commands?

I was able to use most all of the terminal commands, but the practice will of curse becoming fluent in them.

In your opinion, what are the most important commands and arguments to know?

It’s hard to to say which shell commands might be the most important at this point. It seems like many of the more advanced ones will be replaced by programs outside of the terminal. But I think the list important ones will be the directory and navigating commands to see and locate directories and files, like cd, ls, and the maybe to search files like grep. Honestly hard to say at this point as it seems some of these might be taken over by a text editor.

Can you remember what each of the following does of the top of your head? Write what each does.

pwd - prints the directory you are currently in
ls- lists what is in side the directory you are
mv- moves the file or directory you are in
cd- move into a new directory, forward or backwards
../ - command for moving back or up a directory
touch - ???
mkdir - create a new directory
less - lets you read through a file page by page.
rmdir - remove a directory
rm - remove a file
help - get help on a term or command, I believe this is the Windows shell term, not the OS X one.

# 1.4 Forking and Cloning Reflection

What is a shell? What is "bash?"

Shell is the command line interface to interact with the computer. Bash is the unix/osx version of shell, the command line language, I believe.

What was the most challenging for you in going through this material?

The most challenging thing was actually the typing. I need to practice and increase my typing accuracy. I do a lot of writing so I type fast but due to the leeway of autocorrect my typing is a bit sloppy.

Were you able to successfully use all of the commands?

I was able to use most all of the terminal commands, but the practice will of curse becoming fluent in them.

In your opinion, what are the most important commands and arguments to know?

It’s hard to to say which shell commands might be the most important at this point. It seems like many of the more advanced ones will be replaced by programs outside of the terminal. But I think the list important ones will be the directory and navigating commands to see and locate directories and files, like cd, ls, and the maybe to search files like grep. Honestly hard to say at this point as it seems some of these might be taken over by a text editor.

Can you remember what each of the following does of the top of your head? Write what each does.

pwd - prints the directory you are currently in
ls- lists what is in side the directory you are
mv- moves the file or directory you are in
cd- move into a new directory, forward or backwards
../ - command for moving back or up a directory
touch - ???
mkdir - create a new directory
less - lets you read through a file page by page.
rmdir - remove a directory
rm - remove a file
help - get help on a term or command, I believe this is the Windows shell term, not the OS X one.

# 1.5 Tracking Changes

Tracking adding changes helps developers because it allows a road map to find bugs should they arise. If at some point your code stops working, you can go back the point where it was working and then solve from there.

Commit messages should be simple, short descriptions of what changes were made. They should be written in the imperative verb tense for compatibility. If longer than one line, the message can have a title line and then a body that includes more description if necessary.

The HEAD^ argument allows you to reference, access and change files from the last commit.

The three git stages are modified, staged, and committed. Modified simply means a file has been changed. Staged means the file has been added to the stage to be committed on the next commit. And commit means it has been committed to the repository. to go from stage to stage you use the commands “git add” and “git commit”.

GIT CHEAT SHEET
git add .  ==> add modified files to the stage
git commit ==> commit all the files in the staging area to the repository.
git status ==> check the current status of files and where they are in the git progression.

A pull request is used to bring a remote repository onto your local machine. Doing this will “pull" will automatically merge this with your local repository, or you can use “fetch” and then “merge”.

Pull requests and working on branches are preferable when working with teams in order to ensure that people are again working in sync and to make sure that people are not working from code that hasn’t been approved.

# 1.6 Your Website, part 1

http://joecase.github.io/

To create a new repository on Github, click the plus icon next to your photo on your github page, then select “New Repository”. To clone the repo to your local machine, to the repo on gihub and copy the URL for the repo (SSH if you have SSH setup, HTTPS if you do not). to to terminal, navigate to the directory you want to clone the repo to and give the command “git clone” and then past the URL

Open source is the process of sharing the source code to software and making it free and open for anyone to use, change and improve upon.

I think open source is fantastic for certain things. It is a kind of utopia. Obviously it gives anyone the chance to start a project from an already rich code base, and also allows free tools to be give out to a lot of people. Obviously if I had some kind of revolutionary tech I was developing, I probably wouldn’t make it open source, but I think a lot of the greatest technology advancements have come from open source software.

I guess the importance of licenses is to somehow create legal precedence, if something did arise. I think most of the time, if you are open source, you probably don’t care much what license you are using. From the opposite of a protection standpoint, a license can give clear permission to anyone to help out, which they might not if they think they won’t be able to use it. I think it is a simple good practice.

The pulling process was solidified. Since “pulling” goes in multiple directions I was a bit confused.

Nope, I figured it out mostly from the provided resources and I had a bit of experience with it before.

gha_language: Ruby


text:
### Slick Support Fragment

Adds support for Support Fragment

```groovy
implementation 'com.mrezanasirloo:slick-support-fragment:x.x.x'
```

**_NOTE:_** Since the `android.app.Fragment` has been deprecated in Android P, Consider using this package.

repository: Mr-Smithy-x/Slick

repo_name: Mr-Smithy-x/Slick