text:
RELEASE NOTES
=============

Version: 1.2.0
--------------

  Roll our own very partial rST/markdown-like font markup parser to remove
  run-time dependency on PCRE libraries for easier deployment.

  Add `cgCfg.helpSyntax` field which CLI authors can default differently and
  `[templates]/helpSyntax` which end CL users can override to say whatever.

  The type `ClCfg`, the global compile-time default `clCfg`, and the two
  provided config file parsers have grown ways to suppress prefix matching.
  A CLauthor can set clCfg.longPfxOk = false and then his (savvy) CLusers
  can override that default with longPrefixOk = false in the syntax section
  of their config file (unless the CLauthor doesn't use a config file or
  overrides the provided impls...).

  Add `sysUt.toItr` to simplify life when using closure iterators.  Show use
  in `trie.leaves` as a "recursive iterator" (as close as makes sense in Nim).

  Add minimal proof-of-concept Python multiprocessing-like `procpool` module &
  `examples/only` and `examples/dirq` using inotify as a reliable OS queue.

Version: 1.1.0
---------------
  Add fast file tree walk iteration `cligen/dents.forPath`.  On Linux (esp.
  true Intel), sys\_batch & -d:batch afford even more speed-ups.  Add `chom.nim`
  example to also exhibit some fancy "octal integer" argparse usage.  Add `rr`,
  `dirt`, and `du` examples to show non-trivial cases needing a recursion-aware
  recursion abstraction.

  Replace `NimVersion vs ""` tests with `(NimMajor,NimMinor,NimPatch)` tests.

  Add some support inequality routines for `cligen/statx.StatxTs`.

  Repo does auto-CI runs & auto-doc gen now thanks to @jiro4989 and @kaushalmodi
  { Testing pre-commit is better (both less waiting and, well, pre-commit). }

  Added `$doc` and `$help[param]` rendering via any non-nil `clCfg.render`
  string-to-string transformer.  One easy way to get one is to add a `[render]`
  section to your `~/.config/cligen/config` file that sets at least one of
  singleStar, doubleStar, tripleStar, singleBQuo, doubleBQuo to some "on ; off"
  pair.  That will do an initRstMdSGR/render on $doc and $help[param] text.

  As follow-on from the above better help formating work, also do a smarter
  word wrap that A) minimizes the Lp norm of the extra-space-at-EOL vector,
  B) is better about preserving the blank line structure in inputs, and C) can
  still wrap lines in paragraphs that are outside of indented lines (instead
  of the prior any-indent-anywhere ==> whole string pre-formatted).

  The top-level help of a `dispatchMulti` command is now rendered and wrapped
  just like the `$doc` for each subcommand.

  Add more conveniences in cligen/mslice, cilgen/osUt, & factor out stripSGR.

Version: 1.0.0
---------------
  No new problems in the past few weeks => call it time to stamp 1.0.  (Truly
  well argued/motivated breaking changes will always remain possible, but do
  not seem super likely.)

Version: 0.9.47
---------------
  Try to clean up documentation of new config file/colorization features.

  Fix minor bugs in `cligen/abbrev.expandFit` & `examples/dups.nim` on Android.

  Address long-standing (since the beginning) bug when a parameter name is one
  letter and collides with either automatically selected or manually specified
  short options.  https://github.com/c-blake/cligen/issues/146

  Address long-standing surprising behavior where `mergeParams` is called twice
  for `dispatch` style.  Still called N+2 times for `dispatchMulti` until some
  re-write of that to not itself use dispatchGen on some generated proc.  Update
  0-level `cligen/mergeCfgEnv.nim`; add 1-level `cligen/mergeCfgEnvMulti.nim`
  example/library impls.  The only impact of this is that people (maybe no one)
  calling `dispatchCf` directly (to use its `cf` parameter to pass a CLauthor
  `ClCfg`) must now provide a command line themselves via `dispatchCf`'s new
  `cmdLine` parameter.  They can call `mergeParams` there to recreate the old
  broken behavior exactly or do something else which is probably more useful.

Version: 0.9.46
---------------
  Silence `argcvt.nim` implicit copy warnings in `--gc:arc` mode.  Problem cases
  (no move warns but using move fails) remain at: cligen.nim:{490,504}, and
  cfUt.nim:16 and cligen/clCfgInit.nim:14 (at least..maybe others).  The exact
  cases will be specific to your exact version of Nim as `gc:arc` is in a rapid
  development phase.

  Added convenience wrappers `recEntries`, `paths` in `cligen/posixUt.nim` for
  fully general path inputs often nice in CL utils.  See `examples/dups.nim`.

  Remove `cligen/oldAPI.nim` and its `include` in `cligen.nim`.  I'm not sure
  anyone ever used this, but it is especially defunct given `clCfgInit`.

  Add `test/FancyRepeats2.nim` to show a second way to do it.

  Add one "output breaking" change to simplify implementation of dropping (in
  `dispatchMulti` context) the "Usage:\n" header more like how skipping repeats
  of -h,--help and --help-syntax works.  If you were passing your own `usage`
  template anywhere then you will probably want to delete the "Usage:" prefix.
  It will work ok with it still there, but be repetitive/ugly.

  --

  The above is part of a large feature addition to allow opt-in presentation
  (and some CL syntax) configuration by CL end users -- probably How It Always
  Should Have Been (TM) since CL authors can only anticipate so much.  This
  configuration is via the include `cligen/cfCfgInit.nim` by default which reads
  `~/.config/cligen/config`|`~/.config/cligen files`.  `configs/config` in the
  distribution is an example config and the Wiki will have more details someday.

  If you hate parsecfg and don't mind an additional parsetoml dependency,
  @kaushalmodi has contributed an alternate config parser with an example in
  `configs/config.toml`.  Just compile with `-d:cgCfgToml` to activate and
  see `configs/config.toml`.

  If you really hate providing CL end users with some/all of this flexibility
  then you can always write your own project-specific `cligen/clCfgInit.nim`.
  For maximum terminal compatibility `cligen` does no colors by default.  If
  your user base is un-picky, such as "only yourself", you can also provide
  colorful defaults via compile time `clCfg` hacking.

  Further, if the user sets the `$NO_COLOR` environment variable to any value
  then all escape sequences are suppressed.  This can be helpful for programs
  that parse the output of `cmd --help`.  E.g., for the Zsh auto-complete system
  you want to patch the `_call_program` function to export `NO_COLOR=1`.  I am
  considering interpreting the double negative `NO_COLOR=notty` as a tty-test.
  { Often one wants colors piped to `less -r`.  So, that alone isn't enough. }

  Environment-variable sensitive `[include__VAR]` can be used to set up night
  mode/day mode https://github.com/c-blake/cligen/wiki/Color-themes-schemes

  Since this new feature addition is a large change with slight compatibility
  ramifications, and more importantly since it seems likely to inspire follow-on
  requests that may be hard to make compatibly, I am deferring the 1.0.0 stamp
  until a release or two from now.

Version: 0.9.45
---------------
  Make compatible with pre-1.0 Nim.

  This is the last pre-1.0 release with 1.0 likely at the end of April.  Please
  make any feature requests you think may require breaking changes now or be
  prepared for even more than usual pushback in the interests of stability.
  (Truly well argued/motivated breaking changes will always remain possible.)

Version: 0.9.44
---------------
  Fix bad bug in `posixUt.recEntries` where it only worked for "." and make
  the warning message more clear/specific about re-visitation not looping.

  Have `argcvt.ElementError` inherit from `ValueError` not `Exception`.

  Make `helpDump` in `dispatchMulti` skip repetitive --help/--help-syntax rows
  with instead just a note at the top about general availability.

  I've added some `move` annotations to silence many gc:arc warnings, but many
  (cligen.nim:457, cligen.nim:471, cfUt.nim:16, argcvt.nim:308, argcvt.nim:318,
  argcvt.nim:320) fail with `move` due to immutability/etc. (the very first only
  at runtime) while warning without move.  If you find any you can silence with
  a `move` successfully let me know.

Version: 0.9.43
---------------
  In most contexts for most parameters you can now use a compile-time `const`
  value instead of a literal.

  Default `cligen/helpTmpl.nim:clUse` dropped overly chatty text redundant
  upon first real line of `--help-syntax`.

  Updated generated documentation and include CSS (Thanks, @kaushalmodi!)

  `cligen/textUt.match` changed its return type to `tuple[key:string, val:T]`.
  If anyone else is using this, existing call sites need only add a `.val` to
  track the change.  (Sometimes it is nice/necessary to know the matched key.)
  Also for `Table` similarity, added `cligen/textUt.toCritBitTree`.  For UI
  ease add `match` overload to prints to a File if non-`nil` and also raise.

  `cligen/posixUt` grew an infinite-symlink-loop avoidant `recEntries` with a
  more traditional Unix API (user just says `follow=true` or not the way many
  Unix CLI utilities work) than `os.walkDirRec`.  At the API level, pointers
  are also optionally accepted to let callers receive all the metadata acquired
  and so avoid duplicate syscalls.

Version: 0.9.42
---------------
  Allow stropped aka \`backquoted\` params to have a `help` entry.  Add new
  test program for such.  Probably the first of only quite a few places we will
  need `maybeDestrop`.

  Add `cligen.initDispatchGen`.  See doc comment/commit comment for details.

  `textUt.getAll(cb: CritBitTree[T], key: string)` now returns a seq of len==1
  when the key is in the table (even if that key prefixes other keys).

  Add `cligen/osUt.loadSym` proc combining loadLib and symAddr operations.

  Add `cligen/abbrev.expandFit` to re-expand glob patterns as much as can be
  done without impacting a terminal column structure.  (Used by `lc`.)  Also
  add pattern quoting option (5th column to `Abbrev` initializer is "?;[]..")
  that can happen independently of `expandFit` as well as after it.

  `cligen/abbrev.uniqueAbbrevs` signature changes slightly.

Version: 0.9.41
---------------
  Fixed some bugs for `setByParse` users.

  Change the default `hTabSuppress` to `"CLIGEN-NOHELP"` to be more specific
  about what it does and kind of namespace it to be cligen-specific, too.

Version: 0.9.40
---------------
  `help["param"] == "SUPPRESS"` now removes param from the generated help
  table.  In the unlikely event you had that (case sensitive) string as a
  parameter help string, the string "SUPPRESS" can be adjusted via
  `clCfg.hTabSuppress`.

  Work around `csize` definition thrashing in Nim-actual by defining our own
  non-exported `csize` in modules that need it to the uint version.  Code seems
  to test out ok in all Nim versions >= 0.19.2.  About the only downside is
  that a private & different `csize` could cause some confusion to casual
  on-lookers/readers rapidly switching between in-cligen/out-of-cligen modules.
  Anyway, you probably do not want to use cligen v0.9.39 for anything, but
  nimble lets you say <=0.9.38 or >=0.9.40 (or #head, etc.).

Version: 0.9.39
---------------
  initFromCL` now works on ref|ptr object types.  See `test/InitObRef.nim` and
  `test/InitObPtr.nim` and https://github.com/c-blake/cligen/issues/118
  discussion.

  Fixed up several places that needed adjustment due to csize -> uint.

Version: 0.9.38
---------------
  Fix a little bug blocking abbrev(mx>0).

  Move `cmp`, `<=`, `-`(a, b: Timespec) from `statx` to `posixUt`.
  Add argParse/argHelp support for Timespec.

  cligen/[statx, magic] made somewhat autoconfiguring. (magic could probably
  use more paths.  PRs welcome.)

  ClAlias tuples have grown a 4th slot for default CL-author provided alias
  definitions and a provided default reference.  CL-author must pass a
  seq[seq[string]] empty list even if these new features are not used (to
  match the ClAlias type).  See test/UserAliases.nim

  Some new convenience API calls: `macUt.docFromProc`, textUt.termAlign\*,
  mfile.inCore posixUt.readFile st_inode nice nanosleep.

  `prsOnlyId` fix for newer Nim quote do: behavior

  .config/prog/config dir looked for before .config/prog file

  cfToCL includes are cfg-file relative paths if they don't start with /

  includes apply to the current subcommand section (config files for multi-cmds)

  only first paragraph of subcmd descrips are used in summary table

  readlink 1st arg renamed to path

  mergeParams no longer fails w/empty seq cmdNames arg and mergeParams is more
  consistenly always used instead of commandLineParams

Version: 0.9.37
---------------
  Add cligen/trie.nim.  Use match routine in abbrev.nim to change compression
  levels and add two new levels. Now the full map is:
    -2 shortest prefix
    -3 shortest suffix
    -4 shortest of either locally (or, upon any collision, shortest global avg)
    -5 shortest any-spot-1-star location
    -6 shortest 2-star pattern if shorter than 1-star
  and it probably won't change (except to maybe grow -7/3-star, -8/4-star,..)

  Also fixed a bug in parseopt3.nim which wasn't normalizing options for bool
  params correctly. (There still might be some issues in mixed abbreviated and
  in need of normalization cases.)

Version: 0.9.35
---------------
  Simplify usage of abbrev with Abbrev type. Generalize to have locally varying
  abbreviations (just unique prefix, suffix, or globally/locally shortest of
  either right now).

  Add Ternary Search Tree cligen/tern.nim and use in cligen/abbrev.nim, fixing
  bug in abbrevation modes -2..-5 in the presence of non-unique prefix strings.
  Name the routines [PS]fx**Pat**(s) to be clear it's a more well-defined answer
  than just unique prefix strings.

Version: 0.9.33,34
------------------
  Add abbrev, parseAbbrev, uniqueAbs, smallestMaxSTUnique to new cligen/abbrev.

Version: 0.9.32
---------------
  For single-dispatch, add a system so that CL users can define aliases (named
  bundles of CL args).  Alias definitions make sense in earlier `mergeParams`s
  sources such as config files or environment variables.  Later on in the
  command parameters they can reference them with a different CL option.  See
  `test/UserAliases.nim` and `test/UserAliases.cf` for an example.  Also add
  `textUt.match` and use it in the new alias system.

  Do not auto word wrap help text for a parameter if the help text contains any
  newlines. [ Note this extends the existing heuristic of considering the main
  doc comment "pre-formatted" if it has 2-or more "\n " substrings and that
  pre-formatted text is less adaptable to run-time terminal width. ]

  Add a way for `initFromCL` to ignore all fields after a given one.  The first
  (but not necessarily only) member of `suppress = @[ first, ... ]` has to have
  the special spelling `suppress = @[ "ALL AFTER myIdent" ]` where `myIdent` is
  replaced by the final field to include in the initializer wrapped as cmdLine.
  {I'd also have liked a rule more like private fields, but didn't see an easy
  way to tell private from public/export-marked fields in `getTypeImpl` output.}

  Add several things to cligen/ helper libraries for building command-line
  utilities like `tab`, `humanUt`, `statx`, and `magic`.

Version: 0.9.31
---------------
  Fix bug where `cligen/mergeCfgEnv.nim` doc comment (and README.md) had said
  `$CMD_CONFIG` but the proc logic only used `$CMD`.  This is breaking for users
  only if they were relying on the old broken/non-standard behavior to point to
  some non-standard config file location.

  Add well-commented single- and multi-dispatch config file examples for people
  using `cligen/mergeCfgEnv`.

  Fix bug where `--v` would not auto-lengthen to `--version`.

  Added more general `fromNimble(nd, field)`.  Deprecated `versionFromNimble`.

  Added a new file `cligen/helpTmpls.nim` to distribute a library of any
  user-suggested `clUse`/`clMultiUse` definitions.

  `dispatchMulti(["multi"])` brackets now properly pass through `dispatchGen`
  keyword arguments.  Additionally, `doc` & `usage` in that `"multi"` slot are
  re-purposed for the top-level help of the multi-command.  See discussion
  here for background:
    https://github.com/c-blake/cligen/issues/107

  Introductory "pre-Usage" summary text is now taken from the first paragraph
  of the doc comment of the module calling `dispatchMulti`.  This can be changed
  by `["multi",doc=""]` (or whatever value you like) or by a blank line/comment
  at the top of the file.  `doc=fromNimble("description", nmblData)` is another
  partially automagic option.

Version: 0.9.30
---------------
  Have `dispatch2` in `cligen/oldAPI.nim` nest generation/calling inside `proc`
  that sets a local `ClCfg` from its parameter.  This is to quiet `verbosity:2`
  bogus warnings about GC safety as well as to be example code for how a modern
  invocations can silence such warnings.  Also have `dispatch2` be noisy about
  unsupported features.

  Add `dispatchCf` & `initFromCLcf`, wrapped by `dispatch` & `initFromCL`,
  respectively.  `cf` symbol variants allow passing a `cf` parameter, e.g.
  `cf=myCfg`.  Non-cf variants do not.  In both cases, assigments to the
  `cfClg` global propagate fine, but the non-`cf` versions will not trigger
  any (bogus) GcUnsafe warnings under verbosity:2.  For discussion see:
    https://github.com/c-blake/cligen/pull/106
  This is a breaking change *only* if you are already using the brand new (as
  of v0.9.28) `cf` *parameter* to `dispatch` (or `initFromCL`).

  Remove `mandatoryOverride` parameter to `dispatchGen`/`dispatch` introduced
  in cligen-0.9.11 before we had real version support/`parseOnly` mode.  Manual
  `dispatchGen` and `parseOnly` modes (as shown in e.g., `test/ParseOnly.nim`)
  allows totally general CLI author logic to inspect what a CLI user entered
  before actual dispatch to a wrapped proc if such sophisticated inspection is
  desired.  [ I doubt anyone ever used the already more-sophisticated-than-
  likely-useful `mandatoryOverride`. ]

  Make `dispatch`/`dispatchGen`/`initGen`/`initFromCL` interfaces insensitive to
  style style with respect to strings corresponding to Nim identifiers (`help`/
  `short` table keys, `positional`, `suppress`, `implicitDefault`).

Version: 0.9.29
---------------
  Add feature requested in both https://github.com/c-blake/cligen/issues/2 and
  https://github.com/c-blake/cligen/issues/30 .  See initFromCL documentation
  and test/InitOb.nim, test/InitTup.nim for how to use.

  Both issue https://github.com/c-blake/cligen/issues/28 and
  https://github.com/c-blake/cligen/issues/100 had a desire for CLI author
  controlled help-casing.  Now whatever string key is uses in `help = { }` is
  what shows up in help output.  So, e.g., `help = { "print-DNA": "yadda" }`
  should show up as `-p, --print-DNA= ..`.  If there is no `help` entry then
  `helpCase` is still used (though it would be weird for a CLI author to care
  about help table output long option spelling more than the parameter help).

Version: 0.9.28
---------------

  TL;DR: **IF** your compile breaks, just change `dispatch` -> `dispatch2`.
  If that fails, read on to update your code to the new API.

  Do ancient TODO item/close https://github.com/c-blake/cligen/issues/43.
  Remove 2 unneeded & lift 9 "proc signature independent-ish/CLI stylistic"
  of 28 `dispatchGen` (26 `dispatch`) parameters into an object of the new
  type `ClCfg`.  The idea here is to lift anything that very likely "program
  global" in a `dispatchMulti` setting to set in one place.  Per-proc edits
  remain possible via distinct `ClCfg` instances.  The detailed mapping is:

    Old dispatchGen param | New way to adjust settings
    --------------------- | --------------------------
    version/cligenVersion | ClCfg.version:string #MUST be "--version" now
                          |   arg version=("a","b") --> clCfg.version="b"
                          |   cligenVersion="b" --> clCfg.version="b"
    requireSeparator      | ClCfg.reqSep
    helpTabColumnGap      | ClCfg.hTabCols
    helpTabMinLast        | ClCfg.hTabRowSep
    helpTabRowSep         | ClCfg.hTabColGap
    helpTabColumns        | ClCfg.hTabMinLast
    mandatoryHelp         | ClCfg.hTabVal4req
    sepChars              | ClCfg.sepChars
    opChars               | ClCfg.opChars
    shortHelp             | Gone; Use short={"help", '?'} instead
    prelude               | Gone; Just use `usage` directly instead

  Client code not messing with anything in the left column and always passing
  `dispatch` params via keywords should need no changes.  `dispatch` params
  start changing at slot 7 (now `cf`) via mutations/removals.  Param order is
  otherwise the same except for `noAutoEcho` moving to after `echoResult` and
  `stopWords` moving to after `mandatoryOverride`.  This seems unlikely to
  matter.  Keyword calling seems pretty compelling at >=7 params & examples
  all use it.  `template dispatch` shows the new full argument list.

  So, this change is BREAKING-ISH in that it MAY require client code updates,
  but only in rare cases.  Most likely only `version`/`cligenVersion` users
  need to do anything at all, and that is to just lift one assignment out of
  a parameter list/change one variable name.  The only loss in flexibility is
  "--version" spelling becoming as fixed as "--help" (flexibility to spell it
  otherwise was always pretty iffy, IMO).

  Apologies if I'm wrong about impact rarity, but 16 is much cleaner than 26
  and the new way is far more practical for `dispatchMulti` adjustments.  More
  changes like this are unlikely.  Remaining `dispatch` params depend strongly
  on formal parameter lists which are likely to vary across wrapped procs in
  a `dispatchMulti` setting (except `usage`/`echoResult`,`noAutoEcho` which
  have sub-sub-command/compile-time reasons to not move into `cf`).  After a
  trial period to resolve issues, I'll stamp a 1.0 version with the hope to
  make no more backward incompatible changes unless there is a great reason.

  An exported global var `clCfg`, the default for the new `cf` parameter, can
  simplify common cases.  Examples showing how to adjust the above settings
  the new way are in:
    `test/Version.nim`
    `test/FullyAutoMulti.nim`
    `test/HelpTabCols.nim`

  **Also** add `versionFromNimble` for `clCfg.version=versionFromNimble(..)`.

Version: 0.9.27
---------------
  Mostly just a release that supports nim-0.19.6.

Version: 0.9.26
---------------

  Get `dispatchMulti` working without sub-scopes with C++ backend (nim cpp)
  on Nim versions 0.19.2 and 0.19.4. For details see:
    https://github.com/c-blake/cligen/issues/94

Version: 0.9.25
---------------

  Add convenient mslice.Splitr abstraction for CLI utilities delimiting inputs
  in a variety of ways.  Add demo program examples/cols.nim showing use.

  Fix `dupBlock` bug related to table modification during iteration exposed
  by https://github.com/nim-lang/Nim/pull/11160

Version: 0.9.24
---------------

  Remove need for using `argcvt.argDf` in any custom `argHelp` impls.
  A deprecated identity proc is provided for transition.

  Have cligen.nim export all symbols needed by generated procs so `dispatch`
  can now be invoked in a sub-scope within a proc.  See `test/SubScope.nim`.

  In general, be more careful with namespace stuff.  Silence false positive
  warnings, and fix a few bugs.

  Have better `helpCase`-using ambiguity error messages.

Version: 0.9.23
---------------

  Add CLI-style insensitivity to subcommand name matching.  E.g.,
  `./test/FullyAutoMulti nel-ly` works (or ./test/FullyAutoMulti d-e-m-o
  for that matter).  To show a dash in help text requires using `cmdName`.

  Add unambiguous prefix matching for subcommand names.  E.g.,
  `./test/MultMultMult a c y`.

  Multi-commands now exit with status 1 on parsing errors (ambiguous or
  unknown subcommand names).

Version: 0.9.22
---------------

  Add ability to accept any unambiguous prefix spelling of long option keys
  like cmd / option autocompletion in most shells but without TAB key press
  or any shell support required). https://github.com/c-blake/cligen/issues/99

  Minor clean-ups.

Version: 0.9.20
---------------

  Some clean-up of the --help-syntax output, including mentioning style-
  insensitivity.

  Improve character literal escape interpretation (single digit octal and
  various standard abbreviations like \n ,\e, etc.) and also better match
  the non-printable rendering of such char's in default values.

  Add ability via helpCase to convert snake_case to kebab-case help text for
  long option keys and default values.

  Add ability to accept any unique prefix spelling of enum values (like cmd /
  option autocompletion in most shells but without TAB key involvement or any
  shell support required). ( See https://github.com/c-blake/cligen/issues/97
  and https://github.com/c-blake/cligen/issues/99 )

  Add a fully worked out not useless example program `examples/dups.nim`.
  Distribute several support modules for it that may help authors of similar
  CLI utilities via cligen/[tmUt, fileUt, osUt, sysUt, strUt, mfile, mslice].

  Adapt to several deprecations/changes in Nim.  Seems to work on 0.19.2 and
  0.19.4 as well as a current devel branch.  Also fix some bugs here & there.

Version: 0.9.19
---------------

  Get `test/MultiMulti.nim` and even `test/MultMultMult.nim` mostly working.
  Now you can create dizzyingly deeply nested subcommands (but you will
  likely need to write your own `parsecfg` and `mergeParams` rather than just
  using `include cligen/mergeCfgEnv` if you want to use that in a config file
  as `stdlib.parsecfg` is only one level deep). [ As part of this work, add a
  new string-instead-of symbol first [] parameter entry for `dispatchMulti`
  like parameter lists to control name of the generated multi dispatcher, and
  named params after that string are sent to the `dispatchGen` used internally
  for that dispatcher.  Right now this is a little buggy, but someday it
  should allow controlling things like cmdName, version, usage, etc. ]

  The type column for seq[T] in help tables is now the English plural of T
  instead of array(T).  This is both more brief and more human readable.

  Add newline stripping & then re-wrapping to terminal width for the main doc
  comment (in both command help and in a multi-command help table off to the
  side of each command).

  Add ability to `include cligen/mergeCfgEnv` between `import cligen` and
  `dispatch` to get a typical `parsecfg` and then `getEnv` initial filling
  of passed parameters.  It seems better to make CLI authors request this
  smartness rather than have it be on by default (since evars/cfg files may
  be in place already if the CLI names are too generic).  That said, if
  popular demand for on-by-default ensues then I am open-minded and we can
  have an `include cligen/mergeNoCfgEnv` instead.  Let me know.

  Add mergeNames to dispatchGen.  This is mostly for internal re-factoring
  purposes, but someone might find it useful for something else.

  Relax the need for `cmdName` in `dispatchMulti(qual.symb, cmdName)`.
  The last component of the `DotExpr` is used for `cmdName` by default.

  Introduce `clParseOptErr` for `requireSeparator=true` mode to flag
  `parseopt`-level errors.

  `dispatchMulti`-generated help has better gradual reveal semantics/more
  typical behavior (`help cmd` is now like `cmd --help`) { There is much less
  standardization in multi-command world for us to mimick }.  suggestions now
  also work for invocations with a subcommand and options afterward.

  Suggest correct alternatives for possibly misspelled enum values.

Version: 0.9.18
---------------

  This release adds some major features. ArneTheDuck asked for (approximately)
  mergeParams, alaviss asked for qualified proc name support, and TimotheeCour
  requested non-quitting invocation & something like setByParse and the new
  aggregate parsing and pointed out other bugs/helped implement some things.

  Generated dispatchers now have the same return type (including void) and
  the same return value of wrapped procs.  Abnormal control flow from bad or
  magic command parameters is communicated to the caller of a generated
  dispatcher by raising the HelpOnly, VersionOnly, and ParseError exceptions.
  Manual invocation of dispatchers probably needs to be updated accordingly,
  unless chatty exception messages are ok for your CLI users.

  `cligen` now tries to echo results if they are not-convertible to `int`.
  This feature can be deactivated via the `noAutoEcho=true` parameter to
  `dispatch`/`dispatchMulti`. { Since a 1-byte exit codes/mod 256 can be
  catastrophic truncation for many returns, it is possible trying to `echo`
  being the first step would be more user friendly.  However, if people want
  to write procs with various exit codes in mind, it's also hard to think of
  a more natural setup than just exiting with that integer return.  So, the
  need for the CLI author to supply an `echoResult=true` override remains. }

  `cligen` now gets its command parameters by calling `mergeParams()` which
  CLI authors may redefine arbitrarily (see `test/FullyAutoMulti.nim` and/or
  `README.md`).  Config files, environment variables or even network requests
  can be used to populate the `seq[string]` dispatchers parse.  Right now
  `mergeParams()` just returns `commandLineParams()`.  It could become smarter
  in the future if people ask.

  `argPre` and `argPost` have been retired.  If you happened to be using them
  you should be able to recreate (easily?) any behavior with `mergeParams()`.

  `cligen` now tries to detect CL user typos/spelling mistakes by suggesting
  nearby elements in both long option keys and subcommand names where "nearby"
  is according to an edit distance designed for detecting typos.

  Commands written with `dispatchMulti` now reveal information more gradually,
  not dumping the full set of all helps unless users request it with the help
  subcommand which they are informed they can do upon any error.  Similarly,
  `dispatchGen` generates commands that only print full help upon `--help` or
  `-h` (or whatever `shortHelp` is), but tells the user how to ask for more.

  `dispatchGen` now takes a couple new args: `dispatchName` and `setByParse`,
  documented in the doc comment.  `dispatchName` lets you to override the
  default "dispatch" & $cmdName dispatcher naming (note this is different than
  the old `"dispatch" & $pro` default *if* you set `cmdName`, but you can now
  recover the old name with `dispatchName=` if needed).

  `setByParse` is a way to catch the entire sequence of `parseopt3` parsed
  strings, unparsed values, error messages and status conditions assigned to
  any parameter during the parse in command-line order.  This expert mode is
  currently only available in `dispatchGen`.  So, manual dispatch calling is
  required (eg. `dispatchGen(myProc, setByParse=addr(x)); dispatchMyProc()`).
  NOTE: This interface is a first attempt and may change in the future.

  Generated dispatchers now take a `parseOnly` flag which does everything
  except dispatch to the wrapped proc which may be useful in combination with
  the new `setByParse`.

  `dispatchGen` now generates a compile-time error if you use a parameter name
  not in the wrapped proc for `help`, `short`, `suppress`, `implicitDefault`,
  or `mandatoryOverride`.

  Unknown operators in the default `argParse` implementations for aggregates
  (`string`, `seq[T]`, etc.) now produce an error message.

  `positional`="" to dispatch/dispatchGen now disables entirely inference of
  what proc parameter catches positionals.

  `help["positionalName"]` will now be used in the one-line command summary as
  a help string for the parameter which catches positionals.  It defaults to
  a Nim-esque `[ <paramName>: <type> ]`.

  Command-line syntax for aggregate types like `seq[T]` has changed quite a
  bit to be both simpler and more general/capable.  There is a non-delimited
  "single assignment per command-param" mode where users go `--foo^=atFront`
  to pre-pend.  No delimiting rule is needed since the user must re-issue an
  option to give multi-arguments.  There is also a more expert mode that does
  "splitting-assignments" where operators like `^=` get a `,` prefix like
  `,^=` and CL users always specify delimiters as the first char of a value,
  `-f,=,a,b,c` like common /search/replace substitution syntaxes.  Split-mode
  lets CL users assign many elements in one command parameter or clobber a
  whole collection with `,@=`.  See argcvt documentation for more details.

  The `delimit` parameter to `dispatch` has been retired.

  There is a new --help-syntax line item for all commands which emits a
  hopefully eventually user-friendly description of particulars related to
  syntax for cligen commands, a syntax which has some unique extensions.

Version: 0.9.17
---------------

  Add ability for [1] element of Version 2-tuple-literals to be compile-time
  constant strings rather than string literals.  See `test/Version.nim`.
  [ This also works for `cligenVersion`, but you must `const foo = ..` and
  then `cligenVersion = foo` since `cligenVersion` itself is not and
  should not be a compile-time constant. ]

  Add ability for top-level command in `dispatchMulti` to accept "--version"
  to print some version string.  Just set `cligenVersion = "my version"`
  somewhere after `import cligen` but before `dispatchMulti`.

  Fix bug where cmdName was not being compared with `eqIdent`.

  Fix subtle new nil bug https://github.com/c-blake/cligen/issues/41

  More informative error message when non-option arguments are passed.

Version: 0.9.14
---------------

  Add range checking for all numeric types to argParseHelpNum

  Adapt code to new Nim nil world order.  One visible consequence is that
  passing empty values to string/cstring type parameters is allowed/easy.

Version: 0.9.13
---------------

  Add `version` parameter to `dispatchGen` and `dispatch`.

  Send "--help" and "--version"-type output to `stdout` not `stderr` for
  easier shell re-direction.

Version: 0.9.12
---------------

  Rename to be more NEP1 compliant. User-visible renames should be limited to:
    argcvtParams         -> ArgcvtParams
    argcvtParams.Help    -> ArgcvtParams.help
    argcvtParams.Delimit -> ArgcvtParams.delimit
    argcvtParams.Mand    -> ArgcvtParams.mand

  Remaining violations are where I disagree with current --nep1:on are:
      HelpOnlyId as an exception
      WideT and T as types
      ERR where I like all caps to shout the id
  I might be persuadable to change the last one, but the first two are very
  much canonical NEP1 that --nep1:on gets wrong.  Until those are fixed, I
  see little point in being perfectly --nep1:on clean. (Also, that rename
  should not cause any user-code to break, unlike the argcvtParams renames.)

Version: 0.9.11
---------------

  Add new `mandatoryOverride` parameter to dispatchGen/dispatch for
  situations like --version where it is assumed the proc will exit before
  trying to meaningfully use any mandatory parameters.

Version: 0.9.10
---------------

  Appease nimble structure requirements.  The only breaking change should
  be the need to import cligen/argcvt if you define your own converters.

Version: 0.9.9
--------------

There are several major breaking changes and feature additions:

 1. A complete shift in the syntax for mandatory parameters.  They are now
    entered just as optional parameters are.  Programs exit with informative
    errors when not all are given by a command user.  This is more consistent
    syntax, has more consistent help text in the usage message and is easier
    on balance for command users.  For discussion, see
    https://github.com/c-blake/cligen/issues/20
    This is the biggest command-user visible change.

 2. `argParse` and `argHelp` are now `proc`s taking `var` parameters to
    assign, not templates and both take a new `argcvtParams` object to
    hopefully never have to change the signature of these symbols again.
    Anyone defining `argParse`/`argHelp` will have to update their code.

    These should probably always have been procs with var parameters.  Doing
    so now was motivated to implemenet generic support of collections (`set`
    and `seq`) of any `enum` type.

 3. `argHelp` is simplified.  It needs only to return a len 3 `seq` - the
    keys column (usually just `a.argKeys`), the type column and the default
    value column.  See `argcvt` for examples.

 4. `parseopt3` can now capture the separator text used by CLI users which
    includes any trailing characters in `opChars`.  `argParse` can access
    such text to implement things like `--mySeq+=foo,bar`.

 5. Boolean parameters no longer toggle back and forth forever by default. They
    now only flip from *their default to its opposite*.  There could be other
    types/situations for which knowing the default is useful and `argParse`
    in general has access to the triple (current, default, new as a string).
    For discussion see https://github.com/c-blake/cligen/issues/16

 6. `enum` types are supported generically.

 7. `seq[T]` and `set[T]` are supported generically.  I.e., if there is an
    `argParse` and `argHelp` for a new type `T` then `seq` and `set`
    containing that type are automatically supported.  `argcvt` documentation
    describes delimiting syntax for aggregate/collection types.

license: ISC

repository: cooldome/cligen

gha_license_id: ISC

repo_name: cooldome/cligen


text:
# Compose Exmaples

As Dockjob is designed to be run as part of a ‘docker stack’ with Kong in front of it providing https and user accounts I have provided this section with a set of examples showing how it could be run. These examples should be run on a machine with a docker environment which is set up in a swarm. The commands should be run from a directory with the relevant .yml file.

To use these you need to arrange to set the following enviroment variables on the machine running docker swarm:
````
 | Variable Name | Example Value | Description |
 |---------------|---------------|-------------|
 | EXTURL | https://somefunnyhostname.com | URL users use to access web frontend  |
 | EXTPORT | 443 | Port users use to access web frontend |
````
I do this by adding
````
export EXTURL=https://somefunnyhostname.com
export EXTPORT=443
````
to the end of ~/.bashrc

See [Enviroment Variables](../ENVVARIABLES.md) for documentation of possible container enviroment variables that can be used as settings.

# Dockjob Standalone
This uses docker to run dockjob standalone on a machine. This example shows setting dockjob options via environment variables. You must change the urls in docker-compose-standalone.yml replacing the host name with the hostname clients need to use to access dockjob.
Command to run:
````
docker stack deploy --compose-file=docker-compose-standalone.yml dockjob-standalone
````
Note: If you see a message that this node is not a swarm manager you may need to run docker swarm init

(For this option your EXTURL won't be SSL and your EXTPORT will be 80.
Now visit ${EXTURL}:${EXTPORT}/frontend

When done use
````
docker stack rm dockjob-standalone
````
to halt the stack.

# Dockjob with https

The next example uses Kong to expose dockjob as https. For this to work you need to add two secrets to the swarm, 'webservices_cert' and 'webservices_key'. They contain the SSL certificate and SSL key that the server will use. An example command to create them is here:

````
docker secret create webservices_cert - <<EOF
**FILE HERE**
EOF
````

Replace **FILE HERE** with the actual certificate file contents. Repeat for the key.

To use SSL you will need a proper hostname. Take the file docker-compose-https.yml and replace cat-sdts.metcarob-home.com with your own hostname.

Command to run:
````
docker stack deploy --compose-file=docker-compose-https.yml dockjob-https
````

You may need to wait a bit as the database is created and Kong is setup.

Now visit https://** YOU HOST **:443/frontend
You should notice you now have a https connection.

Use the docker stack rm command to stop the services.

# Dockjob with https and user auth

The final exmaple builds on the previous one by configuring Kong to only allow access to the dockjob api with a username and password. Dockjob is also configured to tell it's frontend component to prompt for a log on by setting the APIAPP_APIACCESSSECURITY enviroment variable.

You will again have to change the hostname in X and run this command to start the stack:
````
docker stack deploy --compose-file=docker-compose-https-basic-auth.yml dockjob-https-basic-auth
````

Now visit https://** YOU HOST **:443/frontend
The username and password is sampleuser - this can be changed in the compose file. I expect most deployments would migrate this password into a docker secret.

Use the docker stack rm command to stop the services.

# Dockjob with external hostname passed in via a secret

The application requires knowldege of the external url the users use to access the service. This is so the frontend app can correctly call the API. In my use case for dockJob I have a docker secret set up with the external host name. (This drives the SSL certificate process) It is useful for me that dockJob can pick up the hostname from this secret. Unfortunatly it is required in mutiple enviroment variables in different ways. To resolve this I have implemented a method that will allow another enviroment variables to be refered to. This compose file demos this.

To use it create a secret:
````
echo "somefunnyhostname.com" | docker secret create webservices_hostname -
````

Execute the compose file
````
docker stack deploy --compose-file=docker-compose-hostname-from-secret.yml dockjob-hnsecret
````

Finally use the docker logs command and verify the values were set correctly.

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive


text:
# Getting started with Nightcode
Nightcode is a clojure IDE that comes bundled with other tools in the
clojure development stack.

![Nightcode IDE](https://sekao.net/nightcode/screenshot.png)
# Install Nightcode
Download and install Java 7 or Java 8

Download Nightcode 1.0.1 from the link below into a tools folder like `~/tools/nightcode`

[Nightcode 1.0.1](https://github.com/oakes/Nightcode/releases/download/1.0.1/nightcode-1.0.1-standalone.jar)

Open a command shell and type `java -jar <path to nightcode download>`. For example, if you have downloaded Nightcode to `~/tools/nightcode` type the following in a command shell.

```
java -jar ~/tools/nightcode/nightcode-1.0.1-standalone.jar
```

To open a command shell,

**On Windows:**

(Windows Key + R) and then type `cmd` and enter

**On Mac:**

(Command Key + Space) and then type `terminal` and enter

Once Nightcode is loaded, verify that you have the complete clojure stack by typing command in the Clojure REPL.
# Clojure REPL
The clojure Read-Eval-Print-Loop or REPL console is at the bottom left corner of Nightcode. To evaluate an expression in the REPL, type in the expression and press enter as shown below

```
clojure.core=>(reduce + [1 2 3 4 5])
```

When you press enter at the end of the line you should see the following:

```
clojure.core=> (reduce + [1 2 3 4 5])
15
clojure.core=>
```

This confirms you have successfully installed Nightcode. **Congratulations!**

# New project cloned from git
  Follow the steps below to clone a new project from a git repository. For this example we will clone the git repository at https://github.com/clojurebridge-minneapolis/clojure-koans.git

 1. Click `New Project`
 2. Select a folder location for your project, type in your project name (say CBB) in the `File Name` form and click `Save`.
 3. On the `Specify Project Type` screen, click `Download`. In the `Git address` field, type in the address *https://github.com/clojurebridge-minneapolis/clojure-koans.git* and click `Clone Project`

The git project is now cloned and available for editing in Nightcode.

# Clojure Koans
Create a new Nightcode project cloned from the Clojure Koans git project at https://github.com/clojurebridge-minneapolis/clojure-koans.git

To run the Koans, do the following

 1. In the Nightcode project files panel on the left, select the file *src/koans/01_equalities.clj*. This will open the file in the editing panel.
 2. Click `Run with REPL`
 3. Click `Reload`
 4. Click `Eval`. You will see an assertion failure like the one below

 ```
 ExceptionInfo We shall contemplate truth by testing reality, via equality
 (= __ true)  clojure.core/ex-info (core.clj:4327)
 ```

 4. Modify the code in the file as below and click `Eval` again

 ```
 "We shall contemplate truth by testing reality, via equality"
 (= true true)
 ```

 You will now see that this assertion passed successfully and you a failure on the next assertion.

 5. Modify the code in the next assertion to make it pass and continue on to all the assertions in the file by clicking `Eval` every time you modify the code. The keyboard shortcut `(Command + E)` to eval can be used to quickly evaluate your answers as you modify the code.

gha_language: Clojure


text:
Okio Benchmarks
===============

This directory contains JMH microbenchmarks. Run benchmarks locally with Gradle:

```
$ ./gradlew jmh
```

Select and configure benchmarks in the `jmh` section of `okio/jvm/build.gradle`.


text:
# Automatic docker volume backup with git

[![License](https://img.shields.io/dub/l/vibe-d.svg)](LICENSE)
[![Pulls](https://img.shields.io/docker/pulls/fvanderbiest/volume-git-backup.svg)](https://hub.docker.com/r/fvanderbiest/volume-git-backup/)

This repository is the source of the [fvanderbiest/volume-git-backup](https://hub.docker.com/r/fvanderbiest/volume-git-backup/) image on Docker Hub.
The image provides an easy way to `git commit` a docker volume every time a file is updated.
Feel free to use it if it suits your needs. Contributions welcomed.

This image expects to find the volume mounted in `rw` mode on `/var/local/data`.

The file to watch for changes should also be contained in this directory.
Internally, we're using `inotifywait` to watch the file.

When change is detected, the script performs the commit and optionally pushes to a remote repository.

At startup, if a remote repository is configured a clone of this repository is
done in the volume. If volume is not empty, you will need to set FORCE_CLONE var
to 'yes' to force a cleanup of the volume. If the volume is already verionned
(contains a `.git` folder) then git remote is updated and local repository is updated
to the last commit of configured branch.

Example usage:
```yaml
sync:
  image: fvanderbiest/volume-git-backup
  environment:
    WATCH_FILE: global.xml
    GIT_COMMIT_MESSAGE: printf "updateSequence "; grep updateSequence global.xml|sed -e 's#.*ce>\(.*\)</up.*#\1#'
    GIT_USERNAME: fvanderbiest
    GIT_EMAIL<EMAIL_ADDRESS>  volumes:
    - geoserver_datadir:/var/local/data:rw
```

Required environment:
 * `WATCH_FILE`: file to watch (path relative to volume root)
 * `GIT_COMMIT_MESSAGE`: string or expression evaluated in the volume to provide a commit message
 * `GIT_USERNAME`: git username for commit
 * `GIT_EMAIL`: git email for commit

To push to a repository, these additional variables are required:
 * `REMOTE_NAME`: name of the git remote, eg `origin`
 * `REMOTE_URL`: git repository URL, eg `https://github.com/fvanderbiest/playground.git`

Optional environment:
 * `REMOTE_BRANCH`: Remote branch to use. Defaults to master.
 * `FORCE_CLONE`: Delete volume content before cloning remote repository

To use SSH authentication to access remote repository, one of following
variables must be set:
 * `GIT_RSA_DEPLOY_KEY`: Private RSA key to use (eg: [GitHub deploy keys](https://developer.github.com/guides/managing-deploy-keys/))
 * `GIT_RSA_DEPLOY_KEY_FILE`: Path to a file containing the private RSA key to use

**WARNING**: the `git push` command performs a **forced update** to the `master` branch, which might result in **data loss** !

Optional:
 * `SLEEPING_TIME`: if `WATCH_FILE` does not exist at startup, time to wait before a new check starts. Defaults to 1 sec.

# testing

In the `tests` folder there's a [docker-compose](tests/docker-compose.yml) file to easily create a testing environment.

The Dockerfile in the `tests/geoserver_mock` directory creates an image whose purpose is to periodically update the contents of a docker volume.
It kind of mimics what [GeoServer](http://geoserver.org/) does to its config directory and is a lightweight alternative.

repository: fvanderbiest/docker-volume-git-backup

gha_language: Shell

repo_name: fvanderbiest/docker-volume-git-backup


text:
![](Screenshots/news-api-logo.png)

# NewsAPI

[![Version](https://img.shields.io/cocoapods/v/NewsAPI.svg?style=flat)](https://cocoapods.org/pods/NewsAPI)
[![License](https://img.shields.io/cocoapods/l/NewsAPI.svg?style=flat)](https://cocoapods.org/pods/NewsAPI)
[![Platform](https://img.shields.io/cocoapods/p/NewsAPI.svg?style=flat)](https://cocoapods.org/pods/NewsAPI)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

![](Screenshots/list.png)
![](Screenshots/detail.png)

## Usage

#### Initialization
> Setup with your API key first.

```swift
let news: News = News(apiKey: "your-api-key")
```

#### Fetch top headlines
> Returns breaking news headlines for a country and category, or currently running on a single or multiple sources.

```swift
let options: [QueryOptions] = [
    .country(.us),
    .pageSize(5),
    .sortBy(.popularity)
]

news.get(.topHeadlines, with: options, headlinesCompletion: { [weak self] (headlines, error) in
    if let headlines = headlines, let articles = headlines.articles {
	debugPrint(articles)
    }
})

```

#### Fetch everything
> The NewsAPI indexes every recent news and blog article published by over 50,000 different sources large and small, and you can search through them with this endpoint.

```swift
let options: [QueryOptions] = [
    .domains(["bbc.co.uk", "bbc.com"]),
    .excludeDomains(["google.com"]),
    .country(.us)
]

news.get(.everything, with: options, headlinesCompletion: { [weak self] (headlines, error) in
    if let headlines = headlines, let articles = headlines.articles {
	debugPrint(articles)
    }
})

```

#### Fetch sources
> Returns information (including name, description, and category) about the most notable sources the NewsAPI indexes.

```swift
let options: [QueryOptions] = [
    .language(.en),
    .category(.technology),
    .country(.us)
]

news.get(.sources, with: options, sourcesCompletion: { [weak self] (sources, error) in
    if let sources = sources {
	debugPrint(sources)
    }
})

```

#### Query Options
> The available query options for filtering results.

```swift
/// Keywords or a phrase to search for.
case query(String)

/// Keywords or phrases to search for in the article title only.
case titleQuery(String)

/// The news sources or blogs you want headlines from.
case sources([String])

/// Domains (eg bbc.co.uk, techcrunch.com, engadget.com) to restrict the search to.
case domains([String])

/// Domains (eg bbc.co.uk, techcrunch.com, engadget.com) to remove from the results.
case excludeDomains([String])

/// A date and optional time for the oldest article allowed.
case fromDate(Date)

/// A date and optional time for the newest article allowed.
case toDate(Date)

/// Code of the language you want to get headlines for.
case language(Language)

/// The order to sort the articles in.
case sortBy(SortOptions)

/// The category you want to get headlines for.
case category(Category)

/// The code of the country you want to get headlines for.
case country(Country)

/// The number of results to return per page (request). 20 is the default, 100 is the maximum.
case pageSize(Int)

/// Use this to page through the results if the total results found is greater than the page size.
case page(Int)
```

## Installation

NewsAPI is available through [CocoaPods](https://cocoapods.org/pods/SwiftNewsAPI). To install
it, simply add the following line to your Podfile:

```ruby
pod 'SwiftNewsAPI'
```

## Author

imryan<EMAIL_ADDRESS>
## License

NewsAPI is available under the MIT license. See the LICENSE file for more info.

repository: imryan/NewsAPI

repo_name: imryan/NewsAPI


text:
# Selenium_Python_Behave_Bdd_Allure

This is a Web Automation Testing framework using:

    Selenium
    Python
    Behave BDD
    Allure reports
    Page Object Model

## Installation

### Prerequisite:

    Python
    Pycharm
    Intellibot
    Allure

### Extensions in Pycharm:

    Atom Material Icons
    Comments Highlighter
    Gherkin
    Ini
<EMAIL_ADDRESS>    Kite AI Code AutoComplete: Python

All set!!! Just download the Project folder...

## Framework Structure

    .wdm --> contains browser drivers (created by driver manager)

    allure-report --> contains allure report files

    Base --> contains Base class (used for setting environment, browser driver, logger)

    Features --> contains cucumber feature files

        Environment.py --> contains Hooks methods

        Steps --> contains Step Definition files

    Logs --> execution logs is generated here

    Objects --> contains object locators

    Pages --> Contains Business Components and Object Locator files

    Reports --> HTML report is generated using behave html formatter

    Screenshots --> used to store screenshots

    TestData --> this folder contains test data files

    Utility --> Contains custom utilities developed in the framework and are used globally across the framework

           Config_Reader --> utility built to read data from Config (cfg) file

           Excel_Reader --> utility built to read data from Excel (xlsx) file

           Json_Reader --> utility built to read data from Json file

    behave.ini --> behave configuration file

## Usage

    1. Download the Project folder

    2. Add dependency libraries
        selenium
        behave
        behave-html-formatter
        openpyxl
        jsonpath
        selenium-page-factory

    3. Run command to run the test:

        <Allure Report>

        <Using folder name>
        behave Features -D environment=QA -D browser=Chrome -f allure -o Reports

        <Using tag>
        behave Features --tags=@Sanity -D environment=QA -D browser=Chrome -f allure -o .\Reports

        <Using Feature file name>
        behave Features/Registration1.feature -D environment=QA -D browser=Chrome -f allure -o .\Reports

## Contributing

   Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

   Please make sure to update tests as appropriate.

## Contributors

   Avik Guha

## License

   Licensed under the [MIT License](LICENSE).


text:
# VQGAN-CLIP-Docker

## About

> Zero-Shot Text-to-Image Generation VQGAN+CLIP Dockerized

This is a stripped and minimal dependency repository for running locally or in production VQGAN+CLIP.

For a Google Colab notebook [see the original repository](#Acknowledgments).

## Samples

## Setup

Clone this repository and `cd` inside.

```sh
git clone https://github.com/kcosta42/VQGAN-CLIP-Docker.git
cd VQGAN-CLIP-Docker
```

Download a VQGAN model and put it in the `./models` folder.

| Dataset                | Link                                                                                |
|------------------------|-------------------------------------------------------------------------------------------------|
| ImageNet (f=16), 16384 | [vqgan_imagenet_f16_16384](http://mirror.io.community/blob/vqgan/vqgan_imagenet_f16_16384.ckpt) |

For GPU capability, make sure you have CUDA installed on your system (tested with CUDA 11.1+).

- 6 GB of VRAM is required to generate 256x256 images.
- 11 GB of VRAM is required to generate 512x512 images.
- 24 GB of VRAM is required to generate 1024x1024 images. (Untested)

### Local

Install the Python requirements

```sh
python3 -m pip install -r requirements.txt
```

To know if you can run this on your GPU, the following command must return `True`.
```sh
python3 -c "import torch; print(torch.cuda.is_available());"
```

### Docker

> Make sure you have `docker` and `docker-compose` installed. `nvidia-docker` is needed if you want to run this on your GPU through Docker.

A Makefile is provided for ease of use.

```sh
make build  # Build the docker image
```

## Usage

Two configuration file are provided `./configs/local.json` and `./configs/docker.json`. They are ready to go, but you may want to edit them to meet your need. Check the [Configuration section](#Configuration) to understand each field.

The resulting generations can be found in the `./outputs` folder.

### GPU

To run locally:

```py
python3 -m scripts.generate -c ./configs/local.json
```

To run on docker:

```py
make generate
```

### CPU

To run locally:

```py
DEVICE=cpu python3 -m scripts.generate -c ./configs/local.json
```

To run on docker:

```py
make generate-cpu
```

### Configuration

| Argument               | Type           | Descriptions                                                              |
|------------------------|----------------|---------------------------------------------------------------------------|
| `prompts`              | List[str]      | Text prompts                                                              |
| `image_prompts`        | List[FilePath] | Image prompts / target image path                                         |
| `max_iterations`       | int            | Number of iterations                                                      |
| `save_freq`            | int            | Save image iterations                                                     |
| `size`                 | [int, int]     | Image size (width height)                                                 |
| `init_image`           | FilePath       | Initial image                                                             |
| `init_noise`           | str            | Initial noise image ['gradient','pixels']                                 |
| `init_weight`          | float          | Initial weight                                                            |
| `output_dir`           | FilePath       | Path to output directory                                                  |
| `models_dir`           | FilePath       | Path to models cache directory                                            |
| `clip_model`           | FilePath       | CLIP model path or name                                                   |
| `vqgan_checkpoint`     | FilePath       | VQGAN checkpoint path                                                     |
| `vqgan_config`         | FilePath       | VQGAN config path                                                         |
| `noise_prompt_seeds`   | List[int]      | Noise prompt seeds                                                        |
| `noise_prompt_weights` | List[float]    | Noise prompt weights                                                      |
| `step_size`            | float          | Learning rate                                                             |
| `cutn`                 | int            | Number of cuts                                                            |
| `cut_pow`              | float          | Cut power                                                                 |
| `seed`                 | int            | Seed (-1 for random seed)                                                 |
| `optimizer`            | str            | Optimiser ['Adam','AdamW','Adagrad','Adamax','DiffGrad','AdamP','RAdam']  |
| `augments`             | List[str]      | Enabled augments ['Ji','Sh','Gn','Pe','Ro','Af','Et','Ts','Cr','Er','Re'] |

## Acknowledgments

[VQGAN+CLIP](https://github.com/nerdyrodent/VQGAN-CLIP)

[Taming Transformers](https://github.com/CompVis/taming-transformers)

[CLIP](https://github.com/openai/CLIP)

[DALLE-PyTorch](https://github.com/lucidrains/DALLE-pytorch)

## Citations

```bibtex
@misc{unpublished2021clip,
    title  = {CLIP: Connecting Text and Images},
    author = {Alec Radford, Ilya Sutskever, Jong Wook Kim, Gretchen Krueger, Sandhini Agarwal},
    year   = {2021}
}
```

```bibtex
@misc{esser2020taming,
      title={Taming Transformers for High-Resolution Image Synthesis},
      author={Patrick Esser and Robin Rombach and Björn Ommer},
      year={2020},
      eprint={2012.09841},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}
```

```bibtex
@misc{ramesh2021zeroshot,
    title   = {Zero-Shot Text-to-Image Generation},
    author  = {Aditya Ramesh and Mikhail Pavlov and Gabriel Goh and Scott Gray and Chelsea Voss and Alec Radford and Mark Chen and Ilya Sutskever},
    year    = {2021},
    eprint  = {2102.12092},
    archivePrefix = {arXiv},
    primaryClass = {cs.CV}
}
```

repository: TrendingTechnology/VQGAN-CLIP-Docker

branch_name: refs/heads/main

repo_name: TrendingTechnology/VQGAN-CLIP-Docker


text:
# Programming Languages Project 2
ICOM 4036 (Programming Languages) Project 2
Andres Hernandez

## To run:
1. Install OpenCV.
2. Build WienerFilterOMP and MarrHildrethEdgeDetOMP in their respective /build folders. CMake files are included to make this easier.
3. Run **python3 Project2.py** to start GUI.
4. There are pictures in the pics/ folder to test the algorithms.


text:
# A Recipe API

This API is a small project of mine to demonstrate my ability to make REST API's using the Django REST Framework. Alongside this it demonstrates a number of other skills such as:

- Docker
- Continuous Integration (Travis CI)
- Test Driven Development

# Outcomes

- Created a fully-functional REST API using Django REST Framework
- Setup a project using Docker
- Configure Travis-CI
- Create endpoints
- Listing and filtering
- Upload images
- A lot of unit tests

# What you can do with this API

You are able to create recipes by adding ingredients and a picture. Also create tags such as "Vegan" to associate your recipes. Users can do this by signing up to the application and also logging in with their account.

Feel free to try out

repository: sixfwa/recipe-app-api

repo_name: sixfwa/recipe-app-api


text:
Given three rods and `n` rings, the aim of the exercise is to move the entire stack of ring from one rod to the last rod.

**Constrains:** (1) Only one ring can be moved at a time. (2) Each move consists of taking the upper ring from one of the stacks and placing it on top of another stack i.e. a ring can only be moved if it is the uppermost risk on a stack. (3) No ring may be placed on top of a smaller disk.where n is the number of disks.

**Input:** `n` - number of rings.

![Q4](https://lh3.googleusercontent.com/RVMXQtM0d-TMotpj9EqdvF4JcliQvo17blUHajsM9daPQVzUb4-g0qJiJGFaDMbJaisYKqLIBEe-aGWrca9SSrKL8kiL2LNQJAHBpm0EW7MQCl9uy4kKRQK4pFAf=w562)


text:
[![Build Status](https://travis-ci.org/seadsystem/Backend.svg?branch=master)](https://travis-ci.org/seadsystem/Backend) [![codecov.io](https://codecov.io/github/seadsystem/Backend/coverage.svg?branch=master)](https://codecov.io/github/seadsystem/Backend?branch=master)

#Go Landing Zone
The Go Landing Zone is a high speed, concurrent TCP server which listens for connections from SEAD plugs on port 9000. The plug requests its configuration from the server before beginning to send the buffered data it collects. This stream of packets is decoded, and the data is bulk inserted into the Postgres database in the background to be later queried by the API.

The service can be started using the init script installed via Puppet:
```sh
$ sudo service landingzone start
```

The landing zone is not intended to directly interacted with by a user. The data collected by the landing zone is accessible via the API. The correct way to test if the landing zone is functioning properly is to connect a SEAD plug and check if new data becomes available through the API.

Once we have the groundwork necessary to organize the protocol coordination between the SEAD panel and the landing zone, we will be able receive data from the SEAD panel and perform a classification of the raw data to determine the appliance type. This will complete our final user story:
>As a SEAD panel developer, I want to send raw appliance data to the server and a classification result to be rendered in the GUI.

##Installation

Installation of the Go Landing Zone and the Python API can be automated by using the Puppet modules included in the repository. The puppet modules are written for and assume to be executed on an Ubuntu 14.04 x64 Linux server. First you must install the prerequisites for running Puppet. From the terminal, execute:
```sh
$ sudo apt-get install puppet git
```
It is recommended that you also install fail2ban with the following command:
```sh
$ sudo apt-get install fail2ban
```

Copy the Puppet files onto the server (for example, by cloning the repository) and change to the DB directory.
```sh
$ cd DB/
```
If desired, configure the UNIX application user’s password in puppet/modules/config. First add the user credentials to manifests/credentials.pp, then uncomment the password definitions in config/manifests/init.pp.
```sh
$ cd puppet/config
$ nano manifests/credentials.pp
$ nano manifests/init.pp
$ cd ../..
```

Copy the files to the /etc/puppet directory, and execute Puppet:
```sh
$ sudo rsync -avc puppet/ /etc/puppet/
$ sudo puppet apply puppet/manifests/site.pp
```
After Puppet has executed the modules correctly, the server should be listening on ports 8080 and 9000. Verify with netstat:
```sh
$ netstat -tln | egrep ':(8080|9000)'
```

--------
Adding a device:

Handler: talks to the device and convinces the device to give data
         Tell go what port to open in main.go and which handler to use for that port
         The handler use a decoder to send the data to the database module in a common format

repository: seadsystem/Backend

repo_name: seadsystem/Backend


text:
# Feature Differences Overview

[Detailed Differences Description](differenceBetweenPBSGo-and-Java.md)

 Feature | Java | Go
| --- | :---: | :---:|
GDPR TCF1.1 |+|+
GDPR TCF2 |+|+
Geo location (used for GDPR) |+|-
COPPA |+|+
CCPA |+|+
AMP |+|+
Stored Requests |+|+
Stored Responses |+|-
PBJS First Party data |+|-
Currency Conversion** |+|+
Multiple root schains |+|-
Price Granularity |+|+
Price Granularity per MediaType|+|-
User ID Module support |+|+
Account exclude list  |+|+
Event Notification endpoint |+|-
Video ad support |+|+
Long-form video endpoint |-|+
IAB advertiser category mapping |-|+
Aliases |+|+
Video Impression Tracking endpoint |+|-
Cooperative Cookie Syncing |+|-
Circuit Breaker (Http, DB) |+|-
Operational metrics |+|+
Supports both "debug" and "test" flags |+|-
All adapters ported to OpenRTB |+|-
Echo stored request video attributes in response |+|-
Accept account ID on AMP requests |+|-
Cache only-winning-bids flag |+|-
Remote File Downloader |+|-
Bidder Generator |+|-
Passing `request.ext.prebid.bidders.BIDDER` to corresponding bidder |+|-

**
* PBS-Java Currency conversion supports finding intermediate conversion rate;
* PBS-Go Currency Conversion debug endpoint exposes more information, PBS-Java currently provides last updated time only;

repository: maddapper/prebid-server-java

repo_name: maddapper/prebid-server-java


text:
---
layout: slides
categories: slides
title: Introduction
---

Overview
========

Welcome!
--------

Welcome to **Introduction to JavaScript**! This class is a lab-based, hands-on, problem-solving class that will turn you into a JavaScript adept.

During this course, you will:
- Develop familiarity with the JavaScript language.
- Learn to use common idioms and best practices.
- Understand common features in dynamic programming languages such as introspection, higher-order functions, and closures.
- Become familiar with common JavaScript libraries and tools that are used in web application development.

Are you in the right class? You should have taken one of CS106A or CS106B. You should be comfortable coding in at least one other programming language. An understanding of HTML and CSS is helpful but not necessary. There will be an optional tutorial of HTML and CSS later. If you have any previous experience developing web applications, the first part of the course may be too basic for you, but if you stick around, we will cover some advanced JavaScript language concepts, as well as some useful libraries.

If this is your first time doing programming, this class is probably not appropriate for you. A more appropriate class would be CS105 or CS106A.

What is JavaScript?
-------------------

What is JavaScript? JavaScript is primarily a client-side language.

JavaScript started at Netscape, a web browser developed in the 1990s. A webpage can contain embedded JavaScript, which executes when a user visits the page. The language was created to allow web developers to embed executable code on their webpages, so that they could make their webpages interactive, or perform simple tasks. Today, browser scripting remains the main use-case of JavaScript.

JavaScript's syntax is very similar to C++ and Java. If you have experience in C++ or Java, JavaScript's syntax will seem familiar.

However, the inner workings of JavaScript is closer to a dynamically-typed, interpreted language such as Python or Ruby.

JavaScript is usually interpreted, not compiled. JavaScript code is read by an interpreter, which reads the instructions in the code and executes them.. A program such as C++ or Java needs to be compiled before it is run. The source code is passed through a program called a compiler, which translates it into bytecode that the machine understands and can execute. In contrast, JavaScript has no compilation step. Instead, an interpreter in the browser reads over the JavaScript code, interprets each line, and runs it. More modern browsers use a technology known as Just-In-Time (JIT) compilation, which compiles JavaScript to executable bytecode just as it is about to run.

JavaScript is named after Java, and many ideas are borrowed from the Java language. Other than that, Java and JavaScript are two entirely distinct languages. The most significant difference between them is that Java is a compiled language, and JavaScript is a interpreted language. JavaScript runs on many browsers out-of-the-box, whereas Java applets require an additional plug in. Both languages have different runtime environments, different governing bodies, different libraries.

Despite all its faults, JavaScript is a very useful language. JavaScript runs in every web browser, out of the box. A JavaScript application runs on every device, whereas a desktop or mobile application runs only on the application it is targeted to (Windows, Mac OSX, Linux, iPhone, Android). This allows you to write cross-platform apps in a really easy way. JavaScript's role has also expanded significantly. Platforms such as Node.js allow developers to run JavaScript server-side. It is now possible to create entire web applications in which both client-side and server-side logic is written in JavaScript.

JavaScript can be a very complicated language, and most teams use only a subset of JavaScript. If you read a style guide, it will recommend the use of particular JavaScript techniques, constructs and libraries. Since JavaScript is so messy, this class will make a number of recommendations on what we consider good style. However, we will cover a wide range of styles so that you can jump into a new team and pick up the style quickly.

Live Code Examples
------------------
Live code examples are scattered throughout this text. These snippets of code can be edited and run from within the browser. Click and type within the box to edit, and press the "Run" button to see what they do.

Hello World!
------------
Brian Kernighan and Dennis Ritchie taught that the first thing you should do when learning a new programming language is learn out to print the words "Hello, World!" Here is the program in JavaScript:

{% highlight js %}
console.log("Hello world!");
{% endhighlight %}

The `console.log` function (or method) prints its argument to the console, followed by a newline. We will be using it a lot.

Useful functions
----------------
There are two other useful functions that you might see often. The `alert` function displays a text box with the specified message.

{% highlight js %}
alert("Hello world!");
{% endhighlight %}

The `prompt` function displays a box prompting the user for input.

{% highlight js %}
alert(prompt("What is your name?"));
{% endhighlight %}

View Source
-----------
JavaScript is everywhere on the web. The interactive elements on this page were implemented in JavaScript, of course.

There are two main ways to put JavaScript on the web page, and they both involve the `<script>` tag. The first is to directly include the code within the tags: this is called inline JavaScript. The second, more common practice is to include the code in a `.js` file, and link to the page using the `src` attribute, such as `<script src="code.js"></script>`. Note that in this case, the contents of the script tag should be empty.

You can try it youself on this page. View the source of this page and see if you can find the inline and linked JavaScript code.
<script>
// Example of inline scripts
var youFoundMe = "Hi there! You just found the inline script.";
</script>

The JavaScript Console
----------------------
JavaScript is most often run on webpages inside the browser, but it can also be run server-side. We will go through some of these platforms later. For now, we will run JavaScript in the console, which will allow us to see the results of our code more quickly.

The nice thing about interpreted languages is that they are designed to be run with a single pass through the source code, running each instruction step-by-step. That means that we can give the interpreter a single step and ask it to run it.

There are a number of JavaScript consoles that allow us to do this. Most browsers have one available. Think of it as a command-line interface that runs JavaScript on your JavaScript engine.

Chrome, Safari and Opera
:Open a new tab. Right click on the page and click **Inspect Element**. Click on **Console**.

Firefox
:Open the **Tools** menu. Go to **Web Developer > Web Console**.

Behind the console is the *read-eval-print loop* (REPL). This refers to the loop that the console runs: it first reads your input, then it evaluates it as JavaScript code, then it prints the results. You will sometimes hear the term REPL being used to refer to any sort of programming shell that allows you to enter code and see results immediately. For instance, Python and Ruby also provide similar REPL shells.

Try running some simple math expressions within the console, such as `1 + 2` or `3 * 4`. JavaScript prints the correct answers back at you. Congratulations, you can now use your computer as a very expensive calculator.

Now try to run the hello world program in the console. It produces two lines of output. The first line is the greeting that we expect. The second line reads `undefined`. This is because the first line is the output that we instructed JavaScript to print, and the second line is the result of evaluating our program. Every JavaScript expression has a result, but some expressions, such as the `console.log` function, return an empty result called `undefined`.

Note that the console prints out the result of the expression, whereas the live code examples do not. We will be using `console.log` to evaluate expressions in the live code examples, but you can omit `console.log`.

repository: yifanmai/jsbook

extension: markdown

repo_name: yifanmai/jsbook


text:
---
layout: post
title: 历史生物地理学的研究方法
date: 2009-03-13 13:01:58
comments: true
sharing: true
categories: linux
tags:
---

Comparative Review of Cladistic Approaches to Historical Biogeography of Southern South America

       Cladistic historical biogeographic studies on the austral continents are briefly reviewed with special reference to southern South America. The biogeography of marsupials, southern beeches and the relationships of New Zealand and southern South America are compared. No general pattern of interrelationships is common to all the analyses. Differences in delimitation of areas, selection of taxa and techniques applied are discussed as possible causes of incongruities. The comparative review of these empirical studies reveals that, although it is valid to investigate the existence of a unique pattern of interrelationships among areas of endemism, this cannot be considered as an a priori assumption in the analyses. Australia Systematic Botany

repository: Apiaceae/jekyllblog

repo_name: Apiaceae/jekyllblog


text:
# ExcelAddIn
My custom excel add ins

This is a bunch of junky functions I made to do stuff.  Most of it is string manipulation, find replace, and Levenshtein comparisons.  I don't rite gud code so don't expect miracles.

To use it, clone the "JasonExcelAddIn.xlam" file to your computer (you can put it anywhere, just make sure it's somewhere where it won't get moved or deleted or whatever).

Then, open Excel, go to the Developer ribbon (if you don't have that ribbon, then you gotta add it; may I suggest googling it?) and select Add-ins.  Click the browse button, then find our friendly little add-in "JasonExcelAddIn.xlam."

  Have at it hoss!

Current included functions:

	Levenshtein(s1 As String, s2 As String)
Calculates the Levenshtein distance between two strings (case sensitive)

	ArrayDupRemove(a1 As String, d1 As String)
Removes duplicate entries from an array formatted as a string with a char delimiter

	ArraySubstitute(sourceStr As String, findA As Range, replaceA As Range)
This is a quick and dirty function to replace elements in a string with a range of values

	DelArrayFromArray(s1 As String, d1 As String, s2 As String, d2 As String)
This function deletes an array of values (s2) from another array (s1). These arrays are formatted as strings (s1, s2) with a delimiter (d1, d2)

repository: JasonAtWeir/ExcelAddIn

repo_name: JasonAtWeir/ExcelAddIn


text:
# monte-carlo-rte-fluorescent-medium
Solution of radiative transfer equation in fluorescent medium including  luminescent cascade and non-fluorescent absorption

This code is used in the articles please cite them if you use the code in your study;

https://doi.org/10.1088/2053-1591/ab28b8 Improving photosynthetic efficiency using greenhouse coatings with scattering and fluorescent pigments

https://doi.org/10.1016/j.biosystemseng.2020.02.007 Improving crop production in solar illuminated vertical farms using fluorescence coatings

It solves RTE in fluorescent medium.

It can handle scattering in the medium due to phosphor particles.

It can handle luminescent cascade where absorption and emission spectra of fluorescence overlaps

It can handle non-flourescent absorbing medium by modifiying quantum yield accordingly and calculating refraction angle at the air-medium interface considering both n and k of the medium.

It can handle up-conversion and down-conversion

The code considers particle size distribution

The code works on both MATLAB and Octave.

main.m code is the main code to execute. Concentration, size and thickness of the phosphor can be altered inside this file.


text:
:warning: **As of today (31/08), Pokevision is down for un undefined amount of time.** We will provide a replacement of their private API which we were relying on, but we do not have any timeframe.

*If you have a working/work in progress replacement proposition feel free to open an issue and discuss it.*

# hubot-pokemongo

Hubot script for pokemon go.
hubot-pokemongo send you one private message every time one pokemon spawn near you.
It support multiple location, mute notification, custom notification interval, and some small features.

:exclamation: *This does not require you to run your own bots for Pokémon localisation. However, the API we're querying is very instable and you might experience not-so-great service and unaccurate results.*

## dependency

- hubot-redis-brain
- geolib

## Commands available

- add <lat> <long> : Attach address to your user
- debug on : Enable debug
- debug off : Disable debug
- delete <lat> <long> : Delete address from your user
- list : List addresses from the current user
- locale <en|fr|de> : Set locale for the current user
- notif on : Enable notification
- notif off : Disable notification
- number <number> : Search for a Pokémon using it's Pokédex number
- nb <number> : Alias for number
- id <number> : Alias for number
- preference : Show user preferences
- range <meters> : Set detection range to <meters>m
- remove <lat> <long> : Alias for delete
- rm <address> : Alias for delete
- search <query> : Searches on a Pokémon Wiki (depending on your locale)
- s <query> : Alias for search
- timer <minutes> : Set timer interval to <minutes> minute(s)
- version : Print current version of hubot-pokemongo
- help : Print this help
- ? : Alias for help

## Examples

```
> {hubot} pogo add 43.60385011 1.4439189
> {hubot} pogo list
  43.60385011/1.4439189

> {hubot} pogo remove 43.60385011 1.4439189
> {hubot} pogo list
```

## Installation

Download the latest version from npm

```
npm install hubot-pokemongo
```
Add dependency to your hubot external script:
external-scripts.json
```
[
  //....
  "hubot-redis-brain",
  "hubot-pokemongo"
  //....
]
```

## TODO

- [x] Refactoring
- [x] Locale (User preferences)
- [ ] Tests
- [ ] Show pokemon on map (send image)
- [x] Improve range system

repository: Edznux/hubot-pokemongo

gha_language: JavaScript

repo_name: Edznux/hubot-pokemongo


text:
LV2 Parameter/Property Example
==============================

This simple [LV2](http://lv2plug.in) plugin is provided as example
to show how to use LV2 parameter properties as control values.

This plugin is a simple dezippered amplifier that exposes two parameters
as properties: a float (gain in dB) and a boolean (polarity invert).

The plugin itself has no control data inputs. Both properties are set
using a single LV2 Atom control port.

See also

* http://lv2plug.in/ns/lv2core#Parameter
* http://lv2plug.in/ns/ext/patch#Set
* http://lv2plug.in/ns/ext/patch#writable

Build and Install
-----------------

```bash
make
#sudo make install PREFIX=/usr
ln -s "$(pwd)/build" ~/.lv2/property_example.lv2
```

gha_language: C


text:
# Seeding/Spotting NGM Plates with Bacteria

## Materials
- 6 cm or 10 cm plates in the sliding-door 4°C incubator (pre-dried 48 hr.)
- OP50 culture in a 2 L flask stored at 4°C (refer to [Growing OP50](../PlatePouring_GrowingOP50/PlatePouring_GrowingOP50.md) protocol)
- 50 mL sterile disposable conical tube
- Repeat pipette
    - 5 mL tips to seed 6 cm plates
    - 25 mL tips to seed 10 cm plates
    - **Note:** you will need the red adapter piece for 25 mL tip!

## Protocol

1. Transfer the OP50 from the Stock Flask to the conical tube.

    **Note:** Use a flame for sterile technique- sterilize the Glass Flask edge before and after dispensing into the tube, **But DON'T flame the plastic tube!**

2. Work where plates are normally poured. Set up the plates in stacks that are not too high, about 4 plates high.

3.  Load the pipette tip in the repeat pipettor handle (using sterile technique to prevent contamination of the tip).

4. Set the pipet to dispense 100 μL for 6 cm plates or 1000 μL for 10 cm plates.

5. Seed 6 cm plates by dispensing one spot to the middle of the plate. Seed 10 cm plates by dispensing one spot to the middle of the plate, then after seeding the stack, shake the plates slightly (left to right, then up to down) to spread the bacteria (ask for a DEMO!).

    **Note:** Take care not to spatter the bacteria onto the edges of the plate when dispensing and spreading the bacteria.

6. Leave plates stacked lid side up for at least 24 hr. for bacteria to soak in and grow. Make sure plates grow at least 2 days at room temperature before storing in the 4°C room.

    **Note:** Seeded plates should not be dried overnight with the Clean Hood on, since this will over-dry the bacteria.

7. Finally, put the plates in pre-bleached plastic bins, and store them at 4°C.

## Na22 bacteria

- You can use Na22 *E. coli* as a food source alternative to OP50, if you desire larger numbers of gravid adult worms. Na22 requires liquid 2x YT media. **2X YT Media:**

    | Reagent | Amount |
    | ------- | ------ |
    | Tryptone | 16 g |
    | Yeast Extract | 10 g |
    | NaCl | 5 g |
    | dH2O | up to 1 L |

    Final pH 7.0 ± 0.2 at 25°C

    **Note:** No antibiotic is used in 2x YT media. Do not contaminate the bacterial culture at this point. Use a Bunsen burner during transfer of the media to the flask where bacteria will be grown and keep a frozen sterile glycerol stock of Na22 bacteria. Grow Na22 overnight in 2x YT media, and seed the bacteria over the entirety of the plate, not just the center. Seed onto HGMA plates.

repository: zamanianlab/ZamanianLabDocs

repo_name: zamanianlab/ZamanianLabDocs


text:
# BE-Project-Web
[![Waffle.io - Columns and their card count](https://badge.waffle.io/djunicode/BE-Project-Web.svg?columns=all)](https://waffle.io/djunicode/BE-Project-Web)

Developing a System for BE Projects.

## Backend Setup

### Basic System Prerequisites:
```
Python >= 3.6
pip >= 18.1
virtualenv >= 16.0.0
```

### Fork this repo and run these commands after cloning the project and go inside the ```backend``` directory:
```
virtualenv venv
source venv/bin/activate
pip3 install -r requirements.txt
python3 manage.py migrate
python3 manage.py runserver
```
### Note:
 1) Don't forget to run ``` black BEProjectsApp/ and black BEProjectsWeb/``` before adding or committing or pushing any code otherwise, the code won't be formatted properly and you might end up getting Travis CI Build fails.


text:
# Quickstart - EKS with Agones Gaming Kubernetes Controller

In this workshop, we will learn how to deploy and run Gaming applications on AWS EKS with Agones Kubernetes Controller

 - Deploy Private VPC, Subnets and all the required VPC endpoints
 - Deploy EKS Cluster with one managed node group in an VPC
 - Deploy Agones Kubernetes Controller using Helm Providers
 - Deploy a simple gaming server and test the application

# What is Agones

Agones is an Open source Kubernetes Controller with custom resource definitions and is used to create, run, manage and scale dedicated game server processes within Kubernetes clusters using standard Kubernetes tooling and APIs.
This model also allows any matchmaker to interact directly with Agones via the Kubernetes API to provision a dedicated game server

# What is GameLift

Amazon GameLift enables developers to deploy, operate, and scale dedicated, low-cost servers in the cloud for session-based, multiplayer games.
Built on AWS global computing infrastructure, GameLift helps deliver high-performance, high-reliability, low-cost game servers while dynamically scaling your resource usage to meet worldwide player demand.

# Deployment Steps

Execute **Step1** only when you are running this workshop using AWS EventEngine. Workshop conducted by the AWS teams at Customer sites

## Step1: Login to Event Engine as advised by AWS team. You may need a temporary AWS Account token for this step

    https://www.eksworkshop.com/020_prerequisites/aws_event/portal/

## Step2: Create [Cloud9 IDE in AWS Environment](https://www.eksworkshop.com/020_prerequisites/workspace/#region-1) and install Pre-requisites

Use the following link to install Cloud9 IDE and all the pre-requisites Kubernetes tools

    https://www.eksworkshop.com/020_prerequisites/workspace/#region-1

### Step2.1: Install [Kubernetes Tools](https://www.eksworkshop.com/020_prerequisites/k8stools/)
    https://www.eksworkshop.com/020_prerequisites/k8stools/

### Step2.2: Create [IAM Role for Workspaces](https://www.eksworkshop.com/020_prerequisites/iamrole/)
    https://www.eksworkshop.com/020_prerequisites/iamrole/

### Step2.3: Attach IAM role to Cloud9 IDE and update IAM settings
    https://www.eksworkshop.com/020_prerequisites/ec2instance/
    https://www.eksworkshop.com/020_prerequisites/workspaceiam/

## Step3: Install `aws-iam-authenticator` in Cloud9 IDE
     curl -o aws-iam-authenticator https://amazon-eks.s3.us-west-2.amazonaws.com/1.19.6/2021-01-05/bin/linux/amd64/aws-iam-authenticator

     openssl sha1 -sha256 aws-iam-authenticator

     chmod +x ./aws-iam-authenticator

     mkdir -p $HOME/bin && cp ./aws-iam-authenticator $HOME/bin/aws-iam-authenticator && export PATH=$PATH:$HOME/bin

     echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc

     Verify the installation

     aws-iam-authenticator help

## Step4: Install Terraform in Cloud9 IDE

    sudo yum remove -y terraform

    sudo yum install -y yum-utils

    sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/AmazonLinux/hashicorp.repo

    sudo yum -y install terraform-0.14.9

    sudo terraform version

## Step5: Clone AWS Terraform AWS Accelerator from GITHUB Repo

    git clone https://github.com/aws-samples/aws-eks-accelerator-for-terraform.git

    cd aws-eks-accelerator-for-terraform/

## Step6: Run Terraform init on the Gaming EKS Cluster Configuration
`live/preprod/eu-west-1/gaming/test/base.tfvars` file contains the configuration data to create VPC, Subnets, EKS CLuster and the Agones Helm Chart for this workshop
`live/preprod/eu-west-1/gaming/test/backend.conf` file contains the config for setting up Terraform backend state. For this workshop we will be using local backend state to avoid creating a new S3 bucket to copy the state files.

To initialize a working directory with configuration files.

     terraform init -backend-config ./live/preprod/eu-west-1/gaming/test/backend.conf source

## Step7: Run Terraform plan
To verify the resources created by this execution

     terraform plan -var-file ./live/preprod/eu-west-1/gaming/test/base.tfvars source

## Step8: Finally, Terraform apply
This step may take up-to 15 to 17 mins to create AWS VPC resources, EKS Cluster and necessary Addons using Helm Provider

     terraform apply -var-file ./live/preprod/eu-west-1/gaming/test/base.tfvars source

## Step9:
     aws eks --region <region> update-kubeconfig --name <eks cluster name>

    e.g., $ aws eks --region eu-west-1 update-kubeconfig --name gaming-preprod-test-eks

## Step10: Install K9s
This step is to install K9s client tool to interact with EKS Cluster

     curl -sS https://webinstall.dev/k9s | bash

Just type k9s after the installation and then you will see the output like this

         k9s

![Alt Text](https://github.com/aws-samples/aws-eks-accelerator-for-terraform/blob/9c6f8ea3e710f7b0137be07835653a2bf4f9fdfe/images/k9s-agones-cluster.png "K9s")

## Step11: Add EKS Workshop IAM role as EKS Cluster Administrator

    $ aws sts get-caller-identity

    ROLE="    - rolearn: arn:aws:iam::${ACCOUNT_ID}:role/TeamRole\n      username: admin\n      groups:\n        - system:masters"

    kubectl get -n kube-system configmap/aws-auth -o yaml | awk "/mapRoles: \|/{print;print \"$ROLE\";next}1" > /tmp/aws-auth-patch.yml

    kubectl patch configmap/aws-auth -n kube-system --patch "$(cat /tmp/aws-auth-patch.yml)"

## Step12: Deploying the Sample game server

    kubectl create -f https://raw.githubusercontent.com/googleforgames/agones/release-1.15.0/examples/simple-game-server/gameserver.yaml

    kubectl get gs

Output looks like below

    NAME                       STATE   ADDRESS         PORT   NODE                                        AGE
    simple-game-server-7r6jr   Ready   34.243.345.22   7902   ip-10-1-23-233.eu-west-1.compute.internal   11h

## Step13: Testing the Sample Game Server

    sudo yum install netcat

    nc -u <ADDRESS> <PORT>

    e.g.,  nc -u 34.243.345.22 7902

Output looks like below

    TeamRole:~/environment/aws-eks-accelerator-for-terraform (main) $ echo -n "UDP test - Hello Workshop" | nc -u 34.243.345.22 7902
    Hello Workshop
    ACK: Hello Workshop
    EXIT
    ACK: EXIT

# Deploy GameLift FleetIQ

Amazon GameLift FleetIQ optimizes the use of low-cost Spot Instances for cloud-based game hosting with Amazon EC2. With GameLift FleetIQ, you can work directly with your hosting resources in Amazon EC2 and Auto Scaling while taking advantage of GameLift optimizations to deliver inexpensive, resilient game hosting for your players and makes the use of low-cost Spot Instances viable for game hosting

This [blog](https://aws.amazon.com/blogs/gametech/introducing-the-gamelift-fleetiq-adapter-for-agones/) will go through the details of deploying EKS Cluster using eksctl and deploy Agones with GameLift FleetIQ

Download the shell script and execute

    curl -O https://raw.githubusercontent.com/awslabs/fleetiq-adapter-for-agones/master/Agones_EKS_FleetIQ_Integration_Package%5BBETA%5D/quick_install/fleet_eks_agones_quickinstall.sh


text:
---
layout: post
title:  "8_0_10_patch3"
date:   2017-10-07 22:04:13 +0200
categories: cmssw
relmajor: 8
relminor: 0
relsubminor: 10
relpatch: _patch3
---

# CMSSW_8_0_10_patch3
#### Changes since CMSSW_8_0_10_patch2:

[compare to previous](https://github.com/cms-sw/cmssw/compare/CMSSW_8_0_10_patch2...CMSSW_8_0_10_patch3)

1. [14907](http://github.com/cms-sw/cmssw/pull/14907){:target="_blank"}  from **@Sam-Harper**: Allowing HLT to be seeded by Taus (8010_patchX) `comparison`  `hlt`  created: 2016-06-16T15:30:24Z merged: 2016-06-16T16:47:00Z

#### CMSDIST Changes between Tags REL/CMSSW_8_0_10_patch2/slc6_amd64_gcc530 and REL/CMSSW_8_0_10_patch3/slc6_amd64_gcc530:

[compare to previous](https://github.com/cms-sw/cmsdist/compare/REL/CMSSW_8_0_10_patch2/slc6_amd64_gcc530...REL/CMSSW_8_0_10_patch3/slc6_amd64_gcc530)

repository: rovere/ReleaseNotes

repo_name: rovere/ReleaseNotes


text:
---
layout: post
title:  "Snowflake Shield"
date:   2017-01-01
source: From the Arcane Archive
tags: [druid, shugenja, level1, abjuration, hb, fan]
---

**1st-level abjuration**

**Casting Time**: 1 action

**Range**: Self

**Components**: V, M (a few snowflakes)

**Duration**: 1 hour

You create an intricate fractal of ice, shaping it to form a shield. This shield hovers in your space and protects you. For the duration of this spell, while you are not already wielding a shield, your AC increases by 2. This spell ends early if you take fire damage.

repository: Teamdael/spellbook

repo_name: Teamdael/spellbook


text:
# [Deprecated, checkout https://bintray.com/google/tensorflow/tensorflow-android]

# double-tf-android

A pure Gradle port of the TensorFlow library for Android! Publish [the nightly build of TensorFlow CI](http://ci.tensorflow.org/view/Nightly/job/nightly-android/). The name of this repo is inspired by [JakeWharton/double-espresso](https://github.com/JakeWharton/double-espresso).

[ ![Download](https://api.bintray.com/packages/piasy/maven/double-tf-android/images/download.svg) ](https://bintray.com/piasy/maven/double-tf-android/_latestVersion)

## Dependency

``` gradle
allprojects {
    repositories {
        maven {
            url  "http://dl.bintray.com/piasy/maven"
        }
    }
}

compile 'com.github.piasy:double-tf-android:1.0.0-nightly-125@aar'
```

## Usage

Please refer to [Piasy/mnist-android-tensorflow](https://github.com/Piasy/mnist-android-tensorflow/tree/double-tf-android/MnistAndroid).

repository: Piasy/double-tf-android

repo_name: Piasy/double-tf-android


text:
# Animatr
## Overview
**Animatr** is a very simple lean **CSS3** animator and is library free.

Cross browser support for the latest Firefox/Chrome/Safari/Opera/IE(10). Automatically creates the animation based on vendor specific prefixes.

Also allows `start`, `end` and `iteration` callback functions to be defined.

##Usage

```javascript

	//ELEMENT_ID can be string or the DOM element
	//itself
	var anim = new Animatr(ELEMENT_ID, options);
	//Example options include the default CSS3 animation
	//properties (camelCased)
	options = {

      //s or ms
      duration: '1s',

      //s or ms
      delay: 0,

      // Configures the number of times the animation
      // should repeat; you can specify infinite to
      // repeat the animation indefinitely.
      iterationCount: 'infinite',

      // Configures the timing of the animation; that is,
      // how the animation transitions through keyframes,
      // by establishing acceleration curves.
      timingFunction: 'ease',

      // Configures whether or not the animation should
      // alternate direction on each run through
      // sequence or reset to the start point and repeat
      // itself.
      direction: 'normal',

      // Configures what values are applied by the
      // animation before and after it is executing.
      fillMode: 'forwards',

      // Specifies the name of the @keyframes at-rule
      // describing the animation's keyframes.
      // This will be auto generated if not set.
      name: 'testAnim',

      pauseOnHover: false,

      startCss: null, //Start styles e.g {opacity:1}

      css: null, // End styles e.g. {opacity: 0}

      // When set to false allows for chaining
      // of .step();
      preventImmediateStart: false,

      // Callback function fired after every iteration.
      iterationCallback: function(e){},

      // Callback function fired on start of the
      // animation, triggered after the inital delay has
      // elapsed
      startCallback: function(e){},

      // Callback function fired on completion of final
      // interation.
      // Will not fire if interationCount = 'infinite'
      endCallback: function(e){}
    }
```

##Simple Example

```javascript

var anim = new Animatr(document.querySelector('.test'), {
      //The end style of the animation
      css: {  background: 'red',
              padding: '25px' },

      //Number of times to repeat
      iterationCount: 2,

      //Callback on complete
      endCallback: function(){
      	//do stuff...
      }
    });

```

Check out the demo for more info. Will add more information when I have time.

###Credits:
[@billybobuk](https://github.com/billybobuk)

## License

(The MIT License)

repository: brendanmoore/Animatr

repo_name: brendanmoore/Animatr


text:
# git-practice
Introduction to git

1. Click on "Clone or download" and copy the link that shows up in the box

2. Using git, clone the repository to a file on your local machine

3. Create a new branch called "develop"

4. Add some text files (or anything, it doesn't matter, just make some changes)

5. Add the changes to the develop branch

6. Commit the changes with the commit message: "develop -- step 6 changes"

7. Push the changes from the local develop branch the remote develop branch

8. Create a pull request for the develop branch into the master branch

repository: qa-curriculum/git-practice

repo_name: qa-curriculum/git-practice