Contributing packages¶
The staging process¶
This document presents an overview over how to contribute packages to conda-forge.
Getting Started¶
There are multiple ways to get started:
Look at the example recipe in the staged-recipes repository and modify it as necessary.
If it is an R package from CRAN, please instead start by using the conda-forge helper script for R recipes. Then if necessary you can make manual edits to the recipe.
If it is a python package, you can generate the recipe as a starting point with
grayskull pypi your_package_name
. To install it you can use conda install -c conda-forge grayskull. You do not have to use grayskull, and the recipes produced by grayskull will need to be reviewed and edited. In particular, you’ll at least need to check the build line to use pip, add yourself as a maintainer, and specify alicense_file
.
Your final recipe should have no comments (unless they’re actually relevant to the recipe, and not generic instruction comments), and follow the order in the example.
If there are details you are not sure about please open a pull request. The conda-forge team will be happy to answer your questions.
In case you are building your first recipe using conda-forge, a step-by-step instruction and checklist that might help you with a successful build is provided in the following.
Step-by-step Instructions¶
Ensure your source code can be downloaded as a single file. Source code should be downloadable as an archive (.tar.gz, .zip, .tar.bz2, .tar.xz) or tagged on GitHub, to ensure that it can be verified. (For further detail, see Build from tarballs, not repos).
Fork the example recipes repository.
Create a new branch from the staged-recipes
master
branch.Within your forked copy, generate a new folder in the recipes subdirectory and copy the meta.yml file from the example directory. Please leave the example directory unchanged!
Edit the copied recipe (meta.yml) as needed. For details, see The recipe meta.yaml.
Generate the SHA256 key for your source code archive, as described in the example recipe using the
openssl
tool. As an alternative, you can also go to the package description on PyPi from which you can directly copy the SHA256.Be sure to fill in the
test
section. The simplest test will simply test that the module can be imported, as described in the example.Remove all irrelevant comments in the
meta.yaml
file.
Tip
Be sure not to checksum the redirection page. Therefore use, for example,:
curl -sL https://github.com/username/reponame/archive/vX.X.X.tar.gz | openssl sha256
Checklist¶
Ensure that the license and license family descriptors (optional) have the right case and that the license is correct. Note that case sensitive inputs are required (e.g. Apache-2.0 rather than APACHE 2.0). Using SPDX identifiers for license field is recommended. (see SPDX Identifiers and Expressions)
Ensure that you have included a license file if your license requires one – most do. (see here)
In case your project has tests included, you need to decide if these tests should be executed while building the conda-forge feedstock.
Make sure that all tests pass successfully at least on your development machine.
Recommended: run the test locally on your source code to ensure the recipe works locally (see Running tests locally for staged recipes).
Make sure that your changes do not interfere with other recipes that are in the
recipes
folder (e.g. theexample
recipe).
Feedback and revision¶
Once you finished your PR, all you have to do is waiting for feedback from our reviewer team.
The reviewer team will assist you by pointing out improvements and answering questions. Once the package is ready, the reviewers will approve and merge your pull request.
After merging the PR, our infrastructure will build the package and make it available in the conda-channel.
Note
If you have questions or have not heard back for a while, you can notify us by including @conda-forge/staged-recipes
in your GitHub message.
Post staging process¶
After the PR is merged, our CI services will create a new git repo automatically. For example, the recipe for a package named
pydstool
will be moved to a new repository https://github.com/conda-forge/pydstool-feedstock.CI services will be enabled automatically and a build will be triggered automatically which will build the conda package and upload to https://anaconda.org/conda-forge
If this is your first contribution, you will be added to the conda-forge team and given access to the CI services so that you can stop and restart builds. You will also be given commit rights to the new git repository.
If you want to make a change to the recipe, send a PR to the git repository from a fork. Branches of the main repository are used for maintaining different versions only.
Maintainer role¶
The maintainer’s job is to:
Keep the feedstock updated by merging eventual maintenance PRs from conda-forge’s bots.
Keep the feedstock on par with new releases of the source package by
Bumping the version number and checksum.
Making sure that the feedstock’s requirements stay accurate.
Make sure the test requirements match those of the updated package.
Answer eventual questions about the package on the feedstock issue tracker.
Adding multiple packages at once¶
If you would like to add more than one related packages, they can be added to staged-recipes in a single pull request (in separate directories). If the packages are interdependent (i.e. one package being added lists one or more of the other packages being added as a requirement), the build script will be able to locate the dependencies that are only present within staged-recipes as long as the builds finish in the dependencies order. Using a single pull request allows you to quickly get packages set up without waiting for each package in a dependency chain to be reviewed, built, and added to the conda-forge channel before starting the process over with the next recipe in the chain.
Note
When PRs with multiple interdependent recipes are merged, there may be an error if a build finishes before its dependency is built. If this occurs, you can trigger a new build by pushing an empty commit.
git commit --amend --no-edit && git push --force
Synchronizing fork for future use¶
If you would like to add additional packages in the future, you will need to reset your fork of staged-recipes before creating a new branch on your fork, adding the new package directory/recipe, and creating a pull request. This step ensures you have the most recent version of the tools and configuration files contained in the staged-recipes repository and makes the pull request much easier to review. The following steps will reset your fork of staged-recipes and should be executed from within a clone of your forked staged-recipes directory.
Checkout your master branch:
git checkout master
Define the conda-forge/staged-recipes repository as “upstream” (if you have not already done so).:
git remote add upstream https://github.com/conda-forge/staged-recipes.git
Pull all of the upstream commits from the upstream master branch.:
git pull --rebase upstream master
Push all of the changes to your fork on GitHub (make sure there are not any changes on GitHub that you need because they will be overwritten).:
git push origin master --force
Once these steps are complete, you can continue with the steps in Step-by-step Instructions to stage your new package recipe using your existing staged-recipes fork.
The recipe meta.yaml¶
The meta.yaml
file in the recipe directory is at the heart of every conda package.
It defines everything that is required to build and use the package.
meta.yaml
is in yaml format, augmented with Jinja templating.
A full reference of the structure and fields of meta.yaml
file can be found in the Defining metadata (meta.yaml) section in the conda-build documentation.
In the following, we highlight particularly important and conda-forge specific information and guidelines, ordered by section in meta.yaml
.
Source¶
Build from tarballs, not repos¶
Packages should be built from tarballs using the url
key, not from repositories directly by using e.g. git_url
.
There are several reasons behind this rule:
Repositories are usually larger than tarballs, draining shared CI time and bandwidth
Repositories are not checksummed. Thus, using a tarball has a stronger guarantee that the download that is obtained to build from is in fact the intended package.
On some systems, it is possible to not have permission to remove a repo once it is created.
Populating the hash
field¶
If your package is on PyPi, you can get the sha256 hash from your package’s page
on PyPI; look for the SHA256
link next to the download link on your package’s
files page, e.g. https://pypi.org/project/<your-project>/#files
.
You can also generate a hash from the command line on Linux (and Mac if you install the necessary tools below).
To generate the sha256
hash: openssl sha256 your_sdist.tar.gz
You may need the openssl package, available on conda-forge
conda install openssl -c conda-forge
.
Tip
Be sure not to checksum the redirection page. Therefore use, for example,:
curl -sL https://github.com/username/reponame/archive/vX.X.X.tar.gz | openssl sha256
Downloading extra sources and data files¶
conda-build 3
supports multiple sources per recipe. Examples are available in the conda-build docs.
Build¶
Skipping builds¶
Use the skip
key in the build
section along with a selector:
You can e.g. specify not to build …
on specific architectures:
build: skip: true # [win]
for specific python versions:
build: skip: true # [py<35]
A full description of selectors is in the conda docs.
Optional: bld.bat
and/or build.sh
¶
In many cases, bld.bat
and/or build.sh
files are not required.
Pure Python packages almost never need them.
If the build can be executed with one line, you may put this line in the
script
entry of the build
section of the meta.yaml
file with:
script: "{{ PYTHON }} -m pip install . -vv"
.
Remember to always add pip
to the host requirements.
Use pip¶
Normally Python packages should use this line:
build:
script: "{{ PYTHON }} -m pip install . -vv"
as the installation script in the meta.yml
file or bld.bat/build.sh
script files,
while adding pip
to the host requirements:
requirements:
host:
- pip
These options should be used to ensure a clean installation of the package without its dependencies. This helps make sure that we’re only including this package, and not accidentally bringing any dependencies along into the conda package.
Usually pure-Python packages only require python
, setuptools
and pip
as host
requirements; the real package dependencies are only
run
requirements.
Requirements¶
Build, host and run¶
Conda-build distinguishes three different kinds of dependencies. In the following paragraphs, we give a very short overview what packages go where. For a detailed explanation please refer to the conda-build documentation.
Build
Build dependencies are required in the build environment and contain all tools that are not needed on the host of the package.
Following packages are examples of typical
build
dependencies:
compilers (see Compilers)
cmake
make
pkg-config
CDT packages (see Core Dependency Tree Packages (CDTs))
Host
Host dependencies are required during build phase, but in contrast to build packages they have to be present on the host.
Following packages are typical examples for
host
dependencies:
shared libraries (c/c++)
python/r libraries that link against c libraries (see e.g. Building Against NumPy)
python, r-base
setuptools, pip (see Use pip)
Run
Run dependencies are only required during run time of the package. Run dependencies typically include
most python/r libraries
Avoid external dependencies¶
As a general rule: all dependencies have to be packaged by conda-forge as well. This is necessary to assure ABI compatibility for all our packages.
There are only a few exceptions to this rule:
Some dependencies have to be satisfied with CDT packages (see Core Dependency Tree Packages (CDTs)).
Some packages require root access (e.g. device drivers) that cannot be distributed by conda-forge. These dependencies should be avoided whenever possible.
Pinning¶
Linking shared c/c++ libraries creates dependence on the ABI of the library that was used at build time on the package. The exposed interface changes when previously existing exposed symbols are deleted or modified in a newer version.
It is therefore crucial to ensure that only library versions with a compatible ABI are used after linking.
In the best case, the shared library you depend on:
defines a pin in the list of globally pinned packages
exports its ABI compatible requirements by defining
run_exports
in it’s meta.yaml
In these cases you do not have to worry about version requirements:
requirements:
# [...]
host:
- readline
- libpng
In other cases you have to specify ABI compatible versions manually.
requirements:
# [...]
host:
- libawesome 1.1.*
For more information on pinning, please refer to Pinned dependencies.
Constraining packages at runtime¶
The run_constrained
section allows defining restrictions on packages at runtime without depending on the package. It can be used to restrict allowed versions of optional dependencies and defining incompatible packages.
Defining non-dependency restrictions¶
Imagine a package can be used together with version 1 of awesome-software
when present, but does not strictly depend on it.
Therefore you would like to let the user choose whether he/she would like to use the package with or without awesome-software
. Let’s assume further that the package is incompatible to version 2 of awesome-software
.
In this case run_dependencies
can be used to restrict awesome-software
to version 1.*, if the user chooses to install it:
requirements:
# [...]
run_constrained:
- awesome-software 1.*
Here run_constrained
acts as a means to protect users from incompatible versions without introducing an unwanted dependency.
Defining conflicts¶
Sometimes packages interfere with each other and therefore only one of them can be installed at any time.
In combination with an unsatisfiable version, run_constrained
can define blockers:
package:
name: awesome-db
requirements:
# [...]
run_constrained:
- amazing-db ==9999999999
In this example, awesome-db
cannot be installed together with amazing-db
as there is no package amazing-db-9999999999
.
Test¶
All recipes need tests. Here are some tips, tricks, and justifications. How you should test depends on the type of package (python, c-lib, command-line tool, … ), and what tests are available for that package. But every conda package must have at least some tests.
Simple existence tests¶
Sometimes defining tests seems to be hard, e.g. due to:
tests for the underlying code base may not exist.
test suites may take too long to run on limited CI infrastructure.
tests may take too much bandwidth.
In these cases, conda-forge may not be able to execute the prescribed test suite.
However, this is no reason for the recipe to not have tests. At the very least, we want to verify that the package has installed the desired files in the desired locations. This is called existence testing.
Existence testing can be accomplished in the meta.yaml
file in the
test/commands
block.
On posix systems, use the test
utility and the $PREFIX
variable.
On Windows, use the exist
command. See below for an example.
Simple existence testing example:
test:
commands:
- test -f $PREFIX/lib/libboost_log$SHLIB_EXT # [unix]
- if not exist %LIBRARY_LIB%\\boost_log-vc140-mt.lib exit 1 # [win]
Testing python packages¶
For the best information about testing, see the conda build docs test section.
Testing importing¶
The minimal test of a python package should make sure that the package
can be successfully imported. This can be accomplished with this
stanza in the meta.yaml
:
test:
imports:
- package_name
Note that package_name
is the name imported by python;
not necessarily the name of the conda package (they are sometimes different).
Testing for an import will catch the bulk of the packaging errors, generally including the presence of dependencies. However, it does not assure that the package works correctly. In particular, it doesn’t test if it works correctly with the versions of dependencies used.
It is good to run some other tests of the code itself (the test suite) if possible.
Running unit tests¶
The trick here is that there are multiple ways to run unit tests in Python, including nose, pytest, etc.
Also, some packages install the tests with the package, and thus they can be run in place, while others keep the tests with the source code, and thus can not be run straight from an installed package.
Test requirements¶
Sometimes there are packages required to run the tests that are not required to simply use the package. This is usually a test-running framework, such as nose or pytest. You can ensure that it is included by adding it to requirements in the test stanza:
test:
imports:
- package_name
...
requires:
- pytest
Copying test files¶
Often test files are not installed alongside packages. Conda creates a fresh working copy to execute the test stage of build recipes, which don’t contain the files of source package.
You can include files required for testing with the source_files
section:
test:
imports:
- package_name
requires:
- pytest
source_files:
- tests
- test_pkg_integration.py
commands:
- pytest tests test_pkg_integration.py
The source_files
section works for files and directories.
Built-in tests¶
Some packages have testing built-in. In this case, you can put a test command directly in the test stanza:
test:
...
commands:
python -c "import package_name; package_name.tests.runall()"
Alternatively, you can add a file called run_test.py
in the recipe that
will be run at test time. This allows an arbitrarily complicated test script.
pytest tests¶
If the tests are installed with the package, pytest can find and run them for you with the following command:
test:
requires:
- pytest
commands:
- pytest --pyargs package_name
Command Line Utilities¶
If a python package installs command line utilities, you probably want to test that they were properly installed:
test:
commands:
- util_1 --help
If the utility actually has a test mode, great. Otherwise simply invoking
--help
or --version
or something will at least test that it is
installed and can run.
Tests outside of the package¶
Note that conda-build runs the tests in an isolated environment after installing the package – thus, at this point it does not have access to the original source tarball. This is to ensure that the test environment is as close as possible to what an end-user will see.
This makes it very hard to run tests that are not installed with the package.
Running tests locally for staged recipes¶
If you want to run and build packages in the staged-recipes repository locally,
go to the root repository directory and run the
.scripts/run_docker_build.sh
script. This requires that you have docker
installed on your machine.
You need to define an environment variable named CONFIG
. Its value must be
the name of one of the three YAML configuration files in the .ci_support
directory (either linux64
, osx64
, or win64
). As an example, you can
invoke the command as follows.
$ cd staged-recipes
$ CONFIG=linux64 ./.scripts/run_docker_build.sh
About¶
Packaging the license manually¶
Sometimes upstream maintainers do not include a license file in their tarball despite being demanded by the license.
If this is the case, you can add the license to the recipe
directory (here named LICENSE.txt
) and reference it inside the meta.yaml:
about:
license_file: LICENSE.txt
In this case, please also notify the upstream developers that the license file is missing.
Important
The license should only be shipped along with the recipe if there is no license file in the downloaded archive.
If there is a license file in the archive, please set license_file
to the path of the license file in the archive.
SPDX Identifiers and Expressions¶
For the about: license
entry in the recipe meta.yaml
, using a SPDX identifier or expression is recommended.
See SPDX license identifiers for the licenses. See SPDX license exceptions for license exceptions. See SPDX specification Appendix IV for the specification on expressions.
Apache-2.0
Apache-2.0 WITH LLVM-exception
BSD-3-Clause
BSD-3-Clause OR MIT
GPL-2.0-or-later
LGPL-2.0-only OR GPL-2.0-only
LicenseRef-HDF5
MIT
MIT AND BSD-2-Clause
PSF-2.0
Miscellaneous¶
Activate scripts¶
Recipes are allowed to have activate scripts, which will be source
d or
call
ed when the environment is activated. It is generally recommended to avoid using
activate scripts when another option is possible because people do not always
activate environments the expected way and these packages may then misbehave.
When using them in a recipe, feel free to name them activate.bat
,
activate.sh
, deactivate.bat
, and deactivate.sh
in the recipe. The
installed scripts are recommended to be prefixed by the package name and a
separating -
. Below is some sample code for Unix and Windows that will make
this install process easier. Please feel free to lift it.
In build.sh
:
# Copy the [de]activate scripts to $PREFIX/etc/conda/[de]activate.d.
# This will allow them to be run on environment activation.
for CHANGE in "activate" "deactivate"
do
mkdir -p "${PREFIX}/etc/conda/${CHANGE}.d"
cp "${RECIPE_DIR}/${CHANGE}.sh" "${PREFIX}/etc/conda/${CHANGE}.d/${PKG_NAME}_${CHANGE}.sh"
done
In build.bat
:
setlocal EnableDelayedExpansion
:: Copy the [de]activate scripts to %PREFIX%\etc\conda\[de]activate.d.
:: This will allow them to be run on environment activation.
for %%F in (activate deactivate) DO (
if not exist %PREFIX%\etc\conda\%%F.d mkdir %PREFIX%\etc\conda\%%F.d
copy %RECIPE_DIR%\%%F.bat %PREFIX%\etc\conda\%%F.d\%PKG_NAME%_%%F.bat
:: Copy unix shell activation scripts, needed by Windows Bash users
copy %RECIPE_DIR%\%%F.sh %PREFIX%\etc\conda\%%F.d\%PKG_NAME%_%%F.sh
)
Jinja templating¶
The recipe meta.yaml
can contain expressions that are evaluated during build time.
These expressions are written in Jinja syntax.
Jinja expressions serve following purposes in the meta.yaml:
They allow defining variables to avoid code duplication. Using a variable for the
version
allows changing the version only once with every update.{% set version = "3.7.3" %} [...] package: name: python version: {{ version }} source: url: https://www.python.org/ftp/python/{{ version }}/Python-{{ version }}.tar.xz sha256: da60b54064d4cfcd9c26576f6df2690e62085123826cff2e667e72a91952d318
They can call conda-build functions for automatic code generation. Examples are the compilers, cdt packages or the
pin_compatible
function.requirements: build: - {{ compiler('c') }} - {{ compiler('cxx') }} - {{ cdt('xorg-x11-proto-devel') }} # [linux] - {{ cdt('libx11-devel') }} # [linux]
or
requirements: build: - {{ compiler('c') }} - {{ compiler('cxx') }} host: - python - numpy run: - python - {{ pin_compatible('numpy') }}
For more information please refer to the Templating with Jinja section in the conda-build docs.


1-day Advanced React Training
April 28th, 2018. 1 Fore St Ave, London EC2Y 9DT
On completion of the 1-day React training each student will:
- Understand functional programming applied to React
- Be able to write tests for complex React applications
- Comprehend the best performance practices in React
- Understand the best patterns for building reusable UIs & functionality in React
Curriculum
-
Functional programming concepts applied to React
- Data and behaviour
- Data in, data out
- Composition
-
Advanced React patterns: Reuse functionality across components
- Higher-Order Components (HOCs)
- Declarative composition using the Render Props (AKA function as children)
-
Advanced React patterns II: Create more reusable components
- Compound Components, dynamically flow data between components
- Patterns and use cases using "context"
-
Advanced testing in React
-
Performance and Rendering Optimizations (quantified with numbers)


The New Design Kids
Menu
Home
Aboust us
Contact us
Services
Favorites
Alerts
Messages
Comments
Analytics
Reading List
Close Menu
Open Menu
Home
About Us
Contact Us
Services
THE NEW DESIGN KIDS ON THE BLOCK
THINK.CREATE.DESIGN
LAUNCH
Services
Clound Access
Secure Setup
Customer Care
24hr Service
Happy Clients
“These guys are not only dedicated but also talented. I would work with them
again in a heartbeat"
Contact Us On:


This is an attempt to provide a Slick mobile interface for National Rail that doesn't suck and serves you quick.
Done purely as a hobby project and is not affiliated to National Rail.
Code is entirely open source too. Check it out
Suggestions? Email me
Close


torchfunc¶
torchfunc is PyTorch oriented library with a goal to help you with:
Improving and analysing performance of your neural network
Record/analyse internal state of
torch.nn.Module
as data passes through itDo the above based on external conditions (using single
Callable
to specify it)Day-to-day neural network related duties (model size, seeding, performance measurements etc.)
Get information about your host operating system, CUDA devices and others
See related projects for other helpful libraries revolving around PyTorch.
Installation¶
Following installation methods are available:
pip:¶
To install latest release:
pip install --user torchfunc
To install nightly
version:
pip install --user torchfunc-nightly
Docker:¶
Various torchfunc
images are available both CPU and GPU-enabled.
You can find them in Docker Cloud at szymonmaszke/torchfunc
CPU¶
CPU image is based on ubuntu:18.04 and official release can be pulled with:
docker pull szymonmaszke/torchfunc:18.04
For nightly
release:
docker pull szymonmaszke/torchfunc:nightly_18.04
This image is significantly lighter due to lack of GPU support.
GPU¶
All images are based on nvidia/cuda Docker image.
Each has corresponding CUDA version tag ( 10.1
, 10
and 9.2
) CUDNN7 support
and base image ( ubuntu:18.04 ).
Following images are available:
10.1-cudnn7-runtime-ubuntu18.04
10.1-runtime-ubuntu18.04
10.0-cudnn7-runtime-ubuntu18.04
10.0-runtime-ubuntu18.04
9.2-cudnn7-runtime-ubuntu18.04
9.2-runtime-ubuntu18.04
Example pull:
docker pull szymonmaszke/torchfunc:10.1-cudnn7-runtime-ubuntu18.04
You can use nightly
builds as well, just prefix the tag with nightly_
, for example
like this:
docker pull szymonmaszke/torchfunc:nightly_10.1-cudnn7-runtime-ubuntu18.04


- getBugfixVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginApiVersion
-
Returns the bugfix version of this api (backward-compatible, no functions modified).
- getBugfixVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Returns the bugfix version of this
IPlugin
.
- getConsole() - Method in interface thobe.logfileviewer.plugin.api.IPluginAccess
-
Returns the Console
-plugin.
- getData() - Method in interface thobe.logfileviewer.plugin.source.logline.ILogLine
-
Returns the data.
- getId() - Method in interface thobe.logfileviewer.plugin.source.logline.ILogLine
-
- getLineFilter() - Method in interface thobe.logfileviewer.plugin.source.logstream.ILogStreamDataListener
-
This method should return a Pattern
.
- getLogstream() - Method in interface thobe.logfileviewer.plugin.api.IPlugin
-
Returns a reference to the currently open LogStream
.
- getLogStreamListenerName() - Method in interface thobe.logfileviewer.plugin.source.logstream.ILogStreamListener
-
- getLSRequesterName() - Method in interface thobe.logfileviewer.plugin.source.logstream.ILogStreamRequester
-
Returns the name of the requester.
- getMajorVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginApiVersion
-
Returns the major version of this api (NOT backward-compatible, e.g.
- getMajorVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Returns the major version of this
IPlugin
.
- getMemory() - Method in interface thobe.logfileviewer.plugin.memory.IMemoryWatchable
-
Should return the memory obtained/allocated by this
IMemoryWatchable
(in bytes).
- getMemory() - Method in interface thobe.logfileviewer.plugin.source.logline.ILogLine
-
- getMinorVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginApiVersion
-
Returns the minor version of this api (backward-compatible, e.g.
- getMinorVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Returns the minor version of this
IPlugin
.
- getNameOfDataListener() - Method in interface thobe.logfileviewer.plugin.source.logstream.ILogStreamDataListener
-
Returns the name of this listener.
- getNameOfMemoryWatchable() - Method in interface thobe.logfileviewer.plugin.memory.IMemoryWatchable
-
- getPlugin(String) - Method in interface thobe.logfileviewer.plugin.api.IPluginAccess
-
Returns the Plugin
with the given name or null if no such Plugin
is available.
- getPluginApiVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Should return the version of the plugin-api that was used for this
IPlugin
.
- getPluginAuthor() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Should return the author of this plugin or null if none is available.
- getPluginAuthorEMailAddress() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Should return the email address of the plugins author or null if none is available.
- getPluginDescription() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
This method should return a short description of this
IPlugin
- getPluginLicense() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Should return the license that applies to this plugin or null if none is available.
- getPluginName() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
This method should return the name of this
IPlugin
.
- getPluginPreferences() - Method in interface thobe.logfileviewer.plugin.api.IPlugin
-
- getPlugins() - Method in interface thobe.logfileviewer.plugin.api.IPluginAccess
-
Returns all
Plugin
currently registered (Map
).
- getPluginsNotAttachedToGui() - Method in interface thobe.logfileviewer.plugin.api.IPluginAccess
-
Returns a set containing all
IPluginUI
s that are not already attached to the gui.
- getPluginVersion() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
- getPluginWebsite() - Method in interface thobe.logfileviewer.plugin.api.IPluginBase
-
Should return the website where the plugin is hosted at or null if none is available.
- getPluginWindowManagerAccess() - Method in interface thobe.logfileviewer.plugin.api.IPluginUI
-
Retrieve access to the window-management for the
IPlugin
s.
- getTimeStamp() - Method in interface thobe.logfileviewer.plugin.source.logline.ILogLine
-
- getTimeStampStr() - Method in interface thobe.logfileviewer.plugin.source.logline.ILogLine
-
- getTitle() - Method in interface thobe.logfileviewer.plugin.api.IPluginUIComponent
-
Returns the string that should be presented in the title-line of the
IPluginUIComponent
window/frame.
- getTooltip() - Method in interface thobe.logfileviewer.plugin.api.IPluginUIComponent
-
- getUIComponent() - Method in interface thobe.logfileviewer.plugin.api.IPluginUI
-
Returns the visual-component of this
IPluginUI
, which can be attached to a gui-component/ container.
- getVisualComponent() - Method in interface thobe.logfileviewer.plugin.api.IPluginUIComponent
-
This method should return the JComponent
that should be visible/ displayed in the gui.


6633
Towering Oak Path ● Columbia, MD 21044 ●
<EMAIL_ADDRESS>●<PHONE_NUMBER>
Security Clearance Obtained September 2012
University of Maryland at College Park, A. James Clark Engineering School College Park, MD
B.S., Electrical Engineering Expected May 2014
Berman & Bazell Palo Alto, CA
Co-Founder & Programmer May
2013 – Sept 2013
● Provided software consulting services to small and medium sized companies in the SF Bay area
US Naval Research Laboratory Washington, DC
Electrical Engineering Intern May
2012 – Jan 2013
● Prototyped and developed algorithms to detect, identify and characterize objects of interest in extremely large 3D data files
● Implemented detection, identification and characterization algorithms in C++ using Point Cloud Library
● Worked on a variety of imaging & optics projects
Johns Hopkins University Applied Physics Laboratory Laurel, MD
Software Engineer – Air & Missile Defense
Department Sept
2008 – Jan 2010
● Built software utilizing NASA World Wind for the US Navy to track fleet locations and perform operational calculations
● Conducted independent research on artificial intelligence, specifically regarding genetic algorithms
Robotics at Maryland College
Park, MD
Electronics & Software Team Member Sept 2013 – present
● Rewrote the sensor API for the updated ROS-based 2014 competition robot
● Designed and programmed circuits to process sensor inputs using PIC microcontrollers
Institute of Electrical and Electronics Engineers College
Park, MD
Webmaster & Executive Board Member Oct 2011 – July 2013
● Developed and redesigned the IEEE student branch website including the addition of new features for more intuitive use
● Participated in planning of extracurricular engineering events sponsored by IEEE
University of Maryland Senate College
Park, MD
Programs, Curricula & Courses Member Sept 2012 – May 2013
● Attended monthly meetings to vote on changes or additions to programs offered by the university
Head Start Columbia,
MD
Volunteer Assistant Teacher June 2010 – Aug 2010
● Helped students in mathematics, writing, and creative learning
● Managed the children during recreational activity time
University of Maryland - Intro to Engineering Design College
Park, MD
Hovercraft Group Leader Aug 2009 – Dec 2009
● Coordinated team efforts to develop all necessary systems of the hovercraft
● Choose to work with a camera rather than standard light sensors as all previous teams had done
● IEEE Student Activity Conference – April 2012. Attended presentations and participate in electronics competitions
● IEEE Smart Tech Workshop – Nov 2012. Participated in the Smart Grid and Power Systems tracks of the conference
● IEEE Outstanding Student Award – 2011-2012 University of Maryland Student Chapter Award
●
Programming: Python, Go, C++, C, Javascript,
MATLAB, SQL, PHP
●
Interests: Passionate about music, technology, sports,
and culture


Since there is an even number of values, we take the mean of the two values in the middle, which are 5 and 6. Hence the median is \(\frac{5+6}{2}=5.5\text{.}\) Notice that half of the values are less than the median and half are greater.


Presented by Dr. Cassandre Alvarado and Jonathan Garza
Sharing information gathered through the predictive model and other institutional data is critical for leadership at all levels to make informed decisions to best help stdents. An online Student Programs Database (SPD) was built by SSI to provide the college, school, and unit directors and managers of student programs with a tool to quickly access and share data about their students accross campus. This relational database offers program directors the ability to assign first-year students to success program using the data like the predicted 4-year graduate rate to identify the students most likely to need additional support.


A classless CSS framework with a navbar and dark styling for around 10.46 kB.
Use it by pasting the following into your
<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kimeiga/bahunya/dist/bahunya.min.css">
Now write your web app with semantic html elements and watch it look pretty right out of the box, no css classes needed!
See the project on Github~The ultimate goal of Bahunya is to be a CSS "framework" that can provide almost everything you really need for a web app or website without introducing any new CSS classes at all.
I observed that many of the most common UI elements in websites can be wholly described by semantic HTML elements rather than `<div>`'s with classes. What's more is that most CSS frameworks tend to style these elements very similarly. So why not remove the classes altogether and use semantic html elements (`<nav>`, `<main>`, etc), which can help improve accessiblity for screen readers, and also make the website source easier to read and write for developers.
That's the north star of this project: to get as far as possible toward that goal without introducing classes (this will mean Bahunya might not have a grid system or other things where classes needed). If you have ideas on more things to add without classes, feel free to contribute!
Example:

Bahunya
test
markdown

What about a navbar with nested lists?

Text

Headings

Paragraphs

Blockquotes

...

Embedded content

Images

Audio

Video

...

Form elements

Input fields

Select menus

Checkboxes

...

As you can see, the navbar works whether you use a unordered list with sub-unordered-lists
(

's with

's) or if you just put the
's right
under the main
. Both work, although I think the latter option might be better for screen
readers.


Figmagic promotes a structured way of assembling design systems. Following the primary principle of atomic design, Figmagic wants you to build from the bottom up, beginning with decomposing the tokens. Tokens shape elements, which form components, that are ordered in compositions, which get presented in views... You know the drill, though I am switching Brad Frost's nomenclature into something more front-end friendly.
When it comes to code generation, Figmagic tries to do this in a better way. Instead of over-eagerly promoting hardcoded code generation from huge and complex components, Figmagic tries to competently, or at least "mostly-right", handle automation for things that should not be too context-dependent or manual input-heavy. Code should also be as close to "normal" as possible—meaning that generated code binds values to tokens and not some random px values as other platforms do. All of this can happen because Figmagic assumes a way of working that respects standard CSS and HTML: no magic trickery! Figmagic avoids some of the cognitive and technical overhead by introducing a concept called Elements, which are Figmagic-compliant components that can be output into code. By composing larger components out of simple Elements, code generation is made much more manageable while also promoting much more structured design.
Figmagic does not aim at completely removing designers or developers: It just aims to move them closer, while eliminating any of the tedious busywork that has grown around front-end development.
Please note: Figmagic requires that your document structure is identical to what I show in the template at https://www.figma.com/community/file/821094451476848226/Figmagic-%E2%80%94-Design-System-for-Tokens.
Figmagic is compiled from Typescript to ES6, so you should have Node 10 or later for it to work on your machine.
Built initially as an internal handoff tool for Humblebee.
An example project—using React, Styled Components and Storybook—is available at https://github.com/mikaelvesavuori/figmagic-example.
Note that this demo is not meant to fully style and do all of the things in the Figma document. I wanted to straddle a middle-of-the-road solution where I did the least work possible to get it working with React and style only a few of the most obvious and helpful elements, like setting disabled state on the button and checkbox.
Figmagic Example Demo: On the left is a big Figma component assembled of a number of "Elements", Figmagic-compliant components that can be output into code. On the right is the React-composed version of those after just a few minutes of coding and closing elements correctly.
Run npm install -g figmagic
or yarn global add figmagic
.
Local usage is possible by installing Figmagic as a developer dependency (under devDependencies
) with npm install figmagic -D
or yarn add figmagic -D
, then using a script pointing to the local version, like so:
"scripts": {
"figmagic": "npx figmagic"
}
figmagic.json
or .figmagicrc
)Figmagic can be run without any configuration. You will always need to specify your Figma API token and Figma document ID, though! However, it's highly recommended to add a configuration: it's easy and gives you a ton of possibilities to optimize for your own needs.
Run figmagic init
to initialize a basic configuration file, either named figmagic.json
or .figmagicrc
file. As long as you provide your Figma token and document ID/URL, the new generated file is ready to use for Element Sync which can only be done if your configuration points to valid code generation templates (which the generated one does). You'll see that the config will point templates.templatePath{Graphic|React|Styled|Storybook}
to ./node_modules/figmagic/templates/{graphic|react|styled|story}
. Read more under the Configuration file section.
First of all, get your Figma API token and Figma URL:
Copy Link
—the first, long junk-looking bit is the ID.Pass in your Figma API token and Figma URL by either:
.env
file with your own file ID (i.e. similar to<PHONE_NUMBER>76848226
) or full Figma URL (i.e. similar to https://www.figma.com/file/821094451476848226/Figmagic-%E2%80%94-Design-System-template-4.0
) and API token key.figmagic --token {TOKEN} --url {URL}
(substitute curly braces for your actual values)figmagic.json
/.figmagicrc
under token
and url
. This is discouraged since you will display these values in clear text and you probably don't want that.Then:
figmagic
/.figmagic
) and a folder with tokens (default: /tokens
) in the rootWhen running figmagic
, files will be moved with the Node module trash (multi-platform) into your OS's trash can. Thus, you can recover anything unintentionally overwritten.
Folder names below follow their default naming. The naming is possible to change via configuration.
.figmagic
will contain the extracted JSON retrieved from Figma's APItokens
will contain the token fileselements
will contain the generated codegraphics
will contain graphicsFor a more complete description of the code structure, see the Code structure section.
Go to https://www.figma.com/community/file/821094451476848226/Figmagic-%E2%80%94-Design-System-for-Tokens and make your own copy. Go at it by using the document ID as the FIGMA_URL or start copying in your own work.
Your structure needs to correspond to the following:
Design tokens
. Without this page you can't really do much with Figmagic.Design tokens
page, frames need to exist. You can have any number of supported token frame. For starters, name them Colors
, Font sizes
, Font families
, Font weights
, Line heights
, and Spacing
– exact casing is not important, however the spelling is important! For a full list of token types, see the types of design tokens Figmagic can extract.See a template design system at https://www.figma.com/community/file/821094451476848226/Figmagic-%E2%80%94-Design-System-template-4.0. Feel free to simply copy-paste it or base your own work around it.
Note: Refer to the document structure in the image below and in the template linked above.
How a Figmagic project could be structured in regards to tokens, if you want to support all currently available token types.
Design tokens are the abstract but shared elements from which your design system is built.
Design tokens express any of the individual values that you build from, such as colors, spacing, and typographic features.
Tokens offer a form of “contract” between a designer’s intent and its fulfillment by developers. This means that both sides agree to avoid by all means anything that’s not codified also as a token. For example, avoiding spacing values that are not also available as a token. It’s similar in many ways to old-school styleguides, but tokens should only ever communicate strict, hard values. Styleguides can tend to be context-sensitive and full of explanation—tokens must communicate without context or explanation.
However: You may still want to add written guidance for usage. It’s just that the tokens should be able to be consumed without understanding anything specific about them.
You should bind tokens to Figma styles whenever and wherever possible to simplify your own design work, but make sure that those are also represented in the Tokens page, as this page is where a developer will pick up tokens with Figmagic.
You can currently extract design tokens for:
A typical use-case for the generated documents is to feed the extracted values into CSS systems that support external values (such as Styled Components, Emotion, Styled System, any other CSS-in-JS libraries, or maybe even Sass).
Figma styles became publicly available in June 2018 and are incredibly valuable for designers to create single-sources-of-truth when it comes to design values (tokens). When using Figmagic though, the thinking and usage is a bit different from how Figma styles work.
A Figma style is multidimensional: It contains any number of properties wrapped into one style, acting as kind of a package. This is handy in a design environment and is practical from a user standpoint. The user doesn't have to think too hard about storing "redundant" values that are the same in another component, such as N number of units for line height: They are all taken care of.
Figmagic instead expresses tokens as instances of every individual value, thus being unidimensional – meaning they store only one value per item. Examples could be sets of line heights, font weights, or font sizes, each one individually specified. What this entails for they developer and designer, is that values can be used and mixed as pleased in any number of contexts, not becoming bound to one specific context such as a certain kind of heading. For a developer this is good because we would rather just map out the definitive values for something, onto a component (a "context" so to speak).
Because of this difference, the appropriate way to structure a Figmagic-compatible Figma design document is to display one or more items/tokens in the respective frames that correspond to the accepted token types (line height, font size...) where each item has only one key property that's changed in-between them (such as one text using size 48, the next using size 40...), since those items are what Figmagic loops through when creating your code tokens.
One of the major deviations from this principle is "Fonts" where you can specify more properties than one. However, then those need to individually match other typographical tokens you might have, such as line heights.
The "Heading L" font token is composed of values that are also represented in the "lesser" uni-dimensional tokens: displayed here are "Line Height S" (135% line height), "H1" (size 48), and "Font Bold" (Bold font style). Setting this font as a Figma Style will make your life as a designer much easier as your apply the text style to things. Auto-generating code with Figmagic will also work just fine, since the individual values are respected.
Whatever suits you! As long as you remember that what Figmagic fetches are those single (unidimensional) values from each design item/token it should all work. I've seen that Figma styles make the "contract" between tokens and their day-to-day workflow with designers a lot easier. Again though, Figmagic does not use those values; think of them as a convenient glue.
By default this is turned on. You will need to have a page named "Design tokens", where your tokens lay within named frames.
Tokens are the "bread and butter" of Figmagic. Without tokens, Figmagic cannot create elements. And even without elements, tokens provide the core experience to help you run a competent design system with code.
In case you want to skip generating tokens for a given frame, you can just add a leading underscore to the frame name. You can also skip individual items by naming them ignore
or adding a leading underscore.
This is activated by default, but it's now possible to deactivate it if you have very specific reasons to do so.
By default this is turned off. Pass in --syncGraphics
as a flag to sync them or enable that in your configuration file. You will need to have a page named "Graphics", where your components lay directly on the artboard.
Graphics can be exported in multiple formats with Figmagic. Instead of doing manual hand-overs, just tell your developer(s) that there have been updates to the graphics and let them pull the latest versions from your Figma document.
Again, please look at the template at https://www.figma.com/community/file/821094451476848226/Figmagic-%E2%80%94-Design-System-for-Tokens for reference.
This is also turned off by default. Pass in --syncElements
or enable it in your configuration file to generate code from your Figma components.
Upcoming versions of Figmagic may attempt to support Figma Variants, but that will have to be publicly released first, and then vetted against what Figmagic can generate before I commit to supporting that model. Until then, the existing mental model of "Elements" will continue to be used.
Elements are named so because they are primarily meant to help scaffold anything that maps to standard HTML elements like input, button, h1, and form. With scaffolding we mean that these elements can be generated as code in a shape that is fitting for continued development. Elements are a good entry-point both for design and for code generation, since they are relatively simple and as a concept map to HTML, which in turn is based on tags ("elements").
Elements are generated by parsing your structured Figma components into either "flat" or "nested" varieties. Any values, say a height of 48px and a specific blue color, will try to be derived from your relevant tokens. Therefore, without tokens, elements cannot be generated! In this example, maybe the height will map to a spacing token that uses 48px (mapping to 3rem
where 3 x 16 = 48, with 16 being the root REM value) and the color might be mapped to a color in your color tokens.
If you need more information and guidance on this, see the dedicated documentation section at Figmagic Element Sync.
There are several ways in which you can provide Figmagic with knowledge about how you want it to parse your tokens. You can combine them, but beware of the below prioritization chart (from lowest to highest):
figmagic.json
/.figmagicrc
file.env
file using dotenv
)If possible, stick to one way of providing settings.
Non-provided values will fall back to defaults outlined in bin/entities/Config/baseConfig.ts
.
figmagic.json
or .figmagicrc
)You can use a JSON-formated configuration file at the root of a project to use its settings. Figmagic will pick up the path by assessing the current working directory and looking for either a figmagic.json
or .figmagicrc
file there. If it finds it, it will use it.
An example file is provided in Figmagic—you can find it in the root of the project. The file is named figmagicrc
, just add the leading dot and place the file in your own project folder to use it. To use it as JSON, add json
as the file ending.
Since this is a configuration file, you'll need to be careful to write it correctly or you may end up with failures and errors.
Below is a complete set of what you can configure, together with the defaults.
{
"debugMode": false,
"fontUnit": "rem",
"letterSpacingUnit": "em",
"lineHeightUnit": "unitless",
"opacitiesUnit": "float",
"figmaData": "figma.json",
"figmagicFolder": ".figmagic",
"outputFolderElements": "elements",
"outputFolderGraphics": "graphics",
"outputFolderTokens": "tokens",
"outputFormatCss": "ts",
"outputFormatDescription": "md",
"outputFormatElements": "tsx",
"outputFormatGraphics": "svg",
"outputFormatStorybook": "js",
"outputFormatTokens": "ts",
"outputGraphicElements": false,
"outputGraphicElementsMap": false,
"outputScaleGraphics": 1,
"outputDataTypeToken": null,
"overwrite": {
"css": false,
"description": false,
"graphic": false,
"react": false,
"storybook": false,
"styled": false
},
"recompileLocal": false,
"remSize": 16,
"skipFileGeneration": {
"forceUpdate": true,
"skipCss": false,
"skipDescription": false,
"skipReact": false,
"skipStorybook": false,
"skipStyled": false
},
"spacingUnit": "rem",
"syncElements": false,
"syncGraphics": false,
"syncTokens": true,
"templates": {
"templatePathGraphic": "templates/graphic",
"templatePathReact": "templates/react",
"templatePathStorybook": "templates/story",
"templatePathStyled": "templates/styled"
},
"token": "",
"unitlessPrecision": 2,
"url": "",
"usePostscriptFontNames": false,
"versionName": null
};
Run these in your command line environment of choice.
figmagic [--debug | -d]
Default is false
.
figmagic [--fontUnit | -fu] [rem|em|px]
Default is rem
.
figmagic [--letterSpacingUnit | -lsu] [em|px]
Default is em
.
figmagic [--lineHeightUnit | -lhu] [unitless|em|px|rem]
Default is unitless
.
figmagic [--opacitiesUnit | -ou] [float|percent]
Default is float
.
figmagic [--figmaData | -file] [filename]
Default is figma.json
.
figmagic [--figmagicFolder | -base] [folder]
Default is .figmagic
.
figmagic [--outputFolderElements | -elements] [folder]
Default is elements
.
figmagic [--outputFolderGraphics | -graphics] [folder]
Default is graphics
.
figmagic [--outputFolderTokens | -tokens] [folder]
Default is tokens
.
figmagic [--outputFormatCss | -fc] [ts|mjs|js]
Default is ts
.
figmagic [--outputFormatDesc | -fd] [md|txt]
Default is md
.
figmagic [--outputFormatElements | -fe] [tsx|jsx|mjs|js]
Default is tsx
.
figmagic [--outputFormatGraphics | -fg] [svg|png]
Default is svg
.
figmagic [--outputFormatStorybook | -fs] [ts|js|mdx]
Default is js
.
figmagic [--outputFormatTokens | -ft] [ts|mjs|js|json]
Default is ts
.
figmagic [--outputGraphicElements | -oge]
Default is false
.
figmagic [--outputGraphicElementsMap | -ogm]
Default is false
.
figmagic [--outputScaleGraphics | -scale] [number]
Default is 1
. Note that from the CLI you must specify the scale size like 3x
(or anything at the end, as long as it includes letter at the end). This only applies to CLI configuration, and does not apply to other types of config, such as through figmagic.json
or .figmagicrc
.
figmagic [--outputDataTypeToken | -tokentype] [null | enum]
Default is null
. Currently the only valid non-null value is enum
.
This is not currently possible to adjust from the CLI.
figmagic [--recompileLocal | -local]
Default is null
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
figmagic [--remSize | -rem] [number]
Default is 16
. Note that from the CLI you must specify the REM size like 16p
(or anything at the end, as long as it includes letter at the end). This only applies to CLI configuration, and does not apply to other types of config, such as through figmagic.json
or .figmagicrc
.
figmagic [--forceUpdate | -force]
Default is true
. Forces all elements and file types to be regenerated.
figmagic [--skipCss | -nocss]
Default is false
. Skip creating CSS file when syncing elements.
figmagic [--skipDescription | -nodesc]
Default is false
. Skip creating Markdown file when syncing elements.
figmagic [--skipReact | -noreact]
Default is false
. Skip creating React file when syncing elements.
figmagic [--skipStorybook | -nostory]
Default is false
. Skip creating Storybook file when syncing elements.
figmagic [--skipStyled | -nostyled]
Default is false
. Skip creating Styled Components file when syncing elements.
figmagic [--spacingUnit | -s] [rem|em|px]
Default is rem
.
figmagic [--syncElements | -se]
Default is false
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
Use this when you want to sync elements in your "Elements" page in Figma.
figmagic [--syncGraphics | -sg]
Default is false
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
Use this when you want to sync graphics in your "Graphics" page in Figma. Use the RC configuration file to pass in options. Default format will be SVG.
figmagic [--syncTokens | -st]
Default is true
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
Use this when you want to sync tokens in your "Design tokens" page in Figma. Use the RC configuration file to pass in options.
figmagic [--templatePathGraphic | -tpgraphic] [path]
Default is templates/graphic
.
Your local figmagic.json
or .figmagicrc
file must have a block with templates.templatePathGraphic
that specifies a valid path, such as ./node_modules/figmagic/templates/graphic
.
figmagic [--templatePathReact | -tpreact] [path]
Default is templates/react
.
Your local figmagic.json
or .figmagicrc
file must have a block with templates.templatePathReact
that specifies a valid path, such as ./node_modules/figmagic/templates/react
.
figmagic [--templatePathStorybook | -tpstory] [path]
Default is templates/story
.
Your local figmagic.json
or .figmagicrc
file must have a block with templates.templatePathStory
that specifies a valid path, such as ./node_modules/figmagic/templates/story
.
figmagic [--templatePathStyled | -tpstyled] [path]
Default is templates/styled
.
Your local figmagic.json
or .figmagicrc
file must have a block with templates.templatePathStyled
that specifies a valid path, such as ./node_modules/figmagic/templates/styled
.
figmagic [--token | -t] [token]
Default is null
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
figmagic [--tokensRelativeImportPrefix | -tip] [path]
Default is ''
(effectively just blank or the same folder). Use this so CSS files can import tokens from the correct location, for example to resolve something like ../../tokens/colors.ts
you would pass in ../../
and tokens
would be whatever your outputFolderTokens
value is.
figmagic [--url | -u] [url_id]
Default is null
, and will then be taken from local .env
file if not explicitly passed in through the CLI.
figmagic [--unitlessPrecision | -up] [number]
Defines the precision (decimals) for unitless values (rounded using .toFixed()
internally). Default is 2
.
figmagic [--usePostscriptFontNames | -ps]
Default is false
, i.e. common name.
figmagic [--versionName | -v]
Default is null
which will resolve to the latest version. The value you specify here is the name of the version in the Figma file's Version history.
Starting with Figmagic version 4.0, four types of generated files have customizable templates:
These four types have support for a variety of formats that differ a bit between each type.
Figmagic comes with a set of templates for several file formats. In case you want to customize these, you should respect and keep any substitution tags that exist in the original files; removing them may cause your templates to function incorrectly. For example, the React template includes a substitution tag called {{NAME_STYLED}}
which will be changed to your adjusted element name with a "Styled" suffix. Removing it would make your generated code useless as-is.
The recommended way of adding and using your own templates would be to copy-paste any/all existing templates from Figmagic into your project, pointing the configuration file to your local copies, and then modifying them as needed.
The font family name, either as its common name (as picked up by Figma; spaces are removed) or its Postscript name (eg. FiraSans-Regular).
Default: Common name.
Note: In previous versions of Figmagic the Postscript font family name was used.
Typical font weight values like 200
, 300
etc.
Units based on global font size (base 16px).
Default: rem
units. Can be set to rem
or em
.
Unitless.
2 decimals numbered values by default. Precision can be configured with unitlessPrecision
(see config)
RGBA colors.
Default: rem
units. Can be set to rem
or em
.
Default: px
units.
Default: em
units.
Default: px
units.
Typical 2 decimals numbered values between 0 and 1 like 0
or 0.65
.
Can be set to percent
to have them converted to %
strings instead like 0%
or 65%
.
Default: px
units.
Default: px
units for three values (horizontal offset, vertical offset, blur) and RGBA for the color.
Default: numbers (whole numbers, i.e. integers).
__tests__/
: Tests, structured similarly to the bin
folder source code.github/
: GitHub files for CI and issue template.vscode/
: Visual Studio Code configurationbin/
: Source codebin/contracts
: Types and interfacesbin/controllers
: Controllersbin/entities
: Entities (DDD-style), this is where most of the logic will be containedbin/frameworks
: Non-domain functionality, like string manipulation and downloading files etc.bin/usecases
: Where the application "features" are orchestrated, as per Clean Architecturebuild/
: ES6-compiled code (this is the code that consumers of the Figmagic binary actually use)readme/
: Documentation, mostly images and screen shotstemplates/
: Files that are used as templates for code generationtestdata/
: Most of the tests point to stored test data which is stored in this folderindex.ts
: The file that initializes and sets up everything required to run FigmagicYou are welcome to contribute to the project! Pull requests, as well as issues or plain messages, work fine. For pull requests, please refer to the contribution guidelines in CONTRIBUTING.md
.
Generated using TypeDoc


Hearty Hearth Pizza Oven has been serving up the best Pizza and authentic Italian cuisine for years. Our recipes have been passed down from generation to generation . Our mission is to serve you authentic Italian pizza no matter your location
Whether you're looking for vegetarian treat, chicken treat or meaty treat, your search ends Hearty Hearth pizaa Oven.We provide Outside Catering, Delivery, Dine-In, Take Out, Lunch, Dinner, Online Ordering. Our goal is to provide you with the best Italian Pizza with all the convenience of a local pizza restaurant. We’re open late with a large wine and beer selection so stop by soon for a night out!


Account Login
Remember me
Forgot the password?
x
Use email to get your password
New User?Click to sign up


Compile result of scala projects with Scapegoat plugin
Reasons for Compilation Failure
- Scala version is 2.10, which is not supported by Scapegoat
- Project is too large, and recording all patterns causes JVM GarbageCollection over limit
- Can't resolve buildinfo, which, I don't know why
- sbt build failed
- Compile error with Scapegoat plugin attached, but sbt compile always succeed. Maybe there are some bug in Scapegoat plugin.
How to add Scapegoat plugin
Write following code to project/plugins.sbt ----addSbtPlugin("com.sksamuel.scapegoat" %% "sbt-scapegoat" % "1.0.0")
Results
Success
- adamw_macwire 56s
- AsyncttpClient-async...
- daniel-trinh_scalariform
- p2t2_figaro 122s(done, with some bugs)
- dickwall_subcut 13s(done)
- dispatch_reboot 25s(done, with some bugs, should clean before running scapegoat)
- dylemma_scala-frp 13s(done)
- etaty_rediscala 50s(compile failed, wtf)
- fehmicansaglam_tepkin 54s(compile error, with some bugs)
- finagle_finch 80s (done, found nothing)
- maxcellent_lamma 24s (done, found nothing)
- mesosphere_chaos 45s (done, found something)
- ngocdaothanhnetcatymaster 4s
- nafgreactivev0.4.0 98s(found an actual bug(well...seems not a bug))
- novussalat_master 29s(found some bugs)
- ReactiveMongoReactiveMongomaster 58s(find some bugs)
- ReactiveXRxScala0.x 32s(lots of recursion false positives)
- romainreuillonmgomaster 98s(find some bugs)
- SandroGrzicicScalaBuffmaster 28s(found some bugs)
- scalaasyncmaster 33s(still some false positives) [Path] : E:\Scala\Codes\scalaasyncmaster\async-master\src\main\scala\scala\async\internal\Lifter.scala:29: [Desc] : Unused pattern matching variable not solved
- scalapickling0.10.x 104s
[Path] : scalapickling0.10.x.pickling-0.10.x.core.src.main.scala.scala.pickling.util.Externalizables.scala:41:
[Desc] : lots of unused variables
[Path] : E:\Scala\Codes\scalapickling0.10.x\pickling-0.10.x\benchmark\GeoTrellis.scala:22:
[Desc] : Variable scala.pickling.internal.
package
.cachedMirror is null in If block - scalascala-parser-combinatorsmaster 27s (some bugs, false positive eliminated)
- sirthiasscala-sshmaster 23s(found a false positive)
- sksamuelelastic4smaster 105s(found one bug)
- squerylsquerylmaster 74s
- stephenmcdcuriodbmaster 162s, most time on compiling java sources
- xitrum-frameworkscala-xgettextmaster 4s(only one file)
- xitrum-frameworkscaposermaster 12s
- twitterfinatramaster 510s, most used on resolving
- unfilteredunfiltered0.9.0 122s, some Compilation failed
Failed:
- eed3si9n_scalaxb----multiple compile error
- aselab-scala-activerecord----multiple compile error
- dispatch_reboot----can't resolve BuildInfo
- BIDData_BIDMach
- eardouglas_xsbt-web-plugin----can't compile due to changing version from 2.10 to 2.11
- etorreborre_specs2----unknown compile error(some .scala could be compiled but some not)
- factorie_factorie----outOfMemoryError
- FasterXML_jackson-module-scala-master----null pointer error due to invalid path (jackson-module-scala-master\target\scala-2.11/scapegoat-report])
- fwbrasil_activate----cannot resolve org.scala.reflections
- garyKeorkunian_squants----cannot change scala version to 2.11
- intel-hadoop_gearpump----overhead limit exceed ->outOfMemoryError
- json4s_json4s----96s, compilation failed halfway
- julien-truffaut_Monocle----66s, compilation failed halfway
- lift-framework----278s, compilation failed halfway
- lihaoyi_scala-js-fiddle ----36s, compilation error halfway
- intel-hadoop_gearpump ----overhead limit exceed ->outOfMemoryError when compiling
- ISCPIF_openmole----unknown error
- jaliss_securesocial----loading definitions takes too long
- Jetbrains_sbt-ide-settings----cannot change scala version to 2.11
- jrudolph_sbt-dependency-graph----version 2.10
- js-scalajs-scala----cannot resolve dependency : EPFL#lms2.11;0.3-SNAPSHOT: not found
- lihaoyi_scalatags----unknown error, sbt failed
- mauricio_postgresql-async----plugin not loaded ?
- milessabin_shapeless----compile error
- mohivaplay-silhouettemaster
- monifumonifumaster----compile error
- pocorallscaloidmaster----null pointer error
- propensiverapturedev----sbt build failed
- puffnfreshwartremoverlatest-release----sbt build failed
- rickynilsscalacheckmaster----use scala version 2.10
- romainreuillongridscalemaster----out of memory
- scalanlpbreezemaster ----takes too long
- scalatrascalatra2.4.x----numerous compile error
- scaldiscaldimaster----
- scalikejdbcscalikejdbcmaster----scala version 2.10
- scodecscodecmaster----53s, compile error
- sirthiasparboiled2master----version 2.10
- skinny-frameworkskinny-frameworkmaster----version 2.10
- spraysbt-revolvermaster----type error in expression
- t2vplay2-authmaster----94s, compilation failed
- storm-enroutereactive-collectionsmaster----too many compile errors
- takezoegitbucketmaster----compile error
- tpolecatdoobiemaster----compile error, missing buildinfo.scala
- twittercassovarymaster----Compilation failed
- w3cbanana-rdf0.8.x---- java.lang.OutOfMemoryError: GC overhead limit exceeded
- websudosphantomdevelop----sbt resolution failed
- xitrum-frameworkglokkamaster----Compilation error
- xitrum-frameworkscalivemaster----Compilation error


Home
Stats
web builder
Statistics
As of 11/27/2022 11:11PM
14
Git SDK Releases
14260
OS Downloads
162897
SDK Downloads
177157
Total Downloads
Components
NAME
Type
Last Updated
LonScript
Language
2020-08-23
Lonero OS
Operating System
2020-02-09
Lonero (LNR)
Cryptocurrency
2020-12-14
Decentralized Internet
Development Kit
2022-11-27
SHARE THIS PAGE!
SHARE THIS PAGE!


TubeD
Download any available youtube audio/video.
Success
Successfully downloaded the video.
Convert
Video
Audio
Error
Couldnt download this video.
Members only
mins
Video Description


---
subject: The first step in achieving your miracle
---
{{>header}}
Hi, welcome to the Rythmia Tribe!
I wanted to congratulate you for making the first step in achieving your miracle.
I also want to let you be aware that I use email quite often to keep our community up to date in regards to different events happening at Rythmia, and sharing inspiring information.
Here's what you can expect from being part of this community:
Now here's all I ask of you... be open... surrender and enjoy the ride!
As we start sending you the information, we want to make sure we have your permission. Click the link below to confirm your email address...
Clicking the link above will confirm your email address and allow you to receive the information you requested. If you do not want to receive any communication, please ignore this message.
Warm Regards,
P.S. If you haven't already called us at +1<PHONE_NUMBER> to get more information on the center, and you subscribed to this list, you should. It's the best investment you can make in yourself and your Miracle awaits. You can get it now.
Gerard A Powell
www.rythmialifeadvancement.com


{{post.date | date: "%B %d, %Y" }}
{{post.title}}
{{post.excerpt}}
--- layout: default section_id: home title: Robin Scheibler fields: - icon: microphone title: Audio Array Processing desc: High performance algorithms leveraging structural properties of audio signals in reverberant environments. - icon: cogs title: Theory and Algorithms desc: I apply techniques from information theory and theoretical computer science to derive low-complexity algorithms for signal processing. - icon: flask title: Open and Citizen Science desc: Reproducible computations, DIY devices, and citizen measurements of radiation and Arsenic in water. ---
{{ site.tldr_bio | markdownify }}
A quick tour of some projects representative of my research interests.
Some random ramblings mostly related to building physical prototypes and tinkering with various things.


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 42. PL/Python - Python Procedural Language | Next |
PL/Python supports both the Python 2 and Python 3 language variants. (The PostgreSQL installation instructions might contain more precise information about the exact supported minor versions of Python.) Because the Python 2 and Python 3 language variants are incompatible in some important aspects, the following naming and transitioning scheme is used by PL/Python to avoid mixing them:
The PostgreSQL language named plpython2u implements PL/Python based on the Python 2 language variant.
The PostgreSQL language named plpython3u implements PL/Python based on the Python 3 language variant.
The language named plpythonu implements PL/Python based on the default Python language variant, which is currently Python 2. (This default is independent of what any local Python installations might consider to be their "default", for example, what /usr/bin/python might be.) The default will probably be changed to Python 3 in a distant future release of PostgreSQL, depending on the progress of the migration to Python 3 in the Python community.
It depends on the build configuration or the installed packages whether PL/Python for Python 2 or Python 3 or both are available.
Tip: The built variant depends on which Python version was found during the installation or which version was explicitly set using the PYTHON environment variable; see Section 15.5. To make both variants of PL/Python available in one installation, the source tree has to be configured and built twice.
This results in the following usage and migration strategy:
Existing users and users who are currently not interested in Python 3 use the language name plpythonu and don't have to change anything for the foreseeable future. It is recommended to gradually "future-proof" the code via migration to Python 2.6/2.7 to simplify the eventual migration to Python 3.
In practice, many PL/Python functions will migrate to Python 3 with few or no changes.
Users who know that they have heavily Python 2 dependent code and don't plan to ever change it can make use of the plpython2u language name. This will continue to work into the very distant future, until Python 2 support might be completely dropped by PostgreSQL.
Users who want to dive into Python 3 can use the plpython3u language name, which will keep working forever by today's standards. In the distant future, when Python 3 might become the default, they might like to remove the "3" for aesthetic reasons.
Daredevils, who want to build a Python-3-only operating system environment, can change the build scripts to make plpythonu be equivalent to plpython3u, keeping in mind that this would make their installation incompatible with most of the rest of the world.
See also the document What's New In Python 3.0 for more information about porting to Python 3.
It is not allowed to use PL/Python based on Python 2 and PL/Python based on Python 3 in the same session, because the symbols in the dynamic modules would clash, which could result in crashes of the PostgreSQL server process. There is a check that prevents mixing Python major versions in a session, which will abort the session if a mismatch is detected. It is possible, however, to use both PL/Python variants in the same database, from separate sessions.


--- layout: home title: Welcome! subtitle: Weiwei's personal website ---
Hello! My name is Weiwei Liu and I am a Data Scientist/Machine Learning Developer in Canada.
I’ve spent seven years in civil engineering design and consulting services, and proudly designed a dozen of projects. I wrangled with various kinds of data, performed numerical simulation and hypothesis analysis, and solved complex engineering problems with optimization techniques.
Now, with further education in data science, I work in more broad industries applying data analysis and machine learning techniques. My projects range from app review sentiment analysis using NLP tools, cherry detection with OpenCV and Yolo, to anomaly detection in embeded system log using deep learning.
If you want to contact me you can email me or find me in LinkedIn.


Running a Static Analysis in Creo Simulate
Hello, this is Mark Taddonio from learningconnector.ptc.com.
and this tutorial is running a Static Analysis in Creo Simulate
The first step is to open a file.
So am gonna click on open and select test.part
Now am going to..
Once it is done, I am going to move to the second step.
The second step is to streach the beam.
So am going to force and moment tools.
Now am going apply load to this part.
Now am going to reorient my beam. Again am going to force and moment tools.
Am going to select force to -8000N.
Now am going to click on analysis and studies button.
Now am going to click on this button to view result of my design study.
As expected the middle of my beam is what displaced the most and in the right hand corner you can see the maximum displacement.
Now I want to see it as graph so am going to click this button and select the display type as graph.
Now the results of graph are no surprise either.
Well I hope you found this tutorial helpful. This is Mark Taddonio from learningconnector.ptc.com .


Relay: Drone Command Center
List
Job Info Search
WRKNo :
Result
Customer Name :
This is a popbox test.
Hover here
to see how it works.


Tracking user's quiz score
Total Score:
0
QUESTION: Lorem ipsum dolor sit amet, consectetur adipisicing elit?
Option #1
Option #2
Option #3
Option #4
Incorrect
Correct


| I l@ve RuBoard |
10.2 The anydbm ModuleThe anydbm module provides a unified interface to the simple database drivers supported by Python. The first time it is imported, the anydbm module looks for a suitable database driver, testing for dbhash, gdbm, dbm, or dumbdbm, in that order. If no such module is found, it raises an ImportError exception. In Example 10-1, the open function is used to open or create a database, using the chosen database handler. Example 10-1. Using the anydbm ModuleFile: anydbm-example-1.py import anydbm db = anydbm.open("database", "c") db["1"] = "one" db["2"] = "two" db["3"] = "three" db.close() db = anydbm.open("database", "r") for key in db.keys(): print repr(key), repr(db[key]) '2' 'two' '3' 'three' '1' 'one' |
| I l@ve RuBoard |


Mauricio Pochettino sacked by Tottenham Hotspur
Mauricio Pochettino leaves trophyless after five years in the job, during which he transformed Tottenham Hotspur into a title contender in the Premier League and the Champions League.
by APLess than six months after leading Tottenham Hotspur to the Champions League final, Mauricio Pochettino has been fired by the English club after its poor start to the Premier League season.
Tottenham chairman Daniel Levy said the board was “extremely reluctant” to take the decision but was doing so “in the club’s best interests.”
Pochettino leaves after five years in the job, during which he transformed the London club into a title contender in the Premier League and the Champions League but never managed to win a trophy.
Tottenham is currently 14th in the league having only won three of 12 games this campaign. The team has won just six games in the Premier League since February.
During that period, Pochettino guided Spurs into the Champions League final for the first time, where they lost to Liverpool.
“It is not a decision the board has taken lightly, nor in haste,” Levy said. “Regrettably domestic results at the end of last season and beginning of this season have been extremely disappointing.”
“It falls to the board to make the difficult decisions, this one made more so given the many memorable moments we have had with Mauricio and his coaching staff, but we do so in the club’s best interests.”
Former Tottenham and England striker Gary Lineker said Pochettino had “helped the club to punch massively above their weight for years.”
“Good luck with finding a better replacement,” Lineker tweeted, “…ain’t gonna happen.”


{% include meta.html %}
{% include nav.html %}
Big Data and Scala Blog
By David Virgil Naranjo
{{ content }} {% include analytics.html %}


Toggle navigation
Perfect Match
More
(current)
Contuct
(current)
Activity
Appointment
Communication
Online Dating
Certificate
Sign up
Log out
Perfect Match
Find Your SoulMate Online!!
Get started!


How to ask a good question
Tuesday, November 11th, 2014
For this week's cultural blog, I decided to write about how to ask a good questions. Asking questions are important in learning and there are some important ways and things to keep in mind when asking anyone, including your peers, teachers or the retail employee at some business. Asking good questions are vital to good communication adn benefit all parties involved.
If you break it down, good questions are clear and concise to the reader. Every good questions has a clear title, context and problem statement. By clear, I mean that it's obvious what you are asking and it's clear to the person you are asking. The golden rule is to imagine yourself as the person receiving the questions. Do they have all the information they need to asnwer the question? Is the right question even being asked? These are important things to consider when asking questions.
When asking a question through email, the first thing people notice are the spelling and grammar mistakes. These will easily distract the person answering the question and leave a bad impression that may lead the person elsewhere or unintereseted in responding. Make sure you take the time to think about the question, phrase it correctly with proper grammar and spelling.
The context of a questions is very important. What language (if it's programming), how can I recreate the problem? What other circumstantial details are pertinent for the question to be answered. In terms of web developing it may be important to mention the technologies being used, the things you've tried up to this point. These are things that you need to include in order to get the question answered effectively without wasting the time of the person being asked.
Overall, the golden rule is to put yourself in the shoes of the person being asked and not make any assumptions about what the receiver knows. Also make sure you have a clear and concise context and problem statement. If these things are provided then you are well on your way to asking a good question.


Hello! I am a Second Year Computer Science Co-op Student at Ryerson University in Toronto, Ontario,
Canada. I am currently looking for Summer 2020 Opportunities
My Projects:
Visit My GitHub
To see more of my projects please feel free to check out my GitHub page.


Basic Demo
Getting Started
Create your first interactive grid by copy-pasting the HTML+JS, as seen below...
Code
npm install gridstack
then in html:
 <link href="../dist/gridstack.min.css" rel="stylesheet"/>

...and that's it! Drag, drop, and resize to your heart's content. Looking for more complex examples? Check out the advanced example below, the links in the nav bar, or our docs in GitHub
Advanced Demo
...and many, many others.
Does your company use gridstack.js? We'd love to add your logo!
Come join our


Control with Non-Pharmaceutical interventions¶
pyross.control.control_integration¶
-
class
pyross.control.
control_integration
¶ Integrator class to implement control through changing the contact matrix as a function of the current state.
-
simulate_deteministic : Performs a deterministic simulation.
-
simulate_deterministic
()¶ Performs detemrinistic numerical integration
- Parameters
y0 (np.array) – Inital state of the system.
events (list) – List of events that the current state can satisfy to change behaviour of the contact matrix. contactMatricies
contactMatricies (list of python functions) – New contact matrix after the corresponding event occurs
Tf (float) – End time for integrator.
Nf (Int) – Number of time points to evaluate at.
Ti (float, optional) – Start time for integrator. The default is 0.
seedRate (python function, optional) – Seeding of infectives. The default is None.
events_repeat (bool, optional) – Wheither events is periodic in time. The default is false.
events_subsequent (bool, optional) – TODO
- Returns
y_eval (np.array(len(t), len(y0))) – Numerical integration solution.
t_eval (np.array) – Corresponding times at which X is evaluated at.
event_out (list) – List of events that occured during the run.
-
pyross.control.SIR¶
-
class
pyross.control.
SIR
¶ Susceptible, Infected, Removed (SIR) Ia: asymptomatic Is: symptomatic
…
-
parameters
¶ - Contains the following keys:
- alpha: float, np.array (M,)
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- Type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(3*M, )
-
simulate
()¶
-
pyross.control.SEkIkIkR¶
-
class
pyross.control.
SEkIkIkR
¶ Susceptible, Exposed, Infected, Removed (SEIR) method of k-stages of Ia, Is, E See: Lloyd, Theoretical Population Biology 60, 5971 (2001), doi:10.1006tpbi.2001.1525. .. attribute:: parameters
- Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic infected individuals.
- gIs: float
rate of removal from symptomatic infected individuals.
- gE: float
rate of removal from exposed individuals.
- kI: int
number of stages of asymptomatic infectives.
- kI: int
number of stages of symptomatic infectives.
- kE: int
number of stages of exposed.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(M, )
-
simulate
()¶
-
E
()¶ - Parameters
data (data files) –
- Returns
‘E’
- Return type
Exposed population time series
-
Ia
()¶ - Parameters
data (data files) –
- Returns
‘Is’
- Return type
symptomatics population time series
-
Is
()¶ - Parameters
data (data files) –
- Returns
‘Is’
- Return type
symptomatics population time series
-
R
()¶ - Parameters
data (data files) –
- Returns
‘R’
- Return type
Removed population time series
-
S
()¶ - Parameters
data (data files) –
- Returns
‘S’
- Return type
Susceptible population time series
pyross.control.SIRS¶
-
class
pyross.control.
SIRS
¶ Susceptible, Infected, Removed, Susceptible (SIRS) Ia: asymptomatic Is: symptomatic .. attribute:: parameters
- Contains the following keys:
- alpha: float, np.array (M,)
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- epfloat
fraction of removed who become susceptable again
- safloat, np.array (M,)
daily arrival of new susceptables
- iaa: float, np.array (M,)
daily arrival of new asymptomatics
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(4*M, )
-
simulate
()¶
pyross.control.SEIR¶
-
class
pyross.control.
SEIR
¶ Susceptible, Exposed, Infected, Removed (SEIR) Ia: asymptomatic Is: symptomatic .. attribute:: parameters
- Contains the following keys:
- alpha: float, np.array (M,)
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- gE: float
rate of removal from exposed individuals.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(4*M, )
-
simulate
()¶
pyross.control.SEI5R¶
-
class
pyross.control.
SEI5R
¶ Susceptible, Exposed, Infected, Removed (SEIR) The infected class has 5 groups: * Ia: asymptomatic * Is: symptomatic * Ih: hospitalized * Ic: ICU * Im: Mortality
S —> E E —> Ia, Is Ia —> R Is —> Ih, R Ih —> Ic, R Ic —> Im, R
-
parameters
¶ - Contains the following keys:
- alpha: float, np.array (M,)
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gE: float
rate of removal from exposeds individuals.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- gIh: float
rate of removal for hospitalised individuals.
- gIc: float
rate of removal for idividuals in intensive care.
- fsa: float
fraction by which symptomatic individuals self isolate.
- fhfloat
fraction by which hospitalised individuals are isolated.
- sa: float, np.array (M,)
daily arrival of new susceptables. sa is rate of additional/removal of population by birth etc
- hh: float, np.array (M,)
fraction hospitalised from Is
- cc: float, np.array (M,)
fraction sent to intensive care from hospitalised.
- mm: float, np.array (M,)
mortality rate in intensive care
- Type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(8*M, )
-
simulate
()¶
-
pyross.control.SIkR¶
-
class
pyross.control.
SIkR
¶ Susceptible, Infected, Removed (SIkR) method of k-stages of I .. attribute:: parameters
- Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gI: float
rate of removal from infectives.
- kI: int
number of stages of infection.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array((kI + 1)*M, )
-
simulate
()¶
pyross.control.SEkIkR¶
-
class
pyross.control.
SEkIkR
¶ Susceptible, Infected, Removed (SIkR) method of k-stages of I See: Lloyd, Theoretical Population Biology 60, 5971 (2001), doi:10.1006tpbi.2001.1525. .. attribute:: parameters
- Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gI: float
rate of removal from infected individuals.
- gE: float
rate of removal from exposed individuals.
- ki: int
number of stages of infectives.
- ke: int
number of stages of exposed.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array((kI = kE +1)*M, )
-
simulate
()¶
pyross.control.SEAIR¶
-
class
pyross.control.
SEAIR
¶ Susceptible, Exposed, Asymptomatic and infected, Infected, Removed (SEAIR) Ia: asymptomatic Is: symptomatic A: Asymptomatic and infectious .. attribute:: parameters
- Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- gE: float
rate of removal from exposeds individuals.
- gA: float
rate of removal from activated individuals.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(5*M, )
-
simulate
()¶
pyross.control.SEAI5R¶
-
class
pyross.control.
SEAI5R
¶ Susceptible, Exposed, Activates, Infected, Removed (SEAIR) The infected class has 5 groups: * Ia: asymptomatic * Is: symptomatic * Ih: hospitalized * Ic: ICU * Im: Mortality
S —> E E —> Ia, Is Ia —> R Is —> Ih, R Ih —> Ic, R Ic —> Im, R .. attribute:: parameters
- Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- gE: float
rate of removal from exposeds individuals.
- gA: float
rate of removal from activated individuals.
- gIh: float
rate of hospitalisation of infected individuals.
- gIc: float
rate hospitalised individuals are moved to intensive care.
- type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(9*M, )
-
simulate
()¶
pyross.control.SEAIRQ¶
-
class
pyross.control.
SEAIRQ
¶ Susceptible, Exposed, Asymptomatic and infected, Infected, Removed, Quarantined (SEAIRQ) Ia: asymptomatic Is: symptomatic A: Asymptomatic and infectious
-
parameters
¶ - Contains the following keys:
- alpha: float
fraction of infected who are asymptomatic.
- beta: float
rate of spread of infection.
- gIa: float
rate of removal from asymptomatic individuals.
- gIs: float
rate of removal from symptomatic individuals.
- gE: float
rate of removal from exposed individuals.
- gA: float
rate of removal from activated individuals.
- fsa: float
fraction by which symptomatic individuals self isolate.
- tEfloat
testing rate and contact tracing of exposeds
- tAfloat
testing rate and contact tracing of activateds
- tIa: float
testing rate and contact tracing of asymptomatics
- tIs: float
testing rate and contact tracing of symptomatics
- Type
dict
-
M
¶ Number of compartments of individual for each class. I.e len(contactMatrix)
- Type
int
-
Ni
¶ Initial number in each compartment and class
- Type
np.array(6*M, )
-
simulate
()¶
-


| Home | Libraries | People | FAQ | More |
Copyright © 2006 , 2007, 2008, 2009 John Maddock, Paul A. Bristow, Hubert Holin, Xiaogang Zhang, Bruno Lalande, Johan Råde, Gautam Sewani and Thijs van den Berg
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Table of Contents
ISBN 0-9504833-2-X 978-0-9504833-2-0, Classification 519.2-dc22
This manual is also available in printer friendly PDF format.
Last revised: October 16, 2009 at 09:52:32 GMT |


{{ template "html_head" }}
{{ template "navbar" }}
Handcrafted blog
Written in
Go language
as a self-learning exercise
{{ range entries}}
{{.Title}}
{{.Preview}}
Posted on {{.Time.Month}} {{.Time.Day}} , {{.Time.Year}} (
)
{{ end }}
{{ template "footer" }}