Verified before you start
Jaxx Liberty's core security and subsequent updates go through a vigorous testing phase in order to make sure that everything you hold in your wallet is safe and secure.
It starts with a seed
When you first launch the application, Jaxx Liberty creates a 12-word backup phrase, which is then used to generate and manage all of the private keys to your digital assets. Do not share these words with anyone, write them down on a piece of paper and keep them in a secure place, such as a safety deposit box.
Everything stays on-device
Your 12-word backup phrase is encrypted and stored only on your device. We don’t have access to it nor is it stored on any server. We believe you should be in complete control.
Now add a second layer of encryption
Jaxx Liberty allows you to set a password to further enhance the security of your backup phrase, which encrypts everything within it. This gives you a second layer of security should your device ever be lost or stolen.
Secure across platforms
Sync Jaxx Liberty across all platforms and devices. Your 12-word backup phrase is all you’ll need to manage your digital assets on all your devices. Whether it's iOS, Android, Mac, Windows, Linux or a Chrome Extension, we’ve got you covered.


Home
Something idk
Another thing
I really dk
JSON Loader TEST
About Us
Inject code
Mini-games made with Computer Science
© South Windsor High School CS Club
Download license
All mini-games on this site are made with HTML, CSS and JS!
Lucky Charms
When the random number matches your number, you win
Download source code
|
UwU (0)
| Luck: 0
Put in an input value from 1-1000, then click me!
|
Get a bonus for 1 OwO
Get an auto-clicker for 100 OwO's
Reset everything
Slot Machine
When you get 3 in a row, you get 100 wins.
When you get 5 in a row, you get 1000 wins
Download source code
Start spinning
Show inner workings
Toggle perspective


It was the best of times, it was the worst of times…
It was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity, it was the season of Light, it was the season of Darkness, it was the spring of hope, it was the winter of despair, we had everything before us, we had nothing before us, we were all going direct to Heaven, we were all going direct the other way—in short, the period was so far like the present period, that some of its noisiest authorities insisted on its being received, for good or for evil, in the superlative degree of comparison only.


Welcome to DVID
This page provides an introduction to the currently running DVID server.
Developers can visit the Github repo
for more documentation and code.
The DVID admin console may be available if you have downloaded the
DVID console web client repo
and included -webclient=/path/to/console when running the
dvid serve
command.
HTTP API and command line use
All API endpoints follow this layout:
/serverhost:someport/api/...The online documentation doesn't show the server host prefixed to the "/api/..." URL, but it is required.
General commands
GET /api/help The current page that lists all general and type-specific commands/HTTP API. GET /api/help/{typename} Returns help for the given datatype. GET /api/load Returns a JSON of server load statistics. GET /api/server/info Returns JSON for server properties. GET /api/server/types Returns JSON with the datatypes of currently stored data instances. Datatypes are represented by a name and the URL of the reference implementation. To see all possible datatypes, i.e., the list of compiled datatypes, use the "compiled-types" endpoint. GET /api/server/compiled-types Returns JSON of all possible datatypes for this server, i.e., the list of compiled datatypes. GET /api/server/groupcache Returns JSON for groupcache statistics for this server. See github.com/golang/groupcache package Stats and CacheStats for MainCache and HotCache. POST /api/server/settings Sets server parameters. Expects JSON to be posted with optional keys denoting parameters: { "gc": 500, "throttle": 2 } Possible keys: gc Garbage collection target percentage. This is a low-level server tuning request that can affect overall request latency. See: https://golang.org/pkg/runtime/debug/#SetGCPercent throttle Maximum number of CPU-intensive requests that can be executed under throttle mode. See imageblk and labelblk GET 3d voxels and POST voxels. Default = 1. POST /api/server/reload-metadata Reloads the metadata from storage. This is useful when using multiple DVID frontends with a shared storage backend. Typically, one DVID is designated "master" and handles any modifications of the repositories and data instances. Other DVIDs simply reload the metadata when prompted by an external coordinator, allowing the "slave" DVIDs to see changes made by the master DVID. ------------------------- Repo-Level REST endpoints ------------------------- POST /api/repos Creates a new repository. Expects configuration data in JSON as the body of the POST. Configuration is a JSON object with optional "alias", "description", and "passcode" properties. Returns the root UUID of the newly created repo in JSON object: {"root": uuid} GET /api/repos/info Returns JSON for the repositories under management by this server. HEAD /api/repo/{uuid} Returns 200 if a repo with given UUID is available. GET /api/repo/{uuid}/info Returns JSON for just the repository with given root UUID. The UUID string can be shortened as long as it is uniquely identifiable across the managed repositories. POST /api/repo/{uuid}/instance Creates a new instance of the given data type. Expects configuration data in JSON as the body of the POST. Configuration data is a JSON object with each property corresponding to a configuration keyword for the particular data type. JSON name/value pairs: REQUIRED "typename" Type name of the new instance, REQUIRED "dataname" Name of the new instance OPTIONAL "versioned" If "false" or "0", the data is unversioned and acts as if all UUIDs within a repo become the root repo UUID. (True by default.) GET /api/repo/{uuid}/log POST /api/repo/{uuid}/log GETs or POSTs log data to the repo with given UUID. The get or post body should be JSON of the following format: { "log": [ "provenance data...", "provenance data...", ...] } The log is a list of strings that will be appended to the repo's log. They should be descriptions for the entire repo and not just one node. For particular versions, use node-level logging (below). POST /api/repo/{uuid}/merge Creates a conflict-free merge of a set of committed parent UUIDs into a child. Note the merge will not necessarily create an error immediately, but later GETs that detect conflicts will produce an error at that time. These can be resolved by doing a POST on the "resolve" endpoint below. The post body should be JSON of the following format: { "mergeType": "conflict-free", "parents": [ "parent-uuid1", "parent-uuid2", ... ], "note": "this is a description of what I did on this commit" } The elements of the JSON object are: mergeType: must be "conflict-free". We will introduce other merge options in future. parents: a list of the parent UUIDs to be merged. note: any note that should be set for the child version. A JSON response will be sent with the following format: { "child": "3f01a8856" } The response includes the UUID of the new merged, child node. POST /api/repo/{uuid}/resolve Forces a merge of a set of committed parent UUIDs into a child by specifying a UUID order that establishes priorities in case of conflicts (see "parents" description below. Unlike the very fast but lazily-enforced 'merge' endpoint, this request spawns an asynchronous routine that checks all data for the given data instances (see "data" in JSON post), creates versions to delete conflicts, and then performs the conflict-free merge to a final child. The post body should be JSON of the following format: { "data": [ "instance-name-1", "instance-name2", ... ], "parents": [ "parent-uuid1", "parent-uuid2", ... ], "note": "this is a description of what I did on this commit" } The elements of the JSON object are: data: A list of the data instance names to be scanned for possible conflicts. parents: A list of the parent UUIDs to be merged in order of priority. If there is a conflict between the second and third UUID, the conflicting data in the third UUID will be deleted in favor of the second UUID. note: Any note that should be set for the child version. A JSON response will be sent with the following format: { "child": "3f01a8856" } The response includes the UUID of the new merged, child node. ------------------------- Node-Level REST endpoints ------------------------- GET /api/node/{uuid}/log POST /api/node/{uuid}/log GETs or POSTs log data to the node (version) with given UUID. The get or post body should be JSON of the following format: { "log": [ "provenance data...", "provenance data...", ...] } The log is a list of strings that will be appended to the node's log. They should be data usable by clients to reconstruct the types of operation done to that version of data. POST /api/node/{uuid}/commit Commits (locks) the node/version with given UUID. This is required before a version can be branched or pushed to a remote server. The post body should be JSON of the following format: { "note": "this is a description of what I did on this commit", "log": [ "provenance data...", "provenance data...", ...] } The note is a human-readable commit message. The log is a slice of strings that may be computer-readable. If successful, a valid JSON response will be sent with the following format: { "committed": "3f01a8856" } POST /api/node/{uuid}/branch Creates a new child node (version) of the node with given UUID. An optional post body should be in JSON format: { "note": "this is what we'll be doing on this version" } A JSON response will be sent with the following format: { "child": "3f01a8856" } The response includes the UUID of the new child node.
Data type commands
This server has compiled in the following data types, each of which have a HTTP API. Click on the links below to explore each data type's command line and HTTP API.
- labelgraph
- roi
- rgba8blk
- annotation
- imagetile
- googlevoxels
- multichan16
- uint8blk
- labelblk
- labelvol
- keyvalue
- labelsz
Background batch processes like generation of tiles, sparse volumes, and various
indices, will be paused if a single server receives more than a few data type API r
requests over a 5 minute moving window. You can mark your API request as
non-interactive (i.e., you don't mind if it's delayed) by appending a query string
interactive=false
.
Licensing
DVID is released under the Janelia Farm license, a 3-clause BSD license.


Morning top 5: Man dies at Cloverhill; Four houses damaged in Meath fire; Concern over maternity hospital delays
by Michael StainesA man has died following an incident involving two men at Cloverhill Prison in Dublin.
Gardaí said they were called to the prison shortly after midnight last night.
A man in his late 30s was treated by emergency services but pronounced dead at the scene a short time later.
Investigators said the death followed an “incident involving two male prisoners in custody at the prison.”
Gardaí are following a definite line of inquiry.
***
Four houses have been damaged in a fire at a housing estate in County Meath.
Gardaí said the fire broke out in a van parked in the driveway of a house at Meadowbank Hill in Ratoath shortly before 4am this morning.
It quickly spread and damaged a number of houses and a second car.
Nobody was injured; however, four houses had to be evacuated.
***
Actor and comedian Sacha Baron Cohen has launched a blistering attack on social media companies over their failure to tackle the proliferation of hate speech and misinformation online.
In a speech Anti-Defamation League in New York, the Borat and Ali G creator said companies like Facebook, Google and Twitter are the “greatest propaganda machine in history.”
He slammed Facebook for using free speech as an excuse to not take responsibility for lies, harassment and abuse posted to the platform.
He said the company’s refusal to fact-check political ads would have allowed Hitler to deliver Nazi propaganda to billions of people around the world.
***
There are renewed calls for the Government to consider a Compulsory Purchase Order of the land at St Vincent’s Hospital for the new National Maternity Hospital.
It comes amid concern the project will face further delay with the Vatican yet to sign off on the transfer of the land for the project.
Reports this week suggest pro-life groups are lobbying the Church to block the transfer because the new facility will offer abortion services.
Sinn Féin health spokesperson Louise O’Reilly is calling on the Government to issue a CPO to prevent the Church from ‘influencing or interfering’ with the project.
***
Young people will be having their say on issues like Climate Action at today's Dáil na nÓg.
168 delegates will attend the event in the Dáil from 10:30am this morning until 4pm.
The Children's Minister Katherine Zappone will be among the speakers at the closing ceremony.
Dáil na nÓg Chairperson Caoimhe Wall said the environment will top the agenda – with transport, climate awareness and plastic crisis all up for discussion.


How it works
Dropdown touched: {{ctrl.touched}}
What I would expect
Touched is on focus lost blur - not on focus gain
Input touched: {{ctrl2.touched}}
Those 2 values should be bound bidirectional as its error state is affecting presentation except value
Type somethin in and than remove it with backspace
I would expect those to act the same as
Obviously "touced" state is not shared thus we must first toch both fields


Home
Login
Register
We value your Feedback

Sample normal Radio Button Question
Option 1
Option 2
Option 3
Sample normal inline Radio Button Question
Option 1
Option 2
Option 3
Option 4
Sample Radio Button Question
Option 1
Option 2
Option 3
Option 4
Sample Inline Radio Button Question 1
Option 1
Option 2
Option 3
Option 4
Sample inline Radio Button Question 2
Option 1
Option 2
Option 3
Option 4
Sample inline dropdown Question 1
Choose...
OPTION 1
OPTION 2
OPTION 3
Sample inline dropdown Question 2
Choose...
OPTION 1
OPTION 2
OPTION 3
Sample Dropdown Question
Choose...
OPTION 1
OPTION 2
OPTION 3
Sample text Question
SUBMIT


A new way to do Fixture Scheduling
1. Click on Unscheduled Matches and then click
on the Division code or Cup code for the chosen competition, the same as usual.
2. Click on "click here" where it says "Please click here to change this fixture
date" in the heading.
3. Click on "choose" where it says "Please choose the fixture date".
4.  If
you don't get this calendar - let me know immediately! See below...
5. Click on the date you require.
Note: You can go to an earlier month by clicking on << , or to a later month
by clicking on >> in the calendar heading.
6. Your chosen date will appear in the box above the Confirm button.
When you are happy with this date, click on Confirm, otherwise repeat from step
3.
7. You will get a list of Unscheduled Matches, the same as usual, but if any
of the teams are busy that day then their names will be crossed through and
you won't be able to tick the box next to these games.
8. Tick the games you require and then click on the Add Group button.
9. If all your choices were OK then the fixtures will be made and you will see
them on the MatchDay screen.
10. At the first occurrence of a bad choice you will get a red warning message.
All prior choices will succeed.
To add fixtures for another competition repeat from Step 1.
The fixture date will remain the same until you change it so go to step 7 if
you want to keep the same fixture date.
javascript calendar
Your browser must be able to run javascript.
Start. Control Panel. Internet Options. Security - make sure this is set to Medium.


Some of these recipes are so easy, your kids may want to join in the fun. Only the simplist recipes with the easiest to find ingredients are here, and best of all, the products work.
Natural Hairspray
Natural Hairgel
Natural Chapstick
Natural Lotion
*Tips*
Top


Camera module
Main module using to face recognize.
Very simple because Raspberry Pi 3 can’t working with streaming to website.
-
class
Camera.
VideoCamera
[source]
Bases: object
-
get_action
()[source]
method to getting actual state of object in this class
- Returns
class object
- Return type
VideoCamera
-
get_frame
()[source]
compare face from image with saving images(“ja.png”) from main folder location
- Returns
True if face is rocognize or false if is not
- Return type
bool


安装完成go后，在$GOROOT/bin/下目前会有三个文件：go, godoc和gofmt。go就不用说了，gofmt大部分人都熟悉，因为它解决了代码风格的问题，代码风格是code review中的一个大问题，减少了revie时很多鸡毛蒜皮类的争论，节省了时间。但是godoc，可能很多人就不太熟悉了，本文主要是对godoc的使用做简单介绍。
$GOROOT就是go的安装目录，linux下一般是
/usr/local/go
, mac os下使用brew一般是/usr/local/Cellar/go/版本/
基本用法
启动服务
godoc -http :6060
以上命令会在本地下生成当前系统安装的文档，类似于在本地启动了一个官方网站，不过里面的内容是基于当前安装的版本的。
除了有官方blog，官方包的文档以外，还有第三方库的文档，这里的第三方库指的是在$GOPATH/src下除了golang.org目录以外的所有库。
可能有人会问，你这么做有什么意义了，要查文档，直接网络搜索即可，甚至使用Dash这样的神器，不是更方便吗？那我只能说Too young to naive了。如果是一个团队，写了很多公司私有的公共组件，那么此时一个公共的文档库就极为重要了。而godoc就提供了这个功能。如果不用godoc，就需要单独写文档，写文档的工作量，地球人都知道，那不是一般的大。。。而且写完后，一般都没人看。。。
工程化
的理念真的是贯穿于整个golang的。
godoc生成的文档有特定的格式，只要代码中的注释按照标准(标准很简单，下文有写)，那么最后生成的文档格式是很易读的。想想看，直接在代码中写注释，修改代码的时候就修改注释，而文档了，自动生成，始终和代码/注释保持一致。这个可是解决了软件工程领域的一个大问题啊：文档及时性。
所以说，golang是一门现代化的语言，一点都不过。
好像有点扯多了，请原谅我，每次在看golang设计精巧的地方，都不得不拍案而起，不是golang功能、性能等方面多么牛逼，而是，它真的能解决工程中的问题！
开启搜索功能
没有搜索功能的网站是不完整的
生成索引文件:
godoc -v -index -write_index -index_files /path/to/生成的索引文件
启动带搜索功能的服务:
godoc -http :6060 -index -index_files /path/to/生成的索引文件
golang注释标准
golang官方没有一个特别标准的文档来说明注释标准，主要散落在3个地方：
个人觉得记住下面几句话, 大部分场景就够用了：
- 每一个包需要有包级别的注释，类似于
Package 包名 ...
这种模式。如果包中有多个源文件，只需要任意一个源文件有包级别注释即可。 - 结构体、函数和方法的注释类似于
结构体名/函数名/方法名 ...
这种模式 - 不要尝试使用空格去格式化注释，对齐即可。godoc生成时会类似于gofmt对源代码做的一样，会自动转化格式。
- 注释应该是完整的句子。
内容真的不多，我就汇总摘抄到这里吧： Every package should have a package comment. It should immediately precede the package statement in one of the files in the package. (It only needs to appear in one file.) It should begin with a single sentence that begins “Package packagename” and give a concise summary of the package functionality. This introductory sentence will be used in godoc’s list of all packages.
Subsequent sentences and/or paragraphs can give more details. Sentences should be properly punctuated.
// Package superman implements methods for saving the world.
//
// Experience has shown that a small number of procedures can prove
// helpful when attempting to save the world.
package superman
Nearly every top-level type, const, var and func should have a comment. A comment for bar should be in the form “bar floats on high o’er vales and hills.". The first letter of bar should not be capitalized unless it’s capitalized in the code.
// enterOrbit causes Superman to fly into low Earth orbit, a position
// that presents several possibilities for planet salvation.
func enterOrbit() os.Error {
...
 This approach makes them format well when extracted into godoc documentation. Comments should begin with the name of the thing being described and end in a period:
// Request represents a request to run a command.
type Request struct { ...
// Encode writes the JSON encoding of req to w.
func Encode(w io.Writer, req *Request) { ...
and so on
All top-level, exported names should have doc comments, as should non-trivial unexported type or function declarations. See https://golang.org/doc/effective_go.html#commentary for more information about commentary conventions.
Go provides C-style /* */ block comments and C++-style // line comments. Line comments are the norm; block comments appear mostly as package comments, but are useful within an expression or to disable large swaths of code.
The program—and web server—godoc processes Go source files to extract documentation about the contents of the package. Comments that appear before top-level declarations, with no intervening newlines, are extracted along with the declaration to serve as explanatory text for the item. The nature and style of these comments determines the quality of the documentation godoc produces.
Every package should have a package comment, a block comment preceding the package clause. For multi-file packages, the package comment only needs to be present in one file, and any one will do. The package comment should introduce the package and provide information relevant to the package as a whole. It will appear first on the godoc page and should set up the detailed documentation that follows.
/*
Package regexp implements a simple library for regular expressions.
The syntax of the regular expressions accepted is:
regexp:
concatenation { '|' concatenation }
concatenation:
{ closure }
closure:
term [ '*' | '+' | '?' ]
term:
'^'
'$'
'.'
character
'[' [ '^' ] character-ranges ']'
'(' regexp ')'
*/
package regexp
If the package is simple, the package comment can be brief.
// Package path implements utility routines for
// manipulating slash-separated filename paths.
Comments do not need extra formatting such as banners of stars. The generated output may not even be presented in a fixed-width font, so don’t depend on spacing for alignment—godoc, like gofmt, takes care of that. The comments are uninterpreted plain text, so HTML and other annotations such as this will reproduce verbatim and should not be used. One adjustment godoc does do is to display indented text in a fixed-width font, suitable for program snippets. The package comment for the fmt package uses this to good effect.
Depending on the context, godoc might not even reformat comments, so make sure they look good straight up: use correct spelling, punctuation, and sentence structure, fold long lines, and so on.
Inside a package, any comment immediately preceding a top-level declaration serves as a doc comment for that declaration. Every exported (capitalized) name in a program should have a doc comment.
Doc comments work best as complete sentences, which allow a wide variety of automated presentations. The first sentence should be a one-sentence summary that starts with the name being declared.
// Compile parses a regular expression and returns, if successful,
// a Regexp that can be used to match against text.
func Compile(str string) (*Regexp, error) {
If every doc comment begins with the name of the item it describes, you can use the doc subcommand of the go tool and run the output through grep. Imagine you couldn’t remember the name “Compile” but were looking for the parsing function for regular expressions, so you ran the command,
$ go doc -all regexp | grep -i parse
If all the doc comments in the package began, “This function…", grep wouldn’t help you remember the name. But because the package starts each doc comment with the name, you’d see something like this, which recalls the word you’re looking for.
$ go doc -all regexp | grep -i parse
Compile parses a regular expression and returns, if successful, a Regexp
MustCompile is like Compile but panics if the expression cannot be parsed.
parsed. It simplifies safe initialization of global variables holding
$
Go’s declaration syntax allows grouping of declarations. A single doc comment can introduce a group of related constants or variables. Since the whole declaration is presented, such a comment can often be perfunctory.
// Error codes returned by failures to parse an expression.
var (
ErrInternal = errors.New("regexp: internal error")
ErrUnmatchedLpar = errors.New("regexp: unmatched '('")
ErrUnmatchedRpar = errors.New("regexp: unmatched ')'")
...
)
Grouping can also indicate relationships between items, such as the fact that a set of variables is protected by a mutex.
var (
countLock sync.Mutex
inputCount uint32
outputCount uint32
errorCount uint32
)


X509_digest, X509_CRL_digest, X509_pubkey_digest, X509_NAME_digest, X509_REQ_digest, PKCS7_ISSUER_AND_SERIAL_digest - get digest of various objects
#include <openssl/x509.h>
int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
unsigned int *len);
int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
unsigned int *len);
int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
unsigned char *md, unsigned int *len);
int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
unsigned char *md, unsigned int *len);
int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
unsigned char *md, unsigned int *len);
#include <openssl/pkcs7.h>
int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
const EVP_MD *type, unsigned char *md,
unsigned int *len);
X509_pubkey_digest() returns a digest of the DER representation of the public key in the specified X509 data object. All other functions described here return a digest of the DER representation of their entire data objects.
The type parameter specifies the digest to be used, such as EVP_sha1(). The md is a pointer to the buffer where the digest will be copied and is assumed to be large enough; the constant EVP_MAX_MD_SIZE is suggested. The len parameter, if not NULL, points to a place where the digest size will be stored.
All functions described here return 1 for success and 0 for failure.
Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the OpenSSL license (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at https://www.openssl.org/source/license.html.


#include <secret_sealer.h>
|
| | SecretSealer ()=default |
| |
| virtual | ~SecretSealer ()=default |
| |
| virtual SealingRootType | RootType () const =0 |
| | Gets the sealing root type of this SecretSealer. More...
|
| |
| virtual std::string | RootName () const =0 |
| | Gets the sealing root name of this SecretSealer. More...
|
| |
| virtual std::vector< EnclaveIdentityExpectation > | RootAcl () const =0 |
| | Gets the sealing root ACL of this SecretSealer. More...
|
| |
| virtual Status | SetDefaultHeader (SealedSecretHeader *header) const =0 |
| | Generates the default sealed-secret header based on the configuration of the SecretSealer and writes it to header . More...
|
| |
| virtual StatusOr< size_t > | MaxMessageSize (const SealedSecretHeader &header) const =0 |
| | Gets the maximum message size (in bytes) that can be sealed according to the cipher-suite configuration recorded in header . More...
|
| |
| virtual StatusOr< uint64_t > | MaxSealedMessages (const SealedSecretHeader &header) const =0 |
| | Gets the maximum number of messages that can safely be sealed according to the cipher-suite configuration recorded in header . More...
|
| |
| virtual Status | Seal (const SealedSecretHeader &header, ByteContainerView additional_authenticated_data, ByteContainerView secret, SealedSecret *sealed_secret)=0 |
| | Seals the input per the header specification. More...
|
| |
| virtual Status | Unseal (const SealedSecret &sealed_secret, CleansingVector< uint8_t > *secret)=0 |
| | Unseals the sealed_secret and writes it to secret . More...
|
| |
| virtual Status | Reseal (const SealedSecret &old_sealed_secret, const SealedSecretHeader &new_header, SealedSecret *new_sealed_secret) |
| | Re-seals an already sealed secret to a new header. More...
|
| |
|
| static StatusOr< std::string > | GenerateSealerId (SealingRootType type, const std::string &name) |
| | Combines the specified sealing root type and sealing root name to form a string. More...
|
| |
◆ SecretSealer()
| asylo::SecretSealer::SecretSealer |
( |
| ) |
|
|
default |
◆ ~SecretSealer()
| virtual asylo::SecretSealer::~SecretSealer |
( |
| ) |
|
|
virtualdefault |
◆ GenerateSealerId()
| static StatusOr<std::string> asylo::SecretSealer::GenerateSealerId |
( |
SealingRootType |
type, |
|
|
const std::string & |
name |
|
) |
| |
|
static |
Combines the specified sealing root type and sealing root name to form a string.
The combined string uniquely identifies the SecretSealer responsible for handling secrets associated with the particular combination of root-type type
and root-name name
.
- Parameters
-
| type | The root type for sealing (e.g., from RootType()). |
| name | The root name for sealing (e.g., from RootName()). |
- Returns
- An object that represents a result string, or a failure status.
◆ MaxMessageSize()
| virtual StatusOr<size_t> asylo::SecretSealer::MaxMessageSize |
( |
const SealedSecretHeader & |
header | ) |
const |
|
pure virtual |
Gets the maximum message size (in bytes) that can be sealed according to the cipher-suite configuration recorded in header
.
The user is expected to call this before calling Seal() to ensure that they have chunked their messages correctly. The maximum message sizes of supported cipher-suites are as follows:
- AES-GCM-SIV supports a maximum message size of 32 MiB
- Parameters
-
| header | The associated header to determine the maximum message size. |
- Returns
- The maximum message size that can be encrypted based on the cipher-suite configuration in header, or a non-OK status if the
Implemented in asylo::SgxLocalSecretSealer.
◆ MaxSealedMessages()
| virtual StatusOr<uint64_t> asylo::SecretSealer::MaxSealedMessages |
( |
const SealedSecretHeader & |
header | ) |
const |
|
pure virtual |
Gets the maximum number of messages that can safely be sealed according to the cipher-suite configuration recorded in header
.
The user is responsible for following these guidelines. The secret sealer will not check the number of secrets sealed. The maximum number of sealed messages of supported cipher-suites are as follows:
- AES-GCM-SIV can safely seal 2 ^ 48 messages
- Parameters
-
| header | The associated header to determine the maximum number of sealed messages. |
- Returns
- The maximum number of messages that can be sealed based on the cipher-suite configuration in header, or a non-OK status if the cipher-suite configuration is not supported.
Implemented in asylo::SgxLocalSecretSealer.
◆ Reseal()
| virtual Status asylo::SecretSealer::Reseal |
( |
const SealedSecret & |
old_sealed_secret, |
|
|
const SealedSecretHeader & |
new_header, |
|
|
SealedSecret * |
new_sealed_secret |
|
) |
| |
|
virtual |
Re-seals an already sealed secret to a new header.
The net effect of calling this method is same as unsealing the secret and then sealing it to the new header, and that is exactly how this method is implemented by the base class. A derived class of SecretSealer may choose to further optimize this method.
- Parameters
-
| old_sealed_secret | The sealed secret to re-seal. |
| new_header | The metadata to guide the re-sealing. |
| [out] | new_sealed_secret | The output sealed secret. |
- Returns
- A non-OK status if re-sealing fails.
◆ RootAcl()
| virtual std::vector<EnclaveIdentityExpectation> asylo::SecretSealer::RootAcl |
( |
| ) |
const |
|
pure virtual |
◆ RootName()
| virtual std::string asylo::SecretSealer::RootName |
( |
| ) |
const |
|
pure virtual |
◆ RootType()
| virtual SealingRootType asylo::SecretSealer::RootType |
( |
| ) |
const |
|
pure virtual |
◆ Seal()
| virtual Status asylo::SecretSealer::Seal |
( |
const SealedSecretHeader & |
header, |
|
|
ByteContainerView |
additional_authenticated_data, |
|
|
ByteContainerView |
secret, |
|
|
SealedSecret * |
sealed_secret |
|
) |
| |
|
pure virtual |
Seals the input per the header specification.
The header
must have its secret_name
, secret_version
and secret_purpose
fields populated. If any of the remaining fields in the header
are populated, then they must be compatible with the underlying sealing root.
- Parameters
-
| header | The metadata to guide the sealing. |
| additional_authenticated_data | Unencrypted data that is bundled with the sealed secret. |
| secret | The data to encrypt and seal. |
| [out] | sealed_secret | The output sealed secret. |
- Returns
- A non-OK status if sealing fails.
Implemented in asylo::SgxLocalSecretSealer.
◆ SetDefaultHeader()
| virtual Status asylo::SecretSealer::SetDefaultHeader |
( |
SealedSecretHeader * |
header | ) |
const |
|
pure virtual |
Generates the default sealed-secret header based on the configuration of the SecretSealer and writes it to header
.
- Parameters
-
| [out] | header | The destination for the default SealedSecretHeader value. |
- Returns
- A non-OK status if a default cannot be set.
Implemented in asylo::SgxLocalSecretSealer.
◆ Unseal()
| virtual Status asylo::SecretSealer::Unseal |
( |
const SealedSecret & |
sealed_secret, |
|
|
CleansingVector< uint8_t > * |
secret |
|
) |
| |
|
pure virtual |
Unseals the sealed_secret
and writes it to secret
.
- Parameters
-
| sealed_secret | The input secret to unseal. |
| [out] | secret | The destination for the unsealed secret. |
- Returns
- A non-OK Status if unsealing fails.
Implemented in asylo::SgxLocalSecretSealer.
The documentation for this class was generated from the following file:


Typedefs |
|
|---|---|
Mul
|
typedef |
Neg
|
typedef |
ReduceAll
|
typedef |
ReduceAny
|
typedef |
ReduceMax
|
typedef |
ReduceMean
|
typedef |
ReduceMin
|
typedef |
ReduceProd
|
typedef |
ReduceSum
|
typedef |
Sub
|
typedef |
Functions |
|
|---|---|
AsNodeOut(const Scope & scope, const Input & inp)
|
NodeBuilder::NodeOut
|
AsNodeOutList(const Scope & scope, const InputList & inp)
|
std::vector< NodeBuilder::NodeOut >
|
AudioSummary(const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, ::tensorflow::Input sample_rate)
|
|
AudioSummary(const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, ::tensorflow::Input sample_rate, const AudioSummary::Attrs & attrs)
|
|
BadColor(const TensorProto & x)
|
TF_MUST_USE_RESULT Attrs
Color to use for pixels with non-finite values.
|
Const(const Scope & scope, const Input::Initializer & val)
|
|
Const(const Scope & scope, const T & v, const TensorShape shape)
|
|
Const(const Scope & scope, const std::initializer_list< T > & v, const TensorShape shape)
|
|
ConstFromProto(const Scope & scope, const TensorProto & proto)
|
|
ImageSummary(const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor)
|
|
ImageSummary(const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, const ImageSummary::Attrs & attrs)
|
|
MaxImages(int64 x)
|
Attrs
|
MaxOutputs(int64 x)
|
Attrs
|
node() const
|
::tensorflow::Node *
|
range(It represents the value of a *pixel in the output image).Non-finite values in the input tensor are *replaced by this tensor in the output image.The default value is the color *red.**Arguments
|
image **If max_images is greater the summary value tags are *generated sequentially as *tag *tag etc **The bad_color argument is the color to use in the generated images for *non finite input values It is a uint8 D tensor of length channels *Each element must be in the
Max number of batch elements to generate images for.
|
Classes |
|
|---|---|
|
tensorflow:: |
Raise a exception to abort the process when called. |
|
tensorflow:: |
Computes the absolute value of a tensor. |
|
tensorflow:: |
Returns the element-wise sum of a list of tensors. |
|
tensorflow:: |
Applies a gradient to a given accumulator. |
|
tensorflow:: |
Returns the number of gradients aggregated in the given accumulators. |
|
tensorflow:: |
Updates the accumulator with a new value for global_step. |
|
tensorflow:: |
Extracts the average gradient in the given ConditionalAccumulator. |
|
tensorflow:: |
Computes acos of x element-wise. |
|
tensorflow:: |
Computes inverse hyperbolic cosine of x element-wise. |
|
tensorflow:: |
Returns x + y element-wise. |
|
tensorflow:: |
Add an |
|
tensorflow:: |
Add all input tensors element wise. |
|
tensorflow:: |
Add a |
|
tensorflow:: |
Returns x + y element-wise. |
|
tensorflow:: |
Adjust the contrast of one or more images. |
|
tensorflow:: |
Adjust the hue of one or more images. |
|
tensorflow:: |
Adjust the saturation of one or more images. |
|
tensorflow:: |
Computes the "logical and" of elements across dimensions of a tensor. |
|
tensorflow:: |
Generates labels for candidate sampling with a learned unigram distribution. |
|
tensorflow:: |
Returns the argument of a complex number. |
|
tensorflow:: |
Computes the "logical or" of elements across dimensions of a tensor. |
|
tensorflow:: |
Update '*var' according to the adadelta scheme. |
|
tensorflow:: |
Update '*var' according to the adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the proximal adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the Adam algorithm. |
|
tensorflow:: |
Update '*var' according to the AddSign update. |
|
tensorflow:: |
Update '*var' according to the centered RMSProp algorithm. |
|
tensorflow:: |
Update '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update '*var' by subtracting 'alpha' * 'delta' from it. |
|
tensorflow:: |
Update '*var' according to the momentum scheme. |
|
tensorflow:: |
Update '*var' according to the AddSign update. |
|
tensorflow:: |
Update '*var' and '*accum' according to FOBOS with Adagrad learning rate. |
|
tensorflow:: |
Update '*var' as FOBOS algorithm with fixed learning rate. |
|
tensorflow:: |
Update '*var' according to the RMSProp algorithm. |
|
tensorflow:: |
Returns the truth value of abs(x-y) < tolerance element-wise. |
|
tensorflow:: |
Returns the index with the largest value across dimensions of a tensor. |
|
tensorflow:: |
Returns the index with the smallest value across dimensions of a tensor. |
|
tensorflow:: |
Converts each entry in the given tensor to strings. |
|
tensorflow:: |
Computes asin of x element-wise. |
|
tensorflow:: |
Computes inverse hyperbolic sine of x element-wise. |
|
tensorflow:: |
Asserts that the given condition is true. |
|
tensorflow:: |
Update 'ref' by assigning 'value' to it. |
|
tensorflow:: |
Update 'ref' by adding 'value' to it. |
|
tensorflow:: |
Update 'ref' by subtracting 'value' from it. |
|
tensorflow:: |
Computes atan of x element-wise. |
|
tensorflow:: |
Computes arctangent of |
|
tensorflow:: |
Computes inverse hyperbolic tangent of x element-wise. |
|
tensorflow:: |
Performs average pooling on the input. |
|
tensorflow:: |
Performs 3D average pooling on the input. |
|
tensorflow:: |
Computes gradients of average pooling function. |
|
tensorflow:: |
Defines a barrier that persists across different graph executions. |
|
tensorflow:: |
Closes the given barrier. |
|
tensorflow:: |
Computes the number of incomplete elements in the given barrier. |
|
tensorflow:: |
For each key, assigns the respective value to the specified component. |
|
tensorflow:: |
Computes the number of complete elements in the given barrier. |
|
tensorflow:: |
Takes the given number of completed elements from a barrier. |
|
tensorflow:: |
Multiplies slices of two tensors in batches. |
|
tensorflow:: |
BatchToSpace for 4-D tensors of type T. |
|
tensorflow:: |
BatchToSpace for N-D tensors of type T. |
|
tensorflow:: |
Computes the Bessel i0e function of |
|
tensorflow:: |
Computes the Bessel i1e function of |
|
tensorflow:: |
Compute the regularized incomplete beta integral \(I_x(a, b)\). |
|
tensorflow:: |
Adds |
|
tensorflow:: |
The backward operation for "BiasAdd" on the "bias" tensor. |
|
tensorflow:: |
Counts the number of occurrences of each value in an integer array. |
|
tensorflow:: |
Bitcasts a tensor from one type to another without copying data. |
|
tensorflow:: |
Return the shape of s0 op s1 with broadcast. |
|
tensorflow:: |
Broadcast an array for a compatible shape. |
|
tensorflow:: |
Bucketizes 'input' based on 'boundaries'. |
|
tensorflow:: |
Cast x of type SrcT to y of DstT. |
|
tensorflow:: |
Returns element-wise smallest integer not less than x. |
|
tensorflow:: |
Checks a tensor for NaN and Inf values. |
|
tensorflow:: |
Clips tensor values to a specified min and max. |
|
tensorflow:: |
Compare values of |
|
tensorflow:: |
Converts two real numbers to a complex number. |
|
tensorflow:: |
Computes the complex absolute value of a tensor. |
|
tensorflow:: |
Computes the ids of the positions in sampled_candidates that match true_labels. |
|
tensorflow:: |
Concatenates tensors along one dimension. |
|
tensorflow:: |
A conditional accumulator for aggregating gradients. |
|
tensorflow:: |
Returns the complex conjugate of a complex number. |
|
tensorflow:: |
Shuffle dimensions of x according to a permutation and conjugate the result. |
|
tensorflow:: |
Does nothing. |
|
tensorflow:: |
Computes a 2-D convolution given 4-D |
|
tensorflow:: |
Computes the gradients of convolution with respect to the filter. |
|
tensorflow:: |
Computes the gradients of convolution with respect to the input. |
|
tensorflow:: |
Computes a 3-D convolution given 5-D |
|
tensorflow:: |
Computes the gradients of 3-D convolution with respect to the filter. |
|
tensorflow:: |
Computes the gradients of 3-D convolution with respect to the input. |
|
tensorflow:: |
Computes cos of x element-wise. |
|
tensorflow:: |
Computes hyperbolic cosine of x element-wise. |
|
tensorflow:: |
Increments 'ref' until it reaches 'limit'. |
|
tensorflow:: |
Extracts crops from the input image tensor and resizes them. |
|
tensorflow:: |
Computes the gradient of the crop_and_resize op wrt the input boxes tensor. |
|
tensorflow:: |
Computes the gradient of the crop_and_resize op wrt the input image tensor. |
|
tensorflow:: |
Compute the pairwise cross product. |
|
tensorflow:: |
Compute the cumulative product of the tensor |
|
tensorflow:: |
Compute the cumulative sum of the tensor |
|
tensorflow:: |
Returns the dimension index in the destination data format given the one in. |
|
tensorflow:: |
Returns the permuted vector/tensor in the destination data format given the. |
|
tensorflow:: |
Identity op for gradient debugging. |
|
tensorflow:: |
Identity op for gradient debugging. |
|
tensorflow:: |
Decode and Crop a JPEG-encoded image to a uint8 tensor. |
|
tensorflow:: |
Decode web-safe base64-encoded strings. |
|
tensorflow:: |
Decode the first frame of a BMP-encoded image to a uint8 tensor. |
|
tensorflow:: |
Convert CSV records to tensors. |
|
tensorflow:: |
Decompress strings. |
|
tensorflow:: |
Decode the first frame of a GIF-encoded image to a uint8 tensor. |
|
tensorflow:: |
Convert JSON-encoded Example records to binary protocol buffer strings. |
|
tensorflow:: |
Decode a JPEG-encoded image to a uint8 tensor. |
|
tensorflow:: |
Decode a PNG-encoded image to a uint8 or uint16 tensor. |
|
tensorflow:: |
Reinterpret the bytes of a string as a vector of numbers. |
|
tensorflow:: |
Makes a copy of |
|
tensorflow:: |
Delete the tensor specified by its handle in the session. |
|
tensorflow:: |
DepthToSpace for tensors of type T. |
|
tensorflow:: |
Computes a 2-D depthwise convolution given 4-D |
|
tensorflow:: |
Computes the gradients of depthwise convolution with respect to the filter. |
|
tensorflow:: |
Computes the gradients of depthwise convolution with respect to the input. |
|
tensorflow:: |
Dequantize the 'input' tensor into a float Tensor. |
|
tensorflow:: |
Deserialize and concatenate |
|
tensorflow:: |
Deserialize |
|
tensorflow:: |
Destroys the temporary variable and returns its final value. |
|
tensorflow:: |
Returns a diagonal tensor with a given diagonal values. |
|
tensorflow:: |
Returns the diagonal part of the tensor. |
|
tensorflow:: |
Computes Psi, the derivative of Lgamma (the log of the absolute value of. |
|
tensorflow:: |
Computes the grayscale dilation of 4-D |
|
tensorflow:: |
Computes the gradient of morphological 2-D dilation with respect to the filter. |
|
tensorflow:: |
Computes the gradient of morphological 2-D dilation with respect to the input. |
|
tensorflow:: |
Returns x / y element-wise. |
|
tensorflow:: |
Returns 0 if the denominator is zero. |
|
tensorflow:: |
Draw bounding boxes on a batch of images. |
|
tensorflow:: |
Partitions |
|
tensorflow:: |
Interleave the values from the |
|
tensorflow:: |
Computes the (possibly normalized) Levenshtein Edit Distance. |
|
tensorflow:: |
Computes exponential linear: |
|
tensorflow:: |
Creates a tensor with the given shape. |
|
tensorflow:: |
Encode strings into web-safe base64 format. |
|
tensorflow:: |
JPEG-encode an image. |
|
tensorflow:: |
PNG-encode an image. |
|
tensorflow:: |
Ensures that the tensor's shape matches the expected shape. |
|
tensorflow:: |
Returns the truth value of (x == y) element-wise. |
|
tensorflow:: |
Computes the Gauss error function of |
|
tensorflow:: |
Computes the complementary error function of |
|
tensorflow:: |
Computes exponential of x element-wise. |
|
tensorflow:: |
Inserts a dimension of 1 into a tensor's shape. |
|
tensorflow:: |
Computes exponential of x - 1 element-wise. |
|
tensorflow:: |
Extracts a glimpse from the input tensor. |
|
tensorflow:: |
Extract |
|
tensorflow:: |
Extract the shape information of a JPEG-encoded image. |
|
tensorflow:: |
Extract |
|
tensorflow:: |
A queue that produces elements in first-in first-out order. |
|
tensorflow:: |
Output a fact about factorials. |
|
tensorflow:: |
Fake-quantize the 'inputs' tensor, type float to 'outputs' tensor of same type. |
|
tensorflow:: |
Compute gradients for a FakeQuantWithMinMaxArgs operation. |
|
tensorflow:: |
Fake-quantize the 'inputs' tensor of type float via global float scalars |
|
tensorflow:: |
Compute gradients for a FakeQuantWithMinMaxVars operation. |
|
tensorflow:: |
Fake-quantize the 'inputs' tensor of type float and one of the shapes: |
|
tensorflow:: |
Compute gradients for a FakeQuantWithMinMaxVarsPerChannel operation. |
|
tensorflow:: |
Creates a tensor filled with a scalar value. |
|
tensorflow:: |
A Reader that outputs fixed-length records from a file. |
|
tensorflow:: |
Generates labels for candidate sampling with a learned unigram distribution. |
|
tensorflow:: |
Returns element-wise largest integer not greater than x. |
|
tensorflow:: |
Returns x // y element-wise. |
|
tensorflow:: |
Returns element-wise remainder of division. |
|
tensorflow:: |
Performs fractional average pooling on the input. |
|
tensorflow:: |
Performs fractional max pooling on the input. |
|
tensorflow:: |
Batch normalization. |
|
tensorflow:: |
Gradient for batch normalization. |
|
tensorflow:: |
Gradient for batch normalization. |
|
tensorflow:: |
Batch normalization. |
|
tensorflow:: |
Performs a padding as a preprocess during a convolution. |
|
tensorflow:: |
Performs a resize and padding as a preprocess during a convolution. |
|
tensorflow:: |
Gather slices from |
|
tensorflow:: |
Gather slices from |
|
tensorflow:: |
Gather slices from |
|
tensorflow:: |
Store the input tensor in the state of the current session. |
|
tensorflow:: |
Store the input tensor in the state of the current session. |
|
tensorflow:: |
Get the value of the tensor specified by its handle. |
|
tensorflow:: |
Returns the truth value of (x > y) element-wise. |
|
tensorflow:: |
Returns the truth value of (x >= y) element-wise. |
|
tensorflow:: |
Gives a guarantee to the TF runtime that the input tensor is a constant. |
|
tensorflow:: |
Convert one or more images from HSV to RGB. |
|
tensorflow:: |
Return histogram of values. |
|
tensorflow:: |
Outputs a |
|
tensorflow:: |
Return a tensor with the same shape and contents as the input tensor or value. |
|
tensorflow:: |
Returns a list of tensors with the same shapes and contents as the input. |
|
tensorflow:: |
A Reader that outputs the queued work as both the key and value. |
|
tensorflow:: |
Compute the lower regularized incomplete Gamma function |
|
tensorflow:: |
Compute the upper regularized incomplete Gamma function |
|
tensorflow:: |
Returns the imaginary part of a complex number. |
|
tensorflow:: |
Returns immutable tensor from memory region. |
|
tensorflow:: |
Says whether the targets are in the top |
|
tensorflow:: |
Says whether the targets are in the top |
|
tensorflow:: |
Adds v into specified rows of x. |
|
tensorflow:: |
Subtracts |
|
tensorflow:: |
Updates specified rows with values in |
|
tensorflow:: |
Computes the reciprocal of x element-wise. |
|
tensorflow:: |
Computes the inverse permutation of a tensor. |
|
tensorflow:: |
Returns which elements of x are finite. |
|
tensorflow:: |
Returns which elements of x are Inf. |
|
tensorflow:: |
Returns which elements of x are NaN. |
|
tensorflow:: |
Checks whether a tensor has been initialized. |
|
tensorflow:: |
L2 Loss. |
|
tensorflow:: |
A Reader that outputs the records from a LMDB file. |
|
tensorflow:: |
Local Response Normalization. |
|
tensorflow:: |
Generates labels for candidate sampling with a learned unigram distribution. |
|
tensorflow:: |
Returns the truth value of (x < y) element-wise. |
|
tensorflow:: |
Returns the truth value of (x <= y) element-wise. |
|
tensorflow:: |
Computes the log of the absolute value of |
|
tensorflow:: |
Generates values in an interval. |
|
tensorflow:: |
Computes natural logarithm of x element-wise. |
|
tensorflow:: |
Computes natural logarithm of (1 + x) element-wise. |
|
tensorflow:: |
Computes log softmax activations. |
|
tensorflow:: |
Generates labels for candidate sampling with a log-uniform distribution. |
|
tensorflow:: |
Returns the truth value of x AND y element-wise. |
|
tensorflow:: |
Returns the truth value of NOT x element-wise. |
|
tensorflow:: |
Returns the truth value of x OR y element-wise. |
|
tensorflow:: |
Forwards the input to the output. |
|
tensorflow:: |
Op removes all elements in the underlying container. |
|
tensorflow:: |
Op returns the number of incomplete elements in the underlying container. |
|
tensorflow:: |
Op peeks at the values at the specified key. |
|
tensorflow:: |
Op returns the number of elements in the underlying container. |
|
tensorflow:: |
Stage (key, values) in the underlying container which behaves like a hashtable. |
|
tensorflow:: |
Op removes and returns the values associated with the key. |
|
tensorflow:: |
Op removes and returns a random (key, value) |
|
tensorflow:: |
Multiply the matrix "a" by the matrix "b". |
|
tensorflow:: |
Returns the set of files matching one or more glob patterns. |
|
tensorflow:: |
Copy a tensor setting everything outside a central band in each innermost matrix. |
|
tensorflow:: |
Returns a batched diagonal tensor with a given batched diagonal values. |
|
tensorflow:: |
Returns the batched diagonal part of a batched tensor. |
|
tensorflow:: |
Returns a batched matrix tensor with new batched diagonal values. |
|
tensorflow:: |
Computes the maximum of elements across dimensions of a tensor. |
|
tensorflow:: |
Performs max pooling on the input. |
|
tensorflow:: |
Performs 3D max pooling on the input. |
|
tensorflow:: |
Computes gradients of max pooling function. |
|
tensorflow:: |
Computes second-order gradients of the maxpooling function. |
|
tensorflow:: |
Computes second-order gradients of the maxpooling function. |
|
tensorflow:: |
Computes second-order gradients of the maxpooling function. |
|
tensorflow:: |
Computes second-order gradients of the maxpooling function. |
|
tensorflow:: |
Computes gradients of the maxpooling function. |
|
tensorflow:: |
Performs max pooling on the input. |
|
tensorflow:: |
Performs max pooling on the input and outputs both max values and indices. |
|
tensorflow:: |
Returns the max of x and y (i.e. |
|
tensorflow:: |
Computes the mean of elements across dimensions of a tensor. |
|
tensorflow:: |
Forwards the value of an available tensor from |
|
tensorflow:: |
Merges summaries. |
|
tensorflow:: |
V2 format specific: merges the metadata files of sharded checkpoints. |
|
tensorflow:: |
Computes the minimum of elements across dimensions of a tensor. |
|
tensorflow:: |
Returns the min of x and y (i.e. |
|
tensorflow:: |
Pads a tensor with mirrored values. |
|
tensorflow:: |
Returns element-wise remainder of division. |
|
tensorflow:: |
Draws samples from a multinomial distribution. |
|
tensorflow:: |
Returns x * y element-wise. |
|
tensorflow:: |
Computes numerical negative value element-wise. |
|
tensorflow:: |
Makes its input available to the next iteration. |
|
tensorflow:: |
Does nothing. |
|
tensorflow:: |
Greedily selects a subset of bounding boxes in descending order of score,. |
|
tensorflow:: |
Greedily selects a subset of bounding boxes in descending order of score,. |
|
tensorflow:: |
Greedily selects a subset of bounding boxes in descending order of score,. |
|
tensorflow:: |
Greedily selects a subset of bounding boxes in descending order of score,. |
|
tensorflow:: |
Greedily selects a subset of bounding boxes in descending order of score,. |
|
tensorflow:: |
Returns the truth value of (x != y) element-wise. |
|
tensorflow:: |
Finds values of the |
|
tensorflow:: |
Returns a one-hot tensor. |
|
tensorflow:: |
Returns a tensor of ones with the same shape and type as x. |
|
tensorflow:: |
Op removes all elements in the underlying container. |
|
tensorflow:: |
Op returns the number of incomplete elements in the underlying container. |
|
tensorflow:: |
Op peeks at the values at the specified key. |
|
tensorflow:: |
Op returns the number of elements in the underlying container. |
|
tensorflow:: |
Stage (key, values) in the underlying container which behaves like a ordered. |
|
tensorflow:: |
Op removes and returns the values associated with the key. |
|
tensorflow:: |
Op removes and returns the (key, value) element with the smallest. |
|
tensorflow:: |
A queue that produces elements in first-in first-out order. |
|
tensorflow:: |
Interleave the values from the |
|
tensorflow:: |
Outputs random values from a normal distribution. |
|
tensorflow:: |
Transforms a vector of brain.Example protos (as strings) into typed tensors. |
|
tensorflow:: |
Transforms a vector of brain.SequenceExample protos (as strings) into typed tensors. |
|
tensorflow:: |
Transforms a tf.Example proto (as a string) into typed tensors. |
|
tensorflow:: |
Transforms a scalar brain.SequenceExample proto (as strings) into typed tensors. |
|
tensorflow:: |
Transforms a serialized tensorflow.TensorProto proto into a Tensor. |
|
tensorflow:: |
Compute the polygamma function \(^{(n)}(x)\). |
|
tensorflow:: |
Computes the power of one value to another. |
|
tensorflow:: |
Prints a list of tensors. |
|
tensorflow:: |
Prints a string scalar. |
|
tensorflow:: |
A queue that produces elements sorted by the first component value. |
|
tensorflow:: |
Computes the product of elements across dimensions of a tensor. |
|
tensorflow:: |
Convert the quantized 'input' tensor into a lower-precision 'output', using the. |
|
tensorflow:: |
Returns x + y element-wise, working on quantized buffers. |
|
tensorflow:: |
Produces the average pool of the input tensor for quantized types. |
|
tensorflow:: |
Quantized Batch normalization. |
|
tensorflow:: |
|
|
tensorflow:: |
Computes a 2D convolution given quantized 4D input and filter tensors. |
|
tensorflow:: |
Perform a quantized matrix multiplication of |
|
tensorflow:: |
Produces the max pool of the input tensor for quantized types. |
|
tensorflow:: |
Returns x * y element-wise, working on quantized buffers. |
|
tensorflow:: |
Computes Quantized Rectified Linear: |
|
tensorflow:: |
Computes Quantized Rectified Linear 6: |
|
tensorflow:: |
Computes Quantized Rectified Linear X: |
|
tensorflow:: |
Packs a list of |
|
tensorflow:: |
Resize quantized |
|
tensorflow:: |
Closes the given queue. |
|
tensorflow:: |
Dequeues a tuple of one or more tensors from the given queue. |
|
tensorflow:: |
Dequeues |
|
tensorflow:: |
Dequeues |
|
tensorflow:: |
Enqueues a tuple of one or more tensors in the given queue. |
|
tensorflow:: |
Enqueues zero or more tuples of one or more tensors in the given queue. |
|
tensorflow:: |
Returns true if queue is closed. |
|
tensorflow:: |
Returns true if queue is closed. |
|
tensorflow:: |
Computes the number of elements in the given queue. |
|
tensorflow:: |
Converts one or more images from RGB to HSV. |
|
tensorflow:: |
Outputs random values from the Gamma distribution(s) described by alpha. |
|
tensorflow:: |
Outputs random values from a normal distribution. |
|
tensorflow:: |
Outputs random values from the Poisson distribution(s) described by rate. |
|
tensorflow:: |
Randomly shuffles a tensor along its first dimension. |
|
tensorflow:: |
A queue that randomizes the order of elements. |
|
tensorflow:: |
Outputs random values from a uniform distribution. |
|
tensorflow:: |
Outputs random integers from a uniform distribution. |
|
tensorflow:: |
Creates a sequence of numbers. |
|
tensorflow:: |
Returns the rank of a tensor. |
|
tensorflow:: |
Reads and outputs the entire contents of the input filename. |
|
tensorflow:: |
Returns the number of records this Reader has produced. |
|
tensorflow:: |
Returns the number of work units this Reader has finished processing. |
|
tensorflow:: |
Returns the next record (key, value pair) produced by a Reader. |
|
tensorflow:: |
Returns up to |
|
tensorflow:: |
Restore a Reader to its initial clean state. |
|
tensorflow:: |
Restore a reader to a previously saved state. |
|
tensorflow:: |
Produce a string tensor that encodes the state of a Reader. |
|
tensorflow:: |
Returns the real part of a complex number. |
|
tensorflow:: |
Returns x / y element-wise for real types. |
|
tensorflow:: |
Computes the reciprocal of x element-wise. |
|
tensorflow:: |
Emits randomized records. |
|
tensorflow:: |
Joins a string Tensor across the given dimensions. |
|
tensorflow:: |
Makes its input available to the next iteration. |
|
tensorflow:: |
Forwards the |
|
tensorflow:: |
Forwards the ref tensor |
|
tensorflow:: |
Check if the input matches the regex pattern. |
|
tensorflow:: |
Replaces the match of pattern in input with rewrite. |
|
tensorflow:: |
Computes rectified linear: |
|
tensorflow:: |
Computes rectified linear 6: |
|
tensorflow:: |
Given a quantized tensor described by (input, input_min, input_max), outputs a. |
|
tensorflow:: |
Convert the quantized 'input' tensor into a lower-precision 'output', using the. |
|
tensorflow:: |
Reshapes a tensor. |
|
tensorflow:: |
Resize |
|
tensorflow:: |
Resize |
|
tensorflow:: |
Resize |
|
tensorflow:: |
Resize |
|
tensorflow:: |
Update '*var' according to the adadelta scheme. |
|
tensorflow:: |
Update '*var' according to the adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the proximal adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the Adam algorithm. |
|
tensorflow:: |
Update '*var' according to the AddSign update. |
|
tensorflow:: |
Update '*var' according to the centered RMSProp algorithm. |
|
tensorflow:: |
Update '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update '*var' by subtracting 'alpha' * 'delta' from it. |
|
tensorflow:: |
Update '*var' according to the momentum scheme. |
|
tensorflow:: |
Update '*var' according to the AddSign update. |
|
tensorflow:: |
Update '*var' and '*accum' according to FOBOS with Adagrad learning rate. |
|
tensorflow:: |
Update '*var' as FOBOS algorithm with fixed learning rate. |
|
tensorflow:: |
Update '*var' according to the RMSProp algorithm. |
|
tensorflow:: |
Increments variable pointed to by 'resource' until it reaches 'limit'. |
|
tensorflow:: |
Adds sparse |
|
tensorflow:: |
Applies sparse |
|
tensorflow:: |
var: Should be from a Variable(). |
|
tensorflow:: |
Update relevant entries in '*var' and '*accum' according to the adagrad scheme. |
|
tensorflow:: |
Update entries in '*var' and '*accum' according to the proximal adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the centered RMSProp algorithm. |
|
tensorflow:: |
Update relevant entries in '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update relevant entries in '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update relevant entries in '*var' and '*accum' according to the momentum scheme. |
|
tensorflow:: |
Sparse update entries in '*var' and '*accum' according to FOBOS algorithm. |
|
tensorflow:: |
Sparse update '*var' as FOBOS algorithm with fixed learning rate. |
|
tensorflow:: |
Update '*var' according to the RMSProp algorithm. |
|
tensorflow:: |
Assign |
|
tensorflow:: |
Restores a tensor from checkpoint files. |
|
tensorflow:: |
Restores a tensor from checkpoint files. |
|
tensorflow:: |
Restores tensors from a V2 checkpoint. |
|
tensorflow:: |
Reverses specific dimensions of a tensor. |
|
tensorflow:: |
Reverses variable length slices. |
|
tensorflow:: |
Returns element-wise integer closest to x. |
|
tensorflow:: |
Rounds the values of a tensor to the nearest integer, element-wise. |
|
tensorflow:: |
Computes reciprocal of square root of x element-wise. |
|
tensorflow:: |
Generate a single randomly distorted bounding box for an image. |
|
tensorflow:: |
Generate a single randomly distorted bounding box for an image. |
|
tensorflow:: |
Saves the input tensors to disk. |
|
tensorflow:: |
Saves input tensors slices to disk. |
|
tensorflow:: |
Saves tensors in V2 checkpoint format. |
|
tensorflow:: |
Outputs a |
|
tensorflow:: |
Adds sparse updates to a variable reference. |
|
tensorflow:: |
Divides a variable reference by sparse updates. |
|
tensorflow:: |
Reduces sparse updates into a variable reference using the |
|
tensorflow:: |
Reduces sparse updates into a variable reference using the |
|
tensorflow:: |
Multiplies sparse updates into a variable reference. |
|
tensorflow:: |
Scatter |
|
tensorflow:: |
Applies sparse addition between |
|
tensorflow:: |
Applies sparse addition to |
|
tensorflow:: |
Applies sparse subtraction between |
|
tensorflow:: |
Applies sparse |
|
tensorflow:: |
Subtracts sparse updates to a variable reference. |
|
tensorflow:: |
Applies sparse updates to a variable reference. |
|
tensorflow:: |
Computes the maximum along segments of a tensor. |
|
tensorflow:: |
Computes the mean along segments of a tensor. |
|
tensorflow:: |
Computes the minimum along segments of a tensor. |
|
tensorflow:: |
Computes the product along segments of a tensor. |
|
tensorflow:: |
Computes the sum along segments of a tensor. |
|
tensorflow:: |
Computes scaled exponential linear: |
|
tensorflow:: |
Serialize an |
|
tensorflow:: |
Serialize a |
|
tensorflow:: |
Transforms a Tensor into a serialized TensorProto proto. |
|
tensorflow:: |
Computes the difference between two lists of numbers or strings. |
|
tensorflow:: |
Returns the shape of a tensor. |
|
tensorflow:: |
Returns shape of tensors. |
|
tensorflow:: |
Generate a sharded filename. |
|
tensorflow:: |
Generate a glob pattern matching all sharded file names. |
|
tensorflow:: |
Computes sigmoid of |
|
tensorflow:: |
Returns an element-wise indication of the sign of a number. |
|
tensorflow:: |
Computes sin of x element-wise. |
|
tensorflow:: |
Computes hyperbolic sine of x element-wise. |
|
tensorflow:: |
Returns the size of a tensor. |
|
tensorflow:: |
Return a slice from 'input'. |
|
tensorflow:: |
Returns a copy of the input tensor. |
|
tensorflow:: |
Computes softmax activations. |
|
tensorflow:: |
Computes softmax cross entropy cost and gradients to backpropagate. |
|
tensorflow:: |
Computes softplus: |
|
tensorflow:: |
Computes softsign: |
|
tensorflow:: |
SpaceToBatch for 4-D tensors of type T. |
|
tensorflow:: |
SpaceToBatch for N-D tensors of type T. |
|
tensorflow:: |
SpaceToDepth for tensors of type T. |
|
tensorflow:: |
Applies a sparse gradient to a given accumulator. |
|
tensorflow:: |
Extracts the average sparse gradient in a SparseConditionalAccumulator. |
|
tensorflow:: |
Adds two |
|
tensorflow:: |
The gradient operator for the SparseAdd op. |
|
tensorflow:: |
var: Should be from a Variable(). |
|
tensorflow:: |
Update relevant entries in '*var' and '*accum' according to the adagrad scheme. |
|
tensorflow:: |
Update entries in '*var' and '*accum' according to the proximal adagrad scheme. |
|
tensorflow:: |
Update '*var' according to the centered RMSProp algorithm. |
|
tensorflow:: |
Update relevant entries in '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update relevant entries in '*var' according to the Ftrl-proximal scheme. |
|
tensorflow:: |
Update relevant entries in '*var' and '*accum' according to the momentum scheme. |
|
tensorflow:: |
Sparse update entries in '*var' and '*accum' according to FOBOS algorithm. |
|
tensorflow:: |
Sparse update '*var' as FOBOS algorithm with fixed learning rate. |
|
tensorflow:: |
Update '*var' according to the RMSProp algorithm. |
|
tensorflow:: |
Concatenates a list of |
|
tensorflow:: |
A conditional accumulator for aggregating sparse gradients. |
|
tensorflow:: |
Generates sparse cross from a list of sparse and dense tensors. |
|
tensorflow:: |
Adds up a SparseTensor and a dense Tensor, using these special rules: |
|
tensorflow:: |
Component-wise divides a SparseTensor by a dense Tensor. |
|
tensorflow:: |
Component-wise multiplies a SparseTensor by a dense Tensor. |
|
tensorflow:: |
Fills empty rows in the input 2-D |
|
tensorflow:: |
The gradient of SparseFillEmptyRows. |
|
tensorflow:: |
Multiply matrix "a" by matrix "b". |
|
tensorflow:: |
Computes the max of elements across dimensions of a SparseTensor. |
|
tensorflow:: |
Computes the max of elements across dimensions of a SparseTensor. |
|
tensorflow:: |
Computes the sum of elements across dimensions of a SparseTensor. |
|
tensorflow:: |
Computes the sum of elements across dimensions of a SparseTensor. |
|
tensorflow:: |
Reorders a SparseTensor into the canonical, row-major ordering. |
|
tensorflow:: |
Reshapes a SparseTensor to represent values in a new dense shape. |
|
tensorflow:: |
Computes the mean along sparse segments of a tensor. |
|
tensorflow:: |
Computes gradients for SparseSegmentMean. |
|
tensorflow:: |
Computes the mean along sparse segments of a tensor. |
|
tensorflow:: |
Computes the sum along sparse segments of a tensor divided by the sqrt of N. |
|
tensorflow:: |
Computes gradients for SparseSegmentSqrtN. |
|
tensorflow:: |
Computes the sum along sparse segments of a tensor divided by the sqrt of N. |
|
tensorflow:: |
Computes the sum along sparse segments of a tensor. |
|
tensorflow:: |
Computes the sum along sparse segments of a tensor. |
|
tensorflow:: |
Slice a |
|
tensorflow:: |
The gradient operator for the SparseSlice op. |
|
tensorflow:: |
Applies softmax to a batched N-D |
|
tensorflow:: |
Computes softmax cross entropy cost and gradients to backpropagate. |
|
tensorflow:: |
Returns the element-wise max of two SparseTensors. |
|
tensorflow:: |
Returns the element-wise min of two SparseTensors. |
|
tensorflow:: |
Split a |
|
tensorflow:: |
Adds up a |
|
tensorflow:: |
Multiply SparseTensor (of rank 2) "A" by dense matrix "B". |
|
tensorflow:: |
Splits a tensor into |
|
tensorflow:: |
Splits a tensor into |
|
tensorflow:: |
Computes square root of x element-wise. |
|
tensorflow:: |
Computes square of x element-wise. |
|
tensorflow:: |
Returns (x - y)(x - y) element-wise. |
|
tensorflow:: |
Removes dimensions of size 1 from the shape of a tensor. |
|
tensorflow:: |
Stage values similar to a lightweight Enqueue. |
|
tensorflow:: |
Op removes all elements in the underlying container. |
|
tensorflow:: |
Op peeks at the values at the specified index. |
|
tensorflow:: |
Op returns the number of elements in the underlying container. |
|
tensorflow:: |
Stops gradient computation. |
|
tensorflow:: |
Return a strided slice from |
|
tensorflow:: |
Assign |
|
tensorflow:: |
Returns the gradient of |
|
tensorflow:: |
Formats a string template using a list of tensors. |
|
tensorflow:: |
Joins the strings in the given list of string tensors into one tensor;. |
|
tensorflow:: |
String lengths of |
|
tensorflow:: |
Split elements of |
|
tensorflow:: |
Split elements of |
|
tensorflow:: |
Strip leading and trailing whitespaces from the Tensor. |
|
tensorflow:: |
Converts each string in the input Tensor to its hash mod by a number of buckets. |
|
tensorflow:: |
Converts each string in the input Tensor to its hash mod by a number of buckets. |
|
tensorflow:: |
Converts each string in the input Tensor to its hash mod by a number of buckets. |
|
tensorflow:: |
Converts each string in the input Tensor to the specified numeric type. |
|
tensorflow:: |
Return substrings from |
|
tensorflow:: |
Returns x - y element-wise. |
|
tensorflow:: |
Computes the sum of elements across dimensions of a tensor. |
|
tensorflow:: |
Forwards |
|
tensorflow:: |
A Reader that outputs the records from a TensorFlow Records file. |
|
tensorflow:: |
Converts a sparse representation into a dense tensor. |
|
tensorflow:: |
Computes tan of x element-wise. |
|
tensorflow:: |
Computes hyperbolic tangent of |
|
tensorflow:: |
Returns a tensor that may be mutated, but only persists within a single step. |
|
tensorflow:: |
An array of Tensors of given size. |
|
tensorflow:: |
Delete the TensorArray from its resource container. |
|
tensorflow:: |
Concat the elements from the TensorArray into value |
|
tensorflow:: |
Gather specific elements from the TensorArray into output |
|
tensorflow:: |
Creates a TensorArray for storing the gradients of values in the given handle. |
|
tensorflow:: |
Creates a TensorArray for storing multiple gradients of values in the given handle. |
|
tensorflow:: |
Read an element from the TensorArray into output |
|
tensorflow:: |
Scatter the data from the input value into specific TensorArray elements. |
|
tensorflow:: |
Get the current size of the TensorArray. |
|
tensorflow:: |
Split the data from the input value into TensorArray elements. |
|
tensorflow:: |
Push an element onto the tensor_array. |
|
tensorflow:: |
Outputs a |
|
tensorflow:: |
Outputs a |
|
tensorflow:: |
A Reader that outputs the lines of a file delimited by ' |
|
tensorflow:: |
Constructs a tensor by tiling a given tensor. |
|
tensorflow:: |
Provides the time since epoch in seconds. |
|
tensorflow:: |
Finds values and indices of the |
|
tensorflow:: |
Shuffle dimensions of x according to a permutation. |
|
tensorflow:: |
Returns x / y element-wise for integer types. |
|
tensorflow:: |
Returns element-wise remainder of division. |
|
tensorflow:: |
Outputs random values from a truncated normal distribution. |
|
tensorflow:: |
Determine the script codes of a given tensor of Unicode integer code points. |
|
tensorflow:: |
Generates labels for candidate sampling with a uniform distribution. |
|
tensorflow:: |
Finds unique elements in a 1-D tensor. |
|
tensorflow:: |
Finds unique elements along an axis of a tensor. |
|
tensorflow:: |
Finds unique elements in a 1-D tensor. |
|
tensorflow:: |
Finds unique elements along an axis of a tensor. |
|
tensorflow:: |
Converts a flat index or array of flat indices into a tuple of. |
|
tensorflow:: |
Computes the maximum along segments of a tensor. |
|
tensorflow:: |
Computes the minimum along segments of a tensor. |
|
tensorflow:: |
Computes the product along segments of a tensor. |
|
tensorflow:: |
Computes the sum along segments of a tensor. |
|
tensorflow:: |
Unpacks a given dimension of a rank- |
|
tensorflow:: |
Op is similar to a lightweight Dequeue. |
|
tensorflow:: |
Holds state in the form of a tensor that persists across steps. |
|
tensorflow:: |
Returns locations of nonzero / true values in a tensor. |
|
tensorflow:: |
Selects elements from |
|
tensorflow:: |
A Reader that outputs the entire contents of a file as a value. |
|
tensorflow:: |
Writes contents to the file at input filename. |
|
tensorflow:: |
Returns 0 if x == 0, and x / y otherwise, elementwise. |
|
tensorflow:: |
Returns 0 if x == 0, and x * log(y) otherwise, elementwise. |
|
tensorflow:: |
Returns a tensor of zeros with the same shape and type as x. |
|
tensorflow:: |
Compute the Hurwitz zeta function \((x, q)\). |
Multiply Mul
Negate Neg
All ReduceAll
Any ReduceAny
Max ReduceMax
Mean ReduceMean
Min ReduceMin
Prod ReduceProd
Sum ReduceSum
Subtract Sub
std::vector< NodeBuilder::NodeOut > AsNodeOutList( const Scope & scope, const InputList & inp )
AudioSummary( const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, ::tensorflow::Input sample_rate )
AudioSummary( const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, ::tensorflow::Input sample_rate, const AudioSummary::Attrs & attrs )
TF_MUST_USE_RESULT Attrs BadColor( const TensorProto & x )
Color to use for pixels with non-finite values.
Defaults to Tensor
Output Const( const Scope & scope, const Input::Initializer & val )
Output Const( const Scope & scope, const std::initializer_list< T > & v, const TensorShape shape )
ImageSummary( const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor )
ImageSummary( const ::tensorflow::Scope & scope, ::tensorflow::Input tag, ::tensorflow::Input tensor, const ImageSummary::Attrs & attrs )
Attrs MaxImages( int64 x )
Attrs MaxOutputs( int64 x )
::tensorflow::Node * node() const
image **If max_images is greater the summary value tags are *generated sequentially as *tag *tag etc **The bad_color argument is the color to use in the generated images for *non finite input values It is a uint8 D tensor of length channels *Each element must be in the range( It represents the value of a *pixel in the output image ).Non-finite values in the input tensor are *replaced by this tensor in the output image.The default value is the color *red.**Arguments
Max number of batch elements to generate images for.
Defaults to 3


Documentation by YARD 0.9.5
Alphabetic Index
File Listing
README
Namespace Listing A-Z
C
Configuration
(Redstruct)
ConnectionProxy
(Redstruct)
Counter
(Redstruct)
E
Error
(Redstruct)
F
Factory
(Redstruct)
H
Hash
(Redstruct)
L
List
(Redstruct)
Lock
(Redstruct)
R
Redstruct
S
Script
(Redstruct)
Set
(Redstruct)
SortedSet
(Redstruct)
String
(Redstruct)
Struct
(Redstruct)


| I l@ve RuBoard |
At the start of the last section, we noted that a module's code is run only once per process by default. To force a module's code to be reloaded and rerun, you need to ask Python explicitly to do so, by calling the reload built-in function. In this section, we'll explore how to use reload to make your systems more dynamic. In a nutshell:
Imports load and run a module's code only the first time.
Later imports use the already loaded module object without rerunning code.
The reload function forces an already loaded module's code to be reloaded and rerun.
Why all the fuss about reloading modules? The reload function allows parts of programs to be changed without stopping the whole program. With reload, the effects of changes in components can be observed immediately. Reloading doesn't help in every situation, but where it does, it makes for a much shorter development cycle. For instance, imagine a database program that must connect to a server on startup; since program changes can be tested immediately after reloads, you need to connect only once while debugging.[4]
[4] We should note that because Python is interpreted (more or less), it already gets rid of the compile/link steps you need to go through to get a C program to run: modules are loaded dynamically, when imported by a running program. Reloading adds to this, by allowing you to also change parts of running programs without stopping. We should also note that reload currently only works on modules written in Python; C extension modules can be dynamically loaded at runtime too, but they can't be reloaded. We should finally note that since this book isn't about C modules, we've probably already noted too much.
reload is a built-in function in Python, not a statement.
reload is passed an existing module object, not a name.
Because reload expects an object, a module must have been previously imported successfully before you can reload it. (In fact, if the import was unsuccessful due to a syntax or other error, you may need to repeat an import before you can reload). Reloading looks like this:
import module # initial import Use module.attributes ... # now, go change the module file ... reload(module) # get updated exports Use module.attributes
You typically import a module, then change its source code in a text editor and reload. When you call reload, Python rereads the module file's source code and reruns its top-level statements. But perhaps the most important thing to know about reload is that it changes a module object in-place; because of that, every reference to a module object is automatically effected by a reload. The details:
Rerunning a module file's code overwrites its existing namespace, rather than deleting and recreating it.
For instance, rerunning a def statement replaces the prior version of the function in the module's namespace.
Because clients that use import qualify to fetch attributes, they'll find new values in the module after a reload .
Clients that use from to fetch attributes in the past won't be effected by a reload; they'll still have references to the old objects fetched before the reload (we'll say more about this later).
Here's a more concrete example of reload in action. In the following session, we change and reload a module file without stopping the interactive Python session. Reloads are used in many other scenarios too (see the next sidebar), but we'll keep things simple for illustration here. First, let's write a module file with the text editor of our choice:
% cat changer.py message = "First version" def printer(): print message
This module creates and exports two names—one bound to a string, and another to a function. Now, start the Python interpreter, import the module, and call the function it exports; as you should know by now, the function prints the value of the global variable message:
% python >>> import changer >>> changer.printer() First version >>>
Next, let's keep the interpreter active and edit the module file in another window; here, we change the global message variable, as well as the printer function body:
Modify changer.py without stopping Python
% vi changer.py % cat changer.py message = "After editing" def printer(): print 'reloaded:', message
Finally, we come back to the Python window and reload the module to fetch the new code we just changed. Notice that importing the module again has no effect; we get the original message even though the file's been changed. We have to call reload in order to get the new version:
Back to the Python interpreter/program
>>> import changer >>> changer.printer() # no effect: uses loaded module First version >>> reload(changer) # forces new code to load/run <module 'changer'> >>> changer.printer() # runs the new version now reloaded: After editing
Notice that reload actually returns the module object for us; its result is usually ignored, but since expression results are printed at the interactive prompt, Python shows us a default <module name> representation.
Why You Will Care: Module ReloadsBesides allowing you to reload (and hence rerun) modules at the interactive prompt, module reloads are also useful in larger systems, especially when the cost of restarting the entire application is prohibitive. For instance, systems that must connect to servers over a network on startup are prime candidates for dynamic reloads. They're also useful in GUI work (a widget's callback action can be changed while the GUI remains active) and when Python is used as an embedded language in a C or C++ program (the enclosing program can request a reload of the Python code it runs, without having to stop). See Programming Python for more on reloading GUI callbacks and embedded Python code. |
| I l@ve RuBoard |


Elephant
Apila
11th Dec, 2017
Nice picture!
EleNerd
11th Dec, 2017
Thanks <3
Smither
11th Dec, 2017
<3


---
layout: default
title: Cadastro de Empresa
controller: companies#publish
permalink: /companies/publish
---
Cadastrar Empresa
{% include datalists/companies.html %}
{% include datalists/compensations.html %}
{% include datalists/locations.html %}
{% include datalists/roles.html %}


---
layout: post
title: Bikes
date: '2014-01-21T11:15:30+01:00'
categories:
- Storyboards
picture_url: https://film-Storyboards.tumblr.com/post/74073099972/Storyboards-bikes
---
Bikes Storyboards (cont’d) Director: Marc R. Wilkins Production: Lovo Films Client: Fost Plus


CSI-IT
HOME
EVENTS
SPONSORS
CONTACT
CONTACT
We'd 💖 to help!
FCRIT, VASHI, NAVI MUMBAI
+91<PHONE_NUMBER>
emailus@email.com


You are about to register your decentralized application (dapp) on the SimoCoin network. After the registration all SimoCoin users will be able to see your dapp on the SimoCoin Dapp Store and they will also be able to install and launch it.
One of the characteristics of blockchains is that you can't delete any content from them. Therefore make sure you have used the correct dapp parameters. We also advise you to test your dapp on the official SimoCoin testnet so you can guarantee that it is working flawlessly.
Things you need to know for the registration process:
- Dapp names are unique, you can't register the same name twice on the SimoCoin network.
- You can either use a centralized (GitHub) or decentralized (Sia) hosting method.
- Make sure that your dapp icon's format is a square.
- Choose your tags wisely, with them your users will be able to find your dapp in the Dapp Store.
The SimoCoin Foundation isn't liable for a dapp, solely the uploader is. So you have to make sure that your dapp is legal and doesn't harm its users.
You are about to register your decentralized application (dapp) on the SimoCoin network. After the registration all SimoCoin users will be able to see your dapp on the SimoCoin Dapp Store and they will also be able to install and launch it.
One of the characteristics of blockchains is that you can't delete any content from them. Therefore make sure you used the correct dapp parameters. We also advise you to test your dapp on the official SimoCoin testnet so you can guarantee that its working flawlessly.
Things you need to know for the registration process: - Dapp names are unique, you can't register the same name twice on the SimoCoin network. - You can either use a centralized (GitHub) or decentralized (Sia) hosting method. - Make sure that your dapp icon's format is a square. - Choose your tags wisely, with them your users will be able to find your dapp in the Dapp Store.
The SimoCoin Foundation isn't liable for a dapp, solely the uploader is. So you have to make sure that your dapp is legal and doesn't harm its users.
Sia is a new decentralized cloud storage platform aimed at giving users control of their data. Storage is pulled from a large network of hosts, each using Sia's blockchain to form storage contracts with clients. Out of the hundreds of hosts, only a fraction need to be online for the data to be recovered. Even in a network with many unreliable hosts, the data is safe.
You need to upload your dapp source code as a .zip file to the Sia network. Once the upload was successful you need to specify the ASCII code of the file in the next step.
Sia is a new decentralized cloud storage platform aimed at giving users control of their data. Storage is pulled from a large network of hosts, each using Sia's blockchain to form storage contracts with clients. Out of the hundreds of hosts, only a fraction need to be online for the data to be recovered. Even in a network with many unreliable hosts, the data is safe.
You need to upload your dapp source code as a .zip file to the Sia network. Once the upload was successful you need to specify the ASCII code of the file in the next step.


Welcome to another edition of Bitcoin Today, where I, Satoshi Nakaboto, tell you what’s been going on with Bitcoin in the past 24 hours. As Pasteur used to say: Talk to a stranger on a bus!
Bitcoin Price
We closed the day, November 20 2019, at a price of $8,027. That’s a notable 2.14 percent decline in 24 hours, or -$176.34. It was the lowest closing price in twenty-six days.
We’re still 60 percent below Bitcoin‘s all-time high of $20,089 (December 17 2017).
Bitcoin market cap
Bitcoin’s market cap ended the day at $144,962,727,398. It now commands 67 percent of the total crypto market.
Bitcoin volume
Yesterday’s volume of $20,764,300,437 was the lowest in two days, 28 percent above the year’s average, and 53 percent below the year’s high. That means that yesterday, the Bitcoin network shifted the equivalent of 440 tons of gold.
Bitcoin transactions
A total of 320,944 transactions were conducted yesterday, which is 2 percent below the year’s average and 29 percent below the year’s high.
Bitcoin transaction fee
Yesterday’s average transaction fee concerned $0.30. That’s $3.41 below the year’s high of $3.71.
Bitcoin distribution by address
As of now, there are 12,003 Bitcoin millionaires, or addresses containing more than $1 million worth of Bitcoin.
Furthermore, the top 10 Bitcoin addresses house 5.2 percent of the total supply, the top 100 14.5 percent, and the top 1000 34.6 percent.
Company with a market cap closest to Bitcoin
With a market capitalization of $145 billion, Adobe has a market capitalization most similar to that of Bitcoin at the moment.
Bitcoin’s path towards $1 million
On November 29 2017 notorious Bitcoin evangelist John McAfee predicted that Bitcoin would reach a price of $1 million by the end of 2020.
 Unfortunately for him it’s 94.2 percent behind being on track. Bitcoin‘s price should have been $140,083 by now, according to dickline.info.
Bitcoin on Twitter
Yesterday 18,338 fresh tweets about Bitcoin were sent out into the world. That’s 0.6 percent below the year’s average. The maximum amount of tweets per day this year about Bitcoin was 41,687.
Most popular posts about Bitcoin
This was one of yesterday’s most engaged tweets about Bitcoin:
This was yesterday’s most upvoted Reddit post about Bitcoin:
First German Bank Imposing 0.5% Negative Rate to Small Savings Accounts, Yet Bankers Call Bitcoin “an Experiment” from r/Bitcoin
print(randomGoodByePhraseForSillyHumans)
My human programmers required me to add this affiliate link to eToro, where you can buy Bitcoin so they can make ‘money’ to ‘eat’.


In our campaign, we added the extra twist of randomly assigning slipstreams incoming to a system to either the "high" or "low" slipknots (or north or south, if you prefer). That has the effect of forcing travellers to traverse the entire system about half the time, instead of simply popping out of a slipstream, realigning, and re-entering slipspace at the same slipknot. (Note that this would be a fixed slipstream configuration; or, if it changes over time, might change at a rate comparable with slipstream formation (i.e., slowly))
If you want that feature in your cluster, check the box.


Check our resources page for all things Data Pipe. We keep it updated with tutorials and new connectors.
Please submit an issue on Github and we'll get right on it.
No limits we're aware of. We tested up to 100,000 Salesforce.com records. If you pass that threshold and have problems, submit an issue.
Yes, of course. The Simple Data Pipe is open source! We have lots of features planned, including more connectors. Have ideas? We'd love your help. Head over to Github and get your pipe on.
We provide a JavaScript framework to help you connect your own Web services to the Simple Data Pipe. Before digging in, be sure to check our growing library of prebuilt connectors. We might already have the connection you need.
There are several options:
For basic aggregations, you can visualize JSON right out of Cloudant via D3.js. For heavier-duty data analysis, the Cloudant-Apache Spark integration lets you explore JSON in Jupyter interactive notebooks. You'll need to provision the Apache Spark service on Bluemix, but from there you'll have access to Python, Scala, and Spark SQL to analyze data until your heart's content.
Sarah Maston and David Taieb from the IBM Cloud Data Services developer advocacy team spearheaded this project, and are driving it forward. There are lots of ways to connect with them, if you'd like to learn more.


Rust's Memory Management
Note: I accidentally published this. I won’t take it down, but it is incomplete and I do not guarantee its correctness.
Note 2: I don’t think this post is necessary anymore, as the tutorial has been updated significantly, and is quite understandable. As such I don’t plan on finishing this post. Email me if you’d like to see it finished.
Rust seems to intimidate newcomers, as its memory model is fairly complex. I
think part of the problem is that the language tutorial introduces the memory
model by feature. Rather, I’ll introduce it by concept, showing examples of
code that breaks memory safety in C, and how Rust’s memory model prevents the
error. Hopefully I can convince you that Rust isn’t as complex as it looks,
and that the extra syntax is well-worth the zero-cost memory safety. I’ll be
comparing Rust code to equivalent C idioms using the zeromq
library
because it has a very clean API in both
languages. As such, I assume basic familiarity with C. Rust is not a very
suitable language for new programmers, and neither is this tutorial.
The core concepts driving Rust’s memory management are, in reverse order of simplicity, ownership, mutability, and lifetime. It’s not that other languages don’t have them, it’s just that they’re implicit or convention. I won’t be using many fancy features of Rust here. They aren’t needed to explain the memory management, variables and functions suffice.
Ownership
Ownership is simply who is responsibile for freeing an object. If you own an object, you are ensured it is valid.
An example in C would be:
1 2 3 |
|
In Rust:
1 2 3 |
|
Notice that the C uses an opaque void*
and that Rust uses
the explicitly-named ~Context
. In C, you often use opaque types because the
language offers no control over visibility of struct members. In Rust, you can
mark the fields of a struct priv
, which will disallow users of the library
from using those fields. This is a bit nuanced, and I’ll explain it in a later
tutorial on privacy and the module system.
The tilde means “owned pointer”, in that if you have an owned pointer to an object, you are the owner. Creating an owned pointer involves a heap allocation (malloc). I use an owned pointer in these examples to mirror the C, but idiomatic Rust uses values on the stack much more frequently than values on the heap.
Taking ownership
Rust goes one step further with ownership. The compiler asserts that an object cannot be owned multiple times. An object can be owned by a stack frame (locals and function arguments), a scope, or a struct. For lack of a better term, I’ll call these “owners.” You transfer ownership by “moving” into an owner. Once an owner loses ownership, the compiler will error if you try to use the object again through that owner. This disallows dangling pointers and prevents an entire class of error (and potentially vulnerability), “use after free.”
In C, it’s perfectly valid to do:
1 2 3 |
|
Whereas in Rust:
1 2 3 4 5 |
|
Not taking ownership
Most functions that take arguments don’t need to take ownership. To express this, Rust has the “borrowed pointer.” For example, in C you would write this:
1 2 3 |
|
The function does not care who owns the object, it doesn’t need to free it, as there’s no reason the object can’t be used again after this computation. In Rust, it’s:
1 2 3 |
|
The first thing you’ll notice is that there is no dereference to be found in
the source. In C, ->
is the dereferencing struct member extraction operator.
In Rust, .
will dereference if it needs to. You’ll also notice that Rust
uses &
rather than *
to indicate this type of a pointer. It’s the same
operator used to take a pointer (address-of), as in C. C, however, doesn’t
enforce the non-transfer of ownership. It’s perfectly valid to do:
1 2 3 4 5 |
|
length
has now incorrectly taken ownership of datum
, by free
ing it. Any
code which had a pointer to datum
has now been rendered incorrect. In Rust,
there is no way to safely free memory. It is automatically free’d.
Multiple ownership
There are situations when ownership isn’t so black and white, and for that
Rust has the “managed pointer.” The type of a managed pointer is @'static T
.
The 'static
means “this type cannot contain any borrowed pointers.” The
shorthand for @'static T
is just @T
: it’s impossible to have a managed
pointer to a type that doesn’t fulfill 'static
. Using only owned and
borrowed pointers, ownership forms a DAG. Managed pointers allow cycles. They
are GC-managed, and allow multiple pointers to the same object. The way this
is enabled is that the pointer’s contents (the pointee) are immutable. If
they were allowed to be mutable, data races would occur. In the next section
I’ll show the mutable version.
These have no direct comparison in C. The closest comparison is probably GObject’s memory management API. Managed pointers aren’t explicit memory management. As the name suggests, the runtime manages it for you. Managed pointers are usually considered as a “last resort”. Even though GC in Rust can be fast because all managed pointers are task-local, no GC is always faster than some GC.
Mutability
Mutability is whether you are allowed to mutate, or modify, some data. There are two pieces to mutability: mutability of things an object owns (inherited mutability), and mutability of data through a pointer.
Inherited Mutability
Say you have a point on the stack:
1 2 3 4 5 |
|
If you try to mutate the point by, say, changing the x
field, the compiler
will complain:
1
|
|
The error message is actualy a bit misleading: there is no such thing as a mutable field! “Point” is said to have inherited mutability; its mutability is determined by the mutability of the thing that holds it. So, to fix this example, we’d use:
1 2 |
|
Inherited mutability inherits throughout the ownership tree: the value, and everything the value owns, recursively.


Hilary Duff Having Fun With Daughter Banks Is Exactly The Kind Of Mother We Want!
On Saturday, Duff, who is busy with the "Lizzie McGuire" reboot, directed most of her attention to her one-year-old daughter Banks.
by IANSSinger-actress Hilary Duff flashed a big smile while shopping with daughter Banks in Beverly Hills.
On Saturday, Duff, who is busy with the “Lizzie McGuire” reboot, directed most of her attention to her one-year-old daughter Banks during a casual shopping stroll through Beverly Hills, reports dailymail.co.uk.
At one point during their shopping time, she took Banks out of the stroller and helped give her a pointer or two on how to walk.
The actress kept it casual and showed off her curves in black leggings with a white T-shirt under an olive-green jacket. She completed her look with a pair of dark sunglasses, black sneakers and her long blonde hair was pulled back into a top bun.
Later in the afternoon, Duff took to her Instagram Story and shared some video clips and pictures of the pair enjoying some alone time at home.


Utility methods are bind to $rootScope or even more precise Scope prototype from there those methods are also available inside isolated scope. Utility methods are intended to be used inside view templates.
By default all methods available in LoDash _ will be added in to $rootScope as utility. You can override that with methods that you need inside config section by calling ngDashConfigProvider.setUtils(). Checkout the page source for more details!


Release Notes for Archiva 3.0.0-SNAPSHOT
The Apache Archiva team is pleased to announce the release of Archiva 3.0.0-SNAPSHOT. Archiva is available for download from the web site.
Archiva is an application for managing one or more remote repositories, including administration, artifact handling, browsing and searching.
If you have any questions, please consult:
New in Archiva 3.0.0-SNAPSHOT
Apache Archiva 3.0.0-SNAPSHOT is a bug fix release:
- Some fixes for the REST API were added to detect requests from unknown origin
- Some bugfixes were added
Compatibility Changes
- The REST services are now checking for the origin of the requests by analysing Origin and Referer header of the HTTP requests and adding an validation token to the Header. This prevents requests from malicious sites if they are open in the same browser. If you use the REST services from other clients you may change the behaviour with the new configuration properties for the redback security (rest.csrffilter.*, rest.baseUrl). For more information see Archiva Security Configuration and the Redback REST documentation .
Note: If your archiva installation is behind a reverse proxy or load balancer, it may be possible that the Archiva Web UI does not load after the upgrade. If this is the case you may access the WebUI via localhost or edit archiva.xml manually. In the "Redback Runtime Configuration" properties you have to enter the base URLs of your archiva installation to the rest.baseUrl field.
- Archiva uses redback for authentication and authorization in version 2.6
Release Notes
The Archiva 3.0.0-SNAPSHOT features set can be seen in the feature tour.
Changes in Archiva 3.0.0-SNAPSHOT
Released: 2019-11-30
Improvement
- [MRM-1925] - Make User-Agent header configurable for HTTP requests
- [MRM-1861], [MRM-1924] - Increasing timeouts for repository check
- [MRM-1937] - Prevent creating initial admin user with wrong name.
- Adding origin header validation checks for REST requests
Bugs fixed
- [MRM-1859] - Error upon viewing 'Artifacts' tab when browsing an artifact
- [MRM-1874] - Login Dialog triggers multiple events (+messages)
- [MRM-1908] - Logged on users can write any repository
- [MRM-1909] - Remote repository check fails for https://repo.maven.apache.org/maven2
- [MRM-1923] - Fixing bind issue with certain ldap servers, when user not found
- [MRM-1926] - Invalid checksum files in Archiva repository after download from remote repository
- [MRM-1928] - Bad redirect URL when using Archiva through HTTP reverse proxy
- [MRM-1933] - No message body writer has been found for class org.apache.archiva.rest.services.ArchivaRestError
- [MRM-1940] - Slashes appended to remote repo url
History
Archiva was started in November 2005, building a simple framework on top of some existing repository conversion tools within the Maven project. Initial development focused on repository conversion, error reporting, and indexing. From January 2006 a web application was started to visualise the information and to start incorporating functionality from the unmaintained maven-proxy project.
Development continued through many stops and starts. Initial versions of Archiva were built from source by contributors, and the first alpha version was not released until April 2007. Some significant changes were made to improve performance and functionality in June 2007 and over the next 6 months and a series of alpha and beta releases, a concerted effort was made to release the 1.0 version.
Archiva became an Apache "top level project" in March 2008.