If you find it useful, consider starring the project 💪 and/or following its author ❤ -there's more on the way!
Requires docker
to be installed on your system.
To install poseup globally, run: npm install -g poseup
Poseup leverages docker-compose
with the goal of making having a containerized development and test workflow trivial. It is governed by a poseup.config
file that can be used as a single source of truth, as poseup is also able to generate traditional docker-compose
files from it.
Ultimately, it is an effort to fix the most common issues with similar solutions, which tend to be:
docker-compose
, making it difficult to have a single source of truth.In contrast with other solutions, poseup integrates seamlessly with docker-compose
and its configuration format. Mostly as a product of it, poseup is able to:
poseup run
.exec
.environments
.docker-compose
configuration files from its own poseup.config
-see poseup compose
.docker-compose
commands, hence allowing for a high degree of flexibility -see poseup compose
.poseup
options runs docker-compose
as per your poseup.config
file.poseup run
is a task runner for docker.poseup clean
cleans all non persisted containers.poseup purge
purges volumes, networks, and images from your system.poseup.config
file.poseup
optionsUsage:
$ poseup [option]
$ poseup [command] [options]
Options:
-d, --dir <dir> Project directory
-f, --file <path> Path for config file [js,json,yml,yaml]
-e, --env <env> Node environment
--log <level> Logging level
-h, --help Show help
-v, --version Show version number
Commands:
compose Runs docker-compose
run Runs tasks
clean Cleans not persisted containers and networks -optionally, also volumes
purge Purges dangling containers, networks, and volumes system-wide
Examples:
$ poseup --log debug compose -- up
$ poseup -d ./foo -e development clean
log
Sets logging level. Can be one of silent
, trace
, debug
, info
, warn
, error
.
Example: poseup --log debug clean
file
Sets the poseup configuration file as an absolute or relative path to cwd. By default, poseup will attempt to find it in the project directory -if passed- or cwd, and up.
Example: poseup --file ../poseup.development.js compose -- up
dir
Sets the project directory for docker as an absolute or relative path to cwd. By default, it is the directory where the poseup configuration file is found.
Example: poseup --dir ../ compose -- dowm
env
Assigns an arbitrary value to process.env.NODE_ENV
.
Example: poseup --env development compose -- up
The above would be equivalent to NODE_ENV=development poseup compose -- up
poseup compose
Runs docker-compose
as per the services defined in your poseup.config
or, alternatively, produces a docker compose file from the compose
object of your poseup configuration.
Example: poseup compose -- up
Usage:
$ poseup compose [options] -- [dockerArgs]
Runs docker-compose
Options:
-w, --write <path> Produce a docker compose file and save it to path
-s, --stop Stop all services on exit
-c, --clean Run clean on exit
--dry Dry run -write docker compose file only
-h, --help Show help
docker-compose
fileTo generate a docker-compose
compatible file, you can just run: poseup compose --dry --write docker-compose.yml
.
If your poseup.config
configuration depends on NODE_ENV
, you could just run poseup compose -e development --dry --write docker-compose.development.yml
to get the docker-compose
configuration for the development
environment.
poseup run
A task runner. Runs a task or a series of tasks -defined in your poseup.config
- in a one off primary container while starting its dependent services, or in a single use sandbox -which creates new containers for the task runner and all its services, and removes them after the task has finished execution.
Usage:
$ poseup run [options] [tasks]
Runs tasks
Options:
-l, --list List tasks
-s, --sandbox Create new containers for all services, remove all on exit
-t, --timeout <seconds> Timeout for waiting time after starting services before running commands [${RUN_WAIT_TIMEOUT} by default]
--no-detect Prevent service initialization auto detection and wait until timeout instead
-h, --help Show help
poseup clean
Cleans all services absent from the persist
array of your poseup.config
file.
Usage:
$ poseup clean [options]
Cleans not persisted containers and networks -optionally, also volumes
Options:
-v, --volumes Clean volumes not associated with persisted containers
-h, --help Show help
poseup purge
Shorthand for a serial run of docker volume prune
, docker network prune
, docker image prune --all
, and docker container ls --all
.
Usage:
$ poseup purge [options]
Purges dangling containers, networks, and volumes system-wide
Options:
-f, --force Skip confirmation
-h, --help Show help
A poseup configuration file is the single most important thing for you to make your poseup usage worthwhile. It contains the project name, the persisted containers, any number of tasks, and a docker-compose
configuration object containing services, volumes, and networks definition. Before you jump in, you can check out an example here.
Valid configuration files are .js
, .json
, or .yml
files, though you'll have to use a .js
file in order to be able to define different configurations depending on environment on the same file. See environments.
All poseup commands but poseup purge
(since it's system-wide) will need a poseup.config
file. You can pass the file path via the --file
flag, but otherwise, poseup will look for a poseup.config.{js,json,yml}
in the current working directory and up. Remember you can also specify a different working directory for poseup than the current on console with the --dir
flag.
Root properties are:
log
: string, optional, logging level. One of: 'silent'
, 'trace'
, 'debug'
, 'info'
, 'warn'
, 'error'
.project
: string, required, the name of the project. Note that you should never have different environment-dependent configurations for a same project name (see environments).persist
: strings array, optional, the name of the services to not clean when running poseup clean
and poseup run
. This is useful if you have services you don't want to be ephemeral, like a database, which data you'd like to keep between runs.compose
: object, required, should have the same structure as a traditional docker-compose
file. Here is where you define your services and their configuration. Having your docker-compose
configuration inside the poseup config will allow you, if desired, to have all environmental differences in a single file, while you can always generate an actual docker-compose
yaml file for any environment from it by dry running poseup compose
.tasks
: object, optional, any number of tasks to be executed via poseup run
. The keys of the task
object will be the names of your task, and each have an object as value with optional keys:description
: string, a description for the task -it'll be used when running poseup run --list
.primary
: string, the name of the service for which a new ephemeral container will be created in order to run cmd
. If no primary
is specified, cmd
will be run in your local environment -your system.services
: strings array, the names of the associated services required to run this task. If not present and a primary
service has been specified, poseup will use the services defined on the depends_on
key of the service in the compose
definition by default. If it exists, it will not merge with depends_on
, this way you can restrict or extend the required services for this task with no regard for the compose
definition. If not present and no primary
has been defined, no services will be started for the task, though that would mean you'd essentially be just running a local command, which would make little sense.cmd
: strings array, the command to execute on primary
or locally that represents the task itself. Example: ['npm', 'install']
.exec
: array | object any number of commands to execute on any of the services that are required to start when running the task -either via services
or the compose
depends_on
- before cmd
is run. Each item of the array must be an object. The keys of the object will signal the service to run the command on, meanwhile their value should be a strings array for the command. All the commands in each item of the exec
array will be executed with no guaranteed execution order, while each array item will be guaranteed to run serially:// Unordered execution example
({
tasks: {
myTask: {
primary: 'myPrimaryService',
cmd: ['echo', 'foo'],
exec: [
{
// These will execute in parallel
myDbService: ['psql', '-U', 'postgres', '-c', 'CREATE DATABASE testdb;'],
myNodeService: ['npm', 'install']
}
]
}
}
});
// Unordered execution example (equivalent to the previous)
({
tasks: {
myTask: {
primary: 'myPrimaryService',
cmd: ['echo', 'foo'],
exec: {
// These will execute in parallel
myDbService: ['psql', '-U', 'postgres', '-c', 'CREATE DATABASE testdb;'],
myNodeService: ['npm', 'install']
}
}
}
});
// Series example: guaranteed execution order
({
tasks: {
myTask: {
primary: 'myPrimaryService',
cmd: ['echo', 'foo'],
exec: [
// These will execute in series
{ myDbService: ['psql', '-U', 'postgres', '-c', 'CREATE DATABASE testdb;'] },
{ myNodeService: ['npm', 'install'] }
]
}
}
});
There are two strategies you can follow in order to define different configurations for several environments.
It's important to keep in mind, regardless of the strategy you use, poseup will treat any configuration with the same project name as if they were the same. What that means is you need to make sure that, for different configuration values, the project name in your poseup.config
file is distinct, otherwise things could get quite messy. That being said:
poseup.config
files and pass them to poseup depending on the one you desire to apply via the --file
flag,poseup.config
that defines a different configuration as per any arbitrary number of environment variables.Focusing on the single JavaScript file strategy, a simple solution would be to do something like:
poseup.config.js
:
const isProduction = process.env.NODE_ENV === 'production';
module.exports = {
project: 'my-project-name' + (isProduction ? 'production' : 'development'),
persist: [ /* ...my persisted services */ ],
tasks: isProduction
? { /* ...my production tasks */ }
: { /* ...my development tasks */ },
compose: {
version: '3.4',
services: { /* ...my services */ }
}
};
Solutions like slimconf
might assist you in organizing your environment-dependent configuration.
As an example:
const { default: slim, fallback } = require('slimconf');
module.exports = slim(
{ env: [process.env.NODE_ENV, fallback('development', ['test']) },
(on, { env }) => ({
project: `my-project-${env}`,
persist: on.env({
default: [
// ...my default persisted services
],
development: [
// ...my persisted services in development
],
test: [] // all services will be ephemeral on test
}),
tasks: on.env({
default: {
// ...my default tasks
},
development: {
// ...my development tasks
},
test: {
// ...my test tasks
}
}),
compose: {
version: '3.4',
services: {
// ...my services
}
}
})
);
This example uses slimconf
to manage environment-dependent configuration.
poseup.config.js
:
const { default: slim, fallback, merge } = require('slimconf');
module.exports = slim(
{ env: [process.env.NODE_ENV, fallback('development', ['test']) },
// We're merging the defaults with the environment-dependent configuration
(on, { env }) => on.env(merge, {
/* Defaults */
defaults: {
log: 'info',
project: `my-project-${env}`,
compose: {
version: '3.4',
services: {
app: {
image: 'node:8-alpine',
depends_on: ['db'],
networks: ['backend'],
environment: {
NODE_ENV: env,
DB_URL: `postgres://postgres:pass@db:5432/testdb`
},
volumes: [{ type: 'bind', source: './', target: '/usr/src/app' }]
},
db: {
image: 'postgres:11-alpine',
networks: ['backend'],
environment: { POSTGRES_PASSWORD: 'pass' }
}
},
networks: { backend: {} },
volumes: {}
}
},
/* Development environment */
development: {
// We'll persist the database on development (won't be removed on poseup clean)
persist: ['db'],
tasks: {
// This will run "node index.js" locally after "db" is up.
// We'd run it with: poseup run local
local: {
services: ['db'],
cmd: ['/bin/sh', '-c'].concat('cd /usr/src/app && node index.js')
},
// This will run "node index.js" in a docker container ("app").
// Since app already depends on "db", we don't need to define it.
// We'd run it with: poseup run docker
docker: {
primary: 'app',
cmd: ['/bin/sh', '-c'].concat('cd /usr/src/app && node index.js')
},
// This will just setup the database for usage on development.
// As we are persisting the container, it's a one-off task.
bootstrap: {
services: ['db'],
exec: {
db: 'psql -U postgres -c'
.split(' ')
.concat('CREATE DATABASE testdb;')
}
}
},
compose: {
// We'll also expose ports
services: {
app: { ports: ['3000:3000'] },
db: { ports: ['5432:5432'] }
}
}
},
/* Test environment */
test: {
tasks: {
// We'd run it with: poseup run -e test jest
jest: {
primary: 'app',
cmd: ['/bin/sh', '-c'].concat('cd /usr/src/app && npx jest'),
// Create database before running tests
exec: {
db: 'psql -U postgres -c'
.split(' ')
.concat('CREATE DATABASE testdb;')
}
}
}
}
})
);
poseup exports compose
, run
, clean
, and purge
, which are called by the equally named CLI commands.
However, when running poseup on the CLI, the program will also listen to termination events through exits
and run cleanup tasks either at end of execution or termination signals. In order to handle these cleanup tasks, you have two options:
Generated using TypeDoc


Invoices And Payments
RECEIPT
# {{ receipt.pk}}
Sona Compund, Old Agra Road
Malegaon
Received from {{ receipt.invoice.inward_order.customer }} the amount of {{ receipt.payment.amount}} for the invoice # {{ receipt.invoice.pk }} on {{ receipt.created.date }} by {{ receipt.created_by.name }}


JJ'Angel's Sweets and Catering
4900 W. Rice st. | Chicago, IL 60651 |<PHONE_NUMBER>
Toggle navigation
JJ'Angel's Sweets and Catering
Home
Services
Menu
Contact
Our
Menu
Brunch Options
Scrambled Eggs
Inquire for pricing | Include any of the following: Cheddar Cheese Red Peppers Mushrooms Substitute egg beaters +2 | Full Pan Half Pan
Pancakes
Inquire for pricing | Full Pan Half Pan
Sausage (link or patties)
Market | Choice of: Pork or Turkey
Bacon
Market | Choice of: Pork or Turkey Inquire
Hash Browns
Inquire for pricing
White Rice
Inquire for pricing
Grits
Inquire for pricing
Biscuits
Inquire for pricing
Read More
Entrees
Ham
Choice of: Honey baked or Smoked | Whole Market Half Market
Chicken
$1 per piece mixed | Choice of: Baked, Fried, Smoked, Jerk, Smothered, BBQ | Full Pan $60 Half Pan $30
Fish (Catfish, Tilapia, Swai)
Choice of: Baked, Fried, Smoked, Jerk | Full Pan $70 half Pan $35
Turkey
Choice of: Roasted, Fried, Smoked, Jerk | 10-12lb $40 14-16lb $50 20lb+ $60
Chops (Pork or Turkey)
Market | Choice of: Fried, Grilled, Jerk, Smothered
Hotlinks (Hot or Mild)
Choice of: Pork, Beef or Turkey | Pork (Full Pan) $65 Pork (Half Pan) $35 Beef $2 per link Turkey $2.25 per link
Meatloaf
Choice of: Beef, Vegetarian or Turkey | Full Pan $60 Half pan $30
Rib Tips
Choice of: Pork or Turkey | Pork (Full Pan) $60 Pork (Half Pan) $30 Turkey (Full Pan) $65 Turkey (Half Pan) $35
Ribs
Market | Choice of: Pork or Beef
Beef Short Ribs
Market
Read More
Sides
Mac & Cheese
Baked 7 Cheese | Full Pan $60 Half Pan $30
Greens
Choice of: Collard, Mustard, Turnip or Kale | Full Pan $55 Half Pan $30
Green Beans
Full Pan $50 Half Pan $25
Cornbread Dressing
Full Pan $55 Half Pan $30
Candied Yams
Full Pan $50 Half Pan $30
Spaghetti or Mostacholi
Choice of: Ground Beef, Ground Turkey, Plain or Vegetarian | Full Pan $60 Half Pan $30
Lasagna
Choice of: Beef, Turkey or Vegetarian | Full Pan $70 Half Pan $40
Baked Beans
Full Pan $60 Half Pan $30
Cellentini Pasta Alfredo
Full Pan $55 Half Pan $30
Mashed Potatoes
Full Pan $55 Half Pan $30
Potato Wedges
Choice of: Boiled, Roasted or Fried | Full Pan $55 Half Pan $30
Corn on the Cob
$1 per ear
Rice Pilaf or Dirty Rice
Dirty Rice made with Turkey or Beef | Full Pan $65 Half Pan $30
Read More
Breads
Dinner Rolls
$0.75 each | Homemade yeast rolls
Cornbread Muffins
$0.50 each
Cornbread
Full Pan $40 Half Pan $20
Read More
Desserts
Peach Cobbler
Mini $12 Half Pan $30 Whole Pan $60
Cheesecakes
Original $25 Sweet Potato $30 Banana Pudding $30
Pies
Apple $15 Sweet Potato $15
Cakes
Carmel $30 German Chocolate $35 Pound Cake $30 Crown Royal (21+) $30 Rum Cake (21+) $30 | Many other cake options available, please inquire!!
Gourmet Cookies
$8 a dozen | Banana Pudding Butter Chocolate Chip Rum Crown Royal Peanut Butter Red Velvet Oatmeal Raisin | Walnuts $1 Pecans $1 Craisins $1
Read More


Welcome to tinyweb
This is the home page, for tinyweb v3.
Link to files:
index.html
copyright.html
happynewyear2014.html
Link to actions:
/404
/user/query?author=liigo
/any/other/pathinfo?query=strings&id=123
Image:
Octet stream:
Pawn_Language_Guide.pdf
CookTime.apk (Remote link)


NYC Restaurants Inspections
Toilet violations across boroughs
Do you want to see some more violations?
Click Me!


Copy the contents of the dataset into the storage container that has been created for you. You may use one of these tools, along with the tokens below, to move the dataset contents into the storage container:
Retreive a token that can be used to access the storage container for the updated dataset contents, or a token for the original storage container (if you need to copy some of the original content).


I am currently in the final year of the Bachelor of Technology, from G.G.S.I.P.U. I have done the course for the Android Development and teaching my self the Web Development from freecodecamp.
I would really like to develop android apps and make the websites, as it had always inspired me to be creative and living.I had always been learning and keep updating myself about various tech advancements.
I had now started learning machine learning also and actively seeking the employment in the above stated divisions.
Here I would be using machine learning to Predict 6-month price movements based fundamental indicators from companies' quarterly reports.
calculator using Javascript and CSS3. CSS3 box shadows are used to create the 3D effect and transitions are used for the smooth press effect. Basic regex is used for validations and text replacements
The music app would be able to have distinctive design with its own equilizer, which is able to produce the best music experience for all the audiophiles.It would also show the Lyrics by the help of using last.fm api


DigiOptions orderbook publisher + client (XMPP PubSub)
Connection status:
Disconnected
xmpp url:
pubsub path:
network:
marketsAddr:
marketHash:
Connect
Disconnect
Enter order to send:
{ "offerOwner": "0x0000000000000000000000000000000000000000", "marketsAddr": "0x0000000000000000000000000000000000000000", "marketHash": "0x0000000000000000000000000000000000000000000000000000000000000000", "buy": true, "optionID": 0, "price" :0, "size":<PHONE_NUMBER>000000000, "offerID":<PHONE_NUMBER>, "blockExpires": 1234567, "r": "0x0000000000000000000000000000000000000000000000000000000000000000", "s": "0x0000000000000000000000000000000000000000000000000000000000000000", "v": 27 }
Publish order
clear errors
Errors:
clear received orders
Last 20 order received from orderbook (including own published orders):


Controls the Inspector Panel displayed in the right hand side of the T:MacInspector.MainSplitViewController. This controller is responsible for switching out Inspector Panels as the context changes inside of the app.
More...
Controls the Inspector Panel displayed in the right hand side of the T:MacInspector.MainSplitViewController. This controller is responsible for switching out Inspector Panels as the context changes inside of the app.
Please see: https://developer.xamarin.com/guides/mac/user-interface/working-with-windows/#Inspectors https://developer.xamarin.com/guides/mac/platform-features/storyboards/quickstart/
| MacInspector.InspectorViewController.InspectorViewController |
( |
IntPtr |
handle | ) |
|
Initializes a new instance of the T:MacInspector.InspectorViewController class.
- Parameters
-
| void MacInspector.InspectorViewController.ClearInspectorPanel |
( |
| ) |
|
Removes the current Inspector Panel (View Controller
) from the screen.
| override void MacInspector.InspectorViewController.PrepareForSegue |
( |
NSStoryboardSegue |
segue, |
|
|
NSObject |
sender |
|
) |
| |
Called before a segue is launched to allow you to configure the new view controller that will be displayed.
- Parameters
-
| segue | The Segue that is about to be launched. |
| sender | The View Controller that is launching the segue. |
| void MacInspector.InspectorViewController.ReleaseDesignerOutlets |
( |
| ) |
|
|
private |
| void MacInspector.InspectorViewController.SetInspectorPanel |
( |
NSViewController |
panel | ) |
|
Sets the inspector panel.
- Parameters
-
| panel | The new Inspector Panel (View Controller ) to display. |
If the panel
is null
, the current panel is removed from the screen.
| void MacInspector.InspectorViewController.ShowBoxInspector |
( |
CustomBox |
box | ) |
|
Shows the box inspector.
- Parameters
-
| box | The T:MacInspector.CustomBox being displayed/edited. |
| void MacInspector.InspectorViewController.ShowDocumentInspector |
( |
DocumentProperties |
properties | ) |
|
Shows the document inspector.
- Parameters
-
| properties | The T:MacInspector.DocumentProperties being displayed/edited. |
| NSObject MacInspector.InspectorViewController._inspectedProperties = null |
|
private |
The backing store for the properties currently being displayed and edited.
| NSViewController MacInspector.InspectorViewController._inspectorPanel = null |
|
private |
The backing store for the currently loaded Inspector Panel.
| NSObject MacInspector.InspectorViewController.InspectedProperties |
|
getset |
Gets or sets the inspected properties currently being displayed and edited.
The inspected properties.
| NSViewController MacInspector.InspectorViewController.InspectorPanel |
|
getset |
Gets or sets the inspector panel currently being displayed.
The inspector panel.
Gets or sets the split view controller.
The T:MacInspector.MainSplitViewController this controller is attached to.
The documentation for this class was generated from the following files:


Saturday Night March 20th 2010 @ 8:30PM
123 Notreal Street Fakecity, Queen 9999
$50 Buy-In For 1500 Chips
Unlimited Rebuys During The First Hour
3000 Chip Add-On After The First Hour For $50
Blinds Up Every 15 Minutes
Refreshments Served


{% extends 'default-14.html' %} {% block header %}
Flourish! is a student-led Open Source conference hosted at the University of Illinois at Chicago. Open Source, Open Future
April 5, 2014 / Chicago, IL


Crystallographic data (Views)¶
The models that these views work on can be found in Crystallographic data (Models)
Where the views are used (frontend)¶
Note: For the Diamond instance of fragalysis, authentication is handled by api.security.ISpyBSafeQuerySet
,
a version of the standard DRF (see RESTful API (Views)) viewsets.ReadOnlyModelViewSet
.
viewer.views.TargetView
: This view is used on the landing page (e.g. https://fragalysis.diamond.ac.uk/viewer/react/landing) to populate the Target list with either open targets (if the user is not logged in) or the Target list of targets that the user is authenticated to see.viewer.views.ProteinView
: This view is used on each target specific page to populate protein information on the left-hand side (LHS)viewer.views.ProteinPDBInfoView
: This view is used to retrieve the raw pdb file info to display in the central 3D viewer when a protein for a specific ligand is turned on from the LHS when the ‘P’ button is clicked in the hit navigator.viewer.views.ProteinPDBBoundInfoView
: This view was previously used to store the bound-state information for each crystal in a target set, and the full list for each target was zipped into a file by the front-end for download with the download button in the menu bar of a target specific page. This has been replaced by serving a zip file of all of the information uploaded to fragalysis for a specific target. (see: [link])viewer.views.ProteinMapInfoView
: This view is currently un-used, but is intended to serve the raw electron density data for each ligand when the ‘D’ button is clicked for a ligand in the hit navigatorviewer.views.MoleculeView
: This view is used to retrieve 2D information about molecules - the properties in the view are displayed on each ligand card on the LHS.viewer.views.MolImageView
: This view is used to retreive the 2D image created by the loader, and display it on the LHSviewer.views.CompoundView
: This view is used to obtain the 3D coordinates for a molecule, and display them in the central 3D viewer on a target specific page when the ‘L’ button on a specific ligand card in the hit navigator is turned on.
Other views listed below are currently not in use by the front-end.
View details¶
-
class
viewer.views.
TargetView
(**kwargs)¶ DjagnoRF view to retrieve info about targets
-
url:
api/targets
-
queryset:
viewer.models.Target.objects.filter()
-
filter fields:
viewer.models.Target.title - ?title=<str>
-
returns: JSON
id: id of the target object
title: name of the target
project_id: list of the ids of the projects the target is linked to
protein_set: list of the ids of the protein sets the target is linked to
template_protein: the template protein displayed in fragalysis front-end for this target
metadata: link to the metadata file for the target if it was uploaded
zip_archive: link to the zip archive of the uploaded data
-
example output:
"results": [ { "id": 62, "title": "Mpro", "project_id": [ 2 ], "protein_set": [ 29281, 29274, 29259, 29305, ..., ], "template_protein": "/media/pdbs/Mpro-x10417_0_apo.pdb", "metadata": "http://fragalysis.diamond.ac.uk/media/metadata/metadata_2FdP5OJ.csv", "zip_archive": "http://fragalysis.diamond.ac.uk/media/targets/Mpro.zip" } ]
-
serializer_class
¶ alias of
viewer.serializers.TargetSerializer
-
-
class
viewer.views.
ProteinView
(**kwargs)¶ DjagnoRF view to retrieve bound pdb info (file) for a given protein
-
url:
api/proteins
-
queryset:
viewer.models.Protein.objects.filter()
-
filter fields:
viewer.models.Protein.code - ?code=<str>
viewer.models.Protein.target_id - ?target_id=<int>
viewer.models.Protein.prot_type - ?prot_type=<str>
-
returns: JSON
id: id of the protein object
code: the code/name of the protein
target_id: the id of the related target object
prot_type: the type of protein (e.g. AP for apo)
pdb_info: link to the apo pdb file
bound_info: link to the bound pdb file
mtz_info: link to the mtz file
map_info: link to the map file
cif_info: link to the cif file
-
example output:
"results": [ { "id": 14902, "code": "XX02KALRNA-x1376_1", "target_id": 51, "prot_type": "AP", "pdb_info": "http://fragalysis.diamond.ac.uk/media/pdbs/XX02KALRNA-x1376_1_apo_9VSCvR8.pdb", "bound_info": "http://fragalysis.diamond.ac.uk/media/bound/XX02KALRNA-x1376_1_bound_6xmXkUm.pdb", "mtz_info": null, "map_info": null, "cif_info": null },]
-
serializer_class
¶ alias of
viewer.serializers.ProteinSerializer
-
-
class
viewer.views.
ProteinPDBInfoView
(**kwargs)¶ DjagnoRF view to retrieve apo pdb info (file) for a given protein
-
url:
api/protpdb
-
queryset:
viewer.models.Protein.objects.filter()
-
filter fields:
viewer.models.Protein.code - ?code=<str>
viewer.models.Protein.target_id - ?target_id=<int>
viewer.models.Protein.prot_type - ?prot_type=<str>
-
returns: JSON
id: id of the protein object
pdb_data: If a pdb file has been uploaded for the protein bound_info.path.read()
prot_type: type of protein (e.g. AP for apo - see docs for model)
-
example output:
"results": [ { "id": 27387, "pdb_data": "REMARK warning: chains may be ommitted for alignment REMARK ...", "prot_type": "AP" },]
-
serializer_class
¶ alias of
viewer.serializers.ProtPDBInfoSerialzer
-
-
class
viewer.views.
ProteinPDBBoundInfoView
(**kwargs)¶ DjagnoRF view to retrieve bound pdb info (file) for a given protein
-
url:
api/protpdbbound
-
queryset:
viewer.models.Protein.objects.filter()
-
filter fields:
viewer.models.Protein.code - ?code=<str>
viewer.models.Protein.target_id - ?target_id=<int>
viewer.models.Protein.prot_type - ?prot_type=<str>
-
returns: JSON
id: id of the protein object
pdb_data: If a pdb file has been uploaded for the protein bound_info.path.read()
prot_type: type of protein (e.g. AP for apo - see docs for model)
-
example output:
"results": [ { "id": 27387, "pdb_data": "REMARK warning: chains may be ommitted for alignment REMARK ...", "prot_type": "AP" },]
-
serializer_class
¶ alias of
viewer.serializers.ProtPDBBoundInfoSerialzer
-
-
class
viewer.views.
ProteinMapInfoView
(**kwargs)¶ DjagnoRF view to retrieve map info (file) for a given protein
-
url:
api/protmap
-
queryset:
viewer.models.Protein.objects.filter()
-
filter fields:
viewer.models.Protein.code - ?code=<str>
viewer.models.Protein.target_id - ?target_id=<int>
viewer.models.Protein.prot_type - ?prot_type=<str>
-
returns:
If a map file has been uploaded for the protein map_info.path.read() (JSON)
-
serializer_class
¶ alias of
viewer.serializers.ProtMapInfoSerialzer
-
-
class
viewer.views.
MoleculeView
(**kwargs)¶ DjagnoRF view to retrieve info about molecules
-
url:
api/molecules
-
queryset:
viewer.models.Molecule.objects.filter()
-
filter fields:
viewer.models.Molecule.prot_id - ?prot_id=<int>
viewer.models.Molecule.cmpd_id - ?cmpd_id=<int>
viewer.models.Molecule.smiles - ?smiles=<string>
viewer.models.Molecule.prot_id__target_id - ?target_id=<int>
viewer.models.Molecule.mol_type - ?mol_type=<str>
viewer.models.Molecule.mol_groups - ?mol_groups=<int>,<int>
-
returns: JSON
id: id of the target object
smiles: smiles string of the molecule
cmpd_id: id of the related 2D compound object
prot_id: id of the related protein object
protein_code: code of the related protein object
mol_type: type of molecule - see Molecule model docs
molecule_protein: filepath of the apo protein structure for the molecule
lig_id: residue label for the ligand
chain_id: chain in the pdb file that the ligand belongs to
sdf_info: 3D coordinated of the molecule in MDL file format
x_com: x-coordinate for molecule centre of mass
y_com: y-coordinate for molecule centre of mass
z_com: z-coordinate for molecule centre of mass
mw: molecular weight
logp: LogP
tpsa: Topological Polar Surface Area
ha: heavy atom count
hacc: hydrogen-bond acceptors
hdon: hydrogen-bond donors
rots: number of rotatable bonds
rings: number of rings
velec: number of valence electrons
-
example output:
"results": [ { "id": 13912, "smiles": "CN(C)c1ccc(C(=O)Nc2ccccn2)cc1", "cmpd_id": 796, "prot_id": 13923, "protein_code": "NUDT7A_Crude-x2226_2", "mol_type": "PR", "molecule_protein": "/media/pdbs/NUDT7A_Crude-x2226_2_apo_x5GxiLq.pdb", "lig_id": "LIG", "chain_id": "Z", "sdf_info": " RDKit 3D 18 19 0 0 0 0 0 0 0 0999...", "x_com": null, "y_com": null, "z_com": null, "mw": 241.12, "logp": 2.4, "tpsa": 45.23, "ha": 18, "hacc": 3, "hdon": 1, "rots": 3, "rings": 2, "velec": 92 },]
-
serializer_class
¶ alias of
viewer.serializers.MoleculeSerializer
-
-
class
viewer.views.
MolImageView
(**kwargs)¶ DjagnoRF view for molecule images
-
url:
api/molimg
-
queryset:
viewer.models.Molecule.objects.filter()
-
filter fields:
viewer.models.Molecule.prot_id - ?prot_id=<int>
viewer.models.Molecule.cmpd_id - ?cmpd_id=<int>
viewer.models.Molecule.smiles - ?smiles=<str>
viewer.models.Molecule.prot_id__target_id - ?target_id=<int>
viewer.models.Molecule.mol_groups - ?mol_groups=<int>,<int>
-
returns:
SVG image text for query molecule generated by api.utils.draw_mol() (JSON)
-
example output:
"results": [ {"id": 13912, "mol_image": "<?xml version='1.0' encoding='iso-8859-1'?><svg version='1.1' nk'..."}]
-
serializer_class
¶ alias of
viewer.serializers.MolImageSerialzier
-
-
class
viewer.views.
CompoundView
(**kwargs)¶ DjagnoRF view for compound info
-
url:
api/compounds
-
queryset:
viewer.models.Compound.objects.filter()
-
filter fields:
viewer.models.Molecule.smiles - ?smiles=<str>
-
returns:
id: id for compound object
inchi: inchi key for compound
smiles: smiles string for compound
mol_log_p: LogP for compound
num_h_acceptors: number of hydrogen-bond acceptors
num_h_donors: number of hydrogen-bond donors
-
example output:
"results": [ { "id": 1, "inchi": "InChI=1S/C9H15NOS/c1-7(11)5-10-6-9-4-3-8(2)12-9/h3-4,7,10-11H,5-6H2,1-2H3/t7-/m0/s1", "smiles": "Cc1ccc(CNC[C@H](C)O)s1", "mol_log_p": 1.52692, "mol_wt":<PHONE_NUMBER>, "num_h_acceptors": 3, "num_h_donors": 2 },]
-
serializer_class
¶ alias of
viewer.serializers.CompoundSerializer
-
-
class
viewer.views.
CompoundImageView
(**kwargs)¶ DjagnoRF view for compound images
-
url:
api/cmpdimg
-
queryset:
viewer.models.Compound.objects.filter()
-
filter fields:
viewer.models.Molecule.smiles - ?smiles=<str>
-
returns:
SVG image text for query compound generated by api.utils.draw_mol() (JSON)
-
example output:
"results": [ {"id": 13912, "mol_image": "<?xml version='1.0' encoding='iso-8859-1'?><svg version='1.1' nk'..."}]
-
serializer_class
¶ alias of
viewer.serializers.CmpdImageSerialzier
-


Statistic available for testplans with "Show in two days statistics" option.
Here you can see failed/blocked testresults for chosen testplans.


Our scene begins with two chickens, discussing existence.
Chicken 1: Who am I and why do I want to cross the road?
Chicken 2: Verily, you want to cross the road to get to the other side.
Thus ends our reinterpretation of Waiting for Godot


--- title: 'Net Promoter Score: Using ggvis/NPS package in R' thumbnail: "/img/NPS_img.png" author: Sunita Kenner date: '2015-12-15' slug: net-promoter-score-using-ggvis-nps-package-in-r categories: - Business Science - Net Promoter Score tags: - R - NPS - ggvis - shiny ---
“How likely are you to recommend”Company A" to a friend?" is an Net Promoter Score (NPS) question (Likelihood to Recommend/LTR) which categorizes the responses(voice of the customers) under 3 camps:
| Customers | LTR_Score |
|---|---|
| Promoters | 9 or 10 |
| Passives | 7 or 8 |
| Detractors | 0 to 6 |
A customer loyalty metric introduced by Fred Reicheld, Founder of Bain & Company’s Loyalty Practice, the Net Promoter Score (NPS) is used at my work as a compass by business decision makers to understand if NPS provides an insight to what drives customers to repeat purchase, referrals, and resistance to competitor offerings. Does higher NPS mean repeat purchases? Referrals? Loyalty to brand/resistance to competitors?
This post however will not dwell on the interpretation of the NPS results for decision making (this is a subject matter for another post), but rather building a simple shiny app (first app) using ggvis and the NPS package in R authored by Brendan Rocks, which provides functions that make working with the NPS survey data easier; includes Data transformation methods, statistical properties (variance & SE), and simple inferential testing procedures. Brendan Rocks, yes ‘Rocks’ is indeed his last name, was kind enough to help out with answering some of the questions I had on the NPS functions. Thank you Brendan.


OkiSelect replaces real browser's select. Single and multiple version is supported. You can also use keyboard for searching option inside list.
Below basic usage with default template.
Try searching using keyboard and navigation by arrows:
If option selection was changed inside real select you need to call sync method. In below example real select was forced to be visible. OkiSelect hides it inside div with zero height and overflow hidden - <select> itself remains visible. It is important because some browsers don't fire key events on hidden form widget. OkiSelect uses that event for searching.
If you need to change apperance of the OkiSelect just add you own css class and override default rules. Class can be added by two ways:
Complex mode is helpfull when your select's graphic project cannot be represented by only css. Cloud have more html tags for placing images inside


--- layout: post title: '' categories: - "未分類" tags: [] status: draft type: post published: false meta: _edit_last: '3' author: login: yokoshima email<EMAIL_ADDRESS>display_name: yokoshima first_name: '' last_name: '' ---
http://wordpress.org/extend/plugins/tinymce-advanced/


Cubeacon Reference Class References CBBeacon CBBeaconManager CBBluetoothManager CBRegion Cubeacon Protocol References CBBeaconManagerDelegate CBBluetoothManagerDelegate Constant References CBAuthorizationStatus CBBluetoothState CBLogLevel CBProximity CBRegionState


Just back from an excellent morning watching @shanselman on .Net 4 and ASP.Net MVC. Cool new stuff coming down the pipe with VS2010.
4/13/2010, 1:44:08 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Just back from an excellent morning watching @shanselman on .Net 4 and ASP.Net MVC. Cool new stuff coming down the pipe with VS2010.
4/13/2010, 1:44:08 PM
Favs: 0
Retweets: 0
link


This example animates a motion of a detailed model of the robot with predefined axes' angles over time. For animation, CAD data is used. Translate and simulate with the default settings (default simulation stop time = 2 s).
The path planning block incorporates a simulation termination condition. Thus, the simulation can be terminated before reaching the stop time. The condition depends on the start and end positions of the joints, and on their reference speeds and reference accelerations. For current settings, the termination condition should indeed be fulfilled right before the simulation stops.


Llucas Sprint01
These are the sprint archives/summaries of Anthony Beck. Anthony is a part time (60% Full Time Equivalence (FTE)) researcher on the Leverhulme Trust funded project Sustaining Urban Habitats - an interdisciplinary approach led by Prof Darren Robinson.
These documents represent an archive of the work undertaken by Ant.
Unless stated otherwise these documents are released under a CC0 (+BY). This means that it is essentially in the public domain and you can re-use it in an unfettered way. I would, however, appreciate, but not mandate, a reference.
Sprint 01 2nd Feb - 13th Feb 2015
A general orientation sprint. With the following sub-tasks:
- Workshops
- Wednesday 11th Feb
- Notes available in mindmap in /home/arb/ownCloud/Nottingham/LLUCAS/Workshops
- Create content for and deliver project web-page (need a landing page for phds)
- Required approval from the CMS moderators to attend the course:
- Engineering
- Jemma Higney
- +44 115 84 67556
-<EMAIL_ADDRESS>- Jemma Higney
- Geography
- Claire Chambers
- +44 115 84 67905
-<EMAIL_ADDRESS>- Claire Chambers
- Engineering
- Required approval from the CMS moderators to attend the course:
- Data needs/awareness
- Learn about Insmart from Gavin Long - help to climb learning curve
- Request for access to AddressBase for the Nottingham area submitted to OS, approved and data in the post!
- Develop short-term plan for me
- Described in /home/arb/ownCloud/Nottingham/LLUCAS/Sprints/Sprint01/ARB_ProofOfConceptProject.md
- Create two project summaries for MSc project using AddressBase (one to emulate InSMART).
- Described in /home/arb/ownCloud/Nottingham/LLUCAS/Sprints/Sprint01/ABPMScprojects.md
Tasks rolled over for the next sprint
- Infrastructure - software environment, processing and repository
- Other longer term data repository issues Darren is involved in
- contact David Holland and Isabel Sargent @ OSGB.
- Mention my name and ask if they can discuss what has been happening with their 3D city models research. I know Bournemouth was well covered in research (10 years ago ish) but it would be great to find out if/where this has been rolled out to. Also if they have plans could we ask they consider Nottingham etc. I have not kept up with what has been happening in Photogrammetric Services at OS (and what LiDAR they have been looking at) and so would be good to know.
Retrospective
A general review of thoughts/issues etc that summarise outcomes from the sprint and to take forward to the next sprint.
What went well?
- Building up relationships with people
- Gavin Long
- Lauren Halsted
- John Milner (Systems Development Officer - Geography)
- Accessing Address base data from OS
- Potential MSc student (Jordan Clydesdale) to look at AddressBase elements in InSMART
What have we learnt?
- We can add some value to the housing metric produced by Gavin Long in terms of processing of O/S MasterMap data and integration of AddressBase Premium
- If the RSS rendering of external content is reasonable then internal CMS system may be OK
- The repository landscape has, inevitably, improved in the last few years: The EU FP7 project Zenodo is a good example
What could we do better?
- There seems to be some uncertainty in terms of collaborative environments and sharepoint use with the university - this is likely to get worse for users outside the Nottingham domains.
What still puzzles us?
- What is going on in the university in terms of data repositories, open science, collaborative working (sharepoint?)
- Additionally how any developments can be used externally
- Workflows. Jeremy said to get in touch with Didier Libervichy. He is a spatial statistician working on quality and uncertainty issues in workflows.
- Databases - Oracle/Postres/Nosql - where to go. What to use
- How does the CMS system deal with harvesting content from external or internal systems (bibliographies, papers, sharepoint, slideshare) and promoting content on other frameworks (twitter, facebook (please have some automated system so I don;t have to do anything in facebook))
What is blocking activity
- CMS training - I am booked for April and have flagged a position for any Feb/March dropouts. This is unlikely to match to Darrens timeframe.
- Jemma has kindly agreed to host content until training has been approved.
- I need to discuss with Darren what the external hosting requirements are. Are we going to put content in slideshare, scribd, youtube, mendeley/zotero? If we are, then we should get a shortlist of the ones we will use so that the Web Team can see how they can render any data in an RSS feed.
- An external landing page url. http://llucas.info/
- For the MSc student we would need Darrens approval.
Task summary
Create content for and deliver project web-page (need a landing page for phds)
Content has been created for the website in /home/arb/ownCloud/Nottingham/LLUCAS/Sprints/Sprint01/20150204LLUCASWebsite_Content.md with supporting images in /home/arb/ownCloud/Nottingham/LLUCAS/Sprints/Sprint01/Outputs. These have been passed over to Darren for review. This should make it significantly easier for me to hand this content over to someone to put onto the website (if I am not allowed to self host).
I have been booked on the April course but have flagged to see if a position will become available
General CMS fitness for purpose
I have spoken to John Mitchell and Jemma to try to determine what the CMS does and need to determine if it is fit for what the project wants to do.
Like any CMS it should provide an easy way to host text and content supported by a backend database. The issues come when we consider the following:
- University branding
- URL of any landing page
- Social media integration
- If the system can be extended (plugins)
- Licensing
- Automated harvesting of other content on the web
The last two points are probably the most important.
Keeping everything in the university CMS has some advantages - particularly in terms of longevity and archiving after the project concludes. However, if we need to hand-crank pages and content because we can't harvest information stored elsewhere on the web (such as project twitter feeds, documents on scribd, presentations on slideshare, etc. ) then it becomes a burden.
Availability of funcationality provides us with 3 options:
- Use the university CMS
- Host our own CMS infrastructure internally (this might be unlikely - although there are internal websites that use their own CMS)
- Host our own CMS infrastructure externally
I had a meeting with Jemma on 20150209 to discuss these issues.
Branding
As this is a project there are no major branding restrictions
Landing page
This is flexible: We can buy our own unique url and point to this from an internal host.
I would recommend this - this means we can use something internally and point to the external link. If the CMS does not do what we want we have the flexibility to change this external page in any way we saee fit. http://llucas.info/ is free.
Archiving
If we host externally at project completion we can scrape the external site and host back within Nottingham (or deposit in the British Library).
Social media
The current CMS supports LinkedIn and Twitter connections. There is no internal demand for facebook (which I think is a good thing).
Automated harvesting of content
Jemma said this is not supported by the CMS. Although the CMS does have some plugins and can be extended. I followed this up with the web-team (Jemma said to speak to David Aldred, but I ended up speaking to one of his colleagues who was very helpful). They said they have an RSS feed reader that can be used to render content from external systems - this may be perfect. However, we do need to see examples of how this content would be rendered.
Requirements - make a list of external hosting services for content.
Licensing
There doesn't seem to be any strategy on licensing.
As we are starting to generate content, including illustrations, we should also consider what we are going to do with this content. I would strongly advocate that any original content is hosted on Wikimedia commons under either a CC-BY or a CC0 (+BY) licence. Where there is a clear author then let them place it on there on user account. Where it is unclear host it on a project account. I would also recommend embedding the licence and attribution into the image or graphic - this means that re-users are encouraged to leave it in (and thereby reference the source - completing their side of the licence bargain). This is how I have started to host my more recent content on wikimedia commons (see Figure \ref{SQLJOIN}).
Infrastructure
Caveat - we could take everything outside of university infrastructure. I have made the assumption we want to do everything in collaboration with the university. If there are too many compromises then we can review this.
Data and server environments - this would be best co-ordinated with the virtualisation farm. This is managed by Chris Parry (who is head of partnering and has responsibility for the university data repository<EMAIL_ADDRESS>- +44 115 84 13196). A meeting will be convened with Chris.
Internal Workflow environments. Jeremy said to get in touch with Didier Libervichy. He is a spatial statistician working on quality and uncertainty issues in workflows.
Email to Chris Parry
Title: University Data Repositories
Dear Chris,
John Milner passed me your details.
My name is Anthony Beck I am a recently appointed part-time Research Fellow on the Leverhulme Trust funded project Sustaining Urban Habitats - an interdisciplinary approach led by Prof Darren Robinson. I started last week.
As part of this project we are planning on building a data repository and data processing environment (distinguishing between our archiving and metadata commitments and our data processing requirements). On my last project I built a CKAN based data repository with a rich metadata environment - I am in negotiation with Leeds library about migrating this over to their new institutional repository and minting DOIs for the different research objects. I digress.
I appreciate that this is a rapidly changing area - especially as RCUK and the funding councils develop guidance. To avoid re-inventing the wheel I would like to find out:
- what data repository and analysis initiatives are ongoing in the university
- get guidance in terms of university approved licensing and metadata options
- what accreditation systems may be in place (I'm trying to avoid this as much as possible by taking an Open Science route).
I am also interested in what collaborative tools are available in and supported by the university (from desktop (using sharepoint, google docs, markdown, etc.) to analysis (taverna, alteryx)) and the server platforms for hosting such services (virtual, static etc.).
The project does have resources to contribute to some/all of these activities.
Would it be possible for you to point me in the direction of any supporting information for these activities. Alternatively we could meet up (I appreciate you are likely to have a busy schedule). I work 3 days a week (Monday to Wednesday).
I will follow this message up with a call.
Best wishes
Ant
Data needs/awareness
The OS have kindly given us access to AddressBase Premium and AddressBase Plus
Chat with Gavin - summarise
Accessing AddressBase Premium
AddressBase Premium will add some significant value to the housing work. AddressBase Premium (ABP) as a product is managed by Geoplace a consortium of Ordnance Survey and Local Government. Unfortunately, there is no direct mechanism in place to access ABP directly for academic research. Some of the issues and solutions are described in Karl Hennerman's blog. The upshot is we need to send a brief e-mail to Ordnance Survey<EMAIL_ADDRESS>requesting access to the data.
Email to OS
To whom it may concern,
Request for academic use of AddressBase Premium and AddressBase Plus data from within the city of Nottingham boundary for use within the InSMART and Sustaining Urban Habitats projects at Nottingham University.
Principal Investigator: Prof Darren Robinson
Theme Leaders: Dr Doreen Boyd and Jeremy Morley
Data Contact: Dr Anthony Beck<EMAIL_ADDRESS>The InSMART project brings together cities, scientific and industrial organizations in order to implement a comprehensive model for enhancing sustainable planning addressing the current and future city energy needs through an integrative and multidisciplinary planning approach. This approach will identify the optimum mix of short, medium and long term measures for a sustainable energy future, addressing the efficiency of energy flows across various city sectors with regards to economic, environmental and social criteria and paving the way towards actual implementation of priority actions.
Extensive technical expertise and specialised tools and models will be used to create a platform for implementation of the project idea. The approach will be used by four city partners in Greece, Italy, the UK and Portugal, all actively involved in developing a more sustainable energy system. Each city’s energy system will be analysed, covering all relevant sectors and a comprehensive GIS energy database will be developed. Apart from being a valuable planning tool the GIS database will inform and be linked to the TIMES energy systems model. This will be used to analyse the cost-optimal mix of measures required to meet sustainable energy targets taking into account exogenous parameters (e.g. environmental targets, city expansion). These measures will be further assessed with respect to non-technical criteria using a multi-criteria decision making method (PROMITHEE) that will address economic, environmental as well as social issues.
The Nottingham component of this research project utilises National Land and Property Gazetteer (NLPG) data provided by the Nottingham City Council. The NLPG data is now exposed through the AddressBase family of data provided by Geoplace. By using AddressBase Premium and AddressBase Plus products the InSMART project will be able to build a more scalable research platform that can be seamlessly applied to different UK cities and respond to data changes more effectively (by applying epoch based Change only Updates).
These benefits will also apply to the Sustaining Urban Habitats project (website is currently under construction). Sustaining Urban Habitats: An Interdisciplinary Approach is funded by a prestigious Leverhulme Programme Grant. The ambitious aim of this project is to transform our understanding of how sustainable cities, and by extension our species, can be. This project commenced in early 2015 and will complete in 2019.
AddressBase data will prove to be a crucial resource for the Measurement and Data themes in this project.
I look forward to hearing from you. If you require further information on either project please do not hesitate to ask.
Yours sincerely
Anthony Beck
Research Fellow: University of Nottingham.
Bob Barr and core reference geographies
Karl's website had a reference to Bob Barr and ABPREM which I followed up. I know Bob had a pop at the UK addressing infrastructure and sees addresses as a Core Reference Geography. These are geographic datasets which:
- Are definitive
- Should be collected and maintained once and used many times
- Are Natural monopolies
- Have variable value in different applications
- Have highly elastic demand
He argues that the following are candidate core reference geographies:
- Geodetic Framework
- Topographic Mapping (including height)
- Geographic Names
- Addresses
- Streets
- Land and Property Ownership
- Hydrology / Hydrography
- Statistical Boundaries
- Administrative Boundaries
Much of this data is already available and collected by Public Bodies (some of whom may be independent trading arms - such as the Ordnance Survey). Some of these data may already being opened up as part of the UK governments Open Data agenda. Some of this data is very relevant to the projects. This is tied in with the view of Business Innovation and Skills and their white paper on An open National Address Gazetteer.
Modelling
We need data that will support the following modelling exercises (which in turn go through the simulations environments)
- Model
- Building
- Energy demands
- Multi modal transport
- 4 stage modelling
- 6 stage modelling
- District heating networks
- Demands from LV networks
- Demands from storage
- Model land-user transport interactions
Notes about the different general data categories
- Data differences
- Calibration data
- Evaluation data
- Sensor data
- In terms of sensoring results
- Data agencies
- Traffic count
- Ofgem
Other activities TBC
- Speak to the photogrammetry dept in Stuttgart
- Developing an ADE extension to CityGML for Stuttgart
- Doreen - Speak to Geomatics group
- Kyle
Develop short-term plan for me
Flesh out in week 2
Other longer term data repository issues Darren is involved in
Strategic research and innovation agenda
- Darren is writing this
- Would like
- 2 or 3 city observatories
- Very highly instrumented
- Put in a strong bid for Nottingham
- Funding
- Europe
- ESRC
Annex 66
- Behavioural modelling
- Put together a data repository
- Can make the data available to the academic community
- Conversation around this - later in the week
- I want to think about this in terms of the carrot and stick approach to encouraging participation - the strategy and firewalling option has implications for the licenses. There may be a short-term/long-term incompatibilities.


__halt_compiler
(PHP 5 >= 5.1.0, PHP 7)
__halt_compiler — 中断编译器的执行
说明
void __halt_compiler ( void )
中断编译器的执行。常用于在PHP脚本内嵌入数据，类似于安装文件。
可以通过常量 __COMPILER_HALT_OFFSET__ 获取数据开始字节所在的位置，且该常量仅被
定义于使用了__halt_compiler的文件。
返回值
没有返回值。
范例
Example #1 A __halt_compiler() 例子
===============================================================================
I don't exactly know what PHP is doing internally but I don't understand the
sanity behind how in token_get_all __halt_compiler is handled.
This is actually valid there:
__halt_compiler/**/ /**/ /**/ /**/ /** */();raw
Normally it pops off just any three tokens so you can have even
__halt_compiler***, __halt_compiler))), etc in token _get all.
The weird thing is that is also skips T_OPEN_TAG but in the context
__halt_compiler runs in this tag should not be posible. Instead it will pick up
< and ? as operators and php as a T_STRING.
It ignores the token at any point so this is also valid:
__halt_compiler()/**/ /**/ /**/ /**/ /** */;raw
When I test this with a php file rather than the tokeniser it works the same.
I can only conclude that PHP/__halt_compiler is pretty weird.
I think this is from attempting to weakly imitate the same syntax handling as
in functions (I guess you can put comments/whitespace anywhere). I find it
annoying and counter productive though.
Even this is valid:
__halt_compiler// comment\n();raw
A general problem that compound matters is that tokenise wont check whether or
not syntax is valid (tokens against each other). When running as PHP you must
have ();.
===============================================================================
If "__halt_compiler();" appears in a file which is "include"d or "require"d,
then the called-in file will be treated as if it physically cuts off at the
"__halt_compiler();". In other words, "__halt_compiler();" only affects the
physical file it's in, an outer file that pulls it in will continue to execute.
===============================================================================
__halt_compiler() is a language construct and therefore cannot be used as a
variable function.
Also, it cannot be used in eval() -- it won't throw a syntax error, but it
won't do anything either.
===============================================================================
This is not what people expect to see on manual pages, don't take this as
example.
===============================================================================
Another possible usage, in addition to binary data and installers,
is using it to separate model, view and controller logic from one another:
true,
'modcp'=>true,
'admincp'=>false,
'username'=>'Ultimater',
'userid'=>1234
);
//database logic goes here
//controller logic goes here
$view=new viewhelper;
$view->title="Test -> Ultimater's MVC example";
$view->base="http://".$_SERVER['HTTP_HOST'];
$view->username=$row['username'];
$view->userid=$row['userid'];
$view->authbar->loggedin=$row['loggedin'];
$view->authbar->modcp=$row['modcp'];
$view->authbar->admincp=$row['admincp'];
$view->render();
//controller logic goes here
__halt_compiler();?>
=htmlentities($this->title)?>
authbar->loggedin){
?>
} ?>


--- layout: default ---
SDO Census API
ACS Data for Colorado
ACS 2015-2019 Interactive Map
ACS Interactive Maps 2010 to 2018
Explore Census Data: data.census.gov
SDO Census Data for 2010 and 2020
Background for the American Community Survey


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/Why.20is.20this.20computable.3F.html ---
why on earth is this computable?
def prod' : Type → Type → Type := λ α β, classical.choice ⟨α × β⟩
and why on earth is this noncomputable?
noncomputable def prod' : Type → Type → ℕ := λ α β, classical.choice ⟨0⟩
types are erased
types are what?
they are not data
:o
you can't compute with them
what is data?
this is new
in the VM they are unit
I always thought that only Prop is not data
proofs and types are not data
everything else is
as a result, proofs and types are always vacuously computable
why is Type not data?
because types are not observable in the lambda calculus
you can delete all the types and all the lambdas make sense
Another good reason is that there is no sensible return value for the noncomputable version, after all, all existence proofs here are definitionally equal:
example : classical.choice ⟨0⟩ = classical.choice ⟨1⟩ := rfl
and what's a sensible return value for the computable version?
empty
?
or anything
Here's an amusing example:
import tactic.interactive def T : Type := if classical.choice ⟨0⟩ = 0 then ℕ else ℕ def three : T := cast (by unfold T; split_ifs; refl) 3 #eval three -- #3
it uses a noncomputable type, and a noncomputable proof, and gets something computable and can actually be #eval
'd
and what's a sensible return value for the computable version?
Actually a better answer is "unit star" because in the VM Type = unit
oh hell
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


... Let’s dive into the land like no other ...
Endless beaches, timeless ruins, welcoming people, oodles of elephants, rolling surf, cheap prices, fun trains, famous tea and flavorful food make Sri Lanka irresistible.


Chapters we’ve covered
Create custom landing pages with Omega that converts
more visitors than any website.
-
Solve Daily Problems
With lots of unique blocks, you can easily build a page without coding. Build your next landing page quickly.
-
Key Notes on Each Chapter
With lots of unique blocks, you can easily build a page without coding. Build your next landing page quickly.
-
Audio Book Available
With lots of unique blocks, you can easily build a page without coding. Build your next landing page quickly.
Things you’ll learn
Create custom landing pages with Omega that converts
more visitors than any website.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
- How to improve yourself with small tasks.
Get a free chapter of this book
Create custom landing pages with Omega that converts more visitors than any website.
-
50k+
Customers visit Omega every month to get their service done.
-
96%
Satisfaction rate comes from our awesome customers.
-
4.9/5.0
Average customer ratings we have got all over internet.
Reviews from readers
Create custom landing pages with Omega that converts
more visitors than any website.
-
“You made it so simple. My new site is so much faster and easier to work with than my old site. I just choose the page, make the change and click save.”
Darika Samak
From Amazon.com -
““Simply the best. Better than all the rest. I’d recommend this product to beginners and advanced users.”
Elsie Curtis
From Amazon.com -
“Must have book for students, who want to be Product Designer, UX Designer, or Interaction Designer.”
Trashae Hubbard
From Amazon.com
Reviews from readers
Pricing & Plans
Create custom landing pages with Omega that converts
more visitors than any website.
-
Limited
Free
Get a free chapter of our
book right now. -
Only eBook
$29
One time purchaseGet the eBook version +
Send free chapter
Audio version of the book. -
Limited
$49
One time purchaseHardcover + eBook version +
Send free chapter
Audio version of the book.
-
Can I use Omega for my clients?
Absolutely. The Envato Theme license allows you to build a websites for personal use or for a client. User Omega for your clients.
-
Do I get free updates?
Yes. We update all of our themes regularly, plus are constantly adding new components, pages, and features to our themes. Purchase once and get lifetime updates.
-
Can I use Omega for my clients?
Absolutely. The Envato Theme license allows you to build a websites for personal use or for a client. User Omega for your clients.
-
Does it work with WordPress?
Create custom landing pages with Omega that converts more visitors than any website. With lots of unique blocks, you can easily build a page without any design or custom coding.
Learn problem solving
Create custom landing pages with Omega that converts more
visitors than any website.


--- layout: post title: IBM, HP, Cisco Lead Cloud Computing Equipment Market date: '2012-03-28T09:12:32-07:00' tags: tumblr_url: http://alexhwilliams.tumblr.com/post/20065446989/ibm-hp-cisco-lead-cloud-computing-equipment-market ---
http://bit.ly/HmlkUh


Graduate Student at the University of Chicago Masters Program in Computer Science (MPCS)
Contact<EMAIL_ADDRESS>or<PHONE_NUMBER>
Current GPA: 3.8
Expected Graduation: June/August 2019 (contingent on receipt of research position)
MPCS 50103 Discrete Mathematics (A-)
MPCS 51044 Advanced C++ Programming (A-)
MPCS 51045 Advanced C++ Programming II (B+)
MPCS 51050 Enterprise Integration & Design Patterns (A)
MPCS 51083 Cloud Computing (A)
MPCS 51100 Advanced Programming (A-)
MPCS 52011 Computer Systems (A-)
MPCS 52553 Web Programming (A-)
MPCS 53001 Databases (A)
MPCS 54001 Networks (A)
MPCS 55001 Algorithms
MPCS 53013 Big Data
Airline weather delays. Class project to build an application utilizing big data technologies like Hadoop, Hive, and HBase to understand how to use, scale, and integrate big data technologies under the Lambda architecture.
Getting on Track and Kindergarten Readiness. Support Early Education group at NORC by developing features, enhancements, and bug-fixes for a data collection, scoring, and data visualization application. Core tehnologies used for the project are JavaScript (ES5, VueJS), PostgreSQL, and Python (Django, DjangoREST).
Data operations ETLs. Created ETLs in AWS Redshift, SQL, and Python that processes trillions of records for operational reports and ingests various opertional data sources (from PostgreSQL databases and Google Sheets) and writes them into the Braintree data lakes.
Cloud annotator. Cloud computing class project to develop a genomics annotator application using Python and AWS cloud services (Auto scaling, Dyanmo, EC2, S3, Glacier, Route53, ELB) to build a distributed system that handles web-load and data-processing.
Payment processing system. Final project for enterprise integeration and design patterns class; entirely written in Java 8. Used ActiveMQ messaging technology and custom, software-design patterns to transact with login, wallet, and payment subsystems.
Ecommerce application prototype Prototyped an ecommerce solution for Alliance Polymer Solutions. Demonstrated various web-programming concepts using the ruby programming language and Rails 5 framework: bcrypt hashing, authentication, authorization, CRUD operations, site administration, and cart/checkout.
Cloud pricing database. Database class project to store and retreive cloud pricing from a MySQL database. Demonstrates several SQL concepts on the backend: subqueries, join types, views, functions and stored procedures.
Watson natural language API. A project using the Watson natural language API to asynchronously sentiment and context from text and visualize the results with Chart.js. Technologies use for this project are primarily JavaScript: Express, Handlebars, NodeJS.
Dear Dr. Haryadi Gunawi, et al.
I understand from your original practicum listing and follow-up instructions that commitment is possibly the most important quality that you and research group seek. Having many capable and ambitious computer scientists apply for this practicum position indeed makes it hard to choose which candidate is the right fit. I hope that after reading my statement that you will have no doubt about my interest and commitment to your research.
Prior to coming to the University of Chicago, I worked in industry as a management consultant for six years helping enterprise clients develop and implement their technology goals and strategies. During my time in industry, I had the opportunity to witness advances in virtualization, networking, cloud, and big data technologies, which have fundamentally changed the way that the world consumes and expects their services to perform at (availability, reliability, and consistency). Being part of these projects inspired me to pursue graduate studies in computer science.
After commencing graduate studies in Fall 2017, I first saw your practicum posting last year and instantly felt that your group/posting aligned with my interests in computer science and have been purposefully working towards obtaining a research position with you and the UCARE group (taking challenging courses in advanced programming, big data, cloud, design patterns, library development, etc.) --- even arranging coursework so that I only have one class in the winter and spring semesters so I can fully take on the challenge of being in your research group.
If given the opportunity to work with you and your research group I plan to devote much of my time (>>15 hours) being an active participant with your research group and will gladly spend my summer interning with UCARE.
Further, if curious about my personal qualities, I have a record of demonstrated discipline, motivation, and success for achieving goals. In consulting I was ranked one of the top-five consultants in a 2000-person organization and was awarded the high honor twice in the firm for excellence in research and delivery. I also have a strong academic record in some of the most challenging courses in the MPCS and have a variety of work experiences on a number of different projects, systems, and languages --- purposefully seeking work and consulting projects that have provided me experience with working with cloud and data-intensive systems.
In short, I am very excited to finally have the opportunity to apply for this practicum/research position! Thank you very much for your consideration and hope to be in contact with you soon!
Sincerely, Patrick Huarng


Does your MP represent your vote?
*Must be Canadian, 6-digit postal code.
Go to
votes
.
{{ ctrl.mp | json}}


| Home | Blood Donor | Blood Recipient |
"DonateBlood.Com" is an organization that brings voluntary blood donors and those in need of blood on to a comon platform through this website,we seek donors who are willing to donate blood,as well as provide thetimeliest support to those in france need of it
Our mission is fullfill every blood request in the country with a promising web portable and motivational individuals who are willing to donate blood
Our vision is to be "the hope of every indian search of a voluntary blood donor"
Our motto-"Donate blood to save the most precious human life"
About BloodBlood is the red fluid that circulates in our blood vessels, veins and arteries. The main function of blood is to act as the body transport system, but it also has a major role in the body defense against infection. There is no substitute for blood. It cannot be made or manufactured. Donors are the only source of blood for patients who need it. |
Blood Donation Facts
|
Who Can/Can't DonateLet others benifit from your good health.Do Donate blood if...
|


Starbuzz Cofee's Missions
to provide all the caffine that you need to power your life.
Just drink it.
back to index


Data was obtained from the Environmental Protection Agency which collects data about various pollutants through the use of air monitors placed in a variety of locations. Pollutant measures are expressed in terms of Air Quality Index (AQI), which are directly related to health outcomes. The original data used click here. For more information about air pollutants click here. For more information about AQI measures click here.
Data about mortality rates was obtained through the California Department of Public Health leading causes of death dataset. Mortality rates were derived by using population denominators for various years derived from the American Community Survey and Census data. For more information about the average mortality rate for California state overall please refer to the table below.
In order to collapse down the cities from zip codes we used an additional data source to obtain the city location by zip code and latitude and longitude information to aggregate zip codes into cities and map the data.


FoodHub is an american chain of restaurants that enables food lovers to come together and enjoy food. It provides online delivery of food items,24*7. At FoodHub,you will have some of the city's beat destination cafes, bistros,restaurants,fast food, and others under one roof.
FoodHub provides its customers a heady combination of surreal surroundings in addition to tongue tickling food of different cuisines. FoodHub is not only the beat choice for traditional food at any hour of the day, but also a good place for children to have fun.We provide entertaining facilities, such as puppet shows,for children.


Activate Properties and/or Destroy/Repair "hasOwnProperty"
To see a result, gently change an input value!
distance/time = 1
-------------------------
Check Properties
_________________________________________________
For more information please visit the
Dictonary object and hasOwnProperty Wiki


#include <OpenSSLCryptoHashHMAC.hpp>
Inheritance diagram for OpenSSLCryptoHashHMAC:
Uses the OpenSSL EVP_digest functions to implement the various HMAC hash functions required by the library.
Public Member Functions | |
| virtual void | reset (void) |
| Reset the hash function. | |
| virtual void | hash (unsigned char *data, unsigned int length) |
| Hash some data. | |
| virtual unsigned int | finish (unsigned char *hash, unsigned int maxLength) |
| Finish up a Digest operation and read the result. | |
Constructors and Destructors | |
| OpenSSLCryptoHashHMAC (XSECCryptoHash::HashType alg) | |
| Constructor. | |
| virtual | ~OpenSSLCryptoHashHMAC () |
| Destructor. | |
HMAC Functions | |
| virtual void | setKey (XSECCryptoKey *key) |
| Set the HMAC key. | |
| virtual const XMLCh * | getProviderName () |
| Return the string identifier for the OpenSSL interface. | |
Information functions | |
| virtual HashType | getHashType (void) |
|
|
Constructor. Create the object, with the indicated algorithm (Currently supports MD5 and SHA1)
|
|
|
Destructor. Destroy the object. Will ensure any key material is also destroyed |
|
|
Finish up a Digest operation and read the result. This call tells the CryptoHash object that the input is complete and to finalise the Digest. The output of the digest is read into the hash buffer (at most maxLength bytes). This is effectively the signature for the data that has been run through the HMAC function.
Implements XSECCryptoHash. |
|
|
Determine the hash type of this object
Implements XSECCryptoHash. |
|
|
Return the string identifier for the OpenSSL interface.
|
|
|
Hash some data. Take length bytes of data from the data buffer and update the hash that already exists. This function may (and normally will) be called many times for large blocks of data.
Implements XSECCryptoHash. |
|
|
Reset the hash function. Re-initialises the digest structure. Implements XSECCryptoHash. |
|
|
Set the HMAC key. Sets the key - which needs to have a base class of OpenSSLCryptoKeyHMAC.
Implements XSECCryptoHash. |


Edinburgh-North Berwick 20 mile
Edinburgh => North Berwick SCO
Website: www.b-howie.demon.co.uk/enb.htm
Race Winners
(57 runnings)
2:18:13 2:26:13 2:10:08 2:23:20 05 May
2007
2:12:37
2:30:04
06 May
2006
2:16:48
2:27:46
07 May
2005
2:07:27
2:21:23
01 May
2004
2:10:16
2:24:26
03 May
2003
2:04:15
2:42:17
04 May
2002
2:12:21
2:47:07
05 May
2001
2:07:42
2:41:27
06 May
2000
2:09:24
2:30:26
01 May
1999
2:06:57
2:33:24
03 May
1998
2:06:19
2:37:04
03 May
1997
2:08:33
2:36:58
04 May
1996
2:04:24
2:41:45
06 May
1995
2:06:28
2:32:00
07 May
1994
2:01:05
2:15:31
01 May 1993
1:58:56
2:24:10
02 May 1992
1:57:38
2:32:38
05 May
1991
2:40:19
2:54:11
06 May
1990
2:02:17
---
06 May
1989
2:06:51
---
07 May 1988
2:04:07
---
02 May 1987
1:56:07
---
03 May
1986
2:01:00
---
04 May 1985
1:57:24
---
1984
2:01:24
---
1983
n/a
---
01 May
1982
1:50:55
---
1981
1:52:54
---
1980
1:59:38
---
1979
1:52:13
06 May 1978
2:01:50
1977
1:52:29
1976
n/a
1975
---
1974
---
12 May 1973
2:17:07
13 May 1972
2:24:26
08 May 1971
2:15:27
1970
---
10 May 1969
2:00:54
11 May 1968
1:59:57
13 May 1967
2:02:15
1966
---
1965
---
1964
---
11 May 1963
2:01:50
12 May 1962
2:07:41
13 May 1961
2:12:26
14 May 1960
2:04:41
16 May 1959
2:03:27
17 May 1958
2:05:55
Notes: 1958 was the inaugural year. Race starts at Meadowbank in Edinburgh and follows the coastal route to North
Berwick, finishing at the North Berwick Post Office. On 09 Dec 1953, Joe McGhee ran the 22.875 mile (36.8 km) course
from Edinburgh to North Berwick in 2:05:19.6 as a time trial (not a race). This bettered a previous record of 2:38:15
set by J Morrow (SCO) in 1930.
06 May
2017
20 mi
---
to be held
---
to be held
07 May
2016
20 mi
1:59:33
Robert Turner (SCO)
2:15:02
Dianne Lauder (SCO)
02 May
2015
20 mi
1:59:00
Ross Milne-2
2:19:42
Nikki Gibson (SCO)
03 May
2014
20 mi
1:56:58
Martin Barwood (ENG)
2:12:43
Rebecca Johnson (ENG)
04 May
2013
20 mi
1:49:05
Neil Renault (ENG)
2:19:44
Claire Thompson (SCO)
05 May
2012
20 mi
1:53:39
Ross Milne (SCO)
2:06:05
Joasia Zakrzewski (SCO)
07 May
2011
20 mi
1:49:36
Ross Houston (SCO)
Megan Wright (SCO)
01 May
2010
20 mi
1:57:48
Paul Raistrick (SCO)
Marietta Beal (SCO)
02 May
2009
20 mi
1:53:18
Ray Ward (GBR)
Toni McIntosh (SCO)
03 May
2008
35.04 km
2:14:46
Hugh McInnes (SCO)
Fiona Matheson-2
35.04 km
John McMillan-2
Fiona Matheson (SCO)
35.04 km
John McMillan (SCO)
Kate Jenkins (SCO)
35.04 km
Alistair Hart (SCO)
Jan Roxburgh (SCO)
35.04 km
Phillip Atherton (SCO)
Megan Clark (SCO)
35.04 km
Martin Ferguson (SCO)
Claire Gordon (SCO)
35.04 km
John Duffy (SCO)
Mari Crawford (SCO)
35.04 km
Phil Mowbray-2
Carol Cadger (SCO)
35.04 km
Phil Mowbray (SCO)
Pat Affleck (SCO)
35.04 km
Colin Hutt-3
A Brown (SCO)
35.04 km
Colin Hutt-2
Anne-Marie Hughes (SCO)
35.04 km
Colin Hutt (SCO)
Helene Diamantedes (SCO)
35.04 km
Alan Robson-3
A Thompson (SCO)
35.04 km
Tom Gillespie (SCO)
Kim Fisher (SCO)
35.04 km
Martin Coyne-3
Trudi Thompson (SCO)
35.04 km
Alan Robson-2
Elizabeth Staig (SCO)
35.04 km
Andrew Fair (SCO)
Eleanor Robinson-2
marathon
Brian Howie (SCO)
Eleanor Robinson (ENG)
35.08 km
Alan Robson (SCO)
n/a
35.08 km
Andy Stirling (SCO)
n/a
35.08 km
Rod Stone (SCO)
n/a
35.08 km
Martin Coyne-2
n/a
35.08 km
Martin Coyne (SCO)
n/a
35.08 km
Robin Thomas-2
n/a
35.08 km
Robin Thomas (SCO)
n/a
35.08 km
Lindsay Robertson-2
n/a
35.08 km
Lindsay Robertson (SCO)
n/a
35.08 km
Donald Macgregor-2
n/a
35.08 km
Tom Wiseman (SCO)
n/a
35.08 km
Colin Youngson (SCO)
35.08 km
David Wyper-2
35.08 km
Alexander Keith (SCO)
35.4 km
David Wyper (SCO)
not held
35.4 km
n/a
marathon
Robert Heron (SCO)
marathon
Donald Ritchie (SCO)
marathon
Alexander Wight-2
not held
36.37 km
James Wight (SCO)
36.37 km
Donald Macgregor (SCO)
36.37 km
Alexander Wight (SCO)
36.37 km
n/a
36.37 km
n/a
36.37 km
n/a
36.37 km
James Alder (SCO)
36.37 km
C Fraser (SCO)
36.37 km
T Rooke (ENG)
36.37 km
K Dawson (ENG)
36.37 km
Hugo Fox (SCO)
36.37 km
Harry Fenion (SCO)
Most Wins (1958/date)
Men
3
Martin Coyne (SCO)
1986-87,1994
.
Alan Robson (SCO)
1990,1993,1996
.
Colin Hutt (SCO)
1997-99
Women
2
Eleanor Robinson (ENG)
1991-92
Prize Money
(ADR qualified runners)
No information on prize money has been received for this race.
Race Time Bias
(sec/km)
Insufficient data to calculate the race time bias.
Competitive Level
(1990-date)
Insufficient data to calculate the competitive level.
Quality Performances (marathon, 1971-73,1991)
Men <2:16 2 <2:17 2 <2:18 3 <2:19 3 <2:20 4 Women No women under 2:50
Last Updated on 10
Mar 2017
Contributors: Alexander Wilson (50), Brian Howie, Don Macgregor, Andy Milroy, Mick McGeoch (35), Juraj Gasparovic (18), Thierry Lefeuvre (5), Klaas Loonstra (5)


Class BankDetails
Represents the details of a payer/account in a transaction.
Inheritance
System.Object
BankDetails
Inherited Members
System.Object.ToString()
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
Namespace: Yort.OnlineEftpos
Assembly: Yort.OnlineEftpos.dll
Syntax
public sealed class BankDetails
Properties
| Improve this Doc View SourceBankId
The id of the bank the payer is registered with.
Declaration
[JsonProperty("bankId")]
public string BankId { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
PayerId
An identifier value registered with the Online Eftpos API that represents a specific payer. This is usually provider by the payer at time of purchase.
Declaration
[JsonProperty("payerId")]
public string PayerId { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
PayerIdType
The type of identifier provided in PayerId. Usually "MOBILE".
Declaration
[JsonProperty("payerIdType")]
public string PayerIdType { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Methods
| Improve this Doc View SourceEnsureValid()
Throws if the details are invalid.
Declaration
public void EnsureValid()
Remarks
Throws if the PayerId is null, empty or only whitespace.
Exceptions
| Type | Condition |
|---|---|
| OnlineEftposInvalidDataException | Thrown if the values of this instance are invalid. |


Stefan Bissell
Examples and slides:
https://github.com/weaselflink/exploring-kotlin-coroutines
Threads are used to …
while (true) {
thread {
TimeUnit.MINUTES.sleep(1)
}
}
You will get a OutOfMemoryError relatively soon
(a few thousand threads on my machine).
Coroutines love waiting for something.
runBlocking {
repeat(1_000_000) {
launch {
delay(TimeUnit.MINUTES.toMillis(1))
}
}
}
Coroutines still need threads to execute them.
val context = newSingleThreadContext("single thread")
runBlocking {
launch(context) {
println(Thread.currentThread().name)
}
}
Blocking the thread inside a coroutine is a bad idea!
val context = newSingleThreadContext("single thread")
runBlocking {
launch(context) {
TimeUnit.MINUTES.sleep(1)
}
launch(context) {
println("I have to wait a minute")
}
}
public fun CoroutineScope.launch(...): Job
suspend
keywordCoroutineScope
Job
launch {
println("I am second")
}
println("I am first")
launch {
println("I am first")
}
yield() // allows launch to run
println("I am second")
CoroutineScope(someContext).launch {
// ...
}
runBlocking {
launch {
// ...
}
}
suspend fun bla() {
coroutineScope {
launch {
// ...
}
}
}
suspend fun CoroutineScope.bla() {
launch {
// ...
}
}
val job: Job = launch {
// ...
}
if (job.isActive) {
// react to coroutine state
}
job.cancel()
job.join()
val result: Deferred<Int> = async {
5
}
val value = result.await() // 5
val job: Job = result
job.cancel()
Cancels whole scope.
launch {
launch {
// cancelled
}
throw Exception()
}
launch {
// cancelled
}
// cancelled
Cancels only self and children.
launch {
launch {
// cancelled
}
cancel()
}
launch {
// runs fine
}
// runs fine
Exception cancellation is contained in children.
supervisorScope {
launch {
launch {
// cancelled
}
throw Exception()
}
launch {
// runs fine
}
}
suspend fun send(element: E)
suspend fun receive(): E
runBlocking {
val channel = Channel<Int>()
channel.send(7)
println(channel.receive())
}
runBlocking {
val channel = Channel<Int>()
channel.send(7) // suspends forever
println(channel.receive())
}
runBlocking {
val channel = Channel<Int>()
launch {
channel.send(7)
}
println(channel.receive())
}
runBlocking {
val channel = Channel<Int>(capacity = 1)
channel.send(7)
println(channel.receive())
}
Channel instances are not bound to coroutine scopes.
val channel = Channel<Int>()
Channel instances are not bound to coroutine scopes.
val channel = Channel<Int>()
scope1.launch {
var sum = 0
for (message in channel) {
sum += message
}
println(sum)
}
Channel instances are not bound to coroutine scopes.
val channel = Channel<Int>()
scope1.launch {
var sum = 0
for (message in channel) {
sum += message
}
println(sum)
}
scope2.launch {
channel.send(1)
channel.close()
}
Problem: calling slow services exhausts thread pool
Old solution: separate thread pool per service
Problem: a few slow calls can block service
Non-blocking clients (e.g. java.net.http) can be easily used from coroutines.
suspend fun get(url: String): HttpResponse<String> =
HttpClient
.newHttpClient()
.sendAsync(
HttpRequest.newBuilder(URI(url)).GET().build(),
HttpResponse.BodyHandlers.ofString()
)
.await()
supervisorScope {
repeat(1_000) {
launch {
get("https://httpbin.org/delay/5")
.also {
println(it.statusCode())
}
}
}
}
Classic Java web server way of handling requests.
More requests, more threads, more resources consumed.
One (or more) coroutines per request.
get("/balance/{customerId}") {
findAccounts(call.parameters["customerId"])
.map {
async { // launch + return value
getBalance(it)
}
}
.sumOf {
it.await()
}
}
Every call can take as much time as it likes.
get("/sales.csv") {
call.respondBytesWriter {
getSoldItemLines() // produce lines on demand
.forEach {
writeAvailable(it.toByteBuffer())
}
}
}
When an actor receives a message, it can (in any order)
actor<CounterAction> {
var counter = 0 // <- mutable state
for (message in channel) {
when (message) {
is CounterAction.Add -> {
counter += message.value
}
is CounterAction.Get -> {
message.answer.complete(counter)
}
}
}
}
actor<ShoppingCartPriceRequest> {
for (message in channel) {
val aggregator = aggregatorActor(message.result)
getShoppingCart(message.id)
.forEach {
aggregator.send(ItemPriceRequest(it))
}
aggregator.close()
}
}
Examples and slides:
https://github.com/weaselflink/exploring-kotlin-coroutines


--- layout: page ---
A church in Riverton Utah excited about bringing the amazing message of God’s grace to our community. We are a Bible based church dedicated to doing whatever it takes to share the good news that has radically changed our lives to everyone possible.
Lead Pastor Ben Helton, his wife Kristen (Kid’s Life Coordinator and Women’s Bible Study Leader), children Karis, Jaxson, and Rachel
Lifestone Church is supported by The North American Mission Board.


ARV number:
National patient ID:
Name:
Age:
Sex:
Int Wt(Kg):
Int Ht(cm):
BMI:
TI:
Location:
Landmark / Address (Physical / P.O Box):
Occupation:
Name of guardian:
Date Place of +HIV test:
Agrees to follow-up:
Pulmonary tuberculosis within the last 2 years:
Extrapulmonary tuberculosis (EPTB):
Pulmonary tuberculosis (current):
Kaposi's sarcoma:
| Ht | Wt | BMI | Reg | Outcome | Adh | S.eff | Pills remaining | Gave |
|---|


Image credits
Images used in this chapter were sourced from Flickr, and licensed with
CC BY 2.0 license
:
Anthony Quintano
Christopher Michel
Leonid Mamchenkov
Jan Moltzen
Pie Pec


Ice
wall
A few more clicks to
sign in to your account.
Manage all your e-commerce accounts in one place
Sign In
A few more clicks to sign in to your account. Manage all your e-commerce accounts in one place
Remember me
Forgot Password?
Login
Sign up
By signin up, you agree to our
Terms and Conditions
&
Privacy Policy
Dark Mode


LinkedIn
CodePen
GitHub
Coding
Skills
Projects
My experience...
How I got here
My Story
RentUrApp
Karus Systems Limited


Micky Flanagan (born 1962-10[ref]) has appeared in 33 episodes between 2010-2018. Micky Flanagan on IMDB. Micky Flanagan on Wikipedia. Micky Flanagan on Chortle.


Although the usual way to invoke XQuery from a Java application is to compile and execute a query
as described above, it is also possible to invoke individual XQuery functions directly from Java if required.
This interface is very efficient but performs less validation of parameters than the standard interface described above.
To achieve this, first compile the query as described above, specifying a query that includes one or more
declare function
declarations in the query prolog. It is then possible to retrieve the
UserFunction
objects representing the compiled code of these functions, by calling the
getUserDefinedFunction
method on the StaticQueryContext
object.
Such a function can be called using its call
method. The first argument to this is an array
containing the values of the arguments. These must be supplied using Saxon's native classes, for example
an integer argument is supplied as an instance of net.sf.saxon.value.IntegerValue
. These
values must be of the type expected by the function; no conversion or type checking takes place (which
means that a ClassCastException will probably occur if the wrong type of value is supplied). The second
argument to the call
method is a Controller
. A Controller can be obtained
by calling the getController()
method on the XQueryExpression
object. The same Controller
can be used for a series of separate function calls.
For example:
StaticQueryContext sqc = new StaticQueryContext(new Configuration());
QueryProcessor processor = new QueryProcessor(sqc);
XQueryExpression exp1 = processor.compileQuery(
"declare namespace f='f.ns';" +
"declare function f:t1($p as xs:integer) { $p * $p };" +
"declare function f:t2($p as xs:integer) { $p + $p };" +
"1"
);
UserFunction fn1 = sqc.getUserDefinedFunction("f.ns", "t1", 1);
UserFunction fn2 = sqc.getUserDefinedFunction("f.ns", "t2", 1);
Controller controller = exp1.getController();
IntegerValue[] arglist = new IntegerValue[1];
for (int x=1; x<1000000; x++) {
arglist[0] = new IntegerValue(x);
Value v1 = fn1.call(arglist, controller);
Value v2 = fn2.call(arglist, controller);
System.err.println("Returned product " + v1 + "; sum =" + v2);
}
}


Summary
Administrator interfaces may be present in the application or on the application server to allow certain users to undertake privileged activities on the site. Tests should be undertaken to reveal if and how this privileged functionality can be accessed by an unauthorized or standard user.
An application may require an administrator interface to enable a privileged user to access functionality that may make changes to how the site functions. Such changes may include:
- user account provisioning
- site design and layout
- data manipulation
- configuration changes
In many instances, such interfaces do not have sufficient controls to protect them from unauthorized access. Testing is aimed at discovering these administrator interfaces and accessing functionality intended for the privileged users.
How to Test
Black Box Testing
The following section describes vectors that may be used to test for the presence of administrative interfaces. These techniques may also be used to test for related issues including privilege escalation, and are described elsewhere in this guide(for example Testing for bypassing authorization schema (OTG-AUTHZ-002) and Testing for Insecure Direct Object References (OTG-AUTHZ-004) in greater detail.
- Directory and file enumeration. An administrative interface may be present but not visibly available to the tester. Attempting to guess the path of the administrative interface may be as simple as requesting: /admin or /administrator etc.. or in some scenarios can be revealed within seconds using Google dorks.
- There are many tools available to perform brute forcing of server contents, see the tools section below for more information. * A tester may have to also identify the file name of the administration page. Forcibly browsing to the identified page may provide access to the interface.
- Comments and links in source code. Many sites use common code that is loaded for all site users. By examining all source sent to the client, links to administrator functionality may be discovered and should be investigated.
- Reviewing server and application documentation. If the application server or application is deployed in its default configuration it may be possible to access the administration interface using information described in configuration or help documentation. Default password lists should be consulted if an administrative interface is found and credentials are required.
- Publicly available information. Many applications such as wordpress have default administrative interfaces .
- Alternative server port. Administration interfaces may be seen on a different port on the host than the main application. For example, Apache Tomcat's Administration interface can often be seen on port 8080.
- Parameter tampering. A GET or POST parameter or a cookie variable may be required to enable the administrator functionality. Clues to this include the presence of hidden fields such as:
- <input type="hidden" name="admin" value="no">
- or in a cookie: Cookie: session_cookie; useradmin=0
Once an administrative interface has been discovered, a combination of the above techniques may be used to attempt to bypass authentication. If this fails, the tester may wish to attempt a brute force attack. In such an instance the tester should be aware of the potential for administrative account lockout if such functionality is present.
Gray Box Testing
A more detailed examination of the server and application components should be undertaken to ensure hardening (i.e. administrator pages are not accessible to everyone through the use of IP filtering or other controls), and where applicable, verification that all components do not use default credentials or configurations.
Source code should be reviewed to ensure that the authorization and authentication model ensures clear separation of duties between normal users and site administrators. User interface functions shared between normal and administrator users should be reviewed to ensure clear separation between the drawing of such components and information leakage from such shared functionality.
Each web framework may have its own admin default pages or path. For example
WebSphere:
/admin
/admin-authz.xml
/admin.conf
/admin.passwd
/admin/*
/admin/logon.jsp
/admin/secure/logon.jsp
PHP:
/phpinfo
/phpmyadmin/
/phpMyAdmin/
/mysqladmin/
/MySQLadmin
/MySQLAdmin
/login.php
/logon.php
/xmlrpc.php
/dbadmin
FrontPage:
/admin.dll
/admin.exe
/administrators.pwd
/author.dll
/author.exe
/author.log
/authors.pwd
/cgi-bin
WebLogic:
/AdminCaptureRootCA
/AdminClients
/AdminConnections
/AdminEvents
/AdminJDBC
/AdminLicense
/AdminMain
/AdminProps
/AdminRealm
/AdminThreads
WordPress:
wp-admin/
wp-admin/about.php
wp-admin/admin-ajax.php
wp-admin/admin-db.php
wp-admin/admin-footer.php
wp-admin/admin-functions.php
wp-admin/admin-header.php
Tools - Dirbuster This currently inactive OWASP project is still a great tool for brute forcing directories and files on the server.
- THC-HYDRA is a tool that allows brute-forcing of many interfaces, including form-based HTTP authentication.
- A brute forcer is much better when it uses a good dictionary, for example the netsparker dictionary.
References


sound_check for
1-Minute Test (Apr/14/2016)
Here you can check the technical specs of your recording.
Summary of tech specs
Channel: Mono
Sample rate: 44100 Hz
Sample format: 16 bit
Export format: MP3
Export bitrate: 128 kbps
Volume: 89 dB
1) First upload your recording in tests folder at LibriVox.
Or you can use a existing mp3 file in tests folder at LibriVox.
2) Enter your file name (Ex. test_ekzemplaro.mp3) here & submit.
This program fetch data from <https://librivox.org/uploads/tests/>.
contents
Cashed mp3 files.
As default cashed files are used. If mp3 file at LibriVox is newer, please delete cashed file before checking.
list_file
Please post your feed back to Online tech specs check of test recordings
This program uses the following package.
mp3gain
sox
libsox-fmt-mp3
For Ach Linux
libid3tag
Apr/14/2016 AM 08:15


Arbitrarily decided by the author(s) of this site.
Click on a topic to preview description and useful links.


What is an Organization on Bitrise?
Organizations are used to seamlessly manage bigger teams and members inside a company. It is a place to gather all the people working on each of your company’s apps and delegate them through creating different groups.
How do I create a new Organization?
Just go to your account settings page,
scroll down and click on the green New organization
button at the bottom left.
A popup will appear to guide you through the process.
How do I add an app to an Organization?
First, you have to be added to at least one Group
of the Organization.
Then, go to the Add new app page and select
the Organization in the dropdown at the top left.
You can change this throughout the process of adding the app, or after you finished adding the app, changing the owner is possible through transferring ownership.
How do I migrate/transfer my existing apps to an Organization?
Once you’ve created an Organization, you can transfer any of your apps to it by going to
the Team
tab of the app you want to transfer, and clicking the Transfer ownership button at the top right.
What are “Owners” inside an Organization?
Organizations can have more than one Owner. Owners can manage billing, delete apps and change the billing email, create, delete and assign groups to apps.
What can “Members” of an Organization do?
Members are displayed on the People tab of the Organization’s page.
One can be added as a member by including them in a group on the Groups tab.
These members have the option to add apps to the Organization and view a list of all of the
Organization’s apps on the Apps tab.
Members can only access an Organization’s app, if they are granted access to the app directly or through a Group
,
in respect of their assigned role (Admin, Developer or Tester).
What are groups good for?
A group is basically a wrapper for members. By creating groups, Owners and Admins can add multiple members to each app’s team at once, making it faster and easier to setup new projects on Bitrise. It also make it faster to reassign, remove and change role of multiple members.
Each group is handled as one entity on the app’s Team
tab. They can be added to an app’s team,
the group’s role can be set, and by removing the Group from the app’s Team
you can revoke the access of every member of that group from the app.
It’s not possible however to add or delete individual members of a group there, only on the Org’s page.
All members of a group have the same role when assigned to an app.
What’s the difference between a Team and an Organization?
Teams are handled per app, Organizations are handled globally.
A Team of an Organization’s app can contain members invited directly or through the groups assigned to them. Team members with a direct role can only access the app they were invited to and can’t add an app to the Organization. Members of a Team always have a role assigned to them (Admin, Developer or Tester).
Who are the “outside contributors”?
Outside contributors are members of an app’s Team with a direct role, invited only to an app of an Organization and not to the Organization itself.
Can I have multiple Organizations?
One user can have as many Organizations as they like, but each Organization has to have an active Pro subscription to be able to run builds.
Can I have multiple Pro subscriptions?
Yes. Each account can subscribe to Pro for their personal account and for as many Organizations as needed.
What if I cancel my Pro plan for an Organization?
After the Pro plan expires, builds can’t be started for apps owned by the Organization.
Can I remove someone from all of my Organization’s apps?
If you are an Owner of an Organization, you can remove members and outside contributors
on the Org’s People
tab, with one click. Owners can also remove someone from a group
on the Groups
tab. In this case the user will be removed from all apps’ team that the group is assigned to.
Where can I change the avatar for my Organization?
Once you are on your Organization page, click on the avatar, and you’ll see a popup to change the color scheme of it. We’ll add custom avatar support a bit later.