text:
# Release process

_Black_ has had a lot of work done into standardizing and automating its release
process. This document sets out to explain how everything works and how to release
_Black_ using said automation.

## Release cadence

**We aim to release whatever is on `main` every 1-2 months.** This ensures merged
improvements and bugfixes are shipped to users reasonably quickly, while not massively
fracturing the user-base with too many versions. This also keeps the workload on
maintainers consistent and predictable.

If there's not much new on `main` to justify a release, it's acceptable to skip a
month's release. Ideally January releases should not be skipped because as per our
[stability policy](labels/stability-policy), the first release in a new calendar year
may make changes to the _stable_ style. While the policy applies to the first release
(instead of only January releases), confining changes to the stable style to January
will keep things predictable (and nicer) for users.

Unless there is a serious regression or bug that requires immediate patching, **there
should not be more than one release per month**. While version numbers are cheap,
releases require a maintainer to both commit to do the actual cutting of a release, but
also to be able to deal with the potential fallout post-release. Releasing more
frequently than monthly nets rapidly diminishing returns.

## Cutting a release

**You must have `write` permissions for the _Black_ repository to cut a release.**

The 10,000 foot view of the release process is that you prepare a release PR and then
publish a [GitHub Release]. This triggers [release automation](#release-workflows) that
builds all release artifacts and publishes them to the various platforms we publish to.

To cut a release:

1. Determine the release's version number
   - **_Black_ follows the [CalVer] versioning standard using the `YY.M.N` format**
     - So unless there already has been a release during this month, `N` should be `0`
   - Example: the first release in January, 2022 → `22.1.0`
1. File a PR editing `CHANGES.md` and the docs to version the latest changes
   1. Replace the `## Unreleased` header with the version number
   1. Remove any empty sections for the current release
   1. (_optional_) Read through and copy-edit the changelog (eg. by moving entries,
      fixing typos, or rephrasing entries)
   1. Add a new empty template for the next release above
      ([template below](#changelog-template))
   1. Update references to the latest version in
      {doc}`/integrations/source_version_control` and
      {doc}`/usage_and_configuration/the_basics`
   - Example PR: [GH-3139]
1. Once the release PR is merged, wait until all CI passes
   - If CI does not pass, **stop** and investigate the failure(s) as generally we'd want
     to fix failing CI before cutting a release
1. [Draft a new GitHub Release][new-release]
   1. Click `Choose a tag` and type in the version number, then select the
      `Create new tag: YY.M.N on publish` option that appears
   1. Verify that the new tag targets the `main` branch
   1. You can leave the release title blank, GitHub will default to the tag name
   1. Copy and paste the _raw changelog Markdown_ for the current release into the
      description box
1. Publish the GitHub Release, triggering [release automation](#release-workflows) that
   will handle the rest
1. At this point, you're basically done. It's good practice to go and [watch and verify
   that all the release workflows pass][black-actions], although you will receive a
   GitHub notification should something fail.
   - If something fails, don't panic. Please go read the respective workflow's logs and
     configuration file to reverse-engineer your way to a fix/solution.

Congratulations! You've successfully cut a new release of _Black_. Go and stand up and
take a break, you deserve it.

```{important}
Once the release artifacts reach PyPI, you may see new issues being filed indicating
regressions. While regressions are not great, they don't automatically mean a hotfix
release is warranted. Unless the regressions are serious and impact many users, a hotfix
release is probably unnecessary.

In the end, use your best judgement and ask other maintainers for their thoughts.
```

### Changelog template

Use the following template for a clean changelog after the release:

```
## Unreleased

### Highlights

<!-- Include any especially major or disruptive changes here -->

### Stable style

<!-- Changes that affect Black's stable style -->

### Preview style

<!-- Changes that affect Black's preview style -->

### Configuration

<!-- Changes to how Black can be configured -->

### Packaging

<!-- Changes to how Black is packaged, such as dependency requirements -->

### Parser

<!-- Changes to the parser or to version autodetection -->

### Performance

<!-- Changes that improve Black's performance. -->

### Output

<!-- Changes to Black's terminal output and error messages -->

### _Blackd_

<!-- Changes to blackd -->

### Integrations

<!-- For example, Docker, GitHub Actions, pre-commit, editors -->

### Documentation

<!-- Major changes to documentation and policies. Small docs changes
     don't need a changelog entry. -->
```

## Release workflows

All of _Black_'s release automation uses [GitHub Actions]. All workflows are therefore
configured using YAML files in the `.github/workflows` directory of the _Black_
repository.

They are triggered by the publication of a [GitHub Release].

Below are descriptions of our release workflows.

### Publish to PyPI

This is our main workflow. It builds an [sdist] and [wheels] to upload to PyPI where the
vast majority of users will download Black from. It's divided into three job groups:

#### sdist + pure wheel

This single job builds the sdist and pure Python wheel (i.e., a wheel that only contains
Python code) using [build] and then uploads them to PyPI using [twine]. These artifacts
are general-purpose and can be used on basically any platform supported by Python.

#### mypyc wheels (…)

We use [mypyc] to compile _Black_ into a CPython C extension for significantly improved
performance. Wheels built with mypyc are platform and Python version specific.
[Supported platforms are documented in the FAQ](labels/mypyc-support).

These matrix jobs use [cibuildwheel] which handles the complicated task of building C
extensions for many environments for us. Since building these wheels is slow, there are
multiple mypyc wheels jobs (hence the term "matrix") that build for a specific platform
(as noted in the job name in parentheses).

Like the previous job group, the built wheels are uploaded to PyPI using [twine].

#### Update stable branch

So this job doesn't _really_ belong here, but updating the `stable` branch after the
other PyPI jobs pass (they must pass for this job to start) makes the most sense. This
saves us from remembering to update the branch sometime after cutting the release.

- _Currently this workflow uses an API token associated with @ambv's PyPI account_

### Publish executables

This workflow builds native executables for multiple platforms using [PyInstaller]. This
allows people to download the executable for their platform and run _Black_ without a
[Python runtime](https://wiki.python.org/moin/PythonImplementations) installed.

The created binaries are stored on the associated GitHub Release for download over _IPv4
only_ (GitHub still does not have IPv6 access 😢).

### docker

This workflow uses the QEMU powered `buildx` feature of Docker to upload an `arm64` and
`amd64`/`x86_64` build of the official _Black_ Docker image™.

- _Currently this workflow uses an API Token associated with @cooperlees account_

```{note}
This also runs on each push to `main`.
```

[black-actions]: https://github.com/psf/black/actions
[build]: https://pypa-build.readthedocs.io/
[calver]: https://calver.org
[cibuildwheel]: https://cibuildwheel.readthedocs.io/
[gh-3139]: https://github.com/psf/black/pull/3139
[github actions]: https://github.com/features/actions
[github release]: https://github.com/psf/black/releases
[new-release]: https://github.com/psf/black/releases/new
[mypyc]: https://mypyc.readthedocs.io/
[mypyc-platform-support]:
  /faq.html#what-is-compiled-yes-no-all-about-in-the-version-output
[pyinstaller]: https://www.pyinstaller.org/
[sdist]:
  https://packaging.python.org/en/latest/glossary/#term-Source-Distribution-or-sdist
[twine]: https://github.com/features/actions
[wheels]: https://packaging.python.org/en/latest/glossary/#term-Wheel

repository: psf/black

gha_language: Python

repo_name: psf/black


text:
[![CanvasAPI on PyPI](https://img.shields.io/pypi/v/canvasapi.svg)](https://pypi.python.org/pypi/canvasapi)
[![License](https://img.shields.io/pypi/l/canvasapi.svg)](https://pypi.python.org/pypi/canvasapi)
[![Python Versions](https://img.shields.io/pypi/pyversions/canvasapi.svg)](https://pypi.python.org/pypi/canvasapi)
[![Documentation Status](https://readthedocs.org/projects/canvasapi/badge/?version=stable)](http://canvasapi.readthedocs.io/en/stable/?badge=stable)
[![Build Status](https://github.com/ucfopen/canvasapi/actions/workflows/run-tests.yml/badge.svg?branch=develop)](https://github.com/ucfopen/canvasapi/actions)
[![codecov](https://codecov.io/gh/ucfopen/canvasapi/branch/develop/graph/badge.svg?token=CFNpp8f56M)](https://codecov.io/gh/ucfopen/canvasapi)
[![Join UCF Open Slack Discussions](https://badgen.net/badge/icon/ucfopen?icon=slack&label=slack&color=pink)](https://dl.ucf.edu/join-ucfopen)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

# CanvasAPI

CanvasAPI is a Python library for accessing Instructure’s [Canvas LMS API](https://canvas.instructure.com/doc/api/index.html). The library enables developers to programmatically manage Canvas courses, users, gradebooks, and more.

## Table of Contents

- [CanvasAPI](#canvasapi)
  - [Table of Contents](#table-of-contents)
  - [Installation](#installation)
  - [Documentation](#documentation)
  - [Contributing](#contributing)
  - [Quickstart](#quickstart)
    - [Working with Canvas Objects](#working-with-canvas-objects)
      - [Course objects](#course-objects)
      - [User objects](#user-objects)
      - [Paginated Lists](#paginated-lists)
      - [Keyword arguments](#keyword-arguments)
  - [CanvasAPI Projects](#canvasapi-projects)
  - [Contact Us](#contact-us)

## Installation

You can install CanvasAPI with pip:

`pip install canvasapi`

## Documentation

Full documentation is available at [Read the Docs](http://canvasapi.readthedocs.io/).

## Contributing

Want to help us improve CanvasAPI? Check out our [Contributing Guide](.github/CONTRIBUTING.md) to learn about running CanvasAPI as a developer, picking issues to work on, submitting bug reports, contributing patches, and more.

## Quickstart

Getting started with CanvasAPI is easy.

Like most API clients, CanvasAPI exposes a single class that provides access to the rest of the API: `Canvas`.

The first thing to do is instantiate a new `Canvas` object by providing your Canvas instance’s root API URL and a valid API key:

```python
# Import the Canvas class
from canvasapi import Canvas

# Canvas API URL
API_URL = "https://example.com"
# Canvas API key
API_KEY = "p@$$w0rd"

# Initialize a new Canvas object
canvas = Canvas(API_URL, API_KEY)
```

You can now use `canvas` to begin making API calls.

### Working with Canvas Objects

CanvasAPI converts the JSON responses from the Canvas API into Python objects. These objects provide further access to the Canvas API. You can find a full breakdown of the methods these classes provide in our [class documentation](http://canvasapi.readthedocs.io/en/stable/class-reference.html). Below, you’ll find a few examples of common CanvasAPI use cases.

#### Course objects

Courses can be retrieved from the API:

```python
# Grab course 123456
>>> course = canvas.get_course(123456)

# Access the course's name
>>> course.name
'Test Course'

# Update the course's name
>>> course.update(course={'name': 'New Course Name'})
```

See our documentation on [keyword arguments](#keyword-arguments) for more information about how `course.update()` handles the `name` argument.

#### User objects

Individual users can be pulled from the API as well:

```python
# Grab user 123
>>> user = canvas.get_user(123)

# Access the user's name
>>> user.name
'Test User'

# Retrieve a list of courses the user is enrolled in
>>> courses = user.get_courses()

# Grab a different user by their SIS ID
>>> login_id_user = canvas.get_user('some_user', 'sis_login_id')
```

#### Paginated Lists

Some calls, like the `user.get_courses()` call above, will request multiple objects from Canvas’s API. CanvasAPI collects these objects in a `PaginatedList` object. `PaginatedList` generally acts like a regular Python list. You can grab an element by index, iterate over it, and take a slice of it.

**Warning**: `PaginatedList` lazily loads its elements. Unfortunately, there’s no way to determine the exact number of records Canvas will return without traversing the list fully. This means that `PaginatedList` isn’t aware of its own length and negative indexing is not currently supported.

Let’s look at how we can use the `PaginatedList` returned by our `get_courses()` call:

```python
# Retrieve a list of courses the user is enrolled in
>>> courses = user.get_courses()

>>> print(courses)
<PaginatedList of type Course>

# Access the first element in our list.
#
# You'll notice the first call takes a moment, but the next N-1
# elements (where N = the per_page argument supplied; the default is 10)
# will be instantly accessible.
>>> print(courses[0])
TST101 Test Course (1234567)

# Iterate over our course list
>>> for course in courses:
         print(course)

TST101 Test Course 1 (1234567)
TST102 Test Course 2 (1234568)
TST103 Test Course 3 (1234569)

# Take a slice of our course list
>>> courses[:2]
[TST101 Test Course 1 (1234567), TST102 Test Course 2 (1234568)]
```

#### Keyword arguments

Most of Canvas’s API endpoints accept a variety of arguments. CanvasAPI allows developers to insert keyword arguments when making calls to endpoints that accept arguments.

```python
# Get all of the active courses a user is currently enrolled in
>>> courses = user.get_courses(enrollment_state='active')
```

For a more detailed description of how CanvasAPI handles more complex keyword arguments, check out the [Keyword Argument Documentation](http://canvasapi.readthedocs.io/en/stable/keyword-args.html).

## CanvasAPI Projects

Since its initial release in June 2016, CanvasAPI has amassed over 100 [dependent repositories](https://github.com/ucfopen/canvasapi/network/dependents). Many of these include various tools used to enhance the Canvas experience for both instructors and students. Here are a few popular repositories that use CanvasAPI:

- [Canvas Grab](https://github.com/skyzh/canvas_grab)
  - Canvas Grab is the most popular project using CanvasAPI. This tool, with one click, copies all files from Canvas LMS to local directory. CanvasAPI is used in this project to connect to a course and grab its files.
- [Clanvas](https://github.com/marklalor/clanvas)
  - Clanvas is a command-line client for Canvas. It uses the already available bash commands plus some additional ones to interact with various features of Canvas from the commmand line.
- [CS221Bot](https://github.com/Person314159/cs221bot)
  - CS221Bot is a Discord bot for the CPCS 221 course at University of British Columbia. CanvasAPI is used in this project to connect to and synchronize with a course and get its data, such as announcements, new assignments, and more.

If you have a project that uses CanvasAPI that you'd like to promote, please contact us!

## Contact Us

Need help? Have an idea? Feel free to check out our [Discussions](https://github.com/ucfopen/canvasapi/discussions) board. Just want to say hi or get extended spport? Come join us on the [UCF Open Slack Channel](https://dl.ucf.edu/join-ucfopen) and join the `#canvasapi` channel!

license: MIT

repository: ucfopen/canvasapi

branch_name: refs/heads/develop

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: ucfopen/canvasapi


text:
# Errors

This service may produce four types of errors.

1. Built-in (and JSONRPC 2.0 compliant) errors:

Several types of errors may be thrown by the SDK-provided code or the execution engine runtime itself. This includes -32700 (parse error), -32600 (invalid request), -32601 (method not found), -32602 (invalid parameters), -32603 (internal error).

> TODO: check where these are emitted, if at all.

E.g.

```json
EXAMPLE HERE
```

2. Uncaught exceptions

Runtime errors which are thrown as exceptions (in exception based languages) and are not caught by user code will be caught by the top level service method dispatcher. When caught, exceptions produce an error structure and issues a 500 response.  Note that some services intentionally "throw" runtime errors (in the sense of, e.g. in Python raising an exception) with the intention that they be caught by the sdk server layer (which will have the code -32700, which is incorrect). This codebase does not, rather either the standard code is returned or an application specific code defined in this document.

> TODO: it is actually more complex than this, in terms of how specific exception types are caught and handled.

E.g.

```json
EXAMPLE HERE
```

1. SDK Internal Errors

Certain runtime errors which are not caught by the message dispatcher, but are rather problems with the SDK server layer, may result in a plain text response body and a 500 response code. This should be considered a bug in the SDK.

The SDK execution engine may detect problems and issue an error response. Such errors include errors parsing the json request. [Are they returned as 500?]

E.g.

```json
EXAMPLE HERE
```

4. Service Errors

Finally, errors encountered in the service itself , such as providing an invalid parameter or an unexpected condition of fetched data, will result in either an error with a standard code or a code specific to the service itself. These errors do not result in a 500 response, but rather a 200.

> consider a 400 response?

E.g. an error structure may look like:

```json
{
  "code": 40000,
  "message": "No job found for the provided job id '5d769018aa5a4d298c5dc97a'",
  "data": {
       "source": "JobBrowserBFF.get_job",
       "trace": [
            "some",
            "stack",
            "trace"
       ]
  }
}
```

Important features of this error structure:

- an error code is emitted. This allows the client code to handle this error explicitly.
- a display message is provided
- the JSONRPC standard field `data` is used to provide some useful context:
  - the source provides a more human-grokkable context than the stack trace. It is intentionally simple, so that layered errors may be more easily understood. (Layered or wrapped errors are not proposed yet.)
  - a standard stack trace as provided by the language runtime, if available

A service method may populate the data field with arbitrary data which is meaningful to the specific error.

## Custom Error Catalog

| Code  | Description                                                                       |
| ----- | --------------------------------------------------------------------------------- |
| 01    | Unknown error                                                                     |
| 10    | The requested job could not be found                                              |
| 20    | Job could not be canceled because it is not active                                |
| 21    | Job could not be canceled due to insufficient privileges                          |
| 30    | The requested job log could not be found                                          |
| 40    | User does not have access to this job                                             |
| 50    | Non-admin user attempt to use admin method                                        |
| 60    | Job is not cancelable                                                             |
| 100   | Request timeout                                                                   |
| 101   | HTTP Error calling upstream service                                               |
| 102   | Decoding error in response from upstream service - not json                       |
| 103   | Unexpected type in upstream service result; must be array or null                 |
| 104   | Invalid response from upstream service; not application/json, not an error status |
| 40000 | Unknown error                                                                     |

40xxx job query related
41xxx job action related

branch_name: refs/heads/master


text:
This is a fork of lunixbochs' and ptitSeb's glshim library used in Boardwalk.

See the [main Boardwalk repo](https://github.com/zhuowei/Boardwalk) for details and build instructions.

![Build Status](https://github.com/BoardwalkApp/boardwalk-glshim/workflows/Build%20glshim/badge.svg)

## Building

For Boardwalk 1.0,

```
cd build/android
ndk-build
```

then copy `glshim/build/android/libs` to `lwjgl/platform_build/android_wrapper/libs`

The original README of glshim is included below:

----

glshim
====

This is a shim providing OpenGL 1.x functionality to OpenGL ES accelerated cards.

----

Compiling
----

    cmake .; make GL

*or for the Raspberry Pi*

    cmake . -DBCMHOST=1; make GL

----

GLU
----

You probably want the glu branch from https://github.com/lunixbochs/glues

    git clone git@github.com:lunixbochs/glues.git; git checkout glu; cmake .; make

----

Installation
----

Put lib/libGL.so.1 in your `LD_LIBRARY_PATH`. If you need GLU, build libGLU.so.1 from the glues repo and do likewise.

repository: BoardwalkApp/boardwalk-glshim

repo_name: BoardwalkApp/boardwalk-glshim


text:
---
title: Sequential Symbolic Regression with Genetic Programming
date: '2015-01-01'
publishDate: '2021-05-04T19:20:54.305450Z'
authors:
- Luiz Otavio V. B. Oliveira
- Fernando E. B. Otero
- Gisele L. Pappa
- Julio Albinati
publication_types:
- '6'
abstract: 'This chapter describes the Sequential Symbolic Regression (SSR) method,
  a new strategy for function approximation in symbolic regression. The SSR method
  is inspired by the sequential covering strategy from machine learning, but instead
  of sequentially reducing the size of the problem being solved, it sequentially transforms
  the original problem into potentially simpler problems. This transformation is performed
  according to the semantic distances between the desired and obtained outputs and
  a geometric semantic operator. The rationale behind SSR is that, after generating
  a suboptimal function f via symbolic regression, the output errors can be approximated
  by another function, in a subsequent iteration. The method was tested in eight polynomial
  functions, and compared with canonical genetic programming (GP) and geometric semantic
  genetic programming (SGP). Results showed that SSR significantly outperforms SGP
  and presents no statistical difference from GP. More importantly, they show the
  potential of the proposed approach: an effective way of applying geometric semantic
  operators to combine different (partial) solutions, and at the same time, avoiding
  the exponential growth problem arising from the use of semantic operators.'
featured: false
publication: '*Genetic Programming Theory and Practice XII*'
url_pdf: https://link.springer.com/chapter/10.1007/978-3-319-16030-6_5
doi: 10.1007/978-3-319-16030-6_5
---

repository: luizvbo/academic-kickstart

repo_name: luizvbo/academic-kickstart


text:
# Terraform::TLS::LocallySignedCert

Generates a TLS certificate using a *Certificate Signing Request* (CSR) and
signs it with a provided certificate authority (CA) private key.

Locally-signed certificates are generally only trusted by client software when
setup to use the provided CA. They are normally used in development environments
or when deployed internally to an organization.

## Properties

`CertRequestPem` - (Required) PEM-encoded request certificate data.

`CaKeyAlgorithm` - (Required) The name of the algorithm for the key provided
in `CaPrivateKeyPem`.

`CaPrivateKeyPem` - (Required) PEM-encoded private key data for the CA.
This can be read from a separate file using the ``file`` interpolation
function.

`CaCertPem` - (Required) PEM-encoded certificate data for the CA.

`ValidityPeriodHours` - (Required) The number of hours after initial issuing that the
certificate will become invalid.

`AllowedUses` - (Required) List of keywords each describing a use that is permitted
for the issued certificate. The valid keywords are listed below.

`EarlyRenewalHours` - (Optional) If set, the resource will consider the certificate to
have expired the given number of hours before its actual expiry time. This can be useful
to deploy an updated certificate in advance of the expiration of the current certificate.
Note however that the old certificate remains valid until its true expiration time, since
this resource does not (and cannot) support certificate revocation. Note also that this
advance update can only be performed should the Terraform configuration be applied during the
early renewal period.

`IsCaCertificate` - (Optional) Boolean controlling whether the CA flag will be set in the
generated certificate. Defaults to `false`, meaning that the certificate does not represent
a certificate authority.

## Return Values

### Fn::GetAtt

`CertPem` - The certificate data in PEM format.

`ValidityStartTime` - The time after which the certificate is valid, as an.

`ValidityEndTime` - The time until which the certificate is invalid, as an.

## See Also

* [tls_locally_signed_cert](https://www.terraform.io/docs/providers/tls/r/locally_signed_cert.html) in the _Terraform Provider Documentation_


text:
# JNLP Slave for Jenkins - PHP 7.2.4

Based on https://github.com/dunkelfrosch/docker-jenkins-slave-php-7

## provide dynamic slaves in a Kubernetes/Docker environment

[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
[![System Version](https://img.shields.io/badge/version-0.0.1-blue.svg)](VERSION)

This repository will hold our jnlp slave docker image for php 7.2.4 related CI processes and will be part of our kubernetes jenkins cluster experimental workload. Use this image for all php related build processes you want to call inside our gcloud kubernetes cluster jenkins definition.

## License-Term

Copyright (c) 2018 Yaroslav Sklabinskyi<EMAIL_ADDRESS>
Permission is hereby granted,  free of charge,  to any  person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction,  including without limitation
the rights to use,  copy, modify, merge, publish,  distribute, sublicense,
and/or sell copies  of the  Software,  and to permit  persons to whom  the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,  WHETHER IN AN ACTION OF CONTRACT,  TORT OR OTHERWISE,  ARISING
FROM,  OUT OF  OR IN CONNECTION  WITH THE  SOFTWARE  OR THE  USE OR  OTHER DEALINGS IN THE SOFTWARE.

gha_language: Dockerfile


text:
---
layout: default
---

# 1996-05-09 - Internet/Obscenity Legal Gathering in NYC

## Header Data

From<EMAIL_ADDRESS>(Dr. Dimitri Vulis)

To<EMAIL_ADDRESS>Message Hash: 3a95000281c5445569907334ed192be875c9eb7fef416b37c2987b341ec0247e

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-05-09 08:58:23 UTC

Raw Date: Thu, 9 May 1996 16:58:23 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Dr. Dimitri Vulis)
Date: Thu, 9 May 1996 16:58:23 +0800
To<EMAIL_ADDRESS>Subject: Internet/Obscenity Legal Gathering in NYC
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I haven't seen this announcement reposted to this mailing list, and I think
it's of sufficient interest to warrant reposting:

Newsgroups: misc.legal,alt.censorship,misc.legal.moderated,talk.politics,alt.privacy
From<EMAIL_ADDRESS>(Ron Abramson)
Subject: Free program on net censorship in NYC
Message-ID<EMAIL_ADDRESS>Date: Mon, 6 May 1996 17:49:08 GMT

Announcement: Free Program On Net Censorship
in New York City, May 22 at 7:30 P.M.
--------------------------------------------

THE FIRST AMENDMENT IN CYBERSPACE:  Regulating the On-Line
Dissemination of "Indecent Material"

This program will address the issue of the First Amendment as
applied to the Internet and On-line services.  Special focus
will be given to the new federal law which is intended to
regulate the dissemination of "Indecent Material" via these
mediums.

The Association of the Bar of the City of New York
42 W 44TH Street, New York, New York (Bet. 5th and 6th Avenues)
(212) 382-6600

Wednesday, May 22, 1996, 7:30 till 9 P.M.

Moderator:
CHARLES R. NESSON
Weld Professor of Law, Harvard law School

Panelists:
ROBERT FLORES
Senior Trial Attorney, Child Exploitation and Obscenity
Section, U.S. Department of Justice

MICHAEL GODWIN
General Counsel, Electronic Frontier Foundation

STEPHEN M. HEATON
General Counsel, Compuserve, Inc.

NORMAN REDLICH
Wachtell, Lipton Rosen & Katz, former Dean,
New York University School of Law

BRUCE TAYLOR
President and Chief Counsel, National Center for
Children and Families

Co-sponsored by:
Committee on Computer Law, Joseph P. Zammit, Chair
Committee on Lectures and Continuing Education,
  Normal L. Green, Chair

Members of the Association, their guests and all other
interested persons are invited to attend.

No fees or reservations are required.

---

Dr. Dimitri Vulis
Brighton Beach Boardwalk BBS, Forest Hills, N.Y.: +1-718-261-2013, 14.4Kbps

{% endraw %}
```

## Thread

+ Return to [May 1996](/archive/1996/05)

+ Return to<EMAIL_ADDRESS>(Dr. Dimitri Vulis)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_)"
+ Return to "[DrG <manus@manus.org>](/authors/drg_manus_at_manus_org_)"

+ 1996-05-09 (Thu, 9 May 1996 16:58:23 +0800) - Internet/Obscenity Legal Gathering in NYC -<EMAIL_ADDRESS>(Dr. Dimitri Vulis)_
  + 1996-05-09 (Thu, 9 May 1996 23:02:15 +0800) - [Re: Internet/Obscenity Legal Gathering in NYC](/archive/1996/05/901825b2a8b0a416bbc7c656b6737550875dcddcf40a23e2d487236bbd36c6e5) - _DrG<EMAIL_ADDRESS>


text:
# Balanced parentheses

Implement a function that **takes in a string**, and determines if the **opening** and **closing parentheses** in the given string are **matching correctly** returning the appropriate boolean value.

## Examples:

### Correct cases (should return true):
* (()()()())
* (((())))
* (()((())()))

### Incorrect cases (should return false)
* ((((((())
* ()))
* (()()(()

## Tips & Tricks
* There can be characters anywhere between, after or before the parenteses.
* Think about how can things go wrong, if the amount of opening & closing parentheses are the same.


text:
# Correcting for experiment-specific variability in expression compendia can remove underlying signals

**Alexandra J Lee, YoSon Park, Georgia Doing, Deborah A Hogan and Casey S Greene**

**January 2020**

**University of Pennsylvania**

[![DOI:10.1101/2<IP_ADDRESS>597v1](https://zenodo.org/badge/DOI/10.1007/978-3-319-76207-4_15.svg)](https://www.biorxiv.org/content/10.1101/2<IP_ADDRESS>597v1)

This repository stores data and analysis modules to simulate compendia of gene expression data and measure the effect of technical sources of variation on our ability to extract an underlying biological signal.

*Motivation:* In the last two decades, scientists working in different labs have assayed gene expression from millions of samples. These experiments can be combined into a compendium and used to extract novel biological patterns. However, combining different experiments introduces technical variance, which could distort biological patterns and lead to misinterpretation. As the scale and prevalence of these compendia increases, it becomes crucial to evaluate how integrating multiple experiments affects our ability to detect biological patterns.

*Objective:* To determine the extent to which underlying biological structures are masked by technical variants via simulation of a multi-experiment compendia.

*Method:* We used a generative multi-layer neural network to simulate a compendium of P. aeruginosa gene expression experiments. We performed a pairwise comparison of the simulated compendium versus the simulated compendium containing varying number of sources of technical variation.

*Results:* We found that it was difficult to detect the original biological structure of interest in a compendium containing some sources of technical variation unless we applied batch correction. Interestingly, as the number of sources of variation increased, it became easier to detect the original biological structure without correction. Furthermore, when we applied batch correction, it reduced our power to detect the biological structure of interest.

*Conclusion:* When combining some sources of technical variation, it is best to perform batch correction. However, as the number of sources increases, batch correction becomes unnecessary and indeed harms our ability to extract biological patterns.

## Analysis Modules

There are 2 analyses using Pseudomonas dataset in the `Pseudomonas` directory and 2 analyses using the recount2 dataset in the `Human` directory:

| Name | Description |
| :--- | :---------- |
| [Pseudomonas_sample_lvl_sim](Pseudomonas/Pseudomonas_sample_lvl_sim.ipynb) | Pseudomonas sample-level gene expression simulation|
| [Pseudomonas_experiment_lvl_sim](Pseudomonas/Pseudomonas_experiment_lvl_sim.ipynb) | Pseudomonas experiment-level gene expression simulation|
| [Human_sample_lvl_sim](Human/Human_sample_lvl_sim.ipynb) | Human sample-level gene expression simulation|
| [Human_experiment_lvl_sim](Human/Human_experiment_lvl_sim.ipynb) | Human experiment-level gene expression simulation|

## Computational Environment

All processing and analysis scripts were performed using the conda environment specified in `environment.yml`.
To build and activate this environment run:

```bash
# conda version 4.6.12
conda env create -f environment.yml

conda activate simulate_expression_compendia
```

R scripts were run using R 3.6.3

## How to run this simulation using your own data

In order to run this simulation on your own gene expression data the following steps should be performed:

First we need to set up your local repository:
1. Clone the ```simulate-expression-compendia``` repository
2. Set up conda environment using the command above
3. Create a new analysis folder in the main directory. This is equivalent to the ```Pseudomonas``` directory
4. Within your analysis folder create ```data/``` directory and ```input/```, ```metadata/``` subdirectories
5. Copy ```Pseudomonas_sample_lvl_sim.ipynb``` and ```Pseudomonas_experiment_lvl_sim.ipynb``` into your respective folder.

Next we need to modify the code for your analysis:
1. Update the ```config_Pa_sample_limma.tsv``` and ```config_Pa_experiment_limma.tsv``` based on your analysis
2. Update the analysis notebooks to use your config file and input file
3. Add your gene expression data file to the ```data/input/``` directory.  Your data is expected to be stored as a tab-delimited dataset with samples as rows and genes as columns.
4. Add your metadata file to ```data/metadata/``` directory.  Your metadata is expected to be stored as a tab-delimited with sample ids matching the gene expression dataset as one column and experiment ids as another.
5. The module ```create_experiment_id_file``` in ```pipeline.py``` will need to be updated based on the format of your metadata file
6. Run notebooks

## Additional customization

Further customization can be accomplished by doing the following:

1. The ```apply_correction_io``` function in the ```functions/generate_data_parallel.py``` file can be modified to use a different correction method.
2. If there are additional pre-processing specific to your data, these can be added as modules in the ```pipeline.py``` file and called in the analysis notebook

## Configuration file

| Name | Description |
| :--- | :---------- |
| local_dir| str: Parent directory on local machine to store intermediate results|
| dataset_name| str: Name for analysis directory. Either "Human" or "Pseudomonas"|
| simulation_type | str: "sample_lvl_sim" or "experiment_lvl_sim"|
| NN_architecture | str: Name of neural network architecture to use. Format 'NN_<intermediate layer>_<latent layer>'|
| learning_rate| float: Parent directory on local machine to store intermediate results|
| batch_size | str: Name for analysis directory. Either "Human" or "Pseudomonas"|
| epochs | int: Number of times to train over the entire input dataset|
| kappa | float: How fast to linearly ramp up KL loss|
| intermediate_dim| int: Size of the hidden layer|
| latent_dim | int: Size of the bottleneck layer|
| epsilon_std | float: Standard deviation of Normal distribution to sample latent space|
| num_simulated_samples | int: Simulate a compendia with these many samples|
| num_simulated_experiments| int: Simulate a compendia with these many experiments|
| lst_num_experiments | list:  List of different numbers of experiments to add to simulated data.  These are the number of sources of technical variation that are added to the simulated data|
| lst_num_partitions | list:  List of different numbers of partitions to add to simulated data.  These are the number of sources of technical variation that are added to the simulated data|
| use_pca | bool: True if want to represent expression data in top PCs before calculating SVCCA similarity|
| num_PCs | int: Number of top PCs to use to represent expression data|
| correction_method | str: Noise correction method to use. Either "limma" or "combat"|
| metadata_colname | str: Column header that contains sample id that maps expression data and metadata|
| iterations | int: Number of simulations to run|
| num_cores | int: Number of processing cores to use|

## Acknowledgements
We would like to thank YoSon Park, David Nicholson, Ben Heil and Ariel Hippen-Anderson for insightful discussions and code review

repository: metamaden/simulate-expression-compendia

repo_name: metamaden/simulate-expression-compendia


text:
# ssech

Netwok based 2 players games with sse.

- vue single file components
- sse and rest communication

## Requirements

- Node.js
- Browser (Chrome, Safari, Opera, ...)

## Install

```sh
git clone https://github.com/tomuwhu/ssech
cd ssech
npm i
npm start
```

In your browser:

[http://localhost:3004/](http://localhost:3004/)

In another computer in local network for example:
`http://<your computer ip adress>:3004/`

[Aviable in live](http://www.inf.u-szeged.hu/u/tnemeth_5/)

repository: tomuwhu/ssech

gha_language: Vue

repo_name: tomuwhu/ssech


text:
Testing readme with codeblock execution --config-file
Variables are injecte before code blocks execution,

### Case simple shell command with variables inject before code blocks execution
Expects variable TEST_VAR1 contains foo from injected config file
```
#executable block
#executable contains in expected output foo
echo ${TEST_VAR1}
```

Expects variable TEST_VAR2 contains bar from injected config file
```
#executable block
#executable contains in expected output bar
echo ${TEST_VAR2}
#executable contains in expected output /Home/User
echo ${UPPPER_VAR3}
```

### Case incorrect path to config file
Expects shell md fails on incorrect path to config file
```
#executable block
#executable expected return code 2
python3 bin/shellmd.py --config-file=/tmp/no_foo_bar --input-file=tests/README.md
```

repository: martinkala/shellmd

branch_name: refs/heads/main

repo_name: martinkala/shellmd


text:
---
actual_indicator_available: 'Percentage of public elementary and secondary school
  teachers who have regular certification or probationary certification (only requiring
  fulfillment of a probationary employment period. '
actual_indicator_available_description: "The Schools and Staffing Survey (SASS) was\
  \ conducted by NCES seven times between 1987 through 2011. SASS was an integrated\
  \ study public and private school districts, schools, principals, and teachers designed\
  \ to provide descriptive data on the context of elementary and secondary education.\
  \ SASS covered a wide range of topics from teacher demand, teacher and principal\
  \ characteristics, general conditions in schools, principals' and teachers' perceptions\
  \ of school climate and problems in their schools, teacher compensation, district\
  \ hiring and retention practices, to basic characteristics of the student population.\
  \ After 2011\u201312, NCES redesigned SASS and named it the National Teacher and\
  \ Principal Survey (NTPS) to reflect the redesigned study's focus on the teacher\
  \ and principal labor market and on the state of K-12 school staff. NCES first conducted\
  \ NTPS in 2015\u201316 and released data in 2017. Variable name                \
  \         Description of variable pctteachers_prep\t\t\t    Percent of public school\
  \ teachers with certification, preprimary pctteachers_prim\t\t\t    Percent of public\
  \ school teachers with certification, primary pctteachers_lowersec\t\t\tPercent\
  \ of public school teachers with certification, lower secondary pctteachers_uppersec\t\
  \t\tPercent of public school teachers with certification, upper secondary pctteachers_multiple\
  \ levels\t\tPercent of public school teachers with certification, multiple levels"
comments_and_limitations: Coverage of prekindergarten teachers is only partial. Many
  teachers teach more than one academic level, and included in the tabulation as multiple
  levels.
computation_units: Teacher
data_non_statistical: false
date_metadata_updated: '2017-10-13 '
date_of_national_source_publication: 2017-8-15
disaggregation_categories: Teacher level of instruction
disaggregation_geography: NA
goal_meta_link: http://unstats.un.org/sdgs/files/metadata-compilation/Metadata-Goal-4.pdf
graph_title: Percent of US public school pre-primary teachers with certification
graph_type: line
has_metadata: true
indicator: 4.c.1
indicator_definition: "From UNESCO:  The percentage of teachers by level of education\
  \ taught (pre-primary, primary, lower secondary and upper secondary) who have received\
  \ at least the minimum organized pedagogical teacher training pre-service and in-service\
  \ required for teaching at the relevant level in a given country. The indicator\
  \ should be calculated separately for public and private institutions. From OECD:\
  \ Teachers (ISCED 2 level) were asked to indicate whether they had participated\
  \ in any of the following activities 12 months prior to the survey: \tCourses/workshops\
  \ (on subject matter or methods and/or other education-related topics). \tEducation\
  \ conferences or seminars (where teachers and/or researchers present their research\
  \ results and discuss education problems). \tObservation visits to other schools.\
  \ \tObservation visits to business premises, public organisations, or non-governmental\
  \ organisations. \tIn-service training courses in business premises, public organisations\
  \ or non-governmental organisations. \tQualification programmes (e.g. a degree programme).\
  \ \tParticipation in a network of teachers formed specifically for the professional\
  \ development of teachers. \tIndividual or collaborative research on a topic of\
  \ professional interest. \tMentoring and/or peer observation and coaching as part\
  \ of a formal school arrangement"
indicator_name: 'Percentage of teachers in: (a) pre-primary (b) primary (c) lower
  secondary and (d) upper secondary education who have received at least the minimum
  organized teacher training (i.e. pedagogical training) pre-service or in-service
  required for teaching at the relevant level in a given country'
indicator_sort_order: 04-0c-01
indicator_variable: pctteachers_prep
layout: indicator
method_of_computation: Percentage of public schoool teachers who have regular certification
  or probationary certification (only require fulfillment of probationary employment
  period.
national_geographical_coverage: United States
periodicity: Data collected every 4 years
permalink: /4-c-1/
published: true
rationale_interpretation: "From UNESCO: \n Teachers play a key role in ensuring the\
  \ quality of education provided. Ideally all teachers should receive adequate, appropriate\
  \ and relevant pedagogical training to teach at the chosen level of education and\
  \ be academically well-qualified in the subject(s) they are expected to teach. This\
  \ indicator measures the share of the teaching work force which is pedagogically\
  \ well-trained. \nFrom OECD: \nTo provide policy-relevant analysis on teachers'\
  \ participation in professional development activities through a robust indicator."
reporting_status: complete
scheduled_update_by_national_source: '2019'
sdg_goal: 4
source_active_1: true
source_agency_staff_email_1<EMAIL_ADDRESS>source_agency_staff_name_1: Tom Snyder
source_agency_survey_dataset_1: National Center for Education Statistics, Schools
  and Staffing Survey; National Teacher and Principal Survey
source_notes_1: http://nces.ed.gov/surveys/sass/ and https://nces.ed.gov/surveys/ntps/
source_organisation_1: National Center for Education Statistics, Schools and Staffing
  Survey; National Teacher and Principal Survey
source_title_1: null
target: By 2030, substantially increase the supply of qualified teachers, including
  through international cooperation for teacher training in developing countries,
  especially least developed countries and small island developing States.
target_id: 4.c
time_period: 1999-2000, 2003-04, 2007-08, 2011-12, and 2015-16
title: 'Percentage of teachers in: (a) pre-primary (b) primary (c) lower secondary
  and (d) upper secondary education who have received at least the minimum organized
  teacher training (i.e. pedagogical training) pre-service or in-service required
  for teaching at the relevant level in a given country'
un_custodial_agency: 'UNESCO-UIS (Partnering Agencies: OECD)'
un_designated_tier: '2'
us_method_of_computation: Using nationally representative sample of public school
  teachers, percentage of teachers with regular or probationary certification.
variable_description: null
variable_notes: null
---

repository: GSA/sdg-data-usa

repo_name: GSA/sdg-data-usa


text:
# Books

You can learn so much from books that it deserves its own section on this website.
Not only learning but also opening your mind, dreaming, traveling. Books are really a gate to an enourmous amount of knowledge and stories.

<EMAIL_ADDRESS>
A really good initiative that you can find in many cities is called **book exchange**.
This is a place where you can go to and pick upany book you like. Or you can drop one you have finish reading.
It's all for free, you don't even have to give a book away in order to receive one. But if you do it's great as it keeps the system going.
I know these kind of actions always sounds a bit utopist but they do really exist.

You can also go to a **2nd hand book store** and find great titles under very low price.
Another option is also to visit your local **library**, there you'll easily find the book you are looking for.

You can also find a lot of free titles online.

repository: luseeds/opportunist

repo_name: luseeds/opportunist


text:
# Hyphenopoly.js

[![CircleCI](https://circleci.com/gh/mnater/Hyphenopoly/tree/master.svg?style=shield)](https://circleci.com/gh/mnater/Hyphenopoly/tree/master)
[![Coverage Status](https://coveralls.io/repos/github/mnater/Hyphenopoly/badge.svg?branch=master)](https://coveralls.io/github/mnater/Hyphenopoly?branch=master)
[![npms score](https://badges.npms.io/hyphenopoly.svg)](https://npms.io/search?q=hyphenopoly)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/de50e1ae70a64a47b0bd9b5449f89353)](https://www.codacy.com/gh/mnater/Hyphenopoly/dashboard?utm_source=github.com&utm_medium=referral&utm_content=mnater/Hyphenopoly&utm_campaign=Badge_Grade)

Hyphenopoly.js is a __JavaScript-polyfill for hyphenation in HTML__: it hyphenates text if the user agent does not support CSS-hyphenation at all or not for the required languages and it is a __Node.js-module__.

The package consists of the following parts:
-   _Hyphenopoly_Loader.js_ (~11KB unpacked, ~2KB minified and compressed): feature-checks the client and loads other resources if necessary.
-   _Hyphenopoly.js_ (~36KB unpacked, ~5KB minified and compressed): does the whole DOM-foo and wraps wasm.
-   _wasm-Modules_ (sizes differ! e.g. en-us.wasm: ~21KB uncompressed, ~15KB compressed): core hyphenation functions and hyphenation patterns in a space saving binary format (including pattern license).
-   _hyphenopoly.module.js_: the node module to hyphenate plain text strings.

## Usage (Browser)
Place all the code for Hyphenopoly at the top of the header (immediately after the `<title>` tag) to ensure resources are loaded as early as possible.

You'll have to insert two script blocks. In the first block, load Hyphenopoly_Loader.js as an external script.
In the second block, provide the initial configurations for Hyphenopoly_Loader as an inline script. This also triggers all further steps.

Also, don't forget to enable CSS hyphenation.

 This information is provided as a parameter object to the function `Hyphenopoly.config()`. This information is stored in a globally accessible Object called `window.Hyphenopoly`. Hyphenopoly_Loader.js and (if necessary) Hyphenopoly.js will add other methods and properties only to this object – there will be no other global variables or functions beyond this object.

#### require
The configuration object must have exactly one property called `require` which itself is an object containing at least one nameValuePair where the name is a language code string (Some languages are region-specific. See the patterns directory for supported languages. E.g. just using `en` won't work, use `en-us`or `en-gb`) and the value is a long word string in that language (preferably more than 12 characters long).

If you want to force the usage of Hyphenopoly.js for a language (e.g. for testing purposes), write `"FORCEHYPHENOPOLY"` instead of the long word.

Hyphenopoly_Loader.js tests if the client (aka browser, aka user agent) supports CSS hyphenation for the language(s) given in `require`. In the example above, it will test if the client supports CSS-hyphenation for Latin, German and US-English.

If one of the given languages isn't supported, it automatically hides the document's contents and loads Hyphenopoly.js and the necessary WebAssembly modules.

Hyphenopoly.js – once loaded – will hyphenate the elements according to the settings and unhide the document when it's done.

If something goes wrong and Hyphenopoly.js is unable to unhide the document, Hyphenopoly_Loader.js has a timeout that kicks in after some time (defaults to 1000ms) and unhides the document and writes a message to the console.

If the browser supports all required languages, the script deletes the `Hyphenopoly`-object and terminates without further ado.

### enable CSS-hyphenation
Hyphenopoly by default hyphenates elements (and their children) with the classname `.hyphenate`. Don't forget to enable CSS-hyphenation for the classes eventually handled by Hyphenopoly.

## Usage (node)
[![Try hyphenopoly on RunKit](https://badge.runkitcdn.com/hyphenopoly.svg)](https://npm.runkit.com/hyphenopoly)

Install:
````shell
npm i hyphenopoly
````

````javascript
import hyphenopoly from "hyphenopoly";

const hyphenator = hyphenopoly.config({
    "require": ["de", "en-us"],
    "hyphen": "•",
    "loader": async (file) => {
        const {readFile} = await import("node:fs/promises");
        const {dirname} = await import("node:path");
        const {fileURLToPath} = await import("node:url");
        const cwd = dirname(fileURLToPath(import.meta.url));
        return readFile(`${cwd}/../patterns/${file}`);
    },
    "exceptions": {
        "en-us": "en-han-ces"
    }
});

async function hyphenate_en(text) {
    const hyphenateText = await hyphenator.get("en-us");
    console.log(hyphenateText(text));
}

async function hyphenate_de(text) {
    const hyphenateText = await hyphenator.get("de");
    console.log(hyphenateText(text));
}

hyphenate_en("hyphenation enhances justification.");
hyphenate_de("Silbentrennung verbessert den Blocksatz.");
````

## Support this project
[![PayPal](https://www.paypal.com/en_US/i/btn/btn_donateCC_LG_global.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=SYNZKB8Z2FRQY)

## Automatic hyphenation
The algorithm used for hyphenation was developed by Franklin M. Liang for TeX. It works more or less like this:

1.  Load a set of precomputed language specific patterns. The patterns are stored in a structure called a trie, which is very efficient for this task.
2.
3.  Combine the numerical values between characters: higher values overwrite lower values.
4.  Odd values are hyphenation points (except if the hyphenation point is left from `leftmin` and right from `rightmin`), replace them with a soft hyphen and drop the other values.
5.  Repeat steps 2. - 4. for all words longer than minWordLength

Example:
````text
Hyphenation
h y p h e n a t i o n
h y3p h
      h e2n
      h e n a4
      h e n5a t
         1n a
          n2a t
             1t i o
               2i o
                  o2n
h0y3p0h0e2n5a4t2i0o2n
Hy-phen-ation
````

The patterns are precomputed and available for many languages on [CTAN](https://www.ctan.org/tex-archive/language/hyphenation/) and [tex-hyphen](https://github.com/hyphenation/tex-hyphen). For Hyphenopoly.js they are converted to a succinct trie data structure (including pattern license, metadata, and the patterns).

The original patterns are computed from a large list of hyphenated words by a program called `patgen`. They aim to find some hyphenation points – not all – because it's better to miss a hyphenation point than to have some false hyphenation points. Most patterns are really good, but none are error free.

These patterns vary in size. This is mostly due to the different linguistic characteristics of the languages.

## Contributors ✨

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

repository: mnater/Hyphenopoly

gha_language: TypeScript

repo_name: mnater/Hyphenopoly


text:
Hunts for endpoint activity involving hash IOCs, using Carbon Black Protection.

## Dependencies
This playbook uses the following sub-playbooks, integrations, and scripts.

### Sub-playbooks
This playbook does not use any sub-playbooks.

### Integrations
* carbonblackprotection

### Scripts
* CBPCatalogFindHash
* Exists
* CBPFindRule
* Set

### Commands
* cbp-computer-get

## Playbook Inputs
---

| **Name** | **Description** | **Default Value** | **Source** | **Required** |
| --- | --- | --- | --- | --- |
| Hash | The MD5 file Hash to hunt for. | MD5 | File | Optional |

## Playbook Outputs
---

| **Path** | **Description** | **Type** |
| --- | --- | --- |
| Endpoint.Hostname | The device hostname. | string |
| Endpoint | The endpoint. | unknown |

## Playbook Image
---
![Search_Endpoints_By_Hash_Carbon_Black_Protection](https://raw.githubusercontent.com/demisto/content/f975de39b05cd3560b782f54d37637741d87ff65/docs/images/playbooks/Search_Endpoints_By_Hash_Carbon_Black_Protection.png)

repository: demisto/content

repo_name: demisto/content


text:
# SystemJS 2.0

[![Build Status][travis-image]][travis-url]
[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/systemjs/systemjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Sponsor](https://cdn.canopytax.com/images/canopy-sponsorship.svg)](https://canopytax.github.io/post/systemjs-sponsorship/?utm_source=systemjs)

Configurable module loader enabling backwards compatibility workflows for ES modules in browsers.

[Read the SystemJS 2.0 announcement post](https://guybedford.com/systemjs-2.0-alpha)

_[For the previous release see the SystemJS 0.21.x branch](https://github.com/systemjs/systemjs/tree/0.21)_

_SystemJS is [currently sponsored by Canopy Tax](https://canopytax.github.io/post/systemjs-sponsorship/?utm_source=systemjs)._

SystemJS 2.0 provides two hookable base builds:

#### 1. s.js minimal loader

The 1.5KB [s.js](dist/s.min.js) minimal loader supports:

  * Loads [System.register](docs/system-register.md) modules [supporting all ES module semantics](docs/system-register.md#semantics)
  * Loads and resolves URLs only, excluding support for [bare specifier names](docs/package-name-maps.md#bare-specifiers) (eg `/lodash.js` but not `lodash`)
  * Hookable loader supporting [custom extensions](docs/hooks.md)
  * Works in IE11+ when [Promises are polyfilled](#promise-polyfill)
  * Ideal for use in [Rollup code-splitting builds](https://rollupjs.org/guide/en#experimental-code-splitting)

#### 2. system.js loader

The 2.5KB [system.js](dist/system.min.js) loader supports:

  * [Tracing hooks](docs/hooks.md#trace-hooks) and [registry deletion API](docs/api.md#registry) for reloading workflows
  * Supports loading global scripts as modules, as well as [Sytem.register](docs/system-regsiter.md) modules
  * Supports [package name maps](docs/package-name-maps.md) for resolving [bare specifier names](docs/package-name-maps.md#bare-specifiers), loaded via `<script type="systemjs-packagenamemap">`
  * Supports loading WASM based on the `.wasm` file extension
  * Works in IE11+ when [Fetch (for WASM) and Promises are polyfilled](#promise-polyfill)

#### Extras

The following [pluggable extras](dist/extras) are provided:

* [AMD loading](dist/extras/amd.js) support (through `Window.define` which is created)
* [Named exports](dist/extras/named-exports.js) convenience extension support for global and AMD module formats (`import { x } from './global.js'` instead of `import G from './global.js'; G.x`)
* [Transform loader](dist/extras/transform.js) support, using fetch and eval, supporting a hookable `loader.transform`

Since all loader features are hookable, custom extensions can be easily made following the same approach as the bundled extras. See the [hooks documentation](docs/hooks.md) for more information.

For discussion, join the [Gitter Room](https://gitter.im/systemjs/systemjs).

## Installation

```
npm install systemjs@alpha
```

## Documentation

* [Package Name Maps](docs/package-name-maps.md)
* [API](docs/api.md)
* [System.register](docs/system-register.md)
* [Loader Hooks](docs/hooks.md)

## Example Usage

### Loading a System.register module

```html
<script src="system.js"></script>
<script>
  System.import('/js/main.js');
</script>
```

where `main.js` is a module available in the System.register module format.

### Package Name Maps

Say `main.js` depends on loading `'lodash'`, then we can define a package name map:

```html

<script type="systemjs-packagemap">
{
  "packages": {
    "lodash"<EMAIL_ADDRESS>  }
}
</script>
<!-- Alternatively:
<script type="systemjs-packagemap" src="path/to/map.json">
-->
<!-- SystemJS must be loaded after the package map -->
<script src="system.js"></script>
<script>
  System.import('/js/main.js');
</script>
```

### Browser transpilation

To load ES modules directly in older browsers with SystemJS we can install and use the Babel plugin:

```html
<script src="system.js"></script>
<script src="extras/transform.js"></script>
<script src="plugin-babel/dist/babel-transform.js"></script>
<script>
  // main and all its dependencies will now run through transform before loading
  System.import('/js/main.js');
</script>
```

### Polyfills for Older Browsers

#### Promises

Both builds of SystemJS need Promises in the environment to work, which aren't supported in older browsers like IE11.

Promises can be conditionally polyfilled using, for example, [Bluebird](http://bluebirdjs.com/docs/getting-started.html) (generally the fastest Promise polyfill):

```html
<script>
  if (typeof Promise === 'undefined')
    document.write('<script src="node_modules/bluebird/js/browser/bluebird.core.js"><\/script>');
</script>
```

> Generally `document.write` is not recommended when writing web applications, but for this use case
  it works really well and will only apply in older browsers anyway.

#### Fetch

To support package maps in the system.js build, a fetch polyfill is need. The [GitHub polyfill](https://github.github.io/fetch/) is recommended:

```html
<script>
  if (typeof fetch === 'undefined')
    document.write('<script src="node_modules/whatwg-fetch/fetch.js"><\/script>');
</script>
```

### Loader Extensions

This list can be extended to include third-party loader extensions. Feel free to [post a PR to share your work](https://github.com/systemjs/systemjs/edit/2.0/README.md).

* [transform-babel](https://github.com/systemjs/systemjs-transform-babel) Supports ES module transformation into System.register with Babel.

### Contributing to SystemJS

Project bug fixes and changes are welcome for discussion, provided the project footprint remains minimal.

To run the tests:

```
npm run build && npm run test
```

## License

MIT

[travis-url]: https://travis-ci.org/systemjs/systemjs
[travis-image]: https://travis-ci.org/systemjs/systemjs.svg?branch=master

repository: Yatin-Gupta/react-test-endpoints

repo_name: Yatin-Gupta/react-test-endpoints


text:
Make a melee spell attack against one creature within 5 feet of you. On a hit, the target takes 1d10 acid damage. After you make the attack, your teeth or fingernails return to normal.

The spell’s damage increases by 1d10 when you reach 5th level (2d10), 11th level (3d10), and 17th level (4d10).

repository: lester-lee/dnd

repo_name: lester-lee/dnd


text:
====== Tcl ======
===== Syntax =====
==== Variables ====
Tcl supports scalar variables and associative arrays.

Variables can be assigned and read using the **set** command.
  set s {This is a string}
  => This is a string
  set n 17
  => 17
  set s
  => This is a string

Associative Arrays

  set scores(Andrew) 95
  set scores(Geoff) 87

The dollar ($) symbol is used to reference a previously set variable
The expr keyword is used to mean evaluate and substitute.

  set totalScores 0
  for name (Andrew Geoff) {
    set totalScores [expr $totalScores + $scores($name)
  }

^ Java ^ Tcl ^
| i++ | incr i |
| i += 2 | incr i 2 |
| append s {Hello} | s += Hello |

==== Arrays ====

==== Control Flow ====

=== If ===
  if {$a > 5} {
    set a 0
  }

  if {$a == 0} {
    set a 1
  } elseif {$a == 1} {
    set a 2
  } else {
    set a 0
  }

Note that the start brace *must* appear on the same line as the if statement.

=== Loops ===

  foreach i $a {
  }

Initialiases i to each value of last a in turn.

gha_language: JavaScript


text:
# Creating a Rule Converter

> If you're not familiar with this project's rule converters work, please read the [Architecture docs](./Architecture/README.md) first.

Adding a new rule converter to `tslint-to-eslint-config` is a relatively straightforward task.
For your convenience, a starter script is included that sets up the files:

```shell
node ./script/newConverter --eslint output-name --tslint input-name
```

If the lint rule includes arguments, add the `--sameArguments` flag above to have starter code generated for that as well.

```shell
node ./script/newConverter --eslint output-name --tslint input-name --sameArguments
```

If the original TSLint rule is obsolete and does not have an ESLint equivalent, you can omit `--eslint`:

```shell
node ./script/newConverter --tslint input-name
```

path: /docs/Creating a Rule Converter.md

filename: Creating a Rule Converter.md


text:
## Status
accepted

## Context
Need some way to store system state for analysis.

Postgres SQL is good for storing relational data in an optimized way.

If you can fit the entire DB in memory, reads are very fast.

JSONb support is somewhat quick and very easy for non-homogenous data types (e.g. job configurations)

You can spin up a db locally using docker.

There are decades of existing tooling and documentation to leverage with most SQL stuff.

## Decision

spin up a local postgres docker image locally

use a volume mount to ensure database state is preserved between restarts of host machine/docker.

## Consequences
### good
- cheap
- reasonably quick

### bad
- database limited in how much memory and CPU it can access

repository: cazlo/muskbot-architecture

repo_name: cazlo/muskbot-architecture


text:
+++
title = "Transfer learning from typical Alzheimer's disease to rare dementias using Disease Knowledge Transfer"
date = 2021-05-06T22:42:05-04:00  # Schedule page publish date.

# Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`.
authors = ["Razvan Marinescu"]

# Talk start and end times.
#   End time can optionally be hidden by prefixing the line with `#`.
time_start = 2021-05-07T08:00:00-04:00
#time_end = 2021-05-07T22:42:05-04:00
all_day = false

# Location of event.
location = "The Deep Dementia Phenotyping (DEMON) Network"

# Name of event and optional event URL.
event = "Demon Network Seminar"
event_url = "https://www.eventbrite.co.uk/e/machine-learning-and-disease-knowledge-transfer-tickets-153639444715"

# Abstract. What's your talk about?
abstract = "Population studies in rarer neurodegenerative diseases often suffer from limited datasets. While training sophisticated Machine Learning models on such data is difficult, transfer learning is a key potential solution. We use Disease Knowledge Transfer to infer robust multimodal biomarker trajectories in rare neurodegenerative diseases even when only limited, unimodal data is available, by transferring information from larger multimodal datasets of common neurodegenerative diseases. This allows the estimation of plausible, multimodal biomarker trajectories related to amyloid, tau, glucose metabolism and white-matter degradation in Posterior Cortical Atrophy given only unimodal MRI data."

# Summary. An optional shortened abstract.
summary = ""

# Is this a featured talk? (true/false)
featured = false

# Tags (optional).
#   Set `tags = []` for no tags, or use the form `tags = ["A Tag", "Another Tag"]` for one or more tags.
tags = []

# Markdown Slides (optional).
#   Associate this page with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references
#   `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides = ""

# Optional filename of your slides within your talk folder or a URL.
url_slides = "pres.pdf"

# Projects (optional).
#   Associate this talk with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["deep-learning"]` references
#   `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects = []

# Links (optional).
url_pdf = ""
url_video = ""
url_code = "https://github.com/razvanmarinescu/dkt"

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
[image]
  # Caption (optional)
  caption = ""

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = ""
+++

repository: razvanmarinescu/website-academic

repo_name: razvanmarinescu/website-academic


text:
discourse-facebook-auto-publish
===

## Notes

A specially developed daemon for publish discourse articles to the facebook group.

## Usage

- Install dependency

```console
$ npm insatll
```

- Start daemon
	- It has a pre-process to get the Facebook token.

```console
$ npm start
```

- Stop daemon

```console
$ npm stop
```

## Configuration

- You need the Facebook app.
	- [https://developers.facebook.com/apps/](https://developers.facebook.com/apps/)
	- This app will only be used by you, so you can use it while under `development` status.

- need to copy `.env_sample` to `.env` and change it.

```javascript
DISCOURSE_URL=https://jsdev.kr
FACEBOOK_APP_ID=
FACEBOOK_SECRET=
FACEBOOK_GROUP_ID=
POLLING_INTERVAL_SEC=60
POSTED_AFTER_MIN=5
```

- `DISCOURSE_URL` should not end with `/`.
- To find `FACEBOOK_GROUP_ID`, run `/me` to get `user-id` and run `/{user-id}/groups` in the graph API explorer.
	- [https://developers.facebook.com/tools/explorer](https://developers.facebook.com/tools/explorer)

## Running on Docker or Container Service

- If you want running on `Docker` or `Heroku`, need to provide `process.env.FACEBOOK_ACCESS_TOKEN`
	- To get `FACEBOOK_ACCESS_TOKEN`, open this url and get accessToken : https://developers.facebook.com/tools/explorer/{FACEBOOK_APP_ID}'
	- Type  : `User Access Token`, Scope : `publish_to_groups`

```console
$ npm run start-docker
```

## To do

- Post to other facebook groups by category.
- Posting the same post to multiple groups.

## Caution

- Facebook can block or audit your account.

## License

MIT License


text:
---
sidebar_position: 1
---

# Keepers

:::note Synopsis
`Keeper`s refer to a Cosmos SDK abstraction whose role is to manage access to the subset of the state defined by various modules. `Keeper`s are module-specific, i.e. the subset of state defined by a module can only be accessed by a `keeper` defined in said module. If a module needs to access the subset of state defined by another module, a reference to the second module's internal `keeper` needs to be passed to the first one. This is done in `app.go` during the instantiation of module keepers.
:::

:::note Pre-requisite Readings

* [Introduction to Cosmos SDK Modules](./01-intro.md)

:::

## Motivation

The Cosmos SDK is a framework that makes it easy for developers to build complex decentralized applications from scratch, mainly by composing modules together. As the ecosystem of open-source modules for the Cosmos SDK expands, it will become increasingly likely that some of these modules contain vulnerabilities, as a result of the negligence or malice of their developer.

The Cosmos SDK adopts an [object-capabilities-based approach](../core/10-ocap.md) to help developers better protect their application from unwanted inter-module interactions, and `keeper`s are at the core of this approach. A `keeper` can be considered quite literally to be the gatekeeper of a module's store(s). Each store (typically an [`IAVL` Store](../core/04-store.md#iavl-store)) defined within a module comes with a `storeKey`, which grants unlimited access to it. The module's `keeper` holds this `storeKey` (which should otherwise remain unexposed), and defines [methods](#implementing-methods) for reading and writing to the store(s).

The core idea behind the object-capabilities approach is to only reveal what is necessary to get the work done. In practice, this means that instead of handling permissions of modules through access-control lists, module `keeper`s are passed a reference to the specific instance of the other modules' `keeper`s that they need to access (this is done in the [application's constructor function](../basics/00-app-anatomy.md#constructor-function)). As a consequence, a module can only interact with the subset of state defined in another module via the methods exposed by the instance of the other module's `keeper`. This is a great way for developers to control the interactions that their own module can have with modules developed by external developers.

## Type Definition

`keeper`s are generally implemented in a `/keeper/keeper.go` file located in the module's folder. By convention, the type `keeper` of a module is simply named `Keeper` and usually follows the following structure:

```go
type Keeper struct {
    // External keepers, if any

    // Store key(s)

    // codec

    // authority
}
```

For example, here is the type definition of the `keeper` from the `staking` module:

```go reference
https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/x/staking/keeper/keeper.go#L23-L31
```

Let us go through the different parameters:

* An expected `keeper` is a `keeper` external to a module that is required by the internal `keeper` of said module. External `keeper`s are listed in the internal `keeper`'s type definition as interfaces. These interfaces are themselves defined in an `expected_keepers.go` file in the root of the module's folder. In this context, interfaces are used to reduce the number of dependencies, as well as to facilitate the maintenance of the module itself.
* `storeKey`s grant access to the store(s) of the [multistore](../core/04-store.md) managed by the module. They should always remain unexposed to external modules.
* `cdc` is the [codec](../core/05-encoding.md) used to marshall and unmarshall structs to/from `[]byte`. The `cdc` can be any of `codec.BinaryCodec`, `codec.JSONCodec` or `codec.Codec` based on your requirements. It can be either a proto or amino codec as long as they implement these interfaces.
* The authority listed is a module account or user account that has the right to change module level parameters. Previously this was handled by the param module, which has been deprecated.

Of course, it is possible to define different types of internal `keeper`s for the same module (e.g. a read-only `keeper`). Each type of `keeper` comes with its own constructor function, which is called from the [application's constructor function](../basics/00-app-anatomy.md). This is where `keeper`s are instantiated, and where developers make sure to pass correct instances of modules' `keeper`s to other modules that require them.

## Implementing Methods

`Keeper`s primarily expose getter and setter methods for the store(s) managed by their module. These methods should remain as simple as possible and strictly be limited to getting or setting the requested value, as validity checks should have already been performed by the [`Msg` server](./03-msg-services.md) when `keeper`s' methods are called.

Typically, a *getter* method will have the following signature

```go
func (k Keeper) Get(ctx context.Context, key string) returnType
```

and the method will go through the following steps:

1. Retrieve the appropriate store from the `ctx` using the `storeKey`. This is done through the `KVStore(storeKey sdk.StoreKey)` method of the `ctx`. Then it's preferred to use the `prefix.Store` to access only the desired limited subset of the store for convenience and safety.
2. If it exists, get the `[]byte` value stored at location `[]byte(key)` using the `Get(key []byte)` method of the store.
3. Unmarshall the retrieved value from `[]byte` to `returnType` using the codec `cdc`. Return the value.

Similarly, a *setter* method will have the following signature

```go
func (k Keeper) Set(ctx context.Context, key string, value valueType)
```

and the method will go through the following steps:

1. Retrieve the appropriate store from the `ctx` using the `storeKey`. This is done through the `KVStore(storeKey sdk.StoreKey)` method of the `ctx`. It's preferred to use the `prefix.Store` to access only the desired limited subset of the store for convenience and safety.
2. Marshal `value` to `[]byte` using the codec `cdc`.
3. Set the encoded value in the store at location `key` using the `Set(key []byte, value []byte)` method of the store.

For more, see an example of `keeper`'s [methods implementation from the `staking` module](https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/x/staking/keeper/keeper.go).

The [module `KVStore`](../core/04-store.md#kvstore-and-commitkvstore-interfaces) also provides an `Iterator()` method which returns an `Iterator` object to iterate over a domain of keys.

This is an example from the `auth` module to iterate accounts:

```go reference
https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-alpha.0/x/auth/keeper/account.go
```

repository: cosmos/cosmos-sdk

gha_language: Go

repo_name: cosmos/cosmos-sdk


text:
# Project Flogo

Project Flogo is an Open Source Framework for IoT Edge Apps & Integration.

Highlights include:
* Ultra-light process engine - 20x-50x lighter than Java or NodeRed
* Extensible & reusable by design to build your own apps, frameworks & platforms
* 100% Open Source

Project Flogo consists of the following sub-projects available as separate repos:
* [flogo-cli](https://github.com/TIBCOSoftware/flogo-cli): A command line tool to build flogo apps
* [flogo-lib](https://github.com/TIBCOSoftware/flogo-lib): A library to build Flogo extensions
* [flogo-services](https://github.com/TIBCOSoftware/flogo-services): Backing services required by Flogo
* [flogo-contrib](https://github.com/TIBCOSoftware/flogo-contrib) : Flogo Extensions available out of the box

## Getting Started

**IMPORTANT**: Project Flogo is currently in Developer Preview and primarily addresses the needs of
- Flogo Extensions developers
- IoT Solutions Developers

In other words, currently it is for developers, by developers.

As Project Flogo develops and matures, we are considering adding more integration tooling and developing zero-code experiences and services for end users based on Project Flogo. If you are an end user or a traditional zero-code integration app developer, we would recommend to check out the videos and sign up for updates on the project to see when it's ready for you to get started.

If you are an Extensions or IoT Solutions developer, read on because it's easy to get started with Project Flogo:
* To install just the Flogo CLI and runtime, go to https://github.com/TIBCOSoftware/flogo-cli & follow instructions in the README
* For extensions developers, visit the docs in this repository to get started with developing your first Flogo activity

## Roadmap
Refer to [Flogo Statement of Direction](sod.md) for an overview of the strategic dircetion of the project. You can also monitor [milestones](https://github.com/TIBCOSoftware/flogo/milestones) to see what's coming up.

## Contributing
Contact<EMAIL_ADDRESS>to learn about contributing to the project.

## License
The top level flogo repo, consisting of flow samples & documentation, is licensed under the [TIBCO Samples Internal End User License](http://www.tibco.com/assets/bltaa3b690244486fc9/tibco-samples-with-redistribution-eula.pdf). See TIBCO Samples Internal End User License.txt for license text.

Flogo source code in [flogo-cli](https://github.com/TIBCOSoftware/flogo-cli), [flogo-lib](https://github.com/TIBCOSoftware/flogo-lib), [flgo-contrib](https://github.com/TIBCOSoftware/flogo-contrib) & [flogo-services](https://github.com/TIBCOSoftware/flogo-services) repos are licensed under a BSD-style license. Refer to [flogo-cli license](https://github.com/TIBCOSoftware/flogo-cli/blob/master/TIBCO%20LICENSE.txt) for license text.

repository: AlgoSkyNet/flogo

repo_name: AlgoSkyNet/flogo


text:
Derisking geological carbon storage from high-resolution time-lapse seismic to explainable leakage detection

[![][license-img]][license-status] [![][zenodo-img]][zenodo-status]

Code to reproduce results in Ziyi Yin, Huseyin Tuna Erdinc, Abhinav Prakash Gahlot, Mathias Louboutin, Felix J. Herrmann, "[Derisking geological carbon storage from high-resolution time-lapse seismic to explainable leakage detection](https://arxiv.org/abs/2211.03527)". In The Leading Edge in January 2023. DOI: [10.1190/tle42010069.1](https://doi.org/10.1190/tle42010069.1)

## Installation

First, install [Julia](https://julialang.org/), [Python](https://www.python.org/) and [MiniConda](https://docs.conda.io/en/latest/miniconda.html). Next, run the command below to install the required packages.

```bash
julia -e 'Pkg.add("DrWatson.jl")'
julia --project -e 'using Pkg; Pkg.instantiate()'
conda env create -f environment.yml
source activate gcs-cam
python -m ipykernel install --user --name gcs-cam --display-name "Python (gcs-cam)"
```

## Script descriptions

We use the open-source software [JUDI.jl](https://github.com/slimgroup/JUDI.jl) for seismic modeling and imaging, which calls the highly optimized propagators of [Devito](https://www.devitoproject.org/). We used [FwiFlow.jl](https://github.com/lidongzh/FwiFlow.jl) to solve the two-phase flow equations for both the pressure and concentration. The CO2 plume dataset (consisting of regular plumes and leaking plumes) will be downloaded upon running your first example. We used [PyTorch library for CAM methods](https://github.com/jacobgil/pytorch-grad-cam) to calculate the CAM images. We thank the authors of these packages for their contributions to the open-source software community.

### time-lapse seismic modeling and imaging

`GenLinData.jl`: script to generate time-lapse linearized data via Born modeling operators.

`RTM.jl`: script to run reverse-time migration (RTM) on the linearized data.

`JRM.jl`: script to invert the time-lapse linearized data via joint recovery model (JRM).

The experimental setup (number of sources, receivers, amount of noise etc) can be adjusted according to [input keywords](src/utils.jl).

To generate a dataset for training the deep neural classifier, we provide the clusterless version of the above 3 scripts --- where you can simply run the julia scripts locally and experiments can run on multiple instances in parallel on the cloud. This needs 3 files for registry, credential, and parameter information to be stored in `registryinfo.json`, `credentials.json`, `params.json` files. More information can be found in [AzureClusterlessHPC.jl](https://github.com/microsoft/AzureClusterlessHPC.jl) and [JUDI4Cloud.jl](https://github.com/slimgroup/JUDI4Cloud.jl).

### leakage detection with deep neural classifier and class activation mapping

To train the deep neural classifier for leakage detection, open `main.ipynb` notebook and choose `gcs-cam` environment as the kernel. It internally uses `train.py` and `test.py` modules for training and testing. The notebook contains useful comments for each section.

## LICENSE

The software used in this repository can be modified and redistributed according to [MIT license](LICENSE).

## Disclosure

Some comments in the scripts are generated by ChatGPT 4.

## Reference

If you use our software for your research, we appreciate it if you cite us following the bibtex in [CITATION.bib](CITATION.bib).

## Authors

This repository is written by Ziyi Yin, Huseyin Tuna Erdinc, Abhinav Prakash Gahlot from the [Seismic Laboratory for Imaging and Modeling](https://slim.gatech.edu/) (SLIM) at the Georgia Institute of Technology.

If you have any question, we welcome your contributions to our software by opening issue or pull request.

SLIM Group @ Georgia Institute of Technology, [https://slim.gatech.edu](https://slim.gatech.edu/).
SLIM public GitHub account, [https://github.com/slimgroup](https://github.com/slimgroup).

[license-status]:LICENSE
[zenodo-status]:https://doi.org/10.5281/zenodo.7222318
[license-img]:http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat?style=plastic
[zenodo-img]:https://zenodo.org/badge/DOI/10.5281/zenodo.3878711.svg?style=plastic

repository: slimgroup/GCS-CAM

gha_language: Jupyter Notebook

repo_name: slimgroup/GCS-CAM


text:
# Capital budgeting

## Definition of Capital Budgeting

Capital budgeting is a process used by companies for evaluating and ranking potential [capital expenditures](https://www.accountingcoach.com/blog/what-are-capital-expenditures) or investments that are significant in amount. A few examples of capital expenditures include:

- Purchase of new equipment
- Rebuilding existing equipment
- Purchasing delivery vehicles
- Constructing additions to buildings

## Examples of Capital Budgeting Calculations

Capital budgeting usually involves the following calculations for each project:

- Future accounting profit by period
- Future cash flows by period
- [Present value](https://www.accountingcoach.com/blog/what-is-present-value) of the cash flows by discounting them with an appropriate interest rate
- The number of years it takes for a project's cash flow to pay back the initial cash investment
- An assessment of risk along with the urgency of the project

<https://www.accountingcoach.com/blog/what-is-capital-budgeting>

## Hurdle Rate / Minimum Acceptable Rate of Return (MARR)

## Definition of Hurdle Rate

In [capital budgeting](https://www.accountingcoach.com/blog/what-is-capital-budgeting), the termhurdle rateis the minimum rate that a company wants to earn when investing in a project. Therefore, the hurdle rate is also referred to as the company'srequired rate of returnortarget rate. For a company to further consider a project, its [internal rate of return](https://www.accountingcoach.com/blog/internal-rate-of-return) must equal or exceed the hurdle rate.

The hurdle rate is also used to discount a project's future cash flows to its [net present value](https://www.accountingcoach.com/blog/npv-net-present-value).

## Example of Hurdle Rate

The absolute minimum hurdle rate should be the company's [cost of capital](https://www.accountingcoach.com/blog/what-is-the-cost-of-capital)(a blend of the cost of debt and the cost of equity). However, the hurdle rate is usually larger than the cost of capital when the company has many investment opportunities and for projects that have a higher level of risk.

- Hurdle rates give companies insight into whether they should pursue a specific project.
- Riskier projects generally have a higher hurdle rate, while those with lower rates come with lower risk.
- Investors use a hurdle rate in a discounted cash flow analysis to arrive at the net present value of an investment to deem its worth.
- Companies often use their weighted average cost of capital (WACC) as the hurdle rate.

<https://www.accountingcoach.com/blog/what-is-hurdle-rate>

<https://en.wikipedia.org/wiki/Minimum_acceptable_rate_of_return>

<https://www.investopedia.com/terms/h/hurdlerate.asp>

### Negative working capital cycle

When a business collects money at a faster rate than the time required to pay its bills


text:
# Steganography Messages
Steganography messages with Python and [Steganography API](https://neatnik.net/steganographr/api/).

repository: PedroBernini/steganography

repo_name: PedroBernini/steganography


text:
---
layout: layout-basic.html
title: Theming
---

::: section header
# {{ title }}

Use our beautifully designed theme, or modify it to your needs.

:::

::: section
## Overview
Every PatternFly Element is built to automatically utilize the colors, fonts, spacing, and more defined in the [palette](/theming/palette), which you control! Generally speaking, the only thing you will need to do is re-define some of the CSS variables to match your brand and you’re done.

For this purpose, we've created a palette of CSS custom properties for you to override with your preferences on typography, color, spacing and more. Many of the components have basic theming options such as `type` or `variant` which will utilize these colors in some way. But beyond that, you may also apply a `color` attribute if you choose to add further customizations to individual components.

[Learn more about color theory](/theming/colors/#color-theory)

## Context

In addition, each "content" component comes equipped to adjust its colors depending on where its placed on the page. For example, should you need to put a default call-to-action link (which is a blue) on a dark blue card, the color of the text will need to adapt. This happens via a behind-the-scenes custom property and attribute combo, which inform the component of the current context (on a saturated background) by giving the on attribute the value of saturated.

  <pfe-card class="pfe-l-grid__item pfe-m-3-col pfe-m-6-col" color="complement">
    <pfe-cta>
      Default
    </pfe-cta>
  </pfe-card>

```html
<pfe-card color="complement">
  <pfe-cta>
    <a href="#">Default</a>
  </pfe-cta>
</pfe-card>
```
[Learn more about color context](/theming/colors/#contextually-aware-content)

## Combining attributes

Should you have custom theming needs for a particular use case, you may set individual CTAs to both a priority level to change the style and also apply a particular color from the palette. For example, you can pass a value of `complement` into the `color` attribute like this:

<pfe-cta priority="primary" color="complement">
  Primary
</pfe-cta>

```html
<pfe-cta priority="primary" color="complement">
  <a href="#">Primary</a>
</pfe-cta>
```

Please note that if you are opting to override colors of components, they will not automatically respond to the theme context.

## Typography classes

Coming soon.

:::

repository: Homa/patternfly-elements

gha_language: HTML

repo_name: Homa/patternfly-elements


text:
# Navigate Edits History - Goto Last Edit

## vscode-edits-history

A Visual Studio Extension that provides the ability to quickly navigate back and forth between recently made edits

## Features

Set whatever key commands you wish to navigate backwards and forwards through your history of edits (any of the recently typed code). Designed after the similar feature provided by IntelliJ based IDEs. This is really useful for quickly moving between multiple files and edit points to code faster without having to use the mouse or arrow keys.

- Quick access back and forth between edits
- Works across multiple files
- Retails edit history after file renaming

![Extension Example](demo.gif)

## Requirements

<EMAIL_ADDRESS>
## Extension Settings

This extension contributes the following customizable Keyboard Shortcuts:

| Command                                               | Description                                                            | Mac         | Win          |
| ----------------------------------------------------- |:---------------------------------------------------------------------- | :-----------| :----------- |
| `editsHistory.moveCursorToPreviousEdit`               | Move To Previous Edit                                                  | cmd+j       | ctrl+-       |
| `editsHistory.moveCursorToNextEdit`                   | Move To Next Edit                                                      | cmd+k       | ctrl+=       |
| `editsHistory.moveCursorToPreviouslyEditedFile`       | Move To Previous File Edited                                           | cmd+shift+j | ctrl+shift+- |
| `editsHistory.moveCursorToNextEditedFile`             | Move To Next File Edited                                               | cmd+shift+k | ctrl+shift+= |
| `editsHistory.moveCursorToPreviousEditInSameFile`     | Move To Last Edit In Current File                                      | cmd+shift+u | ctrl+shift+u |
| `editsHistory.moveCursorToNextEditInSameFile`         | Move To Next Edit In Current File                                      | cmd+shift+i | ctrl+shift+i |
| `editsHistory.createEditAtCursor`                     | Create edit on current cursor position (add marker to current line)    | cmd+u       | ctrl+u       |
| `editsHistory.removeEditsFromLine`                    | Remove any edits on the current line (remove marker from current line) | cmd+i       | ctrl+i       |

This extension contributes the following settings:

- `editsHistory.maxHistory`: Moves the cursor forward in the history of edits __(default: 10)__
- `editsHistory.showInformationMessages`: Displays a message when moving through the edit history __(default: false)__
- `editsHistory.loopAround`: Loop back to the start of your history once the end is reached __(default: false)__
- `editsHistory.centerEditInEditor`: Centers the edit in the editor when navigating between edits __(default: true)__

## Known Issues

None currently known of

## Release Notes

See [CHANGELOG.md](CHANGELOG.md)

---------------------------------------------------------------------------------------

### More Visual Studio Code Extensions by `mishkinf`

#### [Visual Studio Code Goto Next/Previous Member](https://github.com/mishkinf/vscode-goto-next-previous-member)

  Visual Studio Code Extenion to navigate through the functions, variables, and classes using quick and easy keycommands similar to functionality provided by IntelliJ IDE's (next/previous function)or Resharper (next/previous member)

**Enjoy!**

## License

MIT

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: mishkinf/vscode-edits-history

repo_name: mishkinf/vscode-edits-history


text:
---
layout: default
title: "Terms of Service"
---

## Preamble:

These are my Terms of Service which are applied to every project and contract I, Anselm Hannemann, have signed.
If you search for my [legal information, find it here](/legal/).

## Notice

<s>Terms of Service are currently only available in German. Find the [Allgemeine Geschäftsbedingungen](http://anselm-hannemann.com/agb.pdf) here.</s>


text:
# @monots/next-plugin

## 0.5.0

> 2022-05-30

### Minor Changes

- ecbcdf7: Add support for `esbuild-register` and use new platform extensions `.$node`, `.$browser`.

## 0.4.5

> 2022-05-27

### Patch Changes

- b807c2f: Update packages and refactor some internal code.

## 0.4.4

> 2022-04-15

### Patch Changes

- [`25a171e`](https://github.com/monots/monots/commit/25a171e9ce6cf0131807345d862be296adc22309) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Minor updates to external dependencies.

## 0.4.3

> 2022-04-07

### Patch Changes

- [`02e7fac`](https://github.com/monots/monots/commit/02e7fac77eb0e0c441efc8adb7b2ec05d5f34fb4) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Update external dependency versions.

## 0.4.2

> 2022-02-26

### Patch Changes

- [`907b281`](https://github.com/monots/monots/commit/907b281ed4f4eb44c19a5a9ec3fc6c8be137d6a2) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Update external dependencies.

## 0.4.1

> 2022-02-15

### Patch Changes

- [`f67dc68`](https://github.com/monots/monots/commit/f67dc686da9adfecddfdf767563110c226ce2e66) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Update dependencies.

## 0.4.0

> 2022-01-28

### Minor Changes

- [`2eafd64`](https://github.com/monots/monots/commit/2eafd640cd48da332e26add232004c729daadf37) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Add support for breaking changes in `<EMAIL_ADDRESS>
## 0.3.0

> 2022-01-25

### Minor Changes

- [`26257f2`](https://github.com/monots/monots/commit/26257f2a59d3cf70896b83390c550266a7fc0345) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Add support for **browser-only** and **node-only** imports to the webpack configuration of the next.js plugin.

## 0.2.1

> 2022-01-24

### Patch Changes

- [`49ea37b`](https://github.com/monots/monots/commit/49ea37b4331dcad6ed9293e3bdf3ce8bd33b28c9) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Fix publishing issue with `<EMAIL_ADDRESS>due to the version already being published to npm several months ago.

## 0.2.0

> 2022-01-24

### Minor Changes

- [`9b03778`](https://github.com/monots/monots/commit/9b0377806adbd448080ac02e7b995074d40a9ae7) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Massively improve and simplify the NextJS plugin.

## 0.1.2

> 2022-01-22

### Patch Changes

- [`5cec9ee`](https://github.com/monots/monots/commit/5cec9ee12b75c8c470ca34ce217402a71c520b77) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Patch updates to dependencies.

## 0.1.1

> 2021-11-15

### Patch Changes

- [#25](https://github.com/monots/monots/pull/25) [`1181e6e`](https://github.com/monots/monots/commit/1181e6e867c50b3b912ac6fe5131ea60361e3ea5) Thanks [@ifiokjr](https://github.com/ifiokjr)! - `patch` and `minor` updates to external dependencies.

## 0.1.0

> 2021-11-01

### Minor Changes

- [#14](https://github.com/monots/monots/pull/14) [`a4fb71d`](https://github.com/monots/monots/commit/a4fb71d409367c1c80df8e8a7ba5bbfbd0826418) Thanks [@ifiokjr](https://github.com/ifiokjr)! - Add support for `next@12`.

- [`f2ee1ce`](https://github.com/monots/monots/commit/f2ee1cea9c69bfdf6f57b4ab56bbc96d9791b95e) Thanks [@ifiokjr](https://github.com/ifiokjr)! - New package `@monots/next-plugin` which is a [Next.js](https://nextjs.org/) plugin for transpiling the workspaces packages.

repository: monots/monots

repo_name: monots/monots


text:
# Guess-the-output
This repository contains tricky questions from various sources to guess the output. Also explaination for the solution is also provided.

## How to contribute to this repository

* Fork this repository (Click the Fork button in the top right of this page, click your Profile Image)
* Clone your fork down to your local machine

```markdown
git clone https://github.com/Yuvrajchandra/Guess-the-output.git
```

* Create a branch

```markdown
git checkout -b branch-name
```

* Make your changes (There are some folders for different category so upload the file accordingly)
* Commit and push

```markdown
git add .
git commit -m 'Commit message'
git push origin branch-name
```
or
* Add the file in the forked repository using upload file option then commit the changes in a new branch.

* Create a new pull request from your forked repository (Click the `New Pull Request` button located at the top of your repo)
* Wait for your PR review and merge approval!

If you are still facing any problem follow steps given in this [website](https://thenewstack.io/getting-legit-with-git-and-github-your-first-pull-request/)

repository: Yuvrajchandra/Guess-the-output

repo_name: Yuvrajchandra/Guess-the-output


text:
# Factory Method Design Pattern

## What is the Factory Method Design Pattern?

https://en.wikipedia.org/wiki/Factory_method_pattern

The factory method design pattern is a class creational design pattern that defines the interface for creating an object, but lets the subclass decide which class to instantiate.

For this design pattern, the main part is the abstract Creator interface that is implemented by all of the concrete creators. The abstract Creator class declares the factory method which returns a Product class, and the concrete creators have to decide what subclass is being returned.

## When Would You Want To Use It?

* When a class does not know ahead of time what the class of objects it must create.

* When a class wants its subclasses to specify which object is being created.

## Example Diagram

Below is a diagram of the structure of the Factory Method Design Pattern in the code example.

![Factory Method](src/main/resources/diagrams/FactoryMethodDesignPattern.png?raw=true "Factory Method Example")

repository: JahnelGroup/design-patterns

repo_name: JahnelGroup/design-patterns