The Postgres module reference.
Information objects available in the Postgres module.
Attributes:
- Postgres.backend_start
The Postgres.types.timestamptz specifying when the backend was started. Shorthand for getting the backend start time from pg_stat_activity.
None if not available.
- Postgres.client_addr
The client’s address as a Python str.
None if not available.
- Postgres.client_port
The client’s port as a Python str.
None if not available.
- Postgres.current_database
- The name of the current database as a Python str.
- Postgres.encoding
- The server encoding as a Python encoding name.
- Postgres.version
- The version of PostgreSQL as a Python str.
- Postgres.version_info
- The version of PostgreSQL as a Python tuple. The tuple’s items are (major, minor, patch, state, level).
- Postgres.CONST
A dictionary object providing many compile-time constants. This is primarily used to support the pure-Python parts of the Postgres module.
Functions should not depend on this object.
Postgres.Array is the base type of all Postgres array types in Python. When an uninitialized array type is referenced, a subclass of this type is created to represent the array type.
Constructors:
- Array(string_or_nested_lists)
If given a string, an array will be created using the type input function. If given a list, the objects contained in the list will make up the elements in the array. Multi-dimensional arrays can be built using lists by nesting them:
from Postgres import WARNING from Postgres.types import int4 a = int4.Array([ [[1,2],[4,3]], [[12,14],[16,18]], [[-18,-14],[-15,-20]], ]) WARNING(str(a))- Array.from_elements(iter [, dimensions = (N,) [, lowerbounds = (1,)]])
Build an array from an iterator producing coercable elements and the specified dimensions and lower bounds. The iterator is the only required argument.
The dimensions and lowerbounds keywords must be sequences of the same length if provided at all. If no lowerbounds are given, a default will be provided: all the lower bounds will be 1. If no dimensions are given, a default will be generated based on the length of the iterable.
Properties:
- Array.dimensions
- A tuple containing numbers that represent the dimensions of the array.
- Array.has_null
- Whether the array has NULLs.
- Array.lowerbounds
- A tuple of numbers representing the lowerbounds of the array.
- Array.ndim
- The number of dimenions in the array.
- Array.nelements
- The number of elements in the array.
- Array.Element
- Postgres.Type instance of the array’s element type.
Methods:
- Array.elements()
- Return an iterator that produces all the elements of the array. The elements are produced in physical order.
- Array.get_element(sequence)
Return the element addressed by the sequence argument. This method takes a sequence of zero-based indexes that are adjusted by the array’s configured lower bounds. Indexes that are out-of-bounds cause index errors. ValueError is raised when too many or too few indexes are given in the sequence:
from Postgres.types import int4 _int4 = int4.Array A = _int4([[1,2],[3,4]) assert A.sql_get_element((0,0)) == 1 # In SQL: SELECT (ARRAY[[1,2],[3,4]]::int4)[1][1]- Array.sql_get_element(sequence_of_indexes)
Return the element addressed by the sequence_of_indexes argument. The method is consistent with how array elements are accessed in SQL. Slicing is not supported by this method. Indexes that are out-of-bounds result in ``None`` being returned.:
from Postgres.types import int4 _int4 = int4.Array A = _int4([[1,2],[3,4]) assert A.sql_get_element((1,1)) == 1 # In SQL: SELECT (ARRAY[[1,2],[3,4]]::int4)[1][1]- Array.__getitem__(index_or_slice), Array[index_or_slice]
Get a slice, sub-array, or element from the array. If given an index, the sub-array or element at that index will be returned.
Note
Slices only support steps of one.
Note
This interface expects zero-based indexes.
- Array.__len__(), len(Array)
- The upper bounds of the first axis minus the lower bounds of the first axis plus one. The natural length of the first axis.
Cursor objects provide a Python interface to Postgres Portals. Primarily, cursors are iterators that yield rows produced by the Portal. However, the execution method used on the statement object ultimately determines how the cursor operates. For instance, the chunks() method will cause next() to return sequences of rows instead of individual rows. See Postgres.Statement for more information about the execution methods that create cursor objects.
Properties:
- Cursor.statement
- The Postgres.Statement object that created the cursor.
- Cursor.parameters
- The original arguments given to the statement that created the cursor.
- Cursor.column_types
- A tuple of Postgres.Type instances of the columns produced by the cursor.
- Cursor.column_names
- A tuple of strings naming the columns produced by the statement.
- Cursor.pg_column_types
- A tuple of type Oids of the columns produced by the cursor.
- Cursor.output
A fully anonymous Postgres.types.record used to create record objects produced by the statement.
Normally, this is the same object as Cursor.statement.output.
- Cursor.direction
- For scrollable cursors, this is a modifiable property used to control the direction of seek and read operations. True for forward, the default. False for backwards. The configured direction affects seek, read, and next methods.
- Cursor.chunksize
For NO SCROLL cursors, this property is used to control the size of the chunks read from the Portal. For row cursors, the chunksize effects how many rows should be internally buffered for subsequent consumption via __next__.
This property is immutable for SCROLL cursors; cursors created using the declare() method. For such cursors, __next__ only reads a single row at a time.
Methods:
- Cursor.close()
- Close the cursor, inhibiting further use. Returns None. Nothing happens if it is already closed.
- Cursor.clone()
- Create a replica of the cursor using the same statement, method, and parameters. The new cursor is returned.
- Cursor.seek(offset[, whence = 0])
- Move the cursor’s position to the specified offset according to the whence keyword argument. Whence behaves consistently with seek operations on file objects. 0 for absolute, 1 for relative, and 2 for absolute from the end.
- Cursor.read([quantity[, direction = None]])
- Read the requested number of rows in the resolved direction. If no quantity is specified, all of the remaining rows will be returned.
- next(Cursor), Cursor.__next__()
Get the next item from the cursor. For cursors created by the chunks execution method, this will return a list of row objects. Any other cursors will return the next row according to its current position–and direction for scrollable cursors.
In compliance with the iterator protocol, this method will raise StopIteration when the cursor is exhausted.
When a database error occurs, this type is used to provide a Python interface to the information collected about the error. Normally, instances of this type are associated with an Postgres.Exception instance using the pg_errordata attribute.
Properties:
- ErrorData.message
- Error ‘message’ field as a Python str object.
- ErrorData.elevel
- Error-level as a Python int object. Usually, Postgres.CONST["ERROR"].
- ErrorData.severity
- Error-level as a Python str object. Usually, "ERROR".
- ErrorData.code
- Error code field as a Python str object.
- ErrorData.sqlerrcode
- Encoded error code field as a Python int object.
- ErrorData.detail
- Error detail field as a Python str object.
- ErrorData.context
- Error ‘context’ field as a Python str object.
- ErrorData.domain
- Error domain field as a Python str object.
- ErrorData.hint
- Error ‘hint’ field as a Python str object.
- ErrorData.filename
- Error ‘filename’ field as a Python str object.
- ErrorData.function
- Error ‘function’ field as a Python str object.
- ErrorData.line
- Error ‘line’ (number) field as a Python int object.
- ErrorData.internal_position
- The ‘internalpos’ field as a Python int object.
- ErrorData.cursorpos
- The cursor position field as a Python int object.
- ErrorData.saved_errno
- ‘saved_errno’ field as a Python int object. This represents the system errno that caused the database error.
The exception raised when a Postgres database error occurs:
import Postgres
try:
with xact():
Postgres.ERROR(message = 'internal error', code = 'XX000')
except Postgres.Exception as dberr:
if dberr.code == 'XX000':
pass
else:
raise
Constructors:
- Exception([pg_errordata = None])
Create the exception using the given Postgres.ErrorData object.
The Postgres.ERROR wrapper to Postgres.ereport is the preferable way to construct and throw this exception.
Properties:
- Exception.code
- The error code as a string.
- Exception.details
- A dictionary object consisting of a subset of the attributes on the assigned pg_errordata attribute.
- Exception.errno
- The errno attribute on pg_errordata.
Exception.message
The error message.
- Exception.severity
- The severity of the error as a string. Almost always, 'ERROR'.
- Exception.pg_errordata
- The Postgres.ErrorData instance describing the database error.
Function objects are used to provide access to a Postgres function’s functionality and basic metadata. These objects are used to work with any Postgres function, not just Python functions.
Constructors:
- Function(oid)
- Create an instance using the given Oid. The Oid will be used to lookup the function’s information in pg_catalog.pg_proc.
Properties:
- Function.oid
- The function’s oid as a Python int object.
- Function.oidstr
- The function’s Oid as a Python str object.
- Function.namespace
- The function’s namespace Oid as a Python int.
- Function.nspname
- The name of the function’s namespace as a Python str.
- Function.filename
- The function’s qualified regprocedure representation.
- Function.language
- The language Oid of the function as a Python int.
- Function.input
- A Postgres.TupleDesc describing the function’s arguments.
- Function.output
- The return type, a Postgres.Type instance.
Methods:
- Function.__call__(*args)
Call the Postgres function with the given arguments.
The arguments that the function takes depend on the signature of the Postgres function itself. The given arguments will be coerced to the Postgres argument types, then the function will be invoked with those created Datums. The input attribute describes the parameters taken by the function.
Direct function invocation cannot be used with set returning, trigger returning, or polymorphic functions.
PEP-302 Methods:
These methods should only be used with Python FUNCTIONs.
- Function.is_package([fullname])
- Always returns False.
- Function.get_source([fullname])
Get the function’s source code.
The fullname parameter is optional, but if it is provided it must be a string that equals string form of the function’s Oid.
- Function.get_code([fullname])
Get the code object that the function’s source code compiles into.
The fullname parameter is optional, but if it is provided it must be a string that equals string form of the function’s Oid.
- Function.load_module([fullname])
Load the function module. If the module doesn’t already exist in sys.modules, a new module will be created and the function’s code will be executed. This will not invoke any entry points.
The fullname parameter is optional, but if it is provided it must be a string that equals string form of the function’s Oid.
Function.find_module(fullname[, path])
Create a function object from the given fullname. The fullname must be a function Oid.
find_module is a class method.
A file-like interface to large objects.
Warning
Using large objects in conjunction with subtransactions can lead to internal errors.
Constructors:
- LargeObject.create()
- Create a new large object.
- LargeObject.tmp()
- Create a new large object that is unlinked after its closed.
- LargeObject(oid[, mode = 'r'])
The instance constructor.
Open the large object at the given Oid.
Properties:
- LargeObject.oid
- The large object’s oid.
Methods:
- LargeObject.unlink()
- Close and remove the large object.
- LargeObject.close()
- Close the large object.
- LargeObject.read(nbytes)
- Read data from the large object.
- LargeObject.write(data)
- Read data from the large object.
- LargeObject.seek(offset[, whence = 0])
- Seek to the target offset.
Postgres.Object is the base type of all Postgres types. Instances are, effectively, a Postgres Datum associated with the respective type. Postgres.Object instances are a Python interface to Postgres data. See Data for more information.
The interfaces described here are applicable to instances of subclasses. Postgres.Object itself is abstract, so the described constructors, properties, and methods only apply to subclasses of Postgres.Object.
The Python operator methods are mapped to Postgres operators. Most are mapped to syntactically identical operators, but some are mapped semantically identical operators. This table shows the default mapping, but some types override this in order provide the expected functionality–notably, string types will map __add__ to "||".
Binary Operators:
| Python Operators | Postgres Operators |
|---|---|
| +, __add__ | + |
| -, __sub__ | - |
| *, __mul__ | * |
| /, __div__ | / |
| %, __mod__ | % |
| **, __pow__ | ^ |
| &, __and__ | & |
| |, __or__ | | |
| ^, __xor__ | # |
| <<, __lshift__ | << |
| >>, __rshift__ | >> |
Unary Operators:
| Python Operators | Postgres Operators |
|---|---|
| -, __neg__ | - |
| ~, __invert__ | ~ |
All comparison operators are syntactically mapped. Although, == is reduced to =.
Constructors:
Object(pystr[, mod = strseq])
Create a new data object using the given Python string. For many built-in subclasses, this is specialized to accept other kinds of Python objects. However, when a Python str is given, the type’s input function is always used.
The mod keyword is optional and can be used to specify the typmod for the data. The given object is coerced to a Postgres.types.cstring.Array and given to the type’s typmodin function. If mod is None, the default, -1 will ultimately be used.
Properties:
- Object.datum
- The raw Datum as a Python long. Read-only. Do not use this.
Methods:
- Object.__str__(), str(Object)
- Return the data object’s string representation as a Python str. The string is created by the type’s output function.
- Object.__int__(), int(Object)
Attempt to instantiate a Python int from the string representation of the object. int(str(o))
Numeric subclasses normally override this default functionality.
- Object.__bool__(), bool(Object)
- Cast the data object to a Postgres BOOL, and return the truth as a Python bool.
Object.__abs__(), abs(Object)
Execute the abs(Object::<pg_type.typname>) function that takes the type as its sole parameter.
The decorator for managing the call state of an entry point. If a given entry point is decorated with Postgres.Stateful, the callable is expected to return a state object to be used when the function is executed in the future. The state object is normally a generator that can receive objects via the send method:
from Postgres import Stateful
@Stateful
def main(*args):
args = (yield object)
while 1:
args = (yield object)
See Stateful Functions for more information.
Constructors:
- Stateful(ob)
- Create an instance using ob as the source of state.
Properties:
- stateful.source
- The object that will be called to get the state object.
Methods:
- stateful.__call__(*args, **kw), stateful(*args, **kw)
If the call has no pre-existing state, the given parameters will be given directly to the stateful.source object. The object returned by that call will have its __next__ method immediately invoked in order to extract the return object.
If the call has pre-existing state, the given parameters will be given to the state object’s send method. If StopIteration is raised, the state object will be created again as if there was no pre-existing state.
Statement objects provide an interface to fully-planned, single, statements. Statements are the primary interface for accessing the database in Python.
A statement object is created by calling Postgres.Statement with an SQL string as the first argument. Subsequent arguments can be given to specify constant parameters, but when this is done, all of the statement’s parameters must be provided.
When a statement is invoked, a Postgres.Cursor object is created and used to manage the Portal. The chosen statement execution method determines how the cursor behaves or if a cursor is even returned.
Properties:
- Statement.parameter_types
- A tuple of Postgres.Type instances. The index of each item corresponds to the parameter required by the statement.
- Statement.column_types
- A tuple of Postgres.Type instances. The index of each item corresponds to the columns produced by the statement.
- Statement.column_names
- A tuple of strings naming the columns produced by the statement.
- Statement.pg_parameter_types
- A tuple of type Oid’s specifying the parameter types.
- Statement.pg_column_types
- A tuple of type Oid’s specifying the column types.
- Statement.input
- A Postgres.TupleDesc object describing the statement’s parameters.
- Statement.output
- An anonymous composite type used to create row objects produced by the statement.
- Statement.string
- The original object given as the statement’s SQL source.
- Statement.command
- The command tag of the statement.
- Statement.parameters
- The constant parameters given to the statement’s constructor. None if none.
Methods:
- Statement.clone()
- Create a new statement using the same parameters that created the statement that method is being called on.
- Statement.rows(*args)
Execute the statement and return a Postgres.Cursor configured to yield individual rows fetched from the cursor.
The returned cursor is to be used to iterate over the rows produced by the statement.
- Statement.column(*args)
- Execute the statement and return a Postgres.Cursor configured to yield the first column of each row fetched from the cursor.
- Statement.chunks(*args)
- Execute the statement and return a Postgres.Cursor configured to yield chunks of rows fetched from the cursor.
- Statement.first(*args)
- Execute the statement and return either the first column of the first row, or the first row when multiple columns are present.
- Statement.declare(*args)
- Execute the statement and return a Postgres.Cursor configured with SCROLL. This execution method provides a cursor whose seek and read methods are usable.
- Statement.load_rows(iterable)
- Repeatedly execute the statement for each item produced by the iterator. Each item will be given as the parameters for the statement.
- Statement.load_chunks(iterable)
Repeatedly execute the statement for each item in the iterable produced by the iterator. Each item is expected to be a iterable producing parameters to be given to the statement:
sqlexec("CREATE TABLE t (i int, t text)") chunk1 = [(1, 'hello'), (None, 'world')] chunk2 = [(5, 'more'), (6, 'data')] ins = prepare("INSERT INTO t VALUES ($1, $2)") ins.load_chunks([chunk1, chunk2])
A flow-control exception used by trigger returning functions to stop a manipulation.
This exception is treated specially when raised by the before_insert, before_update, and before_delete entry points in Trigger Returning Functions. In all other cases, the exception will thrown as a Postgres error:
from Postgres import StopEvent
def before_insert(td, new):
if new["value"] == 0xDEADBEEF:
raise StopEvent
Postgres.String is an abstract base type. It is used as the base type for all built-in string types and for any dynamically created type that is in the string category: pg_type.typcategory = 'S'
Transaction objects are simple context managers that start, commit or rollback an internal subtransaction. The local transaction state kept by these objects are used to validate that transactions are committed or aborted in the appropriate order. When transactions objects are used improperly, a Postgres.Exception is normally raised. Postgres.Transaction is also available in Builtins as xact:
with xact():
...
Methods:
- Transaction.__enter__()
- Context manager interface that starts the internal subtransaction. A RuntimeError will be raised if called more than once on the same instance.
- Transaction.__exit__(exc, val, tb)
Aborts or commits the transaction depending on the given arguments and the identified transaction state.
If an exception is noted by the arguments or the transaction failed due to database error, the subtransaction will be rolled back. A False value will always be returned indicating that the exception, if any, should be raised.
If no exception is noted and no database error occurred, the subtransaction will be committed.
When a TRIGGER returning function is executed by an event, instances of this type are given as the first argument to the selected entry point. This object provides the basic information about the trigger that executed the procedure, the target table, and the event’s details.
Some of the provided information is redundant as the entry point selected by the procedural language determines the timing, orientation, and manipulation. However, for generalized triggers, identifying the execution context using the trigger data can be appropriate.
See Trigger Returning Functions for further information.
Properties:
- TriggerData.args
- Python tuple of trigger arguments specified by CREATE TRIGGER. The items in the tuple are str objects.
- TriggerData.type
- The Postgres.types.record subclass representing the target table. For row triggers, it is also the type of the old and new parameters.
- TriggerData.relation_id
- The Oid of the target table.
- TriggerData.table_schema
- The schema name that holds the target table.
- TriggerData.table_name
- The table name of the target table.
- TriggerData.trigger_schema
- The schema name that holds the trigger.
- TriggerData.trigger_name
- The name of the trigger. Defined by the CREATE TRIGGER statement that originally created the TRIGGER.
- TriggerData.manipulation
The operation that caused the trigger to execute the procedure. Always one of:
- 'INSERT'
- 'UPDATE'
- 'DELETE'
- 'TRUNCATE'
- TriggerData.orientation
Identifies if the trigger was fired at the row level or the statement level. Always one of:
- 'ROW'
- 'STATEMENT'
- TriggerData.timing
When the trigger executed the procedure. Always one of:
- 'BEFORE'
- 'AFTER'
- TriggerData.table_catalog
- The name of the current database.
- TriggerData.trigger_catalog
- The name of the current database.
The Python interface to the TupleDesc structures. This is essentially a sequence of pg_attribute instances. Normally, these objects are used to support composite types and do not need to be used directly.
Properties:
- TupleDesc.column_count
Number of attributes in the descriptor.
This count does not include dropped columns.
- TupleDesc.column_names
A tuple of strings naming the attributes in the descriptor.
This sequence does not include dropped columns.
- TupleDesc.column_types
A tuple of Postgres.Type instances of the attributes in the descriptor.
This sequence does not include dropped columns.
- TupleDesc.pg_column_types
A tuple of type Oids of the attributes in the descriptor.
This sequence does not include dropped columns.
Methods:
- TupleDesc.__getitem__(index), TupleDesc[index]
Get the pg_attribute instance of the index.
The returned record may be for a dropped attribute.
- TupleDesc.__len__(), len(TupleDesc)
The total number of attributes in the descriptor.
This count will include dropped attributes.
Postgres.Type is Postgres.Object‘s type. Instances of this type, Postgres.Object and subclasses thereof, are used to represent Postgres types. These objects provide access to type metadata and instantiation methods to create Data.
Constructors:
- Postgres.Type(oid)
A Postgres.Type instance can be created by calling Postgres.Type with a type oid as it’s sole argument. If the type exists, a Postgres.Object subclass is returned.
The given Oid can be a Python int, Postgres.types.oid, or a Postgres.types.regtype instance.
Properties:
- Type.Array
- The array type of the element type. If the instance is an array type, this property will be the same object as the instance. Postgres.Array.
- Type.Base
- The ultimate base type of the domain type. If the instance is not a domain, this property will be the same object as the instance.
- Type.Element
- The element type of the array type. If the instance is not an array type, this property will be the same object as the instance.
- Type.oid
- The type’s Oid as a Python int.
- Type.oidstr
- The type’s Oid as a Python str.
- Type.typname
- The type’s name as a Python str.
- Type.nspname
- The type’s namespace name as a Python str.
- Type.typnamespace
- The type’s namespace Oid as a Python int.
- Type.descriptor
- The type’s Postgres.TupleDesc. None, if the type is not a composite type.
- Type.column_names
The attribute names of the type’s TupleDesc in a Python tuple. Ordered by the attribute’s index.
This does not include dropped attributes.
- Type.column_types
The attribute types, Postgres.Type instances, of the type’s TupleDesc in a Python tuple. Ordered by the attribute’s index.
This does not include dropped attributes.
- Type.pg_column_types
The attribute type Oids of the type’s TupleDesc in a Python tuple. Ordered by the attribute’s index.
This does not include dropped attributes.
Methods:
- Type.typoutput(ob)
- Call the type’s typoutput routine. The given object must be an instance of this type. Usually, str(ob) suffices.
- Type.typsend(ob)
- Call the type’s binary send routine. The given object must be an instance of this type.
- Type.typinput(strob[, mod = pyint])
- Call the type’s string input routine. This is different from instantiation as the typmod is not passed through the type’s modin.
- Type.typreceive(bufob[, mod = pyint])
- Call the type’s typreceive routine. The given object, bufob, must support the Python buffer protocol.
- Type.typmodin(sequence)
- Call the type’s modin routine. Takes a sequence of strings, cstring[] and returns an int4.
- Type.typmodout(num)
- Call the type’s modout routine. Takes an integer and returns a cstring.
- Type.check(ob)
- Validate that the domain adheres to its constraints. The given object must be an instance of this type.
Cancel the query of another backend process, alias to the pg_cancel_backend function. Returns a Python bool, and takes a number as it’s sole argument:
from Postgres import cancel_backend
cancel_backend(procpid)
Releases Postgres.Type and Postgres.Function objects from the cache. It also clears the Python linecache if the module is available:
from Postgres import clearcache
clearcache()
Normally, it is not necessary to ever call this function. When a function or type is looked up in the cache, its entry is checked to validate that it is up-to-date. If it needs to be refreshed, a new object reflecting the latest version will be created to replace the existing cache entry.
Note
This function has no effect on built-in types.
Get the current clock timestamp. Takes no arguments and returns a Postgres.types.timestamptz:
from Postgres import clock_timestamp
curtime = clock_timestamp()
Convert the Postgres.Object instances in the given iterable into standard Python types. A tuple with the converted objects is returned:
from Postgres import convert_postgres_object
from Postgres.types import int4, text
pg_data = [int4(123), text('foo'), set([1,2,3])]
py_data = convert_postgres_objects(pg_data)
assert py_data[0].__class__ is int
assert py_data[1].__class__ is str
# ignores unidentified types
assert py_data[1].__class__ is set
Data objects whose type is not listed in the table below are not converted.
| Postgres Types | Python Types |
|---|---|
| bool | bool |
| int2 | int |
| int4 | int |
| int8 | int |
| float4 | float |
| float8 | float |
| char | str |
| bpchar | str |
| varchar | str |
| cstring | str |
| text | str |
Arguments:
- iterable
- An iterable containing the objects to convert.
Postgres.current_schemas provides a structured version of the search_path setting. Like pg_catalog.current_schemas, but returns a Python tuple of Python strings:
import Postgres
schemas = Postgres.current_schemas()
all_schemas = Postgres.current_schemas(True)
Arguments:
- include_temps
- Optional keyword. Defaults to ``False``. Include the temporary schemas in the returned tuple.
Postgres.current_schemas_oid provides a tuple of namespace Oids based on the search_path setting:
import Postgres
schemas = Postgres.current_schemas_oid()
all_schemas = Postgres.current_schemas_oid(True)
Warning
The Oids may refer to namespaces that no longer exist.
Arguments:
- include_temps
- Optional keyword. Defaults to ``False``. Include the temporary schemas in the returned tuple.
Postgres.ereport([severity[, message[, detail[, hint[, context[, sqlerrcode[, inhibit_pl_context]]]]]]])
Postgres.ereport is an interface to Postgres’ ereport facility. Direct use is not recommended as the aliases provide some added convenience over the raw function:
- Postgres.DEBUG
- Postgres.LOG
- Postgres.INFO
- Postgres.NOTICE
- Postgres.WARNING
- Postgres.ERROR
- Postgres.FATAL
In addition to the severity being implied by the name, the aliases can accept an additional code argument which is converted to an SQL-state code. This is in contrast to ereport, which can only take the sqlerrcode keyword as an integer:
import Postgres
def main(...):
Postgres.WARNING("unexpected event")
Postgres.WARNING("extra info", code = '01001')
Postgres.LOG("additional information about the event", detail = event_details)
Postgres.ereport(Postgres.severities['DEBUG4'], "direct report")
Keyword Arguments:
- severity
- The first, required keyword parameter. This is expected to be the integer form of the error level. The mapping of severity names to error level integers is available at Postgres.severities.
- message
- The second, required keyword parameter. This is the primary message portion of the report. This string is given to errmsg
- detail
- String given to errdetail.
- hint
- String given to errhint.
- context
- String given to errcontext.
- sqlerrcode
- SQL-state integer given to errcode.
- code
The SQL-state string. This is converted to an SQL-state integer and given as the sqlerrcode keyword.
This keyword is not accepted by Postgres.ereport. See the aliases listed above.
- inhibit_pl_context
- If given True, the traceback and function identity will not be included in the CONTEXT portion of the report.
Postgres.eval is a function that uses Postgres.Statement to execute an SQL-expression:
import Postgres
def main(...):
r = Postgres.eval("now()::date - 10")
It is also available in Builtins as sqleval.
Execute multiple SQL statements in the given string. This function takes a single argument, a string containing the SQL statements to execute. This function always returns None:
import Postgres
Postgres.execute("""
CREATE TEMP TABLE t (i int);
INSERT INTO t VALUES (321);
""")
Also available in Builtins as sqlexec.
Arguments:
- sql_statements_string
- A string object containing the SQL statements to execute.
A callable that produces an iterator that uses Postgres.convert_postgres_objects to convert the sequences produced by the given iterable into Python types:
from Postgres import iterpytypes
stmt = prepare("SELECT i FROM generate_series(1, 100) AS g(i)")
# process the rows() cursor with iterpytypes
results = iterpytypes(stmt.rows())
# iterate over the results as Python types
for row in results:
i = row[0]
...
iterpytypes yields Python tuples.
Arguments:
- iter
- An iterable producing sequences of Postgres.Object instances.
Postgres.notify is an alias to the NOTIFY command. It only takes a single argument, the notification name:
import Postgres
Postgres.notify("relid")
Arguments:
- relname
- The notification channel to use.
Preload provides a means to load a set of functions before they are actually used. The arguments accepted by the function are schema identifiers. The Python functions in each schema are collected and loaded. If no schemas are given, all Python functions in the database are loaded:
import Postgres
Postgres.preload("schema1", "schema2")
Essentially, pg_proc is queried for all Python function Oids, Postgres.Function instances are created from each Oid, and the load_module method is called on each instance to ready the function’s code.
Tip
Using preload in conjunction with a pooler helps to make sure that the initialization overhead will not impact the performance of the function’s first call.
A decorator that uses Postgres.convert_postgres_objects to convert the arguments given to the decorated function into standard Python objects:
@pytypes
def main(...):
...
The decorator only converts objects to Python primitives.
Postgres.quote_ident is an alias to the quote_ident function. It only takes a single argument, the identifer string to quote:
from Postgres import quote_ident
id = quote_ident('an"identifier')
assert id == '"an""identifier"'
Postgres.quote_literal is an alias to the pg_catalog.quote_literal function. It only takes a single argument, the string to quote:
from Postgres import quote_literal
x = quote_literal('an"literal\'string')
assert x == """'an"literal''string'"""
Postgres.quote_nullable is an alias to the pg_catalog.quote_nullable function. It only takes a single argument, the string to quote. If given None, the string 'NULL' will be returned:
from Postgres import quote_nullable
x = quote_nullable('an"literal\'string')
assert quote_nullable(None) == 'NULL'
assert x == """'an"literal''string'"""
sleep(seconds_to_sleep : float)
Alias to the pg_sleep function. Takes a single argument, the amount of time to sleep and always returns None:
from Postgres import sleep
sleep(0.5)
Get the statement start time–an alias to the statement_timestamp function. Takes no arguments and returns a Postgres.types.timestamptz:
from Postgres import statement_timestamp
assert sqleval('pg_catalog.statement_timestamp()') == statement_timestamp()
transaction_timestamp()
Get the transaction start time–an alias to the transaction_timestamp function. Takes no arguments and returns a Postgres.types.timestamptz:
from Postgres import transaction_timestamp
assert sqleval('now()') == transaction_timestamp()
terminate_backend(process_pid)
Terminate another backend process–alias to the pg_catalog.pg_terminate_backend function. Takes a single argument, the process id to terminate, and returns bool indicating whether the specified backend was successfully terminated:
from Postgres import terminate_backend
terminate_backend(proc_pid)


Load
Save
Volume
Step
Loop
Release
Glide
WAVEFORM
?
Waveform selector shows which waveform is used for each of the 32 steps
Click to select one of the waveform tools on the right
Use mouse to paint individual steps in the waveform view to apply the selected waveform
Double-click the tool to automatically paint all the steps
PITCH
?
Pitch envelope shows the pitch bend amount for each of the 32 steps
Click and hold mouse button in the pitch envelope view to adjust the pitch bend amount in one semitone increments
Pitch bend range is from -32 to +31 semitones.
You can select an effect by clicking one of the four effect tools
The effect is applied for the step when you adjust its pitch bend amount
Double-click the tool to apply the effect for all the steps
AMPLITUDE
?
Amplitude envelope shows the amplitude level for each of the 32 steps
Click and hold mouse button in the amplitude envelope view to adjust the amplitude level
You can select an effect by clicking one of the four effect tools
The effect is applied for the step when you adjust its amplitude level
Double-click the tool to apply the effect for all the steps


Income List
Log Out
Dashboard
Income Item
Income Value
+
×
Budget Form
Click on '+' button to add an income
Click on
to edit an income
Click on
to delete an income
please enter your income
please enter income amount
Add income
Edit your income
Edit income amount
Save changes


In this article we present how to automatically generate a network timeline such as the one in Chrome dev tools.
Capture the network traffic
The first step of our mission will be to capture the network traffic. In order to do that, we are going to use Selenium and BrowserMob Proxy, as well as PerfCascade.
Selenium will be used with Chromedriver to control Chrome and create web traffic. On the other side, we will use BrowserMob Proxy to capture the HTTP traffic and export it to a .har file.
In order to instrument these libraries we’ll use Python. However, keep in mind that you could also do this with other languages having a wrapper for Selenium and BrowserMob Proxy such as Java.
Python code
Visualisation of HAR file
Once this code has been run, we obtain a file formatted according to the HTTP Archive format (har format). It is based on JSON, and enables to standardize the representation of HTTP transactions.
Several websites such as G Suite toolbox or Stiel.io enable to easily visualise har files.
In our case we are going to use the PerfCascade Javascript library. Thus, if we want we can fully automate the process of collection and visualisation of the HTTP traffic.
We just need to add this CSS file at the beginning of our page, and the 2 Javascript files at the end.
The demo-page.js file initializes the options and generates the timeline graphic. In your case you need to replace data with your har’s file content. You also need to have a div with an “output” id in your HTML file.
Result
You can see the generated timeline below. It is possible to interact with the graphic and get more data by clicking on the different lines.
For further explanations about PerfCascade you can check the repository on Github.


Robotics applications are typically distributed, made up of a collection of concurrent asynchronous components which communicate using some middleware (ROS messages, ICE, DDS…). Building robotics applications is a complex task. Integrating existing nodes or libraries, which provide already solved functionality, and using several tools may increase the software robustness and shorten the development time. JdeRobot toolkit provides several tools, libraries and reusable nodes for Robotics and Computer Vision.
| Main Features |
|---|
| ROS friendly (full compatible with ROS-Kinetic) |
| C++, Python, JavaScript |
| Open Source |
| Easy installation from debian, PIP and npm packages |
Our (international) community mainly works on five fields inside Robotics and Computer Vision:
| Development Areas | Products |
|---|---|
| Robotics Education and Games | Robotics-Academy for engineering students |
| Kibotics online platform for children learning robotics | |
| MachineLearning in Robotics | DetectionStudio tool for evaluation of visual detection networks |
| BehaviorStudio tool for evaluation of control networks | |
| ObjectDetector see deep learning networks in action | |
| Robot Programming Tools | VisualCircuit visual robot programming using connected blocks and wires |
| VisualStates tool for robot programming with automata | |
| WebSim2D robot simulator with web technologies | |
| FPGAs in Robotics | neuralFPGA running deeplearning networks on FPGAs |
| FPGA-robotics designing robot intelligence with IceStudio blocks | |
| SLAM, visual localization | SDslam visual SLAM algorithm |
| slam-testbed tool for evaluation of SLAM algorithms |
We are registered as non-profit organization in Spain Ref.#615800.
News
- (2021/02/15) JdeRobot-base and JdeRobot-assets are now deprecated. Our toolkit is now fully ROS-based!.
- (2021/02/01) RoboticsAcademy 2.3.2 released. It includes four web based exercises, solve them from your browser :-)
- (2020/12/22) VisualCircuit tool has born, it is ready to use. Program your robot application using blocks and wires, as in electronic circuits.
- JdeRobot has been accepted as a mentoring organization for Google Summer of Code 2020, several students will be funded by Google to work in open projects of our organizaton. Check the proposed ideas list and our candidate selection process.


Your config file has been saved. Reboot your device, join the same WiFi station () as the Solar Server and click here.
Note: Windows users will have to open the serial monitor before rebooting, and then copy and paste the URL: logged after reboot. Unfortunately, Windows doesn't support mDNS.


A new means of performing with repurposed devices
Bendit_I/O is a system that allows for wireless, networked performance of circuit-bent devices, giving artists a new outlet for performing with repurposed technology. In a typical setup, a user pre-bends a device using the BendIt.io board as an intermediary, replacing physical switches and potentiometers with the board’s reed relays, motor driver, and digital potentiometer signals. BendIt.io brings the networking techniques of distributed music performances to the hardware hacking realm, opening the door for creative implementation of multiple circuit-bent devices in audiovisual experiences. Consisting of a Wi-Fi- enabled I/O board and a Node-based networking server, BendIt.io provides performers with a wide option of digital performance interfaces for controlling their hacked devices. Moreover, the BendIt.io system is user-friendly, low-cost, and modular, making it a flexible toolset for artists of diverse experience levels.


August 5
Watch and pray, that ye enter not into temptation: the spirit indeed is willing, but the flesh is weak.  Have you ever resolved never more to yield to a particular sin, yet when the temptation came, you fell right back into it? It's happened to all of us. Even the disciple Peter. He swore he would never deny Jesus...but he did it anyway, time and time and time again. There is, however, something we can do to keep from falling prey to temptations like that. We can "watch and pray." That's what Jesus told Peter and the other disciples to do in the Garden of Gethsemane. He knew they were about to be tempted, and He knew that the weakness of their flesh would overcome them if they didn't strengthen their spirits through prayer.
That's true for you and me too. That's why in Jude 20 and 21, God tells us much the same thing that Jesus told the disciples that night. He says, "But you, beloved, build yourselves up [founded] on your most holy faith... praying in the Holy Spirit: Guard and keep yourselves in the love of God" (The Amplified Bible). God knows even better than we do that our flesh has been trained to flow with the world's stream. He knows that even though our born again spirits are reaching for God, our untrained flesh will always have a tendency to fall into sin.
So, He's given us the ability to pray in other tongues, to strengthen our spirit and build it up until it takes ascendancy over our flesh. As we pray in the Spirit, Romans 8:26 tells us, the "(Holy) Spirit comes to our aid and bears us up in our weakness; for we do not know what prayer to offer nor how to offer it worthily as we ought, but the Spirit Himself goes to meet our supplication and pleads in our behalf" (The Amplified Bible).
Is it any wonder the Apostle Paul said, "I thank my God, I speak with tongues more than ye all!" (1 Cor. 14:18). It is one of the most powerful tools God has given us. So don't neglect to use it. Follow the instruction in Ephesians 6:18 and pray "always with all prayer and supplication in the Spirit...watching thereunto with all perseverance." Don't make the mistake that Peter made. When temptation comes to your door, don't let it catch you sleeping. Be prepared. Make sure your spirit is strong enough to rise above it.
Scripture Reading: Matthew 26:30-44


This class implements a special case of Hidden Markov Models that can be used to do connected word speech recognition for small vocabulary, using embedded training.
This class implements a special case of Hidden Markov Models that can be used to do connected word speech recognition for small vocabulary, using embedded training.It contains a SpeechHMM and a grammar (which states the legal sentences of the langage).
The decoding is done by creating the whole transition matrix and hence is not adapted to large vocabulary problems.
Alphabetic index HTML hierarchy of classes or Java


lib/ngx-responsivemenu/ngx-responsivemenu.module.ts
import { NgModule } from "@angular/core";
import { MenuItemDirective } from "./directives/menu-item.directive";
import { ResponsiveMenuComponent } from "./components/responsive-menu.component";
import { CommonModule } from "@angular/common";
import { OverflowContentDirective } from "./directives/overflow.directive";
import { OverflowControl } from "./provider/overflow.control";
import { MenuToggleDirective } from "./directives/menu-toggle.directive";
@NgModule({
imports: [
CommonModule
],
exports: [
MenuItemDirective,
MenuToggleDirective,
OverflowContentDirective,
ResponsiveMenuComponent,
],
providers: [ OverflowControl ],
declarations: [
MenuItemDirective,
MenuToggleDirective,
OverflowContentDirective,
ResponsiveMenuComponent,
]
})
export class ResponsiveMenuModule {
}


|
.NET Framework | |||||||||
| PREV TYPE NEXT TYPE | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONST | PROP | METHOD | OP | EVENT | DETAIL: FIELD | CONST | PROP | METHOD | OP | EVENT |
A cache of introspection information for a specific class instance. Keys {@link java.lang.Method} objects by a concatenation of the method name and the names of classes that make up the parameters.
| Constructor Summary | |
|---|---|
|
ClassMap(System.Type clazz) Standard constructor |
|
|
ClassMap() Initializes a new instance of the ClassMap class. |
| Method Summary | |
|---|---|
| System.Reflection.MethodInfo |
findMethod(string name, object[] params_Renamed) Find a Method using the methodKey provided. Look in the methodMap for an entry. If found, it'll either be a CACHE_MISS, in which case we simply give up, or it'll be a Method, in which case, we return it. If nothing is found, then we must actually go and introspect the method from the MethodMap. |
| System.Reflection.PropertyInfo |
findProperty(string name) Find a Method using the methodKey provided. Look in the methodMap for an entry. If found, it'll either be a CACHE_MISS, in which case we simply give up, or it'll be a Method, in which case, we return it. If nothing is found, then we must actually go and introspect the method from the MethodMap. |
| System.Reflection.MethodInfo |
getPublicMethod(System.Reflection.MethodInfo method) For a given method, retrieves its publicly accessible counterpart. This method will look for a method with same name and signature declared in a public superclass or implemented interface of this method's declaring class. This counterpart method is publicly callable. |
| System.Reflection.PropertyInfo | getPublicProperty(System.Reflection.PropertyInfo property) |
| Methods inherited from class System.Object |
|---|
| Equals, Finalize, GetHashCode, GetType, MemberwiseClone, ToString |
| Constructor Detail |
|---|
public ClassMap(System.Type clazz)
Standard constructor
public ClassMap()
Initializes a new instance of the ClassMap class.
| Method Detail |
|---|
public System.Reflection.MethodInfo findMethod(string name, object[] params_Renamed)
Find a Method using the methodKey provided. Look in the methodMap for an entry. If found, it'll either be a CACHE_MISS, in which case we simply give up, or it'll be a Method, in which case, we return it. If nothing is found, then we must actually go and introspect the method from the MethodMap.
public System.Reflection.PropertyInfo findProperty(string name)
Find a Method using the methodKey provided. Look in the methodMap for an entry. If found, it'll either be a CACHE_MISS, in which case we simply give up, or it'll be a Method, in which case, we return it. If nothing is found, then we must actually go and introspect the method from the MethodMap.
public System.Reflection.MethodInfo getPublicMethod(System.Reflection.MethodInfo method)
For a given method, retrieves its publicly accessible counterpart. This method will look for a method with same name and signature declared in a public superclass or implemented interface of this method's declaring class. This counterpart method is publicly callable.
Parameters:
method
- a method whose publicly callable counterpart is requested.
public System.Reflection.PropertyInfo getPublicProperty(System.Reflection.PropertyInfo property)
|
.NET Framework | |||||||||
| PREV TYPE NEXT TYPE | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONST | PROP | METHOD | OP | EVENT | DETAIL: FIELD | CONST | PROP | METHOD | OP | EVENT |


Task
Please correct the following error(s):
{{ error }}
Name
Age
Favorite Movie
Star Wars
Vanilla Sky
Atomic Blonde


'Hilary and Jackie' (1998)
A movie review by Walter Frith
<EMAIL_ADDRESS>Member of the ‘Online Film Critics Society' http://ofcs.org/ofcs/
'Hilary and Jackie' is the stuff that sibling rivalries are made of. Pleasant ones that is. As one of the most human stories of 1998, the film has the classic detail of what is supposed to happen while preparing a film script to go before the cameras. Director Anand Tucker has pictured the entire structure of the film inside his head perfectly and has elevated it to the screen with a unique and even structure that tells an old fashioned tale with the highest of culture. And, like 1996's 'Shine', Tucker makes the film about family even though it will be mistaken by many to be about music, which is its secondary theme.
No technical aspect of a motion picture is more important than the use of its music soundtrack. I remember some years ago at the Oscar ceremonies that a clip was shown from several motion pictures without their music background and the audience laughed at how preposterous it was and then broke into applause when the same scenes were shown with their music included, showing a stark contrast that allowed people to breath a sigh of relief at just how important music is to a film. 'Hilary and Jackie' has a beautiful classical score that overwhelms the audience with genuine emotion and makes it even more memorable than it would be with a lesser emphasis on musical harmony.
Jaqueline du Pré (Emily Watson) is a cellist and her sister Hilary (Rachel Griffiths) plays the flute. From the time they were children, their parents instilled in them a sense of musical pride and guided them through their studies to the level of professionals when they were still in their teens. Based on a true story set primarily in the 60's and 70's, the film has exquisite cinematography that sings a harmonic tune all its own.
The two women marry early in life and and while Hilary is clearly the more mature of the two, talent is surely abound in all forms of human personality. The true line that tests the theory of genius being formed on the brink of the human mind gone mad, the film touches on this fact without becoming heavy handed and the film proclaims that sometimes one needs family around them when all other forms of personal contact seem meaningless.
Children are forthcoming in their marriages and as the film progresses, the story throws itself deeper and deeper into the ocean in personal relationships that never seems tiresome or too intrusive but rather a theme that many can relate to.
Emily Watson made her film debut in 1996's 'Breaking the Waves' and received an Oscar nomination for it. This film (her 5th in three years) will almost certainly bring her her second nomination and she is even more powerful in this movie than in 'Breaking the Waves'. Her portrayal of Jaqueline du Pré in 'Hilary and Jackie' is complex, showing her genius for playing the cello while growing to despise playing it later in life. But this fact is never quite put across in a convincing manner and that isn't a negative reflection on the film. It simply means that Jaqueline du Pré, I believe, really wanted to play but was afraid of success and how her life might change while mastering her craft.
Without giving too much away for those unfamiliar with how this true story ends, let's just say that after viewing this film, you will not only have a deeper appreciation of music and film, but these things will seem small when seeing just how large the human heart can be.
OUT OF 5 > * * * * 1/2
Visit FILM FOLLOW-UP by Walter Frith http://www.cgocable.net/~wfrith/movies.htm
* * * * * - a must see * * * * 1/2 - don't miss it * * * * - an excellent film * * * 1/2 - a marginal recommendation * * * - can't quite recommend it * * 1/2 - don't recommend it * * - avoid it * - avoid it AT ALL COSTS 1/2 - see it at your own risk zero - may be hazardous to your health
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Re Urgent Assistance Kindly allow me the modesty of introducing myself. I am KEN GREEN KABILA,the son of the former head of state/ president of Congo-Kinshasha (then called Zaire) Mr. Laurent Desire Kabila. I am contacting you in order to ask for your assistance on this confidential Business proposal with full financial benefit for both of us. Before I go into further details please be informed that I am writing without any other person(s) pre-knowledge of my contacting you on this transaction. Therefore I will appreciate same attitude to be maintained all through. I have the sum of USD55Million from a secret sale of Diamond by my father before he was assassinated by one of his body guard (Rashid) on January 16th 2001, which I will like you to receive on my behalf due to security reasons,as my narration below will explain. But before I continue b e well informed that your share in this transaction has been calculated at 15% of the total sum of USD$55M, 5% for expenses and the rest for my family and me. My father as a real African traditionalist was a polygamist thereby having married so many wives, and my mother being the second wife of my father, My step brother Joseph, who is the current president of my country, is the son of the first wife and he does not have any knowledge about this deal. Already president Joseph is using his power to colonize all the money and private property, which my father left behind for the whole family. Now my mother and I are left with nothing in the inheritance of my late father's wealth. Our situation is seriously critical that we need your assistance to help us receive these funds overseas for proper investment. Let me quickly assure you the 100% safe proof of this transaction because the diamond sales are packaged from the onset in a pa ttern that shows no direct trace or linkage with us (Kabi! la family). At present the money is in cash and is secured in a financial institution company as consignment. The consignment will be released within seven (7) days of my being in receipt of your reply via my email address above only for security reasons. I am waiting for your swift and favorable response, and in case you have any question(s), do not hesitate to contact me.my alternative email is<EMAIL_ADDRESS>you can call me mmediately on my private phone number which is :229-988-039. Best Regards, KEN GREEN KABILA.


Login failed. Please check the information and try again.
OSB
Files
Logout
Bucket
Access ID
Password
Select file to upload:
Choose file
or just drop the files here to upload them immediately.
Drop files here:


Class com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL
Tests
| Test |
Duration |
Result |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 2.(2) |
0s |
passed |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 3.(3) |
0.001s |
passed |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider.(1) |
0.003s |
passed |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 2.(2) |
0s |
passed |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 3.(3) |
0s |
passed |
| com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider.(1) |
0s |
passed |
Standard output
21:47:34.324 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Start Up:
***************************Starting Up***************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider.(1) *
* Scenario:use DLProvider. *
* a:x *
* b:y *
*****************************************************************
21:47:34.325 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.325 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.325 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.326 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.327 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.333 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider.(1) *
* Scenario:use DLProvider. *
* a:x *
* b:y *
* c:3 *
***************************Finished Up***************************
21:47:34.341 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Start Up:
***************************Starting Up***************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 2.(2) *
* Scenario:use DLProvider 2. *
* a:x *
* b:y *
*****************************************************************
21:47:34.342 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.343 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.343 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.343 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.344 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.349 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 2.(2) *
* Scenario:use DLProvider 2. *
* a:x *
* b:y *
* c:3 *
***************************Finished Up***************************
21:47:34.353 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Start Up:
***************************Starting Up***************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 3.(3) *
* Scenario:use DLProvider 3. *
* a:x *
* b:y *
*****************************************************************
21:47:34.354 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.354 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.354 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.354 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.355 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.359 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData:use DLProvider 3.(3) *
* Scenario:use DLProvider 3. *
* a:x *
* b:y *
* c:3 *
***************************Finished Up***************************
bigdecimal: 1234.56
21:47:34.951 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.951 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.951 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.951 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.951 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.953 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider.(1) *
* Scenario:use DLProvider. *
* a:x *
* b:y *
* c:0 *
***************************Finished Up***************************
21:47:34.955 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Start Up:
***************************Starting Up***************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 2.(2) *
* Scenario:use DLProvider 2. *
* a:x *
* b:y *
* c:3 *
*****************************************************************
bigdecimal: 1234.56
21:47:34.955 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.955 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.955 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.955 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.955 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.957 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 2.(2) *
* Scenario:use DLProvider 2. *
* a:x *
* b:y *
* c:0 *
***************************Finished Up***************************
21:47:34.959 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Start Up:
***************************Starting Up***************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 3.(3) *
* Scenario:use DLProvider 3. *
* a:x *
* b:y *
* c:3 *
*****************************************************************
bigdecimal: 1234.56
21:47:34.960 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - :starting executor to evaluate expectations.
21:47:34.960 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutting down executor
21:47:34.960 [TestNG-tests-1] DEBUG com.thegoate.reflection.Executioner - :shutdown finished
21:47:34.960 [TestNG-tests-1] DEBUG com.thegoate.expect.ExpectEvaluator - Expectations:Evaluation finished successfully
21:47:34.960 [TestNG-tests-1] DEBUG com.thegoate.annotations.AnnotationFactory - Building Directory com.thegoate.statics.ResetStatics:the listing was empty, trying to build it.
21:47:34.961 [TestNG-tests-1] INFO com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL - Shut Down:
*****************************************************************
* com.thegoate.testng.TestNGEngineFactoryDataProviderMethodDL:putRunData2:use DLProvider 3.(3) *
* Scenario:use DLProvider 3. *
* a:x *
* b:y *
* c:0 *
***************************Finished Up***************************


History of the Internet Report
Zach and David's second class project for NJIT 602 Spring 2021.
Early History
Invention of the Internet
1950s to the 1990s
Starting with a theory from a MIT psychologist to the first web browser.
Continue reading
Netscape vs Microsoft
Browser Wars
1989 to the early 2000s
From a few downloads to a battle that would set the tone for many internet wars to come.
Continue reading
Internet Second War
Search
1995 to 2004
The internet wars continue this time inside a browser.
Continue reading
It goes pop!
DotCom Bubble
1994 to the early 2000s
Speculation led to a bubble, and from the fallout, a giant arose.
Continue reading
Let's get social
People
1997 to 2003
How everyday people shaped and are shaping the internet.
Continue reading


This is the lushest of the islands and is famous for its large flock of pink flamingos. There are extensive nature reserves here. The small population is spread among four villages.
The NW shore near Sandy Point (across from Parrot Key) is home to multi-million dollar villas and the North Caicos Yacht Club and marina. No information as to whether this is available to visitors is available.
Last updated January 2013.


add the ability to disable the "Soldier" & "Multiplayer" dropdowns!
They are very annoying, and I accidentaly hover over them everytime, and I'm sure I'm not the only one.
I used BBLog once in a while, it wasn't a must for me, but with this tweak, I will surely be a big fan of this Battlelog extension in the future, so please let us disable it.
It would be cool if the plugin would only work if you have the BBLog menu open. Every time I open it, the soldier and multiplayer drop down gets in the way of that, but I like it otherwise.
dapil
Plugin Developer
If anybody else uses this, I moved the plugin to a new URL:


Typeahead.
Typeahead is a modified version of Angular Bootstraps' typeahead component with some new features including:
- touch screen support
- open on focus
- list refreshing
- hint
- highlight
The typeahead reload function is exposed to matches so that matches can trigger updates.
Popover
Popover is a lightweight popover solution that does not rely on scope


Who we are
NHS Digital was set up by the Department of Health and Social Care in April 2013 and is an executive non-departmental public body that provides national information, data and IT systems for health and care services. We exist to help patients, clinicians, commissioners, analysts and researchers. Our goal is to improve health and social care in England by making better use of technology, data and information. Where appropriate legal basis exists we also provide services to areas outside England.
Find out more about NHS Digital.
Mentions of "us" and "we" mean NHS Digital and "you" means anyone using NHS login.
We have developed a platform for you to prove your ID and create your own NHS login account. With this, you can use “Connected Services” such as health related websites and apps, provided by the NHS or by third parties on behalf of the NHS "Connecting Parties". To create your NHS login, we need to take some personal information from you.
We are the data controller of the personal information you provide to us when:
- we verify your identity
- you use NHS login to access Connected Services
- you contact us
We do not have access to any information within your medical records or the product provided by the Connected Services, as such, some features may differ depending on the location being used to access the service.
What personal information we collect about you
NHS login provides access to online health services. The different items of your personal information which you choose to provide to conduct ID checks will determine the level of identity verification you achieve. The levels of identity verification currently are low-level , medium-level, and high-level. The level of identity verification which you have will affect which Connected Services you are able to access using NHS login. Once you have established a low or medium-level you may at any time provide the further personal information required to move to a higher level. To support this, NHS login provides various methods to achieve the higher level of ID verification, including, in some cases, relying on verification which has already been conducted by your GP practice.
Identity and contact information
We collect your basic personal details needed to process your NHS login application, including:
- For the low-level identity verification, NHS login will process your email address and mobile phone number.
- For the medium-level identity verification, NHS login will process your email address, mobile phone number and, depending on the user journey selected either 'first name, middle name, last name, date of birth and postcode' or 'NHS number and date of birth'.
- For the high-level identity verification, NHS login will process all of the data items in the medium-level identity verification plus the special category information detailed below.
- For high level identity verification which leverages Patient Online (POL) account creation processes, NHS login will only transact a minimum set of data to complete the verification process.
- For the NHS login Help Centre, NHS login will process your email address and Name provided by you.
Special category information (sensitive personal data)
For high-level identity verification we also collect special category information needed to verify your identity, including:
- a short video of you
- biometric data of your face that will include ethnicity
- information from your ID document
Technical information
In all cases we also collect technical information needed for security and to set up and manage your account to a Connected Service. This includes:
- linkage key information (GP Account ID, GP ODS code, GP system Linkage key)
- audit data and event logs
- online identifiers, like your Internet Protocol (IP) addresses
Why we collect your personal information
We collect personal information from you to:
- verify who you are
- provide you with an NHS login so that you can access Connected Services
- provide Connecting Parties with data you explicitly agree to us sharing
- to inform you of new Connected Services which you can access using NHS login
- send direct communication to your registered NHS login contact details so that we can support you in the use of your NHS login account
- support User Research
Collecting this information also allows us to manage our service, so that we can:
- improve our manual and automated ID checking function by monitoring the rates of successful and unsuccessful ID verification submissions with existing and proposed suppliers
- provide data in support of the NHS Digital protective monitoring plan to improve the security of the service
- improve the accuracy of the data held within NHS login and our Connected NHS systems such as the Personal Demographic Service (PDS)
- to provide you with supporting information in order to support your use of NHS login via the Help centre service or directly to you (once you have created an account with NHS login)
Our legal basis for using your information
If you are a user from England
We are directed by the Department of Health and Social Care (DHSC), under its powers conferred by sections 254(1) and (6), section 260 (2) (d), section 261 (2) (e), 304 (9), (10) and (12) of the Health and Social Care Act 2012 and regulation 32 of the National Institute for Health and Care Excellence (Constitution and Functions) and the Health and Social Care Information Centre (Functions) Regulations 2013, to establish and operate the NHS login Services in England.
NHS Digital and DHSC process personal data under the legal direction from DHSC as joint data controllers. The legal bases under the Data Protection Act 2018 / General Data Protection Regulation (GDPR) for the processing is explained below.
NHS login will reference the Legal Directions above and the Spine Legal Directions (Health and Social care Information Centre 9Spine Services) (No.2) Directions 2014, to support the NHS login Contact Preferences update feature.
If you are a user from Northern Ireland, Scotland and Wales
We have been requested by the Public Health Agencies from the Devolved Administrations (Northern Ireland, Scotland and Wales) to provide NHS login to residents within their administrative areas for the purpose of providing an NHS login account for access to services approved by the Devolved Administrations. This request is made under the Covid-19 Framework Request made under section 255 of the Health and Social Care Act 2012.
As NHS Digital processes personal data under the legal request from the Devolved Administrations, then the organisations are joint data controllers for data protection purposes. The legal bases under the Data Protection Act 2018 / General Data Protection Regulation (GDPR) for the processing is explained below.
If you are a user from Isle of Man
We have been requested by the Isle of Man Department of Health and Social Care (IOMDHSC) to provide NHS login to residents within their administrative areas for the purpose of providing an NHS login Account for access to services approved by the IOMDHSC. This request is made by the IOMDHSC under section 255 of the Health and Social Care Act 2012.
As NHS Digital processes personal data under the legal request from the IOMDHSC, then the organisations are joint data controllers for data protection purposes. The legal bases under the Data Protection Act 2018 / GDPR and LED Implementing Regulations 2018 / General Data Protection Regulation (GDPR) for the processing is explained below.
NHS Digital processing of personal data
GDPR Article 6(1)(a) - ‘consent of the individual’ (solely for the purposes of non-essential cookies, which comprise personal data, which are placed on the platform).
GDPR Article 6(1)(c) – the ‘processing is necessary for compliance with a legal obligation to which the controller (NHS Digital) is subject’.
GDPR Article 6 (1)(e) – where we process personal data as part of our statutory functions under the Health and Social Care when requested by other bodies, such as the Devolved Administrations and IOMDHSC, the process is part of our public task.
NHS Digital processing of special category data (sensitive personal data)
GDPR Article 9(2) (h) – ‘processing is necessary for the purposes of preventive or occupational medicine, for the assessment of the working capacity of the employee, medical diagnosis, the provision of health or social care or treatment or the management of health or social care systems and services’.
Data Protection Act 2018, schedule 1, part 1, paragraph 2, sub paragraph (2), sub paragraph (f) – ‘the management of health care systems or services or social care systems or services’.
DHSC processing of personal data
GDPR Article (6)(1)(e) – ‘processing is necessary for the performance of a task carried out in the public interest or in the exercise of official authority vested in the controller’.
DHSC only collects, uses and shares your information when they have an appropriate legal basis to do so.
Read the legal direction issued by DHSC
Devolved Administrations processing of personal data
GDPR Article (6)(1)(e) – ‘processing is necessary for the performance of a task carried out in the public interest or in the exercise of official authority vested in the controller’.
Devolved Administrations only collect, use and share your information when they have an appropriate legal basis to do so. You should contact them for details of this.
IOMDHSC processing of personal data
GDPR Article (6)(1)(e) – ‘processing is necessary for the performance of a task carried out in the public interest or in the exercise of official authority vested in the controller’.
IOMDHSC only collect, use and share your information when they have an appropriate legal basis to do so. You should contact them for details of this.
By way of further information on how the Isle of Man health care provision is provided, Manx Care is a statutory board of the Isle of Man Government established by order pursuant to section 12 of the Manx Care Act 2021 (an Act of Tynwald). It is the duty of Manx Care to exercise its powers to discharge the functions of the Isle of Man Department of Health and Social Care, including the duty to promote in the Isle of Man a comprehensive health and social care service. In accordance with a mandate between the Isle of Man Department of Health and Social Care and Manx Care, the Isle of Man Department of Health and Social Care may mandate that Manx Care discharge the Isle of Man Department of Health and Social Care functions regarding this Information System.
NHS Digital undertakes provision of the NHS login service under a request issued by [IOMDHSC] under s255 of the Health and Social Care Act 2012.
How we process your personal information
In the case of low-level, mid-level and high-level identity verification accounts we will use your personal information to create an account and enable you to log in to this.
In the case of mid-level and high-level identity verification accounts we will use your personal information to create a match between you and records on the personal demographics service (PDS) (Find out more about PDS: Demographics - NHS Digital). Some Connected Services may request this matching includes the validation of the NHS login submitted contact details against the information held on PDS.
In the case of high-level identity verification accounts NHS login will verify your ID online using an automated verification process. Where an automated decision cannot be made successfully, a manual verification process is then used.
We will use your NHS login registered email address to send you email communications to support you in the use of your NHS login account and for user research to improve NHS login and connected services. In these cases, we ill ask you if you would like to join our user research panel when you register for NHS login or on a subsequent login. If you choose to do so, we will email you a short survey to fill in about you and your health. Your answers will help make sure we invite you to user research that is relevant to you.
When you have signed up, we may ask you to:
- try new features
- answer more questions by email
- talk to our researchers about your experience of using NHS login or connected services
You can always say no to an invite, and you can leave the user research panel at any time.
We may also use third party service providers to support our delivery of NHS login. Where any such organisation has access to your personal data they will be a processor acting for us, subject to a contract with us, required to meet our security and privacy standards and may only process your personal data for the sole purpose of fulfilling our instructions.
Automated verification process
We use approved ID verification suppliers to complete our automated online ID verification process. As part of the automated ID verification process for high-level identity verification, users will be asked to present photo ID documentation and conduct a live video using Biometric ID verification technology. The personal data from your photo ID document is processed using technology which can automatically read the data on the document. This is checked against the details held within our demographic database before we match you to your NHS number. Users who use the automated ID verification process can select, via the options presented to them, to come out of the automated journey. They can then progress their submission via the manual ID verification journey. In circumstances where the automated ID process cannot positively match you to a record, your submission is then filtered to the manual ID verification process.
NHS Digital uses third party ID verification suppliers to support the automated verification process. They are instructed to provide:
- NHS login with a purpose built ID verification platform which uses biometrics provided by you so that a likeness and liveness check can be conducted. To facilitate this, NHS login will pass across a ‘crop’ of the photo from the ID document you submitted which is then used against the video that you submit during this process.
- NHS login with a purpose built document verification platform which uses the photo ID document provided by you so that the submitted document can be validated against the security features on the document and to provide NHS Digital with a snapshot of the ‘plain text’ information on the document so that it supports the user registration journey.
Manual verification process
Trained ID verification staff from NHS Digital and approved suppliers complete all manual online verification processes. They also review all of the unsuccessful fully automated online ID verification processes for high-level identity verification. As part of the manual ID verification user journey, users will be asked to provide personal data items, for example, NHS number, date of birth, first name, last name and postcode, as part of the process. For high-level identity verification they will also be asked to present photo ID documentation and upload a video selfie which records the user speaking the challenge code which has been sent to them. Trained ID checkers will check this against the details held within our demographic database before we match you to your NHS number.
All submissions, successful or unsuccessful, and manual or automated, are subject to quality assurance and audit checks.
How we protect your personal information
We take the security of your personal information very seriously. We have set up security measures, policies and procedures to make sure your personal information is protected.
We protect your personal information by:
- training staff to understand data and security protection
- ensuring security and confidentiality policies are in place for our staff who have access to personal information
- monitoring our service
- using security features such as two-factor authentication
- introducing features such as ‘passwordless authentication’ and ‘remember my device’ to improve security and functionality
- following good practice guidance provided by the National Technical Authority
- using legally binding agreements with all organisations, including those we use to process your personal information
How long we store your personal information
We store your personal information for as long as is reasonably necessary and legally justifiable. The length of time we store your information for will depend on legal, regulatory or technical requirements. In any event, we follow the Records Management Code of Practice for Health and Social Care (2016). The retention periods are explained here.
User accounts
Stored until your account is closed by you or remains unused for 24 months in total. If your account is unused for 12 months, it will be disabled and stored for a further 12 months, in case you want to reopen it during that time.
You can delete your account anytime. If you delete your account, you must verify your identity again if you ever want to use NHS login in the future.
The personal information within your NHS login account is:
In the case of low-level identity verification accounts:
- mobile phone number
- email address
In the case of mid-level and high-level identity verification accounts:
- mobile phone number
- email address
- NHS number
- date of birth
- first name
- middle names
- surname
- post code
- reference to any evidence you have provided
ID verification evidence
Information processed as part of your ID verification for high-level identity verification will be stored for six months, starting from the date we verify the details on your account. This is true whether or not such verification is successful, and whether or not your account remains open. After this, your proof of identity information will be securely deleted.
We may retain some extracts from your submitted ID document, such as the plain text data on the document and not the photo, for longer than six months to support our ID checker training. The ID checker training material is stored securely and separately from the ID verification evidence submitted by you.
The information stored under instruction by us, as a Data Controller, includes your:
- photo ID documentation, such as a passport or driving licence
- short video from the manual or automated use of the service
- live video photo frame taken during the use of the technology provided by our third party supplier
- a biometric description of the evaluated data from the use of the face verification technology
- a unique ID which is used to validate the transaction between us and our third party supplier
Log data
After an action is logged, we will store this general log data for one year. For example, an IP address that shows activity like webpage access, account login requests and login attempts.
Audit events
We store audit event information for 8 years from the event taking place.
Audit event information lets us record:
- who verifies the identity evidence you provide
- when the ID verification took place
- the result of the ID verification
- when identity evidence is to be deleted
- details of the person verified
- deletion requests and who made them
Where your personal information is stored and processed
We (including all processors) store and process your information in the EEA. We will make sure your information is given the level of protection required by law and NHS policies.
Your rights
Data protection laws provide you with a number of rights which you can exercise by contacting the appropriate Data Controller. NHS login does not hold any medical information but does hold the personal information described earlier to establish your identification.
These general rights allow you to:
- request a copy of your personal information by completing a subject access request form.
- change your information if it is wrong or incomplete
- request your personal information is deleted – if you believe it is no longer needed, though we may not be able to delete your information if there is a legal reason for us to not delete it
- request a restriction on the use of your personal information – if it is wrong and would like it to be changed before being used again
Complaints
You have the right to complain about how we process your personal information. You can do this by emailing<EMAIL_ADDRESS>or you can go through the Information Complaints Office (ICO). The ICO is the regulator for data protection.
Changes to our privacy notice
Our privacy notice may change. The latest version of our privacy notice will be accessible through NHS login. We will inform you through NHS login if we make any material changes to our privacy notice, cookies policy or terms and conditions.


--- layout: new permalink: /new/a.html custom_js: - new.bundle.js --- {% include blocks/menu.html %} {% include blocks/photo-album.html %} {% include blocks/tweets.html %} {% include blocks/footer.html %}


I am a polished team leader with a passion for software development, the outdoors, and creating experiences that encourage others to push boundaries, awaken senses, and breathe new life into their world. I believe there is always room for growth and something new to learn.
I come to software development from 8 years of experience working as a mental health professional. I bring a superb track record as a program manager and team builder with experience in program design and facilitation. I have proven effectiveness in staff development and client-centered services. I am a detail oriented and passionate professional who understands the importance of effective communication within cross-functioning teams.
When I'm not working I am usually out exploring the valleys, mountaintops, and canyons of Colorado and Utah. I love meeting new people, learning about others' passions, and sharing stories of travel and adventure so feel free to reach out and say hi.
Want to learn more about me? Shoot me a message and I will get back to you as soon as possible!


--- layout: page title: Menu Button ---
Use ENTER or SPACE key on button to open a menu in a flyout.
Please read the documentation to understand how these examples were created.
Updated: April 9th, 2020


Thank you for sharing with use your opinion!
Plese now visit one of the following url to see what our algorithms think about your sentences


---
layout: post
title: 4/2
date: '2013-04-02T21:25:00.001-06:00'
author: Jacob .
tags:
modified_time: '2013-04-02T21:25:17.513-06:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-3952908337127362385
blogger_orig_url: http://www.svlark.com/2013/04/42.html
---
D-12 days until listing.
Experiments with spray-painting lighting and tub fixtures to change their finish yielded positive results today. Looks like we'll be able to save a few bucks there.
Not much else to report for today.
55 down, 29 to go, at 229.0.


My name is Emily. I am from Kansas City, Missouri and I'm 32. I enjoy yoga, reading, movies, and being outside.
My dog's name is Nellie, and she is a pitbull.  I love her anyway.


My name is Guillaume and I'm from Tahiti! I'm a Software Engineer working on all kinds of project. I'm also a Trader mostly working on NQ and ES. Most importantly I'm a loyal husband, everything that I do is to make my wife happy. I find my passion in problem solving, I love feeling like I accomplish something real. I'm the most hard-worker person you'll ever meet.
Download ResumeI'm actively searching for a full-time job as a Software Engineer. I have extensive knowledge in most areas, I hope with the project listed below you will be able to gauge my capcity as a developper. I'm a full-stack. I'm also a really good analytics in the stock market making an average of $1k/day
SOMETHING
SOMETHING
SOMETHING
SOMETHING
SOMETHING


Hosea 5:9
Ephraim shall be desolate in the day of rebuke: among the tribes of Israel have I made known that which shall surely be.


--- title: "Analying Subreddits" layout: single tags: permalink: /about/ ---
These are the different subreddits we decided to look at. We had three broad categories of misinformation or scientific information that we wanted to examine.
| Category | Subreddits |
|---|---|
|
|
r/bigfoot, r/Humanoidencounters, r/BigfootEncounters, r/conspiracy, r/wanttobelieve, r/SasquatchAttacks, r/squatchersonly, r/UrbanMyths, r/ufo, r/UFOs, r/aliens |
|
|
r/The_Donald, r/DonaldTrump, r/flatearthsociety, r/tucker_carlson, r/HillaryForPrison, r/climateskeptics, r/benshapiro, r/China_Flu, r/LockdownSkepticism, r/WalkAway, r/antifapassdenied |
|
|
r/science, r/EverythingScience, r/climate, r/COVID19, r/PandemicPreps, r/CoronavirusRecession, r/askscience, r/Health, r/Ebola, r/medicine, r/publichealth |


Bordeaux
Boredeax provides Costume and Fashion Designs to passionate costumers in a friendly environment with an artistic voice, helping them feel confident and beau monde.
Let's CreateBoredeax provides Costume and Fashion Designs to passionate costumers in a friendly environment with an artistic voice, helping them feel confident and beau monde.
Let's CreateTestiominal content will fo here. And that is what I want. That and soda. Aswell as sleep. Hope I can get it. lIke the meowmix comercial.
I like chicken, I like liver. Meowmix meowmix please deliver? That comercial was the best. They should bring those back.
Everyday when your walking down the street. Everybody that meet, has an original point of view. and I say HEY, what a wonderful kind of day!