See: Description
| Interface | Description |
|---|---|
| BlockingDeque<E> |
A
Deque that additionally supports blocking operations that wait
for the deque to become non-empty when retrieving an element, and wait for
space to become available in the deque when storing an element. |
| BlockingQueue<E> |
A
Queue that additionally supports operations
that wait for the queue to become non-empty when retrieving an
element, and wait for space to become available in the queue when
storing an element. |
| Callable<V> |
A task that returns a result and may throw an exception.
|
| CompletableFuture.AsynchronousCompletionTask |
A marker interface identifying asynchronous tasks produced by
async methods. |
| CompletionService<V> |
A service that decouples the production of new asynchronous tasks
from the consumption of the results of completed tasks.
|
| CompletionStage<T> |
A stage of a possibly asynchronous computation, that performs an
action or computes a value when another CompletionStage completes.
|
| ConcurrentMap<K,V> |
A
Map providing thread safety and atomicity
guarantees. |
| ConcurrentNavigableMap<K,V> |
A
ConcurrentMap supporting NavigableMap operations,
and recursively so for its navigable sub-maps. |
| Delayed |
A mix-in style interface for marking objects that should be
acted upon after a given delay.
|
| Executor |
An object that executes submitted
Runnable tasks. |
| ExecutorService | |
| ForkJoinPool.ForkJoinWorkerThreadFactory |
Factory for creating new
ForkJoinWorkerThread s. |
| ForkJoinPool.ManagedBlocker |
Interface for extending managed parallelism for tasks running
in
ForkJoinPool s. |
| Future<V> |
A
Future represents the result of an asynchronous
computation. |
| RejectedExecutionHandler |
A handler for tasks that cannot be executed by a
ThreadPoolExecutor . |
| RunnableFuture<V> | |
| RunnableScheduledFuture<V> |
A
ScheduledFuture that is Runnable . |
| ScheduledExecutorService |
An
ExecutorService that can schedule commands to run after a given
delay, or to execute periodically. |
| ScheduledFuture<V> |
A delayed result-bearing action that can be cancelled.
|
| ThreadFactory |
An object that creates new threads on demand.
|
| TransferQueue<E> |
A
BlockingQueue in which producers may wait for consumers
to receive elements. |
| Class | Description |
|---|---|
| AbstractExecutorService |
Provides default implementations of
ExecutorService
execution methods. |
| ArrayBlockingQueue<E> |
A bounded blocking queue backed by an
array.
|
| CompletableFuture<T> |
A
Future that may be explicitly completed (setting its
value and status), and may be used as a CompletionStage ,
supporting dependent functions and actions that trigger upon its
completion. |
| ConcurrentHashMap<K,V> |
A hash table supporting full concurrency of retrievals and
high expected concurrency for updates.
|
| ConcurrentHashMap.KeySetView<K,V> |
A view of a ConcurrentHashMap as a
Set of keys, in
which additions may optionally be enabled by mapping to a
common value. |
| ConcurrentLinkedDeque<E> |
An unbounded concurrent deque based on linked nodes.
|
| ConcurrentLinkedQueue<E> |
An unbounded thread-safe queue based on linked nodes.
|
| ConcurrentSkipListMap<K,V> |
A scalable concurrent
ConcurrentNavigableMap implementation. |
| ConcurrentSkipListSet<E> |
A scalable concurrent
NavigableSet implementation based on
a ConcurrentSkipListMap . |
| CopyOnWriteArrayList<E> |
A thread-safe variant of
ArrayList in which all mutative
operations (add , set , and so on) are implemented by
making a fresh copy of the underlying array. |
| CopyOnWriteArraySet<E> |
A
Set that uses an internal CopyOnWriteArrayList
for all of its operations. |
| CountDownLatch |
A synchronization aid that allows one or more threads to wait until
a set of operations being performed in other threads completes.
|
| CountedCompleter<T> |
A
ForkJoinTask with a completion action performed when
triggered and there are no remaining pending actions. |
| CyclicBarrier |
A synchronization aid that allows a set of threads to all wait for
each other to reach a common barrier point.
|
| DelayQueue<E extends Delayed> |
An unbounded blocking queue of
Delayed elements, in which an element can only be taken
when its delay has expired. |
| Exchanger<V> |
A synchronization point at which threads can pair and swap elements
within pairs.
|
| ExecutorCompletionService<V> |
A
CompletionService that uses a supplied Executor
to execute tasks. |
| Executors |
Factory and utility methods for
Executor , ExecutorService , ScheduledExecutorService , ThreadFactory , and Callable classes defined in this
package. |
| ForkJoinPool |
An
ExecutorService for running ForkJoinTask s. |
| ForkJoinTask<V> |
Abstract base class for tasks that run within a
ForkJoinPool . |
| ForkJoinWorkerThread |
A thread managed by a
ForkJoinPool , which executes
ForkJoinTask s. |
| FutureTask<V> |
A cancellable asynchronous computation.
|
| LinkedBlockingDeque<E> |
An optionally-bounded blocking deque based on
linked nodes.
|
| LinkedBlockingQueue<E> |
An optionally-bounded blocking queue based on
linked nodes.
|
| LinkedTransferQueue<E> |
An unbounded
TransferQueue based on linked nodes. |
| Phaser |
A reusable synchronization barrier, similar in functionality to
CyclicBarrier and
CountDownLatch
but supporting more flexible usage. |
| PriorityBlockingQueue<E> |
An unbounded blocking queue that uses
the same ordering rules as class
PriorityQueue and supplies
blocking retrieval operations. |
| RecursiveAction |
A recursive resultless
ForkJoinTask . |
| RecursiveTask<V> |
A recursive result-bearing
ForkJoinTask . |
| ScheduledThreadPoolExecutor |
A
ThreadPoolExecutor that can additionally schedule
commands to run after a given delay, or to execute
periodically. |
| Semaphore |
A counting semaphore.
|
| SynchronousQueue<E> |
A blocking queue in which each insert
operation must wait for a corresponding remove operation by another
thread, and vice versa.
|
| ThreadLocalRandom |
A random number generator isolated to the current thread.
|
| ThreadPoolExecutor |
An
ExecutorService that executes each submitted task using
one of possibly several pooled threads, normally configured
using Executors factory methods. |
| ThreadPoolExecutor.AbortPolicy |
A handler for rejected tasks that throws a
RejectedExecutionException . |
| ThreadPoolExecutor.CallerRunsPolicy |
A handler for rejected tasks that runs the rejected task
directly in the calling thread of the
execute method,
unless the executor has been shut down, in which case the task
is discarded. |
| ThreadPoolExecutor.DiscardOldestPolicy |
A handler for rejected tasks that discards the oldest unhandled
request and then retries
execute , unless the executor
is shut down, in which case the task is discarded. |
| ThreadPoolExecutor.DiscardPolicy |
A handler for rejected tasks that silently discards the
rejected task.
|
| Enum | Description |
|---|---|
| TimeUnit |
A
TimeUnit represents time durations at a given unit of
granularity and provides utility methods to convert across units,
and to perform timing and delay operations in these units. |
| Exception | Description |
|---|---|
| BrokenBarrierException |
Exception thrown when a thread tries to wait upon a barrier that is
in a broken state, or which enters the broken state while the thread
is waiting.
|
| CancellationException |
Exception indicating that the result of a value-producing task,
such as a
FutureTask , cannot be retrieved because the task
was cancelled. |
| CompletionException |
Exception thrown when an error or other exception is encountered
in the course of completing a result or task.
|
| ExecutionException |
Exception thrown when attempting to retrieve the result of a task
that aborted by throwing an exception.
|
| RejectedExecutionException |
Exception thrown by an
Executor when a task cannot be
accepted for execution. |
| TimeoutException |
Exception thrown when a blocking operation times out.
|
java.util.concurrent.locks
and
java.util.concurrent.atomic
packages.
Executor
is a simple standardized
interface for defining custom thread-like subsystems, including
thread pools, asynchronous I/O, and lightweight task frameworks.
Depending on which concrete Executor class is being used, tasks may
execute in a newly created thread, an existing task-execution thread,
or the thread calling execute
, and may execute sequentially or concurrently.
ExecutorService
provides a more
complete asynchronous task execution framework. An
ExecutorService manages queuing and scheduling of tasks,
and allows controlled shutdown.
The ScheduledExecutorService
subinterface and associated interfaces add support for
delayed and periodic task execution. ExecutorServices
provide methods arranging asynchronous execution of any
function expressed as Callable
,
the result-bearing analog of Runnable
.
A Future
returns the results of
a function, allows determination of whether execution has
completed, and provides a means to cancel execution.
A RunnableFuture
is a Future
that possesses a run
method that upon execution,
sets its results.
Implementations.
Classes ThreadPoolExecutor
and
ScheduledThreadPoolExecutor
provide tunable, flexible thread pools.
The Executors
class provides
factory methods for the most common kinds and configurations
of Executors, as well as a few utility methods for using
them. Other utilities based on Executors
include the
concrete class FutureTask
providing a common extensible implementation of Futures, and
ExecutorCompletionService
, that
assists in coordinating the processing of groups of
asynchronous tasks.
Class ForkJoinPool
provides an
Executor primarily designed for processing instances of ForkJoinTask
and its subclasses. These
classes employ a work-stealing scheduler that attains high
throughput for tasks conforming to restrictions that often hold in
computation-intensive parallel processing.
ConcurrentLinkedQueue
class
supplies an efficient scalable thread-safe non-blocking FIFO queue.
The ConcurrentLinkedDeque
class is
similar, but additionally supports the Deque
interface.
Five implementations in java.util.concurrent
support
the extended BlockingQueue
interface, that defines blocking versions of put and take:
LinkedBlockingQueue
,
ArrayBlockingQueue
,
SynchronousQueue
,
PriorityBlockingQueue
, and
DelayQueue
.
The different classes cover the most common usage contexts
for producer-consumer, messaging, parallel tasking, and
related concurrent designs.
Extended interface TransferQueue
,
and implementation LinkedTransferQueue
introduce a synchronous transfer
method (along with related
features) in which a producer may optionally block awaiting its
consumer.
The BlockingDeque
interface
extends BlockingQueue
to support both FIFO and LIFO
(stack-based) operations.
Class LinkedBlockingDeque
provides an implementation.
TimeUnit
class provides
multiple granularities (including nanoseconds) for
specifying and controlling time-out based operations. Most
classes in the package contain operations based on time-outs
in addition to indefinite waits. In all cases that
time-outs are used, the time-out specifies the minimum time
that the method should wait before indicating that it
timed-out. Implementations make a "best effort"
to detect time-outs as soon as possible after they occur.
However, an indefinite amount of time may elapse between a
time-out being detected and a thread actually executing
again after that time-out. All methods that accept timeout
parameters treat values less than or equal to zero to mean
not to wait at all. To wait "forever", you can use a value
of Long.MAX_VALUE
.
Semaphore
is a classic concurrency tool.
CountDownLatch
is a very simple yet
very common utility for blocking until a given number of signals,
events, or conditions hold.
CyclicBarrier
is a resettable
multiway synchronization point useful in some styles of parallel
programming.
Phaser
provides
a more flexible form of barrier that may be used to control phased
computation among multiple threads.
Exchanger
allows two threads to
exchange objects at a rendezvous point, and is useful in several
pipeline designs.
ConcurrentHashMap
,
ConcurrentSkipListMap
,
ConcurrentSkipListSet
,
CopyOnWriteArrayList
, and
CopyOnWriteArraySet
.
When many threads are expected to access a given collection, a
ConcurrentHashMap
is normally preferable to a synchronized
HashMap
, and a ConcurrentSkipListMap
is normally
preferable to a synchronized TreeMap
.
A CopyOnWriteArrayList
is preferable to a synchronized
ArrayList
when the expected number of reads and traversals
greatly outnumber the number of updates to a list.
The "Concurrent" prefix used with some classes in this package
is a shorthand indicating several differences from similar
"synchronized" classes. For example java.util.Hashtable
and
Collections.synchronizedMap(new HashMap())
are
synchronized. But ConcurrentHashMap
is "concurrent". A
concurrent collection is thread-safe, but not governed by a
single exclusion lock. In the particular case of
ConcurrentHashMap, it safely permits any number of
concurrent reads as well as a tunable number of concurrent
writes. "Synchronized" classes can be useful when you need
to prevent all access to a collection via a single lock, at
the expense of poorer scalability. In other cases in which
multiple threads are expected to access a common collection,
"concurrent" versions are normally preferable. And
unsynchronized collections are preferable when either
collections are unshared, or are accessible only when
holding other locks.
Most concurrent Collection implementations
(including most Queues) also differ from the usual java.util
conventions in that their Iterators
and Spliterators provide
weakly consistent rather than fast-fail traversal:
ConcurrentModificationException
synchronized
and volatile
constructs, as well as the
Thread.start()
and Thread.join()
methods, can form
happens-before relationships. In particular:
synchronized
block or method exit) of a
monitor happens-before every subsequent lock (synchronized
block or method entry) of that same monitor. And because
the happens-before relation is transitive, all actions
of a thread prior to unlocking happen-before all actions
subsequent to any thread locking that monitor.
volatile
field happens-before every
subsequent read of that same field. Writes and reads of
volatile
fields have similar memory consistency effects
as entering and exiting monitors, but do not entail
mutual exclusion locking.
start
on a thread happens-before any
action in the started thread.
join
on that thread.
java.util.concurrent
and its
subpackages extend these guarantees to higher-level
synchronization. In particular:
Runnable
to an Executor
happen-before its execution begins.
Similarly for Callables
submitted to an ExecutorService
.
Future
happen-before actions subsequent to the
retrieval of the result via Future.get()
in another thread.
Lock.unlock
, Semaphore.release
, and
CountDownLatch.countDown
happen-before actions
subsequent to a successful "acquiring" method such as
Lock.lock
, Semaphore.acquire
,
Condition.await
, and CountDownLatch.await
on the
same synchronizer object in another thread.
Exchanger
, actions prior to the exchange()
in each thread happen-before those subsequent to the
corresponding exchange()
in another thread.
CyclicBarrier.await
and
Phaser.awaitAdvance
(as well as its variants)
happen-before actions performed by the barrier action, and
actions performed by the barrier action happen-before actions
subsequent to a successful return from the corresponding await
in other threads.
Dracula Javadoc Sample, Made with Allan Im.


The CID Menu
The CID Menu provides a few commands for manipulating CID keyed fonts. If
the current font is a CID keyed font the menu also includes a list of all
subfonts that make up this one. This menu is only available in the font view.
Er... What is a CID keyed Font?
A CID keyed font is a postscript (or opentype) font designed to hold Chinese,
Japanese and Korean characters efficiently. More accurately a CID font is
a collection of several sub-fonts each with certain common features (one
might hold all the latin letters, another all the kana, a third all the kanji).
This allows font-wide hinting to be crafted for subsets of glyphs to which
have something in common.
CID keyed fonts do not have an encoding built into the font, and the glyphs
do not have names. Instead the font is associated with a glyph set and on
each glyph set there are several character mappings defined. These mappings
are similar to encodings but allow for a wider range of behaviors.
A CID is a glyph index and is used to look up glyph descriptions instead
of glyph names in other types of fonts. Using a glyph set FontForge will
often be able to map a CID to a unicode character name (but not always),
so FontForge will give glyphs names when it can.
For more information see the section on CID keyed
fonts on the font view page.
-
Convert to CID
-
If the current font is not a CID font then this command will convert it into
one containing one subfont (with the glyphs in this font). You will be prompted
for a glyph set.
-
Convert By CMap
-
If the current font is not a CID font then this command will convert it into
one containing a single subfont. You will be prompted for an Adobe CMap file.
-
Flatten
-
If the current font is a CID font then this command will convert it into
a normal (flat) font by taking all the glyphs from all the sub-fonts and
merging them into one normal font. The new font should be in the same order
as the CID font (ie. ordered by CID). After this operation you may re-encode
it into whatever encoding is appropriate.
-
Flatten By CMap
-
If the current font is a CID font then this command will convert it into
a normal font. It prompts you for an Adobe CMap file and uses that to define
an encoding for the resultant font.
-
Insert Font
-
Will allow you to browse for a normal font which will be added as another
sub font to the current CID font.
-
Insert Blank
-
Inserts a blank sub-font into the current CID font.
-
Remove Font
-
Removes the current font from the CID font. Anything in it will be lost.
(If you want to save it first then use Generate Font and save it as a pfb
file (or any other simple format).
-
Change Supplement...
-
Displays the Registry/Ordering information of the font and allows you to
change the Supplement level.
-
CID Font Info
-
This allows you to provide information on the entire collection of subfonts
rather than just the current subfont. It provides access to the standard
font info dialog.
-
<sub font name>
-
Clicking on a different sub font name in the menu will cause that sub-font
to be displayed instead of the current one.
Other menus
-- Prev -- TOC
-- Next --


Allows practitioners and researchers a wholesale approach for deriving magnitude-based inferences from raw data. A major goal of 'mbir' is to programmatically detect appropriate statistical tests to run in lieu of relying on practitioners to determine correct stepwise procedures independently.
| Version: | 1.3.4 |
| Imports: | graphics, stats, utils, effsize, psych |
| Suggests: | knitr, testthat, rmarkdown |
| Published: | 2018-09-17 |
| Author: | Kyle Peterson [aut, cre], Aaron Caldwell [aut] |
| Maintainer: | Kyle Peterson <petersonkdon at gmail.com> |
| License: | GPL-2 |
| Copyright: | Segments of the package are based upon Will G. Hopkins' work. See vignette and COPYRIGHT file for details. |
| URL: | http://mbir-project.us/ |
| NeedsCompilation: | no |
| CRAN checks: | mbir results |
| Reference manual: | mbir.pdf |
| Vignettes: |
Introduction to mbir |
| Package source: | mbir_1.3.4.tar.gz |
| Windows binaries: | r-devel: mbir_1.3.4.zip, r-release: mbir_1.3.4.zip, r-oldrel: mbir_1.3.4.zip |
| OS X binaries: | r-release: mbir_1.3.4.tgz, r-oldrel: mbir_1.3.4.tgz |
| Old sources: | mbir archive |
Please use the canonical form https://CRAN.R-project.org/package=mbir to link to this page.


mdf_forge package¶
Submodules¶
mdf_forge.forge module¶
-
class
mdf_forge.forge.
Forge
(**kwargs)[source]¶ Bases:
object
Fetch metadata from Globus Search and files from the Materials Data Facility. Forge is intended to be the best way to access MDF data for all users. An internal Query object is used to make queries. From the user’s perspective, an instantiation of Forge will black-box searching.
Public Variables: local_ep is the endpoint ID of the local Globus Connect Personal endpoint.
Methods: __init__ handles authentication with Globus Auth. match_term adds simple terms to the query. match_field adds a field:value pair to the query. match_sources specifies `source_name`s to search for results in. match_elements specifies element abbreviations to match. search executes a search. search_by_elements executes a search for given elements in given sources. aggregate_source returns all records for a given source. reset_query destroys the current query and starts a fresh one. http_download saves the data files associated with results to disk with HTTPS. globus_download saves the data files associated with results to disk with Globus Transfer. http_stream yields a generator to fetch data files in sequence. http_return returns all the data files at once.
-
aggregate
(q=None, scroll_size=10000, reset_query=True)[source]¶ Perform an advanced query, and return all matching results. Will automatically preform multiple queries in order to retrieve all results.
Note that all aggregate queries run in advanced mode.
Arguments: q (str): The query to execute. Defaults to the current query, if any. There must be some query to execute. scroll_size (int): Minimum number of records returned per query reset_query (bool): If True, will destroy the query after execution and start a fresh one. Does nothing if False.
Default True.Returns: list of dict: All matching records
-
aggregate_source
(sources)[source]¶ Aggregate all records from a given source. There is no limit to the number of results returned. Please beware of aggregating very large datasets.
Arguments: sources (str or list of str): The source to aggregate.
Returns: list of dict: All of the records from the source.
-
globus_download
(results, dest='.', dest_ep=None, preserve_dir=False, wait_for_completion=True, verbose=True)[source]¶ Download data files from the provided results using Globus Transfer. This method requires Globus Connect to be installed on the destination endpoint.
Arguments: results (dict): The records from which files should be fetched.
This should be the return value of a search method.dest (str): The destination path for the data files on the local machine. Default current directory. preserve_dir (bool): If True, the directory structure for the data files will be recreated at the destination.
The path to tne new files will be relative to the dest pathIf False, only the data files themselves will be saved. Default False.
- wait_for_completion (bool): If True, will block until the transfer is finished.
- If False, will not block. Default True.
- verbose (bool): If True, status and progress messages will be printed.
- If False, only error messages will be printed. Default True.
Returns: list of str: task IDs of the Gloubs transfers
-
http_download
(results, dest='.', preserve_dir=False, verbose=True)[source]¶ Download data files from the provided results using HTTPS. For more than HTTP_NUM_LIMIT (defined above) files, you should use globus_download(), which uses Globus Transfer.
Arguments: results (dict): The records from which files should be fetched.
This should be the return value of a search method.dest (str): The destination path for the data files on the local machine. Default current directory. preserve_dir (bool): If True, the directory structure for the data files will be recreated at the destination.
If False, only the data files themselves will be saved.Default False.
- verbose (bool): If True, status and progress messages will be printed.
- If False, only error messages will be printed. Default True.
-
http_return
(results, verbose=True)[source]¶ Return data files from the provided results using HTTPS. For more than HTTP_NUM_LIMIT (defined above) files, you should use globus_download(), which uses Globus Transfer.
Arguments: results (dict): The records from which files should be fetched.
This should be the return value of a search method.- verbose (bool): If True, status and progress messages will be printed.
- If False, only error messages will be printed. Default True.
Returns: list of str: Text data of the data files.
-
http_stream
(results, verbose=True)[source]¶ Yield data files from the provided results using HTTPS, through a generator. For more than HTTP_NUM_LIMIT (defined above) files, you should use globus_download(), which uses Globus Transfer.
Arguments: results (dict): The records from which files should be fetched.
This should be the return value of a search method.- verbose (bool): If True, status and progress messages will be printed.
- If False, only error messages will be printed. Default True.
Yields: str: Text of each data file.
-
match_elements
(elements, match_all=True)[source]¶ Add elemental abbreviations to the query.
Arguments: elements (str or list of str): The elements to match. match_all (bool): If True, will add with AND. If False, will use OR. Default True.
Returns: self (Forge): For chaining.
-
match_field
(field, value, required=True, new_group=False)[source]¶ Add a field:value term to the query. Matches will have field == value.
Arguments: field (str): The field to look in for the value.
The field must be namespaced according to Elasticsearch rules, which means a dot to dive into dictionaries. Ex. “mdf.source_name” is the “source_name” field of the “mdf” dictionary. If no namespace is provided, the default (“mdf.”) will be used.value (str): The value to match. required (bool): If True, will add term with AND. If False, will use OR. Default True. new_group (bool): If True, will separate term into new parenthetical group. If False, will not. Default False.
Returns: self (Forge): For chaining.
-
match_sources
(sources)[source]¶ Add sources to match to the query.
Arguments: sources (str or list of str): The sources to match.
Returns: self (Forge): For chaining.
-
match_term
(term, required=True, new_group=False)[source]¶ Add a term to the query.
Arguments: term (str): The term to add. required (bool): If True, will add term with AND. If False, will use OR. Default True. new_group (bool): If True, will separate term into new parenthetical group. If False, will not. Default False.
Returns: self (Forge): For chaining.
-
search
(q=None, advanced=False, limit=10000, info=False, reset_query=True)[source]¶ Execute a search and return the results.
Arguments: q (str): The query to execute. Defaults to the current query, if any. There must be some query to execute. advanced (bool): If True, will submit query in “advanced” mode, which enables searches other than basic fulltext.
If False, only basic fulltext term matches will be supported. Default False. This value can change to True automatically if the query is built using advanced features, such as match_field.limit (int): The maximum number of results to return. The max for this argument is the SEARCH_LIMIT imposed by Globus Search. info (bool): If False, search will return a list of the results.
If True, search will return a tuple containing the results list, and other information about the query. Default False.- reset_query (bool): If True, will destroy the query after execution and start a fresh one. Does nothing if False.
- Default True.
Returns: list (if info=False): The results. tuple (if info=True): The results, and a dictionary of query information.
-
search_by_elements
(elements=[], sources=[], limit=None, match_all=True, info=False)[source]¶ Execute a search for the given elements in the given sources. search_by_elements([x], [y]) is equivalent to match_elements([x]).match_sources([y]).search() Note that this method does use terms from the current query.
Arguments: elements (list of str): The elements to match. Default []. sources (list of str): The sources to match. Default []. limit (int): The maximum number of results to return. The max for this argument is the SEARCH_LIMIT imposed by Globus Search. match_all (bool): If True, will add elements with AND. If False, will use OR. Default True. info (bool): If False, search will return a list of the results.
If True, search will return a tuple containing the results list, and other information about the query. Default False.Returns: list (if info=False): The results. tuple (if info=True): The results, and a dictionary of query information.
-
search_client
¶
-
transfer_client
¶
-
-
class
mdf_forge.forge.
Query
(search_client, q='(', limit=None, advanced=False)[source]¶ Bases:
object
The Query class is meant for internal Forge use. Users should not instantiate a Query object directly, as Forge manages all the functions a user might need, but advanced users may do so at their own risk. Using Query directly is an unsupported behavior and may have unexpected results or unlisted changes in the future.
Queries may end up wrapped in parentheses, which has no direct effect on the search. Adding terms must be chained with .and() or .or(). Terms will not have spaces in between otherwise, and it is desirable to be explicit about which terms are required.
-
aggregate
(q=None, scroll_size=10000)[source]¶ Gather all record results that match a specific query
Note that all aggregate queries run in advanced mode.
Arguments: q (str): The query to execute. Defaults to the current query, if any. There must be some query to execute. advanced (bool): If True, will submit query in “advanced” mode, which enables searches other than basic fulltext.
If False, only basic fulltext term matches will be supported. Default False. This value can change to True automatically if the query is built using advanced features, such as match_field.scroll_size (int): Maximum number of records requested per request
Returns: list of dict: All matching records
-
and_join
(close_group=False)[source]¶ Combine terms with AND. There must be a term added before using this method.
Arguments: close_group (bool): If True, will end the current group and start a new one.
If False, will continue current group. Example: If the current query is “(term1”
.and(close_group=True) => “(term1) AND (” .and(close_group=False) => “(term1 AND “Returns: self (Query): For chaining.
-
field
(field, value)[source]¶ Add a field:value term to the query. Matches will have field == value. This method sets advanced=True.
Arguments: field (str): The field to look in for the value. value (str): The value to match.
Returns: self (Query): For chaining.
-
or_join
(close_group=False)[source]¶ Combine terms with OR. There must be a term added before using this method.
Arguments: close_group (bool): If True, will end the current group and start a new one.
If False, will continue current group. Example: If the current query is “(term1”
.or(close_group=True) => “(term1) OR(” .or(close_group=False) => “(term1 OR “Returns: self (Query): For chaining.
-
search
(q=None, advanced=None, limit=10, info=False)[source]¶ Execute a search and return the results.
Arguments: q (str): The query to execute. Defaults to the current query, if any. There must be some query to execute. advanced (bool): If True, will submit query in “advanced” mode, which enables searches other than basic fulltext.
If False, only basic fulltext term matches will be supported. Default False. This value can change to True automatically if the query is built using advanced features, such as match_field.limit (int): The maximum number of results to return. The max for this argument is the SEARCH_LIMIT imposed by Globus Search. Default 10. info (bool): If False, search will return a list of the results.
If True, search will return a tuple containing the results list, and other information about the query. Default False.Returns: list (if info=False): The results. tuple (if info=True): The results, and a dictionary of query information.
-
mdf_forge.toolbox module¶
-
class
mdf_forge.toolbox.
SearchClient
(base_url='https://search.api.globus.org/', default_index=None, **kwargs)[source]¶ Bases:
globus_sdk.base.BaseClient
Access (search and ingest) Globus Search.
-
ingest
(data, index=None, **params)[source]¶ Perform a simple
POST
based ingest op.Parameters
data
(dict)- A valid GIngest document to index.
index
(string)- Optional unless
default_index
was not set. The search index to send data into. params
- Any additional query params to pass. For internal use only.
-
search
(q, limit=None, offset=None, query_template=None, index=None, advanced=None, **params)[source]¶ Perform a simple
GET
based search.Does not support all of the behaviors and parameters of advanced searches.
Parameters
q
(string)- The user-query string. Required for simple searches (and most advanced searches).
index
(string)- Optional unless
default_index
was not set. The index to query. limit
(int)- Optional. The number of results to return.
offset
(int)- Optional. An offset into the total result set for paging.
query_template
(string)- Optional. A query_template name as defined within the Search service.
advanced
(bool)- Use simple query parsing vs. advanced query syntax when
interpreting
q
. Defaults to False. params
- Any additional query params to pass. For internal use only.
-
structured_search
(data, index=None, **params)[source]¶ Perform a structured,
POST
-based, search.Parameters
data
(dict)- A valid GSearchRequest document to execute.
index
(string)- Optional unless
default_index
was not set. The index to query. advanced
(bool)- Use simple query parsing vs. advanced query syntax when interpreting the query string. Defaults to False.
params
- Any additional query params to pass. For internal use only.
-
-
mdf_forge.toolbox.
confidential_login
(credentials=None)[source]¶ Login to Globus services as a confidential client (a client with its own login information).
Arguments: credentials (str or dict): A string filename, string JSON, or dictionary with credential and config information.
By default, looks in ~/mdf/credentials/confidential_globus_login.json.Contains: client_id (str): The ID of the client. client_secret (str): The client’s secret for authentication. services (list of str): Services to authenticate with (can be transfer, search, search_ingest, or mdf). index: The default Search index. Only required if services contains ‘search’ or ‘search_ingest’.
Returns: dict: The clients and authorizers requested, indexed by service name.
For example, if login() is told to auth with ‘search’ then the search client will be in the ‘search’ field.
-
mdf_forge.toolbox.
find_files
(root, file_pattern=None, verbose=False)[source]¶ Find files recursively in a given directory.
Arguments: root (str): The path to the starting (root) directory. file_pattern (str): A regular expression to match files against, or None to match all files. Default None. verbose: If True, will print status messages.
If False, will remain silent unless there is an error. Default False.Yields: dict: The matching file’s path information.
Contains: path (str): The path to the directory containing the file. no_root_path (str): The path to the directory containing the file, with the path to the root directory removed. filename (str): The name of the file.
-
mdf_forge.toolbox.
format_gmeta
(data)[source]¶ Format input into GMeta format, suitable for ingesting into Globus Search. Format a dictionary into a GMetaEntry. Format a list of GMetaEntry into a GMetaList inside a GMetaIngest.
- Example usage:
glist = [] for document in all_my_documents:
gmeta_entry = format_gmeta(document) glist.append(gmeta_entry)ingest_ready_document = format_gmeta(glist)
Arguments: data (dict or list): The data to be formatted.
If data is a dict, it must contain: data[“mdf”][“links”][“landing_page”] (str): A URI to a web page for the entry. data[“mdf”][“acl”] (list of str): A list of Globus UUIDs that are allowed to view the entry. If data is a list, it must consist of GMetaEntry documents.Returns: dict (if data is dict): The data as a GMetaEntry. dict (if data is list): The data as a GMetaIngest.
-
mdf_forge.toolbox.
get_local_ep
(transfer_client)[source]¶ Discover the local Globus Connect Personal endpoint’s ID, if possible.
Arguments: transfer_client (TransferClient): An authenticated Transfer client.
Returns: str: The local GCP EP ID if it was discovered. If the ID is not discovered, an exception (globus_sdk.GlobusError unless the user cancels the search) will be raised.
-
mdf_forge.toolbox.
gmeta_pop
(gmeta, info=False)[source]¶ Remove GMeta wrapping from a Globus Search result. This function can be called on the raw GlobusHTTPResponse that Search returns, or a string or dictionary representation of it.
Arguments: gmeta (dict, str, or GlobusHTTPResponse): The Globus Search result to unwrap. info (bool): If False, gmeta_pop will return a list of the results and discard the metadata.
If True, gmeta_pop will return a tuple containing the results list, and other information about the query. Default False.Returns: list (if info=False): The unwrapped results. tuple (if info=True): The unwrapped results, and a dictionary of query information.
-
mdf_forge.toolbox.
login
(credentials=None, clear_old_tokens=False, **kwargs)[source]¶ Login to Globus services
Arguments: credentials (str or dict): A string filename, string JSON, or dictionary with credential and config information.
By default, looks in ~/mdf/credentials/globus_login.json.Contains: app_name (str): Name of script/client. This will form the name of the token cache file. services (list of str): Services to authenticate with (can be transfer, search, search_ingest, or mdf). index: The default Search index. Only required if services contains ‘search’ or ‘search_ingest’.
- clear_old_tokens (bool): If True, delete old token file if it exists, forcing user to re-login.
- If False, use existing token file if there is one. Default False.
Returns: dict: The clients and authorizers requested, indexed by service name.
For example, if login() is told to auth with ‘search’ then the search client will be in the ‘search’ field.
-
mdf_forge.toolbox.
uncompress_tree
(root, verbose=False)[source]¶ Uncompress all tar, zip, and gzip archives under a given directory. Note that this process tends to be very slow.
Arguments: root (str): The path to the starting (root) directory. verbose: If True, will print status messages.
If False, will remain silent unless there is an error. Default False.


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
E
F
G
H
I
J
K
L
M
N
P
R
S
T
U
V
W
X
G
get()
- Method in class utilities.eval.
CorpusDepot
getChildren()
- Method in class languagemodel.calc.
MapTreeNode
Deprecated.
getChildWithKey(K)
- Method in class languagemodel.calc.
MapTreeNode
Deprecated.
getCoding()
- Method in class inout.paths.
Path
getCorpusDepot()
- Method in class utilities.eval.
CorpusReader
getDirectory()
- Method in class inout.paths.
Path
getEntries()
- Method in class inout.indexing.
ArrayLexicon
Deprecated.
getEntries()
- Method in class inout.indexing.
BiMapLexicon
getEntries()
- Method in interface inout.indexing.
Lexicon
getEntries()
- Method in class inout.indexing.
ListLexicon
Deprecated.
getExtension()
- Method in class inout.paths.
Path
getFirstPathWithAttributes(String)
- Method in class inout.paths.
PathHandler
Returns the first
Path
-object matching the specification.
getID()
- Method in class inout.indexing.
IndexReader
getID()
- Method in class languagemodel.calc.
nGramCalculator
getID()
- Method in class languagemodel.calc.
nGramSupplier
getID()
- Method in class utilities.eval.
CorpusEvaluator
getID()
- Method in class utilities.eval.
CorpusReader
getIndices()
- Method in class inout.indexing.
Indexing
getIndices()
- Method in class inout.indexing.
IndexReader
getInPath()
- Method in class inout.general.
DataLoader
getKey(String)
- Method in class inout.indexing.
ArrayLexicon
Deprecated.
getKey(String)
- Method in class inout.indexing.
BiMapLexicon
getKey(String)
- Method in interface inout.indexing.
Lexicon
getKey(String)
- Method in class inout.indexing.
ListLexicon
Deprecated.
getKey()
- Method in class languagemodel.calc.
MapTreeNode
Deprecated.
getLexicon()
- Method in class inout.indexing.
Indexing
getLexiconSize()
- Method in class inout.indexing.
ArrayLexicon
Deprecated.
getLexiconSize()
- Method in class inout.indexing.
BiMapLexicon
getLexiconSize()
- Method in interface inout.indexing.
Lexicon
getLexiconSize()
- Method in class inout.indexing.
ListLexicon
Deprecated.
getMode()
- Method in class inout.indexing.
Indexing
getMode()
- Method in class languagemodel.model.
LanguageModel
getN()
- Static method in class counting.
WordCount.allNGramMapper
getN()
- Static method in class counting.
WordCount.nGramMapper
getN()
- Method in class inout.indexing.
Indexing
getN()
- Method in class inout.paths.
Path
getN()
- Method in class languagemodel.calc.
nGramCalculator
getN()
- Method in class languagemodel.model.
LanguageModel
getNGramDepot()
- Method in class languagemodel.calc.
nGramSupplier
getNormalization()
- Method in class languagemodel.model.
LanguageModel
getPartition(IntWritable, Text, int)
- Method in class counting.
WordCount.CustomPartitioner
getPathHandler()
- Method in class languagemodel.model.
LanguageModel
getPaths()
- Method in class inout.paths.
PathHandler
getPaths()
- Method in class inout.paths.
PathParser
getPathsWithAttributes(String)
- Method in class inout.paths.
PathHandler
Returns a
List
of
Path
-objects matching the specification.
getPathsWithCoding(String)
- Method in class inout.paths.
PathHandler
getPathsWithDirectory(String)
- Method in class inout.paths.
PathHandler
getPathsWithExtension(String)
- Method in class inout.paths.
PathHandler
getPathsWithN(int)
- Method in class inout.paths.
PathHandler
getPathsWithSubtype(String)
- Method in class inout.paths.
PathHandler
getPathsWithTask(String)
- Method in class inout.paths.
PathHandler
getPathsWithType(String)
- Method in class inout.paths.
PathHandler
getPrefix()
- Method in class inout.indexing.
Indexing
getProbabilityCalculation()
- Method in class languagemodel.model.
LanguageModel
getProbs()
- Method in class languagemodel.calc.
nGramCalculator
getSequenceProbability(String)
- Method in class languagemodel.model.
LanguageModel
Returns the probability of a sequence.
getSequenceProbabilityParallelized(String)
- Method in class languagemodel.model.
LanguageModel
Returns the probability of a sequence, calculated parallelized.
getSubtype()
- Method in class inout.paths.
Path
getTask()
- Method in class inout.paths.
Path
getTotalProb()
- Method in class utilities.eval.
CorpusEvaluator
Get the sum of all probabilities computed by this object
getType()
- Method in class inout.paths.
Path
getValue(int)
- Method in class inout.indexing.
ArrayLexicon
Deprecated.
getValue(int)
- Method in class inout.indexing.
BiMapLexicon
getValue(int)
- Method in interface inout.indexing.
Lexicon
getValue(int)
- Method in class inout.indexing.
ListLexicon
Deprecated.
getValue()
- Method in class languagemodel.calc.
MapTreeNode
Deprecated.
getWordCount()
- Method in class utilities.eval.
CorpusEvaluator
Return the number of lines processed by this object
A
B
C
D
E
F
G
H
I
J
K
L
M
N
P
R
S
T
U
V
W
X
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


\] pp-
I was tasked with creating a short animation to promote the arrival of the Netflix service on the YouView platform. I initially worked with a contracted motion designer to create the initial vision although i personally took the project through from that point to final completion. There was a lot of communication from not only the internal team but also with the Netflix team to ensure that it promoted the platform. This was seen across London’s Piccadilly Circus during the peak christmas period
YouView & Netflix UK
2015-2016
Motion Graphics, Art Direction


Functions | |
| static bool | Pipe_IsReadWriteAllowed (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static bool | Pipe_IsINReceived (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static bool | Pipe_IsOUTReady (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static bool | Pipe_IsSETUPSent (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static void | Pipe_ClearSETUP (void) ATTR_ALWAYS_INLINE |
| static void | Pipe_ClearIN (void) ATTR_ALWAYS_INLINE |
| static void | Pipe_ClearOUT (void) ATTR_ALWAYS_INLINE |
| static bool | Pipe_IsNAKReceived (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static void | Pipe_ClearNAKReceived (void) ATTR_ALWAYS_INLINE |
| static bool | Pipe_IsStalled (void) ATTR_WARN_UNUSED_RESULT ATTR_ALWAYS_INLINE |
| static void | Pipe_ClearStall (void) ATTR_ALWAYS_INLINE |
Functions, macros, variables, enums and types related to packet management of pipes.
| static void Pipe_ClearIN | ( | void | ) | [inline, static] |
Acknowledges the reception of a setup IN request from the attached device on the currently selected pipe, freeing the bank ready for the next packet.
| static void Pipe_ClearNAKReceived | ( | void | ) | [inline, static] |
Clears the NAK condition on the currently selected pipe.
| static void Pipe_ClearOUT | ( | void | ) | [inline, static] |
Sends the currently selected pipe's contents to the device as an OUT packet on the selected pipe, freeing the bank ready for the next packet.
| static void Pipe_ClearSETUP | ( | void | ) | [inline, static] |
Sends the currently selected CONTROL type pipe's contents to the device as a SETUP packet.
| static void Pipe_ClearStall | ( | void | ) | [inline, static] |
Clears the STALL condition detection flag on the currently selected pipe, but does not clear the STALL condition itself (this must be done via a ClearFeature control request to the device).
| static bool Pipe_IsINReceived | ( | void | ) | [inline, static] |
Determines if an IN request has been received on the currently selected pipe.
| static bool Pipe_IsNAKReceived | ( | void | ) | [inline, static] |
Determines if the device sent a NAK (Negative Acknowledge) in response to the last sent packet on the currently selected pipe. This occurs when the host sends a packet to the device, but the device is not currently ready to handle the packet (i.e. its endpoint banks are full). Once a NAK has been received, it must be cleared using Pipe_ClearNAKReceived() before the previous (or any other) packet can be re-sent.
| static bool Pipe_IsOUTReady | ( | void | ) | [inline, static] |
Determines if the currently selected pipe is ready to send an OUT request.
| static bool Pipe_IsReadWriteAllowed | ( | void | ) | [inline, static] |
Determines if the currently selected pipe may be read from (if data is waiting in the pipe bank and the pipe is an IN direction, or if the bank is not yet full if the pipe is an OUT direction). This function will return false if an error has occurred in the pipe, or if the pipe is an IN direction and no packet (or an empty packet) has been received, or if the pipe is an OUT direction and the pipe bank is full.
| static bool Pipe_IsSETUPSent | ( | void | ) | [inline, static] |
Determines if no SETUP request is currently being sent to the attached device on the selected CONTROL type pipe.
| static bool Pipe_IsStalled | ( | void | ) | [inline, static] |
Determines if the currently selected pipe has had the STALL condition set by the attached device.


Letter to Heads
of State of the European Union
by Lord Yehudi Menuhin, May 6, 1997
The following letter to Heads of State of
the European Union, calling for the creation of a European Cultural
Assembly, was sent by Lord Yehudi Menuhin, the great violinist,
conductor, and humanitarian who received the Nuclear Age Peace
Foundation's 1997 Distinguished Peace Leadership Award.
In my opinion there is one element missing in the general concept
of the European Union -- It is the representation of the rich
diversity of European Cultures.
The peoples aspiring to national sovereignty must
be offered the alternative of cultural autonomy. We cannot afford
a proliferation of atom bombs and terrorists, nor can we deny
any group its own distinctive identity, its needs, traditions
and habitat.
The powers of globalization in science, in communications,
in commerce, the need to combat global menaces-- disease, pollution,
drought, famine-- through more effective and broader cooperation
amongst peoples must be compensated by cultural affinities conceived
on the scale of the human being.
Until now the sovereign state acted as the responsible
monolith for both functions; now they must each be represented
on the European stage by
1) the European Parliament,
2) the Assembly of Cultures.
To this end I am engaged in establishing a representation
of cultures at the level of a greater Europe. The representatives,
either designated or chosen, would have to enjoy the confidence
and trust of their group, but they would also have to speak with
the aim of reaching agreement..
The discussions, conducted in the presence of a
member of the European Court of Justice, would result in resolutions
or in further discussions, in arbitration or legislation. The
discussion concluded, the individual would return to home and
habitual work.
The mission, if successfully accomplished, would
entitle the spokesman or woman to become a member of the full
meetings of the Assembly of Cultures. Full meetings of the Assembly
would be held once or twice a year in Brussels or Strasbourg.
The Cultures would also remain in constant touch with each other.
This would lead to a renunciation on the part of any given culture,
of sovereign national and territorial ambitions. Gradually national
police and military requirements would take on a European character,
as great world powers would no longer be required to defend a
self-reliant Europe.
My foundation in Brussels is already furthering
this project with an office and a qualified gentleman in charge.
Europe would thus have another chamber of representatives:
the one elected by the citizens-- the European Parliament-- and
the other as a counterweight -- a forum of the different cultures.
Both houses would fully consider each other's attitudes
and propositions.
As I see it, Mr. Prime Minister, this is the next
stage in the constant evolution and development of our democracies.
I am convinced that an Assembly of Cultures can
play a decisive role in the emergence of a genuine European conscience,
which would constitute the best defense of its peoples and of
the community. The inclusion of cultures in Eastern Europe would
release a process of acclimatization whereby good neighborliness
and trust would permeate our Assembly of Cultures of greater Europe,
preparing them gradually for fuller membership in the Community,
a membership for which they are not qualified as yet, either economically
or, even more importantly, psychologically.
We cannot include in the evolved community of western
Europe wherein territorial ambitions have been outgrown, those
other peoples whose mentality still reverts to territorial control
and expansion. They are still psychologically unevolved and unprepared
for European Union.
This evolution could be immediately begun with
cultural contacts and expressions in every field, including the
political, of which evolution neither the political Parliament
of States, which are never completely free of mistrust, nor the
economic dictates of profitability in a free market are capable.
(See my letter to the Governor of Moscow.)
Up until now our European Union has not shouldered
its role of Guardian of cultures which would protect a human being,
his heritage, his rights, his creativity.
Europe will not survive on its past record alone,
however great are its contributions to democracy, to the arts,
the sciences and the social sciences; only when it will finally
give a shining example of a balanced, rich, diverse, multicolored
and harmonious society may other powers wish to emulate it rather
than destroy it.
Also, whilst keeping our powder dry, our hands
and our minds and doors must be open, generous and sharing.
For these reasons, Mr. Prime Minister, I would
ask you with a full heart to support the principle of the creation
of this representation of Cultures, and I would be very happy
if among the many issues you will discuss you could agree upon
two points:
1)that the European Union should be called 'The
European Union of States and Cultures'
and
2)that the European Union declares itself the 'Guardian
of European Cultures.'
In setting your sight high, even upon the unattainable,
you will attract the vast majority of people to your side, for
you will have given them to understand that vision and that a
future do exist; that clear and inspiring, noble purposes can
still be pursued -- and not only garages to repair outworn, outdated
mechanisms, reflexes and obsessional thoughts, narrow, timid,
and vulgar.
As Prime Minister you are spokesman for and to
all your people -- rich, poor, old, young, of all colors and denominations
-- and of all political parties, for, of course, as soon as you
confine yourself to one political party or to an alliance you
will be opposed by others, several of which may have valid attitudes
and arguments.
Will you allow me to say that neither the purposes,
nor the measures, nor the problems, nor all that which may link
these problems together, are presented with clarity and against
their backgrounds of weights and forces, which it would be essential
to do if you really want to convince a people, critical, experienced,
tested and tried, a people of essentially good character, yet
wary and cynical.
The measures which you feel obliged to take consist
in part of responses to financial and economic problems, which
relate to social and civil ones, which in their turn are connected
to Europe, to foreign affairs, but very specially to the quality
of education, to health, physical and intellectual, to a creative,
moral code based on a consensus of values, heritage and traditions,
which are at the very heart of a civilization, however complex
it may be.
Your own poor, suffering, aged, young, sick, the
sad unemployed, all the frustrated, the malcontents, the drugged,
the ill-informed and violent, this living tinder cannot be ignored--
a multitude rarely considered by political parties, except gingerly
at election time.
Solemn personal promises will not suffice.
May I suggest that the very words are : to work
towards a civilization founded on a positive reciprocity, on the
balance of right with responsibility, and on duties and obligations
incumbent on all.
As a rule I would say that rights belong to those
at the mercy of others and who lack an official voice.
Thus, for instance, children (who, within their
capacity, safety and well-being should also exercise responsibility)
or the sick, or trees, would have rights in respect of their helplessness,
while, on the other hand, others by virtue of authority, knowledge,
skill, experience and influence should carry the responsibilities;
thus, the passenger has rights, where the chauffeur has specific
responsibilities; the patient has the right, the surgeon the responsibility.
Our task is to build a civilization of positive
reciprocity. An education for reciprocity would concern itself
with the teaching from earliest infancy of the voice, by song
and speech, with everything which is absorbed and learned by example
and imitation-- dance, mime, a body language, a use of hands,
mind, heart and fantasy, in crafts, arts, in thoughts and speech,
in poetry, in compassion, in wonder. In this way the abstract
studies, beginning with reading and writing, can more easily sprout
on a humanely fertilized soil or soul.
As you know, this is exactly the description of
what I pursue through the works of my Foundation (The International
Yehudi Menuhin Foundation) (the project is called MUS-E) in the
more difficult schools (violent and prejudiced) in Europe. We
now have a formal working arrangement with the Ministers of Culture
and Education in Spain and Portugal. This improved society based
on reciprocity, on the mutuality of services, on the recognition
of our interdependence and upon our desire to learn, would tend
largely to reduce our exaggerated dependencies on money itself.
I would maintain that everyone, including the unemployed,
have the right to a lifelong education, to music and opera, to
theater and to sports, as well as to the basics of life-- even
holidays (a "change of air") -- provided in part by
special electronic credit cards, by mutual services and the venues,
facilities, theaters and schools, provided by the state, by private
funds, and maintained by the people with free time. The financial
field of action could thereby be substantially reduced. People
would have the obligation to live without hurting their neighbor,
whilst enjoying a reciprocal liberty and serving, as they can
and may be inclined to, the needs of others. On such a basis a
healthy capitalism could flourish, never exceeding the limits
imposed by pollution, by the abuse of nature, of our mother earth,
of our resources, never breaking all bounds in the sale of arms,
drugs, children, nor in poisons of all sorts which apparently
share our economies.
I would propose that salaries be related not only
to the employer's resources but also to a given, regional, national
(a European) income. Thus salaries would adjust to the given well-being
of a country.
We must rethink basic rights and responsibilities.
These are all to life, ours and all other lives and all life upon
which we depend, and not to money alone.
Forgive me if I allow myself to seize one of those
rare moments of historical opportunity to urge you to engage upon
a renewal of options and at the same time a return to certain
codes pronounced some two thousand and more years ago.
Respectfully,
Yehudi Menuhin
|


How does the kWh/d input processing handle negative values (ie exporting to the grid)? Does it ignore them, or does it decrease the total for each day?
I've noticed that my total energy use (grid import/export + SolarPV, logged to kWh/d) always equals my grid import/export kWh/d + SolarPV kWh/d. Even on sunny days when I've been exporting solidly for several hours.
Re: kWh/d input processing and export values
Do we need two alternative kWh/d feed processes to correctly track import and export?
Re: kWh/d input processing and export values
It should decrease and eventually go negative if net is exported.
It calculates the kwh increment from from the last measurement by multiplying the power by the time at that power. So if the power is negative the kwh increment will be negative and will subtract from the kwh figure stored up to that point.
Do your kwhd bars decrease at all when the sun is out and your consumption is less than gen?
Re: kWh/d input processing and export values
Yes, I have several days graphed with kWh as negative values (generation was indeed higher than consumption). I don't find this terribly intuitive as it doesn't tell me what my import and export values were.
Can we track grid import and export separately with emoncms?
Re: kWh/d input processing and export values
Do you have an input for solar PV gen and an input for grid import/export?
Re: kWh/d input processing and export values
Yes, Power1 is grid import/export, Power2 is SolarPV gen
Re: kWh/d input processing and export values
Great, ok just written a section here to go through the input processing setup steps: http://openenergymonitor.org/emon/applications/solarpv/emoncms Let me know if I can clarify further.
Re: kWh/d input processing and export values
Yeah, that's pretty much identical to how I have it set up. But, it doesn't log my import and export values for the day.
If I generate 15kWh from solar PV, and use 13kWh over a day, this will report my consumption as -2kWh, This doesn't account for anything I've imported at night, when the solar PV isn't generating. What I want is to track what I've imported and exported, perhaps a kWh/d process that only increments on negative values and another kWh/d that only increments on positive values.
Re: kWh/d input processing and export values
Maybe this is off topic, but is there a way to "reset" the total kWH value?
Meaning, starting over?
Thanks
Re: kWh/d input processing and export values
vworp: ah ok yes that would need a new input processor. I will see if I can implement it.
rechena: do you mean resetting the daily kwh or the result of the power to kwh processor?
Re: kWh/d input processing and export values
Trystan: Power to kWh a new fresh start :)
Re: kWh/d input processing and export values
I have been trying to do the same as vworp (show import and export totals separately for a period) and came to the conclusion that it is not currently possible or there was something wrong with my algebra skills, so I was wondering if you had made any progress on the new input processor - I know you are busy.
As an alternative I was going to modify the code that is in the emonglcd that determines the showing of the text importing/exporting, put this on the emontx or emonbase and create two extra inputs for emoncms.
The grid figure would be passed to two inputs for emoncms, named as 'import' and 'export', each having a value assigned for each sending of the data. If the grid figure is negative, then the value, unsigned would be passed to the export input for emoncms and the import input passed would be set at zero. If the grid figure is positive then the value would be passed to the import input for emoncms, and the export input passed would be set at zero. Within emoncms the input processing would then be straight forward.
Any comments on the viability of this approach would be welcome in case I have missed something in my logic.
Re: kWh/d input processing and export values
Trystan,
I've revisited this in the last week or so, and tried to add import and export values to my history page on the GLCD. It doesn't work for some reason, just makes the GLCD hang.
I've manually pasted my alterations to https://github.com/vworp/EmonGLCD (git utterly refuses to work on my machine at the moment).
Rough gist, I've added calculations for wh_import and wh_export to power_calculations() (filling the array is currently commented out) and an extra column to draw_history(). With everything commented out apart from the wh calculations, my GLCD hangs. I'm not sure what's going wrong here, any chance you can have a look see if anything stands out?
Any movement on the new input processor for emoncms?
Re: kWh/d input processing and export values
I've added the code to my emonbase sketch following the descrtiption in my earlier post. Posted to emoncms as powerexport and powerimport. Using 'power' in the name means autoconfigure inputs works on emoncms. If you would like to see the result please go to my dashboard emoncms.org/joseffh. I'll post the code snippet later.
Re: kWh/d input processing and export values
vworp,
I know your (old) code is using nearly all the available memory, is the stack overflowing? I'm not well conversed with the details so you need to research and check.
(Note: by writing the history within a loop and calculating the screen positions rather than hard coding each, you can save a few hundred bytes which should help).
Re: kWh/d input processing and export values
OK, here is the little bit of code I have added to the emonbase sketch to calculate a separate power import and powerexport value to send to emoncms. Code is adapted from that used in the emonGLCD sketch.
first before the 'SETUP section
double consuming, gen, grid;
int powerexport, powerimport;
then the On RF receive section has an addition
//-----------------------------------------------------------------------------------------------------------------
// 1) On RF recieve
//-----------------------------------------------------------------------------------------------------------------
if (rf12_recvDone()){
if (rf12_crc == 0 && (rf12_hdr & RF12_HDR_CTL) == 0)
{
int node_id = (rf12_hdr & 0x1F);
if (node_id == 10) // EMONTX
{
emontx = *(PayloadTX*) rf12_data; // get emontx data
Serial.println(); // print emontx data to serial
Serial.print("emonTx data rx");
last_rf = millis(); // reset lastRF timer
delay(50); // make sure serial printing finished
//import or export calculation
gen = emontx.power2; if (gen<15) gen=0; // set minimum threshold for generation to be recorded
consuming=gen + emontx.power1;
grid=emontx.power1;
if (gen > consuming) // if more is being generated than consumed then there must be an export
{
grid= grid*-1; // changes the export to a positive value
powerimport=0; // as power is being exported power being imported must be zero
powerexport=grid;
}
else
{
powerexport=0;
powerimport=grid;
}
And finally in the JSON creation
str.print(",power2:"); str.print(gen); // Add power reading
str.print(",power3:"); str.print(emontx.power3); // Add power reading
str.print(",powerexport:"); str.print(powerexport);
str.print(",powerimport:"); str.print(powerimport);
Re: kWh/d input processing and export values
I was going to give this mod a go, but I'm having problems with the current NanodeRF sketch.
http://openenergymonitor.org/emon/node/1079
Re: kWh/d input processing and export values
Now that the dhcp issues have been resolved and I have a working Nanode again, I've had a go at this patch. It works great with the minor niggle that it seems to break the JSON string when a temperature reading from the GLCD is present. I'm thinking that the extra import and export values are pushing the str.print over length. I'll have a look later and see what can be done.
If anyone else wants to try this fork, it's pretty up to date with the master branch:-
https://github.com/vworp/NanodeRF
Re: kWh/d input processing and export values
I've tweaked my fork so the JSON string isn't truncated when the GLCD temperature is added to it.
Question for Trystan and Glyn:- I like the idea of having import and export calculated on a base unit rather than in emoncms. If the multinode sketch is the way forward, might it be better to add this calculation to emonTX?


Huntsman Altimor
Huntsman gargons share health with him. Cleave to both while focusing the gargons
Boss receives 100% increase damage when all gargons are dead
Targets 3 players. Damages all players in a line. Leaves DOT on hit
Spread from other arrows and stop moving. Remaing raid members adjust
Randomly targeted unavoidable cone of damage
Raid will be loosely spread around the room to reduce number of people hit
Margore
Places red circle around random circle. Deals split damage to everybody in circle and applies DOT to anybody hit
Bring circle to 2 or 3 additional people to share damage. Too many people will apply too many DOTs
Stacking tank debuff
Taunt when your debuff falls off
Bargast
Creates shades of itself on the edge and move towards boss
CC to apply stacking debuff to shades that make them take more damage
Heavy magic damage to tank. Spawns soul with health equal to tank's health after hit
Bring Margore out of the raid. Use personal/external on tank. Heal soul to full before it reaches boss
Hecutis
Melee attacks apply increasing damage debuff to tank. Removing stacks damage whole raid
Slowly kite the boss in a circle around Altimor.
Targets random player. Deals damage to players within 10 yards. Leaves bad patch after damage
Run out of the raid and drop circle on edge of room


--- title: Contact - Gamespawn layout: default ---
If you have any inquiries about Gamespawn @ UC Riverside, please email us at<EMAIL_ADDRESS>You can also find us at our HighlanderLink page here: https://highlanderlink.ucr.edu/organization/gamespawn


Software Engineering Class SFSU
Spring 2017
Section 07
Team 07
About US Team
Chris Jol
Kevin Venegas
Deep Bhuller
Roderic Kong
About German Team
German Student 1
German Student 2
German Student 3
German Student 4


appendDeviceIdent
This method will append the RatePAY Device Ident code.
Signature
appendDeviceIdent (deviceIdentSId, deviceIdentToken)
Arguments
| Name | Mandatory | Type | Default Value | Description |
|---|---|---|---|---|
| deviceIdentSId | YES | String | N/A | DeviceIdentSId that is part of the ratepay merchant settings |
| deviceIdentToken | YES | String | N/A | Unique token generated by the backend of the integrator that is also to be sent along with the order capture request |
getRatepayInstallmentConfig
This method will return the RatePAY merchant configuration.
Signature
getRatepayInstallmentConfig (callback)
Arguments
| Name | Mandatory | Type | Default Value | Description |
|---|---|---|---|---|
| callback | YES | function | N/A | Function with following signature – callback (error, result) result parameter is object, containing the merchant configuration. error parameter is an object, containing a message with the reason what has failed. Please see Error object for further information. |
getRatepayInstallmentCalculation
This method will calculate an installment plan.
Signature
getRatepayInstallmentConfig(calculationRequest, callback)
Arguments
| Name | Mandatory | Type | Default Value | Description |
|---|---|---|---|---|
| calculationRequest | YES | Object | N/A | The calculation request hash. It should contain: amount: the amount to calculate an installment plan for. Mandatory calculationType: the plan can be calculated based on duration ('calculation-time') or monthly rate ('calculation-rate'). Mandatory. calculationTime: number of months to calculate the plan for. Mandatory if type is time. calculationRate: amount of monthly rate to calculate the plan for. Mandatory if type is rate. |
| callback | YES | function | N/A | Function with following signature – callback (error, result) result parameter is object, containing the calculation result. error parameter is an object, containing a message with the reason what has failed. Please see Error object for further information. |


Didal na-‘torture’ sa seag training
MAY mga bagong trick si skateboarder Margielyn Didal, umaasa siyang ginto ang ibibigay nito sa kanya sa 30th SEA Games.
“I’ve also got some new tricks prepared but will stick to the game plan,” ani Didal.
“I’m always prepared and ready to compete, no matter where it is. That’s why I recently spent time in Rio de Janeiro/Los Angeles to get the best place training possible.”
Naging malaking puntos naman para sa Cebuana-skater ang maging parte ng Red Bull na nagsilbing training niya bago sumabak sa paparating na biennial event.
Related Posts
Aminado siya na mahirap ang pinagdaanan niya sa Red Bull High Performance Training Center dahil natamo niya ang ‘very severe ankle sprain’ na naka-apekto sa kanyang training.
“The best part about them (Red Bull) is when they would torture me during rehab,” pahayag ni Didal.
“But really, they have the best team, therapist and equipment. They helped so much – especially with my ankle concerns and other key areas. Now we’re focusing on a lot of ways to improve my skills.” (Aivan Episcope)


Protocols
The following protocols are available globally.
-
Generic representation of Auth0 errors.
See moreAuthenticationError
,ManagementError
,WebAuthError
, andCredentialsManagerError
conform to this protocol.Declaration
Swift
public protocol Auth0Error : LocalizedError, CustomDebugStringConvertible
-
Generic representation of Auth0 API errors.
See moreAuthenticationError
andManagementError
conform to this protocol.Declaration
Swift
public protocol Auth0APIError : Auth0Error
-
Client for the Auth0 Authentication API.
See more -
Generic storage API for storing credentials.
See moreDeclaration
Swift
public protocol CredentialsStorage
-
A type that can log statements for debugging purposes.
See moreDeclaration
Swift
public protocol Loggable
-
Logger for debugging purposes.
See moreDeclaration
Swift
public protocol Logger
-
A type that can send the
See moreAuth0-Client
header on every request to Auth0.Declaration
Swift
public protocol Trackable
-
-


Quarantine Countdown
Quarantine Time In days:
Enter Number of days for the Quarantine
Quarantine Time In days:
Or
Quarantine Time from to
Enter the starting day of the quarantine
Enter the ending day of the quarantine
◁
▷
◃
▹
Reset countdown:
The Quarantine has ended!!


{% extends 'award/base.html' %}
{% load bootstrap3 %}
{% load static %}
{% block content%}
Let us take you into a deeper experience, make a moment a lasting conveyable memory. Let us help build your tribe.
Find Out MoreWe love what we do and we do what our clients love & work with great clients all over the world to create thoughtful and purposeful websites..
View SiteTitle : {{project.title}}
Description : {{project.description}}
Designed By: {{project.user}}
Review project View Site


Toggle navigation
Coach
Tech
Law
Welcome to my web presence
Please select one of my webapps from the menubar at the top


{% if token_fail %}{% trans "Bad Token" %}{% else %}{% trans "Change Password" %}{% endif %}
{% if token_fail %} {% url 'account_reset_password' as passwd_reset_url %}{% blocktrans %}The password reset link was invalid, possibly because it has already been used. Please request a new password reset.{% endblocktrans %}
{% else %} {% if form %} {% else %}{% trans 'Your password is now changed.' %}
{% endif %} {% endif %}


-
People
-
Places
-
Things
-
Animals
-
Food
A quick summary about all of the items in this list. You can put as much as you like in here and the text will simply wrap around.
To create a footer, just put a paragraph tag right after the list. And yes, as you can see, you can put multiple paragraphs after the list for more complex list footers.


Toggle navigation
Three
Sixty
Link
(current)
Link
Dropdown
Action
Another action
Something else here
Separated link
One more separated link


NOTE: The following list of references and links may be useful. However, note that they do not necessarily cover all the material we plan to cover in the class.
Athey, S. (2018). The impact of machine learning on economics. In The Economics of Artificial Intelligence: An Agenda. University of Chicago Press.
Athey, S., & Imbens, G. W. (2017). The state of applied econometrics: Causality and policy evaluation. Journal of Economic Perspectives, 31(2), 3-32.
Belloni, A., Chernozhukov, V., & Hansen, C. (2014). High-dimensional methods and inference on structural and treatment effects. Journal of Economic Perspectives, 28(2), 29-50.
Mullainathan, S., & Spiess, J. (2017). Machine learning: an applied econometric approach. Journal of Economic Perspectives, 31(2), 87-106.
Varian, H. R. (2014). Big data: New tricks for econometrics. Journal of Economic Perspectives, 28(2), 3-28.
AEA 2018 Continuing Education, “Machine Learning and Econometrics” (Athey and Imbens).
NBER 2015 Method Lectures, “Lectures on Machine Learning” (Athey and Imbens).
NBER 2013 Method Lectures, “Econometric Methods for High-Dimensional Data” (Chernozhukov, Gentzkow, Hansen, Shapiro, Taddy).
“Machine Learning and Prediction in Economics and Finance”, Sendhil Mullainathan, AFA Lecture, 2017.
“The Impact of Machine Learning on Econometrics and Economics”, Susan Athey, AEA Lecture, 2019.
NOTE: To the best of our knowledge, there is no “Machine Learning for Economists” textbook out there yet (Though there is one we know of that is in the making, co-authored by Mullainathan and Spiess.)
An Introduction to Statistical Learning with Applications in R
Gareth James, Daniela Witten, Trevor Hastie and Robert Tibshirani
This book provides a hands-on and R-based introduction to Machine Learning.
PDF available online
Elements of Statistical Learning
Trevor Hastie, Robert Tibshirani and Jerome Friedman
This book covers the same topics as previous book (and more), however, it provides more rigorous treatment.
PDF available online
Machine Learning - A Probablistic Prespective
Kevin P. Murphy
This book includes basic topics in statistical modeling, as well as advanced machine learning topics. It comes with Matlab code to reproduce almost every figure and algorithm, discussed in the book.
The following two books presents a detailed account of recently developed approaches to estimating models containing a large number of parameters, including the Lasso and versions of it:
Statistical Learning with Sparsity - The Lasso and Generalizations
Trevor Hastie, Robert Tibshirani, and Martin Wainwright
In book contains an introduction to and a summary of the actively developing field of statistical learning with sparse models.
PDF available online
Statistics for High-Dimensional Data - Methods, Theory and Applications
Peter Buhlmann, and Sara van de Geer
This book brings together methodological concepts, computational algorithms, a few applications and mathematical theory for high-dimensional statistics.
The following two textbooks provide a graduate level treatment of causal inference in social sciences:
Mostly Harmless Econometrics
Joshua Angrist and Jorn-Steffen Pischke
Causal Inference for Statistics, Social, and Biomedical Sciences
Guido Imbens and Donald Rubin
Text Mining with R - A Tidy Approach
Julia Silge and David Robinson
The go-to textbook for those interested in textmining with R.
Prediction Machines
Ajay Agrawal, Joshua Gans, Avi Goldfarb
A must-read book about the economics of AI. These authors recast the rise of AI as a drop in the cost of prediction and show how basic tools from IO economics can help analyze the effects of AI on the economy and our society.
Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy
Cathy O’Neil
In this book, O’neil discusses the dangers of using on black-box descion making algorithms that are prone to significant biases in tasks like granting (or denying) loans, workers evaluation, parole setting, health monitoring.
Big Data: Does Size Matter?
Timandra Harkness
A non-technical and fun introduction to big-data.
The Book of Why: The New Science of Cause and Effect
Judea Pearl and Dana Mackenzie Pearl and Mackenzie’s book is a must for anyone interested in causality. It lays the foundations of Pearl’s approach to causal inference in plain English and graphs with very few equations.
Susan Athey (Stanford)
Alexandre Belloni (Duke)
Victor Chernozhukov (MIT)
Francis Diebold (Penn)
Christian Hansen (Chicago)
Guido Imbens (Stanford)
Maximilian Kasy (Harvard)
Grant McDermott (University of Oregon)
Sendhil Mullainathan (Chicago)
Jann Spiess (Harvard)
Stefan Wager (Stanford)
A website created by Itamar Caspi using RMarkdown.
Disclaimers: (1) The official syllabus and the content on the official Moodle website shall always prevail in case of any discrepancy or inconsistency between this website and its official HUJI versions; (2) This website and its content do not necessarily reflect the views of the Bank of Israel or any of its staff.


Some Thoughts on Physical Labor, Exercise, and Being Outdoors
by Matt
One of the reasons we decided to buy a farm and move to the country is to be outdoors more, whether working or playing. Certainly one of the attractions that drew me to this area is the proximity to many excellent rock climbing areas--Stone Mountain, the New River Gorge, Looking Glass Rock, Linville Gorge, etc. Also the Blue Ridge mountains, which turn into the Great Smokies as they run south and west, offer plenty of hiking, kayaking, trail running and other opportunities for outdoor recreation. I definitely plan to take advantage of all of this, whether it's spending more time climbing or foraging for mushrooms.
On a more modest scale, I have simply enjoyed being outside working on my property in the morning and evening after finishing work this week. It's nice to hear the neighbors' horses and cattle, and the occasional crunch of tires on the dirt access road, but not the constant drone of traffic and suburban noise I never really got used to. It feels really good to get outside after sitting at a desk for hours at a time, to feel the sun on the skin, and the air gradually gettting cooler as the work progresses at its own pace.
I've been averaging about five hours a day so far this week double-digging our vegetable garden, and while there's a pleasant ache when I lie down in bed, I'm not exhausted. In fact, I have more energy now than after finishing a day's work at the office and looking at a 45-minute commute or the prospect of trying to rouse myself for a workout at an over-crowded climbing gym.
Physical labor, especially outdoors, is what our bodies have been designed for, in many respects. It's no surprise, then, that when we don't get enough exercise and fresh air, we get sick, physically as well psychically and emotionally. Throughout most of the course of our evolutionary history, humans have been hunter-gatherers. For the last few thousand years, many of us have been farmers or agriculturalists in some respect.
It's only in the last generation or two that an increasingly urbanized population, at least here in the US, have worked whole careers at desk jobs requiring minimal physcial activity. With that and the labor saving devices and factory food of the post-World War II era have come epidemic rates of chronic lifestyle diseases like obesity, diabetes, and heart disease.
Some of the diet and exercise fads that have been making the rounds lately have provided some food for thought on the topic. The paleo diet, at least Mark Sisson's version of it in his "Primal Blueprint," touches on these points, although a lot of his ideas come off as pop-science. Another popular book, Christopher McDougall's "Born to Run," which spawned the trend of barefoot running, impressed me more. His examination of the running culture of the legendary Tarahumara tribe in Mexico--a people who casually run ultramarathons--ultimately concludes, with the investigations of anthropologists studying a group in Africa, that humans have evolved the biological equipment to run long distances through a genetic history of chasing down game.
E.O. Wilson, in his theory of biophilia, has gone so far as to suggest that humans have an innate biological need for interacting with the other living things, but especially the natural world. There is evidence to back this up. For example, it's been shown that patients in hospital rooms with a view of a park or natural enclosure heal faster and have better clinical outcomes than patients who don't.
In my mid-twenties I discovered rock climbing and running after reaching a low point brought on by smoking a pack a day, working long and strange hours at a pointless job, eating fast food every day, not getting any exercise, and pretty much living an extreme version of the conditions of modern life that many people take for granted every day. Since then, I've become more and more acutely aware of how important time spent outdoors in nature really is to my own health and sanity.
Subscribe via RSS


just finished the rewriting of the addressgen part. It now will take information for each coin on different servers, this will be done via a params table that will know which user/host the command need to execute remotely the requests, for some this will be done via RPC(mostly eth)
This will allow to add any number of coin as it is now possible to spread them across multiple servers.
no more storage fears
added encryption on mysqlDB too, even with access to DB, can't extract sensitive information
next step is to rewrite the other parts, next will be the txsearch one, used in multiple status, so will have to be done to be able to query it via specific args
as my main goal is to be able to run every single script concurrently on different status types of trades, I need to make sure nothing can overlap, new splitting (on latest document posted here) will allow this as every single query will be run on the same time.
Meyse30-Oct-18 12:24 PM
nice work guys! whats the UI gonna look like?
barv30-Oct-18 12:24 PM
Cool, thx @Deleted User for the heads up.
Deleted User30-Oct-18 12:25 PM
will continue posting updates and stuff done here
so afterwards it will be a full backlog of what happened, and how it was done
barv30-Oct-18 12:29 PM
Very good. Scolling ack I see you expect a delay of 1 month on UX. Maye @Meyse can contribute on this
Meyse30-Oct-18 12:32 PM
yes im available
just the exact workings of the system are still unclear to me
barv30-Oct-18 12:34 PM
It would be cool if there can be a test version online with few (two) coins
Deleted User30-Oct-18 12:38 PM
you can already
with my old interface
I stopped payment processor but I can resume when you want
as I use the machine to dev atm, better testing 1 by one and shut down all the rest
will order new ones today
very little for the webserver, db, and even coins processor... only the coins servers will have to be quite strong, but now It can be configured to poll multiple servers, I think it can be very cost effective
adstrakt30-Oct-18 01:56 PM
@KomodoWorld & @barv - if there are any guidelines for how you want the branding to be let me know. For the moment i have started working with colours that are related to the new Komodo brand.
1
My plan is to have a first draft before the end of the week.
dukeleto30-Oct-18 03:25 PM
FYI, I am still here, lurking, watching all the action
@Deleted User if there is any official spec document about the validation API, let me know, otherwise it's mostly in my head
Deleted User30-Oct-18 03:27 PM
I think most stuff is on each contributor s head atm ^^ am waiting to talk with @maxijb to have something clearer in mind
1
just refining address gen atm, eth is supported
and option for private trade too
added encryption to the db, am chaintesting the gen atm
dukeleto30-Oct-18 03:34 PM
I am running around like crazy preparing for winter right now, once it hits, I will have more time to hack on things. Oh, and also to think about coding while shoveling snow
barv30-Oct-18 05:56 PM
Cool @adstrakt. Most important is that you and @Meyse think of the UX. & customer journey /flow. and the right templates Colours and branding can best be made easy applicable, as you are probably do already. That way we can decide on exact branding(s) later.
Deleted User30-Oct-18 05:58 PM
My PoV on this is that we ll want the most neutral and intuitive ui as possible. Customization and templates if this is predicted, can be done afterwards
Deleted User30-Oct-18 07:13 PM
About the flow @barv it s already partially done (check the document I posted few days ago)
The main logic will be implemented on the PP server. Obviously the ui of all the differents possibilities to interact with the api will use this base as a standard one. That will allow easy integration of 3rd party apps(edited)
1
I think the first external app (webserver excluded) that will bridge on it will be the discord swapbot if @sclear still interested
Separating the ui logic from the PP one will make it possible to have a lot of possibilities for future development.
(Mainly via api for security reasons, by default only the PP server will have the possibility to have a direct access to the db)
Everything else will rely on api to get stuff done
Deleted User30-Oct-18 11:51 PM
about handling specific case, made minor changes to status, in case of an addy gen problem, depending on the side that didn't have its address generated, there will be a different status code :
# BOTH EMPTY : 210
# SRC MISSING : 200
# DST MISSING : 205
# BOTH OK : 3
A specific script will then loop on 200 210 and 205 to check availability on a 5 min timeframe, as soon as the coin is back, it will try only the coin that is missing. if succeed : go to status 3 (BOTH OK) and back to the main path
as coin servers will be automated, the cron timebase will have to be greater than the autocheck/relaunch to avoid unnecessary calls(edited)
adstrakt31-Oct-18 08:33 AM
@barv & @KomodoWorld so end of today i will present the first drafts. From which we will have something to discuss and a starting point to move forward from. Maybe tomorrow we could meet up for an audio chat @Meyse and give me your feedback and ideas if it works for you. Otherwise let me know.
3
KomodoWorld31-Oct-18 08:52 AM
Cool
adstrakt31-Oct-18 08:49 PM
So we had a look with @Deleted User on the first draft design. Some things came up so i will solve them first before presenting to the channel.
I'll place the link update first thing in the morning.
Just better to get those things fixed first.
1
Deleted User01-Nov-18 01:58 AM
As the api won t be able to communicate with any coinserver, i ll make a little cronscript that will generate a json for the ui to be able to know if a coin is available for a swap or not.
(For the ui or the swapbot it will be useful too)
Txsearch mostly rewritten, only eth stuff missing.
I ll try to have it done for tomorrow :)
adstrakt01-Nov-18 10:23 AM
Hi everyone so here is the prototype so far. Still needs fixing on some things. There are also other screens/tabs missing such as history, help, public offer list. But I'm focusing now on the flow of the main swaps which are the core of the product.
On the prototype you will be able to leave comments also click pointers you can find it on the bottom right menu
Logo is still vary basic idea, but i do kind of like it.(edited)
Oh yeah forgot to say - you can click around the prototype - if you click anywhere you will see blue boxes where you can click through.
For now two main tabs that are working are Outgoing Swaps & Incoming Swaps. These will also have tooltips saying what they are.(edited)
Hope you guys like it so far - my idea is that looks like an app in this box framework - the screens should animate with fade and pop effects. Also should be easy to convert to a mobile version without changing to many things. Looking forward to the feedback.
Grandma-Friendly Atomic Swaps. Contribute to atomiclabs/hyperdex development by creating an account on GitHub.
adstrakt01-Nov-18 11:21 AM
Nice - yeah some similarities for sure.
Deleted User01-Nov-18 12:07 PM
Searching tx now works for eth. Will add some security as parity is not yet handled via lazynode.
Hope i ll attack the sendingdeal part very soon ^^
Deleted User01-Nov-18 03:11 PM
looked at how it could be done to support ERC tokens, found a way using etherscan API for example, registered there and created an API key, very easy to get the balance. My problem now is that the contract stuff need to be done and encoded on the data fieldof eth_sendtransaction, but I don't know how to do this yet. I think it will take a bit of time for me to be able to generate this field (which will mean supporting ERC tokens). Unfortunately, every info I gathered was focused on handling tokens via GUI, not much info for curl/cli.
As this part may be time consuming, I will just skip it until I found a way to build the data field.
that means ETH will be supported, and ERC will be too (theorically). Even if I don't dig into it right now I think it will require a DB change for the trade table : adding src_contract and dst_contract, which will allow querying any contract just by typing the contract address
didn't discuss about it extensively with @adstrakt and @maxijb yet... to be continued
rewritten scripts will be reviewed / optimized after I ll have finished to rewrite the 2 remaining ones : senddeal.sh (when funds were received both side, this script just send each side their part), and cancelorder.sh (handling cancellation from any status, calls refund if needed)
Deleted User01-Nov-18 03:27 PM
kinda fun to play with eth commands unfortunately some of em I expected just don't exist
blackjok3r01-Nov-18 07:29 PM
ETH isnt that the one with the command BUG GIVE ME TRILLIONS OF COINS ?
dukeleto01-Nov-18 07:31 PM
yes
FishyGuts01-Nov-18 08:25 PM
@Deleted User is it ok if we get Jawarr a mention in a podcast?
You wanna give me a little elevator pitch to forward to the guy doing the podcast?
Deleted User01-Nov-18 08:36 PM
Yeah
I think a little of teasing would be amazing
FishyGuts01-Nov-18 08:41 PM
Give me the script. I will send it to the guy
Could I say that at the end of the Day, this feels like a "personal" version of BarterDex?
KomodoWorld01-Nov-18 08:58 PM
an automatic escrow for 1 to 1 trades... to me it feels both related and very different from BarterDex
dukeleto01-Nov-18 09:00 PM
automated system for OTC
is the elevator pitch, i think
various things that make it easier/better than plain OTC
KomodoWorld01-Nov-18 09:03 PM
@Deleted User I have question: how much of this is possible thanks to Komodo technology? i.e. I think it could it be done with existing tech but does Komodo tech plays an important part in developing it? Does it make a significant difference that we could say "powered by Komodo" ? It's not clear to me how much is based on it
dukeleto01-Nov-18 09:36 PM
@KomodoWorld protected by KMD DPoW
at first at least, we will support only dpow coins i think
KomodoWorld01-Nov-18 09:42 PM
ok dPoW protection for the Komodo ecosystem!
FishyGuts01-Nov-18 09:47 PM
@cryptoChrisWalken is going to talk Pirate and Jawarrr on the podcast this evening.
Is #PoWSeason in full effect?? Come join us for an hour live with Crypto Chris Walken, WhaleBearMan, and Bitcoin Broski as they discuss mining and PoW coins....
Deleted User01-Nov-18 10:39 PM
re
Deleted User01-Nov-18 10:49 PM
The scripts are not komodo specific, they are using any coin cli to make it possible. Coins like ETH, (I really hope I'll be able to integrate it) will also be integrated. In fact any coin having a CLI could theorically be integrated, without any scaling issue as they can sit on multiple servers.
The thing is : It will make every KMD AC easier to buy/trade, and will at the same time be useful to any trader that want to be recognized as trustworthy (A reputation system is planned).
With current "tech", we can't say it's KMD "powered", but if this project is successful and people like the concept maybe in the future there will be a possibility to use different method and get rid of infrastructure, or the project may also go on a totally different way and just develop an exchange feature
Deleted User01-Nov-18 10:59 PM
any new KMD assetchain will be exchangeable natively on the platform, this point may also help motivate devs to choose to create assetchain on KMD, or migrate their existing token into a KMD AC.
Obviously, Barterlly alone won't be the reason people would choose to use kmd tech instead of something else, but at least it will be a brand new tool that didn't exist before.
KomodoWorld01-Nov-18 11:03 PM
thanks for the explanation, you make really good points
Deleted User01-Nov-18 11:04 PM
I believe this is only a first step, this will allow us to see if there is a real real demand and market for it, and if we can catch it


TELOS Child Care exists to help school-age children develop optimally. TELOS (tel-las) is a Greek word that reflects the ultimate goal of human development: the ability to have healthy two-way relationships with others and with God.
Serving children in grades K through 6, we provide before and after-school care, and full-day programs during school holidays. We provide transportation from Maidu and Excelsior schools, and academic assistance for homework support.
Our flexible scheduling and hourly billing mean that we can accommodate your unique child care needs 24/7 (except school hours), five days a week. A special camp program is offered during the summer months.
The TELOS program includes reading and library resources, homework time, structured activities and projects as well as time for unstructured indoor and outdoor play. Especially popular are the 12-ft. Trampoline and the treehouse. Children make wide use of art materials, a music area, indoor soccer, Nerf dart tag and many creative toys and project materials.
With our emphasis on physical activity, children recieve plenty of healthy and appealing snacks; nutritious meals are served for a modest fee when child care spans breakfast, lunch or dinner time.
Exercise, fresh air and adventure are some of the hallmarks of the TELOS experience. Not being confined to a building sets us apart.
We have regular excursions to places of interest, exploration and recreation. Kids love riding scooters and bikes to local parks, exploring nearby creeks and geocaching, enjoying the snow and visiting the swimming pool weekly.
The exceptional 1:6 teacher-child ratio provides children with twice as much positive adult attention as other providers, whose more typical ratio is 1:14.
The close interaction between teacher and child enables meaningful mentoring to support healthy socialization. Children learn how to make and sustain friendships and function successfully in a group setting. Sharing, teamwork and empathy and part of daily activities.
At the heart of TELOS is the acclaimed Core Essential Values character development curriculum, where children learn to treat others right, make smart decisions, and maximize their potential. We use a monthly value as a theme throughout all our activities.
It has been proven that children exposed to this curriculum improve academically and behaviorally. Bullying goes down, while respect and achievement go up.
TELOS Child Care helps the child learn a healthy model for relationships characterized by:
* Jack Balswick, Pamela E. King, and Kevin Reimer, The Reciprocating Self: Human Development in Theological Perspective (Downers Grove, IL; InterVarsity Press, 2005).


View more of my work here.
My name is Jerica Mitchell and I am an up and coming web developer based in the Houston, Texas area (Go Texans!!! 🏈). I have a passion for problem solving and designing. I design responsive websites and web applications.
I have a bachelor's degree in Information Technology. With my background in IT, I am able use gui and command line interfaces and work with Git, Angularjs, Nodejs, MongoDB, RESTful, and many other front-end and back-end technologies.
I am constantly learning new things I can use within my projects. My goal is to learn as much as I can and produce awesome applications geared toward helping people. I am currently freelancing and I am open to a full-time position at with a great organization. I have so many great ideas for applications that I want to share with the world. If you'd like, you can view my LinkedIn profile or send me an email in the form provided below.
Current Coursework: The Web Development Bootcamp on Udemy.com.