Library for accessing CumulusCI for the local git project
This library allows Robot Framework tests to access credentials to a Salesforce org created by CumulusCI, including Scratch Orgs. It also exposes the core logic of CumulusCI including interactions with the Salesforce API's and project specific configuration including custom and customized tasks and flows.
Initialization requires a single argument, the org name for the target CumulusCI org. If running your tests via cci's robot task (recommended), you can initialize the library in your tests taking advantage of the variable set by the robot task:
*** Settings ***
Library cumulusci.robotframework.CumulusCI ${ORG}
| Keyword | Arguments | Documentation | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Debug | Pauses execution and enters the Python debugger. |
|||||||||||||
| Get Community Info | community_name, key=None, force_refresh=False | This keyword uses the Salesforce API to get information about a community. This keyword requires the exact community name as its first argumment.
Some of the supported keys include name, siteUrl, and loginUrl. For a comprehensive list see the API documentation, or call this keyword without the key argument and examine the results. An API call will be made the first time this keyword is used, and the return values will be cached. Subsequent calls will not call the API unless the requested community name is not in the cached results, or unless the force_refresh parameter is set to True. |
||||||||||||
| Get Namespace Prefix | package=None | Returns the namespace prefix (including __) for the specified package name. (Defaults to project__package__name_managed from the current project config.) Returns an empty string if the package is not installed as a managed package. |
||||||||||||
| Get Org Info | Returns a dictionary of the org information for the current target Salesforce org |
|||||||||||||
| Login Url | org=None | Returns the login url which will automatically log into the target Salesforce org. By default, the org_name passed to the library constructor is used but this can be overridden with the org option to log into a different org. |
||||||||||||
| Run Task | task_name, **options | Runs a named CumulusCI task for the current project with optional support for overriding task options via kwargs. Examples:
|
||||||||||||
| Run Task Class | class_path, **options | Runs a CumulusCI task class with task options via kwargs. Use this keyword to run logic from CumulusCI tasks which have not been configured in the project's cumulusci.yml file. This is most useful in cases where a test needs to use task logic for logic unique to the test and thus not worth making into a named task for the project Examples:
|
||||||||||||
| Set Login Url | Sets the LOGIN_URL variable in the suite scope which will automatically log into the target Salesforce org. Typically, this is run during Suite Setup |
|||||||||||||
| Set Project Config | project_config |
Keyword library for importing and using page objects
When importing, you can include one or more paths to python files that define page objects. For example, if you have a set of classes in robot/HEDA/resources/PageObjects.py, you can import this library into a test case like this:
Library cumulusci.robotframework.PageObjects ... robot/HEDA/resources/PageObjects.py
Page object classes need to use the @pageobject decorator from cumulusci.robotframework.pageobjects. The decorator takes two parameters: page_type and object_name. Both are arbitrary strings, but together should uniquely identify a collection of keywords for a page or objects on a page.
Examples of page_type are Listing, Home, Detail, etc. Object types can be actual object types (Contact), custom object (Custom_object__c) or a logical name for a type of page (eg: AppointmentManager).
Example:
from cumulusci.robotframework.pageobjects import BasePage from cumulusci.robotframework.pageobjects import pageobject ... @pageobject(page_type="Detail", object_name="Custom__c") class CustomDetailPage(BasePage): ...
| Keyword | Arguments | Documentation |
|---|---|---|
| Current Page Should Be | *args, **kwargs | Verifies that the page appears to be the requested page If the page matches the given page object or contains the given page object, the keyword will pass.a When this keyword is called, it will try to get the page object for the given page_tyope and object_name, and call the method `_is_current_page`. Custom page objects may define this function in whatever manner is necessary to determine that the current page is or contains the given page object. The only requirement is that this function raise an exception if it determines the current page either doesn't represent the page object or doesn't contain the page object. The default implementation of the function uses the page URL and compares it to a pattern based off of the page_type and object_name. |
| Get Page Object | page_type, object_name | Return an instance of a page object This is useful if you want to call a single page object method from some other keyword without having to go to another page or load the page object into a page. This works a lot like robot's built-in "get library instance" keyword, but you can specify the page object by page type and object name rather than the library name, and it will autoload the appropriate library (assuming its module has been imported). |
| Go To Page | *args, **kwargs | Go to the page of the given page object. The URL will be computed from the page_type and object_name associated with the object, plus possibly additional arguments. Different pages support different additional arguments. For example, a Listing page supports the keyword argument `filter_name`, and a Detail page can be given an object id, or parameters for looking up the object id. If this keyword is able to navigate to a page, the keyword `load page object` will automatically be called to load the keywords for the page. Custom page objects may define the function `_go_to_page`, which will be passed in all of the keyword arguments from this keyword. This allows each page object to define its own URL mapping using whatever algorithm it chooses. The only requirement of the function is that it should compute an appropriate url and then call `self.selenium.go_to` with the URL. It is also recommended that the keyword wait until it knows that the page has finished rendering before returning (eg: by calling `self.salesforce.wait_until_loading_is_complete()`) |
| Load Page Object | page_type, object_name=None | Load the keywords for the page object identified by the type and object name The page type / object name pair must have been registered using the cumulusci.robotframework.pageobject decorator. |
| Log Page Object Keywords | Logs page objects and their keywords for all page objects which have been imported into the current suite. |
|
| Wait For Modal | *args, **kwargs | Wait for the given page object modal to appear. This will both wait for the modal, and verify that the modal has an expected heading. By default the expected heading will be the page object type (eg "New") and object name (eg: "Contact") separated by a space (eg: "New Contact"). You can override the expected heading with the expected_heading parameter. Example: Wait for modal to appear New Contact |
| Wait For Page Object | *args, **kwargs | Wait for an element represented by a page object to appear on the page. The associated page object will be loaded after the element appears. page_type represents the page type (Home, Details, etc)) and object_name represents the name of an object (Contact, Organization, etc) |
A keyword library for working with Salesforce Lightning pages
While you can import this directly into any suite, the recommended way to include this in a test suite is to import the Salesforce.robot
resource file.
| Keyword | Arguments | Documentation |
|---|---|---|
| Breakpoint | Serves as a breakpoint for the robot debugger Note: this keyword is a no-op unless the debug option for the task has been set to True. Unless the option has been set, this keyword will have no effect on a running test. |
|
| Click Header Field Link | label | Clicks a link in record header. |
| Click Modal Button | title | Clicks a button in a Lightning modal. |
| Click Object Button | title | Clicks a button in an object's actions. |
| Click Related Item Link | *args, **kwargs | Clicks a link in the related list with the specified heading. This keyword will automatically call Wait until loading is complete. |
| Click Related Item Popup Link | heading, title, link | Clicks a link in the popup menu for a related list item. heading specifies the name of the list, title specifies the name of the item, and link specifies the name of the link |
| Click Related List Button | heading, button_title | Clicks a button in the heading of a related list. Waits for a modal to open after clicking the button. |
| Close Modal | Closes the open modal |
|
| Create Webdriver With Retry | *args, **kwargs | Call the Create Webdriver keyword. Retry on connection resets which can happen if custom domain propagation is slow. |
| Current App Should Be | app_name | Validates the currently selected Salesforce App |
| Delete Session Records | Deletes records that were created while running this test case. (Only records specifically recorded using the Store Session Record keyword are deleted.) |
|
| Generate Test Data | obj_name, number_to_create, **fields | Generate bulk test data This returns an array of dictionaries with template-formatted arguments which can be passed to the Salesforce Collection Insert keyword. You can use Example: The following example creates three new Contacts: @{objects} = Generate Test Data Contact 3 ... Name=User {{number}} ... Age={{number}} The example code will generate Contact objects with these fields: [{'Name': 'User 0', 'Age': '0'}, {'Name': 'User 1', 'Age': '1'}, {'Name': 'User 2', 'Age': '2'}] Python Expression Syntax is allowed so computed templates like this are also allowed: Python operators can be used, but no functions or variables are provided, so mostly you just have access to mathematical and logical operators. The Python operators are described here: https://www.digitalocean.com/community/tutorials/how-to-do-math-in-python-3-with-operators Contact the CCI team if you have a use-case that could benefit from more expression language power. Templates can also be based on faker patterns like those described here: https://faker.readthedocs.io/en/master/providers.html Most examples can be pasted into templates verbatim: @{objects}= Generate Test Data Contact 200 ... Name={{fake.first_name}} {{fake.last_name}} ... MailingStreet={{fake.street_address}} ... MailingCity=New York ... MailingState=NY ... MailingPostalCode=12345 ... Email={{fake.email(domain="salesforce.com")}} |
| Get Active Browser Ids | Return the id of all open browser ids |
|
| Get Current Record Id | Parses the current url to get the object id of the current record. Expects url format like: [a-zA-Z0-9]{15,18} |
|
| Get Fake Data | fake, *args, **kwargs | Return fake data This uses the Faker library to provide fake data in a variety of formats (names, addresses, credit card numbers, dates, phone numbers, etc) and locales (en_US, fr_FR, etc). The fake argument is the name of a faker property such as The return value is typically a string, though in some cases some other type of object will be returned. For example, the This keyword can also be called using robot's extend variable syntax using the variable To generate fake data for a locale other than en_US, use the keyword Examples # Generate a fake first name ${first_name}= Get fake data first_name # Generate a fake date in the default format ${date}= Get fake data date # Generate a fake date with an explicit format ${date}= Get fake data date pattern=%Y-%m-%d # Generate a fake date using extended variable syntax Input text //input ${faker.date(pattern='%Y-%m-%d')} |
| Get Field Value | label | Return the current value of a form field based on the field label |
| Get Latest Api Version | ||
| Get Locator | path, *args, **kwargs | Returns a rendered locator string from the Salesforce lex_locators dictionary. This can be useful if you want to use an element in a different way than the built in keywords allow. |
| Get Record Type Id | obj_type, developer_name | Returns the Record Type Id for a record type name |
| Get Related List Count | heading | Returns the number of items indicated for a related list. |
| Go To Object Home | obj_name | Navigates to the Home view of a Salesforce Object |
| Go To Object List | obj_name, filter_name=None | Navigates to the Home view of a Salesforce Object |
| Go To Record Home | obj_id | Navigates to the Home view of a Salesforce Object |
| Go To Setup Home | Navigates to the Home tab of Salesforce Setup |
|
| Go To Setup Object Manager | Navigates to the Object Manager tab of Salesforce Setup |
|
| Header Field Should Be Checked | label | Validates that a checkbox field in the record header is checked |
| Header Field Should Be Unchecked | label | Validates that a checkbox field in the record header is unchecked |
| Header Field Should Have Link | label | Validates that a field in the record header has a link as its value |
| Header Field Should Have Value | label | Validates that a field in the record header has a text value. NOTE: Use other keywords for non-string value types |
| Header Field Should Not Have Link | label | Validates that a field in the record header does not have a link as its value |
| Header Field Should Not Have Value | label | Validates that a field in the record header does not have a value. NOTE: Use other keywords for non-string value types |
| Initialize Location Strategies | Initialize the Salesforce location strategies 'text' and 'title' plus any strategies registered by other keyword libraries Note: This keyword is called automatically from Open Test Browser |
|
| Load Related List | heading | Scrolls down until the specified related list loads. |
| Log Browser Capabilities | loglevel=INFO | Logs all of the browser capabilities as reported by selenium |
| Open App Launcher | Opens the Saleforce App Launcher Modal Note: starting with Spring '20 the app launcher button opens a menu rather than a modal. To maintain backwards compatibility, this keyword will continue to open the modal rather than the menu. If you need to interact with the app launcher menu, you will need to create a custom keyword. |
|
| Populate Field | name, value | Enters a value into an input or textarea field. 'name' represents the label on the page (eg: "First Name"), and 'value' is the new value. Any existing value will be replaced. |
| Populate Form | **kwargs | Enters multiple values from a mapping into form fields. |
| Populate Lookup Field | name, value | Enters a value into a lookup field. |
| Remove Session Record | obj_type, obj_id | Remove a record from the list of records that should be automatically removed. |
| Salesforce Collection Insert | objects | Inserts records that were created with Generate Test Data. objects is a list of data, typically generated by the Generate Test Data keyword. A 200 record limit is enforced by the Salesforce APIs. The object name and Id is passed to the Store Session Record keyword, and will be deleted when the keyword Delete Session Records is called. As a best practice, either Delete Session Records or *Delete Records and Close Browser from Salesforce.robot should be called as a suite teardown. Example: @{objects}= Generate Test Data Contact 200 ... FirstName=User {{number}} ... LastName={{fake.last_name}} Salesforce Collection Insert ${objects} |
| Salesforce Collection Update | objects | Updates records described as Robot/Python dictionaries. objects is a dictionary of data in the format returned by the Salesforce Collection Insert keyword. A 200 record limit is enforced by the Salesforce APIs. Example: The following example creates ten accounts and then updates the Rating from "Cold" to "Hot" ${data}= Generate Test Data Account 10 ... Name=Account #{{number}} ... Rating=Cold ${accounts}= Salesforce Collection Insert ${data} FOR ${account} IN @{accounts} Set to dictionary ${account} Rating Hot END Salesforce Collection Update ${accounts} |
| Salesforce Delete | obj_name, obj_id | Deletes a Salesforce object by object name and Id. Example: The following example assumes that Salesforce Delete Contact ${contact id} |
| Salesforce Get | obj_name, obj_id | Gets a Salesforce object by Id and returns the result as a dict. Example: The following example assumes that &{contact}= Salesforce Get Contact ${contact id} log Contact name: ${contact['Name']} |
| Salesforce Insert | obj_name, **kwargs | Creates a new Salesforce object and returns the Id. The fields of the object may be defined with keyword arguments where the keyword name is the same as the field name. The object name and Id is passed to the Store Session Record keyword, and will be deleted when the keyword Delete Session Records is called. As a best practice, either Delete Session Records or Delete Records and Close Browser from Salesforce.robot should be called as a suite teardown. Example: The following example creates a new Contact with the first name of "Eleanor" and the last name of "Rigby". ${contact id}= Salesforce Insert Contact ... FirstName=Eleanor ... LastName=Rigby |
| Salesforce Query | obj_name, **kwargs | Constructs and runs a simple SOQL query and returns a list of dictionaries. By default the results will only contain object Ids. You can specify a SOQL SELECT clase via keyword arguments by passing a comma-separated list of fields with the Example: The following example searches for all Contacts where the first name is "Eleanor". It returns the "Name" and "Id" fields and logs them to the robot report: @{records}= Salesforce Query Contact select=Id,Name FOR ${record} IN @{records} log Name: ${record['Name']} Id: ${record['Id']} END |
| Salesforce Update | obj_name, obj_id, **kwargs | Updates a Salesforce object by Id. The keyword returns the result from the underlying simple_salesforce The following example assumes that ${contact id} has been previously set, and adds a Description to the given contact. &{contact}= Salesforce Update Contact ${contact id} ... Description=This Contact created during a test Should be equal as numbers ${result} 204 |
| Select App Launcher App | *args, **kwargs | Navigates to a Salesforce App via the App Launcher |
| Select App Launcher Tab | *args, **kwargs | Navigates to a tab via the App Launcher |
| Select Record Type | label | Selects a record type while adding an object. |
| Selenium Execute With Retry | execute, command, params | Run a single selenium command and retry once. The retry happens for certain errors that are likely to be resolved by retrying. |
| Set Faker Locale | locale | Set the locale for fake data This sets the locale for all calls to the For a list of supported locales see Localized Providers in the Faker documentation. Example Set Faker Locale fr_FR ${french_address}= Faker address |
| Soql Query | query | Runs a simple SOQL query and returns the dict results The query parameter must be a properly quoted SOQL query statement. The return value is a dictionary. The dictionary contains the keys as documented for the raw API call. The most useful key is Example The following example searches for all Contacts with a first name of "Eleanor" and a last name of "Rigby", and then prints the name of the first record found. ${result}= SOQL Query ... SELECT Name, Id FROM Contact WHERE FirstName='Eleanor' AND LastName='Rigby' Run keyword if len($result['records']) == 0 Fail No records found ${contact}= Get from list ${result['records']} 0 Should be equal ${contact['Name']} Eleanor Rigby |
| Store Session Record | obj_type, obj_id | Stores a Salesforce record's Id for use in the Delete Session Records keyword. This keyword is automatically called by Salesforce Insert. |
| Wait For Aura | Run the WAIT_FOR_AURA_SCRIPT. This script polls Aura via $A in Javascript to determine when all in-flight XHTTP requests have completed before continuing. |
|
| Wait Until Loading Is Complete | locator=None | Wait for LEX page to load. (We're actually waiting for the actions ribbon to appear.) |
| Wait Until Modal Is Closed | Wait for modal to close |
|
| Wait Until Modal Is Open | *args, **kwargs | Wait for modal to open |
| Wait Until Salesforce Is Ready | locator=None, timeout=None, interval=5 | Waits until we are able to render the initial salesforce landing page It will continue to refresh the page until we land on a lightning page or until a timeout has been reached. The timeout can be specified in any time string supported by robot (eg: number of seconds, "3 minutes", etc.). If not specified, the default selenium timeout will be used. This keyword will wait a few seconds between each refresh, as well as wait after each refresh for the page to fully render (ie: it calls wait_for_aura()) |
This resource file imports the Salesforce and CumulusCI keyword libraries, along with several other commonly used libraries (Collections, OperatingSystem, String, XML). In addition, it defines several other keywords.
This resource file also defines several global variables, including ${BROWSER}
, ${ORG}
, and ${DEFAULT_BROWSER_SIZE}
This resource file should be included in every test suite, like in the following example (note: there should be two or more spaces after Resource
):
*** Settings ***
Resource cumulusci/robotframework/Salesforce.robot
| Keyword | Arguments | Documentation |
|---|---|---|
| Chrome Set Binary | options | |
| Chrome Set Headless | options | |
| Delete Records and Close Browser | This will close all open browser windows and then delete all records created with the Salesforce API during this testing session. |
|
| Get Chrome Options | ||
| Locate Element By Text | browser, locator, tag, constraints | |
| Locate Element By Title | browser, locator, tag, constraints | |
| Open Test Browser | size=${DEFAULT BROWSER SIZE}, alias=${NONE} | Opens a test browser to the org. The variable ${BROWSER} determines which browser should open. The following four browsers are explicitly supported: chrome, firefox, headlesschrome, and headlessfirefox. Any other value will be passed directly to the SeleniumLibrary 'Open Browser' keyword. Once the browser has been opened, it will be set to the given size (default=${DEFAULT BROWSER SIZE}) The keyword `Log Browser Capabilities` will automatically be called. |
| Open Test Browser Chrome | login_url, alias=${NONE} | |
| Open Test Browser Firefox | login_url, alias=${NONE} | |
| Open Test Browser Headless Firefox | login_url, alias=${NONE} |
The following page objects are automatically included when importing the PageObject library. You should not directly import this file.
| Detail |
| Page Type |
A page object representing the standard Detail page.
When going to this page via the standard `Go to page` keyword, you can specify either an object id, or a set of keyword arguments which will be used to look up the object id. When using keyword arguments, they need to represent a unique user.
Example
${contact_id} = Salesforce Insert Contact ... FirstName=${first_name} ... LastName=${last_name} # Using the id: Go to page Detail Contact ${contact_id} # Using lookup parameters Go to page Detail Contact FirstName=${first_name} LastName=${last_name}
| Keyword | Arguments | Documentation |
|---|---|---|
| Log Current Page Object | Logs the name of the current page object The current page object is also returned as an object |
| Edit |
| Page Type |
A page object representing the Edit Object modal
Note: You should not use this page object with 'Go to page'. Instead, you can use 'Wait for modal to appear' after performing an action that causes the new object modal to appear (eg: clicking the "Edit" button). Once the modal appears, the keywords for that modal will be available for use in the test.
Example:
Click object button Edit Wait for modal to appear Edit Contact
| Keyword | Arguments | Documentation |
|---|---|---|
| Click Modal Button | *args, **kwargs | Click the named modal button (Save, Save & New, Cancel, etc) |
| Close The Modal | *args, **kwargs | Closes the open modal |
| Log Current Page Object | Logs the name of the current page object The current page object is also returned as an object |
|
| Modal Should Contain Errors | *args, **kwargs | Verify that the modal contains the following errors This will look for the given message in the standard SLDS component (<ul class='errorsList'>) |
| Populate Field | *args, **kwargs | Populate a field on the modal form Name must the the label of a field as it appears on the modal form. Example Populate field First Name Connor Populate field Last Name MacLeod |
| Populate Form | *args, **kwargs | Populate the modal form Arguments are of the form key=value, where 'key' represents a field name as it appears on the form (specifically, the text of a label with the class 'uiLabel'). Example: Populate form ... First Name=Connor ... Last Name=MacLeod |
| Wait Until Modal Is Closed | *args, **kwargs | Waits until the modal is no longer visible If the modal isn't open, this will not throw an error. |
| Home |
| Page Type |
A page object representing the home page of an object.
When going to the Home page, you need to specify the object name.
Note: The home page of an object may automatically redirect you to some other page, such as a Listing page. If you are working with such a page, you might need to use `page should be` to load the keywords for the page you expect to be redirected to.
Example
Go to page Home Contact
| Keyword | Arguments | Documentation |
|---|---|---|
| Log Current Page Object | Logs the name of the current page object The current page object is also returned as an object |
| Listing |
| Page Type |
Page object representing a Listing page
When going to the Listing page, you need to specify the object name. You may also specify the name of a filter.
Example
Go to page Listing Contact filterName=Recent
| Keyword | Arguments | Documentation |
|---|---|---|
| Log Current Page Object | Logs the name of the current page object The current page object is also returned as an object |
| New |
| Page Type |
A page object representing the New Object modal
Note: You should not use this page object with 'Go to page'. Instead, you can use 'Wait for modal to appear' after performing an action that causes the new object modal to appear (eg: clicking the "New" button). Once the modal appears, the keywords for that modal will be available for use in the test.
Example:
Go to page Home Contact Click object button New Wait for modal to appear New Contact
| Keyword | Arguments | Documentation |
|---|---|---|
| Click Modal Button | *args, **kwargs | Click the named modal button (Save, Save & New, Cancel, etc) |
| Close The Modal | *args, **kwargs | Closes the open modal |
| Log Current Page Object | Logs the name of the current page object The current page object is also returned as an object |
|
| Modal Should Contain Errors | *args, **kwargs | Verify that the modal contains the following errors This will look for the given message in the standard SLDS component (<ul class='errorsList'>) |
| Populate Field | *args, **kwargs | Populate a field on the modal form Name must the the label of a field as it appears on the modal form. Example Populate field First Name Connor Populate field Last Name MacLeod |
| Populate Form | *args, **kwargs | Populate the modal form Arguments are of the form key=value, where 'key' represents a field name as it appears on the form (specifically, the text of a label with the class 'uiLabel'). Example: Populate form ... First Name=Connor ... Last Name=MacLeod |
| Wait Until Modal Is Closed | *args, **kwargs | Waits until the modal is no longer visible If the modal isn't open, this will not throw an error. |


proActiv is an R package that estimates promoter activity from RNA-Seq data. proActiv uses aligned reads and genome annotations as input, and provides absolute and relative promoter activity as output. The package can be used to identify active promoters and alternative promoters. Details of the method are described in Demircioglu et al.
HTML documentation of proActiv, including a complete step-by-step workflow and a function manual, is available at https://goekelab.github.io/proActiv/.
Additional data on differential promoters in tissues and cancers from TCGA, ICGC, GTEx, and PCAWG is available at https://jglab.org/data-and-software/.
proActiv can be installed from Bioconductor:
if (!requireNamespace("BiocManager", quietly = TRUE))
install.packages("BiocManager")
BiocManager::install("proActiv")
proActiv estimates promoter activity from RNA-Seq data. Promoter activity is defined as the total amount of transcription initiated at each promoter. proActiv takes as input either BAM files or junction files (TopHat2 or STAR), and a promoter annotation object of the relevant genome. An optional argument condition
can be supplied, describing the experimental condition corresponding to each input file. Here we demonstrate proActiv with STAR junction files (Human genome GRCh38 GENCODE v34) as input. These files are taken from the SGNEx project but restricted to the chr1:10,000,000-30,000,000 region, and can be found at extdata/vignette
:
extdata/vignette/SGNEx_A549_Illumina_replicate1-run1.subset.SJ.out.tab.gz
extdata/vignette/SGNEx_A549_Illumina_replicate3-run1.subset.SJ.out.tab.gz
extdata/vignette/SGNEx_A549_Illumina_replicate5-run1.subset.SJ.out.tab.gz
extdata/vignette/SGNEx_HepG2_Illumina_replicate2-run1.subset.SJ.out.tab.gz
extdata/vignette/SGNEx_HepG2_Illumina_replicate4-run1.subset.SJ.out.tab.gz
extdata/vignette/SGNEx_HepG2_Illumina_replicate5-run1.subset.SJ.out.tab.gz
library(proActiv)
## List of STAR junction files as input
files <- list.files(system.file('extdata/vignette/junctions',
package = 'proActiv'), full.names = TRUE)
## Vector describing experimental condition
condition <- rep(c('A549','HepG2'), each=3)
## Promoter annotation for human genome GENCODE v34
promoterAnnotation <- promoterAnnotation.gencode.v34.subset
result <- proActiv(files = files,
promoterAnnotation = promoterAnnotation,
condition = condition)
result
is a summarizedExperiment object which can be accessed as follows:
assays(results)
returns raw/normalized promoter counts, absolute/relative promoter activity and gene expression datarowData(results)
returns promoter metadata and summarized absolute promoter activity by conditionsproActiv can also be run with BAM files as input, but an additional parameter genome
must be supplied:
## From BAM files - genome parameter must be provided
files <- list.files(system.file('extdata/testdata/bam', package = 'proActiv'), full.names = TRUE)
result <- proActiv(files = files,
promoterAnnotation = promoterAnnotation.gencode.v34.subset,
genome = 'hg38')
In order to quantify promoter activity, proActiv uses a set of promoters based on genome annotations. proActiv allows the creation of a promoter annotation object for any genome from a TxDb object or from a GTF file with the preparePromoterAnnotation
function. Users have the option to either pass the file path of the GTF/GFF or TxDb to be used, or use the TxDb object directly as input. proActiv includes pre-calculated promoter annotations for the human genome (GENCODE v34). However, due to size constraints, the annotation is restricted to the chr1:10,000,000-30,000,000 region. Users can build full annotations by downloading GTF files from GENCODE page and following the steps below.
Here, we demonstrate creating the subsetted promoter annotation for the Human genome (GENCODE v34) with both GTF and TxDb:
## From GTF file path
gtf.file <- system.file('extdata/vignette/annotation/gencode.v34.annotation.subset.gtf.gz',
package = 'proActiv')
promoterAnnotation.gencode.v34.subset <- preparePromoterAnnotation(file = gtf.file,
species = 'Homo_sapiens')
## From TxDb object
txdb.file <- system.file('extdata/vignette/annotation/gencode.v34.annotation.subset.sqlite',
package = 'proActiv')
txdb <- loadDb(txdb.file)
promoterAnnotation.gencode.v34.subset <- preparePromoterAnnotation(txdb = txdb,
species = 'Homo_sapiens')
The PromoterAnnotation
object has 3 slots:
intronRanges
: Intron ranges, giving the corresponding transcripts of each intronpromoterIdMapping
: An ID mapping between transcripts, promoter IDs and gene IDspromoterCoordinates
: Promoter coordinates (TSS) and internal promoter state, along with the 3’ coordinate of the first exonMost human genes have multiple promoters that control the expression of distinct isoforms. The use of these alternative promoters enables the regulation of isoform expression pre-transcriptionally. Importantly, alternative promoters have been found to be important in a wide number of cell types and diseases. proActiv includes a workflow to identify and visualize alternative promoter usage between conditions. This workflow is described in detail here.
Release 1.1.18
Date: 7th April 2021
Changes in version 1.1.18:
Gene expression data is now stored in the assays
of the summarizedExperiment object returned by proActiv
to facilitate easier filtering of the summarizedExperiment object. The metadata slot is now empty.
Plotting promoter activity: Implementation of boxplotPromoters
function to plot boxplots of absolute promoter activity, relative promoter activity, and gene expression.
Identification of alternative promoters: Implementation of getAlternativePromoters
, used to identify promoters that may exhibit alternative usage.
Release 1.0.0
Release date: 28th October 2020
Released with Bioconductor 3.12
Release 0.99.0
Release date: 21st August 2020
Changes in version 0.99.0:
Workflow: The wrapper function proActiv
performs all steps to estimate promoter activity and calculates promoter metadata. A condition
argument can be supplied for proActiv
to summarize promoter counts and activity across conditions. These results are returned as a SummarizedExperiment object.
BAM file usage: In addition to junction files, proActiv
now allows BAM files as input. However, users should note that this function is not fully optimized and may have long run-time.
Promoter annotation: Improved efficiency in generating promoter annotations without the need for parallelization with the preparePromoterAnnotations
function. The promoter annotation object is also trimmed to preserve essential information for running proActiv
, in order to comply with Bioconductor guidelines concerning package size.
Plotting promoter activity: The plotting function plotPromoters
visualizes promoter activity across conditions. It accepts the SummarizedExperiment object returned by proActiv
along with a gene of interest and gene annotations as arguments. This allows users to visualize promoter activity and identify instances of alternative promoter usage.
Vignette: proActiv now comes with a vignette, documenting a complete step-by-step workflow in identifying active and alternative promoter usage. This includes guidance on running proActiv
, creating promoter annotations and identifying alternative promoter usage. Various visualizations of promoter activity are also offered.
Initial Release 0.1.0
Release date: 19th May 2020
This release corresponds to the proActiv version used by Demircioglu et al.
proActiv will not provide promoter activity estimates for promoters which are not uniquely identifiable from splice junctions (single exon transcripts, promoters which overlap with internal exons).
proActiv is developed and maintained by Deniz Demircioglu, Joseph Lee, and Jonathan Göke.


|
Writing files in Go follows similar patterns to the
ones we saw earlier for reading.
|
|
|
|
|
|
|
import (
"bufio"
"fmt"
"io/ioutil"
"os"
)
|
|
|
func check(e error) {
if e != nil {
panic(e)
}
}
|
|
|
|
|
To start, here’s how to dump a string (or just
bytes) into a file.
|
d1 := []byte("hello\ngo\n")
err := ioutil.WriteFile("/tmp/dat1", d1, 0644)
check(err)
|
|
For more granular writes, open a file for writing.
|
f, err := os.Create("/tmp/dat2")
check(err)
|
|
It’s idiomatic to defer a Close immediately
after opening a file.
|
|
|
You can Write byte slices as you’d expect.
|
d2 := []byte{115, 111, 109, 101, 10}
n2, err := f.Write(d2)
check(err)
fmt.Printf("wrote %d bytes\n", n2)
|
|
A WriteString is also available.
|
n3, err := f.WriteString("writes\n")
fmt.Printf("wrote %d bytes\n", n3)
|
|
Issue a Sync to flush writes to stable storage.
|
|
|
bufio provides buffered writers in addition
to the buffered readers we saw earlier.
|
w := bufio.NewWriter(f)
n4, err := w.WriteString("buffered\n")
fmt.Printf("wrote %d bytes\n", n4)
|
|
Use Flush to ensure all buffered operations have
been applied to the underlying writer.
|
|
|
|
|


World
1,586 completed
248 currently
Friends
7 completed
3 currently
Rating
Difficulty
World
1,586 completed
248 currently
Friends
4 completed
3 currently
Rating
Difficulty
World
1,586 completed
248 currently
Friends
7 completed
5 currently
Rating
Difficulty


The biggest projects include a racial equity review of city code and policies, race, equity and leadership training for all city employees and the Athens 2040 Comprehensive Plan. Although some of the projects focus heavily on race, Athens Mayor Steve Patterson said the city is focused on equity overall.
The racial equity review of city code and policies was initially born out of Athens City Council declaring racism a public health crisis in June 2020. According to a previous Post report, Patterson built a task force that works with the city’s Racial Equity Coalition to inspect code for discriminatory or vague language.
So far, the review has led to some changes within city code and policies. Patterson said he was aware of Councilwoman Sarah Grace, D-At Large, and Councilman Micah McCarey, D-At Large, working to contain more gender-inclusive language in city legislation, removing “his” or “her” pronouns and replacing them with “their” pronouns.
Patterson also said he combed through municipal code but was unable to find any discriminatory language. Despite that, the city is staying mindful of inclusive language moving forward, he said, while also keeping an eye on any discriminatory language that arises.
Another initiative Athens has undertaken is city-wide race, equity and leadership, or REAL, training through the National League of Cities, or NLC, of which Athens is a member. In August, Council approved the training for all city employees, which includes a preliminary attitudinal survey and multiple levels of training, according to a previous Post report.
The training is designed to assist local leaders with implementing “safe places” for people of diverse racial, ethnic and cultural statuses, according to NLC’s website.
In addition to the REAL training and the review of city code and policies, the Athens 2040 Comprehensive Plan sets long-term goals to make Athens an equitable place for a wide range of populations. Although it was adopted by Council in December 2020, the plan has implications in 2021 and beyond.
According to the 80-page final verison of the plan, the initiative’s main objectives are centered around citizen engagement and concerns. It is also broken up into sections including housing and neighborhoods, sustainability and energy, and diversity and inclusion.
McCarey, as Council’s only member of color, is supportive of the plan and sees it as a starting point for much larger initiatives in the city.
“The plan gives us a really strong starting place for work that has to be ongoing,” McCarey said. “For instance, if we’re focusing on the diversity and inclusion aspect of the plan, it needs to highlight goals related to not only accessibility and race, but also the many other facets of diversity that we have in our community.”
With 2022 on the horizon and the city’s initiatives slowly progressing, McCarey wants to see people beyond city administration take responsibility for equitable changes to ensure the city puts its best foot forward in terms of progress.
“If you don't look at it as a top-down thing, like the city is responsible for the progress that we make in terms of diversity inclusion and instead say that we as a whole community are responsible for this work, then it gets easier to comprehend because we can look around to see what's good that we want to keep going and what's missing that we want to create,” he said.


Brian Matney
<EMAIL_ADDRESS>3575 Lexington Ave S Apt 131
Eagan, Mn 55123
(903) 487-6645
Skilled troubleshooter with 5 years of experience in retail, data-management, and sales. Detail-oriented team player proficient in customer service and multi-tasking.
Technical Skills
Professional Experience
Groth Music
2014-2016
School Services Representative
- Increased sales by 10% across 100 school accounts
- Streamlined inventory management processes
- Established credibility and expanded relationships with vendors and other team members
Sam's Club
2013-2014
Customer Service Manager
- Managed a team of 25 employees daily
- Supervised front end service operations including hiring, coaching, and counseling
- Resolved conflicts presented by members and staff
General Dynamics
2012-2013
Customer Service Representative
- Counseled clients on repayment options for federal student loans
- Managed customer information across multiple databases
- Provided technical support for customer account website
Walmart
2012
Customer Service Specialist
- Supported management and department leaders
- Assisted with returns and exchanges requiring knowledge of both store level and legal policies
Education
Prime Digital Academy
2016-current
- Full-Stack Web Develpment Bootcamp
- Experience with HTML / CSS, Javascript, jQuery, AngularJS and Node.js
-
Ouachita Baptist University
2008-2011
- Instrumental Music Education
- Saxophone Performance


Congratulations on reaching the final project of the Robotics Nanodegree!
Previously, you worked on the Semantic Segmentation lab where you built a deep learning network that locates a particular human target within an image. For this project, you will utilize what you implemented and learned from that lab and extend it to train a deep learning model that will allow a simulated quadcopter to follow around the person that it detects!
Most of the code below is similar to the lab with some minor modifications. You can start with your existing solution, and modify and improve upon it to train the best possible model for this task.
You can click on any of the following to quickly jump to that part of this notebook:
We have provided you with a starting dataset for this project. Download instructions can be found in the README for this project's repo. Alternatively, you can collect additional data of your own to improve your model. Check out the "Collecting Data" section in the Project Lesson in the Classroom for more details!
import os
import glob
import sys
import tensorflow as tf
from scipy import misc
import numpy as np
from tensorflow.contrib.keras.python import keras
from tensorflow.contrib.keras.python.keras import layers, models
from tensorflow import image
from utils import scoring_utils
from utils.separable_conv2d import SeparableConv2DKeras, BilinearUpSampling2D
from utils import data_iterator
from utils import plotting_tools
from utils import model_tools
In the Classroom, we discussed the different layers that constitute a fully convolutional network (FCN). The following code will introduce you to the functions that you need to build your semantic segmentation model.
The Encoder for your FCN will essentially require separable convolution layers, due to their advantages as explained in the classroom. The 1x1 convolution layer in the FCN, however, is a regular convolution. Implementations for both are provided below for your use. Each includes batch normalization with the ReLU activation function applied to the layers.
def separable_conv2d_batchnorm(input_layer, filters, strides=1):
output_layer = SeparableConv2DKeras(filters=filters,kernel_size=3, strides=strides,
padding='same', activation='relu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
def conv2d_batchnorm(input_layer, filters, kernel_size=3, strides=1):
output_layer = layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,
padding='same', activation='relu')(input_layer)
output_layer = layers.BatchNormalization()(output_layer)
return output_layer
The following helper function implements the bilinear upsampling layer. Upsampling by a factor of 2 is generally recommended, but you can try out different factors as well. Upsampling is used in the decoder block of the FCN.
def bilinear_upsample(input_layer):
output_layer = BilinearUpSampling2D((2,2))(input_layer)
return output_layer
In the following cells, you will build an FCN to train a model to detect and locate the hero target within an image. The steps are:
encoder_block
decoder_block
Create an encoder block that includes a separable convolution layer using the separable_conv2d_batchnorm()
function. The filters
parameter defines the size or depth of the output layer. For example, 32 or 64.
def encoder_block(input_layer, filters, strides):
# TODO Create a separable convolution layer using the separable_conv2d_batchnorm() function.
output_layer = separable_conv2d_batchnorm(input_layer, filters, strides)
return output_layer
The decoder block is comprised of three parts:
def decoder_block(small_ip_layer, large_ip_layer, filters):
# TODO Upsample the small input layer using the bilinear_upsample() function.
upsampled = bilinear_upsample(small_ip_layer)
# TODO Concatenate the upsampled and large input layers using layers.concatenate
concat_layer = layers.concatenate([upsampled, large_ip_layer])
# TODO Add some number of separable convolution layers
output_layer = separable_conv2d_batchnorm(concat_layer, filters)
output_layer1 = separable_conv2d_batchnorm(output_layer, filters)
return output_layer1
Now that you have the encoder and decoder blocks ready, go ahead and build your FCN architecture!
There are three steps:
def fcn_model(inputs, num_classes):
# TODO Add Encoder Blocks.
# Remember that with each encoder layer, the depth of your model (the number of filters) increases.
block_1 = encoder_block(inputs, 64, 2)
block_2 = encoder_block(block_1, 128, 2)
# TODO Add 1x1 Convolution layer using conv2d_batchnorm().
block_3 = conv2d_batchnorm(block_2, 256, kernel_size=1, strides=1)
# TODO: Add the same number of Decoder Blocks as the number of Encoder Blocks
block_4 = decoder_block(block_3, block_1, 128)
block_5 = decoder_block(block_4, inputs, 64)
# The function returns the output layer of your model. "x" is the final layer obtained from the last decoder_block()
return layers.Conv2D(num_classes, 3, activation='softmax', padding='same')(block_5)
The following cells will use the FCN you created and define an ouput layer based on the size of the processed image and the number of classes recognized. You will define the hyperparameters to compile and train your model.
Please Note: For this project, the helper code in data_iterator.py
will resize the copter images to 160x160x3 to speed up training.
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
image_hw = 160
image_shape = (image_hw, image_hw, 3)
inputs = layers.Input(image_shape)
num_classes = 3
# Call fcn_model()
output_layer = fcn_model(inputs, num_classes)
Define and tune your hyperparameters.
learning_rate = 0.001
batch_size = 30
num_epochs = 12
steps_per_epoch = 250
validation_steps = 39
workers = 4
print("here")
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# Define the Keras model and compile it for training
model = models.Model(inputs=inputs, outputs=output_layer)
model.compile(optimizer=keras.optimizers.Adam(learning_rate), loss='categorical_crossentropy')
# Data iterators for loading the training and validation data
train_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,
data_folder=os.path.join('..', 'data', 'train'),
image_shape=image_shape,
shift_aug=True)
val_iter = data_iterator.BatchIteratorSimple(batch_size=batch_size,
data_folder=os.path.join('..', 'data', 'validation'),
image_shape=image_shape)
logger_cb = plotting_tools.LoggerPlotter()
callbacks = [logger_cb]
model.fit_generator(train_iter,
steps_per_epoch = steps_per_epoch, # the number of batches per epoch,
epochs = num_epochs, # the number of epochs to train for,
validation_data = val_iter, # validation iterator
validation_steps = validation_steps, # the number of batches to validate on
callbacks=callbacks,
workers = workers)
print("Here")
# Save your trained model weights
weight_file_name = 'model_weights'
model_tools.save_network(model, weight_file_name)
print("Here")
Now that you have your model trained and saved, you can make predictions on your validation dataset. These predictions can be compared to the mask images, which are the ground truth labels, to evaluate how well your model is doing under different conditions.
There are three different predictions available from the helper code provided:
# If you need to load a model which you previously trained you can uncomment the codeline that calls the function below.
# weight_file_name = 'model_weights'
# restored_model = model_tools.load_network(weight_file_name)
The following cell will write predictions to files and return paths to the appropriate directories.
The run_num
parameter is used to define or group all the data for a particular model run. You can change it for different runs. For example, 'run_1', 'run_2' etc.
run_num = 'run_1'
val_with_targ, pred_with_targ = model_tools.write_predictions_grade_set(model,
run_num,'patrol_with_targ', 'sample_evaluation_data')
val_no_targ, pred_no_targ = model_tools.write_predictions_grade_set(model,
run_num,'patrol_non_targ', 'sample_evaluation_data')
val_following, pred_following = model_tools.write_predictions_grade_set(model,
run_num,'following_images', 'sample_evaluation_data')
print("Here")
Now lets look at your predictions, and compare them to the ground truth labels and original images. Run each of the following cells to visualize some sample images from the predictions in the validation set.
# images while following the target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','following_images', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
print("Here")
# images while at patrol without target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','patrol_non_targ', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
print("Here")
# images while at patrol with target
im_files = plotting_tools.get_im_file_sample('sample_evaluation_data','patrol_with_targ', run_num)
for i in range(3):
im_tuple = plotting_tools.load_images(im_files[i])
plotting_tools.show_images(im_tuple)
print("Here")
Evaluate your model! The following cells include several different scores to help you evaluate your model under the different conditions discussed during the Prediction step.
# Scores for while the quad is following behind the target.
true_pos1, false_pos1, false_neg1, iou1 = scoring_utils.score_run_iou(val_following, pred_following)
print("Here")
# Scores for images while the quad is on patrol and the target is not visable
true_pos2, false_pos2, false_neg2, iou2 = scoring_utils.score_run_iou(val_no_targ, pred_no_targ)
print("Here")
# This score measures how well the neural network can detect the target from far away
true_pos3, false_pos3, false_neg3, iou3 = scoring_utils.score_run_iou(val_with_targ, pred_with_targ)
print("Here")
# Sum all the true positives, etc from the three datasets to get a weight for the score
true_pos = true_pos1 + true_pos2 + true_pos3
false_pos = false_pos1 + false_pos2 + false_pos3
false_neg = false_neg1 + false_neg2 + false_neg3
weight = true_pos/(true_pos+false_neg+false_pos)
print(weight)
# The IoU for the dataset that never includes the hero is excluded from grading
final_IoU = (iou1 + iou3)/2
print(final_IoU)
# And the final grade score is
final_score = final_IoU * weight
print(final_score)


The equations of guiding center motion are given by[1]
|
| (1) |
|
| (2) |
where X is the guiding-center position, v∥ is the parallel (to the magnetic ﬁeld) velocity deﬁned by v∥ = B⋅v∕B; Here m, Ze, and v are the mass, charge and velocity of the particle, respectively, μ is the magnetic moment deﬁned by μ = mv⊥2∕(2B) with v⊥ being the perpendicular speed; Ω = BZe∕m is the cyclotron angular frequency, B⋆ and B∥⋆ are deﬁned by
|
| (3) |
|
| (4) |
respectively, where b = B∕B. If we use the approximation B∥⋆ ≈ B, then the drift velocity in Eq. (1) can be written as
|
| (5) |
where the usual drifts can be recognized. Before getting to know the above form of the equations of the guiding-center motion, I used the following form of the equations (refer to my notes “collisionless_drift_kinetic_equation.tm”):
|
| (6) |
|
| (7) |
which does not conserve the toroidal angular momentum Pϕ exactly in an axisymmetrical equilibrium magnetic ﬁeld (this has been tested numerically) while the new form given in Eqs. (1)-(4) can conserve Pϕ exactly. My latest numerical code uses Eqs. (1)-(4) as the the equations of guiding center motion. The toroidal angular momentum Pϕ is deﬁned by
|
| (8) |
where Ψ = AϕR with Aϕ being the toroidal component of the magnetic vector potential.
The above formulas are in SI units, which are good since SI units are widely used and thus these formulas are accessible to most people, making communications easier. However, many physicists prefer to deﬁne new units for a speciﬁc problem and write the equations in terms of these new units. This process is often called normalization. This has the advantage of possibly reducing the number of free parameters in a problem. Another advantage is that, by chosen proper characteristic quantities as units, the magnitude of quantities in terms of the new units are easier to be appreciated. A third advantage is that the magnitude of normalized quantities may be in the vicinity of 1 (if suitable units are chosen), and thus numerical overﬂow in a numerical computation may be avoided, making the computation more accurate. The disadvantages of the normalization are (1) the additional work associated with performing the transformation between two units systems, (2) possible confusions about which units are used in a numerical code and the potential of introducing bugs due to this confusion when writing or revising numerical codes.
The units I adopted are as follows. Choose a characteristic magnetic ﬁeld strength Bn and a characteristic length Ln. Using Bn and Ln, we deﬁne a characteristic time tn ≡ 2π∕Ωn, where Ωn = Bn|Ze|∕m, a characteristic velocity vn = Ln∕tn, and a characteristic magnetic moment μn = mvn2∕Bn. Using these characteristic quantities as units, I deﬁne the following normalized quantities:
|
| (9) |
In terms of the above normalized quantities, Eqs. (1)-(4) are written, respectively, as
|
| (10) |
|
| (11) |
|
| (12) |
and
|
| (13) |
In the normalized form, there is only one parameter for distinguishing particle species, namely the sign of particle’s charge Z∕|Z|. The other parameters for particle species enters via the normalization factor Ωn = Bn|Ze|∕m.
The toroidal angular momentum Pϕ is normalized by ZeBnLn2.
In TEK code, I choose Bn = 1T and Ln = 1m, i.e., they are identical to the corresponding SI units. This choice makes my unit system become bad because it is hard to relate vn deﬁned above to any typical velocity in a tokamak plasma. A better choice would be choose Bn to the magnetic ﬁeld magnitude at the magnetic axis and choose Ln to be vt∕Ωn, i.e., the Larmor radius of a typical particles, where vt is the thermal velocity of a species. Then deﬁne tn = 1∕Ωn and deﬁne vn by vn = Ln∕tn = vt, which is a typical particle velocity. In future, I may change TEK code to using this unit system, but presently I stick to using the above unit system.


Please visit the ??? for information about the future of QMF.
QMF (Qpid Management Framework) is a general-purpose management bus built on Qpid Messaging. It takes advantage of the scalability, security, and rich capabilities of Qpid to provide flexible and easy-to-use manageability to a large set of applications.
QMF is used through two primary APIs. The console API is used for console applications that wish to access and manipulate manageable components through QMF. The agent API is used for application that wish to be managed through QMF.
The fastest way to get started with QMF is to work through the "How To" tutorials for consoles and agents. For a deeper understanding of what is happening in the tutorials, it is recommended that you look at the Qmf Concepts section.
This section introduces important concepts underlying QMF.
The major architectural components of QMF are the Console, the Agent, and the Broker. Console components are the "managing" components of QMF and agent components are the "managed" parts. The broker is a central (possibly distributed, clustered and fault-tolerant) component that manages name spaces and caches schema information.
A console application may be a command-line utility, a three-tiered web-based GUI, a collection and storage device, a specialized application that monitors and reacts to events and conditions, or anything else somebody wishes to develop that uses QMF management data.
An agent application is any application that has been enhanced to allow itself to be managed via QMF.
+-------------+ +---------+ +---------------+ +-------------------+ | CLI utility | | Web app | | Audit storage | | Event correlation | +-------------+ +---------+ +---------------+ +-------------------+ ^ ^ ^ ^ | | | | | | v v v v v +---------------------------------------------------------------------------------+ | Qpid Messaging Bus (with QMF Broker capability) | +---------------------------------------------------------------------------------+ ^ ^ ^ | | | v v v +----------------+ +----------------+ +----------------+ | Manageable app | | Manageable app | | Manageable app | +----------------+ +----------------+ +----------------+
In the above diagram, the Manageable apps are agents, the CLI utility, Web app, and Audit storage are consoles, and Event correlation is both a console and an agent because it can create events based on the aggregation of what it sees.
A schema describes the structure of management data. Each agent provides a schema that describes its management model including the object classes, methods, events, etc. that it provides. In the current QMF distribution, the agent's schema is codified in an XML document. In the near future, there will also be ways to programatically create QMF schemata.
Each agent that exports a schema identifies itself using a package name. The package provides a unique namespace for the classes in the agent's schema that prevent collisions with identically named classes in other agents' schemata.
Package names are in "reverse domain name" form with levels of hierarchy separated by periods. For example, the Qpid messaging broker uses package "org.apache.qpid.broker" and the Access Control List plugin for the broker uses package "org.apache.qpid.acl". In general, the package name should be the reverse of the internet domain name assigned to the organization that owns the agent software followed by identifiers to uniquely identify the agent.
The XML document for a package's schema uses an enclosing <schema> tag. For example:
<schema package="org.apache.qpid.broker"> </schema>
Object classes define types for manageable objects. The agent may create and destroy objects which are instances of object classes in the schema. An object class is defined in the XML document using the <class> tag. An object class is composed of properties, statistics, and methods.
<class name="Exchange"> <property name="vhostRef" type="objId" references="Vhost" access="RC" index="y" parentRef="y"/> <property name="name" type="sstr" access="RC" index="y"/> <property name="type" type="sstr" access="RO"/> <property name="durable" type="bool" access="RC"/> <property name="arguments" type="map" access="RO" desc="Arguments supplied in exchange.declare"/> <statistic name="producerCount" type="hilo32" desc="Current producers on exchange"/> <statistic name="bindingCount" type="hilo32" desc="Current bindings"/> <statistic name="msgReceives" type="count64" desc="Total messages received"/> <statistic name="msgDrops" type="count64" desc="Total messages dropped (no matching key)"/> <statistic name="msgRoutes" type="count64" desc="Total routed messages"/> <statistic name="byteReceives" type="count64" desc="Total bytes received"/> <statistic name="byteDrops" type="count64" desc="Total bytes dropped (no matching key)"/> <statistic name="byteRoutes" type="count64" desc="Total routed bytes"/> </class>
<property> and <statistic> tags must be placed within <schema> and </schema> tags.
Properties, statistics, and methods are the building blocks of an object class. Properties and statistics are both object attributes, though they are treated differently. If an object attribute is defining, seldom or never changes, or is large in size, it should be defined as a property. If an attribute is rapidly changing or is used to instrument the object (counters, etc.), it should be defined as a statistic.
The XML syntax for <property> and <statistic> have the following XML-attributes:
Table 2.1. XML Attributes for QMF Properties and Statistics
| Attribute | <property> | <statistic> | Meaning |
| name | Y | Y | The name of the attribute |
| type | Y | Y | The data type of the attribute |
| unit | Y | Y | Optional unit name - use the singular (i.e. MByte) |
| desc | Y | Y | Description to annotate the attribute |
| references | Y | If the type is "objId", names the referenced class | |
| access | Y | Access rights (RC, RW, RO) | |
| index | Y | "y" if this property is used to uniquely identify the object. There may be more than one index property in a class | |
| parentRef | Y | "y" if this property references an object in which this object is in a child-parent relationship. | |
| optional | Y | "y" if this property is optional (i.e. may be NULL/not-present) | |
| min | Y | Minimum value of a numeric attribute | |
| max | Y | Maximum value of a numeric attribute | |
| maxLen | Y | Maximum length of a string attribute |
<method> tags must be placed within <schema> and </schema> tags.
A method is an invokable function to be performed on instances of the object class (i.e. a Remote Procedure Call). A <method> tag has a name, an optional description, and encloses zero or more arguments. Method arguments are defined by the <arg> tag and have a name, a type, a direction, and an optional description. The argument direction can be "I", "O", or "IO" indicating input, output, and input/output respectively. An example:
<method name="echo" desc="Request a response to test the path to the management broker"> <arg name="sequence" dir="IO" type="uint32"/> <arg name="body" dir="IO" type="lstr"/> </method>
Object attributes, method arguments, and event arguments have data types. The data types are based on the rich data typing system provided by the AMQP messaging protocol. The following table describes the data types available for QMF:
Table 2.2. QMF Datatypes
| QMF Type | Description |
| REF | QMF Object ID - Used to reference another QMF object. |
| U8 | 8-bit unsigned integer |
| U16 | 16-bit unsigned integer |
| U32 | 32-bit unsigned integer |
| U64 | 64-bit unsigned integer |
| S8 | 8-bit signed integer |
| S16 | 16-bit signed integer |
| S32 | 32-bit signed integer |
| S64 | 64-bit signed integer |
| BOOL | Boolean - True or False |
| SSTR | Short String - String of up to 255 bytes |
| LSTR | Long String - String of up to 65535 bytes |
| ABSTIME | Absolute time since the epoch in nanoseconds (64-bits) |
| DELTATIME | Delta time in nanoseconds (64-bits) |
| FLOAT | Single precision floating point number |
| DOUBLE | Double precision floating point number |
| UUID | UUID - 128 bits |
| FTABLE | Field-table - std::map in C++, dictionary in Python |
In the XML schema definition, types go by different names and there are a number of special cases. This is because the XML schema is used in code-generation for the agent API. It provides options that control what kind of accessors are generated for attributes of different types. The following table enumerates the types available in the XML format, which QMF types they map to, and other special handling that occurs.
Table 2.3. XML Schema Mapping for QMF Types
| XML Type | QMF Type | Accessor Style | Special Characteristics |
| objId | REF | Direct (get, set) | |
| uint8,16,32,64 | U8,16,32,64 | Direct (get, set) | |
| int8,16,32,64 | S8,16,32,64 | Direct (get, set) | |
| bool | BOOL | Direct (get, set) | |
| sstr | SSTR | Direct (get, set) | |
| lstr | LSTR | Direct (get, set) | |
| absTime | ABSTIME | Direct (get, set) | |
| deltaTime | DELTATIME | Direct (get, set) | |
| float | FLOAT | Direct (get, set) | |
| double | DOUBLE | Direct (get, set) | |
| uuid | UUID | Direct (get, set) | |
| map | FTABLE | Direct (get, set) | |
| hilo8,16,32,64 | U8,16,32,64 | Counter (inc, dec) | Generates value, valueMin, valueMax |
| count8,16,32,64 | U8,16,32,64 | Counter (inc, dec) | |
| mma32,64 | U32,64 | Direct | Generates valueMin, valueMax, valueAverage, valueSamples |
| mmaTime | DELTATIME | Direct | Generates valueMin, valueMax, valueAverage, valueSamples |
When writing a schema using the XML format, types used in <property> or <arg> must be types that have Direct accessor style. Any type may be used in <statistic> tags.
The QMF protocol defines the message formats and communication patterns used by the different QMF components to communicate with one another.
A description of the current version of the QMF protocol can be found at ???.
A proposal for an updated protocol based on map-messages is in progress and can be found at ???.
Please see the ??? for information about using the console API with Python.
Apache Qpid, Messaging built on AMQP; Copyright © 2015 The Apache Software Foundation; Licensed under the Apache License, Version 2.0; Apache Qpid, Qpid, Qpid Proton, Proton, Apache, the Apache feather logo, and the Apache Qpid project logo are trademarks of The Apache Software Foundation; All other marks mentioned may be trademarks or registered trademarks of their respective owners


A Little About Me
I'm currently a student at Code Fellows. I've studied a few other places before as well, but for most of the past 4 years I've been in the workforce. I recently decided to go back to school to study software development so I can spend my working career doing something I love every day: solving problems with code!
Experience
- Faithlife Corporation | Production Manager | June 2016 - Dec. 2018
- Faithlife Corporation | Latin Language Editor | May 2015 - June 2016
Education
- Code Fellows | Seattle, WA
- Our Lady of Guadalupe Seminary | Denton, NE
- Hillsdale College | Hillsdale, MI
- Universität des Saarlandes | Saarbrücken, Germany
Some Favorite Subjects I've Studied
Guessing Game Questions
- Want to play a guessing game?
- Think I'm younger than 20?
- Think I'm younger than 25?
- Think I'm younger than 30?
- Think I'm one of the following ages?
Top 10 Favorite Countries I've Visited
- Germany
- Belgium
- Iceland
- Hungary
- France
- Italy
- Mexico
- Luxembourg
- Austria
- Slovakia


Use this tool to find the ideal timetable for next semester
This tool has been made independently of the university, without any expectation of reimbursement.
All that we get out of making this timetable planner is the satisfaction that we've helped you make the best timetable possible for this semester.
If you find this tool useful, or even just nifty, thank us by sharing it with your friends.
Or just post it to Facebook to make your friends from Adelaide/UniSA jealous (don't worry, though, we'll try and add you guys soon)
You have {{ numPossibleTimetables }} possible timetables. To find your ideal timetable, we're going to need a little more information
Order the below list in terms of what's important to you, most important first.
Drag the preferences to sort them
Generating timetables
Auto generation found {{ numRefinedPossibleTimetables }} possible timetables.
This took {{ examineDuration }} seconds.
| Days at uni | Time at uni | Average start time | Average end time | Apply |
|---|---|---|---|---|
| {{ candidate.daysAtUni }} | {{ candidate.secondsAtUni | secondsToHours }} hours | {{ candidate.averageStartTime | secondsToTime }} | {{ candidate.averageEndTime | secondsToTime }} |
| {{ day }} | |||||
|---|---|---|---|---|---|
|
|


'Extremely relieved'...attorney for Rodney Reed exhale after court grants stay of execution
HOUSTON (AP) — The top criminal appeals court in the state of Texas, in the United States (US), yesterday halted the execution of Rodney Reed, which was scheduled to take place on Wednesday.
Reed’s attorneys and supporters, which include American celebrities Oprah Winfrey and Beyonce, say new evidence raises questions about his conviction for the 1996 killing of 19-year-old Stacey Stites.
The stay of execution by the Texas Court of Criminal Appeals came hours after the Texas Board of Pardons and Paroles recommended delaying the lethal injection the 51-year-old Reed was scheduled to receive.
Prosecutors say he raped and strangled Stites as she made her way to work at a supermarket in Bastrop, a rural community located about 30 miles southeast of the Texas capital, Austin.
Lawmakers from both parties, including Republican Senator Ted Cruz, have also asked that officials take a closer look at the evidence in the case.
The appeal court, in its four-page order, said Reed’s case should be returned to the trial court in Bastrop County so it could examine his claims that he is innocent and that prosecutors suppressed evidence and presented false testimony.
Bryce Benjet, an attorney with the Innocence Project, which is representing Reed, said defence attorneys were “extremely relieved and thankful.”
“This opportunity will allow for proper consideration of the powerful and mounting new evidence of Mr Reed’s innocence,” Benjet said in a statement.
The Texas Attorney General’s Office declined to comment Friday on whether it would appeal the ruling.
Before the ruling was handed down, the parole board had unanimously recommended a 120-day reprieve for Reed.
The board rejected Reed’s request to commute his sentence to life in prison.
The parole board’s decision was to go to Governor Greg Abbott, who has not said whether he would accept or reject it or do nothing.
The court order likely makes Abbott’s decision moot.
Since Texas resumed executions in 1982, only three death row inmates have had their sentences commuted to life in prison by a governor within days of their scheduled executions.
Reed has other appeals pending, including with the US Supreme Court.
He has long maintained he did not kill Stites and that her fiancé, former police officer Jimmy Fennell, was the real killer.
Reed, who is black, says Fennell was angry because Stites, who was white, was having an affair with him.
Fennell’s attorney has said his client did not kill Stites.


All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary.
There are many variations of passages of the have suffered in some form.
We are life saviour


College
All Colleges
| # | Abbreviation | Full Name | SAT Max Score | SAT Min Score | GPA Max Score | GPA Min Score | ACT Max Score | ACT Min Score | ||
|---|---|---|---|---|---|---|---|---|---|---|
| {{ loop.index }} | {{ college.college_name_short }} | {{ college.college_name_full }} | {{ college.sat_max_score }} | {{ college.sat_min_score }} | {{ college.gpa_max_score }} | {{ college.gpa_min_score }} | {{ college.act_max_score }} | {{ college.act_min_score }} |


An overlay tunnel encapsulates IPv6 packets in IPv4 packets for delivery across an IPv4 infrastructure. By using overlay tunnels, you can communicate with isolated IPv6 networks without upgrading the IPv4 infrastructure between them. Tunnel endpoint must support both IPv4 and IPv6 protocol stacks. IPv6 supports the following type of overlay tunneling mechanisms:
We will address Manual, GRE, and IPv4 compatible briefly here, while 6to4 and ISATAP are covered in later articles.
The above diagram will be a recurring topic as we study IPv6 in IPv4 tunneling. We have two IPv6 hosts separated by an IPv4 only transit network. How can we get the two IPv6-only hosts to communicate with each other.
We would use a manual tunnel in situations where the routers are static and regular IPv6 communication is needed to pass between the routers, as might be the case with Edge routers. To create the tunnel, you assign an IPv6 address to the tunnel, and you use the IPv4 addresses for the tunnel source and tunnel destination. Below would be a sample configuration to create a manual IPv6 tunnel.
`R1(config)#interface tunnel 0
R1(config-if)#ipv6 address 2001:13::1/64
R1(config-if)#tunnel source fastethernet0/0
R1(config-if)#tunnel destination <IP_ADDRESS>
R1(config-if)#tunnel mode ipv6ip
R1(config-if)#ipv6 rip CCIERIP enable
R1(config-if)#end
R3(config)#interface tunnel 0
R3(config-if)#ipv6 address 2001:13::3/64
R3(config-if)#tunnel source fastethernet0/0
R3(config-if)#tunnel destination <IP_ADDRESS>
R3(config-if)#tunnel mode ipv6ip
R3(config-if)#ipv6 rip CCIERIP enable
R3(config-if)#end
` Pretty easy, almost like a GRE tunnel, we are just using the IPv4 addresses as the tunnel source and destination, but declaring the tunnel mode as 1ipv6ip.
IPv6 tunneling over GRE is just as easy as the manual tunnels we saw above. Really the only reason this is needed vs the manual method is if you are using IS-IS, as IS-IS requires the use of the protocol field of the GRE header that allows identification of the passenger protocol.
We will use the same topology as before.
Router 1
`R1(config)#ipv6 unicast-routing
R1(config)#interface loopback 0
R1(config-if)#ipv6 rip CCIERIP enable
R1(config-if)#exit
R1(config)#interface tunnel 0
R1(config-if)#ipv6 address 2001:13::1/64
R1(config-if)#tunnel source fastethernet0/0
R1(config-if)#tunnel destination <IP_ADDRESS>
R1(config-if)#tunnel mode gre ip
R1(config-if)#ipv6 rip CCIERIP enable
R1(config-if)#end
`Router 3
`R3(config)#ipv6 unicast-routing
R3(config)#interface loopback 0
R3(config-if)#ipv6 rip CCIERIP enable
R3(config-if)#exit
R3(config)#interface tunnel 0
R3(config-if)#ipv6 address 2001:13::3/64
R3(config-if)#tunnel source fastethernet0/0
R3(config-if)#tunnel destination <IP_ADDRESS>
R3(config-if)#tunnel mode gre ip
R3(config-if)#ipv6 rip CCIERIP enable
R3(config-if)#end
` You can see that the GRE tunnel also uses IPv4 addresses as the tunnel source and destination. Really, the only difference is the tunnel mode is gre ip as compared to ipv6ip.
This is not a Cisco recommend tunnel type, though it is supported in IOS. As compared to Manual tunnels and GRE tunnels above, IPv4-compatible tunnels are point-to-multipoint where the previous two are simple point-to-point.
Automatic IPv4-compatible tunnels use IPv4-compatible IPv6 addresses. IPv4-compatible IPv6 addresses are IPv6 unicast addresses that have zeros in the high-order 96 bits of the address, and an IPv4 address in the low-order 32 bits. They can be written as 0:0:0:0:0:0:A.B.C.D or ::A.B.C.D, where “A.B.C.D” represents the embedded IPv4 address.
The tunnel destination is automatically determined by the IPv4 address in the low-order 32 bits of IPv4-compatible IPv6 addresses. The host or router at each end of an IPv4-compatible tunnel must support both the IPv4 and IPv6 protocol stacks. IPv4-compatible tunnels can be configured between border-routers or between a border-router and a host. Using IPv4-compatible tunnels is an easy method to create tunnels for IPv6 over IPv4, but the technique does not scale for large networks.
The configuration for this is similar to the above tunneling mechanisms. You do not specify a tunnel destination, and the tunnel mode is ipv6ip auto-tunnel.
Cisco recommends using ISATAP tunnels when considering this type of solution.
These are point-to-multipoint tunnels that can be used to connect isolated IPv6 sites. It uses an address space of 2002::/16.
These are point-to-multipoint tunnels that can be used to connect systems within a site. It can utilize any IPv6 unicast address.


| Next Slide | space |
| Speaker Notes | S |
| Fullscreen | F |
| Black Screen (Toggle) | . or B |
Nico Berio LeBeau, Logan Moore, Lucas Pickering
Create an algorithm to automatically solve a puzzle using edge fitting.
Trying to complete a puzzle by hand
Wondered what the time complexity of us completing the puzzle by hand would be
"Human Algorithm"
$$$$
$$x=\frac{-b\pm\sqrt{b^2-4ac}}{2a}$$
function linkify( selector ) {
if( supports3DTransforms ) {
var nodes = document.querySelectorAll( selector );
for( var i = 0, len = nodes.length; i < len; i++ ) {
var node = nodes[i];
if( !node.className ) {
node.className += ' roll';
}
}
}
}
Code syntax highlighting courtesy of highlight.js.
These guys come in two forms, inline:
“The nice thing about standards is that there are so many to choose from”
and block:
“For years there has been a theory that millions of monkeys typing at random on millions of typewriters would reproduce the entire works of Shakespeare.


{% extends '_base.html' %} {% block title %}Authorise GitHub{% endblock %} {% block main %}
Click below to allow this service to interact with GitHub.
The authorisation will only be used for any purposes that you explicitly enable.


&$556;
Fortress North Gate
Fortress South Gate
Dion Town Square
Giran Town Square
The Ant Nest - 500
Windawood Manor - 500
Dragon Valley - 500
Tanor Canyon - 500