Uploading Guidelines
These guidelines to uploading videos help map out contents better for Users and Creators. The title and genre of the videos help viewers get their targeted type of videos with less noise from videos that would not fall under those catalog.
Creators must fill each video properly with no false cataloging or tags added. Any that is found will be removed from view and ask to be fixed.
Some of these features will be present on release, others will be implemented over time. Videos uploaded after the new features are implemented must fill them out as requested, videos before are not but may show up less if not updated.
Average video will need to be 10 minutes long max. The video will require 1k views before Creators can monetize if they qualify.
Understand that this is an open platform and you are responsible for everything you upload to it. We will treat any violation with the utmost of the law to protect ourselves and other user's of this platform. We want everyone to use as much common sense this world still has to determine if it's okay to upload, or just look up what is Ok/Blacklisted on our platform. It's available to everyone and it's free.
VIDEO INFO
Channel: Creators will be able to make up to 4-5 channels. During upload, creators will choose which channel the video will upload too. Channels are seen as individual accounts and are treated as so. We will promote each Channel over the top "Spotlight", and continue to unless THAT Channel breaks the terms "or" the user profile in whole have been proven to be of violation.
Series: The Creator will check this box if this video is part of a series, which when chosen will show more opinion to choose the session and episode. The series will be given a title and will be there for future selections when more episodes are loaded to it.
Titles: the video name must clearly point out what is the main point of the video
Description: This will be used to give details and highlights of the video and it's content.
Audio License: This section is to input purchased license code for presentation to any company that may try to strike your videos for music used in it that you gain the rights to use. No more than 3 License (music) per video.
Production Team: Here you give credit to staff and other Creators. If they are on the platform you can use their ID# to link them directly to their profile
Genre: Video genre to properly catalog them, putting in the correct ones will help it be found faster by viewers of that type of fan based
VIDEO RATING
Rating: The level of Parental Control for age appropriate to age restriction of the content of the video.
When a user views a video with a Gilleo content rating, the page displays the Rating for each video that has a value other than None. This can be partnered up with detailed rating letters to point out key content that may be in the video that the brode ratings don't specify.
The video letter rating categories are listed below:
For categories where you've chosen the third option, a plus sign appears after the Rating. For example, the Gilleo content rating for a video with explicit language would appear as "Mature", but with nudity and such would appear as "Mature+" when click a info bubble will pop up to give more details with the letter telling what is in this rating as extra content. Even though the rating tells what should be expected, some videos may have excessive content that needs to be emphasized. This will allow the Creator to inform the viewers ahead of time.
* Graphic videos must be censored to some level and somewhat if it includes a person being injured. Exceptions are as follows, legal hunting of wild game or farming traditions, common sense must be a factor of choosing the level of the graphic viewing. We will not permit anything out of the legal standards.
* The percentage is to indicate the subtract percentage of visibility based on the type of content from 100% visibility rate
EXTRA
Tags: tags are tags easy to understand, use to group some details about a video that helps match with other videos with that same matching key detail
Copyright: the standard copyright protection for Creators who post videos/Audios on the app will choose between these two protection, helping to limit missed understanding of uses of original content.
All these must be filled out to upload for broadcast on this platform.


Using the grid
When you're working at extremely high zooms, it's important that you know where one pixel stops and another starts. Or perhaps you're working on a sprite sheet and want to delineate each frame. Pixen allows you to set the specific size of each grid unit.
The grid settings will only affect the current document. If you'd like new documents to start with the current settings, click the "Use These as Defaults" button.
To change your grid settings:
Use the View > Grid Settings menu item.
or
Use the Grid toolbar item.


Magic sketchpad (mrm8488 version)
Draw things with machines! Every time you start drawing a doodle, a machine learning algorithm tries to finish it and match the category you've selected. Try drawing multiple categories on the same page!
Built by @notwaldorf with magenta.js and modified by @mrm8488


{{console.title}}
{{console.environmentName}}
{{console.environmentName}}
Running in read only mode
If you need to make any modifications, please contact the Hermes administrators.


Before Change
index = coalesce(index) // Remove duplicates.
if weight is not None:
print(weight.data.min(), weight.data.max())
weight = torch.sigmoid(weight).unsqueeze(1)
norm = scatter_add(Variable(cluster), weight.squeeze(), dim=0)
norm = torch.gather(norm,0,Variable(cluster))
After Change
index = coalesce(index) // Remove duplicates.
if weight is not None:
weight = F.relu(weight).unsqueeze(1) + 0.0001 // avoid all zero
norm = scatter_add(Variable(cluster), weight.squeeze(), dim=0)
norm = torch.gather(norm,0,Variable(cluster))


Single Athlete Settings are active.
Enable Dated Athlete Settings for more reliable stats.
Dated Athlete Settings are active.
You can enable Single Athlete Settings by disabling Dated Athlete Settings.
Dated Athlete Settings
Gender
{{gender.display}}


|
home | news | discuss | issues | license LURE: superrange |
|
|---|---|
Supervised<EMAIL_ADDRESS>This code is a supervised discretizer. Numbers in a list are sorted, then broken according to where a dependent variable starts to change. This code works by first generating ranges using unsupervised discretization (using
ranges.lua). Adjacent |
require "show"
local the=require "config"
local NUM=require "num"
local SYM=require "sym"
local RANGE=require "range"
local LST= require "lists"
local STR=require "str"
local replace = STR.replace_char
|
pretty print |
local function labels(nums)
local out={}
for i =1,#nums do
out[#out+1] = {
most = nums[i],
label =i } end --replace(i,string.rep("_",#nums),
|
|
string.char(64+i))} end |
return out end
|
covenient short cuts |
local function same(_) return _ end
local function sd(_) return _.sd end
local function ent(_) return sym.ent(_) end
local function below(x,y) return x*the.tree.ish < y end
local function above(x,y) return x > y*the.tree.ish end
|
External interface
|
return function (things,x,y, nump, lessp)
y = y or LST.last -- klass is last arg
nump = nump==nil and true or nump
lessp= lessp==nil and true or lessp
local better= lessp and below or above
local what = nump and NUM or sym
local z = nump and sd or ent
local breaks,ranges = {},RANGE(things,x) -- breaks is the output
|
|
Tedious detail #1: |
local function data(j) return ranges[j]._all._all end
|
|
Tedious detail #2: We'll always be counting right and left from current pos. So, to save time, pre-compute and cache the left and right stats. |
local function memo(here,stop,_memo, b4,inc)
if stop > here then inc=1 else inc=-1 end
if here ~= stop then
b4= LST.copy( memo(here+inc, stop, _memo)) end
_memo[here] = what.updates(data(here), y, b4)
return _memo[here]
end
|
|
|
local function combine(lo,hi,all,bin,lvl)
local best = z(all)
local lmemo,rmemo = {},{}
memo(hi,lo, lmemo) -- summarize i+1 using i
memo(lo,hi, rmemo) -- summarize i using i+1
local cut, lbest, rbest
for j=lo,hi-1 do
local l = lmemo[j]
local r = rmemo[j+1]
local tmp= l.n/all.n*z(l) + r.n/all.n*z(r)
if better(tmp, best) then
cut = j
best = tmp
lbest = LST.copy(l)
rbest = LST.copy(r)
end
end
if cut then
bin = combine(lo, cut, lbest, bin, lvl+1) + 1
bin = combine(cut+1, hi, rbest, bin, lvl+1)
else -- no cut found, mark everything "lo" to "hi" as "bin"
breaks[bin] = breaks[bin] or -10^32
if ranges[hi].hi > breaks[bin] then
breaks[bin] = ranges[hi].hi
end
end
return bin end
|
|
Main program |
combine(1,#ranges,
memo(1,#ranges,{}),
1,0)
return labels(breaks) end
|
LegalLURE, Copyright (c) 2017, Tim Menzies All rights reserved, BSD 3-Clause License Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|


Your Project, {{$ctrl.project.name}}, has been created. Now we'll add imagery to your project.
Jump into the Scene Browser and use your existing imports and publicly available imagery in your project.
Import your own earth observation imagery from a drone, manned aerial vehicle or satellite source directly from your S3 Bucket or your hard drive.


catch Your Dream
It's become a Biggest Community Of INdia
Coming Soon...
Brigthest and expensive Creation Coming...


{% extends 'venues/layout.html' %} {% load static %} {% block body %}
I love you like Kanye loves Kanye. Don't be scared of the truth because we need to restart the human foundation.


THE LOW DOWN
Reviewed by Harvey Karten Shooting Gallery Director: Jamie Thraves Writer: Jamie Thraves Cast: Aidan Gillen, Kate Ashfield, Dean Lennox Kelly, Tobias Menzies, Rupert Procter, Samantha Power, Deanna Smiles, Maggie Lloyd Williams, Agnieszka Liggett
Tonight I had a choice of seeing either Morgan Freeman and the adorable Monica Potter in "Along Came a Spider" or taking in a small movie by an untested director, "The Low Down," and I chose the latter. "Why in the world would you do that?" a colleague about to head to "Spider" asked in some disbelief. "Well," I replied, "I never came face to face with a serial killer and (hard to believe in these parlous times) never even saw a guy with his gun drawn," (at least not since my childhood days of playing with a cap pistol). Now I'm not against escapist movies and see quite a few each year but tonight I was in the mood for a bit of naturalism, a Chekhovian experience if you will. By that I mean I wanted to take a gander at ordinary people living in ordinary relationships who were in some ways like me, and serial killers do not fit the bill--at least not yet.
"The Low Down" is dominated by people in their late twenties: I can relate to that because in my former life I was 28 too. The conversations of the people in debut director Jamie Thraves's movie (whose script he penned as well) are so real, so recognizable, that I felt at times ashamed to be snooping on them, sharing their intimate secrets and expressions of vulnerability. Their dialogue seemed improvised and, sure enough, according to the press notes, Thraves did encourage his performers to be creative, but there's nothing amateurish about the way they carry themselves throughout the 96 minute story. This is not surprising considering that the lead, Aidan Gillen, may be acting against type in the role of young Frank but he is also a major player with a more aggressive role in the UK Channel 4's "Queer as Folk."
"The Low Down" is a slice of Frank's life: his relationship with two guys with whom he works as a creator of props for magic shows and TV game shows, Mike (Dean Lennox Kelly) and John (Tobias Menzies). Principally, though, the tale turns on the way that his relationship with the cute Ruby (Kate Ashfield--a London stage actor who has interpreted roles at the Royal Court) gives him impetus to change his life. Why should he change his life? For one thing, at his age he should be working toward his real goal: to be an artist, rather than a talented artisan adept at creating trivial stage props. For another, though he finally moves out of digs that he ostensibly shares with another into a decent-size flat in a not- too-fashionable area of North London, he is in and out of relationships while his friends are beginning to settle down and contemplate commitments.
What stands out especially in Aiden Gillen's performance is the way he conveys his inner knowledge of his situation. He doesn't try to kid himself. He knows there's something wrong with the way he communicates with his friends and especially with Ruby. When he's with his new girl friend whom he met when she, as a real estate agent, escorted him around some flats, he's fine in the outdoors. Indoors, though, he's uneasy with her, at one point kicking a soccer ball around with her and at another tossing cigarettes and catching them in his mouth, at least once in each ten tries while his girl, trying to be in synch with him, does likewise.
Did I say that Frank's friends have grown up? Let me correct that. To me, as someone who could possibly be their granddad (though a very young one), they appear at times obnoxious considering that they are post university and pushing thirty. John is repeatedly belittling the job he is doing making those stage props, needling his partners to such an extent that they are considering turning him loose, while Mike is wont to do hackneyed impressions of the rich and famous and getting drunk at parties. The only really non-Chekhovian scene--one which is welcome at this point into the movie because so little outer action takes place that when something hits the fan you're ready to cheer--involves a violent scene between John and Frank who are quaffing brew in a Norfolk pub and an inebriated macho man who curses them out and challenges them to a skirmish.
The film is not for everyone. "Nothing happens," could be a quote in the newspaper ad if the marketers feel like kidding around, and I wouldn't want a steady diet of authenticity. After all when naturalism was introduced onto the stage in 1870, it died a, well, natural death. Who wants to see nothing but what you might eavesdrop on in the street on any day? But as long as movies like "Along Came a Spider" are around, we should welcome a rest break now and then, just as we look forward to a number of times out for ordinary talk in any movie designed to appeal principally to the raw emotions of the audience.
Not Rated. Running time: 96 minutes. (C) 2001 by Harvey Karten<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Welcome to the Mystery Page
And congratulations on finding us
Mysterious User
Number of visits: 6
Click here to login


No records
Sorry, but we don't know anything about such FAIR Data Point...
Timestamps
| Registered (first contact) |
|
| Modified (last contact) |
|
| Verified (last metadata retrieval) |
never |
|
Repository metadata
| Repository URI |
|
| Title |
|
| Version |
|
| Publisher |
|
|
|
|
Events
Last 10 events related to this entry:
| Type |
Created |
Finished |
|
|
|
N/A |


As a developer many times i need to expose my localhost application to the web for demo purposes or to test my web application api with a webhook which only post to a live url. Either you should have a hosting for it or if you don't have much money spent on hosting you can still make you localhost applicaiton live with an application ngrok
Ngrok is a multiplatform tunnelling, reverse proxy software that establishes secure tunnels from a public endpoint such as internet to a locally running network service while capturing all traffic for detailed inspection and replay.
In my case i am gonna show you how you can make your visual studio web application live with ngrok
First of all you need your application run in the localhost. I believe that you already have your application which is running the localhost. I am just showing you a basic application which is running on my localhost:3000 and supports a post request from user and we will make that live with ngrok so that we can post the data to live url generated with ngrok and get response from it.
So my localhost applicaiton is running
We need ngrok to be download first, so we will go to https://ngrok.com/download and download the latest version of the ngrok application.
once you downloaded the ngrok exe simple run it by double click on it. its a portable command running application which will launch immediately and you will see the command prompt like below
Now there will be simple command to make you localhost application live to web. which will like this
ngrok http 3000Note: 3000 here is my port number. In your case it could be different.
It is possible if you are using the ngrok for the first time it could prompt you for authrozie to use ngrok with api key. In that case you should create a new apikey by login into the ngrok and when you reach to your admin dashboard then redirect to Authentication -> Your Auth Token, in the right area you should see your authtoken in the textbox copy it and do the following command
ngrok authtoken YOUR AUTH TOKENand then again use the
ngrok http 3000Sometimes port are very different and big like in 5 digits (44533, 55677, 34343 etc). It might give you trouble. so for that you can use the following command to make your application live
ngrok http 3000 -host-header="localhost:3000"If the above query runs successfully you will see the terminal like below. You can copy any of the highlited link and visit into the web, it will treat as same as trated in localhost


Conversational Form examples
Dynamic questions/tag
Use event
USER_INPUT_UPDATE
to insert new tags/questions in the flow.


This document explains how to write a new package, how to test code, and how to contribute changes to the Go project. It assumes you have installed Go and Mercurial using the installation instructions.
Before embarking on a significant change to an existing package or the creation of a major new package, it's a good idea to send mail to the mailing list to let people know what you are thinking of doing. Doing so helps avoid duplication of effort and enables discussions about design before much code has been written.
The source code for the package with import path
x/y
is, by convention, kept in the
directory $GOROOT/src/pkg/x/y
.
It would be nice to have Go-specific tools that
inspect the source files to determine what to build and in
what order, but for now, Go uses GNU make
.
Thus, the first file to create in a new package directory is
usually the Makefile
.
The basic form is illustrated by src/pkg/container/vector/Makefile
:
include $(GOROOT)/src/Make.$(GOARCH) TARG=container/vector GOFILES=\ intvector.go\ stringvector.go\ vector.go\ include $(GOROOT)/src/Make.pkg
The first and last lines include
standard definitions and rules,
so that the body of the Makefile
need only specify two variables.
TARG
is the target install path for the package,
the string that clients will use to import it.
This string should be the same as the directory
in which the Makefile
appears, with the
$GOROOT/src/pkg/
removed.
GOFILES
is a list of source files to compile to
create the package. The trailing \
characters
allow the list to be split onto multiple lines
for easy sorting.
After creating a new package directory, add it to the list in
$GOROOT/src/pkg/Makefile
so that it
is included in the standard build. Then run:
cd $GOROOT/src/pkg ./deps.bash
to update the dependency file Make.deps
.
If you change the imports of an existing package,
you do not need to edit $GOROOT/src/pkg/Makefile
but you will still need to run deps.bash
as above.
The first statement in each of the source files listed in the Makefile
should be package name
, where name
is the package's default name for imports.
(All files in a package must use the same name
.)
Go's convention is that the package name is the last element of the
import path: the package imported as "crypto/rot13"
should be named rot13
.
The Go tools impose a restriction that package names are unique
across all packages linked into a single binary, but that restriction
will be lifted soon.
Go compiles all the source files in a package at once, so one file can refer to constants, variables, types, and functions in another file without special arrangement or declarations.
Writing clean, idiomatic Go code is beyond the scope of this document. Effective Go is an introduction to that topic.
Go has a lightweight test framework known as gotest
.
You write a test by creating a file with a name ending in _test.go
that contains functions named TestXXX
with signature func (t *testing.T)
.
The test framework runs each such function;
if the function calls a failure function such as t.Error
or t.Fail
, the test is considered to have failed.
The gotest command documentation
and the testing package documentation give more detail.
The *_test.go
files should not be listed in the Makefile
.
To run the test, run either make test
or gotest
(they are equivalent).
To run only the tests in a single test file, for instance one_test.go
,
run gotest one_test.go
.
Before sending code out for review, make sure everything still works and the dependencies are right:
cd $GOROOT/src ./all.bash
The final line printed by all.bash
should be of the form:
N known bugs; 0 unexpected bugs
The value of N varies over time, but the line must
say “0 unexpected bugs
” and must not
add “test output differs
.”
Once your new code is tested and working, it's time to get it reviewed and submitted.
Changes to Go must be reviewed before they are submitted, no matter who makes the change. (In exceptional cases, such as fixing a build, the review can follow shortly after submitting.) A Mercurial extension helps manage the code review process. The extension is included in the Go source tree but needs to be added to your Mercurial configuration.
Using Mercurial with the code review extension is not the same as using standard Mercurial.
The Go repository is maintained as a single line of reviewed changes;
we prefer to avoid the complexity of Mercurial's arbitrary change graph.
The code review extension helps here: its hg submit
command
automatically checks for and warns about the local repository
being out of date compared to the remote one.
The hg submit
command also verifies other
properties about the Go repository.
For example,
it checks that Go code being checked in is formatted in the standard style,
as defined by gofmt,
and it checks that the author of the code is properly recorded for
copyright purposes.
To help ensure changes are only created by hg submit
,
the code review extension disables the standard hg commit
command.
Mercurial power users: To allow Go contributors to take advantage of Mercurial's functionality for local revision control, it might be interesting to explore how the code review extension can be made to work alongside the Mercurial Queues extension.
Edit $GOROOT/.hg/hgrc
to add:
[extensions] codereview = YOUR_GO_ROOT/lib/codereview/codereview.py
Replace YOUR_GO_ROOT with the value of $GOROOT
.
The Mercurial configuration file format does not allow environment variable substitution.
The code review server uses a Google Account to authenticate. (If you can use the account to sign in at google.com, you can use it to sign in to the code review server.)
$ cd $GOROOT $ hg codereview-login Email (login for uploading to codereview.appspot.com<EMAIL_ADDRESS>Password for<EMAIL_ADDRESS>Saving authentication cookies to /Users/rsc/.codereview_upload_cookies_codereview.appspot.com
Edit your code review settings. Grab a nickname. Many people prefer to set the Context option to “Whole file” to see more context when reviewing changes.
Once you have chosen a nickname in the settings page, others
can use that nickname as a shorthand for naming reviewers and the CC list.
For example, rsc
is an alias for<EMAIL_ADDRESS>.
The entire checked-out tree is writable.
If you need to edit files, just edit them: Mercurial will figure out which ones changed.
You do need to inform Mercurial of added, removed, copied, or renamed files,
by running
hg add
,
hg rm
,
hg cp
,
or
hg mv
.
When you are ready to send a change out for review, run
$ hg change
from any directory in your Go repository.
Mercurial will open a change description file in your editor.
(It uses the editor named by the $EDITOR
environment variable, vi
by default.)
The file will look like:
# Change list. # Lines beginning with # are ignored. # Multi-line values should be indented. Reviewer: CC: Description: <enter description here> Files: src/pkg/math/sin.go src/pkg/math/tan.go src/pkg/regexp/regexp.go
The Reviewer
line lists the reviewers assigned
to this change, and the CC
line lists people to
notify about the change.
These can be code review nicknames or arbitrary email addresses.
Replace “<enter description here>
”
with a description of your change.
The first line of the change description is conventionally
a one-line summary of the change and is used as the
subject for code review mail; the rest of the
description elaborates.
The Files
section lists all the modified files
in your client.
It is best to keep unrelated changes in different change lists.
In this example, we can include just the changes to package math
by deleting the line mentioning regexp.go
.
If we did so, the template would now read:
# Change list. # Lines beginning with # are ignored. # Multi-line values should be indented. Reviewer: r, rsc CC<EMAIL_ADDRESS>Description: Sin, Cos, Tan: improved precision for very large arguments See Bimmler and Shaney, ``Extreme sinusoids,'' J. Math 3(14). Fixes issue 159. Files: src/pkg/math/sin.go src/pkg/math/tan.go
The special sentence “Fixes issue 159.” associates the change with issue 159 in the Go issue tracker. When this change is eventually submitted, the issue tracker will automatically mark the issue as fixed.
Save the file and exit the editor.
The code review server assigns your change an issue number and URL,
which hg change
will print, something like:
CL created: http://codereview.appspot.com/99999
If you need to re-edit the change description,
run hg change 99999
.
You can see a list of your pending changes by running hg pending
(hg p
for short).
While you were working, others might have submitted changes to the repository. To update your client, run
$ hg sync
(For Mercurial fans, hg sync
runs hg pull -u
but then also synchronizes the local change list state against the new data.)
If files you were editing have changed, Mercurial does its best to merge the remote changes into your local changes. It may leave some files to merge by hand.
TODO(rsc): add example of merge
To send out a change for review, run hg mail
using the change list number
assigned during hg change
:
$ hg mail 99999
You can add to the Reviewer:
and CC:
lines
using the -r
or --cc
options.
The above example could have left the Reviewer
and CC
lines blank and then run:
$ hg mail -r r,rsc --cc<EMAIL_ADDRESS>99999
to achieve the same effect.
Note that -r
and --cc
cannot be spelled --r
or -cc
.
Running hg mail
will send an email to you and the reviewers
asking them to visit the issue's URL and make coments on the change.
When done, the reviewer clicks “Publish and Mail comments”
to send comments back.
You will probably revise your code in response to the reviewer comments. When you have revised the code and are ready for another round of review, run
$ hg upload 99999
to upload the latest copy.
You might also visit the code review web page and reply to the comments,
letting the reviewer know that you've addressed them or explain why you
haven't. When you're done replying, click “Publish and Mail comments”
to send the line-by-line replies and any other comments.
A common acronym in such mails is PTAL
: please take another look.
The reviewer can comment on the new copy, and the process repeats.
The reviewer approves the change by replying with a mail that says
LGTM
: looks good to me.
Once the code has been LGTM
'ed, it is time to submit
it to the Mercurial repository.
If you are a committer, you can run:
$ hg submit 99999
This checks the change into the repository. The change description will include a link to the code review, and the code review will be updated with a link to the change in the repository.
If your local copy of the repository is out of date,
hg submit
will refuse the change:
$ hg submit 12345678 local repository out of date; must sync before submit
If you are not a committer, you cannot submit the change directly.
Instead, a committer, usually the reviewer who said LGTM
,
will run:
$ hg clpatch 99999 $ hg submit 99999
The clpatch
command imports your change 99999 into
the committer's local Mercurial client, at which point the committer
can check or test the code more.
(Anyone can run clpatch
to try a change that
has been uploaded to the code review server.)
The submit
command submits the code. You will be listed as the
author, but the change message will also indicate who the committer was.
The standard copyright header for files in the Go tree is:
// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file.
Code you contribute should have this header.
You need to be listed in the
CONTRIBUTORS
file,
which defines who the Go contributors—the people—are;
and the copyright holder for the code you submit (either you or the
organization you work for) needs to be listed in the
AUTHORS
file, which defines
who “The Go Authors”—the copyright holders—are.
When sending your first change list, you should prepare
and send a separate change list adding yourself to
CONTRIBUTORS
and adding
the copyright holder for your code to AUTHORS
if not already listed.
If you are the copyright holder, you will need to agree to
the individual contributor license agreement,
which can be completed online;
if your organization is the copyright holder, the organization
will need to agree to the corporate contributor license agreement.
If the copyright holder for your code has already completed the
agreement in connection with another Google open source project,
it does not need to be completed again.
One of the Go developers at Google will approve and submit
this change after checking the list of people/organizations
that have completed the agreement.


| Opcode/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
|---|---|---|---|---|
| EVEX.128.66.0F38.W0 2C /r VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst | A | V/V | AVX512VL AVX512F | Scale the packed single-precision floating-point values in xmm2 using values from xmm3/m128/m32bcst. Under writemask k1. |
| EVEX.256.66.0F38.W0 2C /r VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst | A | V/V | AVX512VL AVX512F | Scale the packed single-precision values in ymm2 using floating point values from ymm3/m256/m32bcst. Under writemask k1. |
| EVEX.512.66.0F38.W0 2C /r VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} | A | V/V | AVX512F | Scale the packed single-precision floating-point values in zmm2 using floating-point values from zmm3/m512/m32bcst. Under writemask k1. |
| Op/En | Tuple Type | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| A | Full | ModRM:reg (w) | EVEX.vvvv (r) | ModRM:r/m (r) | NA |
Performs a floating-point scale of the packed single-precision floating-point values in the first source operand by multiplying it by 2 power of the float32 values in second source operand.
The equation of this operation is given by:
zmm1 := zmm2*2floor(zmm3).
Floor(zmm3) means maximum integer value ≤ zmm3.
If the result cannot be represented in single precision, then the proper overflow response (for positive scaling operand), or the proper underflow response (for negative scaling operand) is issued. The overflow and underflow responses are dependent on the rounding mode (for IEEE-compliant rounding), as well as on other settings in MXCSR (exception mask bits, FTZ bit), and on the SAE bit.
EVEX.512 encoded version: The first source operand is a ZMM register. The second source operand is a ZMM register, a 512-bit memory location or a 512-bit vector broadcasted from a 32-bit memory location. The destination operand is a ZMM register conditionally updated with writemask k1.
EVEX.256 encoded version: The first source operand is a YMM register. The second source operand is a YMM register, a 256-bit memory location, or a 256-bit vector broadcasted from a 32-bit memory location. The destination operand is a YMM register, conditionally updated using writemask k1.
EVEX.128 encoded version: The first source operand is an XMM register. The second source operand is a XMM register, a 128-bit memory location, or a 128-bit vector broadcasted from a 32-bit memory location. The destination operand is a XMM register, conditionally updated using writemask k1.
Handling of special-case input values are listed in Table 5-30 and Table 5-32.
| Special Case | Returned value | Faults |
|---|---|---|
| |result| < 2-149 | ±0 or ±Min-Denormal (Src1 sign) | Underflow |
| |result| ≥ 2128 | ±INF (Src1 sign) or ±Max-normal (Src1 sign) | Overflow |
SCALE(SRC1, SRC2) { ; Check for denormal operands TMP_SRC2 ← SRC2 TMP_SRC1 ← SRC1 IF (SRC2 is denormal AND MXCSR.DAZ) THEN TMP_SRC2=0 IF (SRC1 is denormal AND MXCSR.DAZ) THEN TMP_SRC1=0 /* SRC2 is a 32 bits floating-point value */ DEST[31:0]←TMP_SRC1[31:0] * POW(2, Floor(TMP_SRC2[31:0])) }
(KL, VL) = (4, 128), (8, 256), (16, 512) IF (VL = 512) AND (EVEX.b = 1) AND (SRC2 *is register*) THEN SET_RM(EVEX.RC); ELSE SET_RM(MXCSR.RM); FI; FOR j←0 TO KL-1 i←j * 32 IF k1[j] OR *no writemask* THEN IF (EVEX.b = 1) AND (SRC2 *is memory*) THEN DEST[i+31:i]←SCALE(SRC1[i+31:i], SRC2[31:0]); ELSE DEST[i+31:i]←SCALE(SRC1[i+31:i], SRC2[i+31:i]); FI; ELSE IF *merging-masking* ; merging-masking THEN *DEST[i+31:i] remains unchanged* ELSE ; zeroing-masking DEST[i+31:i] ← 0 FI FI; ENDFOR DEST[MAXVL-1:VL] ← 0;
VSCALEFPS __m512 _mm512_scalef_round_ps(__m512 a, __m512 b, int rounding);
VSCALEFPS __m512 _mm512_mask_scalef_round_ps(__m512 s, __mmask16 k, __m512 a, __m512 b, int rounding);
VSCALEFPS __m512 _mm512_maskz_scalef_round_ps(__mmask16 k, __m512 a, __m512 b, int rounding);
VSCALEFPS __m512 _mm512_scalef_ps(__m512 a, __m512 b);
VSCALEFPS __m512 _mm512_mask_scalef_ps(__m512 s, __mmask16 k, __m512 a, __m512 b);
VSCALEFPS __m512 _mm512_maskz_scalef_ps(__mmask16 k, __m512 a, __m512 b);
VSCALEFPS __m256 _mm256_scalef_ps(__m256 a, __m256 b);
VSCALEFPS __m256 _mm256_mask_scalef_ps(__m256 s, __mmask8 k, __m256 a, __m256 b);
VSCALEFPS __m256 _mm256_maskz_scalef_ps(__mmask8 k, __m256 a, __m256 b);
VSCALEFPS __m128 _mm_scalef_ps(__m128 a, __m128 b);
VSCALEFPS __m128 _mm_mask_scalef_ps(__m128 s, __mmask8 k, __m128 a, __m128 b);
VSCALEFPS __m128 _mm_maskz_scalef_ps(__mmask8 k, __m128 a, __m128 b);
Overflow, Underflow, Invalid, Precision, Denormal (for Src1).
Denormal is not reported for Src2.
See Exceptions Type E2.


Welcome! 👋
Before we get started:
- Make sure you have a local Git installation (https://git-scm.com/)
- Pull up your command line tool of choice
- Log into GitHub - or make an account if you don't have one yet
- Join us on Slack - ask a volunteer how
About Me - The Past 👶
- Began coding when I was 11
- Dropped out of college, (re)taught myself how to code, and began freelancing
- Moved to Dallas in 2015 and began to work full time in software dev, primarily frontend.
About Me - The Present 🎁
- Engineering Manager at Creative Market
- Director of Women Who Code DFW
- Full-time student
- During the day, I spend most of my time doing Manager Stuff™
- Several side projects and some freelance work that keeps my hand in code.
About Me - The Future 🚀
- UI/UX Engineering Manager of Creative Market
- Design Systems and User Testing
- Mentor others, speak at more events, and write more
- FINALLY FINISH MY PORTFOLIO??
What I'm Passionate About
- Creating great User Experiences and bringing beautiful design to life using code
- Creating opportunity for others, and helping people reach their potential
- Building teams and environments that make people excited to go to work everyday
- Learning and growing every damn day
I Hate Git
General Advice
- Save and push to your remote branch often
- K.I.S.S. (And consult your rubber duck often4)
- Google stuff if you need to, and ask for help
My goal for this workshop...
What's the difference between Git and GitHub?
Git is a version control system.
GitHub is a hosting service for Git repositories.
Version control systems are a category of software tools that help a software team manage changes to source code over time.1
Version Control is helpful for...
- Collaboration
- Source of truth and record
- Maintaining multiple versions of the same software
Almost all software companies use a form of version control. And the ones who don’t, should!
There are a several different version control systems, but Git is the most popular one.2
There are a lot of ways to interact with a version control system, but a universal method that you'll encounter at
almost any job is using the command line.
Very simply, a repository is a bucket where your source code lives.
Git repositories contain all of your source code, plus the history of your source code.
- A branch is essentially an independent line of development.
-
You can take advantage of branching when working on new features or bug fixes because it
isolates your work from that of other team members.5
Let's learn some commands!
Creates a new local repository
Creates a copy of a remote repository on your local machine.
Tells you which files have changed, and files you still need to add to staging or commit.
Changes you from one branch to another
Pulls changes from the remote repository into your local repository
git add stages changes to be committed
staging is basically a holding area where you put files that you want to commit.
git add myFileName.js
git add .

Commit messages are used to communicate...
To ask questions
To celebrate project milestones
To give a colleague constructive feedback
A good commit message is descriptive and well-formatted.3
Sometimes teams and companies have guidelines on how to format commit messages.
This command “Pushes” your local repository changes to your remote repository.


--- title: masthead title_abbrev: masthead layout: default ---
is a Pittsburgher and fiction writer who makes occasional forays into the worlds of poetry and nonfiction. She has no visual arts capabilities whatsoever. Ashley’s work appears in many journals, including Sycamore Review, Forge Literary Magazine, The Los Angeles Review, and Summerset Review. She is Assistant Professor of Creative Writing at Rocky Mountain College in Billings, MT. Find her online at www.ashleykunsa.com or on Twitter @ashleykunsa.
writes fiction and spends more time in pool halls than he probably should. Mike once wrote a poem about his cat, Coconut; even at the age of eight he had a flair for alliteration. His first novel, Once in a Blue Year, is available on Amazon. His second novel has been “almost done” for two years; the title changes monthly. Find him online at http://www.durkota.net or on Twitter @durk13.
writes fiction and lots of code. He once penned a poem about an eagle soaring high above the world’s injustices. He was 16, so you know it was as awesome as it sounds. Brad’s fiction has been published in Yellow Chair Review and Pittsburgh’s City Paper, and he is at work on a novel about a strip club in small-town West Virginia. Visit his website at www.bradcoffield.com or connect with him via Twitter @bradcoffield.


Did you know?
Thailand Water environment-and-natural-resources
Water Resources
My first paragraph.
thailand open source


John Legend is voted Sexiest Man Alive 2019 and he's 'perplexed'
by Entertainment DeskSinger John Legend has an Emmy, Grammy, Oscar and Tony, and now ‘one of the nicest guys in Hollywood’ has been crowned this year’s Sexiest Man Alive by People.
The All of Me singer has another feather to add to his cap with his new title. After taking home his first Grammy in 2006 with his debut album Get Lifted, the 40-year-old began a steady ascension to super stardom.
When Legend weighed in on how he felt about his Sexiest Man Alive status after 2018’s winner Idris Elba, he revealed he was perplexed and made fun of the comparison.
“1995 John would be very perplexed to be following 2018 @IdrisElba as #sexiestman alive,” he wrote on Twitter after the announcement. “Hell, 2019 John is about as equally perplexed but thank you People for finding me sexy. I’ll take it.”
The humble tweet comes as no surprise, considering Legend is unabashedly in love with his wife Chrissy Teigen and a doting father to their kids – all while remaining one of Hollywood’s biggest stars.
Jokes aside, the singer also had a mix of emotions about the news. “I was excited, but I was a little scared at the same time because it’s a lot of pressure,” the entertainer told the magazine. “Everyone’s going to be picking me apart to see if I’m sexy enough to hold this title. I’m also following Idris Elba, which is not fair and is not nice to me!”
When asked who his first and biggest fan is, Legend said it will always be his mother Phyllis. “Whenever we had opportunities to sing in church or in school, my mom would suggest that I do it. She always encouraged me.”
Legend is the publication’s 34th Sexiest Man Alive, joining a long list of Hollywood’s hottest, starting with a then-29-year-old Mel Gibson in 1985.


{# Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. #} {% extends "airflow/dag.html" %} {% block page_title %}{{ dag.dag_id }} - Tree - Airflow{% endblock %} {% block head_css %} {{ super() }} {% endblock %} {% block content %} {{ super() }}


SWI-Prolog binding to libarchive
Abstract
The library https://github.com/libarchive/libarchivelibarchive
provides a portable way to access archive files as well as encoded
(typically compressed) data. This package is a Prolog wrapper around
this library. The motivation to introduce this library is twofold. In
the first place, it provides a minimal platform independent API to
access archives. In the second place, it allows accessing archives
through Prolog streams, which often eliminates the need for temporary
files and all related consequences for performance, security and
platform dependency.
Archives play two roles: they combine multiple documents into a
single one and they typically provide compression and sometimes
encryption or other services. Bundling multiple resources into a single
archive may greatly simplify distribution and guarantee that the
individual resources are consistent. SWI-Prolog provides archiving using
its (rather arcane) saved-state format. See resource/3
and open_resource/3.
It also provides compression by means of library(zlib).
External archives may be accessed through the process interface
provided by process_create/3,
but this has disadvantages. The one that motivated this library was that
using external processes provide no decent platform independent access
to archives. Most likely zip files come closest to platform independent
access, but there are many different programs for accessing zip files
that provide slightly different sets of options and the existence of any
of these programs cannot be guaranteed without distributing our own
bundled version. Similar arguments hold for Unix tar archives, where
just about any Unix-derives system has a tar program but except for very
basic commands, the command line options are not compatible and tar is
not part of Windows. The only format granted on Windows is .cab, but a
program to create them is not part of Windows and the .cab format is
rare outside the Windows context.
Discarding availability of archive programs, each archive program
comes with its own set of command line options and its own features and
limitations. Fortunately,
https://github.com/libarchive/libarchivelibarchive provides a consistent
interface to a wealth of compression and archiving formats. The library library(archive)
wraps this library, providing access to archives using Prolog streams
both for the archive as a whole and the archive entries. E.g., archives
may be read from Prolog streams and each member in turn may be processed
using Prolog streams without materialising data using temporary files.
- See also
-
http://code.google.com/p/libarchive/
This library uses libarchive to access a variety of archive
formats. The following example lists the entries in an archive:
list_archive(File) :-
archive_open(File, Archive, []),
repeat,
( archive_next_header(Archive, Path)
-> format('~w~n', [Path]),
fail
; !,
archive_close(Archive)
).
- [det]archive_open(+Data,
+Mode, -Archive, +Options)
-
Open the archive in Data and unify Archive with a
handle to the opened archive. Data is either a file or a
stream that contains a valid archive. Details are controlled by Options.
Typically, the option
close_parent(true)
is used to close
stream if the archive is closed using archive_close/1.
For other options, the defaults are typically fine. The option format(raw)
must be used to process compressed streams that do not contain explicit
entries (e.g., gzip'ed data) unambibuously. The raw
format
creates a pseudo archive holding a single member named data
.
- close_parent(+Boolean)
-
If this option is
true
(default false
), Stream
is closed if archive_close/1
is called on Archive.
- compression(+Compression)
-
Synomym for
filter(Compression)
. Deprecated.
- filter(+Filter)
-
Support the indicated filter. This option may be used multiple times to
support multiple filters. In read mode, If no filter options are
provided,
all
is assumed. In write mode, none is assumed.
Supported values are all
, bzip2
, compress
, gzip
,
grzip
, lrzip
, lzip
, lzma
, lzop
, none
, rpm
, uu
and xz
. The value all
is default for read, none
for write.
- format(+Format)
-
Support the indicated format. This option may be used multiple times to
support multiple formats in read mode. In write mode, you must supply a
single format. If no format options are provided,
all
is
assumed for read mode. Note that
all
does not include raw
. To open both
archive and non-archive files, both format(all)
and
format(raw)
must be specified. Supported values are: all
,
7zip
, ar
, cab
, cpio
, empty
, gnutar
, iso9660
,
lha
, mtree
, rar
, raw
, tar
, xar
and zip
. The value all
is default for read.
Note that the actually supported compression types and formats may
vary depending on the version and installation options of the underlying
libarchive library. This predicate raises a domain error if the
(explicitly) requested format is not supported.
- Errors
-
-
domain_error(filter, Filter)
if the requested filter is
not supported.
- domain_error(format, Format)
if the requested format type
is not supported.
- [det]archive_close(+Archive)
-
Close the archive. If
close_parent(true)
is specified, the
underlying stream is closed too. If there is an entry opened with archive_open_entry/2,
actually closing the archive is delayed until the stream associated with
the entry is closed. This can be used to open a stream to an archive
entry without having to worry about closing the archive:
archive_open_named(ArchiveFile, EntryName, Stream) :-
archive_open(ArchiveFile, Handle, []),
archive_next_header(Handle, Name),
archive_open_entry(Handle, Stream),
archive_close(Archive).
- [nondet]archive_property(+Handle,
?Property)
-
True when Property is a property of the archive Handle.
Defined properties are:
- filters(List)
-
True when the indicated filters are applied before reaching the archive
format.
- [semidet]archive_next_header(+Handle,
-Name)
-
Forward to the next entry of the archive for which Name
unifies with the pathname of the entry. Fails silently if the name of
the archive is reached before success. Name is typically
specified if a single entry must be accessed and unbound otherwise. The
following example opens a Prolog stream to a given archive entry. Note
that Stream must be closed using
close/1 and the archive must be closed
using archive_close/1 after
the data has been used. See also setup_call_cleanup/3.
open_archive_entry(ArchiveFile, Entry, Stream) :-
open(ArchiveFile, read, In, [type(binary)]),
archive_open(In, Archive, [close_parent(true)]),
archive_next_header(Archive, Entry),
archive_open_entry(Archive, Stream).
- Errors
-
permission_error(next_header, archive, Handle)
if a
previously opened entry is not closed.
- [det]archive_open_entry(+Archive,
-Stream)
-
Open the current entry as a stream. Stream must be closed. If
the stream is not closed before the next call to
archive_next_header/2,
a permission error is raised.
- archive_set_header_property(+Archive,
+Property)
-
Set Property of the current header. Write-mode only. Defined
properties are:
- filetype(-Type)
-
Type is one of
file
, link
, socket
, character_device
,
block_device
, directory
or fifo
.
It appears that this library can also return other values. These are
returned as an integer.
- mtime(-Time)
-
True when entry was last modified at time.
- size(-Bytes)
-
True when entry is Bytes long.
- link_target(-Target)
-
Target for a link. Currently only supported for symbolic
links.
- archive_header_property(+Archive,
?Property)
-
True when Property is a property of the current header.
Defined properties are:
- filetype(-Type)
-
Type is one of
file
, link
, socket
, character_device
,
block_device
, directory
or fifo
.
It appears that this library can also return other values. These are
returned as an integer.
- mtime(-Time)
-
True when entry was last modified at time.
- size(-Bytes)
-
True when entry is Bytes long.
- link_target(-Target)
-
Target for a link. Currently only supported for symbolic
links.
- format(-Format)
-
Provides the name of the archive format applicable to the current entry.
The returned value is the lowercase version of the output of
archive_format_name()
.
- permissions(-Integer)
-
True when entry has the indicated permission mask.
- archive_extract(+ArchiveFile,
+Dir, +Options)
-
Extract files from the given archive into Dir. Supported
options:
- remove_prefix(+Prefix)
-
Strip Prefix from all entries before extracting
- exclude(+ListOfPatterns)
-
Ignore members that match one of the given patterns. Patterns are handed
to wildcard_match/2.
- Errors
-
-
existence_error(directory, Dir)
if Dir does
not exist or is not a directory.
- domain_error(path_prefix(Prefix), Path)
if a path in the
archive does not start with Prefix
- To be done
-
Add options
- [det]archive_entries(+Archive,
-Paths)
-
True when Paths is a list of pathnames appearing in Archive.
- [nondet]archive_data_stream(+Archive,
-DataStream, +Options)
-
True when DataStream is a stream to a data object inside
Archive. This predicate transparently unpacks data inside
possibly nested archives, e.g., a tar file inside a zip
file. It applies the appropriate decompression filters and thus ensures
that Prolog reads the plain data from DataStream.
DataStream must be closed after the content has been
processed. Backtracking opens the next member of the (nested) archive.
This predicate processes the following options:
- meta_data(-Data:list(dict))
-
If provided, Data is unified with a list of filters applied
to the (nested) archive to open the current DataStream. The
first element describes the outermost archive. Each Data dict
contains the header properties (archive_header_property/2)
as well as the keys:
- filters(Filters:list(atom))
-
Filter list as obtained from archive_property/2
- name(Atom)
-
Name of the entry.
Non-archive files are handled as pseudo-archives that hold a single
stream. This is implemented by using archive_open/3
with the options [format(all),format(raw)]
.
- [det]archive_create(+OutputFile,
+InputFiles, +Options)
-
Convenience predicate to create an archive in OutputFile with
data from a list of InputFiles and the given Options.
Besides options supported by archive_open/4,
the following options are supported:
- directory(+Directory)
-
Changes the directory before adding input files. If this is specified,
paths of input files must be relative to
Directory and archived files will not have Directory
as leading path. This is to simulate
-C
option of the tar
program.
- format(+Format)
-
Write mode supports the following formats: `7zip
,
cpio,
gnutar,
iso9660,
xar and
zip`.
Note that a particular installation may support only a subset of these,
depending on the configuration of libarchive
.
The current version is merely a proof-of-concept. It lacks writing
archives and does not support many of the options of the underlying
library. The main motivation for starting this library was to achieve
portability of the upcomming SWI-Prolog package distribution system.
Other functionality will be added on `as needed' basis.
- ?
- archive_close/1
- archive_create/3
- archive_data_stream/3
- archive_entries/2
- archive_extract/3
- archive_header_property/2
- archive_next_header/2
- archive_open/4
- archive_open_entry/2
- archive_property/2
- archive_set_header_property/2
- open_resource/3
-
1
- process_create/3
-
1
- resource/3
-
1


VCF-Miner
Browser not supported
Internet Explorer is not supported. Please use one of the following alternatives:
Chrome
Firefox


Slip Box System Parts List
Table of Contents
The Four Parts
A Capture System
This should be paper-based, or at least something that's always there and quick to use.
- a notebook
- index cards
- loose paper
- napkins…
A Reference System
This is where you put information about your sources. For books and papers Zotero is handy, although once again, the fact that I have to fire up this GUI-based program adds a little bit of overhead. The original system was just another box so I'm going to try something like that. Maybe a sub-folder…
The Slip Box
The original system was a wooden box with A6 paper. I'm using a static site with plain text (org-mode).
Something To Produce a Final Product
The system is aimed at writers, but I'm a computer programmer, and I think it might work with other types of output (like drawing) so it's really just having a way to produce something from your project.
Related Posts
Reference
- HTTSN - How To Take Smart Notes


Are you...
Sick
Lonely
Stressed
Struggling with your Sexuality
Struggling with School
Homesick
Not Eating Well
Drinking too Much
Anonymous Venting
EMERGENCY
I want to help!


REGEXP_TABLE
Section: File Formats (5)Index Return to Main Contents
NAME
regexp_table - format of Postfix regular expression tablesSYNOPSIS
postmap -q "string" regexp:/etc/postfix/filename postmap -q - regexp:/etc/postfix/filename <inputfile
DESCRIPTION
The Postfix mail system uses optional tables for address rewriting, mail routing, or access control. These tables are usually in dbm or db format.Alternatively, lookup tables can be specified in POSIX regular expression form. In this case, each input is compared against a list of patterns. When a match is found, the corresponding result is returned and the search is terminated.
To find out what types of lookup tables your Postfix system supports use the "postconf -m" command.
To test lookup tables, use the "postmap -q" command as described in the SYNOPSIS above.
COMPATIBILITY
With Postfix version 2.2 and earlier specify "postmap -fq" to query a table that contains case sensitive patterns. Patterns are case insensitive by default.
TABLE FORMAT
The general form of a Postfix regular expression table is:
- /pattern/flags result
- When pattern matches the input string, use the corresponding result value.
- !/pattern/flags result
- When pattern does not match the input string, use the corresponding result value.
- if /pattern/flags
- endif
-
Match the input string against the patterns between if
and endif, if and only if that same input string also
matches pattern. The if..endif can nest.
Note: do not prepend whitespace to patterns inside if..endif.
This feature is available in Postfix 2.1 and later.
- if !/pattern/flags
- endif
-
Match the input string against the patterns between if
and endif, if and only if that same input string does
not match pattern. The if..endif can nest.
Note: do not prepend whitespace to patterns inside if..endif.
This feature is available in Postfix 2.1 and later.
- blank lines and comments
- Empty lines and whitespace-only lines are ignored, as are lines whose first non-whitespace character is a `#'.
- multi-line text
- A logical line starts with non-whitespace text. A line that starts with whitespace continues a logical line.
Each pattern is a POSIX regular expression enclosed by a pair of delimiters. The regular expression syntax is documented in re_format(7) with 4.4BSD, in regex(5) with Solaris, and in regex(7) with Linux. Other systems may use other document names.
The expression delimiter can be any character, except whitespace or characters that have special meaning (traditionally the forward slash is used). The regular expression can contain whitespace.
By default, matching is case-insensitive, and newlines are not treated as special characters. The behavior is controlled by flags, which are toggled by appending one or more of the following characters after the pattern:
- i (default: on)
- Toggles the case sensitivity flag. By default, matching is case insensitive.
- m (default: off)
- Toggle the multi-line mode flag. When this flag is on, the ^ and $ metacharacters match immediately after and immediately before a newline character, respectively, in addition to matching at the start and end of the input string.
- x (default: on)
- Toggles the extended expression syntax flag. By default, support for extended expression syntax is enabled.
TABLE SEARCH ORDER
Patterns are applied in the order as specified in the table, until a pattern is found that matches the input string.
Each pattern is applied to the entire input string. Depending on the application, that string is an entire client hostname, an entire client IP address, or an entire mail address. Thus, no parent domain or parent network search is done, and user@domain mail addresses are not broken up into their user and domain constituent parts, nor is user+foo broken up into user and foo.
TEXT SUBSTITUTION
Substitution of substrings from the matched expression into the result string is possible using $1, $2, etc.; specify $$ to produce a $ character as output. The macros in the result string may need to be written as ${n} or $(n) if they aren't followed by whitespace.
Note: since negated patterns (those preceded by !) return a result when the expression does not match, substitutions are not available for negated patterns.
EXAMPLE SMTPD ACCESS MAP
# Disallow sender-specified routing. This is a must if you relay mail # for other domains. /[%!@].*[%!@]/ 550 Sender-specified routing rejected # Postmaster is OK, that way they can talk to us about how to fix # their problem. /^postmaster@/ OK # Protect your outgoing majordomo exploders if !/^owner-/ /^(.*)-outgoing@(.*)$/ 550 Use ${1}@${2} instead endif
EXAMPLE HEADER FILTER MAP
# These were once common in junk mail. /^Subject: make money fast/ REJECT /^To<EMAIL_ADDRESS>REJECT
EXAMPLE BODY FILTER MAP
# First skip over base 64 encoded text to save CPU cycles. ~^[[:alnum:]+/]{60,}$~ OK # Put your own body patterns here.
SEE ALSO
postmap(1), Postfix lookup table manager pcre_table(5), format of PCRE tables cidr_table(5), format of CIDR tables
README FILES
Use "postconf readme_directory" or "postconf html_directory" to locate this information.
DATABASE_README, Postfix lookup table overview
AUTHOR(S)
The regexp table lookup code was originally written by: LaMont Jones<EMAIL_ADDRESS>That code was based on the PCRE dictionary contributed by: Andrew McNamara<EMAIL_ADDRESS>connect.com.au Pty. Ltd. Level 3, 213 Miller St North Sydney, NSW, Australia Adopted and adapted by: Wietse Venema IBM T.J. Watson Research P.O. Box 704 Yorktown Heights, NY 10598, USA
Index
- NAME
- SYNOPSIS
- DESCRIPTION
- COMPATIBILITY
- TABLE FORMAT
- TABLE SEARCH ORDER
- TEXT SUBSTITUTION
- EXAMPLE SMTPD ACCESS MAP
- EXAMPLE HEADER FILTER MAP
- EXAMPLE BODY FILTER MAP
- SEE ALSO
- README FILES
- AUTHOR(S)
This document was created by man2html, using the manual pages.
Time: 05:34:00 GMT, December 24, 2015


Extending Cotk: More Data, More Metrics!¶
We provide easy APIs for extend cotk
to custom datasets and tasks.
Add A New Dataset¶
For Local Use¶
Now you have a new dataset and want to load it with cotk
and
the task is similar with the existed tasks, like dataloader.LanguageGeneration
,
dataloader.SingleTurnDialog
or dataloader.MultiTurnDialog
.
The simplest way is to just adapt the format of your dataset.
For example, if you want to adapt your data to dataloader.LanguageGeneration
,
you just have to generate 3 text files named train.txt
,
dev.txt
, test.txt
.
Each file contains several lines and each line is a sentence.
The structure of your directory should be like:
mydata
├── train.txt
├── dev.txt
└── test.txt
Then you can load your data using dataloader.LanguageGeneration
with a local path.
dataloader = LanguageGeneration("./path/to/mydata", min_frequent_vocab_times=min_frequent_vocab_times,
max_sent_length=max_sent_length, min_rare_vocab_times=min_rare_vocab_times,
tokenizer=tokenizer, convert_to_lower_letter=convert_to_lower_letter)
Note
If you want to write your own dataloader
with a complex data format,
see Add A New Task.
Download Dataset¶
If you want to publish your dataset and make it possible to download them automatically. You can zip your data and upload to an server. The url path should be accessible for every one.
Using dataloader.LanguageGeneration
with a url path is adequate for
the requirements.
dataloader = MSCOCO("http://url/to/new_data.zip")
Note
The zip file is downloaded then processed by
file_utils.resource_processor.DefaultResourceProcessor
.
For more about ResourceProcessor
, refer to this.
Add A Resource¶
This time, you have to change some codes in cotk
.
First you have to understand the usage of resources at
here. Then see the json file under
/cotk/resource_config/
, you will find each predefined resource
corresponds to a json file, like
{
"name": "MSCOCO_small",
"type": "MSCOCO",
"hashtag": "68f6b8d764bff6f5440a63f87aeea97049a1d2e89942a7e524b7dabd475ffd79",
"link": {
"default":"https://cotk-data.s3-ap-northeast-1.amazonaws.com/mscoco_small.zip",
"amazon": "https://cotk-data.s3-ap-northeast-1.amazonaws.com/mscoco_small.zip"
}
}
There are some places you have to pay attention to:
type
is the prefix of itsResourceProcessor
.
link.default
is necessary when no source is specified.
hashtag
is required for checksum.
We use the following codes to hash the zip file.
def _get_file_sha256(file_path):
'''Get sha256 of given file'''
hash_sha256 = hashlib.sha256()
with open(file_path, "rb") as fin:
for chunk in iter(lambda: fin.read(4096), b""):
hash_sha256.update(chunk)
return hash_sha256.hexdigest()
After accomplishment the config file, you can use the following code to load the data.
dataloader = MSCOCO("resources://new_name")
We highly recommend that the developers make a Pull Request and add more datasets for cotk
.
Add A New Task¶
Sometimes you want to deal with a totally different task
from the predefined ones.
In that case, you have to implement a subclass of LanguageProcessing
,
and pass the parameters file_id
and fields
when invoking LanguageProcessing.__init__()
.
For more details about file_id
, refer this.
For more details about fields
, refer this.
Note
In the method __init__
of your own dataloader class, LanguageProcessing.set_default_field()
must be
called. If self.default_field_set_name
and self.default_field_name
are not set, some methods and properties
(such as LanguageProcessing.tokenize()
, LanguageProcessing.all_vocab_size
, etc.) aren’t available.
For example, you can implement a new dataloader for sentence classification.
from collections import OrderedDict
from cotk.dataloader import LanguageProcessing
from cotk.dataloader.context import FieldContext, VocabContext
class SentenceClassification(LanguageProcessing):
def __init__(self, file_id: str,
tokenizer=None,
max_sent_length=None,
convert_to_lower_letter=None,
min_frequent_vocab_times=None,
min_rare_vocab_times=None):
fields = OrderedDict([('sent', 'SentenceDefault'), ('label', 'DenseLabel')])
with FieldContext.set_parameters(tokenizer=tokenizer,
max_sent_length=max_sent_length,
convert_to_lower_letter=convert_to_lower_letter):
with VocabContext.set_parameters(min_rare_vocab_times=min_rare_vocab_times,
min_frequent_vocab_times=min_frequent_vocab_times):
super().__init__(file_id, fields)
self.set_default_field('train', 'sent')
Assume that there is a directory named mydata
, which contains 3 text files (train.txt
, dev.txt
and test.txt
) in the same format.
For example, the content of test.txt
is as follows. Each sentence is followed by an integer (the label), just as fields
specifies.
effective but too-tepid biopic.
2
if you sometimes like to go to the movies to have fun, wasabi is a good place to start.
3
emerges as something rare, an issue movie that's so honest and keenly observed that it doesn't feel like one.
4
the film provides some great insight into the neurotic mindset of all comics -- even those who have reached the absolute top of the game.
2
offers that rare combination of entertainment and education.
4
Then, you can use SentenceClassification
to build the dataloader.
dl = SentenceClassification("mydata", tokenizer="nltk", convert_to_lower_letter=True)
dl.restart('test', batch_size=2, shuffle=False)
dl.get_next_batch('test')
The returned value of dl.get_next_batch
is as follows.
{'sent_length': array([ 9, 23]),
'sent': array([[ 2, 1, 31, 1, 11, 1, 1, 5, 3, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 2, 1, 112, 1, 1, 13, 1, 13, 4, 1, 13, 62, 1,
9, 1, 12, 8, 1, 1, 13, 1, 5, 3]]),
'sent_allvocabs': array([[ 2, 138, 31, 191, 11, 189, 129, 5, 3, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 2, 114, 112, 185, 118, 13, 149, 13, 4, 165, 13, 62, 146,
9, 198, 12, 8, 151, 174, 13, 186, 5, 3]]),
'sent_str': ['effective but too-tepid biopic.',
'if you sometimes like to go to the movies to have fun, wasabi is a good place to start.'],
'label': array([2, 3])
}
Add A New Metric¶
If you have a new way to evaluate the model, you should construct a
metric class inheriting the metric.MetricBase
.
Here are some necessary functions you must implement. You can click on the link to find more details.
__init__()
Here we give an example for calculating the average length of generated sentences.
class AverageLengthMetric(MetricBase):
def __init__(self, dataloader, gen_key="gen"):
super().__init__()
self.dataloader = dataloader
self.gen_key = gen_key
self.token_num = 0
self.sent_num = 0
def forward(self, data):
gen = data[gen_key]
for sent in gen:
self.token_num += len(self.dataloader.trim_in_ids(sent))
self.sent_num += 1
def close(self):
metric_result = super().close()
metric_result.update({"len_avg": self.token_num / self.sent_num})
return metric_result
There is some regulations to design an metric.
Using allvocabs for reference.
Dealing with
<unk>
, which should be regarded as error or using some methods to do smoothing. Pay attention to the connections between<unk>
and rare vocabularies.Record hash value. Hash value keeps the same if and only if the metric is tested under the same settings.
metric.MetricBase._hash_unordered_list()
records unordered information.metric.MetricBase._hash_ordered_data()
records the ordered information.metric.MetricBase._hashvalue()
returns the hash value. (In the example, there is no hash value because we don’t have input and the setting is always the same)


| Health Care System |
A health service manager is responsible for the provision and commissioning of local healthcare through the management of hospital, general practitioner (GP) or community health services. Managers liaise with clinical and non-clinical staff and other partner organisations, whilst considering the demands of political policy and local circumstances.


7 references to DisposedTrue
System.Management.Automation (7)
engine\remoting\client\Job2.cs (7)
899
if (_isDisposed ==
DisposedTrue
)
1066
if (_isDisposed ==
DisposedTrue
)
1305
if (_isDisposed ==
DisposedTrue
)
1482
if (_isDisposed ==
DisposedTrue
)
1659
if (_isDisposed ==
DisposedTrue
)
2011
if (Interlocked.CompareExchange(ref _isDisposed,
DisposedTrue
, DisposedFalse) ==
DisposedTrue
) return;


Summary
This document describes the workflow for implementing the DMCA notice & takedown policy.
Additionally, this document contains the instructions for using the tools provided for implementing the DMCA notice & takedown policy.
Workflow For Implementing
The site administrator is to recieve copyright requests and dispute claims via email.
It is required that the site administrator log ALL requests and disputes onto this web application.
Once the log has been made, the site administrator should now consider taking action based on the request.
The site administrator should view the most current version of the DMCA notice and takedown policy.
If the site administrator is confident that the request/dispute is valid and in accordance with the site's curent DMCA notice and takedown policy,
then the site administrator should proceed to using the appropriate tool outlined in the section below. If it is a valid takedown request, the site administrator should "hide" the review and
a notice should be sent via email to the review creator and logged on this web application.
If it is a valid dispute request, the site administrator should "unhide" the review. If the site administrator instead believes that the request/dispute is invalid and not in accordance
with the site's current DMCA notice and takedown policy,
then the site administrator should proceed to responding to the user's email and notify them of the rejection and the reasons for declining the request/claim/dispute.
Tools For Implementing
There are three mechanisms that are provided to log requests, notices, and disputes. These tools are located on the "Manage Users" link on the top of the web page.
The first mechanism is provided to record any takedown request of a review that is recieved. Click "log request" on the relevant review, then enter the "date request received" and click "submit".
The second mechanism is provided to record any notices of a review that are sent. Click "log notice" on the relevant review, then enter the "date notice sent" and click "submit".
The third mechanism is provided to record any dispute of a review that is recieved. Click "log dispute" on the relevant review, then enter the "date dispute received" and click "submit".
Additionally, there is the "toggle hidden" tool which allows the administrator to hide or unhide the relevant review. If "clicked" to make the review hidden, this review cannot be seen by any users (except administrators).
Clicking the "toggle hidden" tool again will unhide the review (which should be done in the event of a successful dispute) and the review will be visible by all users again.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.FrontendAppConfig @import controllers.routes._ @import controllers.arrival.routes._ @import viewModels.ViewAllArrivalMovementsViewModel @import views.html.components.{Heading, MovementsTable, Pagination, Search} @this( mainTemplate: MainTemplate, heading: Heading, pagination: Pagination, movementsTable: MovementsTable, search: Search, config: FrontendAppConfig ) @( form: Form[_], viewModel: ViewAllArrivalMovementsViewModel )(implicit request: Request[_], messages: Messages) @mainTemplate( title = messages("viewArrivalNotifications.title"), showBackLink = false, fullWidth = true ) { @heading(messages("viewArrivalNotifications.heading"))
@messages("viewArrivalNotifications.makeArrivalNotification")
@search( form = form, action = ViewAllArrivalsController.onSubmit(Some(viewModel.paginationViewModel.results.currentPage)), label = "movement.search.title" ) @pagination(viewModel.paginationViewModel) @movementsTable( dataRows = viewModel.dataRows, visuallyHiddenHeader = messages("viewArrivalNotifications.heading.hidden"), rowHeadingUpdated = messages("viewArrivalNotifications.table.updated"), rowHeadingReferenceNumber = messages("viewArrivalNotifications.table.mrn"), rowHeadingStatus = messages("viewArrivalNotifications.table.status"), rowHeadingAction = messages("viewArrivalNotifications.table.action") )@messages("viewArrivalNotifications.goToManageTransitMovements")
}


{% extends "_post.html" %}
{% hyde
title: "My Extravagant Zsh Prompt"
snip: "It’s big, but my monitor isn’t running out of ink."
created: 2010-02-01 01:05:00
flattr: true
%}
{% block article %}
I spend a lot of time in a Terminal window at a command line. Up until about a
month ago I was using [bash][] for my shell. I decided to try switching to
[Zsh][] after hearing a lot of good things about it and I'm very happy with
the change.
A few days ago I [tweeted][] my current Zsh prompt and the general response
was: "Cool, but how did you do it?" I promised to write more about it when I
got some free time, and it looks like that time is now.
**One quick note:** This entry is about the prompt that *I* find useful. You
are not me, so you'll almost certainly have different needs. That's great!
Take this prompt and hack it to make whatever works for you. If you're feeling
generous you should find me on [Twitter][twsl] and show me what you changed --
I might want to steal/appropriate your changes.
**Another quick note:** I've customized the colors of my Terminal. They're
based on the [Monokai][] TextMate theme, and I think they look very nice. The
colors will be different for you. If you want colors like mine you should take
a look at the [entry][candy] I wrote about it.
[bash]: http://en.wikipedia.org/wiki/Bash
[Zsh]: http://www.zsh.org/
[tweeted]: http://twitter.com/stevelosh/status/8259755151
[Monokai]: http://www.monokai.nl/blog/2006/07/15/textmate-color-theme/
[candy]: /blog/2009/03/candy-colored-terminal/
[twsl]: {{links.twsl}}
[TOC]
Why Should You Care?
--------------------
Many people use the command line every day and never bother to customize their
prompts. It's just a bit of text that's printed before every command -- why
should you waste time learning how to customize it?
I feel that the *most* important aspect of my command line work is the prompt.
Your prompt is something you'll see *literally* thousands of times a day. Why
not take 30 minutes and customize it into something that's much more useful?
I firmly believe I'm right in thinking this way. 30 minutes (or even 3 hours)
of customization to make your work easier for the **rest of your life** (or at
least however long you stay with your current shell) *is* worth it.
This Entry is About Zsh Prompts
-------------------------------
As I mentioned earlier I now use Zsh as my command line shell. If you use bash
(the default on most modern systems) the syntax to create the shell will be
different.
Really, though, you should give Zsh a try.
Screenshots
-----------
I can write all day, but in the end I think a screenshot will be more helpful
than anything I write.
Here's a sample of my current Zsh prompt:
![My Zsh Prompt](/media/images{{parent_url}}/zsh-prompt.png "My Zsh Prompt")
And here's a version of that screenshot with some comments added to explain
things:
![My Zsh Prompt with Comments](/media/images{{parent_url}}/zsh-prompt-comments.png "My Zsh Prompt with Comments")
If you want to know *how* I created that prompt, read on!
Oh My Zsh!
----------
The first thing I'd do when starting out with Zsh is to install
[robbyrussell's][robr] [oh-my-zsh][omz]. It's a great collection of very
useful Zsh configurations and aliases which set some sane defaults and make
working with Zsh much nicer.
The instructions for installing it are on the project page.
[robr]: http://github.com/robbyrussell
[omz]: http://github.com/robbyrussell/oh-my-zsh
Define a "Theme"
----------------
oh-my-zsh uses [theme files][themes] to specify how your prompt looks.
An oh-my-zsh theme file is just a Zsh script which sets a few variables that
the oh-my-zsh scripts use to render your prompt.
Go ahead and create a new theme file for your prompt. Call it whatever you
like. I called my theme "prose" because it's more verbose than the others.
Copy the contents of one of the other themes to get started.
The `PROMPT` variable is what you'll be modifying to change how your prompt
looks. That's the `PROMPT=whatever` line of the theme file.
Once you're done making your awesome prompt you should fork oh-my-zsh on
GitHub and commit/push your new theme so other people can see and use your
prompt.
[themes]: http://github.com/robbyrussell/oh-my-zsh/tree/master/themes/
Username and Hostname
---------------------
The first two pieces of my prompt are the simplest: username and hostname. I
SSH between machines pretty frequently so I find it nice to have these in my
prompt to remind me of where I am.
These are things that you'll find in many, many Zsh prompts. For more
information about this kind of stuff check out [this page][zshpr].
After adding in the colors this piece of my `PROMPT` variable looks like this:
:::text
%{$fg[magenta]%}%n%{$reset_color%} at %{$fg[yellow]%}%m%{$reset_color%}
[zshpr]: http://www.acm.uiuc.edu/workshops/zsh/prompt/escapes.html
Current Directory
-----------------
I like to have the current working directory displayed in my prompt. Zsh has
two built-in ways to show the current directory:
* **%d** shows the *entire* path.
* **%~** shows the path with any variables replaced.
Unfortunately neither of these work for me.
If I'm in a directory that's under my home directory I want to see `~` instead
of the full path. This would seem to mean that I should use `%~`, but there's
a catch.
The `%~` sequence also replaces any directories that happen to be environment
variables. That means if I'm in something under my `virtualenvs` directory
I'll see `~WORKON_HOME/venv_name` which is extremely ugly.
To get around this I defined a simple function that implements the behavior I
want.
To add this to your prompt you'll first need to add the following function to
your theme:
:::bash
function collapse_pwd {
echo $(pwd | sed -e "s,^$HOME,~,")
}
Then add `$(collapse_pwd)` to your `PROMPT` variable wherever you'd like the
directory to show up.
After adding in the colors this piece of my `PROMPT` variable looks like this:
:::text
in %{$fg_bold[green]%}$(collapse_pwd)%{$reset_color%}
**UPDATE:** In a comment Juliano pointed out a better way to do this. I've
gotten rid of the `collapse_pwd` function and put this into my `PROMPT`
variable instead:
:::bash
${PWD/#$HOME/~}
My Right-Prompt: Battery Capacity
---------------------------------
The next piece of my prompt I'll talk about is the most stand-alone one: the
battery charge.
I work exclusively on laptops. I don't own a desktop machine -- I have a
Macbook, Macbook Pro and Asus EEE PC and my work machine is a Macbook Pro. I
work from coffeeshops and client meetings pretty often, so it's nice to have a
reminder of my remaining battery power to know when I need to plug in.
On the right-hand side of the prompt in the screenshot you can see a series of
green triangles. These represent my current battery charge and they turn to
empty triangles as the battery becomes depleted. Once the battery reaches 60%
they turn yellow and once it reaches 40% they turn red.
To do this I wrote a *very* simple Python script to output my current battery
capacity. The entire script is shown below.
:::python
#!/usr/bin/env python
# coding=UTF-8
import math, subprocess
p = subprocess.Popen(["ioreg", "-rc", "AppleSmartBattery"], stdout=subprocess.PIPE)
output = p.communicate()[0]
o_max = [l for l in output.splitlines() if 'MaxCapacity' in l][0]
o_cur = [l for l in output.splitlines() if 'CurrentCapacity' in l][0]
b_max = float(o_max.rpartition('=')[-1].strip())
b_cur = float(o_cur.rpartition('=')[-1].strip())
charge = b_cur / b_max
charge_threshold = int(math.ceil(10 * charge))
# Output
total_slots, slots = 10, []
filled = int(math.ceil(charge_threshold * (total_slots / 10.0))) * u'▸'
empty = (total_slots - len(filled)) * u'▹'
out = (filled + empty).encode('utf-8')
import sys
color_green = '%{[32m%}'
color_yellow = '%{[1;33m%}'
color_red = '%{[31m%}'
color_reset = '%{[00m%}'
color_out = (
color_green if len(filled) > 6
else color_yellow if len(filled) > 4
else color_red
)
out = color_out + out + color_reset
sys.stdout.write(out)
**Note:** The `color_*` variables contain UTF-8 characters which don't show up
in a normal web browser. They *should* be preserved when copying and pasting
from a decent browser. If the colors don't work find me on [Twitter][twsl] and
I'll put the raw script up somewhere so you can download it.
**UPDATE:** [ehamberg][] [sent me][ehbtweet] the beginnings of a
Linux-compatible battery capacity script. If you flesh it out and make it into
a complete script please let me know and I'll add it here.
[ehamberg]: http://twitter.com/ehamberg/
[ehbtweet]: http://twitter.com/ehamberg/status/8503213690
I've put this script in a file named `batcharge.py` in my `~/bin/` directory.
You can of course name it and place it anything/anywhere you like.
No, it's not perfect. No, I don't care. It gets the job done and any
brainpower I could spend on making it more efficient could be better spent on
writing or working on something else.
If you want to improve it, feel free and *please* send me the link to your work on
[Twitter][twsl] so I can use it!
Now that you've got the script, it's time to add it to your prompt.
If you want this to appear on the right-hand side of your screen (like mine
does) you'll need to add two things to your theme file. The first is a
function that calls the script:
:::bash
function battery_charge {
echo `$BAT_CHARGE` 2>/dev/null
}
After that you'll need to define the Zsh `RPROMPT` variable:
:::bash
RPROMPT='$(battery_charge)'
Once those are in your theme file any new Terminal windows you open should
show the battery capacity to the right of your prompt!
Repository Types
----------------
In my personal work and my full-time job I work with both
[Mercurial][mercurial] and [git][] repositories. I find it helpful to have a
visual reminder of what kind of repository I'm working in.
To do this I've replaced the standard `$` character in my prompt with
different Unicode characters depending on what kind of repository I'm
currently in:
* `○` means "I'm not in any repository."
* `☿` means "I'm in a Mercurial repository."
* `±` means "I'm in a git repository."
Those particular characters are meant to reflect the logos of the various
projects. You can of course change them to anything that makes sense to you.
[mercurial]: {{links.mercurial}}
[git]: {{links.git}}
To add this feature to your prompt you'll need to do two things in your theme
file. First, add the following function:
:::bash
function prompt_char {
git branch >/dev/null 2>/dev/null && echo '±' && return
hg root >/dev/null 2>/dev/null && echo '☿' && return
echo '○'
}
Then add `$(prompt_char)` somewhere inside your `PROMPT` variable -- wherever
you want the character to be displayed (probably at the end).
Mercurial Repository Information
--------------------------------
I use Mercurial at work and for my own personal projects and I find it very
handy to have some information about the current repository right in my
prompt. It keeps me "oriented," especially when I'm using [MQ][] and
manipulating the state of a repo.

To fix this I wrote a small Mercurial extension called [hg-prompt][]. It adds
an `hg prompt` command to Mercurial that will let you output information about
the current repository. It's designed especially for use in shell prompts
(hence the name).
I open sourced the code a while ago and since then a few people have made
feature requests and/or contributed patches. It's grown into a nice, flexible
little tool. You can check out the [documentation][hgpdoc] to see all the
things it can do.
[hg-prompt]: /projects/hg-prompt/
[hgpdoc]: http://sjl.bitbucket.org/hg-prompt/
I only use a few of the features myself:
* The current repository branch.
* The "dirty" state of the repo (whether there are untracked/uncommitted files).
* Any tags pointing at the current revision.
* An "update" character to show whether running `hg update` would do anything.
* A list of MQ patches (if any are present).
To put this into my prompt I've added a function to my theme:
:::bash
function hg_prompt_info {
hg prompt --angle-brackets "\
< on >\
< at >\
<
patches: >" 2>/dev/null
}
Inside my `PROMPT` variable I use `$(hg_prompt_info)` to show the information.
The `2>/dev/null` makes sure no output is shown if I don't happen to be in a
Mercurial repository.
Of course this isn't nearly as pretty or readable without color. Unfortunately
adding color codes makes the actual code almost unreadable:
:::bash
function hg_prompt_info {
hg prompt --angle-brackets "\
< on %{$fg[magenta]%}%{$reset_color%}>\
< at %{$fg[yellow]%}%{$reset_color%}>\
%{$fg[green]%}%{$reset_color%}<
patches: >" 2>/dev/null
}
**Small note:** My favorite part of this prompt is that applied MQ patches are
orange while unapplied patches are grey. It makes it very obvious what's going
on.
Showing all the MQ patches isn't something that will work for everyone. If you
work on repositories that ever have more than 5 or 6 patches at a time the
output is going to be too overwhelming. There are some other MQ-related
hg-prompt keywords that you might find useful though.
Git Repository Information
--------------------------
Unfortunately I can't *always* use Mercurial. Many projects that I contribute
to use git.
I could try to use the [hg-git][] extension to let me use Mercurial to work
with them, but the extension just isn't fast or mature enough for my taste.
I've ended up buckling down and jumping down the rabbit hole that is git's
CLI.
[hg-git]: http://hg-git.github.com/
Git doesn't seem to have any equivalent to hg-prompt, but I still wanted to
have some information in my prompt so I don't get disoriented. oh-my-zsh has a
bit of support for this, but it wasn't quite enough for me so I [hacked
something together][omzgitcommit] to add the last bit of functionality I
wanted.
[omzgitcommit]: http://github.com/sjl/oh-my-zsh/commit/3d22ee248c6bce357c018a93d31f8d292d2cb4cd
When I'm in a git repository my prompt now shows:
* The current git branch.
* Whether there are any changes in the index.
* Whether there are any changes *not* in the index.
Adding this to your prompt is very simple because oh-my-zsh has built-in
support for it. All you need to do is define a few variables in your theme:
:::bash
ZSH_THEME_GIT_PROMPT_PREFIX=" on %{$fg[magenta]%}"
ZSH_THEME_GIT_PROMPT_SUFFIX="%{$reset_color%}"
ZSH_THEME_GIT_PROMPT_DIRTY="%{$fg[green]%}!"
ZSH_THEME_GIT_PROMPT_UNTRACKED="%{$fg[green]%}?"
ZSH_THEME_GIT_PROMPT_CLEAN=""
Once you do that you can put `$(git_prompt_info)` into your `PROMPT` variable
to make it show up.
**Note:** The `ZSH_THEME_GIT_PROMPT_UNTRACKED` variable is the part I added.
If your want to use that one (to be able to see indexed and unindexed changes
separately) you'll need to use [my fork of oh-my-zsh][omzfork].
[omzfork]: http://github.com/sjl/oh-my-zsh/
The Whole Thing
---------------
Here's what my new "prose" theme file currently looks like in its entirety:
:::bash
function collapse_pwd {
echo $(pwd | sed -e "s,^$HOME,~,")
}
function prompt_char {
git branch >/dev/null 2>/dev/null && echo '±' && return
hg root >/dev/null 2>/dev/null && echo '☿' && return
echo '○'
}
function battery_charge {
echo `$BAT_CHARGE` 2>/dev/null
}
function virtualenv_info {
[ $VIRTUAL_ENV ] && echo '('`basename $VIRTUAL_ENV`') '
}
function hg_prompt_info {
hg prompt --angle-brackets "\
< on %{$fg[magenta]%}%{$reset_color%}>\
< at %{$fg[yellow]%}%{$reset_color%}>\
%{$fg[green]%}%{$reset_color%}<
patches: >" 2>/dev/null
}
PROMPT='
%{$fg[magenta]%}%n%{$reset_color%} at %{$fg[yellow]%}%m%{$reset_color%} in %{$fg_bold[green]%}$(collapse_pwd)%{$reset_color%}$(hg_prompt_info)$(git_prompt_info)
$(virtualenv_info)$(prompt_char) '
RPROMPT='$(battery_charge)'
ZSH_THEME_GIT_PROMPT_PREFIX=" on %{$fg[magenta]%}"
ZSH_THEME_GIT_PROMPT_SUFFIX="%{$reset_color%}"
ZSH_THEME_GIT_PROMPT_DIRTY="%{$fg[green]%}!"
ZSH_THEME_GIT_PROMPT_UNTRACKED="%{$fg[green]%}?"
ZSH_THEME_GIT_PROMPT_CLEAN=""
The file is also [on GitHub][prosetheme]. Remember, you'll need
[my fork of oh-my-zsh][omzfork] to use the `ZSH_THEME_GIT_PROMPT_UNTRACKED`
feature.
[prosetheme]: http://github.com/sjl/oh-my-zsh/blob/master/themes/prose.zsh-theme
A shell prompt is something that we'll each see thousands of times a day, so
it's something that you should take the time to customize into a useful tool.
Feel free to use my prompt as a starting point or just as a source of ideas.
If you have any questions, suggestions, or examples of your own please fine me on
[Twitter][twsl] -- I'd love to hear them!
{% endblock %}


Starting with github and github pages
After messing around GitHub and only having it for about a month
I made my repository really easily. It probably took me about
5ish minutes. I really like that GitHub exists because I can work
from anywhere that allows me to get online. Ive worked on terminal
and linked github easily before using VScode. I think using VScode was
the easiest when creating and setting up the new repository. I do a
quick sample ReadMe file to double check my even if I have confidence
that its set up. I think its a good idea to double check work being a
newbie at this. I also am in Todds class for CIT 85 and he uses github
regularly. I got a few tricks from him easily without having to use the
program he is using which it Webstorm. I think that was really helpful
when setting up also.


module Visualization: sig
.. end
Fault trees, formulas, and models can be visualized in various ways. Here are
the top-level visualization functions. In order to use the visualization
code, you have to have graphviz installed in your path.
- dot_gen_show_direct_tree_file : a function for directly visualizing
fault trees.
- dot_gen_show_tree_file : a function for simplifying and visualizing
fault trees.
- dot_gen_show_formula_file : a function for visualizing monotone Boolean
formulas.
- dot_gen_show_ph_file : This function generates and displays a
visualization of the physical architecture. By this I mean we get one node
per instance of a component in a model. If there are k outputs from
component A that are connected to k inputs from component B, then only one
edge is shown between the components. This gives us the highest-level view of
the system, as is shows an abstract view showing only components and
connectivity information (yes/no).
- dot_gen_show_funct_file : This function generates and displays a
visualization of the functional architecture. This is an elaboration of the
physical architecture that in addition shows input port and output ports. Now
edges are from port to port, so we get a mode detailed view of the model. For
example, in this view of a model, if there are k outputs from component A
that are connected to k inputs from component B, then k edges are shown
between the components as there is an edge from one port to another if the
first port's output is the input to the second port.
- dot_gen_show_fault_file : This function generate and displays a
visualization of the propagation of faults through the architecture. This is
an elaboration of the functional model that in addition shows basic events
associated with components and shows what parts of the model can affect the
probability of a the top-level fault. If an edge (corresponding to a flow of
information from one component to another) can affect the top-level fault, it
is colored red. If a basic event can affect the top-level fault, then a (set
of) red edge(s) is added from that event to the output(s) along which the
basic event propogates.
Here is an example of how the above functions can be used to visualize and
analyze the example library and model given above.
dot_gen_show_ph_file nasa_handbook_model "mpnasa.gv";;
dot_gen_show_funct_file nasa_handbook_lib nasa_handbook_model "mfnasa.gv";;
dot_gen_show_fault_file nasa_handbook_lib nasa_handbook_model "mftnasa.gv";;
let nasa_ftree = model_to_ftree nasa_handbook_lib nasa_handbook_model ;;
dot_gen_show_direct_tree_file "tdnasa.gv" nasa_ftree ;;
dot_gen_show_tree_file "tnasa.gv" nasa_ftree ;;
let nasa_cutsets = cutsets nasa_ftree;;
dot_gen_show_formula_file "csnasa.gv" nasa_cutsets ;;
let nasa_probErrorCut = probErrorCut nasa_ftree ;;
let nasa_probErrorCutImp = probErrorCutImp nasa_ftree ;;
val unflatten_exe : string
val dot_exe : string
val dot_gen_show_direct_tree_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Core.Std.String.t ->
(Core.Std.String.t * Core.Std.String.t) FaultTree.ftree -> unit
A function for directly visualizing fault trees.
val dot_gen_show_tree_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Core.Std.String.t ->
(Core.Std.String.t * Core.Std.String.t) FaultTree.ftree -> unit
A function for simplifying and visualizing fault trees.
val dot_gen_show_ssfc_tree_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Core.Std.String.t ->
(Core.Std.String.t * Core.Std.String.t) FaultTree.ftree -> unit
val dot_gen_show_nndsimp_tree_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Core.Std.String.t ->
(Core.Std.String.t * Core.Std.String.t) FaultTree.ftree -> unit
val dot_gen_show_formula_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Core.Std.String.t ->
(Core.Std.String.t * Core.Std.String.t) FaultTree.pexp -> unit
A function for visualizing monotone Boolean formulas.
val dot_gen_show_ph_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool -> Modeling.model -> Core.Std.String.t -> unit
This function generates and displays a visualization of the physical
architecture. By this I mean we get one node per instance of a component in
a model. If there are k outputs from component A that are connected to k
inputs from component B, then only one edge is shown between the
components. This gives us the highest-level view of the system, as is shows
an abstract view showing only components and connectivity information
(yes/no).
val dot_gen_show_funct_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Modeling.component Core.Std.List.t ->
Modeling.model -> Core.Std.String.t -> unit
This function generates and displays a visualization of the functional
architecture. This is an elaboration of the physical architecture that in
addition shows input port and output ports. Now edges are from port to port,
so we get a mode detailed view of the model. For example, in this view of a
model, if there are k outputs from component A that are connected to k
inputs from component B, then k edges are shown between the components as
there is an edge from one port to another if the first port's output is the
input to the second port.
val dot_gen_show_fault_file : ?rend:Core.Std.String.t ->
?splines:string ->
?layout:string ->
?overlap:string ->
?unflatten:bool ->
Modeling.component Core.Std.List.t ->
Modeling.model -> Core.Std.String.t -> unit
This function generates and displays a visualization of the propagation of
faults through the architecture. This is an elaboration of the functional
model that in addition shows basic events associated with components and
shows what parts of the model can affect the probability of a the top-level
fault. If an edge (corresponding to a flow of information from one component
to another) can affect the top-level fault, it is colored red. If a basic
event can affect the top-level fault, then a (set of) red edge(s) is added
from that event to the output(s) along which the basic event propogates.


Open Contact Menu
Contact Walter White
Leasing Agent,<PHONE_NUMBER> -ext 3122
Hello, I might have to mention that the background website is just an image, wich I got from dribbble by Vincent Tantardini : http://dribbble.com/shots/1304437-Kptive-Blog?list=popular&offset=60 I shamelessly stole it, sorry for that. Bye, Walter White