Search is not available for this dataset
text stringlengths 75 104k |
|---|
def members(group_id):
"""List user group members."""
page = request.args.get('page', 1, type=int)
per_page = request.args.get('per_page', 5, type=int)
q = request.args.get('q', '')
s = request.args.get('s', '')
group = Group.query.get_or_404(group_id)
if group.can_see_members(current_user)... |
def leave(group_id):
"""Leave group."""
group = Group.query.get_or_404(group_id)
if group.can_leave(current_user):
try:
group.remove_member(current_user)
except Exception as e:
flash(str(e), "error")
return redirect(url_for('.index'))
flash(
... |
def approve(group_id, user_id):
"""Approve a user."""
membership = Membership.query.get_or_404((user_id, group_id))
group = membership.group
if group.can_edit(current_user):
try:
membership.accept()
except Exception as e:
flash(str(e), 'error')
return... |
def remove(group_id, user_id):
"""Remove user from a group."""
group = Group.query.get_or_404(group_id)
user = User.query.get_or_404(user_id)
if group.can_edit(current_user):
try:
group.remove_member(user)
except Exception as e:
flash(str(e), "error")
... |
def accept(group_id):
"""Accpet pending invitation."""
membership = Membership.query.get_or_404((current_user.get_id(), group_id))
# no permission check, because they are checked during Memberships creating
try:
membership.accept()
except Exception as e:
flash(str(e), 'error')
... |
def new_member(group_id):
"""Add (invite) new member."""
group = Group.query.get_or_404(group_id)
if group.can_invite_others(current_user):
form = NewMemberForm()
if form.validate_on_submit():
emails = filter(None, form.data['emails'].splitlines())
group.invite_by_e... |
def locate_spheres(image, feature_rad, dofilter=False, order=(3 ,3, 3),
trim_edge=True, **kwargs):
"""
Get an initial featuring of sphere positions in an image.
Parameters
-----------
image : :class:`peri.util.Image` object
Image object which defines the image file as we... |
def get_initial_featuring(statemaker, feature_rad, actual_rad=None,
im_name=None, tile=None, invert=True, desc='', use_full_path=False,
featuring_params={}, statemaker_kwargs={}, **kwargs):
"""
Completely optimizes a state from an image of roughly monodisperse
particles.
The user can in... |
def feature_from_pos_rad(statemaker, pos, rad, im_name=None, tile=None,
desc='', use_full_path=False, statemaker_kwargs={}, **kwargs):
"""
Gets a completely-optimized state from an image and an initial guess of
particle positions and radii.
The state is periodically saved during optimization, w... |
def optimize_from_initial(s, max_mem=1e9, invert='guess', desc='', rz_order=3,
min_rad=None, max_rad=None):
"""
Optimizes a state from an initial set of positions and radii, without
any known microscope parameters.
Parameters
----------
s : :class:`peri.states.ImageState`
... |
def translate_featuring(state_name=None, im_name=None, use_full_path=False,
**kwargs):
"""
Translates one optimized state into another image where the particles
have moved by a small amount (~1 particle radius).
Returns a completely-optimized state. The user can interactively
selects the in... |
def get_particles_featuring(feature_rad, state_name=None, im_name=None,
use_full_path=False, actual_rad=None, invert=True, featuring_params={},
**kwargs):
"""
Combines centroid featuring with the globals from a previous state.
Runs trackpy.locate on an image, sets the globals from a previou... |
def _pick_state_im_name(state_name, im_name, use_full_path=False):
"""
If state_name or im_name is None, picks them interactively through Tk,
and then sets with or without the full path.
Parameters
----------
state_name : {string, None}
The name of the state. If None, selected t... |
def _translate_particles(s, max_mem=1e9, desc='', min_rad='calc',
max_rad='calc', invert='guess', rz_order=0, do_polish=True):
"""
Workhorse for translating particles. See get_particles_featuring for docs.
"""
if desc is not None:
desc_trans = desc + 'translate-particles'
desc_bu... |
def link_zscale(st):
"""Links the state ``st`` psf zscale with the global zscale"""
# FIXME should be made more generic to other parameters and categories
psf = st.get('psf')
psf.param_dict['zscale'] = psf.param_dict['psf-zscale']
psf.params[psf.params.index('psf-zscale')] = 'zscale'
psf.global_... |
def finish_state(st, desc='finish-state', invert='guess'):
"""
Final optimization for the best-possible state.
Runs a local add-subtract to capture any difficult-to-feature particles,
then does another set of optimization designed to get to the best
possible fit.
Parameters
----------
... |
def optimize_particle(state, index, method='gn', doradius=True):
"""
Methods available are
gn : Gauss-Newton with JTJ (recommended)
nr : Newton-Rhaphson with hessian
if doradius, also optimize the radius.
"""
blocks = state.param_particle(index)
if not doradius:
blocks ... |
def makestate(im, pos, rad, slab=None, mem_level='hi'):
"""
Workhorse for creating & optimizing states with an initial centroid
guess.
This is an example function that works for a particular microscope. For
your own microscope, you'll need to change particulars such as the psf
type and the orde... |
def _calc_ilm_order(imshape):
"""
Calculates an ilm order based on the shape of an image. This is based on
something that works for our particular images. Your mileage will vary.
Parameters
----------
imshape : 3-element list-like
The shape of the image.
Returns
-------... |
def _check_for_inception(self, root_dict):
'''
Used to check if there is a dict in a dict
'''
for key in root_dict:
if isinstance(root_dict[key], dict):
root_dict[key] = ResponseObject(root_dict[key])
return root_dict |
def randomize_parameters(self, ptp=0.2, fourier=False, vmin=None, vmax=None):
"""
Create random parameters for this ILM that mimic experiments
as closely as possible without real assumptions.
"""
if vmin is not None and vmax is not None:
ptp = vmax - vmin
elif... |
def _barnes(self, pos):
"""Creates a barnes interpolant & calculates its values"""
b_in = self.b_in
dist = lambda x: np.sqrt(np.dot(x,x))
#we take a filter size as the max distance between the grids along
#x or y:
sz = self.npts[1]
coeffs = self.get_values(self.ba... |
def schedules(self):
'''
Returns details of the posting schedules associated with a social media
profile.
'''
url = PATHS['GET_SCHEDULES'] % self.id
self.__schedules = self.api.get(url=url)
return self.__schedules |
def schedules(self, schedules):
'''
Set the posting schedules for the specified social media profile.
'''
url = PATHS['UPDATE_SCHEDULES'] % self.id
data_format = "schedules[0][%s][]=%s&"
post_data = ""
for format_type, values in schedules.iteritems():
for value in values:
... |
def moment(p, v, order=1):
""" Calculates the moments of the probability distribution p with vector v """
if order == 1:
return (v*p).sum()
elif order == 2:
return np.sqrt( ((v**2)*p).sum() - (v*p).sum()**2 ) |
def psf_slice(self, zint, size=11, zoffset=0., getextent=False):
"""
Calculates the 3D psf at a particular z pixel height
Parameters
----------
zint : float
z pixel height in image coordinates , converted to 1/k by the
function using the slab position as ... |
def _p2k(self, v):
""" Convert from pixel to 1/k_incoming (laser_wavelength/(2\pi)) units """
return 2*np.pi*self.pxsize*v/self.param_dict['psf-laser-wavelength'] |
def _tz(self, z):
""" Transform z to real-space coordinates from tile coordinates """
return (z-self.param_dict['psf-zslab'])*self.param_dict[self.zscale] |
def measure_size_drift(self, z, size=31, zoffset=0.):
""" Returns the 'size' of the psf in each direction a particular z (px) """
drift = 0.0
for i in range(self.measurement_iterations):
psf, vec = self.psf_slice(z, size=size, zoffset=zoffset+drift)
psf = psf / psf.sum()
... |
def characterize_psf(self):
""" Get support size and drift polynomial for current set of params """
# there may be an issue with the support and characterization--
# it might be best to do the characterization with the same support
# as the calculated psf.
l,u = max(self.zrange[0... |
def _kpad(self, field, finalshape, zpad=False, norm=True):
"""
fftshift and pad the field with zeros until it has size finalshape.
if zpad is off, then no padding is put on the z direction. returns
the fourier transform of the field
"""
currshape = np.array(field.shape)
... |
def pack_args(self):
"""
Pack the parameters into the form necessary for the integration
routines above. For example, packs for calculate_linescan_psf
"""
mapper = {
'psf-kfki': 'kfki',
'psf-alpha': 'alpha',
'psf-n2n1': 'n2n1',
'ps... |
def psffunc(self, *args, **kwargs):
"""Calculates a linescan psf"""
if self.polychromatic:
func = psfcalc.calculate_polychrome_linescan_psf
else:
func = psfcalc.calculate_linescan_psf
return func(*args, **kwargs) |
def psffunc(self, x, y, z, **kwargs):
"""Calculates a pinhole psf"""
#do_pinhole?? FIXME
if self.polychromatic:
func = psfcalc.calculate_polychrome_pinhole_psf
else:
func = psfcalc.calculate_pinhole_psf
x0, y0 = [psfcalc.vec_to_halfvec(v) for v in [x,y]]
... |
def characterize_psf(self):
""" Get support size and drift polynomial for current set of params """
l,u = max(self.zrange[0], self.param_dict['psf-zslab']), self.zrange[1]
size_l, drift_l = self.measure_size_drift(l, size=self.support)
size_u, drift_u = self.measure_size_drift(u, size=s... |
def _req(self, url, method='GET', **kw):
'''Make request and convert JSON response to python objects'''
send = requests.post if method == 'POST' else requests.get
try:
r = send(
url,
headers=self._token_header(),
timeout=self.settings['... |
def get_active_bets(self, project_id=None):
'''Returns all active bets'''
url = urljoin(
self.settings['bets_url'],
'bets?state=fresh,active,accept_end&page=1&page_size=100')
if project_id is not None:
url += '&kava_project_id={}'.format(project_id)
... |
def get_bets(self, type=None, order_by=None, state=None, project_id=None,
page=None, page_size=None):
"""Return bets with given filters and ordering.
:param type: return bets only with this type.
Use None to include all (default).
:param order_by: '-last_st... |
def get_project_slug(self, bet):
'''Return slug of a project that given bet is associated with
or None if bet is not associated with any project.
'''
if bet.get('form_params'):
params = json.loads(bet['form_params'])
return params.get('project')
return Non... |
def subscribe(self, event, bet_ids):
'''Subscribe to event for given bet ids.'''
if not self._subscriptions.get(event):
self._subscriptions[event] = set()
self._subscriptions[event] = self._subscriptions[event].union(bet_ids) |
def preview(context):
"""Opens local preview of your blog website"""
config = context.obj
pelican(config, '--verbose', '--ignore-cache')
server_proc = None
os.chdir(config['OUTPUT_DIR'])
try:
try:
command = 'python -m http.server ' + str(PORT)
server_proc = run... |
def get_collection_endpoint(cls):
"""
Get the relative path to the API resource collection
If self.collection_endpoint is not set, it will default to the lowercase name of the resource class plus an "s" and the terminating "/"
:param cls: Resource class
:return: Relative path to... |
def send(self, url, http_method, **client_args):
"""
Make the actual request to the API
:param url: URL
:param http_method: The method used to make the request to the API
:param client_args: Arguments to be sent to the auth client
:return: requests' response object
... |
def get(self, resource_id):
"""
Get one single resource from the API
:param resource_id: Id of the resource to be retrieved
:return: Retrieved resource
"""
response = self.send(self.get_resource_endpoint(resource_id), "get")
try:
resource = self.resou... |
def filter(self, **search_args):
"""
Get a filtered list of resources
:param search_args: To be translated into ?arg1=value1&arg2=value2...
:return: A list of resources
"""
search_args = search_args or {}
raw_resources = []
for url, paginator_params in se... |
def create(self, **kwargs):
"""
Create a resource on the server
:params kwargs: Attributes (field names and values) of the new resource
"""
resource = self.resource_class(self.client)
resource.update_from_dict(kwargs)
resource.save(force_create=True)
retu... |
def send(self, relative_path, http_method, **requests_args):
"""
Subclasses must implement this method, that will be used to send API requests with proper auth
:param relative_path: URL path relative to self.base_url
:param http_method: HTTP method
:param requests_args: kargs to ... |
def get_response_data(self, response, parse_json=True):
"""
Get response data or throw an appropiate exception
:param response: requests response object
:param parse_json: if True, response will be parsed as JSON
:return: response data, either as json or as a regular response.con... |
def send(self, relative_path, http_method, **requests_args):
"""
Make a unauthorized request
:param relative_path: URL path relative to self.base_url
:param http_method: HTTP method
:param requests_args: kargs to be sent to requests
:return: requests' response object
... |
def write(context):
"""Starts a new article"""
config = context.obj
title = click.prompt('Title')
author = click.prompt('Author', default=config.get('DEFAULT_AUTHOR'))
slug = slugify(title)
creation_date = datetime.now()
basename = '{:%Y-%m-%d}_{}.md'.format(creation_date, slug)
meta ... |
def lint(context):
"""Looks for errors in source code of your blog"""
config = context.obj
try:
run('flake8 {dir} --exclude={exclude}'.format(
dir=config['CWD'],
exclude=','.join(EXCLUDE),
))
except SubprocessError:
context.exit(1) |
def set_real_value_class(self):
"""
value_class is initially a string with the import path to the resource class, but we need to get the actual class before doing any work
We do not expect the actual clas to be in value_class since the beginning to avoid nasty import egg-before-chicken errors
... |
def publish(context):
"""Saves changes and sends them to GitHub"""
header('Recording changes...')
run('git add -A')
header('Displaying changes...')
run('git -c color.status=always status')
if not click.confirm('\nContinue publishing'):
run('git reset HEAD --')
abort(context)
... |
def deploy(context):
"""Uploads new version of the blog website"""
config = context.obj
header('Generating HTML...')
pelican(config, '--verbose', production=True)
header('Removing unnecessary output...')
unnecessary_paths = [
'author', 'category', 'tag', 'feeds', 'tags.html',
... |
def signed_number(number, precision=2):
"""
Return the given number as a string with a sign in front of it, ie. `+` if the number is positive, `-` otherwise.
"""
prefix = '' if number <= 0 else '+'
number_str = '{}{:.{precision}f}'.format(prefix, number, precision=precision)
return number_str |
def balance(ctx):
"""
Show Zebra balance.
Like the hours balance, vacation left, etc.
"""
backend = plugins_registry.get_backends_by_class(ZebraBackend)[0]
timesheet_collection = get_timesheet_collection_for_context(ctx, None)
hours_to_be_pushed = timesheet_collection.get_hours(pushed=Fals... |
def to_zebra_params(params):
"""
Transforms the given `params` dict to values that are understood by Zebra (eg. False is represented as 'false')
"""
def to_zebra_value(value):
transform_funcs = {
bool: lambda v: 'true' if v else 'false',
}
return transform_funcs.get(... |
def show_response_messages(response_json):
"""
Show all messages in the `messages` key of the given dict.
"""
message_type_kwargs = {
'warning': {'fg': 'yellow'},
'error': {'fg': 'red'},
}
for message in response_json.get('messages', []):
click.secho(message['text'], **me... |
def update_alias_mapping(settings, alias, new_mapping):
"""
Override `alias` mapping in the user configuration file with the given `new_mapping`, which should be a tuple with
2 or 3 elements (in the form `(project_id, activity_id, role_id)`).
"""
mapping = aliases_database[alias]
new_mapping = M... |
def photos(context, path):
"""Adds images to the last article"""
config = context.obj
header('Looking for the latest article...')
article_filename = find_last_article(config['CONTENT_DIR'])
if not article_filename:
return click.secho('No articles.', fg='red')
click.echo(os.path.basenam... |
def _generate_circle(self):
"""Generates the circle.
"""
total_weight = 0
for node in self.nodes:
total_weight += self.weights.get(node, 1)
for node in self.nodes:
weight = 1
if node in self.weights:
weight = self.weights.get(... |
def get_node(self, string_key):
"""Given a string key a corresponding node in the hash ring is returned.
If the hash ring is empty, `None` is returned.
"""
pos = self.get_node_pos(string_key)
if pos is None:
return None
return self.ring[self._sorted_keys[pos]... |
def get_node_pos(self, string_key):
"""Given a string key a corresponding node in the hash ring is returned
along with it's position in the ring.
If the hash ring is empty, (`None`, `None`) is returned.
"""
if not self.ring:
return None
key = self.gen_key(st... |
def iterate_nodes(self, string_key, distinct=True):
"""Given a string key it returns the nodes as a generator that can hold the key.
The generator iterates one time through the ring
starting at the correct position.
if `distinct` is set, then the nodes returned will be unique,
... |
def gen_key(self, key):
"""Given a string key it returns a long value,
this long value represents a place on the hash ring.
md5 is currently used because it mixes well.
"""
b_key = self._hash_digest(key)
return self._hash_val(b_key, lambda x: x) |
def get_number_of_app_ports(app):
"""
Get the number of ports for the given app JSON. This roughly follows the
logic in marathon-lb for finding app IPs/ports, although we are only
interested in the quantity of ports an app should have and don't consider
the specific IPs/ports of individual tasks:
... |
def _get_networking_mode(app):
"""
Get the Marathon networking mode for the app.
"""
# Marathon 1.5+: there is a `networks` field
networks = app.get('networks')
if networks:
# Modes cannot be mixed, so assigning the last mode is fine
return networks[-1].get('mode', 'container')
... |
def _get_container_port_mappings(app):
"""
Get the ``portMappings`` field for the app container.
"""
container = app['container']
# Marathon 1.5+: container.portMappings field
port_mappings = container.get('portMappings')
# Older Marathon: container.docker.portMappings field
if port_ma... |
def sort_pem_objects(pem_objects):
"""
Given a list of pem objects, sort the objects into the private key, leaf
certificate, and list of CA certificates in the trust chain. This function
assumes that the list of pem objects will contain exactly one private key
and exactly one leaf certificate and th... |
def _cert_data_to_pem_objects(cert_data):
"""
Given a non-None response from the Vault key/value store, convert the
key/values into a list of PEM objects.
"""
pem_objects = []
for key in ['privkey', 'cert', 'chain']:
pem_objects.extend(pem.parse(cert_data[key].encode('utf-8')))
retu... |
def raise_for_not_ok_status(response):
"""
Raises a `requests.exceptions.HTTPError` if the response has a non-200
status code.
"""
if response.code != OK:
raise HTTPError('Non-200 response code (%s) for url: %s' % (
response.code, uridecode(response.request.absoluteURI)))
re... |
def _sse_content_with_protocol(response, handler, **sse_kwargs):
"""
Sometimes we need the protocol object so that we can manipulate the
underlying transport in tests.
"""
protocol = SseProtocol(handler, **sse_kwargs)
finished = protocol.when_finished()
response.deliverBody(protocol)
r... |
def sse_content(response, handler, **sse_kwargs):
"""
Callback to collect the Server-Sent Events content of a response. Callbacks
passed will receive event data.
:param response:
The response from the SSE request.
:param handler:
The handler for the SSE protocol.
"""
# An SS... |
def _request(self, failure, endpoints, *args, **kwargs):
"""
Recursively make requests to each endpoint in ``endpoints``.
"""
# We've run out of endpoints, fail
if not endpoints:
return failure
endpoint = endpoints.pop(0)
d = super(MarathonClient, sel... |
def get_json_field(self, field, **kwargs):
"""
Perform a GET request and get the contents of the JSON response.
Marathon's JSON responses tend to contain an object with a single key
which points to the actual data of the response. For example /v2/apps
returns something like {"ap... |
def _get_json_field(self, response_json, field_name):
"""
Get a JSON field from the response JSON.
:param: response_json:
The parsed JSON content of the response.
:param: field_name:
The name of the field in the JSON to get.
"""
if field_name not ... |
def get_events(self, callbacks):
"""
Attach to Marathon's event stream using Server-Sent Events (SSE).
:param callbacks:
A dict mapping event types to functions that handle the event data
"""
d = self.request(
'GET', path='/v2/events', unbuffered=True,
... |
def parse(
self,
value: str,
type_: typing.Type[typing.Any] = str,
subtype: typing.Type[typing.Any] = str,
) -> typing.Any:
"""
Parse value from string.
Convert :code:`value` to
.. code-block:: python
>>> parser = Config()
>>> ... |
def get(
self,
key: str,
default: typing.Any = UNSET,
type_: typing.Type[typing.Any] = str,
subtype: typing.Type[typing.Any] = str,
mapper: typing.Optional[typing.Callable[[object], object]] = None,
) -> typing.Any:
"""
Parse a value from an environmen... |
def _request(self, endpoint, *args, **kwargs):
"""
Perform a request to a specific endpoint. Raise an error if the status
code indicates a client or server error.
"""
kwargs['url'] = endpoint
return (super(MarathonLbClient, self).request(*args, **kwargs)
.... |
def _check_request_results(self, results):
"""
Check the result of each request that we made. If a failure occurred,
but some requests succeeded, log and count the failures. If all
requests failed, raise an error.
:return:
The list of responses, with a None value for... |
def maybe_key(pem_path):
"""
Set up a client key if one does not exist already.
https://gist.github.com/glyph/27867a478bb71d8b6046fbfb176e1a33#file-local-certs-py-L32-L50
:type pem_path: twisted.python.filepath.FilePath
:param pem_path:
The path to the certificate directory to use.
:rt... |
def maybe_key_vault(client, mount_path):
"""
Set up a client key in Vault if one does not exist already.
:param client:
The Vault API client to use.
:param mount_path:
The Vault key/value mount path to use.
:rtype: twisted.internet.defer.Deferred
"""
d = client.read_kv2('cli... |
def create_txacme_client_creator(key, reactor, url, alg=RS256):
"""
Create a creator for txacme clients to provide to the txacme service. See
``txacme.client.Client.from_url()``. We create the underlying JWSClient
with a non-persistent pool to avoid
https://github.com/mithrandi/txacme/issues/86.
... |
def generate_wildcard_pem_bytes():
"""
Generate a wildcard (subject name '*') self-signed certificate valid for
10 years.
https://cryptography.io/en/latest/x509/tutorial/#creating-a-self-signed-certificate
:return: Bytes representation of the PEM certificate data
"""
key = generate_private... |
def from_env(cls, reactor=None, env=os.environ):
"""
Create a Vault client with configuration from the environment. Supports
a limited number of the available config options:
https://www.vaultproject.io/docs/commands/index.html#environment-variables
https://github.com/hashicorp/v... |
def read(self, path, **params):
"""
Read data from Vault. Returns the JSON-decoded response.
"""
d = self.request('GET', '/v1/' + path, params=params)
return d.addCallback(self._handle_response) |
def write(self, path, **data):
"""
Write data to Vault. Returns the JSON-decoded response.
"""
d = self.request('PUT', '/v1/' + path, json=data)
return d.addCallback(self._handle_response, check_cas=True) |
def read_kv2(self, path, version=None, mount_path='secret'):
"""
Read some data from a key/value version 2 secret engine.
"""
params = {}
if version is not None:
params['version'] = version
read_path = '{}/data/{}'.format(mount_path, path)
return self... |
def create_or_update_kv2(self, path, data, cas=None, mount_path='secret'):
"""
Create or update some data in a key/value version 2 secret engine.
:raises CasError:
Raises an error if the ``cas`` value, when provided, doesn't match
Vault's version for the key.
"""... |
def get_single_header(headers, key):
"""
Get a single value for the given key out of the given set of headers.
:param twisted.web.http_headers.Headers headers:
The set of headers in which to look for the header value
:param str key:
The header key
"""
raw_headers = headers.getRa... |
def raise_for_status(response):
"""
Raises a `requests.exceptions.HTTPError` if the response did not succeed.
Adapted from the Requests library:
https://github.com/kennethreitz/requests/blob/v2.8.1/requests/models.py#L825-L837
"""
http_error_msg = ''
if 400 <= response.code < 500:
h... |
def _compose_url(self, url, kwargs):
"""
Compose a URL starting with the given URL (or self.url if that URL is
None) and using the values in kwargs.
:param str url:
The base URL to use. If None, ``self.url`` will be used instead.
:param dict kwargs:
A dic... |
def request(self, method, url=None, **kwargs):
"""
Perform a request.
:param: method:
The HTTP method to use (example is `GET`).
:param: url:
The URL to use. The default value is the URL this client was
created with (`self.url`) (example is `http://lo... |
def listen(self, reactor, endpoint_description):
"""
Run the server, i.e. start listening for requests on the given host and
port.
:param reactor: The ``IReactorTCP`` to use.
:param endpoint_description:
The Twisted description for the endpoint to listen on.
... |
def health(self, request):
""" Listens to incoming health checks from Marathon on ``/health``. """
if self.health_handler is None:
return self._no_health_handler(request)
health = self.health_handler()
response_code = OK if health.healthy else SERVICE_UNAVAILABLE
req... |
def main(reactor, argv=sys.argv[1:], env=os.environ,
acme_url=LETSENCRYPT_DIRECTORY.asText()):
"""
A tool to automatically request, renew and distribute Let's Encrypt
certificates for apps running on Marathon and served by marathon-lb.
"""
parser = argparse.ArgumentParser(
descripti... |
def parse_listen_addr(listen_addr):
"""
Parse an address of the form [ipaddress]:port into a tcp or tcp6 Twisted
endpoint description string for use with
``twisted.internet.endpoints.serverFromString``.
"""
if ':' not in listen_addr:
raise ValueError(
"'%s' does not have the ... |
def create_marathon_acme(
client_creator, cert_store, acme_email, allow_multiple_certs,
marathon_addrs, marathon_timeout, sse_timeout, mlb_addrs, group,
reactor):
"""
Create a marathon-acme instance.
:param client_creator:
The txacme client creator function.
:param cert_store:
... |
def init_storage_dir(storage_dir):
"""
Initialise the storage directory with the certificates directory and a
default wildcard self-signed certificate for HAProxy.
:return: the storage path and certs path
"""
storage_path = FilePath(storage_dir)
# Create the default wildcard certificate if... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.