#
# 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.
#
"""A source and a sink for reading from and writing to text files."""
from __future__ import absolute_import
import logging
from functools import partial
from six import integer_types
from apache_beam.coders import coders
from apache_beam.io import filebasedsink
from apache_beam.io import filebasedsource
from apache_beam.io import iobase
from apache_beam.io.filebasedsource import ReadAllFiles
from apache_beam.io.filesystem import CompressionTypes
from apache_beam.io.iobase import Read
from apache_beam.io.iobase import Write
from apache_beam.transforms import PTransform
from apache_beam.transforms.display import DisplayDataItem
__all__ = ['ReadFromText', 'ReadAllFromText', 'WriteToText']
class _TextSource(filebasedsource.FileBasedSource):
r"""A source for reading text files.
Parses a text file as newline-delimited elements. Supports newline delimiters
'\n' and '\r\n.
This implementation only supports reading text encoded using UTF-8 or
ASCII.
"""
DEFAULT_READ_BUFFER_SIZE = 8192
class ReadBuffer(object):
# A buffer that gives the buffered data and next position in the
# buffer that should be read.
def __init__(self, data, position):
self._data = data
self._position = position
@property
def data(self):
return self._data
@data.setter
def data(self, value):
assert isinstance(value, bytes)
self._data = value
@property
def position(self):
return self._position
@position.setter
def position(self, value):
assert isinstance(value, integer_types)
if value > len(self._data):
raise ValueError('Cannot set position to %d since it\'s larger than '
'size of data %d.', value, len(self._data))
self._position = value
def reset(self):
self.data = ''
self.position = 0
def __init__(self,
file_pattern,
min_bundle_size,
compression_type,
strip_trailing_newlines,
coder,
buffer_size=DEFAULT_READ_BUFFER_SIZE,
validate=True,
skip_header_lines=0,
header_processor_fns=(None, None)):
"""Initialize a _TextSource
Args:
header_processor_fns (tuple): a tuple of a `header_matcher` function
and a `header_processor` function. The `header_matcher` should
return `True` for all lines at the start of the file that are part
of the file header and `False` otherwise. These header lines will
not be yielded when reading records and instead passed into
`header_processor` to be handled. If `skip_header_lines` and a
`header_matcher` are both provided, the value of `skip_header_lines`
lines will be skipped and the header will be processed from
there.
Raises:
ValueError: if skip_lines is negative.
Please refer to documentation in class `ReadFromText` for the rest
of the arguments.
"""
super(_TextSource, self).__init__(file_pattern, min_bundle_size,
compression_type=compression_type,
validate=validate)
self._strip_trailing_newlines = strip_trailing_newlines
self._compression_type = compression_type
self._coder = coder
self._buffer_size = buffer_size
if skip_header_lines < 0:
raise ValueError('Cannot skip negative number of header lines: %d',
skip_header_lines)
elif skip_header_lines > 10:
logging.warning(
'Skipping %d header lines. Skipping large number of header '
'lines might significantly slow down processing.')
self._skip_header_lines = skip_header_lines
self._header_matcher, self._header_processor = header_processor_fns
def display_data(self):
parent_dd = super(_TextSource, self).display_data()
parent_dd['strip_newline'] = DisplayDataItem(
self._strip_trailing_newlines,
label='Strip Trailing New Lines')
parent_dd['buffer_size'] = DisplayDataItem(
self._buffer_size,
label='Buffer Size')
parent_dd['coder'] = DisplayDataItem(
self._coder.__class__,
label='Coder')
return parent_dd
def read_records(self, file_name, range_tracker):
start_offset = range_tracker.start_position()
read_buffer = _TextSource.ReadBuffer('', 0)
next_record_start_position = -1
def split_points_unclaimed(stop_position):
return (0 if stop_position <= next_record_start_position
else iobase.RangeTracker.SPLIT_POINTS_UNKNOWN)
range_tracker.set_split_points_unclaimed_callback(split_points_unclaimed)
with self.open_file(file_name) as file_to_read:
position_after_processing_header_lines = (
self._process_header(file_to_read, read_buffer))
start_offset = max(start_offset, position_after_processing_header_lines)
if start_offset > position_after_processing_header_lines:
# Seeking to one position before the start index and ignoring the
# current line. If start_position is at beginning if the line, that line
# belongs to the current bundle, hence ignoring that is incorrect.
# Seeking to one byte before prevents that.
file_to_read.seek(start_offset - 1)
read_buffer.reset()
sep_bounds = self._find_separator_bounds(file_to_read, read_buffer)
if not sep_bounds:
# Could not find a separator after (start_offset - 1). This means that
# none of the records within the file belongs to the current source.
return
_, sep_end = sep_bounds
read_buffer.data = read_buffer.data[sep_end:]
next_record_start_position = start_offset - 1 + sep_end
else:
next_record_start_position = position_after_processing_header_lines
while range_tracker.try_claim(next_record_start_position):
record, num_bytes_to_next_record = self._read_record(file_to_read,
read_buffer)
# For compressed text files that use an unsplittable OffsetRangeTracker
# with infinity as the end position, above 'try_claim()' invocation
# would pass for an empty record at the end of file that is not
# followed by a new line character. Since such a record is at the last
# position of a file, it should not be a part of the considered range.
# We do this check to ignore such records.
if len(record) == 0 and num_bytes_to_next_record < 0: # pylint: disable=len-as-condition
break
# Record separator must be larger than zero bytes.
assert num_bytes_to_next_record != 0
if num_bytes_to_next_record > 0:
next_record_start_position += num_bytes_to_next_record
yield self._coder.decode(record)
if num_bytes_to_next_record < 0:
break
def _process_header(self, file_to_read, read_buffer):
# Returns a tuple containing the position in file after processing header
# records and a list of decoded header lines that match
# 'header_matcher'.
header_lines = []
position = self._skip_lines(
file_to_read, read_buffer,
self._skip_header_lines) if self._skip_header_lines else 0
if self._header_matcher:
while True:
record, num_bytes_to_next_record = self._read_record(file_to_read,
read_buffer)
decoded_line = self._coder.decode(record)
if not self._header_matcher(decoded_line):
# We've read past the header section at this point, so go back a line.
file_to_read.seek(position)
read_buffer.reset()
break
header_lines.append(decoded_line)
if num_bytes_to_next_record < 0:
break
position += num_bytes_to_next_record
if self._header_processor:
self._header_processor(header_lines)
return position
def _find_separator_bounds(self, file_to_read, read_buffer):
# Determines the start and end positions within 'read_buffer.data' of the
# next separator starting from position 'read_buffer.position'.
# Currently supports following separators.
# * '\n'
# * '\r\n'
# This method may increase the size of buffer but it will not decrease the
# size of it.
current_pos = read_buffer.position
while True:
if current_pos >= len(read_buffer.data):
# Ensuring that there are enough bytes to determine if there is a '\n'
# at current_pos.
if not self._try_to_ensure_num_bytes_in_buffer(
file_to_read, read_buffer, current_pos + 1):
return
# Using find() here is more efficient than a linear scan of the byte
# array.
next_lf = read_buffer.data.find('\n', current_pos)
if next_lf >= 0:
if next_lf > 0 and read_buffer.data[next_lf - 1] == '\r':
# Found a '\r\n'. Accepting that as the next separator.
return (next_lf - 1, next_lf + 1)
else:
# Found a '\n'. Accepting that as the next separator.
return (next_lf, next_lf + 1)
current_pos = len(read_buffer.data)
def _try_to_ensure_num_bytes_in_buffer(
self, file_to_read, read_buffer, num_bytes):
# Tries to ensure that there are at least num_bytes bytes in the buffer.
# Returns True if this can be fulfilled, returned False if this cannot be
# fulfilled due to reaching EOF.
while len(read_buffer.data) < num_bytes:
read_data = file_to_read.read(self._buffer_size)
if not read_data:
return False
read_buffer.data += read_data
return True
def _skip_lines(self, file_to_read, read_buffer, num_lines):
"""Skip num_lines from file_to_read, return num_lines+1 start position."""
if file_to_read.tell() > 0:
file_to_read.seek(0)
position = 0
for _ in range(num_lines):
_, num_bytes_to_next_record = self._read_record(file_to_read, read_buffer)
if num_bytes_to_next_record < 0:
# We reached end of file. It is OK to just break here
# because subsequent _read_record will return same result.
break
position += num_bytes_to_next_record
return position
def _read_record(self, file_to_read, read_buffer):
# Returns a tuple containing the current_record and number of bytes to the
# next record starting from 'read_buffer.position'. If EOF is
# reached, returns a tuple containing the current record and -1.
if read_buffer.position > self._buffer_size:
# read_buffer is too large. Truncating and adjusting it.
read_buffer.data = read_buffer.data[read_buffer.position:]
read_buffer.position = 0
record_start_position_in_buffer = read_buffer.position
sep_bounds = self._find_separator_bounds(file_to_read, read_buffer)
read_buffer.position = sep_bounds[1] if sep_bounds else len(
read_buffer.data)
if not sep_bounds:
# Reached EOF. Bytes up to the EOF is the next record. Returning '-1' for
# the starting position of the next record.
return (read_buffer.data[record_start_position_in_buffer:], -1)
if self._strip_trailing_newlines:
# Current record should not contain the separator.
return (read_buffer.data[record_start_position_in_buffer:sep_bounds[0]],
sep_bounds[1] - record_start_position_in_buffer)
else:
# Current record should contain the separator.
return (read_buffer.data[record_start_position_in_buffer:sep_bounds[1]],
sep_bounds[1] - record_start_position_in_buffer)
class _TextSink(filebasedsink.FileBasedSink):
"""A sink to a GCS or local text file or files."""
def __init__(self,
file_path_prefix,
file_name_suffix='',
append_trailing_newlines=True,
num_shards=0,
shard_name_template=None,
coder=coders.ToStringCoder(),
compression_type=CompressionTypes.AUTO,
header=None):
"""Initialize a _TextSink.
Args:
file_path_prefix: The file path to write to. The files written will begin
with this prefix, followed by a shard identifier (see num_shards), and
end in a common extension, if given by file_name_suffix. In most cases,
only this argument is specified and num_shards, shard_name_template, and
file_name_suffix use default values.
file_name_suffix: Suffix for the files written.
append_trailing_newlines: indicate whether this sink should write an
additional newline char after writing each element.
num_shards: The number of files (shards) used for output. If not set, the
service will decide on the optimal number of shards.
Constraining the number of shards is likely to reduce
the performance of a pipeline. Setting this value is not recommended
unless you require a specific number of output files.
shard_name_template: A template string containing placeholders for
the shard number and shard count. When constructing a filename for a
particular shard number, the upper-case letters 'S' and 'N' are
replaced with the 0-padded shard number and shard count respectively.
This argument can be '' in which case it behaves as if num_shards was
set to 1 and only one file will be generated. The default pattern used
is '-SSSSS-of-NNNNN' if None is passed as the shard_name_template.
coder: Coder used to encode each line.
compression_type: Used to handle compressed output files. Typical value
is CompressionTypes.AUTO, in which case the final file path's
extension (as determined by file_path_prefix, file_name_suffix,
num_shards and shard_name_template) will be used to detect the
compression.
header: String to write at beginning of file as a header. If not None and
append_trailing_newlines is set, '\n' will be added.
Returns:
A _TextSink object usable for writing.
"""
super(_TextSink, self).__init__(
file_path_prefix,
file_name_suffix=file_name_suffix,
num_shards=num_shards,
shard_name_template=shard_name_template,
coder=coder,
mime_type='text/plain',
compression_type=compression_type)
self._append_trailing_newlines = append_trailing_newlines
self._header = header
def open(self, temp_path):
file_handle = super(_TextSink, self).open(temp_path)
if self._header is not None:
file_handle.write(self._header)
if self._append_trailing_newlines:
file_handle.write('\n')
return file_handle
def display_data(self):
dd_parent = super(_TextSink, self).display_data()
dd_parent['append_newline'] = DisplayDataItem(
self._append_trailing_newlines,
label='Append Trailing New Lines')
return dd_parent
def write_encoded_record(self, file_handle, encoded_value):
"""Writes a single encoded record."""
file_handle.write(encoded_value)
if self._append_trailing_newlines:
file_handle.write('\n')
def _create_text_source(
file_pattern=None, min_bundle_size=None, compression_type=None,
strip_trailing_newlines=None, coder=None, skip_header_lines=None):
return _TextSource(
file_pattern=file_pattern, min_bundle_size=min_bundle_size,
compression_type=compression_type,
strip_trailing_newlines=strip_trailing_newlines,
coder=coder, validate=False, skip_header_lines=skip_header_lines)
[docs]class ReadAllFromText(PTransform):
"""A ``PTransform`` for reading a ``PCollection`` of text files.
Reads a ``PCollection`` of text files or file patterns and and produces a
``PCollection`` of strings.
Parses a text file as newline-delimited elements, by default assuming
UTF-8 encoding. Supports newline delimiters '\\n' and '\\r\\n'.
This implementation only supports reading text encoded using UTF-8 or ASCII.
This does not support other encodings such as UTF-16 or UTF-32.
"""
DEFAULT_DESIRED_BUNDLE_SIZE = 64 * 1024 * 1024 # 64MB
def __init__(
self,
min_bundle_size=0,
desired_bundle_size=DEFAULT_DESIRED_BUNDLE_SIZE,
compression_type=CompressionTypes.AUTO,
strip_trailing_newlines=True,
coder=coders.StrUtf8Coder(),
skip_header_lines=0,
**kwargs):
"""Initialize the ``ReadAllFromText`` transform.
Args:
min_bundle_size: Minimum size of bundles that should be generated when
splitting this source into bundles. See ``FileBasedSource`` for more
details.
desired_bundle_size: Desired size of bundles that should be generated when
splitting this source into bundles. See ``FileBasedSource`` for more
details.
compression_type: Used to handle compressed input files. Typical value
is ``CompressionTypes.AUTO``, in which case the underlying file_path's
extension will be used to detect the compression.
strip_trailing_newlines: Indicates whether this source should remove
the newline char in each line it reads before decoding that line.
validate: flag to verify that the files exist during the pipeline
creation time.
skip_header_lines: Number of header lines to skip. Same number is skipped
from each source file. Must be 0 or higher. Large number of skipped
lines might impact performance.
coder: Coder used to decode each line.
"""
super(ReadAllFromText, self).__init__(**kwargs)
source_from_file = partial(
_create_text_source, min_bundle_size=min_bundle_size,
compression_type=compression_type,
strip_trailing_newlines=strip_trailing_newlines, coder=coder,
skip_header_lines=skip_header_lines)
self._desired_bundle_size = desired_bundle_size
self._min_bundle_size = min_bundle_size
self._compression_type = compression_type
self._read_all_files = ReadAllFiles(
True, compression_type, desired_bundle_size, min_bundle_size,
source_from_file)
[docs] def expand(self, pvalue):
return pvalue | 'ReadAllFiles' >> self._read_all_files
[docs]class ReadFromText(PTransform):
r"""A :class:`~apache_beam.transforms.ptransform.PTransform` for reading text
files.
Parses a text file as newline-delimited elements, by default assuming
``UTF-8`` encoding. Supports newline delimiters ``\n`` and ``\r\n``.
This implementation only supports reading text encoded using ``UTF-8`` or
``ASCII``.
This does not support other encodings such as ``UTF-16`` or ``UTF-32``.
"""
def __init__(
self,
file_pattern=None,
min_bundle_size=0,
compression_type=CompressionTypes.AUTO,
strip_trailing_newlines=True,
coder=coders.StrUtf8Coder(),
validate=True,
skip_header_lines=0,
**kwargs):
"""Initialize the :class:`ReadFromText` transform.
Args:
file_pattern (str): The file path to read from as a local file path or a
GCS ``gs://`` path. The path can contain glob characters
(``*``, ``?``, and ``[...]`` sets).
min_bundle_size (int): Minimum size of bundles that should be generated
when splitting this source into bundles. See
:class:`~apache_beam.io.filebasedsource.FileBasedSource` for more
details.
compression_type (str): Used to handle compressed input files.
Typical value is :attr:`CompressionTypes.AUTO
<apache_beam.io.filesystem.CompressionTypes.AUTO>`, in which case the
underlying file_path's extension will be used to detect the compression.
strip_trailing_newlines (bool): Indicates whether this source should
remove the newline char in each line it reads before decoding that line.
validate (bool): flag to verify that the files exist during the pipeline
creation time.
skip_header_lines (int): Number of header lines to skip. Same number is
skipped from each source file. Must be 0 or higher. Large number of
skipped lines might impact performance.
coder (~apache_beam.coders.coders.Coder): Coder used to decode each line.
"""
super(ReadFromText, self).__init__(**kwargs)
self._source = _TextSource(
file_pattern, min_bundle_size, compression_type,
strip_trailing_newlines, coder, validate=validate,
skip_header_lines=skip_header_lines)
[docs] def expand(self, pvalue):
return pvalue.pipeline | Read(self._source)
[docs]class WriteToText(PTransform):
"""A :class:`~apache_beam.transforms.ptransform.PTransform` for writing to
text files."""
def __init__(
self,
file_path_prefix,
file_name_suffix='',
append_trailing_newlines=True,
num_shards=0,
shard_name_template=None,
coder=coders.ToStringCoder(),
compression_type=CompressionTypes.AUTO,
header=None):
r"""Initialize a :class:`WriteToText` transform.
Args:
file_path_prefix (str): The file path to write to. The files written will
begin with this prefix, followed by a shard identifier (see
**num_shards**), and end in a common extension, if given by
**file_name_suffix**. In most cases, only this argument is specified and
**num_shards**, **shard_name_template**, and **file_name_suffix** use
default values.
file_name_suffix (str): Suffix for the files written.
append_trailing_newlines (bool): indicate whether this sink should write
an additional newline char after writing each element.
num_shards (int): The number of files (shards) used for output.
If not set, the service will decide on the optimal number of shards.
Constraining the number of shards is likely to reduce
the performance of a pipeline. Setting this value is not recommended
unless you require a specific number of output files.
shard_name_template (str): A template string containing placeholders for
the shard number and shard count. Currently only ``''`` and
``'-SSSSS-of-NNNNN'`` are patterns accepted by the service.
When constructing a filename for a particular shard number, the
upper-case letters ``S`` and ``N`` are replaced with the ``0``-padded
shard number and shard count respectively. This argument can be ``''``
in which case it behaves as if num_shards was set to 1 and only one file
will be generated. The default pattern used is ``'-SSSSS-of-NNNNN'``.
coder (~apache_beam.coders.coders.Coder): Coder used to encode each line.
compression_type (str): Used to handle compressed output files.
Typical value is :class:`CompressionTypes.AUTO
<apache_beam.io.filesystem.CompressionTypes.AUTO>`, in which case the
final file path's extension (as determined by **file_path_prefix**,
**file_name_suffix**, **num_shards** and **shard_name_template**) will
be used to detect the compression.
header (str): String to write at beginning of file as a header.
If not :data:`None` and **append_trailing_newlines** is set, ``\n`` will
be added.
"""
self._sink = _TextSink(file_path_prefix, file_name_suffix,
append_trailing_newlines, num_shards,
shard_name_template, coder, compression_type, header)
[docs] def expand(self, pcoll):
return pcoll | Write(self._sink)


i think they will deny all of them, it's to risky for the SEC to approve it atm(edited)
Maybe next year
snowdamn23-Aug-18 02:39 PM
KMD deserves to do a 3x right here regardless
3
grewalsatinder23-Aug-18 02:51 PM
KMD deserves $7777 price (edited)
1
Anyone wonder when will we reach $7777 per KMD price?
Any crazy predictions for it?
SHossain23-Aug-18 02:58 PM
$777 in 2020
snowdamn23-Aug-18 02:58 PM
i probably won't live to see $7777, will die from excitement @ $777!!!
grewalsatinder23-Aug-18 02:59 PM
Heh
Yassin23-Aug-18 03:00 PM
0.777$ soon!!
2
3
5
grewalsatinder23-Aug-18 03:00 PM
Hehe that’s more like it (edited)
Yassin23-Aug-18 03:01 PM
grewalsatinder23-Aug-18 03:02 PM
In BTC maybe 8k sats?
Yassin23-Aug-18 03:02 PM
grewalsatinder23-Aug-18 03:03 PM
Yassin23-Aug-18 03:05 PM
all is possible, i am just expert holder!!
waiting next div Supernet/asset!!
CHMEX23-Aug-18 03:09 PM
sn passthrough from crypto
Deleted User23-Aug-18 03:11 PM
How does the assets work? Every time 1m is reached its paid out?
Is there a way to see how close to the mil is
And would we not be able to buy it right before the 1m? Or is it paid out only if you hold for whole duration?
Hows it work exactly :o
Cryptoon23-Aug-18 03:12 PM
There are adresses where you can see how much has been accumulated I think
Paid out to holders at time of payout
Deleted User23-Aug-18 03:12 PM
Or are people smart and price reflects it aka drops right after payout
Or are payouts too tiny for people to bother atm
Cryptoon23-Aug-18 03:12 PM
But I assume because more people are buying price will go up and return on investment will be lower
1M usd paid out over 1M DEX is 1 usd per dex
Deleted User23-Aug-18 03:13 PM
Interesting
Cryptoon23-Aug-18 03:13 PM
At current prices that is +-11% return
(I think supply of DEX was 1M, not sure)
Yassin23-Aug-18 03:13 PM
1M
CHMEX23-Aug-18 03:13 PM
I expect the supernet payout to be at approx 0.16 kmd per supernet
Deleted User23-Aug-18 03:14 PM
Sort of want passive kmd
Sort of dont want to risk trading away kmd
CHMEX23-Aug-18 03:14 PM
For crypto maybe around 0.23kmd / crypto(edited)
And revs approx 0.01kmd/revs(edited)
Cryptoon23-Aug-18 03:23 PM
DEX?
I looked into it a while back and thought DEX/Jumblr were the best to buy now speculating on an increase in usage of both platforms
And now DEX is 50% cheaper so yea :p
grewalsatinder23-Aug-18 03:24 PM
Buy buy buy
passcombo.com 🏴☠🏴23-Aug-18 03:26 PM
was there any distrib of fee to DEX assets yet ? By far I remember there was only Supernet and tha other one like 5% sth(edited)
DEX value depends on DEX usage, which depends strongly on DEX promotion/marketing. Same story as in CEX - if you want more profit you need to fight for attraction.
Komodo Price Analysis: KMD Finds Support Trading Close To 12-Month Lows
$KMD
Full Story: https://t.co/CKI26x3KUP
Cryptoon23-Aug-18 04:55 PM
I like the KMD/BTC graph better
Congratulations! Bittrex has added US Dollar trading to your account*. You can now trade Bittrex’s US Dollar markets, including XRP-USD and ETC-USD (Ethereum Classic) which went live Monday August 20, 2018!
OMG thank you bittrex
So amazing and I feel so honored I can trade shitcoins against shitcoin USD


def check_connection(self):
try:
con = mysql.connector.connect(
host=self.host,
port=self.port,
user=self.user,
password=self.password
)
connected = con.is_connected()
con.close()
except Exception:
connected = False
return connected
def check_connection(self):
try:
con = self._get_connnection()
with closing(con) as con:
connected = con.is_connected()
except Exception:
connected = False
return connected


{% include "templates/includes/select_header.html" %}
No Jobs found for the matching criteria.
{% endif %} {% for j in jobs %}{{ j.job_detail[:300] }}
{{ j.country }} {{ j.service }} {% if j.owner == frappe.user -%} My Job {% elif j.my_bid -%} Bid {% endif %}
Use filters to show more jobs
{% endif %}


I study Spanish by playing The Legend of Zelda: Ocarina of Time in Spanish.
I always buy blue DSs, even though my favorite color is green.
I love to draw and make comics and stories, although I may or may not be good at it.
I feel really uncomfortable putting pictures of myself online, which is why I didn't do that. Tee hee.
I tried out that Brownie Recipe... not the world's best, but hey.
I can teleport because of...
Venteocho de Abril
What will people say after GG
This is the button to my lyrics website


|
|
||
|
Welcome to the the GAMYGDALA homepage! GAMYGDALA is an easy to use emotion engine for games.
It enables developers to simulate emotions in NPC's. GAMYGDALA can be used in a black-box game-AI independent manner.
We currently distribute a javascript version of the GAMYGDALA engine. Further, we have developed two Phaser Plugins and an example of how to use GAMYGDALA that builds upon level 9 of the Phaser tutorial (so do that one first to get to know Phaser).
This website includes info on how to use GAMYGDALA, as well as links to several running example games based on the Phaser game engine. To download locally all you need to start playing with it, as well as to contribute post requests and bugs, see the GitHub project called gamygdala GAMYGDALA is released under the MIT license. For questions, contact<EMAIL_ADDRESS>GAMYGDALA is based on the following publication, so please refer to it when you use it or find it useful (or check it if you want to understand how it works in depth): GAMYGDALA: an Emotion Engine for Games Alexandru Popescu, Joost Broekens, and Maarten van Someren (2014). IEEE Transactions on Affective Computing, 5(1), 32-44 Please note that the iconic facial expressions have been based on drawings made by Valentijn Visch (credits to him). For questions: contact<EMAIL_ADDRESS>Cheers, Joost Broekens, TU Delft Example gamesfriend_or_foe.html is an example of an "Emotional Arcade Game" where the bad guys' relations to you influences their behaviour.Is contains assets from the Phaser tutorial, and copyrights are thus owned by others not me. everyones_friend.html is an example of an "Emotional Puzzle Game" where your goal is to make everyone happy by giving them the price they desire. It contains copyrighted assets of others (e.g., Pixar, Nintendo), so please keep in mind that this is FOR EXAMPLE PURPOSES ONLY!! The gamygdala website and GitHub site will be updated soon to be better looking and to contain more examples. GAMYGDALA usage explainedHere we come to the emotion part you've been waiting for. This explains the use of the GAMYGDALA emotion engine.It is the textual explanation of the gamygdala_demo.html running example build on top of the Phaser tutorial level 9. You can find all code on GitHub. If you are a more practically oriented, learn-while-you-are-doing kind of person, we advise you to get the code and simply go through this example in code, as it contains the same info. Note that the plugin classes are Phaser specific, but if you dont use Phaser, you can use Gamygdala stand-alone. See the full javascript documentation for more details on classes, methods and useage. See the IEEE paper for more details on how gamygdala internally works. Let's start...First create the main emotion engine (using the Phaser plugin wrapper class, but this can be done directly too, see below).The engine is needed to interpret how events (Belief in Gamygdala terms) relate to goals resulting in emotions. The following three lines create one instance of Gamygdala that is used by all emotionAgents, and registers this as a Phaser plugin. gamygdalaPlugin=new Phaser.Plugin.GamygdalaWrapper();//create the Phaser plugin. game.plugins.add(gamygdalaPlugin);//add the plugin to the game, as required by Phaser emotionEngine=gamygdalaPlugin.getGamygdala(); //this gives you a ref to the actual underlying emotion engine, so that you can do what you need to do. If you don't need emotional decay (the fact that emotions decay,i.e., if a guy is angry he will slowly become less angry) to be managed by the Phaser plugin engine, then you don't need to do all this, instead you can do the following: emotionEngine=new TUDelft.Gamygdala(); //this simply creates an emotion engine without plugin support. From now on we can do everything we need with the emotionEngine object reference, as this is an object of type Gamygdala We create a new agent that represents the players emotional state. The method createAgent makes a new Agent, and registers it with gamygdala, and returns a ref to the agent. We store the ref in the Phaser player object for later convenience. player.emotionAgent=emotionEngine.createAgent('player'); Now let's give the player some goals: survival and winning are both good, but survival is better. emotionEngine.createGoalForAgent('player','survive', 1); emotionEngine.createGoalForAgent('player','win', 0.7); Alternatively, you can do the necessary goal management yourself instead of having gamygdala do it for you with the create method. This involves creating the goals and adding them to the agent(s) that have these goals (there can be more owners of the same goal so you can create group goals), and registering the goal to gamygdala. player.emotionAgent.addGoal(new TUDelft.Gamygdala.Goal('survive', 1)); player.emotionAgent.addGoal(new TUDelft.Gamygdala.Goal('win', 0.7)); emotionEngine.registerGoal(player.emotionAgent.getGoalByName('survive')); emotionEngine.registerGoal(player.emotionAgent.getGoalByName('win')); Now we are basically done for the player's emotions, apart from the fact we want to see something, so we add expression to the player. This is not really part of Gamygdala, just an easy and crude way of visualizing the emotions using Phaser game.plugins.add(new Phaser.Plugin.GamygdalaExpression(game, player, player.emotionAgent)); We are now done with setting up the player, but we want the monsters to be emotional guys too (to showcase relations NPC's can have with other NPC's or player agents) for (var i=0;i    //create the Gamygdala agent and store it in the bad_guy object for easy reference later, because when the player gets hit, we need to tell gamygdala who did it.    bad_guys.getAt(i).emotionAgent=emotionEngine.createAgent('monster'+i);    //add a relation between player and monster for fun, the first monster hates the player, the second one likes the player, the third hates, etc..    emotionEngine.createRelation('monster'+i, 'player',(i%2)*2-1);    //add expression to the bad guy so we see something    game.plugins.add(new Phaser.Plugin.GamygdalaExpression(game, bad_guys.getAt(i), bad_guys.getAt(i).emotionAgent));    //We don't need to set goals for these bad guys. In our setup they achieve nothing, just react to what happens with the player: feel pity, gloating, etc...    } Finally we need to tell gamygdala to decay emotional states over time (you don't stay angry, the intensity should go down right?) There are three ways to do emotional decay: 1. Either you use Gamygdala as standalone module, not requiring Phaser. In this case , Gamygdala will manage the emotional decay itself, and you need to tell it to do so. In the following line, you tell Gamygdala that every 100 Millis it decays the emotional state of all agents (using the default exponential decay with a factor of 0.8 per second). emotionEngine.startDecay(100); 2. You use the phaser plugin update to manage emotional decay, you should tell the plugin to do so using the next line. gamygdalaPlugin.phaserManagedDecay=true; 3. Finally, you can choose to call emotionEngine.decayAll() yourself when you need it. This is usefull if you have a lot of agents and need to be efficient, or, if some agents dont need decay at all, or you want to write your own timing routines In such a case you need to manage decay yourself using the desired timing, so you have to manage the interval yourself. Should you want, you can set the type (exponential or linear) and speed of decay [0..1], for example with a faster exp decay speed using: emotionEngine.setDecay(0.4, emotionEngine.exponentialDecay); Now you need to calibrate the overall emotional intensity. This is more an art than a science. If you notice the emotional intensities are too low in general, you set the gain higher, otherwise you set it lower. Gain must be between 0 and 20 How gain works can be seen in the Agent.getEmotionalState(); Normally, you decide the gain for the whole game, but if you know that certain NPC's need a higher or lower one, you can set the gain for each NPC separately using Agent.setGain(gainFactor); emotionEngine.setGain(10); If you want to enable debug output to the console, than uncomment the next line emotionEngine.debug=true; Some final remarks...GAMYGDALA is very flexible. You can make use of it in many different ways, and this example is only one way. For example, the degree of agent specific emotion control is flexible.To name a few ways in which you can do this:
This is true for new Agent(name), new Goal(name, utility), new Relation(...) and newBelief(...). This makes is very is to script/config the emotional setup, because you can simply use string refs to the objects. Also the Gamygdala.createAgent(..) and Gamygdala.createGoalForAgent(..) work with literal refs, so an alternative is to have a sequence of these be loaded from a txt file and executed. |


Ever want to check in to Foursquare but the 3G doesn't work well or you don't have wifi, now you can with Time Traveller
Just use the photos from your exotic location and use them to give you the time and location of your check-in


Rebuilding a Legacy
There's an interesting article up on AIGA about a massive artwork called Gastrotypographicalassemblage, created by typography guru Lou Dorfsman. After it was apparently discarded from its original location, the CBS building, the Center for Design Study has been trying to restore it to its original form.
Hooray!


Authenticated WAMP with Mozilla Persona
Open JavaScript console to watch output.
Login
Not logged in.
Sign in
Sign out
RPC Result
No result yet.


|
Space Station Rescue Souls
|
system that controls the nest entities. More...
#include <NestSystem.h>
Public Member Functions | |
| NestSystem () | |
| virtual | ~NestSystem ()=default |
| NestSystem (NestSystem const &)=default | |
| NestSystem & | operator= (NestSystem const &)=default |
| NestSystem (NestSystem &&)=default | |
| NestSystem & | operator= (NestSystem &&)=default |
| virtual void | update (app::time::seconds const &dt) override |
| Public Member Functions inherited from app::sys::BaseSystem | |
| BaseSystem () | |
| virtual | ~BaseSystem ()=default |
| BaseSystem (BaseSystem const &)=default | |
| BaseSystem & | operator= (BaseSystem const &)=default |
| BaseSystem (BaseSystem &&)=default | |
| BaseSystem & | operator= (BaseSystem &&)=default |
Private Member Functions | |
| void | spawnMissile (app::Entity const &nest, app::Entity const &target, comp::Location const &targetLocation, comp::Location const &spawn) |
| void | spawnPredator (comp::Location const &spawn) |
| void | onMissileDestruction (app::Registry ®istry, app::Entity const missile) |
Private Attributes | |
| std::forward_list< std::tuple< app::Entity const, app::Entity const, comp::Location const &, comp::Location const & > > | m_missileSpawner |
| std::shared_ptr< sf::Texture > | m_missileTexture |
Additional Inherited Members | |
| Protected Attributes inherited from app::sys::BaseSystem | |
| app::Registry & | m_registry |
system that controls the nest entities.
Definition at line 15 of file NestSystem.h.
| app::sys::NestSystem::NestSystem | ( | ) |
Definition at line 18 of file NestSystem.cpp.
|
virtualdefault |
|
default |
|
default |
|
private |
Definition at line 108 of file NestSystem.cpp.
|
default |
|
default |
|
private |
Definition at line 56 of file NestSystem.cpp.
|
private |
Definition at line 102 of file NestSystem.cpp.
|
overridevirtual |
Implements app::sys::BaseSystem.
Definition at line 27 of file NestSystem.cpp.
|
private |
Definition at line 43 of file NestSystem.h.
|
private |
Definition at line 44 of file NestSystem.h.


Actors: {{films.Actors}}
Where: {{films.Country}}
Year: {{films.Year}}
{{films.Plot}}
No films found for this country


Papers¶
This chapter is associated with the papers published in deep learning.
Models¶
Convolutional Networks¶
Imagenet classification with deep convolutional neural networks : [Paper]
Convolutional Neural Networks for Sentence Classification : [Paper]
Large-scale Video Classification with Convolutional Neural Networks : [Paper]
Learning and Transferring Mid-Level Image Representations using Convolutional Neural Networks : [Paper]
Deep convolutional neural networks for LVCSR : [Paper]
Face recognition: a convolutional neural-network approach : [Paper]
Recurrent Networks¶
Autoencoders¶
Extracting and composing robust features with denoising autoencoders : [Paper]
Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a Local Denoising Criterion : [Paper]
Adversarial Autoencoders : [Paper]
Autoencoders, Unsupervised Learning, and Deep Architectures : [Paper]
Reducing the Dimensionality of Data with Neural Networks : [Paper]
Generative Models¶
Core¶
Optimization¶
Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift : [Paper]
Dropout: A Simple Way to Prevent Neural Networks from Overfitting : [Paper]
Training Very Deep Networks : [Paper]
Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification : [Paper]
Large Scale Distributed Deep Networks : [Paper]
Representation Learning¶
Understanding and Transfer Learning¶
Learning and Transferring Mid-Level Image Representations using Convolutional Neural Networks : [Paper]
Distilling the Knowledge in a Neural Network : [Paper]
DeCAF: A Deep Convolutional Activation Feature for Generic Visual Recognition : [Paper]
How transferable are features in deep neural networks? : [Paper]
Reinforcement Learning¶
Human-level control through deep reinforcement learning : [Paper]
Playing Atari with Deep Reinforcement Learning : [Paper]
Continuous control with deep reinforcement learning : [`Paper <https://arxiv.org/abs/1509.02971`_]
Deep Reinforcement Learning with Double Q-Learning : [Paper]
Dueling Network Architectures for Deep Reinforcement Learning : [Paper]
Applications¶
Image Recognition¶
Deep Residual Learning for Image Recognition : [Paper]
Very Deep Convolutional Networks for Large-Scale Image Recognition : [Paper]
Multi-column Deep Neural Networks for Image Classification : [Paper]
DeepID3: Face Recognition with Very Deep Neural Networks : [Paper]
Deep Inside Convolutional Networks: Visualising Image Classification Models and Saliency Maps : [Paper]
Deep Image: Scaling up Image Recognition : [Paper]
Long-Term Recurrent Convolutional Networks for Visual Recognition and Description : [Paper]
Object Recognition¶
ImageNet Classification with Deep Convolutional Neural Networks : [Paper]
Learning Deep Features for Scene Recognition using Places Database : [Paper]
Scalable Object Detection using Deep Neural Networks : [Paper]
Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks : [Paper]
OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks : [Paper]
CNN Features Off-the-Shelf: An Astounding Baseline for Recognition : [Paper]
What is the best multi-stage architecture for object recognition? : [Paper]
Action Recognition¶
Long-Term Recurrent Convolutional Networks for Visual Recognition and Description : [Paper]
Learning Spatiotemporal Features With 3D Convolutional Networks : [Paper]
Describing Videos by Exploiting Temporal Structure : [Paper]
Convolutional Two-Stream Network Fusion for Video Action Recognition : [Paper]
Temporal segment networks: Towards good practices for deep action recognition : [Paper]
Natural Language Processing¶
Distributed Representations of Words and Phrases and their Compositionality : [Paper]
Efficient Estimation of Word Representations in Vector Space : [Paper]
Sequence to Sequence Learning with Neural Networks : [Paper]
Neural Machine Translation by Jointly Learning to Align and Translate : [Paper]
Get To The Point: Summarization with Pointer-Generator Networks : [Paper]
Attention Is All You Need : [Paper]
Convolutional Neural Networks for Sentence Classification : [Paper]
Speech Technology¶
Deep Neural Networks for Acoustic Modeling in Speech Recognition: The Shared Views of Four Research Groups : [Paper]
Towards End-to-End Speech Recognition with Recurrent Neural Networks : [Paper]
Speech recognition with deep recurrent neural networks : [Paper]
Fast and Accurate Recurrent Neural Network Acoustic Models for Speech Recognition : [Paper]
Deep Speech 2 : End-to-End Speech Recognition in English and Mandarin : [Paper]
Deep Speech 2 : End-to-End Speech Recognition in English and Mandarin : [Paper]
A novel scheme for speaker recognition using a phonetically-aware deep neural network : [Paper]


Players
Officials
Tournaments
CS 390 Tournament Style Database
Results For: {{tournament.1}}
Enter Information to Add a Result to: {{tournament.1}}
Player Name:
{% for p in players %}
{{p[1]}} {{p[2]}}
{% endfor %}
Round Number:
Match Number:
Result:
Win
Lose
Draw
Score:


--- layout: base-en id: index title: Bitcoin ---
Bitcoin is a digital currency, a protocol, and a software that enables
Bitcoin uses peer to peer technology to operate with no central authority; managing transactions and issuing Bitcoins are carried out collectively by the network. Through many of its unique properties, Bitcoin allows exciting uses that could not be covered by any previous payment systems.
The software is a community-driven free open source project, released under the MIT license.


|
Bug-reproducer Assistant Python kernel
1.0
Código Python de kernel del Bug-reproducer Assistant
|
Public Member Functions | |
| def | __init__ |
| def | generateEquivalentProgram |
Public Attributes | |
| programExecution_ | |
| tokensGenerator_ | |
| projectName_ | |
Static Public Attributes | |
| int | ALL_LEVELS = 1 |
Generates an equivalent program, or unit test, starting from a Json database.
| def bug_reproducer_assistant::code_generator::CodeGenerator::__init__ | ( | self, | |
| callGraphStream, | |||
projectName = None |
|||
| ) |
| self | The CodeGenerator to construct. |
| callGraphStream | File object with the call graph. |
| projectName | Bug-reproducer Assistant project name. Constructor. |
| def bug_reproducer_assistant::code_generator::CodeGenerator::generateEquivalentProgram | ( | self, | |
| fp, | |||
searchLevel = ProgramExecution.MIN_LEVEL , |
|||
sourceType = GeneratedSourceType.MAIN_FILE |
|||
| ) |
| self | The CodeGenerator. |
| fp | File object with the input Json database. |
| searchLevel | Function nesting level to filter. Use ALL_LEVELS to generate all the calls. |
| sourceType | The type of equivalent code to generate (see GeneratedSourceType). Generate an equivalent source code for the program. It may be an equivalent program or unit test. And the searchLevel is a filter for function nesting level. The default is ProgramExecution.MIN_LEVEL (only root calls). Use ALL_LEVELS to get all the functions, although the equivalent program may call a nested function more than once, for instance: Original code: def f(): print 'f' def g(): f(): g() Equivalent code (with searchLevel = 0): g() Equivalent code (with searchLevel = ALL_LEVELS): g() f() The latter is not equivalent to the original program, because f() is called twice. But it may be useful if the tool is used as a "logger": the results are more complete. |


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 2
A classy dinner for two that's packed with healthy ingredients. Quail is strongly flavoured, like duck, but low in fat, like chicken and is quick to cook. Here it’s served with a delicious sauce with bacon, lentils and butternut squash.
Preheat the oven to 190C/375F/Gas 5.
Take four tablespoons of the diced butternut squash and blanch for 2-3 minutes, or until cooked but still firm.
Put the remaining butternut squash in a roasting tin with the garlic cloves and a little olive oil and season with salt and pepper. Roast for 20 minutes, or until very soft.
Transfer to a blender and add half the vegetable stock and two tablespoons of olive oil. Blend to a smooth purée, adding more stock if necessary. Taste and add more salt and pepper as required.
Season the spatchcocked quails with a little salt. Heat a tablespoon of olive oil in an ovenproof pan and brown the quail on all sides. This will only take 2-3 minutes.
Put the pan into the oven and roast for about four minutes. Remove from the oven and rest for five minutes. Check the meat is cooked through – the juices should run clear when the meat is cut into. The breast and legs might need more cooking. If so you can finish cooking them in the sauce.
Use the same pan to fry the lardons until crisp then set them aside. Fry the shallots until softened, add the chicken stock and cook until reduced in volume to a thick sauce (add the quail breasts and legs here if they need to cook a bit more). Put the cooked bacon back into the pan and add the vinegar and cooked lentils.
Fry the four tablespoons of blanched butternut squash in a little oil until golden-brown. Season with salt, pepper and the chopped rosemary.
Spread some purée on each serving plate, add some pieces of butternut squash, lardons and lentils then the quail, and the salad leaves. Serve a little extra sauce on the side.


The SuperDraw user macro is an enhanced polyline editor. It is possible to add new points at the end of the polyline or between two existing points in the polyline. It is also possible to move or delete individual points in he polyline. The whole polyline can be translated or deleted. The created polyline can be made either open or closed.
Input Ports
Name Type Description parent UIconnection Connection to the User Interface. obj_in GDobject_templ Object that defines canvas dimensions. view_in GDview_templ Output of the viewer; connection to the current object. Parameters
Name Type Description UI Control command int Current drawing type. Radio Box type int Defines if polyline should be closing. Toggle Output Ports
Name Type Description out_points float[][2] Coordinates of the created polyline points. out_mesh Polyline Mesh Points and connectivity which represent the data. out_obj DefaultObject Directly renderable output object.
The SuperDraw macro allows the user to generate and edit a polyline in 2D space. As such it is similar to the Click_Sketch AVS/Express macro. However the SuperDraw macro is a much more comprehensive macro. It allows the user to construct a polyline by sequentially adding points at the end of the polyline. However it also allows the user to add points in between two existing points. It allows the user to move or delete existing points and translate the whole polyline. Finally the polyline can be opened or closed at any point. The SuperDraw macro could be used for many different purposes. For instance it could be used to segment an image by hand. The other macros in this project(LineResampler and RegionResampler) are intended to build on this macro and extend its functionality. They provide ways of generating more points from the a polyline hence allowing it to be used as, for example, a probe.
The SuperDraw macro is actually used by first selected a drawing operation and then holding down
Ctrl
and right clicking in the main viewer. It is possible to either click twice at the start and end of a segment or click and drag. If you click and drag a 'rubber-band' will appear to indicate where the current segment will be created. However with both of these methods it is essential that you always hold downCtrl
and use the right mouse button. If you do not do this then nothing will happen.If you are moving or deleting points then the point nearest to the mouse click will be either moved or deleted. The user inteface also provides an option for deleting all points of the polyline and translating the line in the 2D space. Translating the line is also achieved by
Ctrl
right dragging. Finally an option is available to close the curve. This simply connects the first point of the polyline to the last point.
parent : UIconnection
This is the port that automatically connects the user interface of the module to the user interface of AVS/express.
obj_in : GDobject_templ
DataObject input that is used to get a coordinate space to draw on. If, for example, a picture is being segmented this input will be the image.
view_in : GDview_templ
Output of the 2D viewer that is being used for drawing input. This input is used to received the inputs that the user makes by clicking the mouse in the viewer window.
command
Integer parameter that is used to specify which drawing operation should be performed. This parameter can have the following values:
- Inactive : Disables the SuperDraw macro.
- Append point : Adds a point at the end of the polyline.
- Add point between : Adds a point between two existing polyline points.
- Move point : Moves an existing point.
- Delete point : Deletes an existing point.
- Delete all points : Deletes entire polyline, and automatically sets SuperDraw macro to be inactive.
- Translate line : Moves entire polyline.
type
Integer parameter that specifies if the polyline should be closed. If set the last point in the polyline will be connected to the first point and a closed loop will be formed.
out_points : float[][2]
This output represents all points of the polyline. Its values are saved in 2D coordinate space and it can be used for further processing of the polyline. The other macros in this project accept this output.
out_obj : DefaultObject
This port is suitable for direct connection to a viewer. A 2D viewer is recommended since the generated polyline only has 2D coordinates.
out_mesh : Polyline Mesh
This mesh output represents the polyline. It is a combination of the points output and the connectivity between the points. It can be input into other AVS/Express modules for further processing of the polyline.
The SuperDrawEg example application illustrates how the SuperDraw macro can be used. It reads an image and then allows the user to draw on the image.
xp_comm_proj/draw/drawmods.v Creates the DrawMods library containing the low-level modules RegionResamplerCore, LineResamplerCore, SuperDrawCore and the parameter blocks DrawLineParams and LineResamplerParams.
xp_comm_proj/draw/drawmacs.v Creates the DrawMacs library containing the user interface macros SuperDrawUI and LineResamplerUI, the functional macros SuperDrawFunc and LineResampleFunc, and the user macros SuperDraw, LineResampler and RegionResampler.
xp_comm_proj/draw/drawapps.v Creates the DrawApps library containing the example applications SuperDrawEg, LineResamplerEg, and RegionResamplerEg.
The low-level DrawMods library containing the low-level modules does not specify a process. By default the express process will be used.
Mario Valle, AVS Inc.
Anja Bindrich, Andrew Dodd, International AVS Centre


Correctness is clearly the prime quality. If a system does not do what it is supposed to do, then everything else about it matters little. --Bertrand Meyer [source]


GOVERNMENT OF THE DISTRICT OF COLUMBIA [INSERT AGENCY NAME] Open Government Report 2014 To institutionalize a culture of transparent and open government, accountability, and to expand opportunities for resident participation and collaboration, this Report describes how the Office of Motion Picture and Television Development has and will continue to develop and enhance transparency, public participation, and collaboration. In accordance with Mayor’s Order 2014-170, this report addresses the following topics: 1) Transparency The Office of Motion Picture and Television Development (MPTD) is committed to sharing all agency public information documents including press releases, a listing of current film events, a listing of career and casting opportunities, updated fact sheets regarding productions that have filmed in the District over the last several years, and relevant production information for current multimedia projects that have approved permits to film in the District on the MPTD web site. MPTD also shares or provides links to information regarding MPTD’s staff, performance plans, budget, and permit policies on the Open Government page of its web site. MPTD meets obligations pursuant to the District’s Freedom of Information Act (FOIA) and Open Meetings Act by clearly stating on our web site how to file a FOIA request, the contact information for the FOIA Officer, and providing a link to the FOIA Reading Room. MPTD also has a policy of responding to FOIA requests within the designated response time of 15 business days, unless it is determined that the request qualifies for an extension of 10 business days. The Office of Motion Picture and Television Development is working closely with the Office of the City Administrator (OCA) and the Office of the Chief Technology Officer (OCTO) to identify a significant number of datasets that OCA and OCTO expect to publish online later this year. If no dataset from the Office of Motion Picture is selected to be included in this 2014 release, we will continue to work with OCA and OCTO to identify datasets appropriate to publish in 2015. In the future, requirements for open data reporting will be provided by the Chief Data Officer. 2) Public Engagement and Participation MPTD values the feedback and welcomes the engagement and input of its stakeholders. As a result, MPTD regularly hosts and participates in meetings with each stakeholder group including filmmakers, location and production managers, and individuals seeking to break into the industry of film and television. MPTD identifies 1 these stakeholders through referrals, networking, and its own research of film and media professionals in the District. MPTD is also committed to keeping the community informed of the work that we do through press release postings on our web site as well as through social media platforms and our quarterly newsletter. We invite our followers on Twitter and Facebook to offer feedback on the initiatives we launch and tell us how we can better serve our stakeholders. Additionally, whenever a multimedia production has received a permit to film, we alert the necessary businesses, ANC commissioners, and Councilmember offices via email and a letter to ensure that they and their constituents are made aware of any disruption that may be caused due to filming. 3) Collaboration Many of MPTD’s large scale projects require the cooperation of other District government agencies including the Department of Transportation (DDOT) and the Metropolitan Police Department (MPD) as well as federal agencies such as the National Park Service (NPS) and the U.S. Capitol Police. Therefore, it has been extremely important for MPTD to develop relationships with representatives of these agencies to better service our stakeholders. Over the last year, MPTD has sought to build better relationships and engage agency partners through regular meetings and other forms of communication. MPTD also is in the process of working concurrently with the Office of the Chief Technology Officer (OCTO) and other agency partners to design and implement a customized internal D.C. government database that will make the permitting process more efficient and reliable for our customers. Additionally MPTD, under the new direction of Pierre Bagley, is currently working on creating a networking and partnership strategy that identifies important external partnerships and charts how MPTD will manage and maintain ongoing relationships with key external partners moving forward. 2


HTML notes
HTML: Hypertext markup language
-Web invented in the 1990s; all pages link together
-Browser makes requests to the internet via HTTP to servers, which respond with files that the browser displays
-Text content: infromation you see
-Markup: what it looks like
-References to other documents: images and videos
-Test out code at link
Opening tags and closing tags; both tags plus contents within is called an element
- B tag is for bold
- em tag is for italics
- If you don’t close tag; everything after is bolded/italicized
- a is for anchor
- Used for making links
- Followed by an attribute name, value, and then contents
- img is for image
- Src and alt are attributes; alt is what to display if broken request
- Img doesn’t have any content, so no closing tag; this is called a void tag, a tag that has no content
-
- Lines
- br is a line break to make text go onto next line; also a void tag
- p is for paragraph; need closing tag after content
- Br just puts to next line whereas p tag makes an invisible box; br is an inline element while p is a block element; latter creates blocks on the screen
- Spaces and returns will not be registered
- Span and div
- Span can be used to give CSS styles to contents; inline element
- Div does the same but as a block element
Thus basic HTML vocab consists of tags, elements, and attributes


Creating or updating your Control Repo¶
A Control Repo contains the modules, hieradata, and roles/profiles required for an infrastructure, and keeping it all in a git repo creates a workflow for updating and developing on your Puppet infrastructure.
Change into the directory you’re using from above and run git init
to create
a control repo. Puppet, Inc has some great `documentation of a control repo online`_.
In order to use r10k or Code Manager with SIMP, you must create or update your Control repo with the following components:
| File/Directory | Description of changes |
|---|---|
| Puppetfile | Add SIMP Puppet Modules |
| environment.conf | Configures the alternate module path for rsync and pki |
| hieradata/ | Directory that needs to contain SIMP top-scope hiera data |
| hiera.yaml | Configured with simp::scenario settings and compliance map |
Adding SIMP Modules to the Puppetfile¶
We keep an up-to-date Puppetfile in the core of our repo, which you can download using this snippet:
$ curl -o Puppetfile https://raw.githubusercontent.com/simp/simp-core/6.0.0-0/Puppetfile.stable
The example Puppetfile is labeled stable, meaning that the versions of the
modules it contains are the ones contained in the last SIMP release. You can go
to any previous release and download a Puppetfile with references to older
modules from the git history of the simp-core
repo.
Our Puppetfile pulls down every dependency SIMP needs, which is currently
contains more than just modules. Open up the Puppetfile
that was just
downloaded and remove the lines from moduledir 'src'
to
moduledir 'src/puppet/modules'
. That should just leave the Puppet modules.


Man Bags Jail Term For Stealing Boxers
by Oyindamola OlubajoFor stealing thirty four pieces of boxers, a 24-year-old man, Tobechukwu Anyanwu has been sentenced to two years imprisonment by a Magistrate Court in Isolo, Lagos.
Anyanwu was handed over to Ago Divisional Police Station, after he stole the boxers valued N30,600 at the rate of N900 each from a supermarket at Ago-Palace Way, Isolo LCDA.
The young man was said to have committed the crime on Monday, 25th of November.
According to the prosecutor, Inspector Oje Uagbale, the accused was caught by the security lady manning the entrance of the supermarket who noticed he hid something underneath his clothes and subsequently handed him over to the police.
However, Anyanwu pleaded guilty to the offense punishable under section 287 criminal law, volume 44 of Lagos State 2015.
The presiding Magistrate, Olufunmilayo Teluwo sentenced him to two years imprisonment.


Javascript Basic Exercises
Ex 1: Current Time
Ex. 2: Print Current Page
Ex. 3: Get Current Date
Ex. 4: Rotate The String
Rotate Me
Ex. 5: All Words To Caps


Happy Hour runs every day! Join us Tuesday through Saturday 2pm - 6pm, and all day Monday & Sunday for the happiest hours of the day. Featuring $2 off all craft beers on tap, wine by the glass, and all our Bar Bites. Check out our Menu for more.
--- permalink: fact/fact-06/ layout: index title: Happy Hour show_call_to_action: false ---
Happy Hour runs every day! Join us Tuesday through Saturday 2pm - 6pm, and all day Monday & Sunday for the happiest hours of the day. Featuring $2 off all craft beers on tap, wine by the glass, and all our Bar Bites. Check out our Menu for more.


Now everyone can get the best out of both digital and traditional money, the easy way! Get online banking account, worldwide-issued bitcoin debit cards, cheap money transfer and more in one place.
Get all the benefits of traditional and digital banking with the easy-to-use Wirex card, app, and account.


Amet - Flattening a Python dictionary as environment variables
I recently had to build an ETL job in Python that was initially going to be deployed on AWS. Little did I know that a last minute change from AWS to Heroku would cause me to change how the job’s configuration was going to be read significantly.
A bit of Background
ETL jobs do not usually require much interaction. You pretty much just need to
figure out how to pass it some configuration values (such as a database
connection string). You can do this in several ways, but probably the easiest
are to either read everything from sys.argv
or to use a configuration file. I
tend to go for the latter, as I cannot be bothered to parse CLI arguments, plus
it is a lot easier to share and swap configuration files instead of command
line arguments. As for configuration files I tend to favor JSON over other
formats, as it is easy to read/write by humans, allows for lists and nested
objects and the json
module makes reading these files trivial.
As I said before, this was initially going to run on AWS, but it was later decided that it would be run in Heroku. This is usually not a problem, unless you decided that your configuration would reside on configuration files.
The problem
The downside to configuration files is that since you usually keep secret values in them you should not add them to version control systems such as git (yes, even if your repository is private). This can become a problem with some environments such as Heroku where you have no way of pushing you config files. You should, in this cases, use environment variables for configuration.
Changing from configuration files to environment variables poses several obvious problems. First and foremost some code will have to be changed to accommodate this new requirement. Not only that, working with environment variables is not nearly as user friendly as a JSON file, but worst of all, environment variables are “flat”, meaning that you cannot have nested values (and no, trying to encode something like a JSON object into an environment variable isn’t even an option).
The solution
The solution I came up with was relatively simple. I wrote a function that will attempt to fill a prototype configuration dictionary with the expected configuration values. It does this by iterating through the dictionary and, for every key whose value is not a dictionary, looks for an environment variable whose name is the same as the key. However, if the value is a dictionary, it will recursively call itself and do the same, although in this case the key containing this dictionary will be taken into account when building the variable’s name.
A simplified pseudocode version of the function looks like:
As you can see this has its own problems. Without any extra work, any int
values will not be converted automatically, probably making it infuriatingly
inconsistent. This method also does not support lists without doing some
probably ugly things. Finally, in some cases names may clash, although that
would be highly improbable (and would probably mean you’re using terrible
names for keys anyway).
Up until this point, however, we only cared about reading values and not writing them. Unless we want to create those environment variables manually (which I do not recommend) we also need some code to generate the key value pairs for us. This is even simpler than reading.
A simplified pseudocode version of the function looks like:
After we have our dictionary of variable names as keys we can either
export
them or (in my case)
call the Heroku API
so they are set in my app’s configuration.
Amet - The solution, packaged.
I wrote a library in Pythom, Amet, that packages these two functions so that they can be used from any Python script. The code with instructions can be found here.
Amet provides two functions, load_from_environment
and dump
to help with
reading and creating any relevant environment variables. It also provides some
extras such as automatic parsing of types and some error handling. This means
that if you are expecting an environment variable to be an int
, float
, or
bool
value, it will be automatically converted for you
The library is still pretty green, so any contributions are more than welcome.
I hope it works well for you and saves you time and headaches 😁.


WITNESS LIST
Licensing & Administrative Procedures Committee
April 16, 2013 - 12:00 PM or upon final adjourn./recess
For:
Porter, Scott (Self; Tax Assessor Collectors Association)
South, Brent (Hunt County Appraisal District, Texas Assc. Of Appraisal Districts)
Registering, but not testifying:
For:
Caraway, Luanne (Self; Tax Assessor Collector Association)
On:
Kuntz, William (Bill) (Texas Deprtment of Licensing and Regulation)
For:
Reddy, Vikrant (Texas Public Policy Foundation)
Registering, but not testifying:
For:
Fisher, Jon (Associated Builders and Contractors of Texas)
On:
Kuntz, William (Bill) (Texas Deprtment of Licensing and Regulation)
For:
Roche, Kenneth (Gulf States Toyota, Inc)
Registering, but not testifying:
For:
Borskey, Mark (Texas Recreational Vehicle Association)
Braziel, Robert (Texas Automobile Dealers Association)
Chavez, Andrea (Texas Motorcycle Dealers Association)
Leo, Myra (Alliance of automobile manufacturers)
On:
Brewster, Whitney (TxDMV)
Harbeson, William (Txdmv)
Vandergriff, Victor (TXDMV)
For:
Griffin, Amanda (Self; Texas turf irrigation association)
Guz, Karen (San Antonio Water System)
Against:
Reddy, Vikrant (Texas Public Policy Foundation)
1
WITNESS LIST
Registering, but not testifying:
For:
Miller, Sid (Texas nursery and landscape asociation)
Morris, Joe (Texas Turf Irrigation Assoc.)
Patterson, TJ (City of Fort Worth)
Reaves, Jim (Texas Nursery & Landscape Association)
Walker, Jennifer (Sierra Club, Lone Star Chapter)
Against:
Connett, Brent (Texas Conservative Coalition)
Matocha, Dustin (Texans for Fiscal Responsibility)
On:
Garrett, Candy (TCEQ)
For:
Rickers, Emily (Alliance for Texas Families)
Registering, but not testifying:
Against:
Pendleton, D.J. (Texas Manufactured Housing Association)
On:
Garcia, Joe (Manufactured Housing Division, Texas Department of Housing and Community
Affairs)
For:
Barajas, Richard (Houston Police Department)
Harris, Todd (Houston Police Department)
Against:
Reddy, Vikrant (Texas Public Policy Foundation)
Registering, but not testifying:
For:
Jones, James (San Antonio Police Department)
Against:
Connett, Brent (Texas Conservative Coalition)
Against:
Ormand, Bruce (Texas automotive recyclers association)
Registering, but not testifying:
On:
Blackwell, Monica (TxDMV)
2
WITNESS LIST
On:
Harbeson, William (Txdmv)
For:
Hammerlein, George (Harris county clerk's Office)
Registering, but not testifying:
On:
Wassdorf, Lorna (Secretary of state)
For:
Garey, Glen (Texas Restaurant Association)
Against:
Gray, Alan (Licensed Beverage Distributors)
Liebmann, Will (Republic National Distributing Company)
Registering, but not testifying:
For:
Homer, Mark (Texas Bar and Night Club Alliance)
Lively, Lance (Texas Package Stores Association)
Rydman, John (Self; Specs Wines spirits & finer foods)
Against:
Szyndrowski, Dale (Distilled Spirits Council of U.S.)
Townes, Ralph (Licensed beverage distributors)
On:
Graham, Thomas (Texas Alcoholic Beverage Commission)
For:
Koerth, Teri (Self; Airline Improvement District)
For:
Barajas, Richard (Houston Police Department)
Harris, Todd (Houston Police Department)
Solomon, Rex (Self; Houston Jewelry, Texas Jewelers Association and Texas Retailers
Association)
Against:
Hulsey, Steve (Self; Gold buyers of east texas)
Mcmurtry, Allan (Self)
Reddy, Vikrant (Texas Public Policy Foundation)
3
WITNESS LIST
Registering, but not testifying:
For:
Jones, James (San Antonio Police Department)
Volkening, Ronnie (Texas Retailers Association)
Against:
Connett, Brent (Texas Conservative Coalition)
4


--- layout: post title: Citrix Acquires Flexible Social Collaboration Service Podio date: '2012-04-11T09:12:10-07:00' tags: tumblr_url: http://alexhwilliams.tumblr.com/post/20907366760/citrix-acquires-flexible-social-collaboration-service ---
http://bit.ly/HHsLcw


Using our convenient web app, you'll get all the power of gFood without having to call your order in. Order in your pajamas, order 24 hours a day, order on Christmas, we're here to serve you.
You've never seen ordering this quick.  We'd ask what that is, but gFood respects your privacy.
Money: You've got it, we want it. But let it never be said we're not incredibly fair! Burger sales? Check. Pizza sales? Check. Burger and pizza sales?? Check, check, check! We seriously can't stop making deals.


#673790 — python-prettytables: Broken API on new version
Investigated the current state, then re-assigned the bug to the only
still-broken package python-cloudservers. People who (can) use
python-cloudservers and want to change it to the current python-prettytables
API can help here.


My Favorite Websites
This page is under construction.
My Recommend Websites
This page is under construction.I will be back soon.


{%extends "base.html"%} {%block content%} {% from "nav_bar.html" import nb as nb%} {{nb()}}
{{i.sql}}


{% extends "account/base.html" %} {% load i18n %} {% block head_title %}{% trans "Verify Your Phone Number" %}{% endblock %} {% block content %}
{% blocktrans %}We have sent an SMS to you for verification with a verification code. Enter that code to complete verification process. {% endblocktrans %}
{% endblock %}


the and for The are with SARS-CoV- {background drug coronavirus that margin was {border-style protease px;} virus #ffffff;} RNA SARS-CoV from CLpro been viral inhibitors have potential Med. also has COVID- antiviral novel treatment Chem. CoV PLpro human into protein respiratory structure which binding host were (FigureÂ SARS approved inhibit not other receptor repurposing FigureÂ acute current development including px; rapidly several severe than their will {font-family ACE but font-size infection might more rather some syndrome target viruses Drug N/A RdRp against broad-spectrum can currently double; infected large less much outbreaks papain-like potent proteins recently sequence structural such treat (), Elsevier Res. active agreement border-color border-width cells cellular clinical compounds could developed different disease drugs enzyme future information interaction key medicine medicines million new noncovalent rapid shown small solid; thus very {font-style {font-weight (grant -nCoV Chinese CoVs. Covid- Cys Favipiravir For HIV However, Rev. SARS-CoV-. Scheme Wuhan active-site activity additional basis because between biological biology bold causing centre chloroquine common courier; described develop discovery domain em; entry evaluation extensive fight genome high identified inhibition inhibitor only outbreak pandemic pandemic. pneumonia polymerase promising protein, pt;} research resource short-term structure, targeting therapies, they through world â€"


DISMISSAL
§806-56 Nolle prosequi. No nolle prosequi shall be entered in a criminal case in a court of record except by consent of the court upon written motion of the prosecuting attorney stating the reasons therefor. The court may deny the motion if it deems the reasons insufficient and if, upon further investigation, it decides that the prosecution should continue, it may, if in its opinion the interests of justice require it, appoint a special prosecutor to conduct the case and allow the special prosecutor a fee. Section 802-5(b) relative to fees allowed counsel assigned by the court for a defendant is made applicable to fees of special prosecutors appointed hereunder. [L 1876, c 40, §5; am L 1903, c 39, §6; RL 1925, §4029; am L 1931, c 73, §1; RL 1935, §5525; RL 1945, §10830; RL 1955, §258-40; HRS §711-56; ren L 1972, c 9, pt of §1; gen ch 1985; am L 1987, c 283, §67]
Rules of Court
Dismissal by prosecutor, see HRPP rule 48(a).
Case Notes
A nolle prosequi of an appeal from a magistrate before trial is no bar to a subsequent trial. 3 H. 339 (1872).
For historical background: 6 H. 718 (1889).


Abstract bit-writer.
More...
#include <bit-io.hpp>
|
| virtual void | write (uint64_t bits, int width)=0 |
| | Write given number of least significant bits of a given number in big endian order. More...
|
| |
| virtual void | write_str (const char *str) |
| | Write a given null-terminated string. More...
|
| |
| virtual void | write_buf (const uint8_t *buffer, size_t bits) |
| | Write first n bits from a given buffer. More...
|
| |
| virtual int | write_gamma (uint64_t n) |
| | Write a gamma-encoded number. More...
|
| |
| virtual int | write_delta (uint64_t n) |
| | Write a delta-encoded number. More...
|
| |
| virtual void | flush ()=0 |
| | Flush buffered data. More...
|
| |
| virtual void alzw::bwriter::flush |
( |
| ) |
|
|
pure virtual |
Flush buffered data.
All buffered bits will be written. Note that complete bytes must be written, this may cause to write more bits in case the last bits does not form a complete byte.
Implemented in alzw::stream_bwriter.
| virtual void alzw::bwriter::write |
( |
uint64_t |
bits, |
|
|
int |
width |
|
) |
| |
|
pure virtual |
Write given number of least significant bits of a given number in big endian order.
- Parameters
-
| bits | bits |
| width | number of bits |
Implemented in alzw::stream_bwriter.
| void bwriter::write_buf |
( |
const uint8_t * |
buffer, |
|
|
size_t |
bits |
|
) |
| |
|
virtual |
Write first n bits from a given buffer.
- Parameters
-
| buffer | buffer |
| bits | number of bits to write |
| int bwriter::write_delta |
( |
uint64_t |
n | ) |
|
|
virtual |
Write a delta-encoded number.
- Parameters
-
- Returns
- number of written bits
| int bwriter::write_gamma |
( |
uint64_t |
n | ) |
|
|
virtual |
Write a gamma-encoded number.
- Parameters
-
- Returns
- number of written bits
| void bwriter::write_str |
( |
const char * |
str | ) |
|
|
virtual |
Write a given null-terminated string.
- Parameters
-
The documentation for this class was generated from the following files:


Spoilers: EastEnders' Jake Wood says 35th anniversary will be 'jaw-dropping'
EastEnders legend Jake Wood has promised that the soap’s storylines will be filled to the brim with drama in celebration of its upcoming 35th anniversary in February 2020. The actor, who plays Max Branning, told Piers Morgan, Susanna Reid and Good Morning Britain audiences that the programme is on ‘real high’ at the moment and won’t be slowing down anytime soon.
Susanna probed: ‘So EastEnders, 35 years, a significant anniversary next year. Are there going to be some extraordinary, jaw-dropping, edge of your seat, duff duff moments?’
Advertisement Advertisement
Jake confirmed: ‘Yes, undoubtedly there will be.’
He continued: ‘I think we’re on a real high at the moment, EastEnders. We’ve got a new boss Kate Oates and Jon Sen. She’s [Kate] got an amazing great track record of turning these shows around.
‘At the moment, we’ve got great actors, great characters, great storylines. I think when you have a combination of all those three things, we’ve got a great soap opera.’
This exciting news comes just days after Jake exclusively revealed to Metro.co.uk that EastEnders has got a phenomenal 12 months lined up for us.
This year’s really strengthened what we’ve got, and Christmas and the 35thanniversary next year — it’s going to be an incredible six months, or year, ahead,’ he enthused.
Speaking about the upcoming milestone, Jake told us: ‘I think what Kate has done has really upped the game and really brought us to the top — and as far as I can see it’s going to continue, the scripts we’re getting are just amazing, I know what the plans are for the 35th— they’re going to be some of the most exciting scenes we’ve ever done.
‘I’m really looking forward to it!’
Roll on February!
Advertisement Advertisement
Good Morning Britain airs weekdays at 6am on ITV and EastEnders continues tonight at 7.3pm on BBC.
Got a showbiz story?
If you've got a story, video or pictures get in touch with the Metro.co.uk Entertainment team by emailing us<EMAIL_ADDRESS>calling 020 3615 2145 or by visiting our Submit Stuff page - we'd love to hear from you.


Welcome to Dummy Python API Docs!¶
Overview¶
A test class that walks like and RDD, talks like an RDD but is just a list.
Contains 3 primary classes:
- SparkConf
- SparkContext
- RDD
All of which implement the exact same API as the real spark methods, but use a simple python list as the actual datastore. Many functions such as the Hadoop API, partitioning, complex operations, and other things are not implemented. See below for detailed list of implemented functions and their caveats.
Note that for now this is experimental, and may later be useful for testing or development, but anything developed using this should always be checked on real spark to make sure that things actually work there. Because none of the code is actually distributed in this environment, some things will behave differently.
It is intended that this library can be used as a drop in replacement for a real spark context, without erroring out but maybe not actually doing anything (in the case of irrelevant configuration options, for example).
Currently there is no support for the dataframe api, or for that matter most features of anything, very much still a work in progress.
Example¶
A quick example:
from dummy_spark import SparkContext, SparkConf
sconf = SparkConf()
sc = SparkContext(master='', conf=sconf)
rdd = sc.parallelize([1, 2, 3, 4, 5])
print(rdd.count())
print(rdd.map(lambda x: x**2).collect())
yields:
5
[1, 4, 9, 16, 25]
Contents:
Core classes:¶
Main entry point for Spark functionality.
A Resilient Distributed Dataset (RDD), the basic abstraction in Spark.


Lorem ipsum dolor sit amet, consectetur adipisicing elit. Excepturi sint sapiente deserunt esse, repellendus aut praesentium ipsa a ipsum possimus ea ex maxime nesciunt, dolorem vitae modi. Ad, incidunt consequuntur.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Ipsam nihil iusto enim, excepturi consequuntur asperiores ducimus labore repudiandae optio error magni, quam cupiditate aperiam suscipit, aut. Culpa exercitationem qui, ducimus, dolor dolorum nesciunt, veritatis cumque modi veniam sint fuga temporibus hic, vel vero eaque! Autem quis laudantium ea. Accusamus.
We simply provide information about the clubs and restaurants available in a given area at the convenience of the client.
Before setting out for the night, you, the user, is able to identify the go to places in their area, the kind of experience to expect and also view comments and reviews of other users based on their experience in the said place.
This will save the user both time and money as they will have an idea of what to expect firsthand before its too late.


{% extends 'blog/base.html' %} {% block content %}
I have mailed you instructions for resetting your password
If you didn't receive it verify you entered the correct email and / or check your spam folder


About
About the church
The Man of God Phronesis is the founder and the President of Believers Nation World Wide International which was established in 2016.
He is known for revealing the Word of God in a very unique, profound and life- transforming way. He is known as the Apostle of Love because of the love of God which He reveals to everyone. Being a Man sent from God, with his wife and co-founder Zeh Phronesis, their mandate is to equip and enlighten God's people, delivering the true, undiluted, unfiltered and liberating Gospel of our Lord Jesus; bringing many people to the full knowledge of God and their sonship in Him and revealing their identity in Christ.
Phronesis also selflessly trains leaders through his outstanding leadership skills to bring the best out of each individual as purposed by God.
Our Vision
Elohim International falls under the umbrella of its Mother Organisation - Believers Nation World Wide (BNWW), which also incorporates Phronesis Foundation - which is a charity foundation wing of the ministry as well as the Billionaires Office - an entity which is focused on bringing up billionaires in the Kingdom of God using the Godly principles. The Vision of BNWW is Christ Revolution, manifesting Christ Jesus in all sectors and all departments world wide.
Our Mission
Since the inception of Elohim International, it's Mission statement has always been about revealing the Fullness of God unto the ends of the world. The ministry is a fast growing interracial and diverse ministry with the Main branch in Cape Town, and currently operating in KZN, Limpopo, Johannesburg and Eastern Cape in South Africa, and Zimbabwe and Zambia outside of South Africa.
Theme Of The Month
Welcome to December the Month of GoodNews! GoodNews are coming to you this month; in your phone, emails, notifications, phone calls, sms or WhatsApp. There shall be Recovery and Restoration of all that you lost in Jesus Name. Things shall turn around for your Good this Month. You shall experience the Goodness of the LORD in the land of the living. You're protected from danger, sickness, accidents and death. Only Goodness and Mercy shall follow all the days of your Life!
Social Media
Follow Us on social media
Giving
Giving online is quick, easy and secure
Offering
a voluntary religious offering made in addition to what is required by a vow, tithe, or pledge. The greatest freewill offering ever made and will ever be made was from God the Father Who freely gave His One and only Son, Jesus Christ.
Tithe
Tithes are 10% of your income. Tithes are more of an act of recognition. It’s also a way of giving thanks for all the blessings that you are receiving. It’s to honor and acknowledge that He is your provider. ~ GEN. 14:19–20
Partnership
The word "partnership" is derived from the Latin word for "portion". In partnership, we share a portion with each other. Implementing our programs allows each of us to achieve a shared, mutually desired vision that cannot be reached by either of us alone.
First Fruit
The first fruits are usually done once a year or for every new blessing that you receive.Any new blessings that you receive counts as a first fruit, so all these should be offered to God. Giving your first fruits once a year will show how grateful you are for the blessings that you received from Him
Seed
When we put our faith in God’s hands like a seed we plant, we are giving Him something to work with, and He will send the miracle we need. No matter how small our faith seems to be, it will meet needs and solve problems that appear as impossible to move as mountains.
Eiusmod Tempor
Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi
Leaders
Check our Leaders
Phronesis
FounderZeh Phronesis
ProphetessPastor Sbusi
Cape Town branchElder Ngwenya
Cape Town branchSeer
Durban branchPastors Enoch & Hlami
Limpopo branchPastors Khathu & Tondi
Johannesburg branchPastors Roger & Alu
Johannesburg branchPastors Richard & Mary
Zambia branchPastor Ngwenya
Zimbabwe branchContact
Contact Us
Our Address
Park Inn Hotel, Newlands, Cape Town
Email Us
<EMAIL_ADDRESS><EMAIL_ADDRESS>Call Us
+27 61 099 2422
+27 61 099 2422


Bluetooth Event Service¶
Introduction¶
This Bluetooth service is an optional part of the standard Bluetooth profile for the micro:bit. It is a passive service, that can operate transparently in the background as your main program is running. This service extends the microBitMessageBus over Bluetooth, so that standard MicroBitEvents raised on the device can be transmitted transparently over Bluetooth and received and processed by connected Bluetooth master device such as a smartphone. You do not need to explicity address and API on the service to achieve this.
Enabling the Service¶
This service is enabled by default.
Bluetooth Service Specification¶
Please see the micro:bit Bluetooth profile specification.
Example Applications for Android/IOS/Android¶
General Procedures¶
micro:bit uses an event bus which relays event objects from system components which generate them to other system components which have registered an interest in events of a given type. This principle and capability has been extended to remote devices connected over Bluetooth. Connected clients can indicate the types of event they are interested in and be informed via Bluetooth notificatons as and when such events occur. Similarly, micro:bit application code can inform a connected client of events which might happen in or be observed by an application running on the connected device (the client application) and be informed when they occur via Bluetooth write operations.
Event objects consist of a short (2 octets) type and a short (2 octets) value.
When either client application or micro:bit code registers an interest in an event type it may register for all events of that type regardless of the associated value or may specify a particular value which must accompany that event type for it to be of interest.
The Microbit Requirements characteristic allows micro:bit code to inform the client application of a list of one or more event types/values it wants to be informed about if they arise. For example if a client application monitors for incoming SMS messages and defines receipt of an SMS message to be event type 1234 then a micro:bit application could inform the client application it wants to be told when an SMS has been received by declaring its interest in event type 1234 in its MicrobitRequirements characteristic.
The Client Requirements characteristic has a similar purpose but is the mechanism the client application uses to tell the micro:bit application what events it is interested in. Should they arise and notifications have been enabled on the MicrobitEvent characteristic, the client application will receive a Bluetooth notification containing the event object. A micro:bit application which monitors temperature and notifies a smartphone application when the temperature falls below a specified limit or rises above another threshold could use events to notify the client application when either of these things happens.
The MicroBit Event characteristic is used to convey events which have happened on the micro:bit to the connected client. Notifications are normally used but the most recent events for which the client registered can be determined by reading the characteristic value at any time.
The Client Event characteirstic is used to convey events which have happened on the client device to the micro:bit. This is achieved through the client application writing one or more events to the characteristic value.
See the profile page and profile reference documentation for data format and UUID details.
Android¶
Android Bluetooth APIs¶
Android developers should make themselves familiar with the Android Bluetooth low energy APIs
microbit-ble-demo-android¶
The open source microbit-ble-demo-android application contains a number of demonstrations of the micro:bit Bluetooth event service including Temperature Alarm and Squirrel Counter. The main body of code for the temperature alarm demonstration can be found in ui.TemperatureAlarmActivity.java except for the Bluetooth operations themselves which are in bluetooth.BleAdapterService which acts as a kind of higher level Bluetooth API for activities to use without needing to directly concern themselves too closely with the Android APIs themselves. In most cases, operations are asynchronous so that the activity code initiates a Bluetooth operation by calling one of the methods in bluetooth.BleAdapterService (e.g. readCharacteristic(....) ) and later receives a message containing the result of the operation from this object via a Handler object. The message is examined in the Handler code and acted upon.
Key parts of the temperature alarm demonstration in this application are explained next.
In bluetooth.BleAdapterService¶
public static String EVENTSERVICE_SERVICE_UUID = "E95D93AF251D470AA062FA1922DFA9A8";
public static String MICROBITREQUIREMENTS_CHARACTERISTIC_UUID = "E95DB84C251D470AA062FA1922DFA9A8";
public static String MICROBITEVENT_CHARACTERISTIC_UUID = "E95D9775251D470AA062FA1922DFA9A8";
public static String CLIENTREQUIREMENTS_CHARACTERISTIC_UUID = "E95D23C4251D470AA062FA1922DFA9A8";
public static String CLIENTEVENT_CHARACTERISTIC_UUID = "E95D5404251D470AA062FA1922DFA9A8";
In ui.TemperatureAlarmActivity¶
// event variables and values
private byte upper_limit;
private byte lower_limit;
// LE here means Little Endian btw
// micro:bit event codes:
// 9000 = 0x2823 (LE) = temperature alarm. Value=0 means OK, 1 means cold, 2 means hot
// client event codes:
// 9001=0x2923 (LE) = set lower limit, value is the limit value in celsius
// 9002=0x2A23 (LE) = set upper limit, value is the limit value in celsius
private byte [] event_set_lower = { 0x29, 0x23, 0x00, 0x00}; // event 9001
private byte [] event_set_upper = { 0x2A, 0x23, 0x00, 0x00}; // event 9002
// enabling microbit event notifications
bluetooth_le_adapter.setNotificationsState(
Utility.normaliseUUID(BleAdapterService.EVENTSERVICE_SERVICE_UUID),
Utility.normaliseUUID(BleAdapterService.MICROBITEVENT_CHARACTERISTIC_UUID), true)
// setting the upper and lower temperature limits
private void setUpperLimit() {
// set the value part of this event data
event_set_upper[2] = Settings.getInstance().getUpper_temperature_limit();
bluetooth_le_adapter.writeCharacteristic(Utility.normaliseUUID(BleAdapterService.EVENTSERVICE_SERVICE_UUID), Utility.normaliseUUID(BleAdapterService.CLIENTEVENT_CHARACTERISTIC_UUID), event_set_upper);
}
private void setLowerLimit() {
// set the value part of this event data
event_set_lower[2] = Settings.getInstance().getLower_temperature_limit();
bluetooth_le_adapter.writeCharacteristic(Utility.normaliseUUID(BleAdapterService.EVENTSERVICE_SERVICE_UUID), Utility.normaliseUUID(BleAdapterService.CLIENTEVENT_CHARACTERISTIC_UUID), event_set_lower);
}
// handling a MicrobitEvent notification indicating a temperature alarm of "too hot" or "too cold"
case BleAdapterService.NOTIFICATION_RECEIVED:
bundle = msg.getData();
service_uuid = bundle.getString(BleAdapterService.PARCEL_SERVICE_UUID);
characteristic_uuid = bundle.getString(BleAdapterService.PARCEL_CHARACTERISTIC_UUID);
b = bundle.getByteArray(BleAdapterService.PARCEL_VALUE);
if (characteristic_uuid.equalsIgnoreCase((Utility.normaliseUUID(BleAdapterService.MICROBITEVENT_CHARACTERISTIC_UUID)))) {
byte[] event_bytes = new byte[2];
byte[] value_bytes = new byte[2];
System.arraycopy(b, 0, event_bytes, 0, 2);
System.arraycopy(b, 2, value_bytes, 0, 2);
short event = Utility.shortFromLittleEndianBytes(event_bytes);
short value = Utility.shortFromLittleEndianBytes(value_bytes);
Log.d(Constants.TAG, "Temperature Alarm received: event=" + event + " value=" + value);
if (event == Constants.MICROBIT_EVENT_TYPE_TEMPERATURE_ALARM) {
setAlarmImage(alarm_image, value);
setAlarmMessage(value);
}
}
break;
Video Demonstrations¶
Temperature Alarm¶
Buggy Remote Control¶
micro:bit code for the buggy controller¶
/*
The MIT License (MIT)
Copyright (c) 2016 British Broadcasting Corporation.
This software is provided by Lancaster University by arrangement with the BBC.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include "MicroBit.h"
#include "MicroBitSamples.h"
#ifdef MICROBIT_GAMEPAD
MicroBit uBit;
#define MES_DPAD_CONTROLLER 1104
#define MES_DPAD_1_BUTTON_UP_ON 1
#define MES_DPAD_1_BUTTON_UP_OFF 2
#define MES_DPAD_1_BUTTON_DOWN_ON 3
#define MES_DPAD_1_BUTTON_DOWN_OFF 4
#define MES_DPAD_1_BUTTON_LEFT_ON 5
#define MES_DPAD_1_BUTTON_LEFT_OFF 6
#define MES_DPAD_1_BUTTON_RIGHT_ON 7
#define MES_DPAD_1_BUTTON_RIGHT_OFF 8
#define MES_DPAD_2_BUTTON_UP_ON 9
#define MES_DPAD_2_BUTTON_UP_OFF 10
#define MES_DPAD_2_BUTTON_DOWN_ON 11
#define MES_DPAD_2_BUTTON_DOWN_OFF 12
#define MES_DPAD_2_BUTTON_LEFT_ON 13
#define MES_DPAD_2_BUTTON_LEFT_OFF 14
#define MES_DPAD_2_BUTTON_RIGHT_ON 15
#define MES_DPAD_2_BUTTON_RIGHT_OFF 16
int pin0, pin8, pin12, pin16 = 0;
int drive = 0;
void onControllerEvent(MicroBitEvent e)
{
if (e.value == MES_DPAD_2_BUTTON_UP_ON) {
pin12 = 1;
pin16 = 1;
drive = 1;
} else {
if (e.value == MES_DPAD_2_BUTTON_UP_OFF) {
pin12 = 0;
pin16 = 0;
drive = 0;
}
}
if (drive == 1) {
if (e.value == MES_DPAD_1_BUTTON_LEFT_ON) {
pin12 = 1;
pin16 = 0;
} else {
if (e.value == MES_DPAD_1_BUTTON_RIGHT_ON) {
pin12 = 0;
pin16 = 1;
} else {
if (e.value == MES_DPAD_1_BUTTON_LEFT_OFF || e.value == MES_DPAD_1_BUTTON_RIGHT_OFF) {
pin12 = 1;
pin16 = 1;
} else {
}
}
}
}
uBit.io.P0.setDigitalValue(pin0);
uBit.io.P8.setDigitalValue(pin8);
uBit.io.P12.setDigitalValue(pin12);
uBit.io.P16.setDigitalValue(pin16);
}
int main()
{
// Initialise the micro:bit runtime.
uBit.init();
uBit.display.scroll("BUGGY!");
uBit.messageBus.listen(MES_DPAD_CONTROLLER, 0, onControllerEvent);
// If main exits, there may still be other fibers running or registered event handlers etc.
// Simply release this fiber, which will mean we enter the scheduler. Worse case, we then
// sit in the idle task forever, in a power efficient sleep.
release_fiber();
}
#endif


Bookshelf
Home
Series
Book
Series
Link
Maintenance
Store
Link
Link
2
Link
Book
Link
Maintenance
Store
Link
Link
2
Link


Test API
Test API
This project is to serve as an experiment to learn FastApi and serve as a useful API to serve psuedo data when needed in other projects.
Currently running at Test-API.DevSetGo.com - OpenAPI/Swagger UI @ Test-API.DevSetGo.com/docs - ReDoc @ Test-API.DevSetGo.com/ReDoc
Would love to have help to build a great example for others to use.
How to Use
- See project README.md
- More and better documentation to come
TODO
- Access Controls
- Docker
- Tutorials/Documentation
[Unreleased]
- websockets (working on it)
[19.2-beta-1] - 2019-04-20
Added
- routers for todo, users, and silly
- .env file update
- Logging via Loguru
Changed
- Refactor application
- Changed list to database (SQLite or Postgres)
Removed
- a lot… due to refactoring
- Removed list for todos
- Some of the Silly endpoints to limit to just list or one user generation
[19.1-beta-1] - 2019-04-06
Added
- initial commit
- building base frame of project
- ‘User’ random data (extension of FastAPI example)
- Random user contact information
- ‘Item’ little change from FastAPI example
- ‘Sample’ Generates randomized data
- can set a delay in seconds (0 -10) as a parameter
- list can generate from 1 to 1000
Changed
- Nothing, since it is an initial commit
Removed
- Nothing, since it is an initial commit


{% extends "layout.html" %} {% block content %} Ideas and execution merge here.
We simplify m-commerce industry in India by providing a platform for the unorganized retail sector to sell their products online via our platform
For collaborating please feel free to talk to us.
Contact Us »
CFO/Head of Business Operations
CTO/Head of Technical Operations