mustache man (5)
mustache is a logic-less template system
with implementations available in multiple languages.
In nim there are two implementations:
nimib uses nim-mustache
and takes
specific advantage of its feature for in-memory partials to store default templates.
Below I will show examples of usage of mustache
using nim-mustache
,
mostly replicating mustache(5) man page
(why (5)?).
import
mustache
SYNOPSIS
A typical mustache template:
var tmpl = """Hello {{name}}
You have just won {{value}} dollars!
{{#in_california}}
Well, {{taxed_value}} dollars, after taxes.
{{/in_california}}
"""
Given the following context:
var context = newContext()
context["name"] = "Chris"
context["value"] = 10000
context["taxed_value"] = 10000 - (10000 * 0.4)
context["in_california"] = true
Will produce the following:
echo tmpl.render(context)
Hello Chris
You have just won 10000 dollars!
Well, 6000.0 dollars, after taxes.
DESCRIPTION
Mustache can be used for HTML, config files, source code - anything.
It works by expanding tags in a template using values provided in a context
object.
We call it "logic-less" because there are no if statements, else clauses, or for loops.
Instead there are only tags.
Some tags are replaced with a value, some nothing, and others a series of values.
This document explains the different types of Mustache tags.
in this document we use the context
keyword instead of referring to it as a hash or object
as in the original document
TAG TYPES
Tags are indicated by the double mustaches. {{person}}
is a tag, as is {{#person}}
.
In both examples, we'd refer to person as the key or tag key.
Let's talk about the different types of tags.
Variables
The most basic tag type is the variable.
A {{name}}
tag in a basic template will try to find the name key in the current context.
If there is no name key, the parent contexts will be checked recursively.
If the top context is reached and the name key is still not found, nothing will be rendered.
All variables are HTML escaped by default.
If you want to return unescaped HTML, use the triple mustache: {{{name}}}
.
You can also use & to unescape a variable: {{& name}}
.
This may be useful when changing delimiters (see "Set Delimiter" below).
By default a variable "miss" returns an empty string.
This can usually be configured in your Mustache library.
The Ruby version of Mustache supports raising an exception in this situation, for instance.
Template:
tmpl = """* {{name}}
* {{age}}
* {{company}}
* {{{company}}}
* {{&company}}"""
Context:
context = newContext()
context["name"] = "Chris"
context["company"] = "Github"
Output:
echo tmpl.render(context)
* Chris
*
* Github
* Github
* Github
added the {{&company}}
to clarify that it is just an alternative syntax with the same result
as the triple mustache.
Sections
Sections render blocks of text one or more times, depending on the value of the key in the current context.
A section begins with a pound and ends with a slash.
That is, {{#person}}
begins a "person" section while {{/person}}
ends it.
The behavior of the section is determined by the value of the key.
False Values or Empty Lists
If the person key exists and has a value of false or an empty list, the HTML between the pound and slash will not be displayed.
Template:
tmpl = """Shown.
{{#person}}
Never shown!
{{/person}}"""
Context:
context = newContext()
context["person"] = false
Output:
echo tmpl.render(context)
Shown.
Non-Empty Lists
If the person key exists and has a non-false value,
the HTML between the pound and slash will be rendered and displayed one or more times.
When the value is a non-empty list, the text in the block will be displayed once for each item in the list.
The context of the block will be set to the current item for each iteration. In this way we can loop over collections.
Template:
tmpl = """{{#repo}}
{{name}}
{{/repo}}"""
Context:
import
json
context = newContext()
context["repo"] = %*[{"name": "resque"}, {"name": "hub"}, {"name": "rip"}]
Output:
echo tmpl.render(context)
resque
hub
rip
Lambdas
When the value is a callable object, such as a function or lambda, the object will be invoked and passed the block of text.
The text passed is the literal block, unrendered.
{{tags}}
will not have been expanded - the lambda should do that on its own. In this way you can implement filters or caching.
Template:
tmpl = """{{#wrapped}}
{{name}} is awesome.
{{/wrapped}}"""
Context:
import
strutils
context = newContext()
context["name"] = "Willy"
context["wrapped"] = proc (s: string; c: Context): string =
"" & s.strip.render(c) & ""
Output:
echo tmpl.render(context)
Willy is awesome.
note that we need to strutils.strip
the string in order to obtain the expected
whitespace behaviour
(see discussion in soasme/mustache/issues/8)
Non-False Values
When the value is non-false but not a list,
it will be used as the context for a single rendering of the block.
Template:
tmpl = """{{#person?}}
Hi {{name}}!
{{/person?}}"""
Context:
context = newContext()
context["person?"] = %*{"name": "Jon"}
Output:
echo tmpl.render(context)
Hi Jon!
Inverted Sections
An inverted section begins with a caret (hat) and ends with a slash.
That is {{^person}}
begins a "person" inverted section while {{/person}}
ends it.
While sections can be used to render text one or more times based on the value of the key,
inverted sections may render text once based on the inverse value of the key.
That is, they will be rendered if the key doesn't exist, is false, or is an empty list.
Template:
tmpl = """{{#repo}}
{{name}}
{{/repo}}
{{^repo}}
No repos :(
{{/repo}}"""
Context:
context = newContext()
let empty: seq[string] = @[]
context["repo"] = empty
Output:
echo tmpl.render(context)
No repos :(
Comments
Comments begin with a bang and are ignored. The following template:
tmpl = """
Today{{! ignore me }}.
"""
Will render as follows:
echo tmpl.render(newContext())

Today.

Partials
Partials begin with a greater than sign, like {{> box}}
.
 Just avoid infinite loops.
They also inherit the calling context.
Whereas in an ERB file you may have this:
<%= partial :next_more, :start => start, :size => size %>
Mustache requires only this:
{{> next_more}}
Why? Because the next_more.mustache
file will inherit
the size and start methods from the calling context.
In this way you may want to think of partials as
includes, imports, template expansion, nested templates,
or subtemplates, even though those aren't literally the case here.
For example, this template and partial:
let base = """
Names

{{#names}}
{{> user}}
{{/names}}
"""
let user = "{{name}}\n"
Can be thought of as a single, expanded template:
let expanded = """
Names

{{#names}}
{{name}}
{{/names}}
"""
nim-mustache
allows to use partials in-memory.
By default nim-mustache looks for .mustache
files in current directory
but the behaviour of where to find partials (which directories or in-memory)
can be fully customized
(see here).
Below we show an example where we only search in-memory.
import
tables
let partials = {"base": base, "user": user, "expanded": expanded}.toTable
context = newContext(searchDirs = @[], partials = partials)
context["names"] = %*[{"name": "resque"}, {"name": "hub"}, {"name": "rip"}]
echo "{{>base}}".render(context)

Names

resque
hub
rip
echo "{{>expanded}}".render(context)

Names

resque
hub
rip
Set Delimiter
Set Delimiter tags start with an equal sign and change the tag delimiters from {{ and }} to custom strings.
Consider the following contrived example:
tmpl = """* {{default_tags}}
{{=<% %>=}}
* <% erb_style_tags %>
<%={{ }}=%>
* {{ default_tags_again }}
"""
Here we have a list with three items. The first item uses the default tag style, the second uses erb style as defined by the Set Delimiter tag, and the third returns to the default style after yet another Set Delimiter declaration.
According to ctemplates, this "is useful for languages like TeX,
where double-braces may occur in the text and are awkward to use for markup."
Custom delimiters may not contain whitespace or the equals sign.
adding an example of usage of set delimiter feature
context = newContext()
context["default_tags"] = "one"
context["erb_style_tags"] = "two"
context["default_tags_again"] = "three"
echo tmpl.render(context)
* one
* two
* three
import nimib
nbInit
nbDoc.darkMode
nbText: """# mustache man (5)
[mustache](https://mustache.github.io/) is a logic-less template system
with implementations available in multiple languages.
In nim there are two implementations:
* [nim-mustache](https://github.com/soasme/nim-mustache)
* [moustachu](https://github.com/fenekku/moustachu)
[nimib](https://pietroppeter.github.io/nimib/) uses `nim-mustache` and takes
specific advantage of its feature for in-memory partials to store default templates.
Below I will show examples of usage of `mustache` using `nim-mustache`,
mostly replicating [mustache(5)](https://mustache.github.io/mustache.5.html) man page
([why (5)?](https://en.wikipedia.org/wiki/Man_page#Manual_sections)).
"""
nbCode: import mustache
nbText: """
## SYNOPSIS
A typical mustache template:
"""
nbCode:
var tmpl = """
Hello {{name}}
You have just won {{value}} dollars!
{{#in_california}}
Well, {{taxed_value}} dollars, after taxes.
{{/in_california}}
"""
nbText: "Given the following context:"
nbCode:
var context = newContext()
context["name"] = "Chris"
context["value"] = 10_000
context["taxed_value"] = 10000 - (10000 * 0.4)
context["in_california"] = true
nbText: "Will produce the following:"
nbCode:
echo tmpl.render(context)
nbText: """
## DESCRIPTION
Mustache can be used for HTML, config files, source code - anything.
It works by expanding tags in a template using values provided in a context
object.
We call it "logic-less" because there are no if statements, else clauses, or for loops.
Instead there are only tags.
Some tags are replaced with a value, some nothing, and others a series of values.
This document explains the different types of Mustache tags.
> in this document we use the `context` keyword instead of referring to it as a hash or object
> as in the original document
## TAG TYPES
Tags are indicated by the double mustaches. `{{person}}` is a **tag**, as is `{{#person}}`.
In both examples, we'd refer to person as the key or tag key.
Let's talk about the different types of tags.
### Variables
The most basic tag type is the variable.
A `{{name}}` tag in a basic template will try to find the **name** key in the current context.
If there is no **name** key, the parent contexts will be checked recursively.
If the top context is reached and the **name** key is still not found, nothing will be rendered.
All variables are HTML escaped by default.
If you want to return unescaped HTML, use the triple mustache: `{{{name}}}`.
You can also use & to unescape a variable: `{{& name}}`.
This may be useful when changing delimiters (see "Set Delimiter" below).
By default a variable "miss" returns an empty string.
This can usually be configured in your Mustache library.
The Ruby version of Mustache supports raising an exception in this situation, for instance.
Template:
"""
nbCode:
tmpl = """
* {{name}}
* {{age}}
* {{company}}
* {{{company}}}
* {{&company}}"""
nbText: "Context:"
nbCode:
context = newContext()
context["name"] = "Chris"
context["company"] = "Github"
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
> added the `{{&company}}` to clarify that it is just an alternative syntax with the same result
> as the triple mustache.
### Sections
Sections render blocks of text one or more times, depending on the value of the key in the current context.
A section begins with a pound and ends with a slash.
That is, `{{#person}}` begins a "person" section while `{{/person}}` ends it.
The behavior of the section is determined by the value of the key.
#### False Values or Empty Lists
If the person key exists and has a value of false or an empty list, the HTML between the pound and slash will not be displayed.
Template:
"""
nbCode:
tmpl = """
Shown.
{{#person}}
Never shown!
{{/person}}"""
nbText: "Context:"
nbCode:
context = newContext()
context["person"] = false
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
#### Non-Empty Lists
If the **person** key exists and has a non-false value,
the HTML between the pound and slash will be rendered and displayed one or more times.
When the value is a non-empty list, the text in the block will be displayed once for each item in the list.
The context of the block will be set to the current item for each iteration. In this way we can loop over collections.
Template:
"""
nbCode:
tmpl = """
{{#repo}}
{{name}}
{{/repo}}"""
nbText: "Context:"
nbCode:
import json
context = newContext()
context["repo"] = %* [
{ "name": "resque" },
{ "name": "hub" },
{ "name": "rip" }
]
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
#### Lambdas
When the value is a callable object, such as a function or lambda, the object will be invoked and passed the block of text.
The text passed is the literal block, unrendered.
`{{tags}}` will not have been expanded - the lambda should do that on its own. In this way you can implement filters or caching.
Template:
"""
nbCode:
tmpl = """
{{#wrapped}}
{{name}} is awesome.
{{/wrapped}}"""
nbText: "Context:"
nbCode:
import strutils
context = newContext()
context["name"] = "Willy"
context["wrapped"] = proc(s: string, c: Context): string = "" & s.strip.render(c) & ""
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
> note that we need to `strutils.strip` the string in order to obtain the expected
> whitespace behaviour
> (see discussion in [soasme/mustache/issues/8](https://github.com/soasme/nim-mustache/issues/8))"""
nbText: """
#### Non-False Values
When the value is non-false but not a list,
it will be used as the context for a single rendering of the block.
Template:
"""
nbCode:
tmpl = """
{{#person?}}
Hi {{name}}!
{{/person?}}"""
nbText: "Context:"
nbCode:
context = newContext()
context["person?"] = %* { "name": "Jon" }
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
### Inverted Sections
An inverted section begins with a caret (hat) and ends with a slash.
That is `{{^person}}` begins a "person" inverted section while `{{/person}}` ends it.
While sections can be used to render text one or more times based on the value of the key,
inverted sections may render text once based on the inverse value of the key.
That is, they will be rendered if the key doesn't exist, is false, or is an empty list.
Template:
"""
nbCode:
tmpl = """
{{#repo}}
{{name}}
{{/repo}}
{{^repo}}
No repos :(
{{/repo}}"""
nbText: "Context:"
nbCode:
context = newContext()
let empty: seq[string] = @[]
context["repo"] = empty
nbText: "Output:"
nbCode:
echo tmpl.render(context)
nbText: """
### Comments
Comments begin with a bang and are ignored. The following template:
"""
nbCode:
tmpl = """
Today{{! ignore me }}.
"""
nbText: "Will render as follows:"
nbCode:
echo tmpl.render(newContext())
nbText: """
### Partials
Partials begin with a greater than sign, like `{{> box}}`.
 Just avoid infinite loops.
They also inherit the calling context.
Whereas in an [ERB](http://en.wikipedia.org/wiki/ERuby) file you may have this:
```
<%= partial :next_more, :start => start, :size => size %>
```
Mustache requires only this:
```
{{> next_more}}
```
Why? Because the `next_more.mustache` file will inherit
the size and start methods from the calling context.
In this way you may want to think of partials as
includes, imports, template expansion, nested templates,
or subtemplates, even though those aren't literally the case here.
For example, this template and partial:
"""
nbCode:
let base = """

Names

{{#names}}
{{> user}}
{{/names}}
"""
let user = "{{name}}\n"
nbText: "Can be thought of as a single, expanded template:"
nbCode:
let expanded = """

Names

{{#names}}
{{name}}
{{/names}}
"""
nbText: """
> `nim-mustache` allows to use partials in-memory.
> By default nim-mustache looks for `.mustache` files in current directory
> but the behaviour of where to find partials (which directories or in-memory)
> can be fully customized
> (see [here](https://github.com/soasme/nim-mustache#read-partials-from-memory)).
>
> Below we show an example where we only search in-memory.
"""
nbCode:
import tables
let partials = {
"base": base,
"user": user,
"expanded": expanded
}.toTable
context = newContext(searchDirs = @[], partials=partials)
context["names"] = %* [
{ "name": "resque" },
{ "name": "hub" },
{ "name": "rip" }
]
echo "{{>base}}".render(context)
nbCode:
echo "{{>expanded}}".render(context)
nbText: """
### Set Delimiter
Set Delimiter tags start with an equal sign and change the tag delimiters from {{ and }} to custom strings.
Consider the following contrived example:
"""
nbCode:
tmpl = """
* {{default_tags}}
{{=<% %>=}}
* <% erb_style_tags %>
<%={{ }}=%>
* {{ default_tags_again }}
"""
nbText: """
Here we have a list with three items. The first item uses the default tag style, the second uses erb style as defined by the Set Delimiter tag, and the third returns to the default style after yet another Set Delimiter declaration.
According to ctemplates, this "is useful for languages like TeX,
where double-braces may occur in the text and are awkward to use for markup."
Custom delimiters may not contain whitespace or the equals sign.
> adding an example of usage of set delimiter feature
"""
nbCode:
context = newContext()
context["default_tags"] = "one"
context["erb_style_tags"] = "two"
context["default_tags_again"] = "three"
echo tmpl.render(context)
nbSave


[1]
MEDIA streaming did some knowledge i downloaded to much glee.
[2]
life is n't familiar with connecting to pair it unless it gets fixed or bd with analog 7.1 audio outputs so many features i downloaded to much glee.


Select a date to show events for that date from all your Google Calendars:
Use Google Calendar's Quick Add function to add a new event (the description is the same as you would use in the Google Calendar Quick Add function).


"""
Run x12/x13-arima specs in a subprocess from Python and curry results back
into python.
Notes
-----
Many of the functions are called x12. However, they are also intended to work
for x13. If this is not the case, it's a bug.
"""
from statsmodels.compat.pandas import deprecate_kwarg
import os
import re
import subprocess
import tempfile
from warnings import warn
import pandas as pd
from statsmodels.tools.sm_exceptions import (
IOWarning,
X13Error,
X13NotFoundError,
X13Warning,
)
from statsmodels.tools.tools import Bunch
__all__ = ["x13_arima_select_order", "x13_arima_analysis"]
_binary_names = (
"x13as.exe",
"x13as",
"x12a.exe",
"x12a",
"x13as_ascii",
"x13as_html",
)
class _freq_to_period:
def __getitem__(self, key):
if key.startswith("M"):
return 12
elif key.startswith("Q"):
return 4
elif key.startswith("W"):
return 52
_freq_to_period = _freq_to_period()
_period_to_freq = {12: "M", 4: "Q"}
_log_to_x12 = {True: "log", False: "none", None: "auto"}
_bool_to_yes_no = lambda x: "yes" if x else "no" # noqa:E731
def _find_x12(x12path=None, prefer_x13=True):
"""
If x12path is not given, then either x13as[.exe] or x12a[.exe] must
be found on the PATH. Otherwise, the environmental variable X12PATH or
X13PATH must be defined. If prefer_x13 is True, only X13PATH is searched
for. If it is false, only X12PATH is searched for.
"""
global _binary_names
if x12path is not None and x12path.endswith(_binary_names):
# remove binary from path if given
x12path = os.path.dirname(x12path)
if not prefer_x13: # search for x12 first
_binary_names = _binary_names[::-1]
if x12path is None:
x12path = os.getenv("X12PATH", "")
if not x12path:
x12path = os.getenv("X13PATH", "")
elif x12path is None:
x12path = os.getenv("X13PATH", "")
if not x12path:
x12path = os.getenv("X12PATH", "")
for binary in _binary_names:
x12 = os.path.join(x12path, binary)
try:
subprocess.check_call(
x12, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
return x12
except OSError:
pass
else:
return False
def _check_x12(x12path=None):
x12path = _find_x12(x12path)
if not x12path:
raise X13NotFoundError(
"x12a and x13as not found on path. Give the "
"path, put them on PATH, or set the "
"X12PATH or X13PATH environmental variable."
)
return x12path
def _clean_order(order):
"""
Takes something like (1 1 0)(0 1 1) and returns a arma order, sarma
order tuple. Also accepts (1 1 0) and return arma order and (0, 0, 0)
"""
order = re.findall(r"\([0-9 ]*?\)", order)
def clean(x):
return tuple(map(int, re.sub("[()]", "", x).split(" ")))
if len(order) > 1:
order, sorder = map(clean, order)
else:
order = clean(order[0])
sorder = (0, 0, 0)
return order, sorder
def run_spec(x12path, specpath, outname=None, meta=False, datameta=False):
if meta and datameta:
raise ValueError("Cannot specify both meta and datameta.")
if meta:
args = [x12path, "-m " + specpath]
elif datameta:
args = [x12path, "-d " + specpath]
else:
args = [x12path, specpath]
if outname:
args += [outname]
return subprocess.Popen(
args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
)
def _make_automdl_options(maxorder, maxdiff, diff):
options = "\n"
options += "maxorder = ({0} {1})\n".format(maxorder[0], maxorder[1])
if maxdiff is not None: # maxdiff always takes precedence
options += "maxdiff = ({0} {1})\n".format(maxdiff[0], maxdiff[1])
else:
options += "diff = ({0} {1})\n".format(diff[0], diff[1])
return options
def _make_var_names(exog):
if hasattr(exog, "name"):
var_names = exog.name
elif hasattr(exog, "columns"):
var_names = exog.columns
else:
raise ValueError("exog is not a Series or DataFrame or is unnamed.")
try:
var_names = " ".join(var_names)
except TypeError: # cannot have names that are numbers, pandas default
from statsmodels.base.data import _make_exog_names
if exog.ndim == 1:
var_names = "x1"
else:
var_names = " ".join(_make_exog_names(exog))
return var_names
def _make_regression_options(trading, exog):
if not trading and exog is None: # start regression spec
return ""
reg_spec = "regression{\n"
if trading:
reg_spec += " variables = (td)\n"
if exog is not None:
var_names = _make_var_names(exog)
reg_spec += " user = ({0})\n".format(var_names)
reg_spec += " data = ({0})\n".format(
"\n".join(map(str, exog.values.ravel().tolist()))
)
reg_spec += "}\n" # close out regression spec
return reg_spec
def _make_forecast_options(forecast_periods):
if forecast_periods is None:
return ""
forecast_spec = "forecast{\n"
forecast_spec += "maxlead = ({0})\n}}\n".format(forecast_periods)
return forecast_spec
def _check_errors(errors):
errors = errors[errors.find("spc:") + 4 :].strip()
if errors and "ERROR" in errors:
raise X13Error(errors)
elif errors and "WARNING" in errors:
warn(errors, X13Warning)
def _convert_out_to_series(x, dates, name):
"""
Convert x to a DataFrame where x is a string in the format given by
x-13arima-seats output.
"""
from io import StringIO
from pandas import read_csv
out = read_csv(
StringIO(x), skiprows=2, header=None, sep="\t", engine="python"
)
return out.set_index(dates).rename(columns={1: name})[name]
def _open_and_read(fname):
# opens a file, reads it, and make sure it's closed
with open(fname, "r") as fin:
fout = fin.read()
return fout
class Spec(object):
@property
def spec_name(self):
return self.__class__.__name__.replace("Spec", "")
def create_spec(self, **kwargs):
spec = """{name} {{
{options}
}}
"""
return spec.format(name=self.spec_name, options=self.options)
def set_options(self, **kwargs):
options = ""
for key, value in kwargs.items():
options += "{0}={1}\n".format(key, value)
self.__dict__.update({key: value})
self.options = options
class SeriesSpec(Spec):
"""
Parameters
----------
data
appendbcst : bool
appendfcst : bool
comptype
compwt
decimals
modelspan
name
period
precision
to_print
to_save
span
start
title
type
Notes
-----
Rarely used arguments
divpower
missingcode
missingval
saveprecision
trimzero
"""
def __init__(
self,
data,
name="Unnamed Series",
appendbcst=False,
appendfcst=False,
comptype=None,
compwt=1,
decimals=0,
modelspan=(),
period=12,
precision=0,
to_print=[],
to_save=[],
span=(),
start=(1, 1),
title="",
series_type=None,
divpower=None,
missingcode=-99999,
missingval=1000000000,
):
appendbcst, appendfcst = map(
_bool_to_yes_no,
[
appendbcst,
appendfcst,
],
)
series_name = '"{0}"'.format(name[:64]) # trim to 64 characters
title = '"{0}"'.format(title[:79]) # trim to 79 characters
self.set_options(
data=data,
appendbcst=appendbcst,
appendfcst=appendfcst,
period=period,
start=start,
title=title,
name=series_name,
)
def pandas_to_series_spec(x):
# from statsmodels.tools.data import _check_period_index
# check_period_index(x)
if hasattr(x, "columns"): # convert to series
if len(x.columns) > 1:
raise ValueError(
"Does not handle DataFrame with more than one " "column"
)
x = x[x.columns[0]]
data = "({0})".format("\n".join(map(str, x.values.tolist())))
# get periodicity
# get start / first data
# give it a title
try:
period = _freq_to_period[x.index.freqstr]
except (AttributeError, ValueError):
from pandas.tseries.api import infer_freq
period = _freq_to_period[infer_freq(x.index)]
start_date = x.index[0]
if period == 12:
year, stperiod = start_date.year, start_date.month
elif period == 4:
year, stperiod = start_date.year, start_date.quarter
else: # pragma: no cover
raise ValueError(
"Only monthly and quarterly periods are supported."
" Please report or send a pull request if you want "
"this extended."
)
if hasattr(x, "name"):
name = x.name or "Unnamed Series"
else:
name = "Unnamed Series"
series_spec = SeriesSpec(
data=data,
name=name,
period=period,
title=name,
start="{0}.{1}".format(year, stperiod),
)
return series_spec
[docs]@deprecate_kwarg("forecast_years", "forecast_periods")
def x13_arima_analysis(
endog,
maxorder=(2, 1),
maxdiff=(2, 1),
diff=None,
exog=None,
log=None,
outlier=True,
trading=False,
forecast_periods=None,
retspec=False,
speconly=False,
start=None,
freq=None,
print_stdout=False,
x12path=None,
prefer_x13=True,
):
"""
Perform x13-arima analysis for monthly or quarterly data.
Parameters
----------
endog : array_like, pandas.Series
The series to model. It is best to use a pandas object with a
DatetimeIndex or PeriodIndex. However, you can pass an array-like
object. If your object does not have a dates index then ``start`` and
``freq`` are not optional.
maxorder : tuple
The maximum order of the regular and seasonal ARMA polynomials to
examine during the model identification. The order for the regular
polynomial must be greater than zero and no larger than 4. The
order for the seasonal polynomial may be 1 or 2.
maxdiff : tuple
The maximum orders for regular and seasonal differencing in the
automatic differencing procedure. Acceptable inputs for regular
differencing are 1 and 2. The maximum order for seasonal differencing
is 1. If ``diff`` is specified then ``maxdiff`` should be None.
Otherwise, ``diff`` will be ignored. See also ``diff``.
diff : tuple
Fixes the orders of differencing for the regular and seasonal
differencing. Regular differencing may be 0, 1, or 2. Seasonal
differencing may be 0 or 1. ``maxdiff`` must be None, otherwise
``diff`` is ignored.
exog : array_like
Exogenous variables.
log : bool or None
If None, it is automatically determined whether to log the series or
not. If False, logs are not taken. If True, logs are taken.
outlier : bool
Whether or not outliers are tested for and corrected, if detected.
trading : bool
Whether or not trading day effects are tested for.
forecast_periods : int
Number of forecasts produced. The default is None.
retspec : bool
Whether to return the created specification file. Can be useful for
debugging.
speconly : bool
Whether to create the specification file and then return it without
performing the analysis. Can be useful for debugging.
start : str, datetime
Must be given if ``endog`` does not have date information in its index.
Anything accepted by pandas.DatetimeIndex for the start value.
freq : str
Must be givein if ``endog`` does not have date information in its
index. Anything accepted by pandas.DatetimeIndex for the freq value.
print_stdout : bool
The stdout from X12/X13 is suppressed. To print it out, set this
to True. Default is False.
x12path : str or None
The path to x12 or x13 binary. If None, the program will attempt
to find x13as or x12a on the PATH or by looking at X13PATH or
X12PATH depending on the value of prefer_x13.
prefer_x13 : bool
If True, will look for x13as first and will fallback to the X13PATH
environmental variable. If False, will look for x12a first and will
fallback to the X12PATH environmental variable. If x12path points
to the path for the X12/X13 binary, it does nothing.
Returns
-------
Bunch
A bunch object containing the listed attributes.
- results : str
The full output from the X12/X13 run.
- seasadj : pandas.Series
The final seasonally adjusted ``endog``.
- trend : pandas.Series
The trend-cycle component of ``endog``.
- irregular : pandas.Series
The final irregular component of ``endog``.
- stdout : str
The captured stdout produced by x12/x13.
- spec : str, optional
Returned if ``retspec`` is True. The only thing returned if
``speconly`` is True.
Notes
-----
This works by creating a specification file, writing it to a temporary
directory, invoking X12/X13 in a subprocess, and reading the output
directory, invoking exog12/X13 in a subprocess, and reading the output
back in.
"""
x12path = _check_x12(x12path)
if not isinstance(endog, (pd.DataFrame, pd.Series)):
if start is None or freq is None:
raise ValueError(
"start and freq cannot be none if endog is not "
"a pandas object"
)
endog = pd.Series(
endog,
index=pd.DatetimeIndex(start=start, periods=len(endog), freq=freq),
)
spec_obj = pandas_to_series_spec(endog)
spec = spec_obj.create_spec()
spec += "transform{{function={0}}}\n".format(_log_to_x12[log])
if outlier:
spec += "outlier{}\n"
options = _make_automdl_options(maxorder, maxdiff, diff)
spec += "automdl{{{0}}}\n".format(options)
spec += _make_regression_options(trading, exog)
spec += _make_forecast_options(forecast_periods)
spec += "x11{ save=(d11 d12 d13) }"
if speconly:
return spec
# write it to a tempfile
# TODO: make this more robust - give the user some control?
ftempin = tempfile.NamedTemporaryFile(delete=False, suffix=".spc")
ftempout = tempfile.NamedTemporaryFile(delete=False)
try:
ftempin.write(spec.encode("utf8"))
ftempin.close()
ftempout.close()
# call x12 arima
p = run_spec(x12path, ftempin.name[:-4], ftempout.name)
p.wait()
stdout = p.stdout.read()
if print_stdout:
print(p.stdout.read())
# check for errors
errors = _open_and_read(ftempout.name + ".err")
_check_errors(errors)
# read in results
results = _open_and_read(ftempout.name + ".out")
seasadj = _open_and_read(ftempout.name + ".d11")
trend = _open_and_read(ftempout.name + ".d12")
irregular = _open_and_read(ftempout.name + ".d13")
finally:
try: # sometimes this gives a permission denied error?
# not sure why. no process should have these open
os.remove(ftempin.name)
os.remove(ftempout.name)
except OSError:
if os.path.exists(ftempin.name):
warn(
"Failed to delete resource {0}".format(ftempin.name),
IOWarning,
)
if os.path.exists(ftempout.name):
warn(
"Failed to delete resource {0}".format(ftempout.name),
IOWarning,
)
seasadj = _convert_out_to_series(seasadj, endog.index, "seasadj")
trend = _convert_out_to_series(trend, endog.index, "trend")
irregular = _convert_out_to_series(irregular, endog.index, "irregular")
# NOTE: there is not likely anything in stdout that's not in results
# so may be safe to just suppress and remove it
if not retspec:
res = X13ArimaAnalysisResult(
observed=endog,
results=results,
seasadj=seasadj,
trend=trend,
irregular=irregular,
stdout=stdout,
)
else:
res = X13ArimaAnalysisResult(
observed=endog,
results=results,
seasadj=seasadj,
trend=trend,
irregular=irregular,
stdout=stdout,
spec=spec,
)
return res
[docs]@deprecate_kwarg("forecast_years", "forecast_periods")
def x13_arima_select_order(
endog,
maxorder=(2, 1),
maxdiff=(2, 1),
diff=None,
exog=None,
log=None,
outlier=True,
trading=False,
forecast_periods=None,
start=None,
freq=None,
print_stdout=False,
x12path=None,
prefer_x13=True,
):
"""
Perform automatic seasonal ARIMA order identification using x12/x13 ARIMA.
Parameters
----------
endog : array_like, pandas.Series
The series to model. It is best to use a pandas object with a
DatetimeIndex or PeriodIndex. However, you can pass an array-like
object. If your object does not have a dates index then ``start`` and
``freq`` are not optional.
maxorder : tuple
The maximum order of the regular and seasonal ARMA polynomials to
examine during the model identification. The order for the regular
polynomial must be greater than zero and no larger than 4. The
order for the seasonal polynomial may be 1 or 2.
maxdiff : tuple
The maximum orders for regular and seasonal differencing in the
automatic differencing procedure. Acceptable inputs for regular
differencing are 1 and 2. The maximum order for seasonal differencing
is 1. If ``diff`` is specified then ``maxdiff`` should be None.
Otherwise, ``diff`` will be ignored. See also ``diff``.
diff : tuple
Fixes the orders of differencing for the regular and seasonal
differencing. Regular differencing may be 0, 1, or 2. Seasonal
differencing may be 0 or 1. ``maxdiff`` must be None, otherwise
``diff`` is ignored.
exog : array_like
Exogenous variables.
log : bool or None
If None, it is automatically determined whether to log the series or
not. If False, logs are not taken. If True, logs are taken.
outlier : bool
Whether or not outliers are tested for and corrected, if detected.
trading : bool
Whether or not trading day effects are tested for.
forecast_periods : int
Number of forecasts produced. The default is None.
start : str, datetime
Must be given if ``endog`` does not have date information in its index.
Anything accepted by pandas.DatetimeIndex for the start value.
freq : str
Must be givein if ``endog`` does not have date information in its
index. Anything accepted by pandas.DatetimeIndex for the freq value.
print_stdout : bool
The stdout from X12/X13 is suppressed. To print it out, set this
to True. Default is False.
x12path : str or None
The path to x12 or x13 binary. If None, the program will attempt
to find x13as or x12a on the PATH or by looking at X13PATH or X12PATH
depending on the value of prefer_x13.
prefer_x13 : bool
If True, will look for x13as first and will fallback to the X13PATH
environmental variable. If False, will look for x12a first and will
fallback to the X12PATH environmental variable. If x12path points
to the path for the X12/X13 binary, it does nothing.
Returns
-------
Bunch
A bunch object containing the listed attributes.
- order : tuple
The regular order.
- sorder : tuple
The seasonal order.
- include_mean : bool
Whether to include a mean or not.
- results : str
The full results from the X12/X13 analysis.
- stdout : str
The captured stdout from the X12/X13 analysis.
Notes
-----
This works by creating a specification file, writing it to a temporary
directory, invoking X12/X13 in a subprocess, and reading the output back
in.
"""
results = x13_arima_analysis(
endog,
x12path=x12path,
exog=exog,
log=log,
outlier=outlier,
trading=trading,
forecast_periods=forecast_periods,
maxorder=maxorder,
maxdiff=maxdiff,
diff=diff,
start=start,
freq=freq,
prefer_x13=prefer_x13,
)
model = re.search(
"(?<=Final automatic model choice : ).*", results.results
)
order = model.group()
if re.search("Mean is not significant", results.results):
include_mean = False
elif re.search("Constant", results.results):
include_mean = True
else:
include_mean = False
order, sorder = _clean_order(order)
res = Bunch(
order=order,
sorder=sorder,
include_mean=include_mean,
results=results.results,
stdout=results.stdout,
)
return res
class X13ArimaAnalysisResult(object):
def __init__(self, **kwargs):
for key, value in kwargs.items():
setattr(self, key, value)
def plot(self):
from statsmodels.graphics.utils import _import_mpl
plt = _import_mpl()
fig, axes = plt.subplots(4, 1, sharex=True)
self.observed.plot(ax=axes[0], legend=False)
axes[0].set_ylabel("Observed")
self.seasadj.plot(ax=axes[1], legend=False)
axes[1].set_ylabel("Seas. Adjusted")
self.trend.plot(ax=axes[2], legend=False)
axes[2].set_ylabel("Trend")
self.irregular.plot(ax=axes[3], legend=False)
axes[3].set_ylabel("Irregular")
fig.tight_layout()
return fig


?us.
Botan.
Stockholm.
/└/┴yi/
Plantż
Indiż
Occidentalis
N:o
V'Ł^eAs
└└└f,
└.└P.
'ą
<âa*0'6-g,
f
spw
^U^«,....
Cuba:
prov,
/9.19ă?^;..
leg.
E.
L.
Ekman.
0-
i
A
D
ty*
01529695
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


iab!filter -type (FilterID) (Parameters)
FilterID: see Filters.
This page exists to catalog functions that you can perform under filters that are technically separate from how iab usually handles filters. These filters are usually faster since iab handles them directly, and does not send jobs to another program.
RotateRight
RotateLeft
RotateFlip (180)
Flip Horizontal
Flip Vertical
Cut X/Y
Repeat X/Y
ActivateWindows
Rotates an image 90 degrees right.
Possible IDs:
No Parameters.
Rotates an image 270 degrees right
Possible IDs
No parameters.
Rotates an image 180 degrees left or right, you'll never know which one it is.
Possible IDs:
No Parameters.
Flips an image horizontally.
Possible IDs:
No parameters
Flips an image vertically.
Possible IDs:
No parameters.
Cuts out a portion of an image.
Possible IDs:
Parameters
The position in which to cut.
The amount to cut out.
Repeats a single line of an image for a specified width.
Possible IDs:
Parameters
The position in which to start repeating.
The amount of lines to draw.
Activate Windows. Go to Settings to activate Windows.
Possible IDs:
No parameters.


Rejudge/Judge
ID:
Title:
Description:
Privilege:
Public
Private
Pattern:
ACM
OI
Password:(Private 填写)
Start Time:
Length:
Problems :
id:
alias:
Submit


About Trendy5
Trendy5 may have been born by a coincidence, but the harmony developed between us once we started working on the project. We are passionate about what we do, and we always want to learn more. We aim to deliver the best outcome in the market to insure the great service and amazing experience. Trendy5 has been super productive along the way, we take care of your website from all aspects. We create data, content, functional sites, design, and everything. In conclusion, you would not have to worry about anything!
Balqees Qasem
I am a recent graduate from
Hashemite University
Computer Engineering Department
Taking
photos is my passion
Darah Shalabi
Political Science
McMaster University
I like Skate Boarding,
Playing the Piano,
Horse Riding
and Organizing my stuff,
But I can do none of them!
Abdallah Shanaah
I am a recent graduate from middle east Uni.
Computer science
i enjoy going out
with friends and travel
also doing prank with them too
i also like reading sometime
swimming
definitely love coding haha
🍔 🏊🏻♂ 🧗🏻♂ ✈
Osama Yousef
I am a civil engineering graduate from J.U.S.T university
Highly-motivated and
ambitious person
I have outgoing personality and love hanging out a lot
Yazan Alaiwah
I finsh my high school and work a few jobs like Sales-man, Carpenter, A builder, and Car electrician. I joind LTUC college in codeing boot camp and i found my self love coding so i decide that I am committed to producing elegant code and to discovering optimal pathways to a solution.


{% extends 'templates/nhs_layout.html' %} {% import 'includes/form_macros.html' as form_macros %} {% block content %} Register with a GP Confirm your details We will send your details to Lakeside Surgery. Please check this information is up to date and make any changes needed. {{ form_macros.text_field({ id: 'name', label: 'Name', value: 'Jose Baxter' }) }} {{ form_macros.text_field({ id: 'address', label: 'Address', value: '13 Fletcher Street, London, NW13 3XC' }) }} {{ form_macros.text_field({ id: 'email', label: 'Email', value<EMAIL_ADDRESS>}) }} {{ form_macros.text_field({ id: 'phone', label: 'Phone', value: '07700 900414' }) }} Confirm {% endblock %}
We will send your details to Lakeside Surgery. Please check this information is up to date and make any changes needed.


:cat:
— If ClausesThe :cat:
construct is one of the most important features in Emojicode. It allows for conditional execution of code fragments. That structure of is the following:
:cat: expression
statements
:indian:
The expression must be a boolean value. If expression evaluates to true, Emojicode will execute statements, and if it evaluates to false it'll ignore it.
:cat: :basketball: a b
8) :abc: a is greater b:abc:
:indian:
The following example would display "a is greater than b" if the variable a
is greater than b
.
:mouse:
— ElseOften you'd want to execute a statement if a certain condition is met, and a different statement if the condition is not met. This is what :mouse:
for. :mouse:
extends an :cat:
statement to execute a statement in case the expression in the :cat:
statement evaluates to false. For example, the following code would display a "is greater than b " if a
is greater than b
, and "a is NOT greater than b" otherwise:
:cat: :basketball: a b
8) :abc: a is greater b:abc:
:mouse:
8) :abc: a is NOT greater b:abc:
:indian:
The :mouse:
statement is only executed if the :cat:
expression evaluated to false, and if there were any :chicken:
expressions - only if they evaluated to false as well.
:chicken:
— Else If:chicken:
is a combination of :cat:
and :mouse:
. Like :mouse:
, it extends an :cat:
statement to execute a different statement in case the original :cat:
expression evaluates to false. However, unlike :mouse:
, it will execute that alternative expression only if the :chicken:
conditional expression evaluates to trie. For example, the following code would display "a is bigger than b", "a equal to b" or "a is smaller than b":
:cat: :basketball: a b
8) :abc: a is greater b:abc:
:chicken: :cookie: a B
8) :abc: a is equal to b:abc:
:mouse:
8) :abc: a is smaller greater b:abc:
:indian:


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Metanoia International Sales Inc.
Mailing Address:
458 Sandmere PlaceOAKVILLE, Ontario
L6L 4G4
Location Address:
458 Sandmere PlaceOAKVILLE, Ontario
L6L 4G4
Tel.:<PHONE_NUMBER>
Tel.:<PHONE_NUMBER>
Fax:
Company Profile
Metanoia International Sales Inc. Is a wholly Canadian owned
manufacturing company supplying engineering, new technology,
training and consulting services for all facets of the water
industry, the transportation and packaging of various food
products, the manufacture of various sizes of bottles, virtually
any size of steel building for industrial, commercial or
agricultural requirements.
We provide equipment, engineering and training, to local business
people who now have the opportunity of establishing various
profitable commercial operations to supply products to their
local area, their own country as well as providing additional
export opportunities.
Local businesses being established could include:
-a complete water bottling operation
-a water cooler assembly plant
-production of clean drinking water from rivers (muddy and murky)
and/or salt water
-a mobile and stationary water treatment and distribution system
to towns and villages
-a low cost water purification plant for towns and cities that
does not depend on the production of chlorine
-a low cost packaging plant for various detergents and germicidal
cleaners where we supply a very concentrated product for
dilution (160:1) and packaging on site
-a packaging plant for cooking oils
-a low cost manufacturing plant to produce bottles for water,
cooking oil, detergents etc.
-supply and installation of any size of steel buildings
Our unique mobile emergency water treatment and bottling system
combined with our waterbag bulk water transportation system can
provide a rapid response to deliver water in bulk in an emergency
situation, or for military use. Routine delivery of potable
water to outlaying areas (town and villages) on scheduled basis.
Tanker trucks not required. A brief product description is
noted below. New and innovative products are continually being
introduced through research and development.
Production of bottled water, juices, and water coolers is now
possible at a cost substantially lower than previous imports,
plus local labour is utilized. Production capacity can meet both
domestic requirements as well as developing export opportunities.
A substantial export or import market of various products is now
possible using the reusable waterbag shipping system. Standard
20 ft. And/or 40 ft. Shipping containers can now be used to ship
virtually any liquid or powder without any "one way" or cleaning
surcharge, or the expensive cost of shipping/returning empty
containers. The Waterbag consists of two parts; an outer heavy
duty liner that is re-usable, (life expectancy is a least 6 years
under normal use) and an inner bag that is normally discarded
after each shipment. As there is no cross contamination, fuel
oil can be shipped in one direction and a food products can be
shipped on the return trip. Of the outer shell is not re-used
for another shipment of any type of product, it can be folded
onto a skid for storage or returned at a fraction of normal
shipping costs. Two way shipping results at minimum cost without
expensive investment in takers or "fixed" volume containers.
Assembly, testing, engineering of new products, parts
manufactured to our specifications by contractors (machine shops
and stainless fabricators).
Products and systems available
The following are for drinking water:
-bottle washers
-bottle fillers
-bottle cappers
-bottle cap tighteners
-complete plant - for producing bottled water
-complete plant - for assembly of water coolers
-complete plant for producing bottles on site
-complete plant for sanitizing water distribution systems for
cities, towns and villages without producing chlorine and using
salt as the base product
-complete plant for packaging cooking oils, detergents and
germicidal cleaners
-mobile, completely self contained, water treatment / bottling
system for emergency or military applications. Optional 20,000
litre mobile water storage system (WATERBAG TRANSPORTATION
SYSTEM)
-stationary, completely self contained, water treatment plant
with optional bottling system and optional 20,000 litre water
storage system (WATERBAG SYSTEM)
-water - bottled and bulk
-re-usable and collapsible shipping and/or storage containers for
liquids/powders etc. 5300 U.S. gal
-bottles: any size, including "hard" and collapsible / foldable
bottles
-cooking oils
-concentrated detergents and germicidal cleaners
-steel buildings virtually any size for industrial, commercial
and agricultural applications.
We have now engineered buildings for high occupancy, residential
housing that are quickly erected, and low cost.
Full profile
Full profile
Contact information
Company description
413220 - Alcoholic Beverage Wholesaler-Distributors
Product / Service / Licensing
A complete and diversified product line of bottle washers,
fillers, and cappers to meet any requirement from small start up
to high volume output suitable for all 3, 5 and 6 U.S. gal
bottles. Semi automatic and completely automatic systems are
available each offering a choice of high to minimum labour
requirements. Collapsible and "hard" bottles are available, as
well as all operating supplies. Filling bottles from 350 ml to
22 litre and 1 gal bottles are also available.
An operational plant is available. We can provide all equipment
and material, and use local labour plus our installation
supervisor, and tradesmen, or equipment only is available, for
installation by others. By providing equipment and training, at
an economical and reasonable cost, the needs of the small bottler
as well as the larger established growing bottlers, can be met.
A unique, low cost, flexible and versatile solution to shipping &
storage of virtually any liquid or powder product. Shipment of
water, cooking oils, concentrated detergents, juices, flavours,
paint, oil, powders, etc. is now possible in the same container
system, simply by replacing (or re-using if applicable), the
inner bag. There is no product cross contamination, which allows
the WATERBAG to be used as a "two way" shipping container
regardless of the type of products being shipped. The outer
heavy duty liner has a life expectancy of 6 years under normal
use. The MODEL 20K (20,000 litres) folds onto a standard skid
should it be necessary to be returned empty. Note that other
types of returnable containers keep their original shape and
volume resulting in substantial additional costly shipping
charges when returned empty. Stainless steel tankers are very
expensive, not normally available, and must be dedicated for
drinking water. Transporting any other liquid is not normally
possible. As the tanker must return empty, operating costs
become very high. Model 20K is placed into any standard 20 ft.
Container, or 2- in a 40 ft. Container depending on road
restrictions.
By adding a water treatment system to the WATERBAG a permanent
bulk water storage system can also be established at minimum
cost.
Using low cost salt where available to produce a sanitizing
product that is 50 - 100 times more effective than chlorine to
treat a water distribution systems for cities, towns and villages
or permanent water storage tanks.
Complete blow moulding machinery to produce bottles in various
sizes and shapes to suit.
Complete blow moulding machinery to produce bottles in various
sizes and shapes to suit.
To fill bottles with cooking oil from a bulk supply, i.e.
WATERBAG SYSTEM or from ocean tankers/tanker trucks
To fill bottles and pails with germicidal and disinfectant
cleaners that are supplied in bulk and in very strong
concentrations. (Blend 160:1) The complete blending and
proportioning system is supplied with the bottle filling
equipment, labellers, labels etc...Local tradespeople are
used to assemble the pre-fabricated system.
A complete "turn key" operational assembly line that will supply
water coolers for "own use", as well as sales in the local area;
the country; and for export to other countries. The system is
available where applicable, in completely assembled modules that
interconnect on site that become a completely enclosed "building"
within the main plant. The result is a completely operational
assembly plant including air conditioning, lighting, all
utilities, (electrical, plumbing, air) conveyors, air compressor,
tables, PLUS all assembly, testing and installation equipment and
tools. The evacuation, (vacuum), refrigerant charging, leak
detection and operational testing of coolers is carried out using
sensitive monitoring equipment. Local labour only is required.
Base system is rated at 200 coolers per shift, (daily output may
vary depending on market requirement and the number of
employees). Output production can be increased in future by
adding modules into the system. Resulting cooler cost is usually
less than ½ of the normal landed price. All tooling can also be
provided whenever local metal fabrication is economically viable
in that particular country.
As an alternative to the above high production operation, we also
provide a low cost assembly system for small production outputs.
All tools, equipment and training would be supplied according to
each situation.
All water cooler component parts are supplied in container loads.
An innovative and unique complete self contained, mobile
emergency water treatment and bottling system, fabricated in a
45/48 ft trailer or shipping container and includes its own power
source. Each system is designed to customer's requirement and
can include a filtering system, bottle filling equipment, bottle
washer, ozonator, storage tanks, bottles, (sizes available from
350ml to 22 litres. Both the 1 litre and the 20 litre bottle is
available in both a hard and a collapsible model.). This system
is ideal for both military, and civilian applications to help
solve a water distribution crisis. Mobile unit is operational
within 10 minutes of arriving on site. Local water source (sea
water, lakes, stream, wells) can be treated and resulting potable
water can be bottled, or transferred to larger permanent storage
containers. The 20,000 litre WATERBAG transportation system
placed into a 20 ft. container can also be used to transport the
treated water. In can now be used either as a mobile storage
system accompanying the mobile bottling unit or as an "on site"
storage system. By travelling between sites (towns, villages
etc.) At pre-determined time intervals, clean drinking water is
provided to a large number of people at minimum cost.
Market profile
Alliances:
- Technology
Geographic markets:
Export experience:
- Ecuador
- Mexico
- Portugal
- United States
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
413220 - Alcoholic Beverage Wholesaler-Distributors
Products, services and licensing
Product / Service / Licensing
A complete and diversified product line of bottle washers,
fillers, and cappers to meet any requirement from small start up
to high volume output suitable for all 3, 5 and 6 U.S. gal
bottles. Semi automatic and completely automatic systems are
available each offering a choice of high to minimum labour
requirements. Collapsible and "hard" bottles are available, as
well as all operating supplies. Filling bottles from 350 ml to
22 litre and 1 gal bottles are also available.
An operational plant is available. We can provide all equipment
and material, and use local labour plus our installation
supervisor, and tradesmen, or equipment only is available, for
installation by others. By providing equipment and training, at
an economical and reasonable cost, the needs of the small bottler
as well as the larger established growing bottlers, can be met.
A unique, low cost, flexible and versatile solution to shipping &
storage of virtually any liquid or powder product. Shipment of
water, cooking oils, concentrated detergents, juices, flavours,
paint, oil, powders, etc. is now possible in the same container
system, simply by replacing (or re-using if applicable), the
inner bag. There is no product cross contamination, which allows
the WATERBAG to be used as a "two way" shipping container
regardless of the type of products being shipped. The outer
heavy duty liner has a life expectancy of 6 years under normal
use. The MODEL 20K (20,000 litres) folds onto a standard skid
should it be necessary to be returned empty. Note that other
types of returnable containers keep their original shape and
volume resulting in substantial additional costly shipping
charges when returned empty. Stainless steel tankers are very
expensive, not normally available, and must be dedicated for
drinking water. Transporting any other liquid is not normally
possible. As the tanker must return empty, operating costs
become very high. Model 20K is placed into any standard 20 ft.
Container, or 2- in a 40 ft. Container depending on road
restrictions.
By adding a water treatment system to the WATERBAG a permanent
bulk water storage system can also be established at minimum
cost.
Using low cost salt where available to produce a sanitizing
product that is 50 - 100 times more effective than chlorine to
treat a water distribution systems for cities, towns and villages
or permanent water storage tanks.
Complete blow moulding machinery to produce bottles in various
sizes and shapes to suit.
Complete blow moulding machinery to produce bottles in various
sizes and shapes to suit.
To fill bottles with cooking oil from a bulk supply, i.e.
WATERBAG SYSTEM or from ocean tankers/tanker trucks
To fill bottles and pails with germicidal and disinfectant
cleaners that are supplied in bulk and in very strong
concentrations. (Blend 160:1) The complete blending and
proportioning system is supplied with the bottle filling
equipment, labellers, labels etc...Local tradespeople are
used to assemble the pre-fabricated system.
A complete "turn key" operational assembly line that will supply
water coolers for "own use", as well as sales in the local area;
the country; and for export to other countries. The system is
available where applicable, in completely assembled modules that
interconnect on site that become a completely enclosed "building"
within the main plant. The result is a completely operational
assembly plant including air conditioning, lighting, all
utilities, (electrical, plumbing, air) conveyors, air compressor,
tables, PLUS all assembly, testing and installation equipment and
tools. The evacuation, (vacuum), refrigerant charging, leak
detection and operational testing of coolers is carried out using
sensitive monitoring equipment. Local labour only is required.
Base system is rated at 200 coolers per shift, (daily output may
vary depending on market requirement and the number of
employees). Output production can be increased in future by
adding modules into the system. Resulting cooler cost is usually
less than ½ of the normal landed price. All tooling can also be
provided whenever local metal fabrication is economically viable
in that particular country.
As an alternative to the above high production operation, we also
provide a low cost assembly system for small production outputs.
All tools, equipment and training would be supplied according to
each situation.
All water cooler component parts are supplied in container loads.
An innovative and unique complete self contained, mobile
emergency water treatment and bottling system, fabricated in a
45/48 ft trailer or shipping container and includes its own power
source. Each system is designed to customer's requirement and
can include a filtering system, bottle filling equipment, bottle
washer, ozonator, storage tanks, bottles, (sizes available from
350ml to 22 litres. Both the 1 litre and the 20 litre bottle is
available in both a hard and a collapsible model.). This system
is ideal for both military, and civilian applications to help
solve a water distribution crisis. Mobile unit is operational
within 10 minutes of arriving on site. Local water source (sea
water, lakes, stream, wells) can be treated and resulting potable
water can be bottled, or transferred to larger permanent storage
containers. The 20,000 litre WATERBAG transportation system
placed into a 20 ft. container can also be used to transport the
treated water. In can now be used either as a mobile storage
system accompanying the mobile bottling unit or as an "on site"
storage system. By travelling between sites (towns, villages
etc.) At pre-determined time intervals, clean drinking water is
provided to a large number of people at minimum cost.
Market
Market profile
Alliances:
- Technology
Geographic markets:
Export experience:
- Ecuador
- Mexico
- Portugal
- United States


Basic Information
Name
Mr
Ms
Age
Gender
Male
Female
Contact Information
Primary Phone
Alternate Phone
Email
Extension
Fax
Address Information
Street
City
State
Country
Zipcode
DOB


Ryan Perkins shared a post.
September 5 at 02:33
-
Jonathan Diaz I love it and i will share in my timeline
-
Douglas Hall One of my favourite quotes from the old days. So glad it's back! :-)
Ryan Perkins added a new photo.
September 3 at 18:10
Ryan Perkins shared a video.
September 1 at 09:52
Efficiently unleash cross-media information without cross-media value. Quickly maximize timely deliverables for real-time schemas. Dramatically maintain clicks-and-mortar solutions without functional solutions.
Completely synergize resource sucking relationships via premier niche markets. Professionally cultivate one-to-one customer service with robust ideas. Dynamically innovate resource-leveling customer service for state of the art customer service.
Ryan Perkins added a new photo.
August 30 at 19:10
Ryan Perkins shared a video.
September 1 at 09:52
Completely synergize resource sucking relationships via premier niche markets. Professionally cultivate one-to-one customer service with robust ideas. Dynamically innovate resource-leveling customer service for state of the art customer service.
Ryan Perkins shared a post.
July 17 at 05:59
-
Rachel Ryan I love it and i will share in my timeline
-
William Patel One of my favourite quotes from the old days. So glad it's back! :-)
Houston, TX 77030
The 1999 Kocaeli earthquake occurred with a moment magnitude of 7.4 that struck northwestern Turkey on 17 August at about 3:02 a.m. local time.


// "Small things matter." Clean Code by Robert C. Martin
do { clean_code(now) } while (1 == 1);
Mari Rizzo
Programmer, developer, systems analyst and in my free time , I play ukulele and love being in nature.
São Paulo/Brazil


Semantics! is a library for implementing interpreters of structured text, e. g. lists, markup or computer languages. I wrote it as a part of another project, Barbersynth, but I was more pleased with the interpreter part of that project than the rest of it, so I decided to give the interpreter some extra attention here.
In this document, I will design a simple math language and implement an interpreter for that language using the Semantics! library as an demonstration of how it works. I will also build a simple calculator to make the interpreter interactive. The calculator will look something like this:
function Calculator(interpreter, formElement, name) { this.name = name; this.interpreter = interpreter; this.input = document.createElement("input"); this.output = document.createElement("input"); this.submit = document.createElement("input"); this.submit.type = "submit"; this.submit.value = "calculate"; this.element = formElement; formElement.appendChild(this.input); formElement.appendChild(this.submit); formElement.appendChild(this.output); // otherwise the page relodes formElement.onsubmit = function() { return false; }; formElement.addEventListener("submit", this); } Calculator.prototype.handleEvent = function() { var userInput = this.input.value; var result = this.interpreter[this.name](userInput); this.output.value = result; return false; };
The name argument in the constructor specifies what method of the interpreter we want to use. You use the calculator by writing an expression in the left field. When you hit "Calculate" it will call the method of interpreter that was defined in the name argument of the constructor. It will call that method with the text content of the left field. The result of the interpretation will be presented in the rightmost field.
Lets make a dummy interpreter that answers every question with 42, just to test the calculator. Write a question in the left field, click calculate ant try to understand the answer given in the right field.
HTML:
<form id="dummy"></form>
JavaScript:
var dummyInterpreter = { expression: function(question) { return "The ansver to '" + question + "' is 42."; } }; var dummyForm = document.getElementById("dummy"); new Calculator(dummyInterpreter, dummyForm, "expression");
The most central component of a math language is the number. In computer science and semantics, such a component is called a "terminal". The Semantics! library has a way of creating terminals, and I will show how it could be done for the number terminal. I will make this as simple as possible as not to distract from the demonstration of the functionallity of the library. Therefore I will define a number as one or more digits that may start with zeros. Semantics uses regular expressions to identify terminals. My definition of a number has the regular expression /[0-9]+/.
In Semantics!, you must use capturing groups, so the expression becomes /([0-9]+)/. This has the practical effect that parts of the text that doesn't carry any meaning can be left out of the capruring group. For example, I want my language to allow for whitespaces. I can easily do this by adding optional whitespaces to the regexp, but to left them out of the capturing group that defines the part of the text that carries meaning. This makes the new regexp /\s*([0-9]+)\s*/. The interpreter will accept spaces, but it wont make any use of them. Now we are ready to create our first terminal expression!
var factory = new InterpreterMethodFactory(); var interpreter = {}; interpreter.number = factory.terminal(/\s*([0-9]+)\s*/, function(number) { return Number(number); });
Let's try that in our Calculator. Write a positive, whole number, possibly with surounding spaces.
In the first line of the code we create an InterpreterMethodFactory, which is an object that makes interpreter methods for other objects. Next we create the object that is going to be the interpreter of our language. Then we use the method factory to create a new terminal method for our interpreter. To do that, it needs two things: the syntax of a number and the semantics of a number. The capturing group of the regular expression provides the syntax and the function provides the semantics of a number. Numbers have a simple semantic in most languages. It just reports its value for the statements around it to use. In the Semantics! library, this is accomplished by a return statement. Later on we will see how the statements around the number will be notified of its return value, but for now it works like this.
The terminal method of the factory object will create a new method that is supposed to be put on an interpreter object. The created method will accept a string and match it to the regular expression. Next it will call the supplied function as if it where a method of the interpreter object with the captured group as argument. Our particular function calls the Number constructor, because that is an easy way of converting strings to numbers in javascript. Remember that the group captured by the regular expression will be a string, not a number. The resulting number of the function will then be returned by the expression method of the interpreter.
I want you to think of the terminal method as a way of making a function that can split a string argument into several string arguments, one per capturing group,
function(string) {code} + /(capturingGroup1)(capturingGroup2).../ + magic -> -> function(match1, match2, ...) {code}
or, more formally
InterpreterMethodFactory.prototype.terminal = function(regexp, callback) { return function(text) { var match = regexp.exec(text); callback.apply(this, match.slice(1)); }; };
The actuall code is more complicated than this, mostly because of Semantics! ability to backtrack alternative interpretations requires it to separate the matching step from the execution step. In fact it recursively builds a single monolithic instruction from the whole text and executes it. Not very efficient, I admit, but if the current part of the code can be interpreted in several ways, Semantics! is able to look further in the code to determine which of them is the correct one.
In fact, Semantics! can handle languageswhere the last letter determines the interpretation of the rest of the text. Semantics! will just build an instruction for all of the code and discard that instruction if the last letter doesn't match, and redo it for all the interpretations corresponding to each possible last letter until the last letter matches. Firstly then, anything is executed. Since nothing was executed for the wrong interpretations, they will leave no side effects. Please don't make such a language.
So far, all we have done could easily be accomplished with the Number constructor. Now I will show how the sequencing feature of Semantics! may be used to do some actuall computations, by giving our interpreter the ability to add two numbers.
interpreter.plusSign = factory.terminal(/(\+)/, function() {}); interpreter.add = factory.nonTerminalSequence("number", "plusSign", "number" , function(number1, plusSign, number2) { return number1+number2; });
Before we dive into the code, here is an calculator connected to the add method. Remember that the calculator calls the add method with the string content of the left input and prints the result of the add method to the right input. Indeed, all methods produced by InterpreterMethodFactory should be called with a string to parse. Try adding two numbers, e. g. 1+2.
First we make a terminal that just matches a plus-sign without actually doing anything with it. Hence the empty function in its definition. That might seem unnecessary, but to match an addition we will have to match a plus-sign, even if we don't explicitly with it. Rather, the plus sign will be used to determine the meaning of the numbers around it: they should be added.
I agree that this is a rather awkvard way of doing it. I would rather be able to write:
interpreter.add = factory.nonTerminalSequence("number", /\+/, "number" , function(number1, number2) { return number1+number2; });
It's on my todo list.
The nonTerminalSequence method accepts one or more strings and one function. The strings are names of other parsing methods on the interpreter object. When the method, add in this case, is called it will call the named methods and remember their results. It then calls the function with the results as arguments. Informally it works like this:
interpreter.add(string) + (number1 -> result1 + plusSign + number2 -> result2) + + magic -> interpreter.add(result1, plusResult, result2)
More formaly it works like this:
InterpreterMethodFactory.prototype .nonTerminalSequence = function(methodName1, methodName2, ..., callback) { return function(text) { // text is split into text1, text2, ... according to the syntax of // this[methodName1], this[methodName2], ... var results = [this[methodName1](text1), this[methodName2](text2), ...]; callback.apply(this, results); }; };
The text is split by letting methodName1 parsing the text, method2 parsing the rest of the text and so on. There can be nothing "between" the text that the methods parses, they only consider a match at the beginning of the text they get.
There is an important difference between when the methods are called "from the outside" and when they are called internaly, e. g. as a part of a nonTerminalSequence. When they are called from the outside they don't accept any "trailing code". Even if the begining of the text matches, the interpreter will throw an error if the end of the text can't be parsed. When a parser method is called internally, on the other hand, it accepts that it only can match the beginning of the text that it is passed.
The reason for this slightly dramatic behavior is that the methods produced by Semantics! generally has a return value, so there is no room for a match result. Furthermore I can't think of a use case where it is better to use Sematics! for matching than regular expressions. But if there is a popular demand for a matching version, I will consider writing it.


|
2DGameSDK
1.0
2D Game Engine in C++ based on SFML
|
An object that can be rendered. More...
#include <VisualObject.h>
Public Member Functions | |
| virtual void | OnRender (sf::RenderTarget *target, sf::RenderStates states=sf::RenderStates::Default)=0 |
| Renders the object. More... | |
| virtual int | GetZIndex ()=0 |
| Retreives the Z Index. More... | |
Static Public Member Functions | |
| static bool | SortByZOrder (VisualObject *a, VisualObject *b) |
| Compares visual objects for sort. More... | |
An object that can be rendered.
|
pure virtual |
Retreives the Z Index.
Implemented in game::Entity, game::Projectile, game::Effect, and game::TileLayer.
|
pure virtual |
Renders the object.
| target | the render target |
| states | the render states |
Implemented in game::DynamicEntity, game::KinematicEntity, game::TileLayer, game::StaticEntity, game::Effect, and game::Projectile.
|
inlinestatic |
Compares visual objects for sort.
| a | object a |
| b | object b |


--- permalink: 404.html layout: error-default ---
Unfortunately that means you’ve also happened to find yourself at this 404 error page. But don’t waste your time at a page that doesn’t exist…check out my portfolio instead!


Be the Guest of Honor at This Exclusive Dinner Party
Outstanding in the Field is an open-air feast that celebrates farms and the farmers who run them. All of the food comes directly from the host farm and all the guests sit down to feast at one long table. So, do you want a seat? Visit www.outstandinginthefield.com for more information!


--- layout: documentation title: GroupListType ---
The GroupListType type specifies the groups that the user account belongs to.
| Field Name | Type | Description |
|---|---|---|
| Group1..n | GroupType |
The Group field specifies a group that a user account belongs to. This is an abstract type since group IDs are operating-system specific, and is extended as needed in the derived CybOX object schemas. |


| Name | Link |
|---|---|
| Algorithms | Link |
| All F2L Cases Explained | Video |
| Cube solution guide | |
| Cross | Video |
| White Cross (2) | Video |
| White Cross (3) | Video |
| Align Cross | Video |
| Align Cross (2) | Video |
| White Cross and Align | Video |
| Full | Video |
| Insert Corners - White sticker on side of the top layer | Video |
| Insert Corners - White sticker on top of the top layer | Video |
| Solving 3 x 3 | Link |
| Solving 2 x 2 | Link |
| Patterns | Link |
| Rubik's Cube Solve | Video |
©2018 Travis Hahn - MIT License


Password generator
Random password meeting user-specified requirements.
Required
Allowed
Excluded
Character group
Lowercase letters (a-z)
Uppercase letters (A-Z)
Decimal digits (0-9)
ASCII special characters (!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)
Other allowed characters:
Other allowed characters (overrides above exclusions):
Other required characters:
Other required character groups, separated by whitespace (overrides above exclusions):
Password length:
Generate password
Password:
password


Prince Charles hit by counterfeit art scandal as he sends back £50m 'fake' Monet
The Dumfries House has taken down the waterlily painting while a £42m Picasso and a £12m Dali artworks are also in doubt
by Keith Perry, https://www.mirror.co.uk/authors/keith-perry/Prince Charles has been caught up in an embarrassing art scandal following allegations a £50million Monet at one of his favourite stately homes is a fake.
An American forger says he, and not the 19th Century French impressionist, painted the image of waterlilies that hung at Dumfries House.
Dumfries House is the headquarters of The Prince’s Foundation and the painting has since been removed from public view.
According to the Mail on Sunday, two other artworks there – a £42million Picasso and a £12million Dali – are also counterfeit.
They are among 17 paintings on loan to the house from bankrupt businessman James Stunt, the former husband of Formula 1 heiress Petra Ecclestone.
A Prince’s Foundation spokesman last night confirmed: "Dumfries House accepts artwork on loan from time to time from individuals and organisations.
"It is extremely regrettable that the authenticity of these particular paintings, which are no longer on display, now appears to be in doubt."
Yesterday American artist Tony Tetro, who was once sentenced to six months in prison for art forgery, told the newspaper he had painted the pictures and sold them to Mr Stunt.
Mr Tetro makes a legal living replicating masterpieces for private use by clients in their homes and offices, and said Mr Stunt acquired 11 such pieces.
He said: "You can impress your friends with my pictures, decorate your home with them, but they would never pass expert scrutiny."
However, former bullion dealer Stunt insisted: "None of my stuff is fake."


{% extends "vipTips/vipbase.html" %} {% load static %} {% block title %} 1XPredict Free Tips {% endblock %} {% block content %}
1XPredict is all about trust
Your log in credentials are meant for you alone
Sharing them with anyone else may lead to suspension of your account
Use the navigation bar to check out our Services
{% endblock %}


Hello!
Welcome to the TKS single-page application template, built with:
To help you get started, we've also set up:
-
State Management. With RxJs Observable Store you will have
a centralized place to store your application or feature data. With the
state being immutable, the data will always be fed from a single source of
truth.
-
C# Model to TypeScript Model Generator. With the TypeGen
Generator, your C# Data Transfer Models will be automatically converted into
TypeScript Models to be used on the client side.
-
Azure Pipelines. A Build Pipeline is ready to use in your
Azure DevOps environment.
-
Debugging with VS Code. Debugging launch profiles for VS
Code that start up the API and Client App all at once. Instantly switch
between debuggers without leaving VS Code.
-
Client-side navigation. For example, click
Counter then Back to return here.
-
VS Code Extensions. Angular, .Net Core, Formatting and more
extensions to speed up development and keep code clean.
-
Angular CLI integration. In development mode, there's no
need to run
ng serve
. It runs in the background automatically,
so your client-side resources are dynamically built on demand and the page
refreshes when you modify any file.
-
Efficient production builds. In production mode,
development-time features are disabled, and your
dotnet publish
configuration automatically invokes
ng build
to produce minified, ahead-of-time compiled JavaScript
files.
The ClientApp
subdirectory is a standard Angular CLI application.
If you open a command prompt in that directory, you can run any
ng
command (e.g., ng test
), or use
npm
to install extra packages into it.


Preparing the DB2 Instance
Now we need to configure the database so that the plug-in can work with it. This requires coping some files from the plug-in's folder to the necessary SQLLIB locations.
We also need to change SYSADM_GROUP configuration parameter to use your choice of the SYSADM group name as the SYSADM group for this DB2 instance.
Steps:
- Issue the following comand:
db2auth_prepareinst > out.txt
- This copies the plug-in files to necessary SQLLIB locations, and prepares the local DB2 instance.
- Issue the following command:
configure_db2auth_plugin.bat (your SYSADM group name here)
- This updates the DB2 server instance to use the db2auth security plug-in binaries.
- It also changes the SYSADM_GROUP configuration parameter to use your choice of the SYSADM group name as the SYSADM group for this DB2 instance:
- Re-start the DB2 instance:
db2stop
db2start
You have now finished installing and configuring the plug-in.
For further information or trouble-shooting, please refer to the README documentation provided in the plug-in package.


December 2019 Hacker News Hiring Trends
Just as it did last year, React completed the full calendar 2019 as the top tech in Ask HN: Who is hiring? extending its win streak to 31 months. React has been trending down in recent months and December marks its lowest share of the year, at just over 25% of postings. But, the runner up, Python, still has a long way to go to catch up.
There were some notable big movers in December. Machine Learning made a jump from #12 to #4. While Go jumped back into the Top 10 overall and was the second most popular programming language.
The other big story for 2019 would have to be TypeScript which is now a Top 10 contender every month and at parity with JavaScript regularly.
Compare Top 10 Programming Languages
Compare Rails, node.js, PHP and Django
Compare React, Angular, Vue, and Ember
Compare Postgresql, MySQL and SQL Server
Compare Mongodb, Elasticsearch, Cassandra and DynamoDB
Compare Storm, Hadoop and Spark
Compare Kafka, RabbitMQ, SQS and Kinesis
Compare Terraform, Chef, Puppet, Ansible and CloudFormation
Compare Docker, Kubernetes, Mesos and Terraform
Compare Blockchain, Bitcoin and Ethereum
| Tech | Rank | Last Month | Change | Last Year | Change |
|---|---|---|---|---|---|
| React | 1 | 1 | 0 | 1 | 0 |
| Python | 2 | 2 | 0 | 2 | 0 |
| AWS | 3 | 3 | 0 | 3 | 0 |
| Machine Learning | 4 | 12 | +8 | 9 | +5 |
| Postgresql | 5 | 5 | 0 | 10 | +5 |
| node.js | 6 | 7 | +1 | 7 | +1 |
| Full Stack | 7 | 8 | +1 | 4 | -3 |
| golang | 8 | 11 | +3 | 11 | +3 |
| DevOps | 9 | 6 | -3 | 6 | -3 |
| JavaScript | 10 | 4 | -6 | 5 | -5 |
| TypeScript | 11 | 10 | -1 | 19 | +8 |
| Android | 12 | 16 | +4 | 17 | +5 |
| iOS | 13 | 14 | +1 | 16 | +3 |
| Java | 14 | 9 | -5 | 8 | -6 |
| Docker | 15 | 15 | 0 | 12 | -3 |
| Ruby | 16 | 13 | -3 | 13 | -3 |
| Rails | 17 | 17 | 0 | 14 | -3 |
| Kubernetes | 18 | 18 | 0 | 15 | -3 |
| Data Science | 19 | 25 | +6 | 22 | +3 |
| AI | 20 | 20 | 0 | 21 | +1 |
| Tech | Mentions | Rank | Last Year Mentions | Last Year Rank | Change |
|---|---|---|---|---|---|
| SQS | 8 | 72 | 4 | 128 | +56 |
| S3 | 12 | 61 | 4 | 116 | +55 |
| Phoenix | 7 | 76 | 4 | 122 | +46 |
| EC2 | 7 | 78 | 4 | 117 | +39 |
| Bitcoin | 5 | 86 | 4 | 123 | +37 |
| Embedded Systems | 5 | 89 | 4 | 124 | +35 |
| RDS | 7 | 77 | 5 | 111 | +34 |
| Microservices | 19 | 39 | 10 | 73 | +34 |
| Web Services | 5 | 92 | 4 | 126 | +34 |
| Ansible | 14 | 48 | 8 | 76 | +28 |


Are you ready to hit power level 9000!? Then read through this lesson plan to be a Super Saiyan
.
Topic / semester outline
Here's the proposed topics I've come up with to start. We may deviate from here as far as timing or how long we spend on different ones.
- Week 1 - Establishing an online identity as an
IT Professional (Vlogger)
- Treating ourselves as brands, we will establish
accounts and begin to setup the foundation for submission of assignments
throughout the semester
- Week 2 – Git / Github / Contribution (All roles)
- Collaborative participation on Github,
understanding concepts of Git / version control and how teams leverage this
technology for code and non-code
projects
- Week 3 - Improving our Brand
- Review the other brands being established, offering feedback to classmates as well as reflecting on and internalizing that feedback to improve our own brand for the semester
- Week 4 - HTML / CSS / JavaScript & the web (Front end)
- The big three powering most of what you use
today, a primer for reverse engineering. We’ll use codepen to demonstrate how
you can extend concepts of github into other realms
- Week 5 - Reclaim Hosting & CPanel & GravCMS
- We're going to dig into Reclaim
hosting
for the next several lessons and to give us a server to deploy CMSs on. CMSs come in different shapes and sizes and this will kick off several weeks looking at different CMSs in depth
- Reclaim
uses CPanel
- A hosting management platform which makes installing new applications a click away. We'll explore the CPanel interface and open the door to installing and experimenting with many different applications.
- We'll use GravCMS as our first vehicle into CPanels powers. GravCMS is a powerful yet simple static file driven website. It's built in PHP yet reads off Markdown
files in order to generate content. We'll explore the GravCMS user interface, learn why people use it and look at some sites built using it.
- Week 6 - WordPress CMS
- We'll look at the WordPress community and platform as it is the worlds most used open source CMS, thought to power some 30+% of all websites
- We'll dig into the WordPress UI, look at the Gutenberg editor, and see why more people build smaller websites using WordPress than any other platform out there today
- We'll talk about "Forks" through the lens of ClassicPress which is a popular fork of WordPress caused as a result of the Gutenberg editor
- We'll setup a basic WordPress site in Reclaim
hosting
to explore the guts of our own real working WordPress site.
- Week 7 - Drupal CMS
- We'll look at the Drupal community, it's history, structure and learn about why it's popular at a high level
- We'll dig into the Drupal UI and look at the more powerful aspects of it as to why people put up for lack of UX in exchange for raw power like User / role management and entity / field management
- We'll setup a basic Drupal site in Reclaim
hosting
to explore the guts of our own real working Drupal site.
- Week 8 - Drupal, revenge
- Given the interest and relative complexity of Drupal, we'll cover it in greater detail. This lab will focus on digging into the Drupal modules, permissions and roles system in order to start to convert our data modeling into a full blown headless API!
- It sounds more complicated then it is so don't get overwhelmed, Drupal really begins to shine when you understand the concepts it allows for. We won't have to write any code in order to identify and build out a headless API that talks to codepen!
- Week 9 - Spring Break
- Sleep and catch up on labs
- Week 10 - HAXcms
/ FOSS governance / User experience
- HAXcms is an experimental, incredibly lightweight content management system that my team is working on. I've dubbed it a new breed of system called an organic static site generator
. Traditional static site generators require command line to work and modify. Traditional CMSs require databases or backend processing in order to operate. HAXcms uses backend processing to write things to a portable static format on every operation. It means you could zip a site up in a single folder, hand it to another person, and they could open it up in their copy of HAXcms and start working on it. It also means that those same files can live on things like github and serve a highly dynamic website to people without a complex backend. It's a bit trippy... and it's the future of all things being pioneered at your institution of choice :)
- The HAX portion of HAXcms is short for Headless Authoring eXperience - meaning that it can be portable and plugged into any system. As a result, we'll go back to Drupal, Grav and WordPress and see what it's like to have a unified authoring experience in these spaces.
- We’ll review governance within open source
communities, understand the difference between licenses, learn how different structures operate (including Open vs Closed), see how to identify
healthy vs stagnated open source communities, and learn when people fallback to proprietary technologies. ELMS:LN / HAXcms had to go through a formal audit from the Apereo Foundation
, so I'll provide insight into what got us certified as a well formed software community.
- We'll perform a blind UX audit of HAXcms leveraging a technique in which you work with a partner to accomplish a specific task in order to identify gaps in the UX. I will demonstrate this technique first before we do it together in class.
- We'll continue to play with HAXcms and create a basic website in it, identifying issues run into and submitting them to the project issues queue as needed. Video and exercise for this week will be related to creating a documentation site about the experience of using HAX.
- Week 11 - Server Virtualization technologies (DevOps)
- Vagrant, Docker, Kubernetes, Docker Swarm and other virtualization tech has changed the web forever,
we’ll explore these and surrounding applications and learn why they are so
powerful
- We'll use the PlayWithDocker
web service in order to get hands on with Docker and better understand what it's doing and why it transform business process from a security and timeline perspective
- We will most likely have a guest join us this week, Michael Potter who is pioneering the future of microservice architecture
tied to visual front end assets to invoke them.
- Week 12 - Web components & Package management & Progressive Web Apps (Front end)
- HTML on steroids and the future of all application development, web or otherwise
- We’ll look at why this is transformative for application development and why all teams should be exploring it from an efficiency perspective. We’ll also experiment with a powerful new platform called Stackblitz to demonstrate the power of Package management + compartmentalized HTML
- NPM / Composer and how we stand on the shoulders of giants
- Week 13 –
Designing Accessible User experiences
- What is it, why is it important, who benefits, how do we test for it?
- We'll use assistive technology, lighthouse and Webaim's Wave plugin to test websites and understand the reports and feedback that these tools give us
- The lab this week, we'll leverage the tools discussed on real websites to find accessibility issues in a code pen and other spaces to demonstrate technique and explain how to diagnose accessibility issues to others.
- Persona creation and build real world accessible applications
- We'll learn about the process of building accessible applications prior to code development and leading into application development
- We'll look at platforms our team has been working on and have a guest lecture by Nikki Massaro-Kaufmann, UX lead on HAXTheWeb web component projects
- Week 14 – Exam / Introduction of OER final project
- Class 1: Exam. Finish and your welcome to leave
- Class 2: Establishing what the final project is
- Week 15-16 - EdTech / OER / Course project
- We’ll look at the courses we’re taking and its
usage of technology, where this technology is usable, where it’s not. Where
accessibility can be improved or accounted for.
- We’ll look at OER / open course technology
movements from philosophical, societal and technological perspectives.
- We’ll audit systems the instructor works on /
has worked on to identify gaps in existing technologies, critique what’s
available and think about how technologies discussed throughout the class can
be leveraged
- These labs will be combined into a single submission with 10% of the grade. Lab time will be spent learning about the context and having access to instructors to help while exploring the topic.


Sidi Bou Said lies about 5nm north east of the entrance to the commercial port of Tunis. It is a convenient base from which to explore the ruins at Carthage and the capital Tunis. The old town is worth the climb up from the marina, but keep to the main streets to see the best of it.
Position 36° 51'54"N, 10° 21'E (marina entrance)
Immigration and Customs officials are based here, but be prepared to pay as much as 100 euro in gifts
plus cigarettes.
Last updated February 2013.
Mooring
The marina is usually full from November to June and even in summer advance reservations are necessary. Details of the boat and ETA etc. (in French) are required by fax in advance of arrival.
Boats over 20 m LOA must contact the marina at least one week before arrival.
Facilities at the marina are very poor, no security (open to the public) and the water filthy.
The weather forecast is only available if you pay a gift
.
Anchoring
If you must visit this port, then anchoring off the marina (where it is free), is a better option. Here the water is clean and the sand offers good holding. Somewhere around 3651.5N/01021E would be good.
Last updated February 2013.
The local yacht club is welcoming, and you can get WiFi in their club-house if you take your own computer.


Query objects contain expressions that allow the application to specify a filter on the locally available data.
More...
#include "Query.hpp"
Inherits dds::core::Reference< DELEGATE >.
Inherited by dds::sub::cond::QueryCondition.
Query objects contain expressions that allow the application to specify a filter on the locally available data.
A Query is used in a QueryCondition or DataReader::Selector and is associated with one DataReader.
- SQL Expression
- The SQL query string is set by expression which must be a subset of the SQL query language. In this query expression, parameters may be used, which must be set in the sequence of strings defined by the parameter query_parameters. A parameter is a string which can define an integer, float, string or enumeration. The number of values in query_parameters must be equal or greater than the highest referenced n token in the query_expression (e.g. if %1 and %8 are used as parameters in the query_expression, the query_parameters should at least contain n+1 = 9 values).
Look here for the specific query expression syntax.
- See also
- dds::sub::cond::QueryCondition
-
dds::sub::DataReader::Selector
-
dds::sub::DataReader::ManipulatorSelector
-
Subscription concept
Definition at line 61 of file Query.hpp.
◆ const_iterator
Iterator for the query expression parameters.
Definition at line 75 of file Query.hpp.
◆ iterator
Iterator for the query expression parameters.
Definition at line 70 of file Query.hpp.
◆ Query() [1/3]
◆ Query() [2/3]
template<typename FWIterator >
| dds::sub::Query::Query |
( |
const dds::sub::AnyDataReader & |
dr, |
|
|
const std::string & |
expression, |
|
|
const FWIterator & |
params_begin, |
|
|
const FWIterator & |
params_end |
|
) |
| |
Create a dds::sub::Query associated with an dds::sub::AnyDataReader.
- Parameters
-
- Template Parameters
-
| params_begin | Iterator pointing to the beginning of the parameters to set |
| params_end | Iterator pointing to the end of the parameters to set |
- Exceptions
-
◆ Query() [3/3]
| dds::sub::Query::Query |
( |
const dds::sub::AnyDataReader & |
dr, |
|
|
const std::string & |
expression, |
|
|
const std::vector< std::string > & |
params |
|
) |
| |
◆ add_parameter()
| void dds::sub::Query::add_parameter |
( |
const std::string & |
param | ) |
|
Adds a parameter to the query.
See SQL expression info
- Parameters
-
| param | The parameter to add |
- Exceptions
-
◆ begin() [1/2]
◆ begin() [2/2]
◆ data_reader()
◆ end() [1/2]
◆ end() [2/2]
◆ expression() [1/2]
| const std::string& dds::sub::Query::expression |
( |
| ) |
const |
◆ expression() [2/2]
| void dds::sub::Query::expression |
( |
const std::string & |
expr | ) |
|
Set new expression.
- Parameters
-
| expr | ref anchor_dds_sub_query_expression "SQL expression" |
- Exceptions
-
◆ is_nil()
template<typename DELEGATE>
Check if the referenced object is nil.
In other words, check if the reference is pointing to a null object.
- Returns
- true if the referenced object is null.
◆ operator!=() [1/2]
template<typename DELEGATE>
Special operator!= used to check if this reference object does not equal the dds::core::null reference.
The non-null-check can be done like this:
if (r != dds::core::null) {
}
- Returns
- true if this reference is not null.
◆ operator!=() [2/2]
template<typename DELEGATE>
template<typename R >
Compares two Reference objects and returns true if they are not equal.
Inequality is based on the referential inequality of the object being pointed to.
- Parameters
-
| ref | the other Reference object |
- Returns
- true when not equal
◆ operator->() [1/2]
template<typename DELEGATE>
The operator->() is provided to be able to directly invoke functions on the delegate.
The decision to provide direct access to the delegate was motivated by the need for providing a way that was not invasive with respect to the CXXDDS API and yet would allow for vendor-specific extension. Thus vendor-specific extensions can be invoked on the Reference and on all its subclasses as follows:
my_dds_entity.standard_function();
my_dds_entity->vendor_specific_extension();
- Returns
- a reference to delegate.
◆ operator->() [2/2]
template<typename DELEGATE>
The operator->() is provided to be able to directly invoke functions on the delegate.
The decision to provide direct access to the delegate was motivated by the need for providing a way that was not invasive with respect to the CXXDDS API and yet would allow for vendor-specific extension. Thus vendor-specific extensions can be invoked on the Reference and on all its subclasses as follows:
my_dds_entity.standard_function();
my_dds_entity->vendor_specific_extension();
- Returns
- a reference to delegate.
◆ operator==() [1/2]
template<typename DELEGATE>
Special operator== used to check if this reference object equals the dds::core::null reference.
The null-check can be done like this:
if (r == dds::core::null) {
}
- Returns
- true if this reference is null.
◆ operator==() [2/2]
template<typename DELEGATE>
template<typename R >
Compares two Reference objects and returns true if they are equal.
Equality is based on the referential equality of the object being pointed.
- Parameters
-
| ref | the other Reference object |
- Returns
- true when equal
◆ parameters()
template<typename FWIterator >
| void dds::sub::Query::parameters |
( |
const FWIterator & |
begin, |
|
|
const FWIterator |
end |
|
) |
| |
Sets the query parameters.
See SQL expression info
- Template Parameters
-
| begin | Iterator pointing to the beginning of the parameters to set |
| end | Iterator pointing to the end of the parameters to set |
- Exceptions
-
◆ parameters_length()
| uint32_t dds::sub::Query::parameters_length |
( |
| ) |
const |
Gets the number of parameters in the query.
See SQL expression info
- Returns
- uint32_t The number of parameters in the query
- Exceptions
-
The documentation for this class was generated from the following file: