text:
# Chooser browser client

The main chooser UI is implemented as a browser-based javascript application. This is incorporated into the chooser app as assets.

This directory is a re-implementation of the chooser browser app.

Status: initial skeleton (scss/coffeescript/zurb-foundation)

## Building the client

Trying out lots of new JS technologies here - coffee script, sass, stitch,
backbone, zurb foundation...

For initial project set-up I'm following [The Little Book on Coffee Script, chapter 6](http://arcturo.github.io/library/coffeescript/06_applications.html) and [Zurb's getting started with sass](http://foundation.zurb.com/docs/sass.html).

You'll need npm, node, coffescript, zurb foundation tool(s), e.g. (ubuntu 10.x)
```
sudo apt-get install npm
sudo apt-get install nodejs-legacy

sudo npm install -g coffee-script

sudo apt-get install ruby1.9.1

sudo gem install compass
```

If you are going to try updating the version of foundation used you might need:
```
sudo npm install -g bower
sudo gem install foundation
```

Get dependencies:
```
npm install coffee-script stitch express eco
```

Re-generate the CSS from SCSS (if changed, only):
```
compass compile
```

Export the assembled application.js:
```
coffee build.coffee
```

Runs as server on [port 9294](http://<IP_ADDRESS>:9294) by default:
```
coffee index.coffee
```

repository: cgreenhalgh/opensharingtoolkit-kiosk

repo_name: cgreenhalgh/opensharingtoolkit-kiosk


text:
# ml-react-app

A simple Machine Learning application built on a Flask backend and React frontend

![alt text](https://github.com/fowad-sohail/ml-react-app/blob/master/images/functionality.png)

This project was built following [this](https://towardsdatascience.com/create-a-complete-machine-learning-web-application-using-react-and-flask-859340bddb33) tutorial.

This serves as initial research and development for a larger AI project - a frontend web app that detects brain tumors in MRI scans.

license: MIT

repository: fowad-sohail/ml-react-app

branch_name: refs/heads/master

extension: md

gha_language: Tcl

gha_license_id: MIT

license_type: permissive

repo_name: fowad-sohail/ml-react-app


text:
# Aeon Desktop Theme for Foxhole

This [Foxhole for Starling](https://github.com/joshtynjala/foxhole-starling) theme based on the theme used by the Flash Pro and the Flex 2-3 component sets.

## Credits

The Aeon theme is originally designed by Adobe Systems Incorporated. Contains modifications by [Josh Tynjala](http://twitter.com/joshtynjala).

## Preview

Coming Soon

repository: mplord/foxhole-starling-examples

repo_name: mplord/foxhole-starling-examples


text:
# Full-Stack Udacity Project 4

## Item Catalog: Restaurant menu items

Homepage
add codepen link

## description of project
You will develop an application that provides a list of items within a variety of categories as well as provide a user
registration and authentication system. Registered users will have the ability to post, edit and delete their own items.

## About this project
* Using relational database through an ORM
* Using Template engine
* Using CRUD
* Using python3
* Using OOP language

To run this final project

Install flask : sudo pip install Flask

Dependencies:
* SQL Alchemy
* Template engine: http://jinja.pocoo.org/docs/2.10/templates/

### Getting Started
1. run `python3 database_setup.py to create the database
2. run `python3 lotsofmenus.py to populate the database
3. run `python3 ./item-catalog.py and navigate to localhost:5000 in your browser

### Whats used
- Python v3
- Flask v1.11
- SQL Alchemy
- Styling
    - CSS
    - Bulma css
    - fontawesome
- JS
    - Jquery

### Database
- Restaurant
- MenuItem

### Routes
- /
- /about
- /latest
- /restaurants
- /reservations
- /photos
- /restaurant/new/
- /restaurant/<int:restaurant_id>/edit/
- /restaurant/<int:restaurant_id>/delete/
- /restaurant/<int:restaurant_id>/
- /restaurant/<int:restaurant_id>/menu/new/
- /restaurant/<int:restaurant_id>/menu/<int:menu_id>/edit
- /restaurant/<int:restaurant_id>/menu/<int:menu_id>/delete

### Future requirements
* Tidy up design
* Add more json routes
* Potentially rename Menu to recipe
* Validate forms
* Error Handle SQL ALCHEMY
* Move model and queries into a module

repository: UndreamtMayhem/Back-End-Dev

gha_language: HTML

repo_name: UndreamtMayhem/Back-End-Dev


text:
ResqueUi
--------

Resque UI is a Rails engine port of the Sinatra app that is included in Chris Wanstrath's resque gem.  We love the gem and love the UI,
but just didn't want to add Sinatra to our stack and wanted to be able to manage the queues from the UI.

Installation
------------

    sudo gem install resque_ui

Or just add it to your Gemfile

    gem 'resque_ui'

Once installed, you now have a resque controller, so you can get to the ui with:  http://your_domain/resque.

If you have your default routes disabled, which you should if you have a RESTful API, then you'll need to add this to
the top of your routes.rb file.

For Rails 3.1.x +

    # Resque UI
    match 'resque(/:action(/:id))', :controller => 'resque'

For old Rails 3.0.x branch

    # Resque UI
    map.connect 'resque/:action/:id', :controller => 'resque'

Dependencies
------------

This engine now requires rails 3.0.0 or greater.

This engine now requires redis 2.1.3 or greater for the expiration of keys to work correctly.

This engine requires the resque 1.5 or higher gem.

This engine now requires the resque-status 0.2.2 or higher gem.

This engine now requires the resque-cleaner 0.2.6 or higher gem.

These gems will all be installed for you automatically when you install resque_ui.

Times Fixed
-----------

The displaying of times is fixed.  Some browsers displayed "Nan days ago" for all process times in the original Sinatra app.
Fixed the stats/keys page.  The page wasn't showing the keys' types, size or values.

Display Process Status
----------------------

Added the ability to display process status in the worker "Processing" column on the workers and working pages.
To do this, yield the status message back in your perform method.  You should check that a block was sent. If you
set Resque.inline = true in development, then the block is not passed.

    Class YourClass

      self.perform(arg)
      ...your code here
      yield "Your status message" if block_given?
      ...more code
      yield "Another status message" if block_given?
      ...more code
      end
    end

This is really handy for those long running jobs to give you assurance the the job is really running or not.

![Status Messages](http://img.skitch.com/20100308-8mk5hrwnu462q2d23d51n8cjxp.png)

Restart Failed Jobs
-------------------

Added the Resque Cleaner gem to manage the failed queue.  Have complete control over the failed queue now with the
Cleaner tab by querying and restarting failed jobs.

See what all you can do on the github page:  https://github.com/ono/resque-cleaner

Remove Items from the Queue
---------------------------

Added the ability to remove jobs, from a queue

![Remove Items from the Queue](http://img.skitch.com/20100308-qukiw7bpsnr9y1saap7f8276qx.png)

View Processed Job Info
-----------------------

![Job Status](https://img.skitch.com/20110309-r9mhfgnn8w63ep29sik4c6khcj.png)

Resque_ui now incorporates the resque-status gem and replaced the Processed tab with the Status tab. You can read about
what you can do with resque-status [here](https://github.com/quirkey/resque-status).

I've added some additional functionality to the resque-status gem.  Namely, I've added a Resque::ChainedJobWithStatusClass.
We process a lot of data files.  Each part of the file's process is handled by a different worker.  One worker may convert
a file into a different format, then another will parse that file and peel each record off the file and put each individual
record on a separate queue.  A separate worker may then do any post processing when the file is complete.

I wanted all of that to show under a single status.  So to do that, the very first worker class inherits from
Resque::JobWithStatus, and everything after that inherits from Resque::ChainedJobWithStatus.  When you call #create on
the chained job from the preceding job, you just need to pass {'uuid' => uuid} as one of the hash arguments.

    class DataContributionFile < Resque::JobWithStatus
        @queue = :data_contribution

        def perform
            ...your code here
            tick "Retrieving file."
            ...more code
            tick "Peeling #{file_path}"
            SingleRecordLoader.create({'uuid' => uuid, 'row_data' => hash_of_row_data, 'rows_in_file' => total_rows})
        end
    end

    class SingleRecordLoader < Resque::ChainedJobWithStatus
        @queue = :single_record_loader

        def completed(*messages)
            if counter(:processed) >= options[:rows_in_file].to_i
            super("#{options[:rows_in_file]} records processed: Started(#{status.time.to_s(:eastern_time_zone_long)}) Finished(#{Time.now.to_s(:eastern_time_zone_long)})")
            post_process
        end

        def perform
            ...your code here

            incr_counter(:processed)
            at((self.processed), options[:rows_in_file], "#{(self.processed)} of #{options[:rows_in_file]} completed.")
        end
    end

So now, the data_contribution worker and the single_record_loader workers will update the same status on the status page.
You can call #tick or #set_status to add messages along the way too.

You will want to override the completed method so that it isn't called until the very end of the entire process.

I've also added two more methods, #incr_counter(:counter) and #count(:counter).  We have dozens of single_record_loader
workers processing records at a time.  You encounter a race condition when they are all calling #at at the same time to
update the :num attribute.  So I created these two methods to atomically increment a dedicated counter.  Just call #incr_counter
and pass in a symbol for what you want to call the counter.  You can create any number of different counters
for different purposes.  We keep track of different validation issues for each record.  Use #counter and pass is the same
symbol to read the integer back.  The redis entries created by these methods all get cleaned up with a call to Resque::Status.clear(uuid)

When you kill a job on the UI, it will kill all the workers in the chain.

Pause a Worker
--------------

The workers page now has a button for every worker to pause that worker.

### Regular Workers

For workers that do not inherit from JobWithStatus, this will pause the worker, but not the job.  So if the worker is in
the middle of a job when it is paused, it will finish it's process, but then will not pick anything else up off the queue.

You can manually pause the processing though.

yield, which is used to set the workers status, as described above, now returns the worker.

    Class YourClass

      self.perform(arg)
      ...your code here
      worker = yield "Your status message" if block_given?

      if worker && worker.paused?
          loop do
            break unless worker.paused?
            sleep 60
          end
        end
      end

      ...continue
    end

Remember to check that a block was sent. If you set Resque.inline = true in development, then the block is not passed.

### JobWithStatus Workers

For workers that do inherit from JobWithStatus or ChainedJobWithStatus, this will pause the worker, and will automatically pause the job it is processing
on the next call to #tick.  The worker is also available to JobWithStatus so you can manually check it's status as well.

    Class YourClass << Resque::JobWithStatus

    def perform
      ...your code here
      tick "Retrieving file."  #You're process with pause here automatically and the status on the Status tab will be set to paused if the worker is paused.

      #Alternatively, you have access to the worker, so you can pause the process yourself too.
      if worker && worker.paused?
          # There could be workers in a chained job still doing work.
          loop do
            pause! unless status.paused?
            break unless worker.paused?
            sleep 60
          end
          tick("Job resumed at #{Time.now}")
        end

      ...continue
    end

    This will only pause the work being processed by the worker that was paused.  If the job is paused by the call to #tick,
    the job will sleep for 60 seconds before checking the status again.

    You may have a series of ChainedJobWithStatus and you want all processing in the chain stopped.

    Class YourClass << Resque::ChainedJobWithStatus

    def perform
      ...your code here
      tick "Retrieving file."  #You're process with pause here automatically and the status on the Status tab will be set to paused if the worker is paused.

      #Alternatively, you have access to the worker, so you can pause the process yourself too.
      if (worker && worker.paused?) || status.paused?
          # There could be workers in a chained job still doing work.
          loop do
            pause! unless status.paused?
            break unless worker.paused?
            sleep 60
          end
          tick("Job resumed at #{Time.now}")
        end

      ...continue
    end

    By looking at the status.paused? method too, this process will stop, even if it's worker has not been paused.
    But be aware, if this worker does other jobs, it will not process anything else and it's queue could get backed up.
    This is where pausing one worker, could affect other, unrelated workers and jobs from getting backed up as well.

Throttle a Queue
----------------

A throttle method has been added.  This is useful if you have a queue that tends to have very high volume, for example,
the queue that process all the individual records of a file.  You don't want to load that queue up with 1 million entries,
possibly blowing out the memory of your Redis server.

    FasterCSV.foreach(self.file_path, :headers => true, :quote_char => '"') do |row|
        Resque.throttle(:single_record_loader, 10000, 30)
        SingleRecordLoader.create({'uuid' => uuid, 'row_data' => row.to_hash, 'rows_in_file' => total_rows})
    end

Putting the throttle before enqueing the SingleRecordLoader will check the single_record_loader queue to make sure it has
less than 10000 entries in it before proceeding.  If is has 10000 or more entries, it will sleep for 30 seconds before checking again.

Manage Workers
--------------

Added the ability to stop, start, and restart workers from the workers page.  This requires capistrano, and capistrano-ext to be installed on all
deployed servers.

![Manage Workers](http://img.skitch.com/20100308-ds6bgsnwqe6j9jn9yx8x7cxre3.png)

The controller calls cap tasks to manage the workers.  To include the recipes in your application, add this line to your deploy.rb file:

    require 'resque_ui/cap_recipes'

You will also need to define the :resque role in your deploy/<environment>.rb file with the servers that will run your workers.

    role :resque, 'server1', 'server2'

You will also need to make sure you have your rake path set in the deploy.rb file.

    set :rake, "/opt/ruby-enterprise-1.8.6-20090421/bin/rake"

You will also need to tell resque_ui where cap is installed.  Add this line to your environments.rb file:

    ResqueUi::Cap.path           = '/opt/ruby-enterprise-1.8.6-20090421/bin/cap'

...using your own path of course.

The cap tasks included are:

    cap resque:work                         # start a resque worker.
    cap resque:workers                      # start multiple resque workers.
    cap resque:quit_worker                  # Gracefully kill a worker.  If the worker is working, it will finish before shutting down.
    cap resque:quit_workers                 # Gracefully kill all workers on all servers.  If the worker is working, it will finish before shutting down.
    cap resque:kill_worker_with_impunity    # Kill a rogue worker.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtyExit. arg: host=ip pid=pid
    cap resque:kill_workera_with_impunity   # Kill all rogue workers on all servers.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtyExit.
    cap resque:restart_workers              # Restart all workers on all servers

Multi-Threaded Workers
---------------------
With Jruby, you have to specify the amount of memory to allocate when you start up the jvm.  This has proven inefficient for us because different workers
require different amounts of memory.  We have standardized our jvm configuration for the workers, which means we have to start each worker with
the maximum amount of memory needed by the most memory intensive worker.  This means we are wasting a lot of resources for the workers that don't
require as much memory.

Our answer was to make the workers multi-threaded.  Now you can pass multiple workers and queues into the rake task, each worker will be started in separate
threads within the same process.

NOTE:  The convention to identify which queues are monitored by which worker is to prefix each worker with a '#' in the rake task argument.

    rake QUEUE=#file_loader#file_loader,email resque:work

This will start up 2 workers, 1 will work the file_loader queue, and one will work the file_loader and email queue.

Be aware that when you stop a worker, it will stop all the workers within that process.

After Deploy Hooks
------------------

The resque:restart_workers cap task can be added as an after deploy task to refresh your workers.  Without this, your workers will
continue to run your old code base after a deployment.

To make it work add the callbacks in your deploy.rb file:

    after "deploy", "resque:restart_workers"
    after "deploy:migrations", "resque:restart_workers"

Resque Scheduler
----------------

If resque-scheduler is installed, the Schedule and Delayed tabs will display.

Be sure you add the resque_scheduler gem before the resque_ui gem in your Gemfile:

    gem 'resque-scheduler', :require => 'resque_scheduler'
    gem 'resque_ui'

The Schedule tab functionality has been enhanced to be able to add jobs to the scheduler from the UI.  This means you don't
need to edit a static file that gets loaded on initialization.  This also means you don't have to deploy that file every time
you edit your schedule.

You can also create different schedules on different servers in your farm.  You specify
the IP address you want to schedule a job to run on, and it will add the job to the schedule on that server.  You can also start and
stop the scheduler on each server from the Schedule tab.

![Resque Scheduler](http://img.skitch.com/20100308-quccysfiwtgubpw286ka2enr9m.png)

The caveat to this is the Arguments value must be entered in the text box as JSON in order for the arguments to get parsed and stored
in the schedule correctly.  I find the easiest thing to do is to perform a Resque.encode on my parameters list in script/console.  If
we have a method that takes 3 parameters:

    >> Resque.encode([['300'],1,{"start_date"=>"2010-02-01","end_date"=>"2010-02-28"}])
    => "[["300"],1,{"end_date":"2010-02-28","start_date":"2010-02-01"}]"

The first parameter is an array of strings, the second parameter is an integer, and the third parameter is a hash.
Remembering that the arguments are stored in an array, all the parameters need to be in an array when there is more than one.

Any string arguments need to be quoted in the text box:

    >> Resque.encode("Hello World")
    => ""Hello World""

### Additional cap tasks added:

    cap resque:quit_scheduler   # Gracefully kill the scheduler on a server.
    cap resque:scheduler        # start a resque worker.
    cap resque:scheduler_status # Determine if the scheduler is running or not

Delayed Tab
-----------

I have not tested or added any functionality to the Delayed tab.  I get a RuntimeError: -ERR invalid bulk write count
any time I try to do a Resque.enqueue_at.  I've spent some time researching, and assume it's something with my version combinations.
I believe it's a Redis issue and not a Resque-Scheduler issue.  But since I'm not using it, I haven't put a great deal of
time into resolving it.

Copyright (c) 2009 Chris Wanstrath
Copyright (c) 2010 Ben VandenBos
Copyright (c) 2010 Aaron Quint
Copyright (c) 2011 Tatsuya Ono
Copyright (c) 2010 Kevin Tyll, released under the MIT license

Thanks to Karl Baum for doing the original heavy lifting for converting this to a rails engine for rails 3.

Much thanks goes to Brian Ketelsen for the ideas for the improved functionality for the UI.

TO DO
-----

To bring this up to scratch and be Rails 3.2.x ready:

- Investigate ```undefined method `statuses' for Resque::Status:Class```
- Fix assets to use assets pipeline
- Investigate what is needed for the ability to use the mount method in the routes.rb file
- Test coverage for any changes
- Fix this:
```DEPRECATION WARNING: Passing the format in the template name is deprecated.
Please pass render with :formats => [:html] instead. (called from poll at app/controllers/resque_controller.rb:30)```

extension: markdown


text:
# Health Monitor

View and log health/medicine events.

* View time and dosage of last medication.
* Keep track of symptoms and temperature.
* Quickly enter new records with the copy feature.

Live Demo: [https://reactdemo.appspot.com/healthmon/](https://reactdemo.appspot.com/healthmon/)

- *Author*: Antonio Rodriguez<EMAIL_ADDRESS>- *Description*: React demo application
- *License*: BSD
- *Blog post*: http://www.xhroot.com/blog/2015/05/21/a-brief-foray-into-react-dot-js/

repository: xhroot/healthmon

repo_name: xhroot/healthmon


text:
# Lecture Notes - Merge Sort
This algorithm takes in an array of integers, and uses recursion to sort it numerically from least to greatest. Modifies the given array in place.

## Learning Objectives
    In this lecture, you will learn about how the merge sort algorithm functions.
    You will also learn about the space complexity and performance of the merge sort algorithm.
## Lecture Flow
    First, look at the visualization to understand how we are separating and then merging the array.
    Then, take a look at the main method to see how it recursively splits the array, and calls the Merge helper method.
    Finally, take a look at the helper method: what is passed into it, and what does it return?

## Diagram
[This visualization](https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif) of the merge sort algorithm is extremely useful in understanding the recursive approach the algorithm takes.

## Algorithm
    mergeSort // The main method
    The main mergeSort method does all of the recursive work for this algorithm.
    Given an array, it copies and splits the array in half, and then calls itself on each half.
    This will repeat until the arrays reach a length of 1, at which point it will begin calling the merge helper method on each pair of 'array halves'.

    merge // The helper method
    This helper method takes an input of an unsorted array C, and two arrays A and B which are the first and second half of that array. Note that the first and second half are both already ordered, due to the recursive nature of how this function is called.
    It begins by comparing the first value from A with the first value from B, and inserts the smaller value into the first position in C. If the value was taken from A, we increment a counter which tracks the current position in A. Otherwise, we do similarly for a counter for B. Either way, we also increment a counter for the whole array C.
    This is repeated until we have reached the end of both arrays A and B, at which point the helper method returns C, now modified in place to be in order from least to greatest.

## Pseudocode
ALGORITHM Mergesort(arr)
    DECLARE n <-- arr.length

    if arr.length > 1
      DECLARE mid <-- n/2
      DECLARE b <-- arr[0...mid]
      DECLARE c <-- arr[mid...n]
      // break down the left side
      Mergesort(b)
      // break down the right side
      Mergesort(c)
      // merge the left and the right side together
      Merge(b, c, arr)

ALGORITHM Merge(b, c, a)
    DECLARE i <-- 0
    DECLARE j <-- 0
    DECLARE k <-- 0

    while i < b && j < c
        if b[i] <= c[j]
            a[k] <-- b[i]
            i <-- i + 1
        else
            a[k] = c[j]
            j <-- j + 1

        k <-- k + 1

    if i = b.length
       add remaining items in array c to array a
    else
       add remaining items in array b to array a

    return a

## Readings and References
    https://en.wikipedia.org/wiki/Merge_sort

repository: pettynan/data-structures-and-algorithms

gha_language: JavaScript

repo_name: pettynan/data-structures-and-algorithms


text:
# standard-commit-2

A zero-config opiniated, [commitizen](https://github.com/commitizen/cz-cli)
like command line utility to use
[conventional commits](https://conventionalcommits.org/).

- **git cc**: Same as `git commit` but with prompt and formatting of the
  commit message.

## Installation
```bash
npm install -g standard-commit-2
```
## Git Alias
```bash
git config --global alias.cc "!standard-commit-2"
# Now you can use:
git cc
```
## Usage
```bash
git cc --help
```

## Update

```bash
npm update -g standard-commit-2
```

## Configuration
Use the suggested defaults.
```bash
gcc --init
```
you can configure standard-commit via a `.standard-commitrc` file. You should add this file to the git repo.


text:
# ROS1 to ROS2 porting

## Introduction

Our goal for this exercise is to have you fully port a small ROS1 application into ROS2. We'll be
using the basic training material from sessions 1 and 2 as the initial ROS1 application. This will
provide some exposure to the differences in the basic tools of ROS development including publishers,
subscribers, services, and parameters. We will be using exercise 2.3 as the starting point.

## Workspace setup

1.  Clone the ROS2 version of `fake_ar_publisher` into your ROS2 workspace

    ```
    cd ~/ros2_ws/src/
    git clone -b ros2 https://github.com/ros-industrial/fake_ar_publisher.git
    ```

1.  Create empty ROS2 packages.

    ```
    cd ~/ros2_ws/src/
    ros2 pkg create myworkcell_core
    ros2 pkg create myworkcell_support
    ```

1.  Verify the workspace builds with `colcon build`

1.  Set up a new project in Qt Creator with 'Build System' set to 'Colcon' and 'Distribution' set to
    '/opt/ros/eloquent'. This is optional but highly recommended since you will get code
    autocompletion when editing C++ in the Qt Creator IDE. Verify that the workspace builds
    successfully from inside the IDE.

1.  Copy the ROS1 code from the packages at `~/industrial_training/exercises/2.3/src/` into the
    empty ROS2 packages.  We'll want everything copied over except `CMakeLists.txt` and
    `package.xml`, where we will be modifying the empty ROS2 versions instead. For more complex
    porting efforts, it will likely be more efficient to directly modify the ROS1 versions of these
    files.

## Porting

We will more or less follow the same sequence that the ROS1 basic training takes in switching to
ROS2.

### Topic subscription

1.  Open and start editing the `CMakeLists.txt` file in `myworkcell_core`

1.  Package dependencies: Ament packages you depend on are now found directly using the CMake
    `find_package` command. Almost always the first invocation will be `find_package(ament_cmake)`
    which is required to make this package an ament package.

    Add additional dependencies for this application below this first `find_package` command:

    ```
    find_package(rclcpp REQUIRED)
    find_package(fake_ar_publisher_msgs REQUIRED)
    ```

1.  Build the vision node: An executable is added in the usual CMake way. Rather than use
    `include_directories` and `target_link_libraries` to depend on other packages, a convenience
    macro is provided to depend on other ament packages.

    ```
    add_executable(vision_node src/vision_node.cpp)
    ament_target_dependencies(vision_node rclcpp fake_ar_publisher)
    ```

1.  Install the vision node: Everything in ROS2 must have an install rule in order to be used at
    runtime.

    ```
    install(TARGETS vision_node
        ARCHIVE DESTINATION lib/${PROJECT_NAME}
        LIBRARY DESTINATION lib/${PROJECT_NAME}
        RUNTIME DESTINATION lib/${PROJECT_NAME}
    )
    ```

1.  Above the final call to `ament_package()` add a line which indicates which ament packages this
    package depends on at runtime:

    ```
    ament_export_dependencies(rclcpp fake_ar_publisher)
    ```

1.  You may try to build the workspace again now and you should get a compile error about
    `ros/ros.h` not being found. We're now ready to port the C++ code. Open `vision_node.cpp` for
    editing.

1.  Change the headers: ROS2 requires headers to end in .hpp instead of .h and includes for msgs and
    srv require the file name to file/msg/ and file/srv/ respectively in their names.

    ```diff
    - #include <ros/ros.h>
    + #include <rclcpp/rclcpp.hpp>
    - #include <fake_ar_publisher/ARMarker.h>
    + #include <fake_ar_publisher/msg/ar_marker.hpp>
    ```

1.  Comment out the callbacks, the member variables, and the contents of the constructor. Change the
    `Localizer` class to inherit from `rclcpp::Node`.

    ```c++
    class Localizer : public rclcpp::Node
    {
    public:
        Localizer()
        : Node("vision_node")
        {
           //...
        }
        //...
    };
    ```

1.  The main function can now be replaced with ROS2 equivalents of creating a node and spinning to
    wait for callbacks to be invoked:

    ```c++
    int main(int argc, char* argv[])
    {
        // This must be called before anything else ROS-related
        rclcpp::init(argc, argv);

        // Create the node
        auto node = std::make_shared<Localizer>();

        // Don't exit the program.
        rclcpp::spin(node);
    }
    ```

1.  Now we'll port the subscriber Replace the `ar_sub_` and `last_msg_` member variables with:

    ```c++
    rclcpp::Subscription<fake_ar_publisher::msg::ARMarker>::SharedPtr ar_sub_;
    fake_ar_publisher::msg::ARMarker::SharedPtr last_msg_;
    ```

1.  Add the subscription creation to the constructor:

    ```c++
    using namespace std::placeholders;

    ar_sub_ = this->create_subscription<fake_ar_publisher::msg::ARMarker>("ar_pose_marker", rclcpp::QoS(1),
      std::bind(&Localizer::visionCallback, this, _1));
    ```

    and the callback that stores the message:

    ```c++
    void visionCallback(fake_ar_publisher::msg::ARMarker::SharedPtr msg)
    {
      last_msg_ = msg;
      RCLCPP_INFO(this->get_logger(), "Received ARMarker message");
    }
    ```

1.  Verify the workspace builds now and test the topic subscription. Run the publisher node and
    vision node in separate terminals:

    ```
    ros2 run fake_ar_publisher fake_ar_publisher
    ros2 run myworkcell_core vision_node
    ```

### Interface generation

We'll now build the `LocalizePart` service type to use in the `myworkcell_core` package.

1.  The `.srv` file syntax is basically unchanged, but we do have to modify the definition. Since
    ROS2 does not allow you to return a boolean from a service callback, we must track success and
    failure ourselves. Add a `success` member to the response in `LocalizePart.srv`:

    ```
    #request
    string base_frame
    ---
    #response
    bool success
    geometry_msgs/Pose pose
    ```

1.  Modify CMake and `package.xml` to build the service. In `CMakeLists.txt` add additional
    dependencies and a call to generate custom interfaces:

    ```
    find_package(rosidl_default_generators REQUIRED)
    find_package(geometry_msgs REQUIRED)

    rosidl_generate_interfaces(${PROJECT_NAME}
      "srv/LocalizePart.srv"
      DEPENDENCIES geometry_msgs
    )
    ```

    To use generated interfaces in the same package, another dependency must be added on built
    targets:

    ```
    rosidl_target_interfaces(vision_node ${PROJECT_NAME} "rosidl_typesupport_cpp")
    ```

    In `package.xml` make sure the `format` version is 3 and add the following tags:

    ```xml
    <member_of_group>rosidl_interface_packages</member_of_group>
    <build_depend>rosidl_default_generators</build_depend>
    <exec_depend>rosidl_default_runtime</exec_depend>
    ```

1.  Make sure the workspace builds and you can now see the `myworkcell_core/srv/LocalizePart`
    service when running `ros2 srv list`.
### Services

1.  At the top of `vision_node.cpp` add/uncomment:

    ```c++
    #include <myworkcell_core/srv/localize_part.hpp>
    ```

    Then add the service server to the vision node, replacing the `ServiceServer` member variable
    with:

    ```c++
    rclcpp::Service<myworkcell_core::srv::LocalizePart>::SharedPtr server_;
    ```

    Add the service creation to the constructor:

    ```c++
    server_ = this->create_service<myworkcell_core::srv::LocalizePart>("localize_part",
      std::bind(&Localizer::localizePart, this, _1, _2));
    ```

    and the service callback:

    ```c++
    void localizePart(myworkcell_core::srv::LocalizePart::Request::SharedPtr req,
                      myworkcell_core::srv::LocalizePart::Response::SharedPtr res)
    {
      // Read last message
      fake_ar_publisher::msg::ARMarker::SharedPtr p = last_msg_;

      if (!p){
        RCLCPP_ERROR(this->get_logger(), "no data");
        res->success = false;
        return;
      }

      res->success = true;
      res->pose = p->pose.pose;
    }
    ```

1.  Run both the `fake_ar_publisher` node and the `vision_node` and try manually calling the
    service.

1.  Now we'll set up the application node to call the service. Add a new target to `CMakeLists.txt`:

    ```
    add_executable(myworkcell_node src/myworkcell_node.cpp)
    ament_target_dependencies(myworkcell_node rclcpp fake_ar_publisher_msgs)
    rosidl_target_interfaces(myworkcell_node ${PROJECT_NAME} "rosidl_typesupport_cpp")
    ```

    and add `myworkcell_node` to the existing `install` function call, after `vision_node`.

1.  Open `myworkcell_node.cpp` to start porting it over. As done with the vision node, convert the
    `ScanNPlan` class to inherit from `rclcpp::Node` and rewrite the `main` function in the same
    way. For now, comment out the code that loads the 'base_frame' parameter and call the `start`
    function with a hardcoded `"world"`.

    ```c++
    class ScanNPlan : public rclcpp::Node
    {
    public:
        ScanNPlan() : Node("scan_n_plan")
        {
            //...
        }
        //...
    }

    int main(int argc, char* argv[])
    {
        //...
    }
    ```

1.  Replace the `vision_client` member variable with:

    ```c++
    rclcpp::Client<myworkcell_core::srv::LocalizePart>::SharedPtr vision_client_;
    ```

    and create it in the constuctor with:

    ```c++
    vision_client_ = this->create_client<myworkcell_core::srv::LocalizePart>("localize_part");
    ```

1.  The `start` function will be fully replaced since it is quite a bit more complex. Since ROS2
    services are now asynchronous, the client returns a `future` object when called and the
    developer is responsible for spinning until a response returns from the vision node. Read
    through the new `start` function here before replacing to make sure you understand everything
    that is happening.

    ```c++
    void start(const std::string& base_frame)
    {
        using namespace std::chrono_literals;

        // Need to wait until vision node has data
        rclcpp::sleep_for(1s);

        RCLCPP_INFO(this->get_logger(), "Attempting to localize part in frame: %s", base_frame.c_str());

        // The vision client needs to wait until the service appears
        while (!vision_client_->wait_for_service(500ms)) {
            if (!rclcpp::ok()) {
                RCLCPP_ERROR(this->get_logger(), "client interrupted while waiting for service to appear.");
                return;
            }
            RCLCPP_INFO(this->get_logger(), "waiting for service to appear...");
        }

        // Create a request for the LocalizePart service call
        auto request = std::make_shared<myworkcell_core::srv::LocalizePart::Request>();
        // The base_frame that is passed in is used to fill the request
        request->base_frame = base_frame;

        auto future = vision_client_->async_send_request(request);
        if (rclcpp::spin_until_future_complete(this->get_node_base_interface(), future) != rclcpp::FutureReturnCode::SUCCESS)
        {
            RCLCPP_ERROR(this->get_logger(), "Failed to receive LocalizePart service response");
            return;
        }

        auto result = future.get();
        if (! result->success)
        {
            RCLCPP_ERROR(this->get_logger(), "LocalizePart service failed");
            return;
        }

        RCLCPP_INFO(this->get_logger(), "Part Localized:  w: %f, x: %f, y: %f, z: %f",
                result->pose.orientation.w,
                result->pose.position.x,
                result->pose.position.y,
                result->pose.position.z);
    }
    ```

1.  Verify everything builds and works

### Parameters

1.  Parameters work slightly differently than in ROS1. The most significant change is the parameter
    declaration mechanism, which, when given a default value, ensures that a parameter will exist
    under the given name which matches the type of the default. Modify the `main` function to
    declare and get the `base_frame` parameter:

    ``` c++
    auto node = std::make_shared<ScanNPlan>();

    // String to store the base_frame parameter after getting it from the Node's parameter client
    std::string base_frame;
    node->declare_parameter("base_frame", "");
    node->get_parameter("base_frame", base_frame);

    if (base_frame.empty())
    {
        RCLCPP_ERROR(node->get_logger(), "No 'base_frame' parameter provided");
        return -1;
    }

    // Call the vision client's LocalizePart service using base_frame as a parameter
    node->start(base_frame);
    ```

1.  Unfortunately, parameters can not currently be set on the command line when using `ros2 run`. To
    test that the parameter is set, you must create and save a YAML file:

    ```yaml
    /**:
      ros__parameters:
        base_frame: world
    ```

    Then load this file when running the node:

    ```
    ros2 run myworkcell_core myworkcell_node __params:=my_params_file.yaml
    ```

### Launch file

1.  Currently, the `myworkcell_support` package only contains a launch file for starting the three
    required nodes. We will port it to a ROS2 python launch script.

1.  Start by creating a new file `workcell.launch.py` under the `launch/` directory.

1.  Modify the contents to add the required python imports and the required function which will
    return the launch configuration description:

    ``` py
    from launch import LaunchDescription
    import launch_ros.actions

    def generate_launch_description():
        print('Workcell is launching...')
    ```

1.  Each node in the XML launch file will correspond to a `Node` launch 'action' in the new launch
    description. The named arguments used in the action constructor should have clear meaning.
    You'll need one for the `fake_ar_publisher`:

    ```py
    fake_ar_pub_node = launch_ros.actions.Node(
        node_name='fake_ar_publisher_node',
        package='fake_ar_publisher',
        node_executable='fake_ar_publisher_node',
        output='screen',
        parameters=[{'x': -0.6},
                    {'y': 0.4},
                    {'z': 0.1},
                    {'camera_frame': 'camera_frame'}],
    )
    ```

    one for the `vision_node`:

    ```py
    vision_node = launch_ros.actions.Node(
        node_name='vision_node',
        package='myworkcell_core',
        node_executable='vision_node',
        output='screen',
    )
    ```

    and one for `myworkcell_node`:

    ```py
    myworkcell_node = launch_ros.actions.Node(
        node_name='myworkcell_node',
        package='myworkcell_core',
        node_executable='myworkcell_node',
        output='screen',
        parameters=[{'base_frame': 'world'}],
    )
    ```

    Notice the `parameters` argument must be set with a list of dictionaries. Another common
    argument not used here is `arguments`, set with a list of command line arguments that the
    executable will start with.

1.  Now bundle the three nodes in a `LaunchDescription` and return it from the function:

    ```py
    return LaunchDescription([fake_ar_pub_node, vision_node, myworkcell_node])
    ```

1.  Add an `install` call to `CMakesList.txt` to install the launch file:

    ```
    install(DIRECTORY launch
      DESTINATION share/${PROJECT_NAME}/
    )
    ```

1.  Modify `package.xml` to show the runtime dependency on the packages

    ``` xml
    <exec_depend>fake_ar_publisher</exec_depend>
    <exec_depend>myworkcell_core</exec_depend>
    ```

1.  After building the workspace test the launch file with:

    ```
    ros2 launch myworkcell_support workcell.launch.py
    ```

    Note that the file loaded by `ros2 launch` resides in the `install/` directory and will not
    update if you edit the version in the `src/` space. To avoid having to rebuild the workspace to
    see changes in the launch script, you can run `colcon build` with the `--symlink-install` option
    so the file in the install space is just a link back to the source space. This build option is
    also useful when developing ROS python code in general.

branch_name: refs/heads/humble


text:
# Development environment for `registries-operator`

## Project structure

This project follows the conventions presented in the [standard Golang
project](https://github.com/golang-standards/project-layout).

## Dependencies

* `go >= 1.11`

### Bumping the Kubernetes version used by `registries-operator`

Update the constraints in [`go.mod`](../go.mod).

## Building

A simple `make` should be enough. This should compile [the main
function](../cmd/registries-operator/main.go) and generate a `registries-operator` binary as
well as a _Docker_ image.

## Running `registries-operator` in your Development Environment

There are multiple ways you can run the `registries-operator` for bootstrapping
and managing your Kubernetes cluster:

### ... in your local machine

You can run the `registries-operator` container locally with a
`make KUBECONFIG=my-kubeconfig local-run`. This will:

  * build the `registries-operator` image
  * run it locally  using  `my-kubeconfig` to connect to the kubernetes cluster

For running the operator locally you must ensure that it access the kubernetes
api with privileges for mounting the /etc/docker host volume, like in the psp
fragment below:

```yaml
apiVersion: extensions/v1beta1
kind: PodSecurityPolicy
spec:
  volumes:
    # Kubernetes Host Volume Types
    - hostPath
  allowedHostPaths:
    - pathPrefix: /etc/docker
```

repository: nirmoy/registries-operator

repo_name: nirmoy/registries-operator


text:
# URL Example

Parameter | Example
--------- | -----------
Root | **https://api.hmsonline.com**
Version | **v1**
Request | **search/masterfile?**
Security | **timestamp=1369844777731&key=EU2BD6eHBQeUMpMxDW9dmg== &signature=8qrFmQbQgILzdDeQfbJTxHXeZvE=**

Yields the following URL:

`https://api.hmsonline.com/v1/search/masterfile?timestamp=1369844777731&key=EU2BD6eHBQeUMpMxDW9dmg==&signature=8qrFmQbQgILzdDeQfbJTxHXeZvE=`

The `Body` in this case will determine the actual query to perform.  To query all records, use:

`Body` = **{"match_all":{}}**

<aside class="notice">
**Note: All security values shown here and throughout this documentation are for illustration purposes only and will not work as shown.  See [[Security Credentials|Security Credentials]] for more information.**
</aside>

repository: DeanPoulin/slate

repo_name: DeanPoulin/slate


text:
---
order: 10
---
# Discovery

After you create an account, the first thing you'll want to do is discover a system.  The first page that will be presented
to you is a call-to-action to discover if you have not previously discovered a system.

![Initial Discovery](./imgs/discovery/discover-initial.png)

## System Details

Click the _Discover_ button.  You'll be guided to the system discovery wizard.  The first page allows you to enter some
details about your system such as its name, as well as providing a place where you can enter notes about the system,
its purpose, etc.

![System Details](./imgs/discovery/system-details.png)

## Vaults

The next page you'll encounter after System Details is the vault page.  Sunshower.io stores your cloud credentials (e.g. IAM roles)
in a strongly-encrypted format that we can't access.  When you create a vault, any data placed in it is locked up and we
don't keep a key.  When you want to use Sunshower.io to take a given secret and do something with it, such as use it to discover
your infrastructure, you have to supply your key.

In other words, even if Sunshower.io is compromised, you cloud secrets will be safe and no one will be able to access them
without your vault password.  Not even us.

So, let's create one.  If you're still on the System Details page, click "Next" to continue to the vault selection page:

![Vault Selection](./imgs/discovery/vault-page.png)

Initially, you won't have any vaults, so the list of vaults will be empty.  To create one, click the purple FAB on the
top-right hand corner of the vault list.  The list will flip around and you can enter the vault details.

#### Important!

```
The password you use to secure your Vault is unknown and unrecoverable to Sunshower.io.
You must store it elsewhere: we strongly recommend LastPass for this.  This is an important
part of Sunshower.io's security model; we hope to find a more convenient, equally-secure way
to store your information soon.
```

![Vault Creation Page](./imgs/discovery/vault-creation-page.png)

Select Save.  The vault will be created and the form will flip back around and you'll be presented with it in the list.
Click on the newly-created vault to select it, then enter its password in the field beneath the list to unlock it:

![Vault Unlocked](./imgs/discovery/vault-unlocked.png)

## Accounts

Once you've unlocked the vault, click "Next" on the Wizard.  You'll be directed to the `Accounts` page where you'll add
in your Cloud Provider Credentials.

![Vault Unlocked](./imgs/discovery/discover-add-account.png)

As with the Vault, click the purple `+` button to the top-right, this will flip the accounts list so that you can
add a new account.

![Vault Unlocked](./imgs/discovery/aws-add-account.png)

Any descriptive name for the `Account Name` will work.  For the `Account Key` set it to the `Access key ID` that
you created in [Creating an IAM Account](/pages/en/guide/before-you-begin.html#amazon-web-services-identity-access-management-iam)
and the `Account Secret` will be the `Secret access key`.

Once you've entered your IAM Role, click the `Save` button.  You'll be returned to the Accounts list.  Click `Next` to be
presented with the Discovery Summary:

![Vault Summary](./imgs/discovery/vault-summary.png)

## Discovery

Click `Finish` to begin the Discovery process.  You'll briefly be taken to a loading page while we go in and discover your
infrastructure, then you'll be presented with your infrastructure summary:

![Infrastructure Summary](./imgs/discovery/infrastructure-summary.png)

Congratulations!  You've successfully created a System and discovered it.  In subsequent chapters we'll explore some
advanced techniques for aggressively optimizing your infrastructure.

repository: sunshower-io/sunshower-documentation

repo_name: sunshower-io/sunshower-documentation


text:
---
layout: post
title: ""Reading mailing list archives with Python: Noisechain Pt. 1"
date: 2014-11-23 23:12:20 -0800
comments: true
categories: python noisebridge
---
  Inspired by the twitter account "Shit Noisebridge says" I set about recently to script together that trains a [Markov chaina](https://en.wikipedia.org/wiki/Markov_chain) on the complete archive of the `noisebridge-discuss@` mailing list to create a rival account "Shit noisebridge probably says".

  It's not yet complete but one useful thing to have fallen out of this project already is a script that makes it easy to download mailman list arcihves in their entirety by passing the name of a list. It's a very simple script with a magic constant pointing to the Noisebridge mailman instance at the moment but it might prove useful for those wishing to read through mailing list archives. You can find the script [on Github](https://github.com/patrickod/noisechain/blob/master/bin/fetch-pipermail-archive).

While the noisechain component is yet incomplete this script has also proven useful in reading mailing list archives. Combined with a [neat little Perl script](http://www.hermann-uwe.de/blog/converting-mailman-gzipd-text-archive-files-to-proper-mbox-files) for converting the Mailman archives into `.mbox` files for reading with Mutt it becomes a very easy way to read through mailing list archives.

P

repository: patrickod/blog-yesteryear

repo_name: patrickod/blog-yesteryear


text:
---
layout: feature
title: 'Derivation'
shortdef: 'derivation'
udver: '2'
---

(Please note: this part of the documentation is not yet completed.)

Language-specific feature identifying the form of derivation applied
to a word.

### `Dimin`: derivation with suffix -ня

Produces diminutive derivations of nouns.

#### Examples

* [mdf] _варманя_ "a slight wind"

### `F`: derivation with suffix -ф

Produces participle-like adnominal modifiers.

#### Examples

* [mdf] _ацаф_ \n "covered"

### `GenAttr`: genitive attribute -Онь

Produces indefinite genitive-like modifiers from adverbs

#### Examples

* [mdf] _озадонь_ "sitting"

### `OvOms`: derivation with suffix -ОвОмс

Produces a verb form with epistemic modality and an inherent telicity but no volition.
With derivations from transitive verbs this may be close to a "get" passive, whereas the
intransitive derivation seems closer to a "manage to/happen to" reading.

#### Examples

* [mdf] _шарькодевомс_ "to be comprehensible/to get understood"
* [mdf] _содавомс_ "to get recognized"
* [mdf] _ярхцавомс_ "to happen/manage to eat (too much)"

### `Ozj`: derivation with suffix -Озь

Produces converb.

#### Examples

* [mdf] _кенордазь_ "feeling happy"

### `NomAg`: possessive -и/-ы

Produces nomen agensis (non-temporal).

#### Examples

* [mdf] _кельги_ "one who loves"

### `Poss`: possessive -Онне

Produces pronoun-like nominals from nearly any words that can take an indefinite genitive form.

#### Examples

* [mdf] _а ульцясь июленнекс пси._ "but the street is hot like July"

### `Cond`: protasis marker, aka conditional -Ондеря-

Marks the protasis verb, which may be in the the so-called subjunctive (presumably this conditional) and indicative non-past and past (quite infrequent).

#### Examples

* [mdf] _А кадондярясак тяфтак,._ "And if you leave it like this,."

### `Voc`: vocative derivation with suffix -й or кай

Used with proper nouns and kinship terms ending in vowels.

#### Examples

* [mdf] _ялгай_ "friend"

### `Wife`: derivation with suffix -эря

Produces wife address name based on husband's name/nick name.

#### Examples

* [mdf] _Цямкаерясь _ "Tsiamkaj's wife"

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


text:
<!-- https://github.hubspot.com/sortable/ -->
<script src="js/sortable.min.js"></script>
<link rel="stylesheet" href="css/sortable-theme-bootstrap.css" />

<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-128364527-3"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'UA-128364527-3');
</script>

# Model Compression

This is a collection for model compression and acceleartion for DNNs, with a bias towards to the CV domain.

## Existing collections

### Repo

+ [Knowledge Distillation](https://github.com/dkozlov/awesome-knowledge-distillation)
+ [Model Compression Acceleration](https://github.com/jnjaby/Model-Compression-Acceleration)
### Survey paper

+ [Recent Advances in Efficient Computation of Deep Convolutional Neural Networks](https://arxiv.org/pdf/1802.00939.pdf)
+ [A Survey on Methods and Theories of Quantized Neural Networks](https://arxiv.org/pdf/1808.04752.pdf)

## Tools

+ [PocketFlow](https://pocketflow.github.io)
+ [Distiller](https://nervanasystems.github.io/distiller/)
+ [Tensorflow Lite](https://www.tensorflow.org/lite)
+ [Tensorflow Model Optimization](https://www.tensorflow.org/model_optimization)
+ [TVM](https://tvm.ai/)

## Literature Summry

List:


text:
# Hypocrea semiorbis (Berk.) Sacc., 1883 SPECIES

#### Status
ACCEPTED

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

#### Published in
Syll. fung. (Abellini) 2: 533 (1883)

#### Original name
Sphaeria semiorbis J.M. Hook, 1840

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Upblog setup guide

## Download

Clone the code from github and include submodules!

	$ git clone --recursive https://github.com/stegriff/upblog

## Config

Open `config.php` and change the `BLOG_ROOT` constant to the relative directory where upblog is installed on your domain. This is just used in a "find and replace" kind of way. Here are two examples:

 1. If you are using Upblog to power your whole website, called `bloggins.com`: **set the `BLOG_ROOT` to `bloggins.com/`
 2. If you are using it to power the `/blog` section of your site, then **set `BLOG_ROOT` to `/blog/`

That's all you need to configure in that file unless you have a particular reason to make upblog run differently.

## htaccess

Open `.htaccess` and change the address on the `RewriteRule` line. Two examples again:

 1.	If you are using Upblog as the whole site, the line should read:
		RewriteRule . /index.php [L]

 2.	If you are using it to power the `/blog` section of your site:
		RewriteRule . /blog/index.php [L]

## Upload

Upload the contents of the `upblog` directory that you checked out to your website.

license: Unlicense

repository: SteGriff/sg-upblog

gha_language: PHP

gha_license_id: Unlicense

repo_name: SteGriff/sg-upblog


text:
LaTeX-examples
==============

More than 570 examples for the usage of LaTeX. You can check that with the
following command:

```bash
$ find . -type d | sort | awk '$0 !~ last "/" {print last} {last=$0} END {print last}' | grep -v .git | wc -l
```

Many examples can be found on [my Wikpedia Commons user page](http://commons.wikimedia.org/wiki/User:MartinThoma#Galerie).

You might also be interested in [my Blog](http://martin-thoma.com/tag/tikz/).

Usage
=====

Every LaTeX file is in a seperate folder and has its own Makefile.
So you can simply generate the PDF by typing `make` in the terminal.

If you want to get all examples offline, you have to execute

```bash
$ git clone --recursive https://github.com/MartinThoma/LaTeX-examples.git
```

Requirements
============

* You should have the latest LaTeX version. Here are
  [LaTeX installation instructions](http://martin-thoma.com/how-to-install-the-latest-latex-version/).
* If you want to use the Makefiles, you have to have make installed.

Contact
=======
If you have examples or suggestions for improving given examples, please send
them to<EMAIL_ADDRESS>

Re-use
=======
Feel free to use and modify the examples in this repository,
but please add a link to this repository or martin-thoma.com.

*Most* of the content was created completely by me. But check
the Readme files in each specific folder to make sure you can use it.

Other resources
===============
* [LaTeX Templates](http://www.latextemplates.com/)
* [LaTeX templates for writing a thesis](http://tex.stackexchange.com/q/326/5645)

repository: MartinThoma/LaTeX-examples

gha_language: TeX

repo_name: MartinThoma/LaTeX-examples


text:
---
title: Why can’t rootless Podman pull my image?
layout: default
categories: [new]
---

Matt Heon has a blog post on the [Red Hat Enable Sysadmin](https://www.redhat.com/sysadmin/) site about [Why can’t rootless Podman pull my image?](https://www.redhat.com/sysadmin/rootless-podman).  In the blog Matt discusses why restrictions on rootless containers can be inconvenient, but why they're necessary.  In the blog Matt covers the use of user namespace and the allocations of uid and gid's that are required to make rootless containers work securely in your environment.

branch_name: refs/heads/main

gha_license_id: NOASSERTION


text:
## 1.0.9 (2017-09-10)

Bugfix:

  - Chain.clear not resetting all flags

## 1.0.8 (2017-09-09)

Bugfix:

  - fix property of undefined exceptions

## 1.0.7 (2014-07-25)

Features:

  - export ValidationException for use in try-catch blocks

## 1.0.6 (2014-01-26)

Features:

  - add History.md
  - add License.md
  - reorganize Readme.md

## 1.0.5 (2014-01-22)

Features

  - renamed dependency `congruent` to `deepequal`

## 1.0.4 (2014-01-22)

Bugfix:

  - fix global Buffer check

## 1.0.3 (2014-01-22)

Features:

  - use faster type-checking method
  - changed dependency `deep-is` to `congruent` for checking object equality

## 1.0.2 (2014-01-19)

Features:

  - add validators
    - object

## 1.0.1 (2014-01-17)

Features:

  - add validators
    - instanceOf
    - array
    - buffer
    - empty
  - add `or` condition to the Chain

## 1.0.0 (2014-01-16)

Features:

  - complete API rework
  - use getter methods instead of functions
  - renamed all methods from abbreviations to full names
  - add `deep-is` dependency for object equality checking
  - switched unit testing from `node-unit` to `mocha` and `should`
  - switched `is` from an instance to a singleton object

Removed:

  - common regular expression validation (email, url, alpha, alphanumeric, and ip)

## 0.0.1 (2013-05-08)

Initial publish

repository: jaycetde/is-validation

repo_name: jaycetde/is-validation


text:
# sender-sqs

This component leverages [zipkin-reporter-java](https://github.com/openzipkin/zipkin-reporter-java)
interfaces to send spans to Amazon SQS for collection and processing.
SQS is an alternative to kafka that is fully managed in the AWS cloud.

## Configuration

A minimal configuration of this sender would be:

```java
sender = SQSSender.create("my-queue");
```

Additionally, `CredentialsProvider`, `EndpointConfiguration` and `region`
can all be customized as needed.

```java
sender = SQSSender.builder()
    .queueName("my-queue")
    .region("us-west-1")
    .credentialsProvider(new AWSStaticCredentialsProvider(new AnonymousAWSCredentials()))
    .endpointConfiguration(new AwsClientBuilder.EndpointConfiguration("http://localhost:8080/", "us-east-1"))
    .build();
```

## Requirements

The credentials that your service has requires the following permissions in order to function:

`sqs:DescribeStream` for health checking

`sqs:PutRecord` for placing spans on the queue

## Message encoding
The message's binary data includes a list of spans. Supported encodings
are the same as the http [POST /spans](http://zipkin.io/zipkin-api/#/paths/%252Fspans) body.

Encoding defaults to json, but can be overridden to use PROTO3 instead.

Unless the message is ascii, it is Base64 encoded before being sent. For
example, plain json is sent as is. Thrift or json messages that include
unicode characters are encoded using Base64.

# Related work

[collector-sqs](https://github.com/openzipkin/zipkin-aws/tree/master/collector-sqs)
integrates with zipkin-server to pull spans off of an SQS queue instead
of http or kafka.

repository: openzipkin/zipkin-aws

gha_language: Java

repo_name: openzipkin/zipkin-aws


text:
# Mac address spoofer

Requires Python3.6+

This tool allows you to change your mac address with one you found when scanning the network.
You can select on which interface you want to scan for hosts and then you can select which
mac address you want to use.

## Install dependencies

`pip install -r requirements.txt`

You may need to install python-scapy as well:
`sudo apt-get install python-scapy`

## Run it (preferably in virtualenv)

`python3.6 spoof_mac_address.py`

For me, I need to use sudo because I have a permission denied, but I use virtualenv, so
when I sudo I loose my virtualenv. In case you have the same trouble, I do the following :

`sudo ./venv/bin/python3.6 spoof_mac_address.py`

## N.B :

Modifying mac address is a volatile action, so it will be changed until the next reboot.

repository: sorasful/Mac-address-spoofer

repo_name: sorasful/Mac-address-spoofer


text:
## Cracks and Potholes in Road Images Dataset

### Abstract

The poor condition of the roads directly affects traffic safety. In several countries, vehicles that survey road information are already used. These vehicles capture information and images that are used to define highway intervention and maintenance strategies. The images captured by these vehicles allow the identification of problems found on the highways, however in many cases they need manual analysis by trained technicians.

Defects such as cracks and potholes can be identified automatically using image processing and machine learning techniques. Developed researches in the field of machine learning requires a large set of images, whether for training the algorithms or during the recognition test. In this context, this dataset was created containing images of defects in asphalted roads in Brazil, in order to be used for a study on the detection of cracks and potholes in asphalted roads, using texture descriptors and machine learning algorithms such as Support Vector Machine, K-Nearest Neighbors and Multi-Layer Perceptron Neural Network.

The dataset was developed using images made available by Brazilian National Department of Transport Infrastructure (NDTI), through the Access to Information Law - Protocol 50650.003556/2017-28. The images are from highways in the states of Espírito Santo, Rio Grande do Sul and the Federal District. 2235 images were selected manually, following criteria such as not showing signs of vehicles and people, as well as not having image defects. This work consists of 2235 samples of roads where each image has 3 masks that delimit the vehicle's path and crack and pothole defects.

### Keywords

Road, Pavement, Defects, Detection, Recognition, Crack, Pothole

### Authors

Bianka Tallita Passos, Mateus Junior Cassaniga, Anita Maria da Rocha Fernandes, Kátya Balvedi Medeiros, Eros Comunello

### Affiliations

University of Itajaí Valley – UNIVALI. Santa Catarina – Brazil.

### Value of Data

- The data can be used to train classifiers or artificial neural networks to identify a lane, cracks or potholes. Different classifiers can be trained to identify the best type of image for a given problem, such as defects recognition for road maintenance.
- The federal road network in several countries is monitored using vehicles that capture images. However, the analysis and marking of the defects found in these images is done posteriori, by technicians in laboratories. A tool capable to detect and classify defects in these images in an automated way could replace this step, speeding up the process and reducing the final cost of monitoring.
- Vision-based methods, which use image processing to detect defects in the floor, enables a low investment cost and can be achieved with common cameras.
- Cracks and potholes are types of defects in the pavements that can compromise the safety and quality of the roads. The identification of such defects is an important step for intervention and maintenance strategies to be carried out.

### Data Description

The dataset images were extracted from videos captured by NDTI, using a Highway Diagnostic Vehicle (HDV). To register the highways, the HDV is equipped with a high-resolution camera and two cameras for filming.

The camera is installed on the highest part of the vehicle, facing the front and with an inclination closer to orthogonality. Thus, the visibility of the pavement is 15 meters. This camera captures images with a minimum resolution of 4 megapixels, every 5 meters away [1].

The video cameras, installed on the front and rear of the HDV, are responsible for the continuous capture of videos with a rate of 30 Frames Per Second (FPS). The resolution is at least 1280x729 and respects the 16:9 aspect ratio. Figure 1 shows the main characteristics of the
HDV [1].

![](/figures/1.png)
Figure 1. Representation of the HDV used by NDTI [1]: (a) satellite tracking system (b) high-resolution camera (c) recording cameras (d), precision odometer and (e) laser sensors.

The images were provided by the NDTI on a hard disk, and with the following characteristics:
- The images were captured between 2014 and 2017; and
- They are images from highways of Espírito Santo state (BR 101, 259, 262, 393, 447, 482 and 484), Rio Grande do Sul state (BR 101, 290 and 386) and Federal District (BR 010, 020, 060, 070, 080 and 251).

The dataset was developed using only the images provided by NDTI. A total of 2235 images were selected manually, considering the following criteria:
1. To count as an image with damaged asphalt, present crack(s) and/or pothole(s);
2. Do not contain vehicles in images;
3. Do not contain people in images; and
4. No problems due to capture, such as defects in colors (colors that do not correspond to the rest of the image) and defects in the image (such as missing parts).

Figure 2 shows some images present in this database.

![](/figures/2.png)

Figure 2. Example of some images from the dataset.

Each image has 3 masks - binary images in PNG (Portable Network Graphics) format - separated for each type of annotation: road, crack and pothole. The annotation of the road consisted of demarcating the total region corresponding to the vehicle's road, as shown in Figure 3.

![](/figures/3.png)

Figure 3. Road region annotation example.

The annotation of cracks and potholes consisted of the defect selection, maintaining its shape as much as possible, as shown in Figure 4.

![](/figures/4.png)

Figure 4. Pothole annotation example (blue) and cracks (red).

Figure 5 shows the separate masks for each type of annotation - road, pothole and crack - that compose this dataset.

![](/figures/5.png)

Figure 5. Example of the original image (a) and the masks corresponding to the road region (b), pothole (c) and crack (d).

For the identification of cracks and potholes, the same definitions presented in NDTI [2] and Fernandes, Oda and Zerbini [3] were used.

### Experimental Design, Materials and Methods

The images provided by NDTI have no labelling or any information referring to the damage present on the roads. A tool was developed that made it possible to annotate these objects/defects in order to create the ground-truth available in this article. The tool received as input the original image, where it is possible to select the region of the road and the defects found. As a result, the marks generated were converted into masks.

### Acknowledgments

This study was financed in part by the Coordenação de Aperfeiçoamento de Pessoal de Nı́vel Superior – Brasil (Higher Level Personnel Improvement Coordination - Brazil - CAPES) - Finance Code 001.

### References

[1] Brazil. Departamento Nacional de Infra-Estrutura de Transportes (National Department of Transport Infraestructure) . Edital Pregão Eletrônico No 0268/16-00, 2016.

[2] NDTI. Norma DNIT 005/2003 - TER: Defeitos nos pavimentos flexíveis e semi-rígidos. Rio de Janeiro. 2003.

[3] Fernandes Jr, J. L.; Oda, S.; Zerbini, L. F. Defeitos e atividades de manutenção e reabilitação em pavimentos asfálticos. Universidade de São Paulo: Escola de Engenharia de São Carlos. São Paulo (SP), 1999.

### DOI

10.17632/t576ydh9v8.4

### Cite this dataset

[Passos, Bianka T.; Cassaniga, Mateus J.; Fernandes, Anita M. R. ; Medeiros, Kátya B. ; Comunello, Eros (2020), “Cracks and Potholes in Road Images”, Mendeley Data, V4, doi:10.17632/t576ydh9v8.4](http://dx.doi.org/10.17632/t576ydh9v8.4)

### Corresponding author(s)

[Bianka<EMAIL_ADDRESS>
### Download
[Mendeley Data](
https://data.mendeley.com/datasets/t576ydh9v8/3/files/afc7c028-06e0-475b-b190-e008df681b19/Cracks-and-Potholes-in-Road-Images.zip?dl=1
)


text:
# ALIYUN::ECS::InstanceGroup {#concept_48278_zh .concept}

ALIYUN::ECS::InstanceGroup is used to create an ECS instance group.

## Syntax {#section_xyg_tn2_lfb .section}

``` {#codeblock_qwf_u6r_omx .language-json}
{
  "Type": "ALIYUN::ECS::InstanceGroup",
  "Properties": {
    "DedicatedHostId": String,
    "LaunchTemplateName": String,
    "RamRoleName": String,
    "IoOptimized": String,
    "InternetChargeType": String,
    "PrivateIpAddress": String,
    "KeyPairName": String,
    "SystemDiskDiskName": String,
    "PeriodUnit": String,
    "Description": String,
    "AutoRenew": String,
    "SpotPriceLimit": String,
    "HostName": String,
    "AutoRenewPeriod": Number,
    "ImageId": String,
    "ResourceGroupId": String,
    "InstanceChargeType": String,
    "VSwitchId": String,
    "EniMappings": List,
    "Password": String,
    "InstanceType": String,
    "MaxAmount": Integer,
    "AutoReleaseTime": String,
    "Tags": List,
    "SystemDiskCategory": String,
    "DeletionProtection": Boolean,
    "LaunchTemplateId": String,
    "LaunchTemplateVersion": String,
    "SystemDiskSize": Number,
    "ZoneId": String,
    "InternetMaxBandwidthOut": Integer,
    "VpcId": String,
    "SpotStrategy": String,
    "InstanceName": String,
    "InternetMaxBandwidthIn": Integer,
    "UserData": String,
    "DeploymentSetId": String,
    "SecurityGroupId": String,
    "Period": Number,
    "HpcClusterId": String,
    "AllocatePublicIP": Boolean,
    "SystemDiskDescription": String,
    "NetworkType": String,
    "DiskMappings": List
  }
}
```

## Properties {#section_pzg_wn2_lfb .section}

|Name|Type|Required|Editable|Description|Validity|
|----|----|--------|--------|-----------|--------|
|ResourceGroupId|String|No|Yes|The ID of the resource group to which created instances belong.|None|
|HpcClusterId|String|No|Yes|The ID of the HPC cluster to which created instances belong.|None|
|MaxAmount|Integer|Yes|Yes|The maximum number of ECS instances that can be created in a single scaling operation.|Valid values: 1 to 100. The value of this parameter must be greater than or equal to that of the MinAmount parameter.|
|MinAmount|String|Yes|Yes|The minimum number of ECS instances that can be created in a single scaling operation.|Valid values: 1 to 100. The value of this parameter must be less than or equal to that of the MaxAmount parameter.|
|Description|String|No|No|The description of created ECS instances.|The description can be up to 256 characters in length.|
|InstanceType|String|Yes|No|The type of created ECS instances.|For more information, see [Instance families](https://partners-intl.aliyun.com/help/doc-detail/25378.htm).|
|ImageId|String|Yes|Yes|The ID of the image used to start an ECS instance. You can use a public image, custom image, or Alibaba Cloud Marketplace image.|For more information, see [Public images for ECS instances](https://ros.console.aliyun.com/#/product/cn-hangzhou/list/imageList). You can specify a partial public image ID instead of providing the complete ID. When editing a template used to deploy an ECS instance, you can specify either the image type and version or only the image type. ROS automatically selects an appropriate public image ID. You can use the wildcard character \(\*\) to represent part of an image ID. Take the Ubuntu public images provided by Alibaba Cloud as an example:

 ubuntu\_14\_0405\_32\_40G\_alibase\_20170711.vhd

 ubuntu\_14\_0405\_64\_20G\_alibase\_20170824.vhd

 ubuntu\_16\_0402\_32\_40G\_alibase\_20170711.vhd

 ubuntu\_16\_0402\_64\_20G\_alibase\_20170818.vhd

 You can use one of the following methods to specify a public image ID for the ECS instance:

 If you enter ubuntu,

 the system matches it with the following ID: ubuntu\_16\_0402\_64\_20G\_alibase\_20170818.vhd

 If you enter ubuntu\_14,

 the system matches it with the following ID: ubuntu\_14\_0405\_64\_20G\_alibase\_20170824.vhd

 If you enter ubuntu1432,

 the system matches it with the following ID: ubuntu\_14\_0405\_32\_40G\_alibase\_20170711.vhd If you enter ubuntu\_16\_0402\_32,

 the system matches it with the following ID: ubuntu\_16\_0402\_32\_40G\_alibase\_20170711.vhd|
|SecurityGroupId|String|No|No|The ID of the security group to which created instances belong.|None|
|InstanceName|String|No|No|The name of created ECS instances.|The name can be up to 128 characters in length and can contain letters, digits, underscores \(\_\), periods \(.\), and hyphens \(-\). Instance names must be in the name\_prefix\[begin\_number,bits\]name\_suffix format. The name\_prefix parameter specifies the prefix of an instance name. This parameter is required. The \[begin\_number,bits\] parameter specifies the part of an instance name that distinguishes a created instance from others. The begin\_number parameter specifies the number from which to start incrementing instance names. The bits parameter specifies the number of digits in the number for each instance name. The name\_suffix parameter specifies the suffix of each instance name. This parameter is optional. When specifying the \[begin\_number,bits\] parameter, you must pay attention to the following rules:

 Do not place spaces between the begin\_number and bits parameters.

 The value of bits can range from 1 to 6.

 The value of begin\_number can range from 0 to 999999.

 If you specify the begin\_number parameter without specifying the bits parameter, bits is set to 6.

 If neither the begin\_number parameter nor the bits parameter is specified, begin\_number is set to 0 and bits is set to 6.

 If the number of digits for begin\_number is greater than the specified value of bits, the specified value of bits will be overridden by the number of digits in the specified value of begin\_number. For example, if \[begin\_number,bits\] is set to \[123456,1\], the value of bits will be overridden by the number of digits in the specified value of begin\_number, which in this case is 6.

 |
|Password|String|No|No|The password used to log on to created ECS instances.|The password must contain characters from at least three of the following categories: uppercase letters, lowercase letters, digits, and special characters. Special characters include \( \) \` ~ ! @ \# $ % ^ & \* - + = | \{ \} \[ \] : ; ' < \> , . ? / If you specify the Password parameter in the API request, use HTTPS to secure the API and protect your password.|
|HostName|String|No|No|The hostname of created ECS instances.| The hostname must be at least 2 characters in length. It cannot start or end with a period \(.\) or a hyphen \(-\). It cannot contain consecutive periods \(.\) or hyphens \(-\).

 For Windows-based instances, the hostname must be 2 to 15 characters in length and can contain letters, digits, and hyphens \(-\). It cannot contain periods \(.\) and cannot be composed of only digits.

 For Linux-based instances, the hostname must be 2 to 30 characters in length and can contain letters, digits, hyphens \(-\), and periods \(.\). Use periods \(.\) to separate a name into multiple segments.

 Hostnames for created ECS instances must be in the name\_prefix\[begin\_number,bits\]name\_suffix format.

 The name\_prefix parameter specifies the prefix of each hostname. This parameter is required.

 The \[begin\_number,bits\] parameter specifies the part of a hostname that distinguishes a created instance from others. The begin\_number parameter specifies the number from which to start incrementing hostnames. The bits parameter specifies the number of digits in the number for each hostname.

 The name\_suffix parameter specifies the suffix of each hostname. This parameter is optional.

 When specifying the \[begin\_number,bits\] parameter, you must pay attention to the following rules: Do not place spaces between the begin\_number and bits parameters.

 The value of bits can range from 1 to 6.

 The value of begin\_number can range from 0 to 999999.

 If you specify the begin\_number parameter without specifying the bits parameter, bits is set to 6.

 If neither the begin\_number parameter nor the bits parameter is specified, begin\_number is set to 0 and bits is set to 6.

 If the number of digits for begin\_number is greater than the specified value of bits, the specified value of bits will be overridden by the number of digits in the specified value of begin\_number. For example, if \[begin\_number,bits\] is set to \[123456,1\], the value of bits will be overridden by the number of digits in the specified value of begin\_number, which in this case is 6.

 |
|AllocatePublicIP|Boolean|No|No|Specifies whether the system allocates a public IP address to an ECS instance. If the InternetMaxBandwidthOut parameter is set to 0, no public IP addresses will be allocated.|Default value: true|
|AutoReleaseTime|String|No|No|The time scheduled for created ECS instances to be automatically released.|Specify the time in the ISO 8601 standard in the yyyy-MM-ddTHH:mm:ssZ format. The specified release time must be within three years of the current time.|
|PrivateIpAddress|String|No|No|The private IP address of an ECS instance in a VPC. The specified IP address must not be in use by other instances in the VPC.|None|
|DiskMappings|List|No|No|The data disks to be attached to created ECS instances.|None|
|InternetChargeType|String|No|No|The billing method for Internet traffic.| Valid values: PayByBandwidth and PayByTraffic

 Default value: PayByTraffic

 |
|InternetMaxBandwidthIn|Integer|No|No|The maximum inbound bandwidth from the Internet. Unit: Mbit/s.|Valid values: 1 to 100. Default value: 100.|
|InternetMaxBandwidthOut|Integer|No|No|The maximum outbound bandwidth to the Internet. Unit: Mbit/s.|Valid values in PayByBandwidth mode: 0 to 200. Default value: 0. Valid values in PayByTraffic mode: 1 to 200. If you choose to use the PayByTraffic mode, you must specify this parameter.|
|IoOptimized|String|No|No|Specifies whether created ECS instances are I/O optimized.| Valid values: none \(non-I/O optimized\) and optimized \(I/O optimized\)

 Default value: none

 |
|SystemDiskCategory|String|No|No|The system disk type of created instances.|Valid values: cloud, cloud\_efficiency, cloud\_ssd, and ephemeral\_ssd|
|SystemDiskDescription|String|No|No|The system disk description of created instances.|None|
|SystemDiskDiskName|String|No|No|The system disk name of created instances.|None|
|SystemDiskSize|Number|No|Yes|The system disk size of created instances. Unit: GB.|Valid values: 40 to 500. If a custom image is used to create a system disk, make sure that the size of the system disk is greater than that of the custom image.|
|Tags|List|No|No|The custom tags of created instances.|For each ECS instance, a maximum of 20 tags can be specified in the \[\{"Key":"tagKey","Value":"tagValue"\},\{"Key":"tagKey2","Value":"tagValue2"\}\] format.|
|UserData|String|No|No|The user data you provide when you create an ECS instance.|The user data can be up to 16 KB in size. You must convert the data into Base64-encoded strings. If the data contains special characters, add a backslash \(\\\) immediately before each special character.|
|ZoneId|String|No|No|The ID of the zone where created instances reside.|None|
|VpcId|String|No|No|The ID of the VPC to which created instances belong.|None|
|VSwitchId|String|No|No|The ID of the VSwitch for created instances.|None|
|KeyPairName|String|No|No|The name of the key pair used to connect to created ECS instances. For Windows-based ECS instances, this parameter is ignored and is empty by default. For Linux-based ECS instances, the Password parameter will still take effect if the KeyPairName parameter is specified. However, logon by password is disabled, and the KeyPairName value is used.|None|
|RamRoleName|String|No|No|The name of the RAM role assigned to created instances.|You can call the ListRoles operation to query the role name. For more information, see [CreateRole](https://partners-intl.aliyun.com/help/doc-detail/28710.htm) and [ListRoles](https://partners-intl.aliyun.com/help/doc-detail/28713.htm).|
|SpotPriceLimit|String|No|No|The maximum hourly price of created instances.|This parameter is only valid when SpotStrategy is set to SpotWithPriceLimit. A maximum of three decimal places can be specified.|
|SpotStrategy|String|No|No|The spot strategy for pay-as-you-go instances.|This parameter is only valid when InstanceChargeType is set to PostPaid. Valid values:

 NoSpot: specifies a regular pay-as-you-go instance.

 SpotWithPriceLimit: specifies a pay-as-you-go instance with a maximum hourly price.

 SpotAsPriceGo: specifies a pay-as-you-go instance priced at the market price at the time of purchase.

 Default value: NoSpot

 |
|DedicatedHostId|String|No|No|The ID of the dedicated host for created instances.|None|
|LaunchTemplateName|String|No|No|The name of the launch template for created instances.|None|
|PeriodUnit|String|No|No|The unit of billing cycle for created instances. When the PeriodUnit parameter is set to Week:

 -   Valid values for the Period parameter: 1, 2, 3, and 4
-   Valid values for the AutoRenewPeriod parameter: 1, 2, and 3

 When the PeriodUnit parameter is set to Month: -   Valid values for the Period parameter: 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 24, 36, 48, and 60
-   Valid values for the AutoRenewPeriod parameter: 1, 2, 3, 6, and 12

 | Valid values: Week and Month

 Default value: Month

 |
|AutoRenewPeriod|Number|No|Yes|The automatic subscription renewal period for created instances. This parameter is required when AutoRenew is set to True.| Valid values: 1, 2, 3, 6, and 12

 Default value: 1

 |
|AutoRenew|String|No|Yes|Specifies whether to enable automatic renewal for created instances. Default value: False. This parameter is only valid when InstanceChargeType is set to PrePaid.|Valid values: -   True: specifies to enable automatic renewal for created instances.
-   False: specifies to disable automatic renewal for created instances.

 |
|InstanceChargeType|String|No|Yes|The billing method of created instances. Default value: PostPaid.|Valid values: -   PrePaid: specifies the subscription billing method, in which services are billed on a monthly or yearly basis. You must ensure that the balance of your account or credit balance can cover the cost of the subscription. Otherwise, you will receive an `InvalidPayMethod` error code.
-   PostPaid: specifies the pay-as-you-go billing method, in which services are billed by the amount of resources that you actually use.

 |
|EniMappings|List|No|Yes|The elastic network interfaces \(ENIs\) to be attached to created instances.|Only one ENI can be attached to an instance.|
|LaunchTemplateId|String|No|Yes|The ID of the launch template from which to create instances.|None|
|LaunchTemplateVersion|String|No|Yes|The version of the specified launch template. If you do not specify a version, the default version is used.|None|
|Period|Number|No|Yes|The subscription period of created instances. Unit: months. This parameter is only required when InstanceChargeType is set to PrePaid. If the DedicatedHostId parameter is specified, the subscription period of the instance must be shorter than that of the dedicated host.|Valid values: -   Valid values for the Period parameter in the case of `PeriodUnit=Week`: 1, 2, 3, and 4
-   Valid values for the Period parameter in the case of `PeriodUnit=Month`: 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 24, 36, 48, and 60

 |
|NetworkType|String|No|No|The network type of created ECS instances.| Valid values: vpc and classic

 Default value: classic

 |
|DeletionProtection|Boolean|No|No|The release protection property of created ECS instances. It specifies whether the instances can be released from the ECS console or through the DeleteInstance API operation.|Valid values: true and false|
|DeploymentSetId|String|No|Yes|The ID of the deployment set used to create ECS instances.|None|

## DiskMappings syntax {#section_tjh_kal_k6c .section}

``` {#codeblock_uoz_vdu_2d5 .language-json}
"DiskMappings": [
  {
    "Category": String,
    "DiskName": String,
    "Description": String,
    "Device": String,
    "SnapshotId": String,
    "Size": String,
    "Encrypted": String,
    "KMSKeyId": String
  }
]
```

## DiskMappings properties {#section_39d_e40_xo6 .section}

|Name|Type|Required|Editable|Description|Validity|
|----|----|--------|--------|-----------|--------|
|Size|String|Yes|No|The size of a data disk to be attached to a created instance. Unit: GB.|None|
|Category|String|No|No|The type of a data disk to be attached to a created instance.|Valid values: cloud, cloud\_efficiency, cloud\_ssd, and ephemeral\_ssd|
|DiskName|String|No|No|The name of a data disk to be attached to a created instance.|The name can be up to 128 characters in length and can contain letters, digits, underscores \(\_\), periods \(.\), and hyphens \(-\).|
|Description|String|No|No|The description of a data disk to be attached to a created instance.|The description must be 2 to 256 characters in length and cannot start with http:// or https://.|
|Device|String|No|No|The device name of a data disk to be attached to a created instance.|The system allocates a device name in the alphabetical order from /dev/xvda to /dev/xvdz by default.|
|SnapshotId|String|No|No|The ID of the snapshot used to create a data disk.|None|
|Encrypted|String|No|No|Specifies whether to encrypt a data disk.|Default value: false|
|KMSKeyId|String|No|No|The ID of the KMS key corresponding to a data disk.|None|

## Tags syntax {#section_yw8_jqs_gx1 .section}

``` {#codeblock_ha2_frx_24k .language-json}
"Tags": [
  {
    "Value": String,
    "Key": String
  }
]
```

## Tags properties {#section_qf5_2mx_o68 .section}

|Name|Type|Required|Editable|Description|Validity|
|----|----|--------|--------|-----------|--------|
|Key|String|Yes|No|None|None|
|Value|String|No|No|None|None|

## Response parameters {#section_ijt_fr2_lfb .section}

**Fn::GetAtt**

-   InstanceIds: the IDs of instances in the ECS instance group. An ID is a system-generated globally unique identifier \(GUID\) for an instance.
-   PrivateIps: the list of private IP addresses of VPC-connected instances. This parameter is only valid when the NetworkType parameter is set to VPC. The list is a JSON array, containing up to 100 IP addresses separated by commas \(,\). Example: \["172.16.XX.XX", "172.16. XX.XX", ... "172.16. XX.XX"\].
-   InnerIps: the list of private IP addresses of classic network-connected instances. This parameter is only valid when the NetworkType parameter is set to Classic. The list is a JSON array, containing up to 100 IP addresses separated by commas \(,\). Example: \["10.1.XX.XX", "10.1. XX.XX", ... "10.1. XX.XX"\].
-   PublicIps: the list of public IP addresses of classic network-connected instances. This parameter is only valid when the NetworkType parameter is set to Classic. The list is a JSON array, containing up to 100 IP addresses separated by commas \(,\). Example: \["42.1.XX.XX", "42.1. XX.XX", ... "42.1. XX.XX"\].
-   HostNames: the list of hostnames of all instances. The list is a formatted JSON array. Example: \["host1", "host2", ... "host3"\].
-   OrderId: the list of order IDs of all instances.
-   ZoneId: the ID of the zone where created instances reside.
-   RelatedOrderIds: the list of related order IDs of created ECS instances.

## Examples {#section_ygv_fr2_lfb .section}

``` {#codeblock_cpe_djk_cf3 .language-json}
{
  "ROSTemplateFormatVersion":"2015-09-01",
  "Resources":{
    "WebServer": {
      "Type": "ALIYUN::ECS::InstanceGroup",
      "Properties": {
        "ImageId":"m-25l0r****",
        "InstanceType": "ecs.t1.small",
        "SecurityGroupId": "sg-25zwc****",
        "ZoneId": "cn-beijing-b",
        "MaxAmount":1,
        "MinAmount":1,
        "Tags": [{
            "Key": "tiantt",
            "Value": "ros"
        },{
            "Key": "tiantt1",
            "Value": "ros1"
        }
        ]
      }
    }
  },
  "Outputs": {
    "InstanceIds": {
         "Value":{"get_attr": ["WebServer","InstanceIds"]}
    },
    "PublicIps": {
         "Value":{"get_attr": ["WebServer","PublicIps"]}
    }
  }
}
```

repository: fouadyousufdar/ros

repo_name: fouadyousufdar/ros


text:
# Changelog

## [v1.3.1](https://github.com/NPLinker/nplinker/tree/v1.3.1) (2022-08-05)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.3.0...v1.3.1)

**Closed issues:**

- Important: Stop committing until restructuring is done  [\#73](https://github.com/NPLinker/nplinker/issues/73)
- Explore tutorials/modules are relevant to develop the dashboard [\#68](https://github.com/NPLinker/nplinker/issues/68)

**Merged pull requests:**

- Refine install script and upgrade python syntax [\#75](https://github.com/NPLinker/nplinker/pull/75) ([CunliangGeng](https://github.com/CunliangGeng))

## [v1.3.0](https://github.com/NPLinker/nplinker/tree/v1.3.0) (2022-07-21)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.2.0...v1.3.0)

**Implemented enhancements:**

- Packaging [\#15](https://github.com/NPLinker/nplinker/issues/15)

**Closed issues:**

- Create independent repo for webapp? [\#72](https://github.com/NPLinker/nplinker/issues/72)
- Restructure repo with python template from eScience Center  [\#71](https://github.com/NPLinker/nplinker/issues/71)
- Update wiki page [\#64](https://github.com/NPLinker/nplinker/issues/64)
- something goes wrong in the step for "MetcalfScoring.setup preprocessing dataset" [\#57](https://github.com/NPLinker/nplinker/issues/57)
- Parsing strains in GNPS FBMN output needs to be more flexible [\#50](https://github.com/NPLinker/nplinker/issues/50)
- Rosetta Score issue [\#39](https://github.com/NPLinker/nplinker/issues/39)
- Loading FBMN-GNPS and Bigscape output data into NPLinker error. [\#35](https://github.com/NPLinker/nplinker/issues/35)
- Remove requirements.txt file [\#6](https://github.com/NPLinker/nplinker/issues/6)
- Matching compound names from GNPS to MiBIG [\#3](https://github.com/NPLinker/nplinker/issues/3)

**Merged pull requests:**

- Bump numpy from 1.21.0 to 1.22.0 [\#70](https://github.com/NPLinker/nplinker/pull/70) ([dependabot[bot]](https://github.com/apps/dependabot))
- NpclassScore expand notebooks [\#69](https://github.com/NPLinker/nplinker/pull/69) ([louwenjjr](https://github.com/louwenjjr))

## [v1.2.0](https://github.com/NPLinker/nplinker/tree/v1.2.0) (2022-06-07)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.1.3...v1.2.0)

**Closed issues:**

- WebApp shows no data in tables [\#63](https://github.com/NPLinker/nplinker/issues/63)
- "Error in server loaded hook UnicodeDecodeError" [\#60](https://github.com/NPLinker/nplinker/issues/60)
- Error in loading from PoDP: MSV000078839 [\#58](https://github.com/NPLinker/nplinker/issues/58)
- Linking molfams [\#54](https://github.com/NPLinker/nplinker/issues/54)

**Merged pull requests:**

- Bump httpx from 0.16.1 to 0.23.0 [\#66](https://github.com/NPLinker/nplinker/pull/66) ([dependabot[bot]](https://github.com/apps/dependabot))
- Expand documentation [\#65](https://github.com/NPLinker/nplinker/pull/65) ([louwenjjr](https://github.com/louwenjjr))
- Bump numpy from 1.20.1 to 1.21.0 [\#62](https://github.com/NPLinker/nplinker/pull/62) ([dependabot[bot]](https://github.com/apps/dependabot))
- NPClassScore scoring [\#61](https://github.com/NPLinker/nplinker/pull/61) ([louwenjjr](https://github.com/louwenjjr))
- Bump pillow from 8.3.2 to 9.0.0 [\#59](https://github.com/NPLinker/nplinker/pull/59) ([dependabot[bot]](https://github.com/apps/dependabot))

## [v1.1.3](https://github.com/NPLinker/nplinker/tree/v1.1.3) (2021-11-26)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.1.2...v1.1.3)

## [v1.1.2](https://github.com/NPLinker/nplinker/tree/v1.1.2) (2021-09-23)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.1.1...v1.1.2)

**Closed issues:**

- Turning MIBiG on in BiG-SCAPE run of NPLinker [\#55](https://github.com/NPLinker/nplinker/issues/55)

## [v1.1.1](https://github.com/NPLinker/nplinker/tree/v1.1.1) (2021-09-13)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.1...v1.1.1)

**Closed issues:**

- Add a changelog and tag Docker images [\#52](https://github.com/NPLinker/nplinker/issues/52)
- GCF/BGC data does appear correctly in results [\#49](https://github.com/NPLinker/nplinker/issues/49)

**Merged pull requests:**

- Bump pillow from 8.2.0 to 8.3.2 [\#53](https://github.com/NPLinker/nplinker/pull/53) ([dependabot[bot]](https://github.com/apps/dependabot))

## [v1.1](https://github.com/NPLinker/nplinker/tree/v1.1) (2021-09-04)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v1.0...v1.1)

**Implemented enhancements:**

- Error when loading Crüsemann data [\#38](https://github.com/NPLinker/nplinker/issues/38)

**Fixed bugs:**

- large-scale sample run error [\#43](https://github.com/NPLinker/nplinker/issues/43)

**Closed issues:**

- Add Licence [\#48](https://github.com/NPLinker/nplinker/issues/48)
- Allowing other websocket to connect to proxy server? [\#47](https://github.com/NPLinker/nplinker/issues/47)
- KeyError in strains.py [\#46](https://github.com/NPLinker/nplinker/issues/46)
- Internal Server Error with tutorial data [\#45](https://github.com/NPLinker/nplinker/issues/45)
- Error loading tutorial data [\#44](https://github.com/NPLinker/nplinker/issues/44)
- rosetta scoring: check for knownclusterblast .txt files at start of scoring process [\#34](https://github.com/NPLinker/nplinker/issues/34)

**Merged pull requests:**

- Bump pillow from 8.1.1 to 8.2.0 [\#42](https://github.com/NPLinker/nplinker/pull/42) ([dependabot[bot]](https://github.com/apps/dependabot))

## [v1.0](https://github.com/NPLinker/nplinker/tree/v1.0) (2021-03-19)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/last_version_with_plots...v1.0)

**Merged pull requests:**

- Bump pillow from 8.1.0 to 8.1.1 [\#40](https://github.com/NPLinker/nplinker/pull/40) ([dependabot[bot]](https://github.com/apps/dependabot))

## [last_version_with_plots](https://github.com/NPLinker/nplinker/tree/last_version_with_plots) (2021-02-15)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/v.0.1...last_version_with_plots)

**Closed issues:**

- Write log output to file [\#37](https://github.com/NPLinker/nplinker/issues/37)

## [v.0.1](https://github.com/NPLinker/nplinker/tree/v.0.1) (2020-12-11)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/scoring_jun2020...v.0.1)

**Implemented enhancements:**

- Input options [\#14](https://github.com/NPLinker/nplinker/issues/14)
- More general annotations [\#12](https://github.com/NPLinker/nplinker/issues/12)

**Closed issues:**

- metadata [\#2](https://github.com/NPLinker/nplinker/issues/2)
- MiBIG [\#1](https://github.com/NPLinker/nplinker/issues/1)

## [scoring_jun2020](https://github.com/NPLinker/nplinker/tree/scoring_jun2020) (2020-05-29)

[Full Changelog](https://github.com/NPLinker/nplinker/compare/6c299348b417e494167c4bd4869fa79f62383fc9...scoring_jun2020)

**Implemented enhancements:**

- Generate null distributions for the different scoring functions [\#9](https://github.com/NPLinker/nplinker/issues/9)

**Fixed bugs:**

- NP-optimised Metcalf score crashes [\#24](https://github.com/NPLinker/nplinker/issues/24)

**Closed issues:**

- Restrict NPLinker strain object to data set population [\#27](https://github.com/NPLinker/nplinker/issues/27)

**Merged pull requests:**

- Bump bleach from 3.0.2 to 3.1.1 [\#30](https://github.com/NPLinker/nplinker/pull/30) ([dependabot[bot]](https://github.com/apps/dependabot))
- Hack to resolve GenBank accession to RefSeq accession [\#29](https://github.com/NPLinker/nplinker/pull/29) ([grimur](https://github.com/grimur))
- Rosetta [\#28](https://github.com/NPLinker/nplinker/pull/28) ([sdrogers](https://github.com/sdrogers))
- Bump notebook from 5.7.0 to 5.7.8 [\#26](https://github.com/NPLinker/nplinker/pull/26) ([dependabot[bot]](https://github.com/apps/dependabot))
- Merging webapp back into master [\#25](https://github.com/NPLinker/nplinker/pull/25) ([andrewramsay](https://github.com/andrewramsay))
- Additional link expectancy calculations. [\#20](https://github.com/NPLinker/nplinker/pull/20) ([florian-huber](https://github.com/florian-huber))
- get\_links function now takes Spectrum, MolecularFamily, or GCF object… [\#19](https://github.com/NPLinker/nplinker/pull/19) ([florian-huber](https://github.com/florian-huber))
- Added some expectancy/probability calculations [\#18](https://github.com/NPLinker/nplinker/pull/18) ([florian-huber](https://github.com/florian-huber))
- Update of tests for updated matrix multiplication functions [\#17](https://github.com/NPLinker/nplinker/pull/17) ([florian-huber](https://github.com/florian-huber))
- Added functions and clearer code structure [\#16](https://github.com/NPLinker/nplinker/pull/16) ([florian-huber](https://github.com/florian-huber))
- Additional DataLinks and LinkProbabilty classes  [\#8](https://github.com/NPLinker/nplinker/pull/8) ([florian-huber](https://github.com/florian-huber))
- Updating metcalf\_scoring to use a faster numpy-based method. [\#7](https://github.com/NPLinker/nplinker/pull/7) ([andrewramsay](https://github.com/andrewramsay))
- 2to3 changes [\#5](https://github.com/NPLinker/nplinker/pull/5) ([andrewramsay](https://github.com/andrewramsay))
- simple multiprocessing for scoring [\#4](https://github.com/NPLinker/nplinker/pull/4) ([andrewramsay](https://github.com/andrewramsay))

\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

repository: NPLinker/nplinker

branch_name: refs/heads/dev

gha_language: Jupyter Notebook

repo_name: NPLinker/nplinker