Some time ago I’ve cloned the original argbash repository, because the original Docker image available on the Docker Hub has been outdated at that time.

Later I’ve added two wrapper utilities that make using the dockerized argbash even more convenient. They are pretty straightforward and the embedded help should be probably sufficient, but I’ve added also the following description page.

From time to time I’ll merge the new updates from the original argbash repository.

The original README for the Docker image can be found here.

You can build the argbash-docker image from the project’s root directory like this:

docker build -f ./docker/Dockerfile -t accetto/argbash-docker .

You can also download the image from the Docker Hub repository accetto/argbash-docker.

Enjoy using argbash, it’s a nice tool. The credit goes to the original author(s).

The original README content follows.

• Do you write Bash scripts that should accept arguments?
• But they don’t since arguments support is a daunting task, because …
• getopt is discouraged, getopts doesn’t support long options, there is no widely-accepted Bash module to do the task and some solutions don’t work on all platforms (Linux, OSX, MSW)…

Give Argbash a try and stop being terrorized by those pesky arguments! With Argbash, you will get:

• Fast, minimalistic declaration of arguments your script expects (see below for supported argument types).
• Scripts generated from definitions once that can be used on all platforms that have bash.
• Definitions embedded in few lines of the script itself (so you can use Argbash to regenerate the parsing part of your script easily).
• Ability to re-use low-level Argbash-aware scripts by wrapping them by higher-level Argbash-aware ones conveniently, without duplicating code.
• Easy installation (optional). Just grab a release, unzip it, go inside and run cd resources && make install (you may want to run sudo make install PREFIX=/usr for a system-wide installation).
• Documentation and examples.

Make your existing script powered by Argbash in a couple of minutes. Explore various Argbash flavours:

Argbash is not a parsing library, but it is rather a code generator that generates a bash library tailor-made for your script. It lets you to describe arguments your script should take and then, you can generate the bash parsing code. It stays in your script by default, but you can have it generated to a separate file and let Argbash to include it in your script for you. In any case, you won’t need Argbash to run the script.

Argbash is very simple to use and the generated code is relatively nice to read. Moreover, argument definitions stay embedded in the script, so when you need to update the parsing logic, you just re-run the argbash script on the already generated script.

So by writing few comments to your script and running the Argbash’s bin/argbash over it, you will get a bash script with argument parsing. See the simple example source template and simple example script for the result. If you are not into long reading, let bin/argbash-init generate the template for you.

Following argument types are supported:

• Positional arguments (defaults supported, possibility of fixed, variable or infinite number of arguments),
• optional arguments that take one value,
• boolean optional arguments,
• repeated (i.e. non-overwriting) optional arguments,
• incrementing (such as --verbose) optional arguments and
• action optional arguments (such as --version, --help).

Following outputs are available:

• Bash scripts, tailor-made bash parsing libraries.
• POSIX scripts that use getopts, also tailor-made.
• Bash completion.
• docopt-compliant usage message.
• Manpage output using rst2man.

The utility has been inspired by Python’s argparse and the shflags project.

Read the docs (latest stable version) for more info

• bash that can work with arrays (most likely bash >= 3.0) (the only requirement for users – i.e. people that only execute scripts and don’t make them)
• autom4te utility that can work with sets (part of autoconf >= 2.63 suite)
• basic utilities s.a. sed, grep, cat, test.

• wxWidgets
• SDL2
• SDL2_image
• SDL2_ttf
• SDL2_mixer
• cmake
• git

git clone github.com/SL-Pirate/snake
cd snake
mkdir build
cd build
cmake ..
make

do sudo chmod +x ./snake

• This needs to be done only once!
• after this is done just execute the snake binary from a command line or a graphical file manager.

1. Download and install wxWidgets from their official website

2. Add the path_to_the_root_of_your_wxWidgets_folder to your system environment variables under the name wxWidgets

3. Download the development packages of

   • SDL2
   • SDL2_image
   • SDL2_ttf
   • SDL2_mixer

   corresponding to your compiler

4. Extract the development package of SDL2 and rename the directory as SDL2

5. Extract the development package of SDL2_image to the same folder and rename it as SDL2_image

6. Extract the development package of SDL2_image to the same folder and rename it as SDL2_ttf

7. Extract the development package of SDL2_mixer to the same folder and rename it as SDL2_mixer

   Now your directory should look like this

   {BaseFolder}
   ├── SDL2
       ├── cmake
       ├── include
       ├── lib
       etc...
   .......
       SDL2_image
       ├── cmake
       ├── include
       ├── lib
       etc...
   ........
       SDL2_ttf
       ├── cmake
       ├── include
       ├── lib
       etc...
   ........
       SDL2_mixer
       ├── cmake
       ├── include
       ├── lib
       etc...
   

8. Add the path_to_the_root_of_your_SDL2_BaseFolder to your system environment variables under the name SDL2

• if using MinGW32-gcc

git clone github.com/SL-Pirate/snake
cd snake
mkdir build
cd build
cmake .. -G "MinGW Makefiles"
make

• if using msvc

git clone github.com/SL-Pirate/snake
cd snake
mkdir build
cd build
cmake --build ..

A newer version of @Animecyc Android TitaniumAnimator

A drop-in animation replacement for Titanium. This module’s aim is to mimick as much of the Titanium animation module as possible with the addition of new timing functions and better performance. As of right now the only properties that can be animated are: rotate, transform, top, bottom, left, right, width, height, opacity, color and backgroundColor. The transform property is not supported at this time.

If you are animating views that don’t contain any sort of transparency you will see performance gains when animating large or otherwise complex view groups.

• Android: 7.0+

Download it here

var Animator = require('ti.android.animator');
    
var mainWindow = Ti.UI.createWindow({
	backgroundColor : 'white'
});
    
var animationView = Ti.UI.createView({
    	backgroundColor : 'red',
    	width : 100,
    	height : 100
});

animationView.addEventListener('click', function () {
	Animator.animate(animationView, {
		duration : 1000,
		easing : Animator.BOUNCE_OUT,
		width : 150,
		height : 150,
		backgroundColor : 'blue',
		opacity : 0.5,
		bottom : 0
	}, function () {
		Animator.animate(animationView, {
			duration : 1000,
			easing : Animator.BOUNCE_OUT,
			width : 100,
			height : 100,
			backgroundColor : 'red',
			opacity : 1,
			bottom : null
		});
	});
});

mainWindow.add(animationView);

mainWindow.open();

If you need to perform a rotation you can pass the rotate property which accepts a float. The rotate property is the angle you wish to rotate to; A positive value will result in a counter-clockwise rotation, while a negative value will result in a clockwise rotation.

Once a rotation has been performed subsequent rotations will be performed from its last rotation angle. To simplify multiple rotations you can pass values > 360. For example to do two complete rotations you can pass a value of 720.

When animating a complex layout (such as a vertical layout inside a vertical layout) it may be necessary to specify which parent to propogate the animimations from, you can do this by setting parentForAnimation and passing the proxy that holds the views that should animate. This is especially useful in cases where you are animating inside of a Ti.UI.ScrollView.

The below easing functions can be accessed as you would any other Titanium constant. Assuming the above usage example you can access all of these by passing the below name to the module, such as in: Animator.ELASTIC_IN_OUT

• LINEAR (default)
• QUAD_IN
• QUAD_OUT
• QUAD_IN_OUT
• CUBIC_IN
• CUBIC_OUT
• CUBIC_IN_OUT
• QUART_IN
• QUART_OUT
• QUART_IN_OUT
• QUINT_IN
• QUINT_OUT
• QUINT_IN_OUT
• SINE_IN
• SINE_OUT
• SINE_IN_OUT
• CIRC_IN
• CIRC_OUT
• CIRC_IN_OUT
• EXP_IN
• EXP_OUT
• EXP_IN_OUT
• ELASTIC_IN
• ELASTIC_OUT
• ELASTIC_IN_OUT
• BACK_IN
• BACK_OUT
• BACK_IN_OUT
• BOUNCE_IN
• BOUNCE_OUT
• BOUNCE_IN_OUT

Note : All the Rendered Juypter Notebooks(in nbviewer) for better view are availabe by clicking on the links embedded below. Also some links might not work so you can direcly click here and paste the link of the notebook you want to render

DNA Sequencing is the process of determining the nucleic acid sequence – the order of nucleotides in DNA. It includes any method or technology that is used to determine the order of the four bases: Adenine(A), Guanine(G), Cytosine(C), and Thymine(T).
DNA Sequencing may be used to determine the sequence of individual genes, larger genetic regions (i.e. clusters of genes or operons), full chromosomes, or entire genomes of any organism. DNA sequencing is also the most efficient way to indirectly sequence RNA or proteins.

• Online Algorithms:

  The algorithm in which the text ‘T’ (in our case the reference genome) is not pre-processed, and it doesn’t matter if the pattern ‘P’ is pre-processed or not.

  • Naive Exact Matching Algorithm :

    We niether pre-process ‘P’ nor ‘T’.

  • Boyer-Moore (using Z-Algorithm) :

    Here we pre-process ‘P’ but not ‘T’ so it’s online.

    • Text Resource : Go Through Chapter 2 of Algorithms on Strings, Trees, and Sequences( by Dan Gusfield)

    • Video Resource : Linear-time pattern matching : Z-values and Z-algorithm ( by Dan Gusfield) Part 1 Part 2

• Offline Algorithms:

  The algorithm in which the text ‘T’ is pre-processed, and it doesn’t matter if the pattern ‘P’ is pre-processed or not.

  • SubString Indexing, k-mer index :

  We use the term k-mer to refer to a substring of length k. For each offset that the index reports back, that’s called an index hit. When P matches within T, we’ve been calling that a match, or an occurrence. But, an index hit may or may not correspond to a match, it’s just a hint that we should look harder in that particular region of T. So, not all index hits lead to matches, because we don’t know whether the rest of P matches where it should within T. We have to do more character comparisons. And, this additional work that we do is called verification.

  This kind of data structure is called a multimap. It’s a map because it associates keys, k-mers, in this case with values, offsets in the genome. And it’s a multimap because a k-mer may be associated with many different offsets in the genome.

  • SubSequence Indexing:

  In mathematics, a subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

• We need algorithms that can do approximate matching. Allowing for differences between the pattern and the text. One of the reason we might expect differences between the read and the reference is because of sequencing errors. Sometimes the sequencer will make mistakes. It will miscall a base in the sequencing read. And when that happens, that base might no longer match the reference genome.

• We want to be able to talk about the distance between two strings. In other words, we want to be able to describe how different they are, how many differences there are. But we have to define exactly what we mean by distance.

  • So the first kind of distance we’ll define is called Hamming Distance. So if you have two strings, X & Y, that are of the same length, we can define the hamming distance between X and Y as the minimal number of substitutions we need to make to turn one of the strings into the other.

  • Another is Edit Distance(AKA levenshtein Distance) between two strings equals the minimal number of edits required to turn one string into the other. Where a single edit could be a substitution, or it could be an insertion or a deletion. (In this case X & Y could be of different length)

  • Approximate Matching Algorithm using Pigeonhole Principle (and Boyer Moore) : The Pigeonhole Principle states that if items are put into containers, with, then at least one container must contain more than one item. In our case we will split pattern ‘P’ (k+1) times when we are looking for an approximate match of upto ‘k’ mismatches, that means even if we have ‘k’ mismatches in ‘k’ partitions of pattern ‘P’, still there will be atleast one partition which will exactly match with the reference genome, which we can later confirm by verification as stated in indexing techiques.

  • Global Alignment: Calculating a global alignment is a form of global optimization that “forces” the alignment to span the entire length of all query sequences. By contrast, local alignments identify regions of similarity within long sequences that are often widely divergent overall. An attempt is made to align the entire sequence (end to end alignment) Finds local regions with the highest level of similarity between the two sequences. A global alignment contains all letters from both the query and target sequences. It penalises the Substitution/ Insertion/ Deletion differently than editDistance.

  • Overlaps: Overlap–layout–consensus genome assembly algorithm: Reads are provided to the algorithm. Overlapping regions are identified. Each read is graphed as a node and the overlaps are represented as edges joining the two nodes involved. The algorithm determines the best path through the graph (Hamiltonian path).

  • Shortest Common Superstring: A shortest common supersequence (SCS) is a common supersequence of minimal length. In the shortest common supersequence problem, two sequences X and Y are given, and the task is to find a shortest possible common supersequence of these sequences.

A passcode entry field for macOS similar to Apple’s two-factor authentication field.

The control is made up of multiple groups of passcode ‘cells’. Each cell holds a single ‘character’, and you define groups of cells using a group separator. The pattern you define provides the layout — containing # for a passcode cell and - for a group separator.

For example, to create a passcode of six characters split evenly into two groups of three cells, you set the passcode pattern to "###-###"

.---. .---. .---.   .---. .---. .---.
|   | |   | |   |   |   | |   | |   |
|   | |   | |   |   |   | |   | |   |
`---' `---' `---'   `---' `---' `---'

This control can be used in both autolayout and manual layout apps (internally the control does not use auto-layout)

Note this control uses @VIViewInvalidating providing automatic NSView invalidation when properties value change. (automatically added as a dependency)

• Configurable allowable character support
• Character Viewer support (eg. hit Command-Ctrl-Space when a passcode cell is active)
• Different fonts
• Different spacing (intra-cell, edge insets, group and cell spacing)
• Light and dark modes
• High contrast support
• Accessibility and VoiceOver support

Using Swift Package Manager, add https://github.com/dagronf/DSFPasscodeView to your project.

The cell pattern to use when displaying the passcode. A # represents a cell and a - represents a group space.

The only valid characters are # (a cell) and – (group spacing). Attempting to set a pattern with any other character will result in a fatalError()

Examples :-

"###-###"
.---. .---. .---.   .---. .---. .---.
|   | |   | |   |   |   | |   | |   |
|   | |   | |   |   |   | |   | |   |
`---' `---' `---'   `---' `---' `---'

"####-##-###"
.---. .---. .---. .---.   .---. .---.   .---. .---. .---.
|   | |   | |   | |   |   |   | |   |   |   | |   | |   |
|   | |   | |   | |   |   |   | |   |   |   | |   | |   |
`---' `---' `---' `---'   `---' `---'   `---' `---' `---'

"##-##-#"
.---. .---.   .---. .---.   .---.
|   | |   |   |   | |   |   |   |
|   | |   |   |   | |   |   |   |
`---' `---'   `---' `---'   `---'

The spacing to use between adjacent cells

The spacing to use between cell groups

The font to use when displaying the character in a cell

The padding to use between the character and the edge of its cell

The padding to use between the cells and the bounds of the control

Enable or disable the control (observable)

There are two methods of validation

This settings on the control allows you to specify a string containing the characters that are allowed within the control. By default, this is 0123456789.

For more complex validations, you can specify a callback block which can be used to validate each character

It takes a string element and returns either a value transformed string element (for example, uppercased), or nil if the presented character isn’t valid for the control.

// A validator block which allows numbers and case-insensitive A-F characters
self.passcode.characterValidatorBlock = { element in
   let validChars = "0123456789ABCDEF"
   let s = element.uppercased()         // Always check against uppercase
   if validChars.contains(s) {          // If the validChars contains the uppercased char...
       return s.first                   //  ... return the uppercased version
   }
   return nil                           // Unsupported char, ignore by returning nil
}

You can bind to these member variables to receive updates as the control content changes.

Is the passcode entered a valid passcode (ie. all the values are specified)

Are there no values specified yet

If the passcode is valid, the passcode value as a string, otherwise nil.

You can attach a delegate to receive messages back from the view if binding is not your thing.

func passcodeViewDidChange(
   _ view: DSFPasscodeView)

Called when the content of the passcode view changes.

func passcodeView(
   _ view: DSFPasscodeView,                        // The passcode view
   updatedPasscodeValue passcode: String)          // The valid passcode as a string of characters

Called ONLY when the passcode is valid and complete.

func passcodeView(
   _ view: DSFPasscodeView,                        // The passcode view 
   didTryInvalidCharacter invalidChar: String?,    // The invalid character, or nil for a special key
   atIndex index: Int)                             // The passcode cell index where the attempt failed

Called if the user presses an unsupported character or key in a passcode cell.

• Xcode has been broken for many years regarding support for @IBDesignable/@IBInspectable. Whilst this control provides support, Xcode’s support for @IBDesignable for a control provided from a package is completely broken.

If you copy the DSFPasscodeView source files directly into your project the Designables work as expected (FB8358478).

MIT. Use it and abuse it for anything you want, just attribute my work. Let me know if you do use it somewhere, I’d love to hear about it!

MIT License

Copyright (c) 2021 Darren Ford

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

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

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

• Tools
• Educational
• Companies
• Other
• Contributing

• Secure.py – secure.py 🔒 is a lightweight package that adds optional security headers and cookie attributes for Python web frameworks.
• Flask-HTTPAuth – Simple extension that provides Basic, Digest and Token HTTP authentication for Flask routes.
• Flask Talisman – Talisman is a small Flask extension that handles setting HTTP headers that can help protect against a few common web application security issues.
• Django deployment checklist – Web framework Django has built-in feature to check for security configurations: run this command manage.py check --deploy. It’s really helpful as it already included in the framework.
• Django Session CSRF – CSRF protection for Django without cookies.

• hawkeye – Multi purpose security/vulnerability/risk scanning tool supporting Ruby, Node.js, Python, PHP and Java.
• GuardRails – A GitHub App that gives you instant security feedback in your Pull Requests.
• Hubble – Hubble is a modular, open-source security compliance framework.
• Salus – Multi purpose security scanning tool supporting Ruby, Node, Python and Go.

• Bandit – Bandit is a tool designed to find common security issues in Python code.
• Pyt – A Static Analysis Tool for Detecting Security Vulnerabilities in Python Web Applications.
• Detect Secrets – An enterprise friendly way of detecting and preventing secrets in code.

• Safety – Safety checks your installed dependencies for known security vulnerabilities.
• snyk Vulnerability DB – Commercial but free listing of known vulnerabilities in libraries.
• Common Vulnerabilities and Exposures – Vulnerabilities that were assigned a CVE. Covers the language and packages.
• National Vulnerability Database – Python known vulnerabilities in the National Vulnerability Database.

• EvilTwinFramework – A framework for pentesters that facilitates evil twin attacks as well as exploiting other wifi vulnerabilities.
• sqlmap – Automatic SQL injection and database takeover tool

• Passlib – Secure password storage/hashing library, very high level.
• PyNacl – Python binding to the Networking and Cryptography (NaCl) library.

• wemake-django-template – Bleeding edge django template focused on code quality and security.

• Let’s be bad Guys – Shiny, Let’s Be Bad Guys: Exploiting and Mitigating the Top 10 Web App Vulnerabilities.
• django.nV – django.nV is a purposefully vulnerable Django application provided by nVisium.
• DSVW – Damn Small Vulnerable Web (DSVW) is a deliberately vulnerable web application written in under 100 lines of code, created for educational purposes.
• DVPWA – Damn Vulnerable Python Web Application was inspired by famous dvwa project and bobby-tables xkcd comics.

• Full Stack Python Security – A comprehensive look at cybersecurity for Python developers

• cryptography – A package designed to expose cryptographic primitives and recipes to Python developers.
• 10 Common Security Gotchas in Python – 10 common security gotchas in Python and how to avoid them.
• OWASP Python Security – Aims at creating a hardened version of python that makes it easier for developers to write applications more resilient to attacks and manipulations.
• Django Security – Overview of Django’s security features includes advice on securing a Django-powered site.

• GuardRails – A GitHub App that gives you instant security feedback in your Pull Requests.
• Snyk – A developer-first solution that automates finding & fixing known vulnerabilities in your dependencies.

• Python Security Reporting

Found an awesome project, package, article, or another type of resources related to Python Security? Send me a pull request! Just follow the guidelines. Thank you!

say hi on Twitter

Engineering,BCA,B.Com,M.Com,Mca notes For All University
notes4free(http://notes4free.in/)
notes4free this platform, Students can get all kinds of notes for courses such as Vtu Engineering(CBCS and Non-CBCS), b.com, BCA, mca, b.tech, etc. and students can also get regular semester projects based on web development and other domain projects, including all types of software projects. Model paper and question paper from the previous year are also available to help the students score more.

Engineering Notes
Notes4free provides all department notes under new scheme and syllabus of VTU CBCS & Non-CBCS Engineering notes and that is mainly intended for students who are studying under the new CBCS and Non-CBCS VTU scheme. Often we update more VTU CBCS scheme notes of all departments of engineering including study materials. To download please click here.http://notes4free.in/

BCA
notes4free offers BCA departmental notes for the students studying in the new BCA Scheme and the 3-year curriculum from the first sem to the sem of BCA. We frequently add more BCA notes and study materials on a regular basis. To download, click here http://notes4free.in/

B.Com
Notes4free offers B.Com notes and this is given under the new B.Com scheme and curriculum. We add more B.com notes and study materials on a regular basis. To download, click here.http://notes4free.in/

M.Com
Notes4free provides M.com department notes and this is provided to students studying under the new M.Com scheme and syllabus. More M.Com notes and study materials are added regularly. To download, click here.http://notes4free.in/

Vtu Engineering software projects

VTU software projects based on python, web-based development, graphics design, and other software where you pay for certain projects, and some are not paid means its free to download. if you have an error during the execution of the projects then you must contact the admin on the contact page or in live chat to admin. And for enquires for any projects, you can join and register in a live chat with proper email and contact to admin@gmail.com

Web development http://notes4free.in/vtu-project.html
Computer Graphics design or cg project http://notes4free.in/vtu-project.html
DBMS project http://notes4free.in/vtu-project.html
final year project http://notes4free.in/vtu-project.html
Php project http://notes4free.in/vtu-project.html

BCA NOTES FOR ALL YEAR

notes4free provides bca notes and this are given to students studying under bca of all semester. We regularly add more bca notes and study materials choose the department and semester of the notes and click download to download the notes.

B.Com NOTES FOR ALL YEAR
notes4free provides B.Com notes and this are given to students studying under B.Com of all semester. We regularly add more B.Com notes and study materials choose the department and semester of the notes and click download to download the notes
http://notes4free.in/bcom-notes.html

M.Com NOTES FOR ALL BRANCHES | M.Com Specialisations

notes4free provides M.Com department notes and this are given to students studying under the new scheme and syllabus. We regularly add more SCHEME M.com department notes and study materials choose the department and semester of the notes and click download to download the notes. http://notes4free.in/mcom-notes.html

contact us
For any queries, please feel free to contact us, and if any student needs notes tell us and we’ll add notes to notes4free.
http://notes4free.in/contact.html

A collection of Open Source components to develop modules for COBI.Bike – the perfect fusion of smartphone and bike.

The quickest way to learn the DevKit basics without writing any code.

Change location coordinates and hit thumb controller buttons to see COBI.js in action. This simulates data and interaction events that will later be provided by the COBI.Bike system when riding a bike. Bonus points for directly tweaking the code e.g. subscribing to additional data from the COBI.js data stream.

It only takes a few lines of javascript to turn Web Apps into a module:

To get your Web App ready just add COBI.js at the end of the body section of your HTML:

<script src="https://cdn.cobi.bike/cobi.js/0.44.0/cobi.js"></script>

and pass an authentication token to the COBI.init function before subscribing to the data stream. Tokens are not issued yet, so you can use any string for now:

// Authenticate your module
COBI.init('token — can be anything right now')

It’s that easy: Any Web App + COBI.js = Module!

Enough with the boilerplate code, let’s make our new module respond to the handlebar remote control:

COBI.hub.externalInterfaceAction.subscribe(function(action) {
  console.log('I just tapped the handlebar remote and instantly received this ' + action + ' in my Web App');
});

or visualize the cadence acquired by COBI.Bike app from an external Bluetooth sensor or e-bike motor:

COBI.rideService.cadence.subscribe(function(cadence) {
    console.log('Your current cadence is ' + cadence + ' rpm.');
});

There is a ton of data available such as current speed, course, heart-rate (if heart-rate monitor is connected), power, calories burned and much more. Our COBI.js reference will be your friend.

Now that you have supercharged your Web App, you can test your module either in the Chrome browser on your machine or directly in the COBI.Bike iOS App on your bike.

Just install the DevKit Simulator Chrome Extension, open up the Developer Tools (⌘ + Option + i / Ctrl + Shift + j) and select the »COBI.Bike« tab.
To get the best experience, switch on the phone mode in the upper left corner and rotate the device to landscape. To simulate riding and fitness data you can play back one of our sample cobitrack or GPX files.

If you don’t own a COBI.Bike yet, apply for a hardware development kit at cobi.bike/devkit or purchase one at get.cobi.bike. Afterwards, register as a developer to test your module on your bike.

Ready? Then open up the COBI.Bike app on your iPhone and open the edit modules screen. As developer you can now choose from a number of examples modules or add you own via »My Module«

When you open »My Module« on the home screen or the dashboard, you can enter the URL of your module (it can be hosted wherever you want, but we have some suggestions below). When you press »Open module« your module is loaded and hooked up to the app. Now you can easily test your idea on your 🚲.

Take advantage of interfaces to the native COBI.Bike app to save yourself a lot of work.

COBI.navigationService.control.write({
  'action': 'START', 
  'destination': {'latitude': 50.110924,'longitude': 8.682127}
});

COBI.app.contact.read(function(contact) {
  console.log(contact);
});

COBI.app.textToSpeech.write({'content' : 'Can you hear my voice?', 'language' : 'en-US'});

COBI.app.clockVisible.write(false);

COBI.devkit.overrideThumbControllerMapping.write(true);

Check out the COBI.js reference for more.

A module can be shown in different contexts. There are three pieces of information that you should adapt to:

1. The device orientation — your module should automatically adapt to the available screen size
2. The value of COBI.parameters.context() — can be one of

• COBI.context.onRide
• COBI.context.offRide
• COBI.context.onRideSettings
• COBI.context.offRideSettings

3. The value of COBI.app.touchInteractionEnabled — changes when you start/stop riding

Take a look at our COBI.Bike DevKit UI Components for an easy way to create a UI for your settings.

There are 4 contexts you should support. You can check COBI.parameters.context() at any time to decide if some sort of settings should be shown (COBI.context.onRideSettings or COBI.context.offRideSettings) or if the actual module is requested (COBI.context.onRide or COBI.context.offRide). To share information between the two contexts and in between user sessions use the web standard Local Storage.

While riding, the user is encouraged to use the thumb controller instead of interacting with the UI via touch. Subscribe to changes of this value to make the best out of both situations. Please note that a bar is shown at the top while touchInteractionEnabled is false — make sure it is not overlapping with your UI.

COBI.app.touchInteractionEnabled.subscribe(function(enabled) {
    // Adapt your UI
});

• For seing javascript errors in the native App, activate the “Show module errors” option in the “Diagnostics” section
• To get better error messages when interacting with the COBI.js API, include https://cdn.cobi.bike/cobi.js/0.44.0/cobi.dev.js instead of the script mentioned above (please note: the dev version is considerably larger which has a big impact on the loading time)
• To show a native dialog when running inside the iOS App, just use a normal alert("your messages") (only for debugging)
• When developing in Chrome, use the phone button in the upper left corner of the Chrome Developer Tools and rotate it to landscape to see how it looks while riding
• When using the Chrome Simulator, press the Print state to console button to print the current COBI.js state to the Chrome Developer Tools Console
• To change the current context append ?context=onRide or your desired context to your URL in the browser.

• Get inspired by our showcases on the COBI.Bike DevKit site
• Take a testride with one of our example modules in the COBI.Bike iOS app. Requires registration as a developer on my.cobi.bike
• Visit our Showtime Developer Forum for additional inspiration from the developer community
• Check out our open source modules
  • News
  • Grid
  • Ping
  • Spotify

Read our Interface Guidelines to understand the unique challenges of developing software for bikes and to learn more about how the COBI.Bike system and modules work.

• FAQ
• Developer Forums
• COBI.Bike DevKit Chrome Extension on Chrome Web Store
• COBI.Bike DevKit Chrome Extension on Github
• COBI.Bike DevKit UI Components
• COBI.js reference

• Glitch – friendly community where you’ll build the app of your dreams
• CodePen – social development environment for front-end designers and developers

Anyone and everyone is welcome to contribute to this project, the DevKit Simulator and the COBI.Bike DevKit UI Components. Please take a moment to review the guidelines for contributing.

• Bug reports
• Feature requests
• Pull requests

Copyright © 2020 Robert Bosch GmbH

Warning The Cartographer upstream project is not actively developed anymore. As a consequence, this package has been archived. Check out the https://github.com/kadras-io/supply-chains package from the Kadras Engineering Platform as an alternative.

A Carvel package for Cartographer, a cloud-native framework to build paved paths to production on Kubernetes.

• Kubernetes 1.27+

• Carvel kctrl CLI.

• Carvel kapp-controller deployed in your Kubernetes cluster. You can install it with Carvel kapp (recommended choice) or kubectl.

  kapp deploy -a kapp-controller -y \
    -f https://github.com/carvel-dev/kapp-controller/releases/latest/download/release.yml

Cartographer requires cert-manager. You can install it from the Kadras package repository.

Add the Kadras package repository to your Kubernetes cluster:

kctrl package repository add -r kadras-packages \
  --url ghcr.io/kadras-io/kadras-packages \
  -n kadras-packages --create-namespace

kubectl create namespace kadras-packages
kapp deploy -a cartographer-package -n kadras-packages -y \
  -f https://github.com/kadras-io/package-for-cartographer/releases/latest/download/metadata.yml \
  -f https://github.com/kadras-io/package-for-cartographer/releases/latest/download/package.yml

Install the Cartographer package:

kctrl package install -i cartographer \
  -p cartographer.packages.kadras.io \
  -v ${VERSION} \
  -n kadras-packages

Note You can find the ${VERSION} value by retrieving the list of package versions available in the Kadras package repository installed on your cluster.

kctrl package available list -p cartographer.packages.kadras.io -n kadras-packages

Verify the installed packages and their status:

kctrl package installed list -n kadras-packages

Documentation, tutorials and examples for this package are available in the docs folder. For documentation specific to Cartographer, check out cartographer.sh.

The Cartographer package can be customized via a values.yml file.

cartographer:
  concurrency:
    max_workloads: 10
    max_deliveries: 10

Reference the values.yml file from the kctrl command when installing or upgrading the package.

kctrl package install -i cartographer \
  -p cartographer.packages.kadras.io \
  -v ${VERSION} \
  -n kadras-packages \
  --values-file values.yml

The Cartographer package has the following configurable properties.

The security process for reporting vulnerabilities is described in SECURITY.md.

This project is licensed under the Apache License 2.0. See LICENSE for more information.

This package is based on the original Cartographer package used in the Tanzu Community Edition project before its retirement.