@(title: String) @Main(title) {
Created by students at the University of Hawaii for local players.
Hawaii Hoops Network isn't one of those mainland websites that tries to cater to basketball players on the islands. Hawaii Hoops Network was created by a group of local students who have a passion for amateur basketball.
Hawaii Hoops Network's mission is to connect all basketball players, teams, and leagues on the island of Oahu! Get information on leagues, open gyms, pick up games, and network with players and teams in your area! Register for leagues online. #MOVE


{% load cases_tags %}
File {{ remapped_imported_from }} has been moved or deleted!
File {{ remapped_imported_from }} has changed on disk since it was imported
You should do one of the following using the buttons below:


| India GVA YoY% | ||||||
| Release Date | For Quarter | Market Expectation | Kshitij Expectation | Previous | Released | Revised |
| 31-Aug-17 | Jun-17 | - | - | 5.18% | 5.55% | 5.57% |
| 30-Nov-17 | Sep-17 | - | - | 5.57% | 6.07% | 6.23% |
| 28-Feb-18 | Dec-17 | - | 5.54% | 6.23% | 6.72% | - |
| 30-May-18 | Mar-18 | - | - | 6.72% | - | - |


Issakhanova Gaukhar.
Hello. My name is Gaukhar. I'm from Kazakhstan. When I was 5 years old my parents sent me to a music school and I understand that my life going to became heavy.I grew up with my piano and notes, participated in many competitions and concerts. But after 17 years I understand that I don't want to be a musician and decided to change my sphere. So I became a student at Fanshawe again, even though I graduated from a university in my own country.
And also I am a big fun of Japan and anime. I love my cat, but he doesn't like me.


--- layout: default title: Bitcoin.com Developer Platform | Cloud banner: hero.jpeg H1: Cloud subtitle: Deploy and Scale secondSubtitle: Build, run, and operate applications entirely on Bitcoin.com's Cloud --- {{> cloud-header}}


#include <array_ops.h>
Returns a tensor of ones with the same shape and type as x.
Arguments:
Returns:
Output
: a tensor of the same shape and type as x but filled with ones.
Constructors and Destructors |
|
|---|---|
OnesLike(const ::tensorflow::Scope & scope, ::tensorflow::Input x)
|
Public attributes |
|
|---|---|
operation
|
|
y
|
Public functions |
|
|---|---|
node() const
|
::tensorflow::Node *
|
operator::tensorflow::Input() const
|
|
operator::tensorflow::Output() const
|
|
Operation operation
::tensorflow::Output y
OnesLike( const ::tensorflow::Scope & scope, ::tensorflow::Input x )
::tensorflow::Node * node() const
operator::tensorflow::Input() const
operator::tensorflow::Output() const


 What good is a reward if you ain't around to use it? Besides, attacking that battle station ain't my idea of courage. It's more like... suicide. Kid, I've flown from one side of this galaxy to the other. I've seen a lot of strange stuff, but I've never seen anything to make me believe there's one all-powerful Force controlling everything.
The plans you refer to will soon be back in our hands. Kid, I've flown from one side of this galaxy to the other. I've seen a lot of strange stuff, but I've never seen anything to make me believe there's one all-powerful Force controlling everything. There's no mystical energy field that controls my destiny. It's all a lot of simple tricks and nonsense.
I don't know what you're talking about. I am a member of the Imperial Senate on a diplomatic mission to Alderaan-- Escape is not his plan. I must face him, alone. Don't underestimate the Force. Kid, I've flown from one side of this galaxy to the other. I've seen a lot of strange stuff, but I've never seen anything to make me believe there's one all-powerful Force controlling everything.
 What good is a reward if you ain't around to use it? Besides, attacking that battle station ain't my idea of courage. It's more like... suicide. Kid, I've flown from one side of this galaxy to the other. I've seen a lot of strange stuff, but I've never seen anything to make me believe there's one all-powerful Force controlling everything.
John Doe
8 Jun, 2012 at 4:03 pm
I have traced the Rebel spies to her. Now she is my only link to finding their secret base. I have traced the Rebel spies to her. Now she is my only link to finding their secret base.  Take her away!
ReplyJohn Doe
8 Jun, 2012 at 4:03 pm
I have traced the Rebel spies to her. Now she is my only link to finding their secret base. I have traced the Rebel spies to her. Now she is my only link to finding their secret base.
ReplyJohn Doe
8 Jun, 2012 at 4:03 pm
I have traced the Rebel spies to her. Now she is my only link to finding their secret base. I have traced the Rebel spies to her. Now she is my only link to finding their secret base.  Take her away!
Reply


Front-End Developer
Skopje,Macedonia
<EMAIL_ADDRESS>+389 72/316-076
Skills
HTML
CSS
Java Script
React
Languages
English
German
I started my career as a Front-End Developer on a course at Code Academy in Skopje. During the course I upgraded my knowledge by creating my own projects, and lots of exercises.
Name of School: “OU. Johann Heinrich Pestalozzi” Skopje-Macedonia
Name of School: “SGGU Zdravko Cvetkovski “ Skopje- Macedonia
Name of Univesrity : “ Ss. Cyril and Methodius University “
Name of Faculty : “Faculty of Ekonomics’-Skopje Macedonia
Department - Marketing
Name of academy : Code Academy
Front-End Developer


Dgame.Window.VideoMode
- struct VideoMode;
- The VideoMode struct contains informations about the current window video mode.
It is passed to Window which extract the informations and use them to build a window context.
Author:
rschuett
- ushort width;
- The width of this video mode
- ushort height;
- The height of this video mode
- ubyte refreshRate;
- The refresh rate of this video mode
- this(uint width, uint height, uint hz = 0);
- CTor
- const bool isValid(ubyte display = 1);
- Returns:
if the this video mode is valid which means, if it is listed from the OS
- const pure nothrow bool opEquals(ref const VideoMode vm);
- opEquals
- static VideoMode getDesktopMode(ubyte display = 1);
- Returns:
the desktop video mode
- static VideoMode getMode(uint index, ubyte display = 1);
- Returns:
the video mode on the given index
- static VideoMode[] listModes(ubyte display = 1);
- Returns:
A List of all valid supported video modes
- static int countModes(ubyte display = 1);
- Returns how many valid video modes are supported
- static int countDisplays();
- Returns how many display are available.
Page generated by Ddoc.


|
BeeSafe Project
v1.0
Low-cost tracking device.
|
The hardware part made up of three parts:
The PI and its extension board will be fit into a casing for protection, allowing access only to the USB power input and the antenna.
The subpages provide more information about the electronics, the u-blox module and the mechanical casing.
The diagram below displays the main components of the hardware with the interfaces and voltage levels for each of them.
The power is supplied by a power bank providing 5 V and at least 1.5 A maximum output current. This provides power for the Raspberry PI, which operates at 3.3 V and the SARA-G3 module. For the SARA module, a LDO transforms the 5 V into the required 3.8 V. The module handles all other voltage conversions itself.
Both 1.8 V from the SARA module and 3.3 V from the PI supply the voltage translator so the both of them can communicate with each other.
The SARA module supports both 3.0 V and 1.8 V SIM cards. The voltage is automatically switched.


Beat Trump, Have unlimited Fun
Tell the community why Trump shouldnt be elected. You receive points for each post that you make and alsoe each like of your posts.
Share with friends. You receive points for each new vote you bring to the app.
We protect your anonymity with anonymous login option and use of usernames. Feel free to delete your account at anytime.
Put the team on your back. Check the scoreboard to see who's doing the most to remove the most corrupt president in history.


{{ define "main" }}
Shrub will use the information you provide on this form to email you our monthly newsletter and other updates. Please check the box below to confirm that you agree to this.
You can change your mind at any time by clicking the unsubscribe link in the footer of any email you receive from us, or by contacting us at<EMAIL_ADDRESS>We will treat your information with respect. For more information about our privacy practices please visit our website. By clicking below, you agree that we may process your information in accordance with these terms.
We use Mailchimp as our marketing platform. By clicking below to subscribe, you acknowledge that your information will be transferred to Mailchimp for processing. Learn more about Mailchimp's privacy practices here.
Posted: {{ dateFormat "02/01/06" .Date }} | Expires: {{ dateFormat "02/01/06" .ExpiryDate }}
{{ .Description }}
Continue reading!


CRADLE WILL ROCK (Touchstone) Starring: Hank Azaria, Emily Watson, John Turturro, Angus Macfayden, Bill Murray, Joan Cusack, Cherry Jones, Cary Elwes, John Cusack, Vanessa Redgrave, Philip Baker Hall, Ruben Blades, Susan Sarandon, Jamey Sheridan. Screenplay: Tim Robbins. Producers: Jon Kilik, Lydia Dean Pilcher and Tim Robbins. Director: Tim Robbins. MPAA Rating: R (profanity, nudity, adult themes) Running Time: 132 minutes. Reviewed by Scott Renshaw.
CRADLE WILL ROCK is a tapestry of American social activism in the 1930s ... and a fairly tattered one, at that. Beginning in the fall of 1936, Tim Robbins' fact-based drama introduces us to the Federal Theatre Project, a W.P.A. sub-division dedicated to employing America's artists for the low-cost entertainment of America's Depression-era masses. Among the works funded by the project is "The Cradle Will Rock," a pro-union musical written by Marc Blitzstein (Hank Azaria) and staged by the ever-feuding tandem of producer John Houseman (Cary Elwes) and director Orson Welles (Angus Macfayden). According to Congressman Martin Dies (Harris Yulin), it's also too typical of the left-leaning tendencies of the arts community. When Congress abruptly declares a moratorium on all Federal Theatre Project activities, the F.T.P.'s director Hallie Flanagan (Cherry Jones) attempts to set things straight politically. Meanwhile, Welles and company decide on a more direct course of action.
The F.T.P. controversy and the staging of "The Cradle Will Rock" is the central story of CRADLE WILL ROCK, but it's far from the only one. Sub-plots follow "Cradle" cast members like Aldo Silvano (John Turturro), who turns his back on his pro-Fascist Italy family, and Olive Stanton (Emily Watson), a homeless aspiring singer. There are glimpses into the glittering lives of the industrialists whose efforts supported Italy and Germany prior to the war, including Nelson Rockefeller (John Cusack) and steel magnate Grey Mathers (Philip Baker Hall). There is a tale of Rockefeller's battle with artist Diego Rivera (Ruben Blades) over the mural Rivera has been commissioned to create in the new Rockefeller Center. And there are stories of anti-Communist whistle-blowers like W.P.A. clerk Hazel Huffman (Joan Cusack) and ventriloquist Tommy Crickshaw (Bill Murray).
If that seems like a lot to digest, it is. Robbins' sprawling narrative attempts to approach the era's growing class unrest from every possible angle, and in so doing can't quite do justice to any of them. Olive and Aldo are walking representations of the virtuous poor more than they are actual characters; their counterparts in Mathers and William Randolph Hearst (John Carpenter) are cackling industrialists who sit around counting their money (quite literally, in one scene). Characters with the potential to develop into something intriguing and complex -- like Margherita Sarfatti (Susan Sarandon), a Jewish propagandist for Mussolini -- barely get enough screen time for you to remember who they are. In a cinematic season where epic running times are epidemic, CRADLE WILL ROCK clocks in at a meager-by-comparison 132 minutes, not nearly enough time to render all its stories fully.
It's a shame, too, because CRADLE WILL ROCK often shows flashes of the compelling film that might have been. Robbins has real visual flair as a director, including a great scene-setting opening Steadicam shot and Blitzstein's sleep-deprived creation of "Cradle" (accompanied by hallucinatory inspirations for its staging and commentary from his muse Bertolt Brecht. Vanessa Redgrave has a juicy role as Mathers' "socially conscious" wife, who gets a rebellious thrill out of watching a "Negro production of 'Macbeth,'" or helping Welles' pirate performance of "Cradle." And there's the theater group, with Macfayden chewing scenery as the egotistical Welles and Elwes his effective foil as Houseman. Robbins says in the press notes that he originally set out to do a film just about the staging of "Cradle," before other storylines presented themselves. You can't help but wish he had stayed more focused.
In this era of fuming over the National Endowment for the Arts and its support of "questionable" works, CRADLE WILL ROCK's themes are certainly still timely. Robbins' sympathies are clearly with the social activists, but, as he did in DEAD MAN WALKING, he shows a willingness to explore the other side with some semblance of an open mind (if earnest, misguided namer of names Hazel falls into that category). The problem with CRADLE WILL ROCK isn't politics, though, but a reach exceeding Robbins' grasp. He has so little time to spend exploring any of his stories that he never delves into questions of what an artist sacrifices when he accepts patronage, or examines the irony of "The Cradle Will Rock" being sabotaged as much by the entertainers' unions as by the government. As an overview history lesson, CRADLE WILL ROCK has much to recommend it. As a film, it's too cursory a glance at too complex an issue.
On the Renshaw scale of 0 to 10 La Internation-ills: 5.
Visit Scott Renshaw's Screening Room http://www.inconnect.com/~renshaw/ *** Subscribe to receive new reviews directly by email! See the Screening Room for details, or reply to this message with subject "Subscribe".
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


I am a Computer Science undergrad and a coding enuthsiast. My immense love for coding persuaded me to explore various domains of computer science including Android Development, Web Development, Machine Learning etc.
Apart from coding I am a blogging enuthusiast and love teaching algorithms.
View ResumeStories is a public blogging webapp built with an intent to help interoverts communicate openly with people. Through stories people can share their emotions, some of the happy moments, some life tips and few more things beyond imagination in form of blogs.
Tech Stack : NodeJS, ExpressJS,MongoDB, Handlebars
OpenDocx facilitates realtime collaboration for making last minute document. With integration of WebSockets multiple users can collaborate in creation of a document thus increasing team's productivity.
Tech Stack : NodeJS, SocketIO, MongoDB, ReactJS
With advancement of technology we wanted to make student's assignment submissions paperless. Thus we came up with the idea of LIMS to help under-previleged educational institutes automate the process of assignment submission, notice announcements, sharing study material etc.
Tech StackBackend : Flask, Firebase, Postgres-SQL
IOS App :Swift, Firebase
Bridge is a social-cause app, where under-previleged students can request for monetry support by filling a short yet informative application form. We have kept a simple 3 step process to carry out the entire application flow.
Tech Stack
Backend : Flask, Firebase, Postgres-SQL
Android App : Kotlin, Retrofit
IOS App : Swift
Wanna get in touch?
npm init AnkitCode99


Holy shit, FIRSTNAME
It was great to see you at the club night! I think this is the first time anyone has ever brought a trained bear to a club! People will be talking about this for a loooong time. You must tell me more about your hobby some day.  We'll just write it up as a company expense.
I hope you will keep showing up for the social events, but don't feel obligated to do something big every time. The important thing is that we get to know each other!
There are no more social events this week, but you'll have more opportunities for fun soon enough. Make sure you prioritize them, and see them as an opportunity to exercise your imagination :).
Benedetto Tornincasa
Human Relations
Senior Consultant / Haka Leader


Link estimator asks the routing engine if this entry should be inserted into the neighbor table if the white bit on a link is set but there is no room for the link on the link table. The return value is the "pin bit" - if true insert into the neighbor table. In the reference implementation the router will return true if the path through the source will be better than a path through at least one current neighbor. @ author Omprakash Gnawali @ Created: September 16, 2006


Back to play2048.co
The following disclosure is reflective of requests received from all individuals. The results are recorded between 2020-2021.
Request Type
Number Received
Number Denied
Mean Days to Respond
Request to know
768
0
0
Requests to delete
70
0
0
Opt outs
0
0
0


I am a Dialog Box.  And since I am set to be modal, I won't let you return to the opener until you close me. My settings are listed below:
<DialogBox demo_dlg> Width 450px Height 330px 3DBorder Off ScrollBar Off Modal On HelpButton On </DialogBox>


You can add one more person than there are game players (e.g., 5 people for a 4 player game). The extra person will automatically replace the last place finisher in each race.


Class: Aws::S3::ObjectVersion
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
|
|
|
Instance Chain:
|
|
| Inherits: |
Aws::Resources::Resource
|
| Defined in: | (unknown) |
Class Attribute Summary
::Aws::Resources::Resource - Inherited
Class Method Summary
- .new(bucket_name, object_key, id, options = {}) constructor
::Aws::Resources::Resource - Inherited
| .add_data_attribute | Registers a data attribute. |
| .add_identifier, .data_attributes, .identifiers, .new |
::Aws::Resources::OperationMethods - Extended
Instance Attribute Summary
- #bucket_name ⇒ String readonly
- #etag ⇒ String readonly
- #id ⇒ String readonly
-
#is_latest ⇒ Boolean
readonly
Specifies whether the object is (true) or is not (false) the latest version of an object.
-
#key ⇒ String
readonly
The object key.
-
#last_modified ⇒ Time
readonly
Date and time the object was last modified.
- #object_key ⇒ String readonly
- #owner ⇒ Types::Owner readonly
-
#size ⇒ Integer
readonly
Size in bytes of the object.
-
#storage_class ⇒ String
readonly
The class of storage used to store the object.
Possible values:
. -
#version_id ⇒ String
readonly
Version ID of an object.
::Aws::Resources::Resource - Inherited
| #client | Marked private to prevent double documentation. |
| #data_loaded?, | |
| #identifiers | Marked private to prevent double documentation. |
Instance Method Summary
-
#delete(options = {}) ⇒ Types::DeleteObjectOutput
Removes the null version (if there is one) of an object and inserts a delete marker, which becomes the latest version of the object.
-
#get(options = {}) ⇒ Types::GetObjectOutput
Retrieves objects from Amazon S3.
-
#head(options = {}) ⇒ Types::HeadObjectOutput
The HEAD operation retrieves metadata from an object without returning the object itself.
- #object ⇒ Object
::Aws::Resources::Resource - Inherited
| #data, | |
| #load | Loads data for this resource. |
| #reload | Alias for Resources::Resource#load. |
| #wait_until | Waiter polls an API operation until a resource enters a desired state. |
Constructor Details
.new(bucket_name, object_key, id, options = {})
.new(options = {})
Instance Attribute Details
#bucket_name ⇒ String
(readonly)
#etag ⇒ String
(readonly)
#id ⇒ String
(readonly)
#is_latest ⇒ Boolean
(readonly)
Specifies whether the object is (true) or is not (false) the latest version of an object.
#key ⇒ String
(readonly)
The object key.
#last_modified ⇒ Time
(readonly)
Date and time the object was last modified.
#object_key ⇒ String
(readonly)
#owner ⇒ Types::Owner (readonly)
#size ⇒ Integer
(readonly)
Size in bytes of the object.
#storage_class ⇒ String
(readonly)
The class of storage used to store the object.
Possible values:
- STANDARD
#version_id ⇒ String
(readonly)
Version ID of an object.
Instance Method Details
#delete(options = {}) ⇒ Types::DeleteObjectOutput
Removes the null version (if there is one) of an object and inserts a delete marker, which becomes the latest version of the object. If there isn't a null version, Amazon S3 does not remove any objects.
#get(options = {}) ⇒ Types::GetObjectOutput
Retrieves objects from Amazon S3.
#head(options = {}) ⇒ Types::HeadObjectOutput
The HEAD operation retrieves metadata from an object without returning the object itself. This operation is useful if you're only interested in an object's metadata. To use HEAD, you must have READ access to the object.


--- layout: post title: I introduced a Y2K bug! tags: - ego - Software Development status: publish type: post published: true meta: {} --- An Agile trap for the unwary « Alec the Geek
Some of us may remember the Y2K bugSome of us actually introduced our own Y2K bug :-(. In about 1984 I was working in Jordan on an ATM system implementation. The customer has some very specific requirements with regard to keeping transaction records on the card magnetic strip. As you you can imagine there is very constrained space on the back of a bank card for information storage, so we stored the date of the last transaction as DDDYY (BCD storage for those that can remember back that far). I did point our that come the end of the century then I code would fall in a nasty heap, but was laughed at for being so niave as to think it would last that long. I often wondered what happened...
Powered by ScribeFire.


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Object org.apache.spark.Accumulable<R,T>
public class Accumulable<R,T>
A data type that can be accumulated, ie has an commutative and associative "add" operation,
but where the result type, R
, may be different from the element type being added, T
.
You must define how to add data, and how to merge two of these together. For some data types,
such as a counter, these might be the same operation. In that case, you can use the simpler
Accumulator
. They won't always be the same, though -- e.g., imagine you are
accumulating a set. You will add items to the set, and you will union two sets together.
param: initialValue initial value of accumulator
param: param helper object defining how to add elements of type R
and T
param: name human-readable name for use in Spark's web UI
| Constructor Summary | |
|---|---|
Accumulable(R initialValue,
AccumulableParam<R,T> param)
|
|
Accumulable(R initialValue,
AccumulableParam<R,T> param,
scala.Option<String> name)
|
| Method Summary | |
|---|---|
void |
add(T term)
Add more data to this accumulator / accumulable |
long |
id()
|
R |
localValue()
Get the current value of this accumulator from within a task. |
void |
merge(R term)
Merge two accumulable objects together |
scala.Option<String> |
name()
|
void |
setValue(R newValue)
Set the accumulator's value; only allowed on master |
String |
toString()
|
R |
value()
Access the accumulator's current value; only allowed on master. |
R |
zero()
|
| Methods inherited from class Object |
|---|
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
|---|
public Accumulable(R initialValue, AccumulableParam<R,T> param, scala.Option<String> name)
public Accumulable(R initialValue, AccumulableParam<R,T> param)
| Method Detail |
|---|
public scala.Option<String> name()
public long id()
public R zero()
public void add(T term)
term
- the data to addpublic void merge(R term)
Normally, a user will not want to use this version, but will instead call add
.
term
- the other R
that will get merged with thispublic R value()
public R localValue()
This is NOT the global value of the accumulator. To get the global value after a
completed operation on the dataset, call value
.
The typical use of this method is to directly mutate the local value, eg., to add an element to a Set.
public void setValue(R newValue)
newValue
- (undocumented)public String toString()
toString
in class Object
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


__all__ = ["NimiqClient", "InternalErrorException", "RemoteErrorException"]
from .models.account import *
from .models.block import *
from .models.mempool import *
from .models.miner import *
from .models.node import *
from .models.peer import *
from .models.transaction import *
import requests
from requests.auth import HTTPBasicAuth
from enum import Enum
[docs]class InternalErrorException(Exception):
"""
Internal error during a JSON RPC request.
"""
pass
[docs]class RemoteErrorException(Exception):
"""
Exception on the remote server.
"""
def __init__(self, message, code):
super(RemoteErrorException, self).__init__("{0} ({1})".format(message, code))
[docs]class NimiqClient:
"""
API client for the Nimiq JSON RPC server.
:param scheme: Protocol squeme, "http" or "https".
:type scheme: str, optional
:param user: Authorized user.
:type user: str, optional
:param password: Password for the authorized user.
:type password: str, optional
:param host: Host IP address.
:type host: str, optional
:param port: Host port.
:type port: int, optional
"""
def __init__(
self, scheme="http", user="", password="", host="<IP_ADDRESS>", port=8648
):
self.id = 0
self.url = "{0}://{1}:{2}".format(scheme, host, port)
self.auth = HTTPBasicAuth(user, password)
self.session = requests.Session()
def _call(self, method, *args):
"""
Used in all JSONRPC requests to fetch the data.
:param method: JSONRPC method.
:type method: str
:param params: Parameters used by the request.
:type params: list
:return: If succesfull, returns the model reperestation of the result, None otherwise.
:rtype: dict
"""
# increase the JSONRPC client request id
self.id += 1
# make JSON object to send to the server
call_object = {
"jsonrpc": "2.0",
"method": method,
"params": (list(args),),
"id": self.id,
}
# make request
req_error = None
try:
resp_object = self.session.post(
self.url, json=call_object, auth=self.auth
).json()
except Exception as e:
req_error = e
# raise if there was any error
if req_error is not None:
raise InternalErrorException(req_error)
error = resp_object.get("error")
if error is not None:
raise RemoteErrorException(error.get("message"), error.get("code"))
return resp_object.get("result")
def _get_account(self, data):
"""
Get the specific account type from the dictionary data.
:param data: The dictionary containing the data.
:type data: dict
:return: Account object.
:rtype: Account or VestingContract or HTLC
"""
type = data.get("type")
if type == AccountType.HTLC:
return HTLC(**data)
elif type == AccountType.VESTING:
return VestingContract(**data)
else:
return Account(**data)
[docs] def accounts(self):
"""
Returns a list of addresses owned by client.
:return: List of Accounts owned by the client.
:rtype: list of (Account or VestingContract or HTLC)
"""
return [self._get_account(account) for account in self._call("accounts")]
[docs] def block_number(self):
"""
Returns the height of most recent block.
:return: The current block height the client is on.
:rtype: int
"""
return self._call("blockNumber")
[docs] def consensus(self):
"""
Returns information on the current consensus state.
:return: Consensus state. "established" is the value for a good state, other values indicate bad.
:rtype: ConsensusState
"""
return ConsensusState(self._call("consensus"))
[docs] def constant(self, constant):
"""
Returns the value of the constant.
:param constant: The class and name of the constant (format should be "Class.CONSTANT").
:type constant: str
:return: The value of the constant.
:rtype: int
"""
return self._call("constant", constant)
[docs] def set_constant(self, constant, value=None):
"""
Overrides the value of a constant. It sets the constant to the given value. To reset the constant use reset_constant() instead.
:param constant: The class and name of the constant (format should be "Class.CONSTANT").
:type constant: str
:param value: The new value of the constant.
:type value: int, optional
:return: The new value of the constant.
:rtype: int
"""
return self._call("constant", constant, value)
[docs] def create_account(self):
"""
Creates a new account and stores its private key in the client store.
:return: Information on the wallet that was created using the command.
:rtype: Wallet
"""
return Wallet(**self._call("createAccount"))
[docs] def create_raw_transaction(self, transaction):
"""
Creates and signs a transaction without sending it. The transaction can then be send via sendRawTransaction() without accidentally replaying it.
:param transaction: The transaction object.
:type transaction: OutgoingTransaction
:return: Hex-encoded transaction.
:rtype: str
"""
return self._call("createRawTransaction", transaction)
[docs] def get_account(self, address):
"""
Returns details for the account of given address.
:param address: Address to get account details.
:type address: str
:return: Details about the account. Returns the default empty basic account for non-existing accounts.
:rtype: Account or VestingContract or HTLC
"""
return self._get_account(self._call("getAccount", address))
[docs] def get_balance(self, address):
"""
Returns the balance of the account of given address.
:param address: Address to check for balance.
:type address: str
:return: The current balance at the specified address (in smalest unit).
:rtype: int
"""
return self._call("getBalance", address)
[docs] def get_block_by_hash(self, hash, include_transactions=None):
"""
Returns information about a block by hash.
:param hash: Hash of the block to gather information on.
:type hash: str
:param include_transactions: If True it returns the full transaction objects, if False only the hashes of the transactions.
:type include_transactions: bool, optional
:return: A block object or None when no block was found.
:rtype: Block or None
"""
result = None
if include_transactions is not None:
result = self._call("getBlockByHash", hash, include_transactions)
else:
result = self._call("getBlockByHash", hash)
return Block(**result) if result is not None else None
[docs] def get_block_by_number(self, height, include_transactions=None):
"""
Returns information about a block by block number.
:param height: The height of the block to gather information on.
:type height: int
:param include_transactions: If True it returns the full transaction objects, if False only the hashes of the transactions.
:type include_transactions: bool, optional
:return: A block object or None when no block was found.
:rtype: Block or None
"""
result = None
if include_transactions is not None:
result = self._call("getBlockByNumber", height, include_transactions)
else:
result = self._call("getBlockByNumber", height)
return Block(**result) if result is not None else None
[docs] def get_block_template(self, address=None, extra_data=""):
"""
Returns a template to build the next block for mining. This will consider pool instructions when connected to a pool.
If address and extra_data are provided the values are overriden.
:param address: The address to use as a miner for this block. This overrides the address provided during startup or from the pool.
:type address: str
:param extra_data: Hex-encoded value for the extra data field. This overrides the extra data provided during startup or from the pool.
:type extra_data: str
:return: A block template object.
:rtype: BlockTemplate
"""
result = None
if address is not None:
result = self._call("getBlockTemplate", address, extra_data)
else:
result = self._call("getBlockTemplate")
return BlockTemplate(
BlockTemplateHeader(**result.get("header")),
result.get("interlink"),
BlockTemplateBody(**result.get("body")),
result.get("target"),
)
[docs] def get_block_transaction_count_by_hash(self, hash):
"""
Returns the number of transactions in a block from a block matching the given block hash.
:param hash: Hash of the block.
:type hash: str
:return: Number of transactions in the block found, or None, when no block was found.
:rtype: int or None
"""
return self._call("getBlockTransactionCountByHash", hash)
[docs] def get_block_transaction_count_by_number(self, height):
"""
Returns the number of transactions in a block matching the given block number.
:param height: Height of the block.
:type height: int
:return: Number of transactions in the block found, or None, when no block was found.
:rtype: int or None
"""
return self._call("getBlockTransactionCountByNumber", height)
[docs] def get_transaction_by_block_hash_and_index(self, hash, index):
"""
Returns information about a transaction by block hash and transaction index position.
:param hash: Hash of the block containing the transaction.
:type hash: str
:param index: Index of the transaction in the block.
:type index: int
:return: A transaction object or None when no transaction was found.
:rtype: Transaction or None
"""
result = self._call("getTransactionByBlockHashAndIndex", hash, index)
if result is not None:
return Transaction(**result)
else:
return None
[docs] def get_transaction_by_block_number_and_index(self, height, index):
"""
Returns information about a transaction by block number and transaction index position.
:param height: Height of the block containing the transaction.
:type height: int
:param index: Index of the transaction in the block.
:type index: int
:return: A transaction object or None when no transaction was found.
:rtype: Transaction or None
"""
result = self._call("getTransactionByBlockNumberAndIndex", height, index)
if result is not None:
return Transaction(**result)
else:
return None
[docs] def get_transaction_by_hash(self, hash):
"""
Returns the information about a transaction requested by transaction hash.
:param hash: Hash of a transaction.
:type hash: str
:return: A transaction object or None when no transaction was found.
:rtype: Transaction or None
"""
result = self._call("getTransactionByHash", hash)
if result is not None:
return Transaction(**result)
else:
return None
[docs] def get_transaction_receipt(self, hash):
"""
Returns the receipt of a transaction by transaction hash.
:param hash: Hash of a transaction.
:type hash: str
:return: A transaction receipt object, or None when no receipt was found.
:rtype: TransactionReceipt or None
"""
result = self._call("getTransactionReceipt", hash)
if result is not None:
return TransactionReceipt(**result)
else:
return None
[docs] def get_transactions_by_address(self, address, number_of_transactions=None):
"""
Returns the latest transactions successfully performed by or for an address.
Note that this information might change when blocks are rewinded on the local state due to forks.
:param address: Address of which transactions should be gathered.
:type address: str
:param number_of_transactions: Number of transactions that shall be returned.
:type number_of_transactions: int, optional
:return: List of transactions linked to the requested address.
:rtype: list of (Transaction)
"""
result = None
if number_of_transactions is not None:
result = self._call(
"getTransactionsByAddress", address, number_of_transactions
)
else:
result = self._call("getTransactionsByAddress", address)
return [Transaction(**tx) for tx in result]
[docs] def get_work(self, address=None, extra_data=""):
"""
Returns instructions to mine the next block. This will consider pool instructions when connected to a pool.
:param address: The address to use as a miner for this block. This overrides the address provided during startup or from the pool.
:type address: str
:param extra_data: Hex-encoded value for the extra data field. This overrides the extra data provided during startup or from the pool.
:type extra_data: str
:return: Mining work instructions.
:rtype: WorkInstructions
"""
result = None
if address is not None:
result = self._call("getWork", address, extra_data)
else:
result = self._call("getWork")
return WorkInstructions(**result)
[docs] def hashrate(self):
"""
Returns the number of hashes per second that the node is mining with.
:return: Number of hashes per second.
:rtype: float
"""
return self._call("hashrate")
[docs] def set_log(self, tag, level):
"""
Sets the log level of the node.
:param tag: Tag: If "*" the log level is set globally, otherwise the log level is applied only on this tag.
:type tag: str
:param level: Minimum log level to display.
:type level: LogLevel
:return: True if the log level was changed, False otherwise.
:rtype: bool
"""
return self._call("log", tag, level)
[docs] def mempool(self):
"""
Returns information on the current mempool situation. This will provide an overview of the number of transactions sorted into buckets based on their fee per byte (in smallest unit).
:return: Mempool information.
:rtype: MempoolInfo
"""
result = self._call("mempool")
return MempoolInfo(**result)
[docs] def mempool_content(self, include_transactions=None):
"""
Returns transactions that are currently in the mempool.
:param include_transactions: If True includes full transactions, if False includes only transaction hashes.
:type include_transactions: bool, optional
:return: List of transactions (either represented by the transaction hash or a transaction object).
:rtype: list of (Transaction or str)
"""
result = None
if include_transactions is not None:
result = self._call("mempoolContent", include_transactions)
else:
result = self._call("mempoolContent")
return [tx if type(tx) is str else Transaction(**tx) for tx in result]
[docs] def miner_address(self):
"""
Returns the miner address.
:return: The miner address configured on the node.
:rtype: str
"""
return self._call("minerAddress")
[docs] def miner_threads(self):
"""
Returns the number of CPU threads for the miner.
:return: The number of threads allocated for mining.
:rtype: int
"""
return self._call("minerThreads")
[docs] def set_miner_threads(self, threads=None):
"""
Sets the number of CPU threads for the miner.
:param threads: The number of threads to allocate for mining.
:type threads: int, optional
:return: The new number of threads allocated for mining.
:rtype: int
"""
return self._call("minerThreads", threads)
[docs] def min_fee_per_byte(self):
"""
Returns the minimum fee per byte.
:return: The new minimum fee per byte.
:rtype: int
"""
return self._call("minFeePerByte")
[docs] def set_min_fee_per_byte(self, fee=None):
"""
Sets the minimum fee per byte.
:param fee: The new minimum fee per byte.
:type fee: int, optional
:return: The new minimum fee per byte.
:rtype: int
"""
return self._call("minFeePerByte", fee)
[docs] def is_mining(self):
"""
Returns true if client is actively mining new blocks.
:return: True if the client is mining, otherwise False.
:rtype: bool
"""
return self._call("mining")
[docs] def set_mining(self, state=None):
"""
Sets the client mining state.
:param state: The state to be set.
:type state: bool
:return: True if the client is mining, otherwise False.
:rtype: bool
"""
return self._call("mining", state)
[docs] def peer_count(self):
"""
Returns number of peers currently connected to the client.
:return: Number of connected peers.
:rtype: int
"""
return self._call("peerCount")
[docs] def peer_list(self):
"""
Returns list of peers known to the client.
:return: The list of peers.
:rtype: list of (Peer)
"""
return [Peer(**peer) for peer in self._call("peerList")]
[docs] def peer_state(self, address):
"""
Returns the state of the peer.
:param address: The address of the peer.
:type address: str
:return: The current state of the peer.
:rtype: Peer
"""
return Peer(**self._call("peerState", address))
[docs] def set_peer_state(self, address, command=None):
"""
Returns the state of the peer.
:param address: The address of the peer.
:type address: str
:param command: The command to send.
:type command: PeerStateCommand
:return: The new state of the peer.
:rtype: Peer
"""
return Peer(**self._call("peerState", address, command))
[docs] def pool(self):
"""
Returns the mining pool.
:return: The mining pool connection string, or None if not enabled.
:rtype: str or None
"""
return self._call("pool")
[docs] def set_pool(self, address=None):
"""
Sets the mining pool.
:param address: The mining pool connection string ("url:port") or boolean to enable/disable pool mining.
:type address: str, optional
:return: The new mining pool connection string, or None if not enabled.
:rtype: str or None
"""
return self._call("pool", address)
[docs] def pool_confirmed_balance(self):
"""
Returns the confirmed mining pool balance.
:return: The confirmed mining pool balance (in smallest unit).
:rtype: int
"""
return self._call("poolConfirmedBalance")
[docs] def pool_connection_state(self):
"""
Returns the connection state to mining pool.
:return: The mining pool connection state.
:rtype: PoolConnectionState
"""
return PoolConnectionState(self._call("poolConnectionState"))
[docs] def send_raw_transaction(self, transaction):
"""
Sends a signed message call transaction or a contract creation, if the data field contains code.
:param transaction: The hex encoded signed transaction
:type transaction: str
:return: The Hex-encoded transaction hash.
:rtype: str
"""
return self._call("sendRawTransaction", transaction)
[docs] def send_transaction(self, transaction):
"""
Creates new message call transaction or a contract creation, if the data field contains code.
:param transaction: The transaction object.
:type transaction: OutgoingTransaction
:return: The Hex-encoded transaction hash.
:rtype: str
"""
return self._call("sendTransaction", transaction)
[docs] def submit_block(self, block):
"""
Submits a block to the node. When the block is valid, the node will forward it to other nodes in the network.
:param block: Hex-encoded full block (including header, interlink and body). When submitting work from getWork, remember to include the suffix.
:type block: Block
"""
self._call("submitBlock", block)
[docs] def syncing(self):
"""
Returns an object with data about the sync status or False.
:return: An object with sync status data or False, when not syncing.
:rtype: SyncStatus
"""
result = self._call("syncing")
if type(result) is not bool:
return SyncStatus(**result)
else:
return result
[docs] def get_raw_transaction_info(self, transaction):
"""
Deserializes hex-encoded transaction and returns a transaction object.
:param transaction: The hex encoded signed transaction.
:type transaction: str
:return: The transaction object.
:rtype: Transaction
"""
return Transaction(**self._call("getRawTransactionInfo", transaction))
[docs] def reset_constant(self, constant):
"""
Resets the constant to default value.
:param constant: Name of the constant.
:type constant: str
:return: The new value of the constant.
:rtype: int
"""
return self._call("constant", constant, "reset")


Welcome to QuaPy’s documentation!¶
QuaPy is an open source framework for Quantification (a.k.a. Supervised Prevalence Estimation) written in Python.
Introduction¶
QuaPy roots on the concept of data sample, and provides implementations of most important concepts in quantification literature, such as the most important quantification baselines, many advanced quantification methods, quantification-oriented model selection, many evaluation measures and protocols used for evaluating quantification methods. QuaPy also integrates commonly used datasets and offers visualization tools for facilitating the analysis and interpretation of results.
A quick example:¶
The following script fetchs a Twitter dataset, trains and evaluates an Adjusted Classify & Count model in terms of the Mean Absolute Error (MAE) between the class prevalences estimated for the test set and the true prevalences of the test set.
import quapy as qp
from sklearn.linear_model import LogisticRegression
dataset = qp.datasets.fetch_twitter('semeval16')
# create an "Adjusted Classify & Count" quantifier
model = qp.method.aggregative.ACC(LogisticRegression())
model.fit(dataset.training)
estim_prevalences = model.quantify(dataset.test.instances)
true_prevalences = dataset.test.prevalence()
error = qp.error.mae(true_prevalences, estim_prevalences)
print(f'Mean Absolute Error (MAE)={error:.3f}')
Quantification is useful in scenarios of prior probability shift. In other words, we would not be interested in estimating the class prevalences of the test set if we could assume the IID assumption to hold, as this prevalence would simply coincide with the class prevalence of the training set. For this reason, any Quantification model should be tested across samples characterized by different class prevalences. QuaPy implements sampling procedures and evaluation protocols that automates this endeavour. See the Evaluation for detailed examples.
Features¶
Implementation of most popular quantification methods (Classify-&-Count variants, Expectation-Maximization, SVM-based variants for quantification, HDy, QuaNet, and Ensembles).
Versatile functionality for performing evaluation based on artificial sampling protocols.
Implementation of most commonly used evaluation metrics (e.g., MAE, MRAE, MSE, NKLD, etc.).
- Popular datasets for Quantification (textual and numeric) available, including:
32 UCI Machine Learning datasets.
11 Twitter Sentiment datasets.
3 Reviews Sentiment datasets.
4 tasks from LeQua competition (_new in v0.1.7!_)
Native supports for binary and single-label scenarios of quantification.
Model selection functionality targeting quantification-oriented losses.
Visualization tools for analysing results.


Warner Beach stolen scooter recovered
After getting the footage from the Warners Crime Group, it led us to a residence in Malugazi.
by Earl BaillacheA scooter stolen from Veary Road in Warner Beach on Thursday, 21 December was recovered on the same day by the CCPO. “Camera footage showed us who the culprits were and after getting the footage from the Warners Crime Group, it led us to a residence in Malugazi, near Isipingo,” said CCPO committee member, George Snodey.
Accompanied by ET Rapid Response officers, who had already called SAPS and Metro Police K9 unit for back-up, the scooter was found hidden behind other vehicles. The vehicle used in the theft was also parked on the property. One suspect was detained for questioning and the scooter taken to Toti SAPS.
READ ALSO: 622 arrested during festive season operation
DID YOU KNOW?
Click on the words highlighted in red to read more on this and related topics.
To receive news links via WhatsApp or Telegram, send an invite to<PHONE_NUMBER>
The South Coast Sun is also on Facebook, Twitter, Instagram and Pinterest – why not join us there?
Do you have more information pertaining to this story?
Feel free to let us know by commenting on our Facebook page or you can contact our newsroom on<PHONE_NUMBER> and speak to a journalist.


G93: A Fast, File-Based API for Managing Raster Data
Gridfour's G93 file-based API helps Java applications manage raster (grid) data in situations where the size of the data exceeds what could reasonably be kept in memory. To do so, it provides utilities that allow an application to seamlessly swap blocks of the grid between memory and data files. The G93 library and file format also provide a way of storing raster data in files that can be shared between applications or used across multiple application runs. And, in cases where storage space or transmission bandwidth is limited, G93 provides built-in data compression that can reduce storage requirements by at least a factor of four.
This article gives an introduction to the Java API for G93 and offers example code showing how to use it in your own applications. As usual, code for the applications described in this article is available from the Gridfour Software Project. You may find the code in the Gridfour demo code tree in the class PackageData.java
An article that describes how to use an API to manipulate and store data would surely benefit from have a good source of data to use as an example. We are fortunate to have two: ETOPO1 and GEBCO_2019. These products give world-wide Earth surface elevations and ocean depth (bathymetry) values in a regular geographic coordinate grid.
In the ETOPO1 product, grid points are given in a regular spacing of 1 minute of arc (e.g. 60 rows or columns for each degree of latitude or longitude). Thus ETOPO1 includes (360x60)x(180x60) data values, or about 233 million samples. Storing that many numeric values in memory requires a lot of capacity, but is not out-of-reach for a modern computer. The GEBCO product, however, uses a finer resolution based on a grid spacing of 15 seconds of arc (e.g. 240 rows or columns for each degree of latitude or longitude). That spacing results in a data collection containing 3.7 billion samples. And while there are plenty of computers with sufficient memory to hold that much data, it wouldn't leave much room for anything else.
Fortunately, when dealing with such large data sets, applications seldom need to access the entire collection all at once. So an obvious solution to the problem of memory use is to store the data on a file and load (or store) pieces of it on an as-needed basis. This approach is used in data formats such as the TIFF image specification which partition large grids into smaller, regularly sized sub-grids known as tiles (Adobe, 1992, pg. 68).
The basic idea of tiling a grid can be seen in the image below. In this case, a grid consisting of six rows and nine columns is divided into six 3-by-3 tiles.
In G93, the size of tiles are arbitrary, though all tiles must be of a uniform size. Applications are free to specify tile sizes according to their needs. In this case, a 2-by-9 tile would have worked just fine. In fact, a 4-by-5 tile size would also work, even though the tiles would not evenly divide the 6-by-9 master grid. The G93 API handles any extra cells internally and their management is transparent to the application.
The figure below illustrates how a tiling scheme works. A collection of surface elevation and bathymetry data could be divided into regular tiles ten-degrees across. An application requiring access to information in Europe would load the relevant tiles without needing to access information from South America.
In the case of the ETOPO1 data set, the PackageData demonstration application specifies a grid of 90 rows by 120 columns. In terms of geographic coordinates, the 1-minute resolution used in ETOPO1 means that these tiles will cover an area with a span of 1.5 degrees latitude and 2 degrees of longitude. This size was chosen after some experimentation because it gives a good data compression results and provides a convenient size for access.
Tiling is a core feature of the G93 API and deeply involved in all its operations. In fact, even a small grid is treated as being tiled, though it is completely reasonable to specify a tile size that matches that of the entire grid.
A few other details about G93 tiling are worth noting:
The G93 library is a tool for both creating raster files and accessing them. Writing a G93 file is a 3 step process:
The code fragment below is taken from the PackageData example application (with some simplifications applied for the sake of this discussion). PackageData extracts elevation and bathymetry values from the ETOPO1 and GEBCO products, and stores the information in a G93 file with optional data compression. Both ETOPO1 and GEBCO are distributed in a file format called NetCDF. We have posted an article that provides background information on NetCDF files as well as details for reading their content at How-to-Extract-Data-from-a-NetCDF-File.
The parameters for the number of rows and columns in the grid are based on the dimensions of the source data. The number of rows and columns in the tile were chosen because they seemed well suited to the needs of an application that might use the G93 file.
NetcdfFile ncfile = NetcdfFile.open(filePathToSourceETOPO1); Variable z = ncfile.findVariable("z"); // the NetCDF variable for reading values int nRowsInGrid = 10800; // spans 90 south to 90 north int nColsInGrid = 21600; // spans 180 west to 180 east int nRowsInTile = 90; int nColsInTile = 120; // Create a specification for the overall grid and tiling. G93FileSpecification spec = new G93FileSpecification(nRowsInGrid, nColsInGrid, nRowsInTile, nColsInTile); // Create a G93-formatted file for output File outputFile = new File("ETOPO1.g93"); G93File g93File = new G93File(outputFile, spec);
When a G93 file is created, the metadata from the specification object is used to populate the header file. Some of this metadata is immutable and must be fully specified before the output file is created, other elements can be adjusted after the file is opened. We will look at some of these setting later on.
As shown in the code block below, storing data in a G93 file is a relatively straightforward process. In fact, most of complexity in the code example comes from accessing the NetCDF data rather than writing the G93. The example reads data from the source file one row at a time. This is the most efficient pattern for accessing the ETOPO1 file.
// initialize access specifications for NetCDF. int[] readOrigin = new int[2]; int[] readShape = new int[2]; for (int iRow = 0; iRow < nRowsInGrid; iRow++) { readOrigin[0] = iRow; readOrigin[1] = 0; readShape[0] = 1; readShape[1] = nColsInGrid; // Read one row of data from the NetCDF file. // The data will be stored in a NetCDF "Array" object. // Then loop on each column, obtain the elevation/bathymetry data // and store it in G93. ETOPO1 stores data as integers. // GEBCO_2019 stores it as doubles. Array array = z.read(readOrigin, readShape);. for (int iCol = 0; iCol < nColsInGrid; iCol++) { int sample = array.getInt(iCol); g93.storeValue(iRow, iCol, sample); } } g93.flush(); g93.close();
The snippet above would work just fine, except that it might be a little slower than we would prefer. The reason for this is that each row stored to the data file requires swapping tiles in and out of memory. Because there are 21600 columns in the master grid and 120 columns in each tile, there are 21600/120 = 180 tiles in each row of the tiling scheme. So in order to keep an entire row of the master-grid data in memory, the G93 API needs to keep 180 tiles in its cache. But, by default, the G93 cache size is only 16 tiles in size. And 16 tiles is not wide enough to hold an entire row of data. Because the storage process scans one-row-at-a-time, the cache has to drop and load tiles 180 times per row. This approach leads to a lot of redundant reading and writing of tiles.
Fortunately, the tile cache size can be adjusted by using the following adjustment before storing the data.
g93.setTileCacheSize(G93CacheSize.Large);
The adjustment is applied after the G93File is opened, but before the application starts to access data. The "Large" cache size adjustment tells G93 to adjust the size of the cache so that it is large enough to store an entire row (or entire column) of tiles. Tiles use 4 bytes per each value stored in memory. Because this example code specifies a tile size of 90-by-120 grid values, an entire row of 180 tiles would require 180x90x120x4 = 7776000 bytes (about 7.4 megabytes). This setting is not onerous, and it will dramatically improve the speed of writing a file.
How much difference does the larger cache make? With the default "Medium" cache size, the time required to store ETOPO1 in uncompressed format was 237.2 seconds. With the "Large" size setting, it was only 8.6 seconds. The use of a large cache can also be useful when reading data. In testing, we compared the access time using both a Medium and Large cache size for reading the entire 233 million sample set from the G93-formatted version of ETOPO1. Using the Medium cache, the read operation required 69.8 seconds. Using the Large cache, the operation required only 3.6 seconds.
Here it is worth emphasizing that the need for a larger cache size is due to the pattern-of-access applied in packaging the data. Had the packaging process populated a single tile at a time (rather than spanning an entire row of tiles), the increased tile cache size would not have been required. This consideration applies both when writing data and when reading data for a G93 file.
By run-time settings, we are referring to those parameters that can be set using access methods for the G93File class after a G93File is opened. These parameters are not part of the file definition and are not stored between sessions.
We already introduced the tile-cache size and described how it can affect run-time performance. The other setting of interest is
g93.setIndexCreationEnabled(boolean enabled);
When writing data to a G93 file, we have the option of telling G93 to write an index file when the file is closed. The index file is a companion data file written with the sample root name as the G93 file and the file extension ".g9x". The index carries information about the location of tiles within the G93 file. Without the index, the G93File class has to perform a scan of the full file at start-up. Since G93 files can be quite large, such scans can take a few seconds (more on slow file systems). The availablity of an index expedites that process considerably. Again, the index file is optional. If it was accidentally deleted, the G93 API would be able to open the main file just fine.
In addition to the overall grid size and tiling scheme specifications, there are a number of other settings that can be stored in a G93 file header when it is created. These settings are supplied through calls to the G93FileSpecification class' access methods.
The main G93File API allows an application to read and write raster data values by supplying the row and column indices for the values of interest. Many real-world applications depend on a horizontal coordinate system that relate these values not to grid coordinates, but real-valued position information.
Gridfour allows an application to specify two broad categories of coordinate systems for file access: Cartesian Coordinates and Geographic Coordinates.
Although Gridfour is not limited to geographic coordinate systems, the two example products we used for this wiki-article are geographic in nature. So we will begin with the specification for a geographic coordinate system.
As mentioned above, the row and column spacing for ETOPO1 is a uniform 1 minute of arc (1/60th of a degree). There are a couple of ETOPO1 variations. The one chosen for this discussion runs from south to north and west to east. The latitudes start just above the South Pole and run to just below the North. The longitudes start just to the east of the International Date Line (-179.99166 longitude) and extend to just to its west (+179.99166 longitude). The following code snippet shows an example of how a specification for ETOPO1 geographic coordinates could be constructed:
G93FileSpecification spec = new G93FileSpecification(nRows, nCols, nRowsInTile, nColsInTile); double h = 1.0/60.0; // one minute spacing, 1/60th of a degree spec.setGeographicCoordinates( -90+h/2, // south, first row in grid -180+h/2, // west, first column in grid 90-h/2, // north, last row in grid 180-h/2); // east, last column in grid
Note that the geographic coordinates are given in degrees and specified in the order latitude, longitude. West longitudes are given as negative values. East longitudes are given as positive values.
As an example of Cartesian coordinates, consider an example in which the (x, y) coordinates are normalized between 0 and 1. In that case, we might specify coordinates using the following
G93FileSpecification spec = new G93FileSpecification(nRows, nCols, nRowsInTile, nColsInTile); spec.setCartesianCoordinates( 0, // x coordinate of first column in grid 0, // y coordinate of first row in grid 1, // x coordinate of last column in grid 1); // y coordinate of last row in grid
The order of the Cartesian coordinates follows the standard practice of being given as (x, y). In the example above, we assumed that the coordinates were increasing as the row and column index increased. Consider the case where the x coordinate increased which the y coordinate decreased. Such a specification would look like:
spec.setCartesianCoordinates( 0, // x coordinate of first column in grid 1, // y coordinate of first row in grid 1, // x coordinate of last column in grid 0); // y coordinate of last row in grid
The G93File class implements methods for mapping Cartesian or Geographic coordinates to grid coordinates and vice versus. These are shown below:
public double []mapGridToCartesian(double row, double column) // returns x,y public double []mapCartesianToGrid(double x, double y) public double []mapGridToGeographic(double row, double column) // returns lat, lon public double []mapGeographicToGrid(double latitude, longitude)
Note that the mapping functions may return and/or accept fractional values for the row and column values the process. This feature is intended to support data value interpolation.
G93Files can process either scalar values or vector values. For example, surface elevation is a scalar value. But ocean currents or surface winds have both direction and magnitude and are usually treated as vectors. For G93, scalar values are said to be of dimension 1. A vector such as Earth surface wind data would be of dimension 2. Higher dimension data is also supported.
G93Files also allow the specification of integer data or floating point values.
The data type and dimension are specified using one of the following calls:
spec.setDataModelInt( int dimension); spec.setDataModelFloat(int dimension); spec.setDataModelIntegerScaledFloat(int dimension, double scale, double offset);
The scale and offset values specified as part of the integer-scaled-float model are used in cases where floating point values are to be converted to integers for internal storage. While this approach can result in reduced precision for the input data, it has advantages when compressing the data. The G93 implementations of integer compression attain better compression ratios than the implementation for floating-point values. If data compression is not required, the integer-scaled option has little advantage. However, it is worth noting that this format is sometimes encountered in raster data formats used for publicly available data sources and the G93 equivalent may be useful in handling such source.
Scale and offset are treated as follows:
intValue = (floatValue-offset) * scale floatValue = (intValue/scale) + offset
Data compression is enabled as part of the file specification:
spec.setDataCompressionEnabled(compressionEnabled);
Data compression is an interesting topic and is discussed in more detail elsewhere in these notes (see Gridfour Raster Data Compression Algorithms and Lossless Compression for Floating Point Data). Here, we simply note it's impact on the storage for ETOPO1 and GEBCO_2019 data. In its native, uncompressed form, ETOPO1 data is stored as a 4-byte integer. GEBCO_2019 is stored as a 4-byte float. Both of these would require 32 bits per sample if they were stored without data compression. The Gridfour library provides lossless data compression for both integer and float formats. Because integer forms tend to compress better than floating-point data, GEBCO data compresses better if it is converted to an integer form. In the table below, data for GEBCO is given for both its native floating point format and as scaled integer. GEBCO x 1 is rounded to the nearest meter, GEBCO x 2 to the nearest half meter. The larger scaling factor increases the amount of information to be stored in the output file, and thus the bits-per-sample values increases.
| Product | Size (bits/sample) | Number of Samples | Time to Process (sec) |
|---|---|---|---|
| ETOPO1 | 4.460 | 233,280,000 | 68.3 |
| GEBCO (float) | 15.354 | 3,732,480,000 | 765.2 |
| GEBCO x 1 | 2.909 | 3,732,480,000 | 1215.5 |
| GEBCO x 2 | 3.590 | 233,280,000 | 1320.3 |
Earlier, we mentioned that the storage time for the uncompressed version of ETOPO1 was 8.6 seconds. As the values in the table show, compressing the data requires more processing and increases the time to process to 68.3 seconds. However, most data compression techniques in use today require far less processing to decompress data than to compress it. This generalization is also true for all the currently implemented Gridfour data compression utilities. While it took over a minute to compress the ETOPO1 data, the time required to read the entire 233 million points in the compressed data set was only 6.3 seconds.
Even though the integer-coded GEBCO x 1 and the ETOPO1 products represent elevations with the same precision (as integral meters), the bits per-sample-value for GEBCO x 1 is lower than that for ETOPO1. This difference occurs because the sample points in the GEBCO grid are spaced closer together than those for ETOPO1 (15 seconds of arc versus 1 minute of arc). With the closer spacing, there tends to be less variation from sample to sample, which leads to an improved predictability in the data. With improved predictability, better data compression ratios can be attained
In order to maintain a simple design, the G93 API presents a deliberately minimal feature set. Even so, we recognize that many users have application-specific requirements for the product. In some cases, users may wish to attach supplemental data to a G93 file. This requirement can be met through the use of the Variable-Length Record feature.
Variable-Length Records (VLRs) are blocks of text or binary data that can be stored as part of a G93 file. The G93 API treats these elements as opaque and does not perform any operation related to their content. These elements may be stored or retrieved using identification tags provided by the application.
The ETOPO1 and GEBCO products provide an example of how this feature may be used. Both data sets are based on geophysical information and, naturally, there are industry standards for specifying metadata related to their content. Because G93 is intended to be a general-purpose utility, adding direct support for such standards is outside its scope. However, the PackageData demonstration application implements code for storing relevant metadata in a G93 file.
The metadata bundled with the demonstration code is based on the Well-Known Text (WKT) standard which is supported by many Geographic Information Systems. Well-Known Text files provide information about coordinate systems (map projections), units of measure, and specifications for Earth's size and shape ("datums"), and other information needed to accurately represent the data on a map. While neither ETOPO1 nor GEBCO supply WKT files in their distributions, both include relevant specifications on their product web sites. For the demo, we used the information to create a file called GlobalMSL.prj that contains metadata in WKT format.
Variable-Length Records are stored using a call to the G93File class' storeVariableLengthRecord() method as shown in the following code snippet:
byte []b; // an array of bytes containing the WKT data g93.storeVariableLengthRecord( "G93_Projection", 2111, "WKT Projection Metadata", b, 0, b.length, true);
The first two arguments in the call provide application-defined identification keys for the variable-length text. The last argument indicates that the payload (content) for the VLR is a text product. An application wishing to fetch the information from the G93 file would do so by calling
VariableLengthRecord vlr = g93.getVariableLengthRecord("G93_Projection", 2111); String payloadText = vlr.readPayloadText();
The method that fetches the VLR is named "get" because the record identifications are loaded from a G93 file when it is initially opened. So the method simply gets the identification from memory. However, the method that fetches the text is named "read" because a file-read operation is needed to retrieve it.
As mentioned above, the assignment of the identification string and numeric value (in this case, "G93_Projection" and 2111) are arbitrary and are defined by the application. The parameters used for this example are based on the LAS file standard that are used for terrestrial Lidar data sets. For background on Lidar systems, see What is Lidar? at the National Oceanic and Atmospheric Administration web site. The LAS standard defines a data structure called "Variable Length Record" which was the model for the G93 implementation. LAS uses the identifications LASF_Projection, 2111 for Well-Known Text.
At present, there is no registry or official standard for specifying identification strings in G93. The development of such a resource would depend on much wider adoption of G93 than is currently the case.
The information given in this wiki article should be enough to get you started using G93. The use of many of the functions described above is demonstrated in the PackageData.java application included in the Gridfour software distribution.
The G93 API is still under development. While it has undergone quite a bit of testing, it has seen very little actual use. If you encounter issues using G93, please let us know. Also, if you identify new features or enhancements you would like added to the API, we welcome your suggestions.
Adobe Systems Inc., 1992.TIFF Revision 6.0, Final-June 3, 1992. Accessed December 2019 from https://www.itu.int/itudoc/itu-t/com16/tiff-fx/docs/tiff6.pdf
General Bathymetric Chart of the Oceans [GEBCO], 2019.GEBCO Gridded Bathymetry Data. Accessed December 2019 from https://www.gebco.net/data_and_products/gridded_bathymetry_data
National Oceanographic and Atmospheric Administration [NOAA], 2019. ETOPO1 Global Relief Model. Accessed December 2019 from https://www.ngdc.noaa.gov/mgg/global/
Sonalysts, Inc., 2019.wXstation. Accessed December 2019 from http://www.sonalysts.com/products/wxstation/
University Corporation for Atmospheric Research [UCAR], 2019.NetCDF-Java Library Accessed December 2019 from https://www.unidata.ucar.edu/software/netcdf-java/current/


Author Name is required
Quote field is required
Person Submitting Name is required
{{newQuote.createdDate|date}}


# Environment Setup To get support for `VK_NV_ray_tracing`, please install an [NVIDIA driver](http://www.nvidia.com/Download/index.aspx?lang=en-us) with version 440.97 or later, and the [Vulkan SDK](http://vulkan.lunarg.com/sdk/home) version <IP_ADDRESS> or later. This tutorial is a modification of [`ray_tracing__simple`](https://github.com/nvpro-samples/vk_raytracing_tutorial/tree/master/ray_tracing__simple), which is the result of the ray tracing tutorial. All following instructions are based on the modification of this project. Beside the current repository, you will also need to clone or download the following repositories: * [nvpro_core](https://github.com/nvpro-samples/nvpro_core): The primary framework that all samples depend on. The directory structure should look like this: ********************************************************** * \ * | * +-- 📂 nvpro_core * | * +-- 📂 vk_raytracing_tutorial * | | * | +-- 📂 ray_tracing__simple (<-- Start here) * | | * | +-- 📂 ray_tracing_... * | ⋮ * | * ⋮ ********************************************************** !!! Warning **Run CMake** in vk_raytracing_tutorial.


Two mandatory data connections must be created: Butler_GET
and Butler_POST
.
The latter is used both for POST calls and also PUT, DELETE and other HTTP operations.
The X-HTTP-Method-Override
HTTP header is used with the Butler_POST data connection to tell Butler which HTTP operation should be used.
This is a way to work around a limitation of Qlik’s REST connector, as it only supports GET and POST operations.
One data connection is optional: URL encode table
It is used to URL encode strings, which is useful when passing strings to Butler’s REST API (or other APIs!).
URL encode table
Optional
Creating this data connection is optional.
That said, if you plan to use the Slack, Teams, email, or webhook connectivity features of Butler, you should create this data connection.
This is a basic “web file” connector pointing to http://www.w3schools.com/tags/ref_urlencode.asp
:
Remember!
As with all new data connections, Sense will change the name your new connection (adding your username as a suffix).Use the QMC to change the name to “URL encode table”.
Butler_GET
Mandatory
These settings are mandatory if you plan to use Butler’s REST API from the load scripts of Sense apps.With Butler running, create a new REST data connection called “Butler_GET”.
It’s URL should point to Butler’s host/port.
When createing REST data connections it’s always a good idea to verify they work.
Using the /v4/butlerping
endpoint is an easy way to do this (assuming that endpoint is enabled in Butler’s config file):
Creating the data connection can look like this:
No special settings are needed - just make sure the REST connector finds Butler as it should.
The actual URL of the data connection will be modified on the fly every time you call the Butler APIs, it’s thus not really important which URL is entered during the setup phase. But the /v4/butlerping
endpoint is a conveneint way to check that the data connection works.
Test the connection before creating it:
Remember!
As with all new data connections, Sense will change the name your new connection (adding your username as a suffix).Use the QMC to change the name to “Butler_GET”.
Butler_POST
Mandatory
These settings are mandatory if you plan to use Butler’s REST API from the load scripts of Sense apps.The data connection used for POST, PUT, DELETE and all other HTTP operations beyond GET should be named “Butler_POST”.
Its configuration is similar to that of Butler_GET, except that a message body is also needed for the POST to work.
Assuming Butler’s key-value store is enabled in the main config file, you can create a dummy key-value pair using a POST command with the following payload.
The effect is that the data connection is created and can be used for future POST/PUT/DELETE operations against Butler’s API.
The fact that is was created against the key-value store doesn’t matter, the data conncetion details will be replaced each time it is used.
{
"key": "abc",
"value": "123",
"ttl": "5000"
}
Creating the data connection can look like this:
… and test the connection before creting it.
Remember!
As with all new data connections, Sense will change the name your new connection (adding your username as a suffix).Use the QMC to change the name to “Butler_POST”.


This section explains how to use the GNU Emacs interface for SICStus Prolog, and how to customize your GNU Emacs environment for it.
Emacs is a powerful programmable editor especially suitable for program development. It is available for free for many platforms, including various UNIX dialects, Windows and Mac OS X. For information specific to GNU Emacs or XEmacs, see http://www.gnu.org and http://www.xemacs.org respectively. For information on running Emacs under Windows, see the `GNU Emacs FAQ For Windows 98/ME/NT/XP and 2000' at http://www.gnu.org/software/emacs/windows/ntemacs.html, much of which applies to both GNU Emacs and XEmacs.
The advantages of using SICStus in the Emacs environment are source-linked debugging, auto indentation, syntax highlighting, help on predefined predicates (requires the SICStus info files to be installed), loading code from inside Emacs, auto-fill mode, and more.
The Emacs interface is not part of SICStus Prolog proper, but is included in the distribution for convenience. It was written by Emil Ĺström and Milan Zamazal, based on an earlier version of the mode written by Masanobu Umeda. Contributions has also been made by Johan Andersson, Peter Olin, Mats Carlsson, Johan Bevemyr, Stefan Andersson, and Per Danielsson, Henrik Bĺkman, and Tamás Rozmán. Some ideas and also a few lines of code have been borrowed (with permission) from Oz.el by Ralf Scheidhauer and Michael Mehl, the Emacs major mode for the Oz programming language. More ideas and code have been taken from the SICStus debugger mode by Per Mildner.


Full Width & Custom CSS3 Transition Animation
Note: Touch-friendly Drag and Drop
Parallax Effect
Set the data-my-parallax
property to make parallax effect.
Default Options
Special Options Using data-*
Attributes
With Timeline
Set the data-my-nav-timeline
property to display timeline effect.
Next/Prev Image Thumbnail In Navigation
Set the data-my-prev-next-thumbs
property to display Next/Prev image thumbnail in navigation.
Video Slider
Set the data-embed-video-wrapper
property to listen for video play events.
Custom Navigation Buttons
Set the data-my-controls
property to be used in lieu of dynamic controlNav.
Multiple Items
Set the data-my-multiple-items
and data-my-multiple-items-move
properties to control the number of items displayed.
Add Counter
Set data-my-count-total
and data-my-count-now
properties to display counter.
Add CounterThumbnail ControlNav Pattern
Set the data-my-nav-thumbs
property to match a simple pattern.
Sync Multiple Sliders
Set the data-my-sync
property to sync multiple sliders.
Full Screen Slider
You need add an attribute data-slider-bg
to .uix-flexslider__item
. Simultaneously, use the .is-fullscreen
class on your .uix-flexslider--primary
div


Table
Class which represent a table. Provides attributes and methods for details of the table. Tables have relationships with other tables.
Below is a database schema which is used in code examples.
size -------------------
id (PK) | ---------------------------< line_item >------------ cart
name | | product_id (PFK) id (PK)
| | cart_id (PFK) name
^ |
color -------------< product >------------- vendor
id (PK) id (PK) id (PK)
name name name
color_id (FK)
size_id (FK)
vendor_id (FK)
Below is the same schema as image:
Kind: global class
- Table
- new Table(args)
- .name :
string
- .fullName :
string
- .fullCatalogName :
string
- .schema :
Schema
- .parent :
Schema
- .comment :
string
- .commentData :
Object
- .description :
string
- .descriptionData :
Object
- .kind :
string
- .columns :
Map.<Column>
- .constraints :
Map.<Constraint>
- .db :
Db
- .foreignKeyConstraints :
Map.<Constraint>
- .foreignKeyColumns :
Map.<Column>
- .foreignKeyConstraintsToThis :
Map.<Constraint>
- .primaryKeyConstraint :
Constraint
|undefined
- .primaryKeyColumns :
Map.<Column>
- .hasManyTables :
Map.

- .belongsToTables :
Map.

- .belongsToManyTables :
Map.

- .belongsToManyTablesPk :
Map.

- .m2mRelations :
Set.<M2MRelation>
- .m2mRelationsPk :
Set.<M2MRelation>
- .o2mRelations :
Set.<O2MRelation>
- .m2oRelations :
Set.<M2ORelation>
- .relations :
Array.<(O2MRelation|M2ORelation|M2MRelation)>
- .get(path) ⇒
Column
|undefined
new Table(args)
Constructor function. You don't need to call constructor manually. pg-structure handles this.
| Param | Type | Description |
|---|---|---|
| args | Object |
Attributes of the Table instance to be created. |
| args.parent | Schema |
Parent Schema of the Table. |
| args.name | string |
Name of the Table. |
| args.description | string |
Description of the Table. |
| args.descriptionData | Object |
Extra data to store in object. |
| args.kind | string |
Kind of table. (table or view ) |
table.name : string
Name of the table.
Kind: instance property of Table
Read only: true
table.fullName : string
Full name of the Table with (.) notation.
Kind: instance property of Table
Read only: true
Example
var fullName = table.fullName; // public.account
table.fullCatalogName : string
Full name of the Table with (.) notation including catalog name.
Kind: instance property of Table
Read only: true
Example
var fullName = table.fullName; // crm.public.account
table.schema : Schema
Schema this table belongs to.
Kind: instance property of Table
Read only: true
See: Aliases parent
Example
var schema = table.schema; // Schema instance
table.parent : Schema
Schema this table belongs to.
Kind: instance property of Table
Read only: true
See: Aliases schema
Example
var schema = table.parent; // Schema instance
table.comment : string
Comment of the table.
Kind: instance property of Table
Read only: true
See: Aliases description
table.commentData : Object
JS Object extracted from table description. Object is expected as JSON data between [PG-STRUCTURE]
and [/PG-STRUCTURE]
tags in description. Tags are case-insensitive.
For maximum comfort JSON parsing is made by jsonic. It is a non-strict JSON parser. It is possible
to ommit quotes etc. Please see jsonic for details.
Kind: instance property of Table
Read only: true
See: Aliases descriptionData
Example
let description = table.comment; // -> 'This table holds account details. [PG-STRUCTURE]{ extraData: 2 }[/PGEN]'
let extra = table.commentData; // -> { extraData: 2 }
console.log(table.commentData.extraData); // -> 2
table.description : string
Comment of the table.
Kind: instance property of Table
Read only: true
See: Aliases comment
table.descriptionData : Object
JS Object extracted from table description. Object is expected as JSON data between [PG-STRUCTURE]
and [/PG-STRUCTURE]
tags in description. Tags are case-insensitive.
For maximum comfort JSON parsing is made by jsonic. It is a non-strict JSON parser. It is possible
to ommit quotes etc.
You don't need to quote property names: { foo:"bar baz", red:255 }
You don't need the top level braces: foo:"bar baz", red:255
You don't need to quote strings with spaces: foo:bar baz, red:255
You do need to quote strings if they contain a comma or closing brace or square bracket: icky:",}]"
You can use single quotes for strings: Jules:'Cry "Havoc," and let slip the dogs of war!'
You can have trailing commas: foo:bar, red:255,
For details, please see jsonic.
Kind: instance property of Table
Read only: true
See: Aliases commentData
Example
let description = table.description; // -> 'This table holds account details. [PG-STRUCTURE]{ "extraData": 2 }[/PGEN]'
let extra = table.descriptionData; // -> { extraData: 2 }
console.log(table.descriptionData.extraData); // -> 2
table.kind : string
Kind of table. One of the values of table
or view
.
Kind: instance property of Table
Read only: true
table.columns : Map.<Column>
All Column instances in the table as a Map. They are ordered same order as they are defined in database table.
Kind: instance property of Table
Read only: true
See: Map
Example
var isAvailable = table.columns.has('id');
var columnNames = Array.from(schema.columns.keys()); // Use spread operator to get column names as an array.
var column = table.columns.get('user_id');
var name = column.name;
for (let column of table.columns.values()) {
console.log(column.name);
}
for (let [name, column] of table.columns) {
console.log(name, column.name);
}
table.constraints : Map.<Constraint>
All Constraint instances in the table as a Map. They are ordered by name.
Kind: instance property of Table
Read only: true
table.db : Db
Db this table belongs to.
Kind: instance property of Table
Read only: true
table.foreignKeyConstraints : Map.<Constraint>
All Constraint instances which are foreign key constraints in the table as a Map.
Kind: instance property of Table
Read only: true
See: o2mRelations, m2oRelations, m2mRelations to get more details about relations.
table.foreignKeyColumns : Map.<Column>
All foreign key columns of all foreignKeyConstraints as a Map. Foreign key constraints may contain more than one column. To get foreign key columns of a specific foreign key constraint use foreignKeyConstraints.columns
Kind: instance property of Table
Read only: true
table.foreignKeyConstraintsToThis : Map.<Constraint>
All foreign key Constraint instances which are referring to this table as a Map.
Kind: instance property of Table
Read only: true
See: o2mRelations, m2oRelations, m2mRelations to get more details about relations.
table.primaryKeyConstraint : Constraint
| undefined
Primary key constraint instance of this table.
Kind: instance property of Table
Read only: true
See: primaryKeyColumns to get primary key columns directly.
Example
let pkConstraint = table.primaryKeyConstraint;
let pkColumns = Array.from(pkConstraint.columns.values()); // As an array
for (let [name, column] of pkConstraint.columns) {
console.log(column.name);
}
table.primaryKeyColumns : Map.<Column>
Primary key columns of this table as a Map.
Kind: instance property of Table
Read only: true
See: primaryKeyConstraint to get primary key constraint.
Example
let pkColumns = Array.from(table.primaryKeyColumns.values()); // As an array
for (let [name, column] of pkConstraint.columns) {
console.log(column.name);
}
table.hasManyTables : Map.

Tables sorted by name, which this table has relationship of type one to many
.
Kind: instance property of Table
Read only: true
See: Example schema, Map
Example
for (let [name, table] of vendorTable.hasManyTables) {
console.log(table.name);
}
table.belongsToTables : Map.

Tables sorted by name, which this table has relationship of type belongs to
which is reverse direction of one to many
.
Kind: instance property of Table
Read only: true
See: Example schema, Map
Example
for (let [name, table] of productTable.belongsToTables) {
console.log(table.name);
}
table.belongsToManyTables : Map.

Tables sorted by name, which this table has relationship of type many to many
.
Kind: instance property of Table
Read only: true
See: Example schema, Map
Example
// Cart (id) has many products (id) through line_item join table.
for (let [name, table] of cartTable.belongsToManyTables) {
console.log(table.name);
}
table.belongsToManyTablesPk : Map.

Tables sorted by name, which this table has relationship of type many to many
. Includes
only tables joined by primary keys in join table.
Kind: instance property of Table
Read only: true
See: Example schema, Map
Example
// Cart (id) has many products (id) through line_item join table.
for (let [name, table] of cartTable.belongsToManyTables) {
console.log(table.name);
}
table.m2mRelations : Set.<M2MRelation>
Set of many to many relationships of the table. M2MRelation resembles
has many through
and belongs to many
relations in ORMs. It has some useful methods and information for generating ORM classes.
Kind: instance property of Table
Read only: true
table.m2mRelationsPk : Set.<M2MRelation>
Set of many to many relationships of the table. Different from m2mRelations
this only includes relations joined by Primary Foreign Keys
in join table. Primary Foreign Keys
means
foreign keys of join table which are also Primary Keys of join table at the same time.
M2MRelation resembles has many through
and belongs to many
relations in ORMs.
It has some useful methods and information for generating ORM classes.
Kind: instance property of Table
Read only: true
table.o2mRelations : Set.<O2MRelation>
Set of one to many relationships of the table. O2MRelation resembles
has many
relations in ORMs. It has some useful methods and information for generating ORM classes.
Kind: instance property of Table
Read only: true
table.m2oRelations : Set.<M2ORelation>
Set of many to one relationships of the table. M2ORelation resembles
belongs to
relations in ORMs. It has some useful methods and information for generating ORM classes.
Kind: instance property of Table
Read only: true
table.relations : Array.<(O2MRelation|M2ORelation|M2MRelation)>
List of all relationships of the table.
Kind: instance property of Table
Read only: true
table.get(path) ⇒ Column
| undefined
Returns Column on given path relative to Table.
Kind: instance method of Table
Returns: Column
| undefined
- - Requested item.
| Param | Type | Description |
|---|---|---|
| path | string |
Path of the requested item in dot (.) notation such as 'public.contact' |
Example
var column = table.get('contact'), // Returns contact column in public table.


- setCompressionLevel(int) - Method in class org.springframework.integration.zip.transformer.ZipTransformer
-
Sets the compression level.
- setDeleteFiles(boolean) - Method in class org.springframework.integration.zip.transformer.AbstractZipTransformer
-
If the payload is an instance of File
, this property specifies
whether to delete the File
after transformation.
- setExpectSingleResult(boolean) - Method in class org.springframework.integration.zip.transformer.UnZipTransformer
-
This parameter indicates that only one result object shall be returned as
a result from the executed Unzip operation.
- setUseFileAttributes(boolean) - Method in class org.springframework.integration.zip.transformer.ZipTransformer
-
Specifies whether the name of the file shall be used for the
zip entry.
- setWorkDirectory(File) - Method in class org.springframework.integration.zip.transformer.AbstractZipTransformer
-
Set the work-directory.
- setZipResultType(ZipResultType) - Method in class org.springframework.integration.zip.transformer.AbstractZipTransformer
-
Defines the format of the data returned after transformation.
- splitMessage(Message<?>) - Method in class org.springframework.integration.zip.splitter.UnZipResultSplitter
-
- SpringZipUtils - Class in org.springframework.integration.zip.transformer
-
Once the Spring Integration Zip support matures, we need to contribute the
methods in this utility class back to the ZT Zip project.
- SpringZipUtils() - Constructor for class org.springframework.integration.zip.transformer.SpringZipUtils
-


Biogen Inc said the European
Patent Office granted it a patent covering certain proteins
used to produce a hepatitis B vaccine through genetic
engineering techniques.
Robert Gottlieb, Biogen spokesman, said the company has
licensed the vaccine on a nonexclusive basis to <Wellcome PLC>,
the British pharmaceutical firm, and is discussing licensing
with other companies.
Biogen said the patent gives it the right to exclude others
from marketing hepatitis B vaccine in the 11 member countries
of the European Patent Convention.
Gottlieb said the company has also filed a patent in other
markets, including the U.S. The vaccine is in clinical tests.
Patents in the biotechnology field are particularly
important as the company with an exclusive patent can reap
large rewards. Recently many of the products of genetic
engineering have become the target of patent lawsuits.
Merck and Co Inc <MRK> already sells a genetically
engineered hepatitis B vaccine in the U.S. called Recombivax
HB. A subsidiary of <SmithKline Beckman Corp>, SmithKline
Biologicals, based in Belgium, is selling a hepatitis B
vaccine, called Engerix-B, in Belgium.
A SmithKline spokesman said the vaccine has also been
formally approved in Switzerland and Luxembourg and has been
authorized for market in a number of Far East countries.
Hepatitis B is a serious liver infection common in many
parts of Africa and southeast Asia where about five pct to 15
pct of the population carry the virus. In the U.S. about
200,000 new cases occur each year.
Last December the European Patent Ofice rejected Biogen's
patent for alpha-interferon, which Biogen said it will appeal
once it receives a formal written opinion from the office.
Reuter


Britain is a dangerous mess, former PM Blair says
by By Guy Faulconbridge and William James1 / 7Former British PM Blair speaks at a Reuters Newsmaker event in London
By Guy Faulconbridge and William James
LONDON (Reuters) - Former prime minister Tony Blair said on Monday that Britain was in a dangerous mess and that neither his own Labour Party nor Prime Minister Boris Johnson's Conservatives deserved to win a Dec. 12 election.
Britain is holding an election three years ahead of schedule because parliament was deadlocked over Brexit, unable to agree on how or even whether to leave the European Union.
"We're a mess," Blair said at a Reuters Newsmaker event. "The buoyancy of the world economy has kept us going up to now, but should that falter, we will be in deep trouble."
Blair, Labour prime minister from 1997 to 2007, said both major parties were peddling fantasies, adding that if the opinion polls were accurate, Johnson's party looked likely to win a majority.
Blair, the only Labour leader to win three elections, said his party was now controlled by its "Marxist-Leninist wing" and that its leader Jeremy Corbyn was promising a revolution.
"The problem with revolutions is never how they begin but how they end," said Blair. "The problem with revolutions is that they always end badly."
"The truth is: the public aren't convinced either main party deserves to win this election outright."
The Dec. 12 vote presents a stark choice between a socialist-run state under Labour, which is offering a second referendum on leaving the EU, and the free-market Conservatives, who want to "get Brexit done" by the end of January.
RISK OF NO-DEAL BREXIT
Blair, an opponent of Brexit, argued for a second referendum on the decision to leave, saying it would need to be followed by another general election.
Johnson has pledged to take Britain out of the EU by Jan. 31 if he wins a parliamentary majority and then to negotiate a comprehensive deal with the bloc covering trade and future relations during a transition period due to end next December.
Blair cast doubt on that timetable and said there was still a risk that Britain could exit the EU in a year's time without having struck a deal with its biggest trading partner.
"No-deal Brexit is not off the table," Blair said. "This negotiation (on the future relationship) has no chance of being concluded in that transition period."
Blair said he did not know whether Labour, which has tacked sharply to the left under Corbyn, would ever return to the center ground of British politics, but added: "We must set about the urgent task of reconstructing the sensible mainstream of British politics."
"Otherwise, this laboratory experiment in populism running riot will end very badly for our nation."
(Reporting by Guy Faulconbridge, writing by William James; editing by Kate Holton and Gareth Jones)


Kraai's Websites
Home
Portfolio
Contact
Thank You!
Your Message has been sent
Name
Email
Message
Send Message


Kylian Mbappe backs Lionel Messi for Ballon d’Or and reveals self-doubt
by FSA EditorKylian Mbappe has scored nine goals in 12 games for Paris Saint-Germain this season but said he still suffers from self-doubt
Kylian Mbappe tipped Barcelona’s Lionel Messi to win the Ballon d’Or and admitted that he has suffered from bouts of self-doubt during an injury-plagued year at Paris Saint-Germain.
France international Mbappe was fourth in the shortlist for the 2018 Ballon d’Or and won the Kopa Trophy, presented to the best-performing player under the age of 21.
After scoring 33 goals in 29 Ligue 1 appearances for the French champions in 2018-19, Mbappe has been restricted to just five starts this term.
He has nevertheless scored five league goals but backed the legendary Messi to collect the gong for world’s best player for a sixth time, telling Spiegel: “In individual terms he [Messi] was the best this year.”
“Sometimes I’m worried,” Mbappe continued. “I’m scared, if you fail as a player, you have doubts, and when you lose in a big match, the question is, is this the end of it? It was nice, but now it’s over!
“But it does not last long, because the good thing about football is that you do not have much time to think.”
Mbappe has scored nine goals in 12 games across all competitions in 2019-20 despite spending much of the campaign sidelined by hamstring, thigh and adductor problems.
He said another issue affecting him at PSG is the language barrier between him and German coach Thomas Tuchel, but said the 46-year-old makes certain words loud and clear.
“Unfortunately, I do not know nice words in German,” said Mbappe.
“Just swear words like s***, my trainer is German and he always says that when something bugs him: s***, s***!”


The pdytools
Module¶
Every deployed application is able to import the pdytools
module. This
enables the application to determine if it is running as a deployed application
and, if necessary, to change its behaviour accordingly.
-
pdytools.
hexversion
¶ This is the version number of pdytools encoded as a single (non-zero) integer. The encoding used is the same as that used by
sys.hexversion
.
Deployed applications also follow the convention of other deployment tools of
defining an attribute called frozen
in the sys
module.