hexsha stringlengths 40 40 | size int64 4 1.02M | ext stringclasses 8
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 209 | max_stars_repo_name stringlengths 5 121 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 209 | max_issues_repo_name stringlengths 5 121 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 209 | max_forks_repo_name stringlengths 5 121 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 4 1.02M | avg_line_length float64 1.07 66.1k | max_line_length int64 4 266k | alphanum_fraction float64 0.01 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
12afe41fdeb07fe6aecc175be32f5ff1a39cefdf | 99 | py | Python | web_site_kripta/__init__.py | krypta-oficial/web-site-krypta | a9b0ee3e098b4c4b89a1cad12a9d7fb04a350856 | [
"MIT"
] | 1 | 2021-10-29T22:03:07.000Z | 2021-10-29T22:03:07.000Z | web_site_kripta/__init__.py | MarianoTupa/web-site-krypta | a9b0ee3e098b4c4b89a1cad12a9d7fb04a350856 | [
"MIT"
] | null | null | null | web_site_kripta/__init__.py | MarianoTupa/web-site-krypta | a9b0ee3e098b4c4b89a1cad12a9d7fb04a350856 | [
"MIT"
] | null | null | null | """Name Space of Web Site Flask"""
from .web_site_kripta import create_app
__version__ = "0.1.0"
| 16.5 | 39 | 0.727273 |
4db561847a57784b466585eba1f8275f03eba2d3 | 787 | py | Python | 007er_pyserver/db_repository/versions/015_migration.py | Lidagou007er/lidagou007er.github.io | 25ffb8d84ad6ef9ece8ee9f458c299d06f1742f9 | [
"MIT"
] | null | null | null | 007er_pyserver/db_repository/versions/015_migration.py | Lidagou007er/lidagou007er.github.io | 25ffb8d84ad6ef9ece8ee9f458c299d06f1742f9 | [
"MIT"
] | null | null | null | 007er_pyserver/db_repository/versions/015_migration.py | Lidagou007er/lidagou007er.github.io | 25ffb8d84ad6ef9ece8ee9f458c299d06f1742f9 | [
"MIT"
] | null | null | null | from sqlalchemy import *
from migrate import *
from migrate.changeset import schema
pre_meta = MetaData()
post_meta = MetaData()
relationships = Table('relationships', post_meta,
Column('id', String(length=25), primary_key=True, nullable=False),
Column('r_content', TEXT),
)
def upgrade(migrate_engine):
# Upgrade operations go here. Don't create your own engine; bind
# migrate_engine to your metadata
pre_meta.bind = migrate_engine
post_meta.bind = migrate_engine
post_meta.tables['relationships'].columns['r_content'].create()
def downgrade(migrate_engine):
# Operations to reverse the above upgrade go here.
pre_meta.bind = migrate_engine
post_meta.bind = migrate_engine
post_meta.tables['relationships'].columns['r_content'].drop()
| 29.148148 | 70 | 0.740788 |
cbd36bb0abeda28cd442bff919a58791b4e4a5f6 | 8,033 | py | Python | pandas/tests/io/sas/test_sas7bdat.py | kpflugshaupt/pandas | c9e3883c630c48b17218e6bcc5593720c1402bf1 | [
"BSD-3-Clause"
] | 2 | 2021-04-07T13:56:06.000Z | 2021-04-12T13:45:23.000Z | pandas/tests/io/sas/test_sas7bdat.py | sanjusci/pandas | a1fee9199eba7ebf423880243936b9f1501d3d3a | [
"BSD-3-Clause"
] | null | null | null | pandas/tests/io/sas/test_sas7bdat.py | sanjusci/pandas | a1fee9199eba7ebf423880243936b9f1501d3d3a | [
"BSD-3-Clause"
] | 3 | 2018-01-08T08:40:55.000Z | 2019-10-07T02:02:40.000Z | import io
import os
import numpy as np
import pytest
from pandas.errors import EmptyDataError
import pandas.util._test_decorators as td
import pandas as pd
import pandas.util.testing as tm
# https://github.com/cython/cython/issues/1720
@pytest.mark.filterwarnings("ignore:can't resolve package:ImportWarning")
class TestSAS7BDAT(object):
@pytest.fixture(autouse=True)
def setup_method(self, datapath):
self.dirpath = datapath("io", "sas", "data")
self.data = []
self.test_ix = [list(range(1, 16)), [16]]
for j in 1, 2:
fname = os.path.join(
self.dirpath, "test_sas7bdat_{j}.csv".format(j=j))
df = pd.read_csv(fname)
epoch = pd.datetime(1960, 1, 1)
t1 = pd.to_timedelta(df["Column4"], unit='d')
df["Column4"] = epoch + t1
t2 = pd.to_timedelta(df["Column12"], unit='d')
df["Column12"] = epoch + t2
for k in range(df.shape[1]):
col = df.iloc[:, k]
if col.dtype == np.int64:
df.iloc[:, k] = df.iloc[:, k].astype(np.float64)
self.data.append(df)
def test_from_file(self):
for j in 0, 1:
df0 = self.data[j]
for k in self.test_ix[j]:
fname = os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k))
df = pd.read_sas(fname, encoding='utf-8')
tm.assert_frame_equal(df, df0)
def test_from_buffer(self):
for j in 0, 1:
df0 = self.data[j]
for k in self.test_ix[j]:
fname = os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k))
with open(fname, 'rb') as f:
byts = f.read()
buf = io.BytesIO(byts)
rdr = pd.read_sas(buf, format="sas7bdat",
iterator=True, encoding='utf-8')
df = rdr.read()
tm.assert_frame_equal(df, df0, check_exact=False)
rdr.close()
def test_from_iterator(self):
for j in 0, 1:
df0 = self.data[j]
for k in self.test_ix[j]:
fname = os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k))
rdr = pd.read_sas(fname, iterator=True, encoding='utf-8')
df = rdr.read(2)
tm.assert_frame_equal(df, df0.iloc[0:2, :])
df = rdr.read(3)
tm.assert_frame_equal(df, df0.iloc[2:5, :])
rdr.close()
@td.skip_if_no('pathlib')
def test_path_pathlib(self):
from pathlib import Path
for j in 0, 1:
df0 = self.data[j]
for k in self.test_ix[j]:
fname = Path(os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k)))
df = pd.read_sas(fname, encoding='utf-8')
tm.assert_frame_equal(df, df0)
@td.skip_if_no('py.path')
def test_path_localpath(self):
from py.path import local as LocalPath
for j in 0, 1:
df0 = self.data[j]
for k in self.test_ix[j]:
fname = LocalPath(os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k)))
df = pd.read_sas(fname, encoding='utf-8')
tm.assert_frame_equal(df, df0)
def test_iterator_loop(self):
# github #13654
for j in 0, 1:
for k in self.test_ix[j]:
for chunksize in 3, 5, 10, 11:
fname = os.path.join(
self.dirpath, "test{k}.sas7bdat".format(k=k))
rdr = pd.read_sas(fname, chunksize=10, encoding='utf-8')
y = 0
for x in rdr:
y += x.shape[0]
assert y == rdr.row_count
rdr.close()
def test_iterator_read_too_much(self):
# github #14734
k = self.test_ix[0][0]
fname = os.path.join(self.dirpath, "test{k}.sas7bdat".format(k=k))
rdr = pd.read_sas(fname, format="sas7bdat",
iterator=True, encoding='utf-8')
d1 = rdr.read(rdr.row_count + 20)
rdr.close()
rdr = pd.read_sas(fname, iterator=True, encoding="utf-8")
d2 = rdr.read(rdr.row_count + 20)
tm.assert_frame_equal(d1, d2)
rdr.close()
def test_encoding_options(datapath):
fname = datapath("io", "sas", "data", "test1.sas7bdat")
df1 = pd.read_sas(fname)
df2 = pd.read_sas(fname, encoding='utf-8')
for col in df1.columns:
try:
df1[col] = df1[col].str.decode('utf-8')
except AttributeError:
pass
tm.assert_frame_equal(df1, df2)
from pandas.io.sas.sas7bdat import SAS7BDATReader
rdr = SAS7BDATReader(fname, convert_header_text=False)
df3 = rdr.read()
rdr.close()
for x, y in zip(df1.columns, df3.columns):
assert(x == y.decode())
def test_productsales(datapath):
fname = datapath("io", "sas", "data", "productsales.sas7bdat")
df = pd.read_sas(fname, encoding='utf-8')
fname = datapath("io", "sas", "data", "productsales.csv")
df0 = pd.read_csv(fname, parse_dates=['MONTH'])
vn = ["ACTUAL", "PREDICT", "QUARTER", "YEAR"]
df0[vn] = df0[vn].astype(np.float64)
tm.assert_frame_equal(df, df0)
def test_12659(datapath):
fname = datapath("io", "sas", "data", "test_12659.sas7bdat")
df = pd.read_sas(fname)
fname = datapath("io", "sas", "data", "test_12659.csv")
df0 = pd.read_csv(fname)
df0 = df0.astype(np.float64)
tm.assert_frame_equal(df, df0)
def test_airline(datapath):
fname = datapath("io", "sas", "data", "airline.sas7bdat")
df = pd.read_sas(fname)
fname = datapath("io", "sas", "data", "airline.csv")
df0 = pd.read_csv(fname)
df0 = df0.astype(np.float64)
tm.assert_frame_equal(df, df0, check_exact=False)
def test_date_time(datapath):
# Support of different SAS date/datetime formats (PR #15871)
fname = datapath("io", "sas", "data", "datetime.sas7bdat")
df = pd.read_sas(fname)
fname = datapath("io", "sas", "data", "datetime.csv")
df0 = pd.read_csv(fname, parse_dates=['Date1', 'Date2', 'DateTime',
'DateTimeHi', 'Taiw'])
# GH 19732: Timestamps imported from sas will incur floating point errors
df.iloc[:, 3] = df.iloc[:, 3].dt.round('us')
tm.assert_frame_equal(df, df0)
def test_compact_numerical_values(datapath):
# Regression test for #21616
fname = datapath("io", "sas", "data", "cars.sas7bdat")
df = pd.read_sas(fname, encoding='latin-1')
# The two columns CYL and WGT in cars.sas7bdat have column
# width < 8 and only contain integral values.
# Test that pandas doesn't corrupt the numbers by adding
# decimals.
result = df['WGT']
expected = df['WGT'].round()
tm.assert_series_equal(result, expected, check_exact=True)
result = df['CYL']
expected = df['CYL'].round()
tm.assert_series_equal(result, expected, check_exact=True)
def test_many_columns(datapath):
# Test for looking for column information in more places (PR #22628)
fname = datapath("io", "sas", "data", "many_columns.sas7bdat")
df = pd.read_sas(fname, encoding='latin-1')
fname = datapath("io", "sas", "data", "many_columns.csv")
df0 = pd.read_csv(fname, encoding='latin-1')
tm.assert_frame_equal(df, df0)
def test_inconsistent_number_of_rows(datapath):
# Regression test for issue #16615. (PR #22628)
fname = datapath("io", "sas", "data", "load_log.sas7bdat")
df = pd.read_sas(fname, encoding='latin-1')
assert len(df) == 2097
def test_zero_variables(datapath):
# Check if the SAS file has zero variables (PR #18184)
fname = datapath("io", "sas", "data", "zero_variables.sas7bdat")
with pytest.raises(EmptyDataError):
pd.read_sas(fname)
| 36.184685 | 77 | 0.568156 |
ab80401c4ea727f42cd7c409d700a7ad6ad11017 | 24,321 | py | Python | seaborn/distributions.py | gokceneraslan/seaborn | 5034d0a23cebc5f34f6f656d4064345f4004d4ee | [
"BSD-3-Clause"
] | 2 | 2019-05-27T04:32:12.000Z | 2019-06-10T15:28:22.000Z | seaborn/distributions.py | gokceneraslan/seaborn | 5034d0a23cebc5f34f6f656d4064345f4004d4ee | [
"BSD-3-Clause"
] | null | null | null | seaborn/distributions.py | gokceneraslan/seaborn | 5034d0a23cebc5f34f6f656d4064345f4004d4ee | [
"BSD-3-Clause"
] | 1 | 2021-03-15T03:48:10.000Z | 2021-03-15T03:48:10.000Z | """Plotting functions for visualizing distributions."""
from __future__ import division
import numpy as np
from scipy import stats
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.transforms as tx
from matplotlib.collections import LineCollection
import warnings
from distutils.version import LooseVersion
from six import string_types
try:
import statsmodels.nonparametric.api as smnp
_has_statsmodels = True
except ImportError:
_has_statsmodels = False
from .utils import iqr, _kde_support
from .palettes import color_palette, light_palette, dark_palette, blend_palette
__all__ = ["distplot", "kdeplot", "rugplot"]
def _freedman_diaconis_bins(a):
"""Calculate number of hist bins using Freedman-Diaconis rule."""
# From https://stats.stackexchange.com/questions/798/
a = np.asarray(a)
if len(a) < 2:
return 1
h = 2 * iqr(a) / (len(a) ** (1 / 3))
# fall back to sqrt(a) bins if iqr is 0
if h == 0:
return int(np.sqrt(a.size))
else:
return int(np.ceil((a.max() - a.min()) / h))
def distplot(a, bins=None, hist=True, kde=True, rug=False, fit=None,
hist_kws=None, kde_kws=None, rug_kws=None, fit_kws=None,
color=None, vertical=False, norm_hist=False, axlabel=None,
label=None, ax=None):
"""Flexibly plot a univariate distribution of observations.
This function combines the matplotlib ``hist`` function (with automatic
calculation of a good default bin size) with the seaborn :func:`kdeplot`
and :func:`rugplot` functions. It can also fit ``scipy.stats``
distributions and plot the estimated PDF over the data.
Parameters
----------
a : Series, 1d-array, or list.
Observed data. If this is a Series object with a ``name`` attribute,
the name will be used to label the data axis.
bins : argument for matplotlib hist(), or None, optional
Specification of hist bins, or None to use Freedman-Diaconis rule.
hist : bool, optional
Whether to plot a (normed) histogram.
kde : bool, optional
Whether to plot a gaussian kernel density estimate.
rug : bool, optional
Whether to draw a rugplot on the support axis.
fit : random variable object, optional
An object with `fit` method, returning a tuple that can be passed to a
`pdf` method a positional arguments following an grid of values to
evaluate the pdf on.
{hist, kde, rug, fit}_kws : dictionaries, optional
Keyword arguments for underlying plotting functions.
color : matplotlib color, optional
Color to plot everything but the fitted curve in.
vertical : bool, optional
If True, observed values are on y-axis.
norm_hist : bool, optional
If True, the histogram height shows a density rather than a count.
This is implied if a KDE or fitted density is plotted.
axlabel : string, False, or None, optional
Name for the support axis label. If None, will try to get it
from a.namel if False, do not set a label.
label : string, optional
Legend label for the relevant component of the plot.
ax : matplotlib axis, optional
If provided, plot on this axis.
Returns
-------
ax : matplotlib Axes
Returns the Axes object with the plot for further tweaking.
See Also
--------
kdeplot : Show a univariate or bivariate distribution with a kernel
density estimate.
rugplot : Draw small vertical lines to show each observation in a
distribution.
Examples
--------
Show a default plot with a kernel density estimate and histogram with bin
size determined automatically with a reference rule:
.. plot::
:context: close-figs
>>> import seaborn as sns, numpy as np
>>> sns.set(); np.random.seed(0)
>>> x = np.random.randn(100)
>>> ax = sns.distplot(x)
Use Pandas objects to get an informative axis label:
.. plot::
:context: close-figs
>>> import pandas as pd
>>> x = pd.Series(x, name="x variable")
>>> ax = sns.distplot(x)
Plot the distribution with a kernel density estimate and rug plot:
.. plot::
:context: close-figs
>>> ax = sns.distplot(x, rug=True, hist=False)
Plot the distribution with a histogram and maximum likelihood gaussian
distribution fit:
.. plot::
:context: close-figs
>>> from scipy.stats import norm
>>> ax = sns.distplot(x, fit=norm, kde=False)
Plot the distribution on the vertical axis:
.. plot::
:context: close-figs
>>> ax = sns.distplot(x, vertical=True)
Change the color of all the plot elements:
.. plot::
:context: close-figs
>>> sns.set_color_codes()
>>> ax = sns.distplot(x, color="y")
Pass specific parameters to the underlying plot functions:
.. plot::
:context: close-figs
>>> ax = sns.distplot(x, rug=True, rug_kws={"color": "g"},
... kde_kws={"color": "k", "lw": 3, "label": "KDE"},
... hist_kws={"histtype": "step", "linewidth": 3,
... "alpha": 1, "color": "g"})
"""
if ax is None:
ax = plt.gca()
# Intelligently label the support axis
label_ax = bool(axlabel)
if axlabel is None and hasattr(a, "name"):
axlabel = a.name
if axlabel is not None:
label_ax = True
# Make a a 1-d array
a = np.asarray(a)
if a.ndim > 1:
a = a.squeeze()
# Decide if the hist is normed
norm_hist = norm_hist or kde or (fit is not None)
# Handle dictionary defaults
if hist_kws is None:
hist_kws = dict()
if kde_kws is None:
kde_kws = dict()
if rug_kws is None:
rug_kws = dict()
if fit_kws is None:
fit_kws = dict()
# Get the color from the current color cycle
if color is None:
if vertical:
line, = ax.plot(0, a.mean())
else:
line, = ax.plot(a.mean(), 0)
color = line.get_color()
line.remove()
# Plug the label into the right kwarg dictionary
if label is not None:
if hist:
hist_kws["label"] = label
elif kde:
kde_kws["label"] = label
elif rug:
rug_kws["label"] = label
elif fit:
fit_kws["label"] = label
if hist:
if bins is None:
bins = min(_freedman_diaconis_bins(a), 50)
hist_kws.setdefault("alpha", 0.4)
if LooseVersion(mpl.__version__) < LooseVersion("2.2"):
hist_kws.setdefault("normed", norm_hist)
else:
hist_kws.setdefault("density", norm_hist)
orientation = "horizontal" if vertical else "vertical"
hist_color = hist_kws.pop("color", color)
ax.hist(a, bins, orientation=orientation,
color=hist_color, **hist_kws)
if hist_color != color:
hist_kws["color"] = hist_color
if kde:
kde_color = kde_kws.pop("color", color)
kdeplot(a, vertical=vertical, ax=ax, color=kde_color, **kde_kws)
if kde_color != color:
kde_kws["color"] = kde_color
if rug:
rug_color = rug_kws.pop("color", color)
axis = "y" if vertical else "x"
rugplot(a, axis=axis, ax=ax, color=rug_color, **rug_kws)
if rug_color != color:
rug_kws["color"] = rug_color
if fit is not None:
def pdf(x):
return fit.pdf(x, *params)
fit_color = fit_kws.pop("color", "#282828")
gridsize = fit_kws.pop("gridsize", 200)
cut = fit_kws.pop("cut", 3)
clip = fit_kws.pop("clip", (-np.inf, np.inf))
bw = stats.gaussian_kde(a).scotts_factor() * a.std(ddof=1)
x = _kde_support(a, bw, gridsize, cut, clip)
params = fit.fit(a)
y = pdf(x)
if vertical:
x, y = y, x
ax.plot(x, y, color=fit_color, **fit_kws)
if fit_color != "#282828":
fit_kws["color"] = fit_color
if label_ax:
if vertical:
ax.set_ylabel(axlabel)
else:
ax.set_xlabel(axlabel)
return ax
def _univariate_kdeplot(data, shade, vertical, kernel, bw, gridsize, cut,
clip, legend, ax, cumulative=False, **kwargs):
"""Plot a univariate kernel density estimate on one of the axes."""
# Sort out the clipping
if clip is None:
clip = (-np.inf, np.inf)
# Calculate the KDE
if _has_statsmodels:
# Prefer using statsmodels for kernel flexibility
x, y = _statsmodels_univariate_kde(data, kernel, bw,
gridsize, cut, clip,
cumulative=cumulative)
else:
# Fall back to scipy if missing statsmodels
if kernel != "gau":
kernel = "gau"
msg = "Kernel other than `gau` requires statsmodels."
warnings.warn(msg, UserWarning)
if cumulative:
raise ImportError("Cumulative distributions are currently "
"only implemented in statsmodels. "
"Please install statsmodels.")
x, y = _scipy_univariate_kde(data, bw, gridsize, cut, clip)
# Make sure the density is nonnegative
y = np.amax(np.c_[np.zeros_like(y), y], axis=1)
# Flip the data if the plot should be on the y axis
if vertical:
x, y = y, x
# Check if a label was specified in the call
label = kwargs.pop("label", None)
# Otherwise check if the data object has a name
if label is None and hasattr(data, "name"):
label = data.name
# Decide if we're going to add a legend
legend = label is not None and legend
label = "_nolegend_" if label is None else label
# Use the active color cycle to find the plot color
facecolor = kwargs.pop("facecolor", None)
line, = ax.plot(x, y, **kwargs)
color = line.get_color()
line.remove()
kwargs.pop("color", None)
facecolor = color if facecolor is None else facecolor
# Draw the KDE plot and, optionally, shade
ax.plot(x, y, color=color, label=label, **kwargs)
shade_kws = dict(
facecolor=facecolor,
alpha=kwargs.get("alpha", 0.25),
clip_on=kwargs.get("clip_on", True),
zorder=kwargs.get("zorder", 1),
)
if shade:
if vertical:
ax.fill_betweenx(y, 0, x, **shade_kws)
else:
ax.fill_between(x, 0, y, **shade_kws)
# Set the density axis minimum to 0
if vertical:
ax.set_xlim(0, auto=None)
else:
ax.set_ylim(0, auto=None)
# Draw the legend here
handles, labels = ax.get_legend_handles_labels()
if legend and handles:
ax.legend(loc="best")
return ax
def _statsmodels_univariate_kde(data, kernel, bw, gridsize, cut, clip,
cumulative=False):
"""Compute a univariate kernel density estimate using statsmodels."""
fft = kernel == "gau"
kde = smnp.KDEUnivariate(data)
kde.fit(kernel, bw, fft, gridsize=gridsize, cut=cut, clip=clip)
if cumulative:
grid, y = kde.support, kde.cdf
else:
grid, y = kde.support, kde.density
return grid, y
def _scipy_univariate_kde(data, bw, gridsize, cut, clip):
"""Compute a univariate kernel density estimate using scipy."""
try:
kde = stats.gaussian_kde(data, bw_method=bw)
except TypeError:
kde = stats.gaussian_kde(data)
if bw != "scott": # scipy default
msg = ("Ignoring bandwidth choice, "
"please upgrade scipy to use a different bandwidth.")
warnings.warn(msg, UserWarning)
if isinstance(bw, string_types):
bw = "scotts" if bw == "scott" else bw
bw = getattr(kde, "%s_factor" % bw)() * np.std(data)
grid = _kde_support(data, bw, gridsize, cut, clip)
y = kde(grid)
return grid, y
def _bivariate_kdeplot(x, y, filled, fill_lowest,
kernel, bw, gridsize, cut, clip,
axlabel, cbar, cbar_ax, cbar_kws, ax, **kwargs):
"""Plot a joint KDE estimate as a bivariate contour plot."""
# Determine the clipping
if clip is None:
clip = [(-np.inf, np.inf), (-np.inf, np.inf)]
elif np.ndim(clip) == 1:
clip = [clip, clip]
# Calculate the KDE
if _has_statsmodels:
xx, yy, z = _statsmodels_bivariate_kde(x, y, bw, gridsize, cut, clip)
else:
xx, yy, z = _scipy_bivariate_kde(x, y, bw, gridsize, cut, clip)
# Plot the contours
n_levels = kwargs.pop("n_levels", 10)
scout, = ax.plot([], [])
default_color = scout.get_color()
scout.remove()
color = kwargs.pop("color", default_color)
cmap = kwargs.pop("cmap", None)
if cmap is None:
if filled:
cmap = light_palette(color, as_cmap=True)
else:
cmap = dark_palette(color, as_cmap=True)
if isinstance(cmap, string_types):
if cmap.endswith("_d"):
pal = ["#333333"]
pal.extend(color_palette(cmap.replace("_d", "_r"), 2))
cmap = blend_palette(pal, as_cmap=True)
else:
cmap = mpl.cm.get_cmap(cmap)
label = kwargs.pop("label", None)
kwargs["cmap"] = cmap
contour_func = ax.contourf if filled else ax.contour
cset = contour_func(xx, yy, z, n_levels, **kwargs)
if filled and not fill_lowest:
cset.collections[0].set_alpha(0)
kwargs["n_levels"] = n_levels
if cbar:
cbar_kws = {} if cbar_kws is None else cbar_kws
ax.figure.colorbar(cset, cbar_ax, ax, **cbar_kws)
# Label the axes
if hasattr(x, "name") and axlabel:
ax.set_xlabel(x.name)
if hasattr(y, "name") and axlabel:
ax.set_ylabel(y.name)
if label is not None:
legend_color = cmap(.95) if color is None else color
if filled:
ax.fill_between([], [], color=legend_color, label=label)
else:
ax.plot([], [], color=legend_color, label=label)
return ax
def _statsmodels_bivariate_kde(x, y, bw, gridsize, cut, clip):
"""Compute a bivariate kde using statsmodels."""
if isinstance(bw, string_types):
bw_func = getattr(smnp.bandwidths, "bw_" + bw)
x_bw = bw_func(x)
y_bw = bw_func(y)
bw = [x_bw, y_bw]
elif np.isscalar(bw):
bw = [bw, bw]
if isinstance(x, pd.Series):
x = x.values
if isinstance(y, pd.Series):
y = y.values
kde = smnp.KDEMultivariate([x, y], "cc", bw)
x_support = _kde_support(x, kde.bw[0], gridsize, cut, clip[0])
y_support = _kde_support(y, kde.bw[1], gridsize, cut, clip[1])
xx, yy = np.meshgrid(x_support, y_support)
z = kde.pdf([xx.ravel(), yy.ravel()]).reshape(xx.shape)
return xx, yy, z
def _scipy_bivariate_kde(x, y, bw, gridsize, cut, clip):
"""Compute a bivariate kde using scipy."""
data = np.c_[x, y]
kde = stats.gaussian_kde(data.T, bw_method=bw)
data_std = data.std(axis=0, ddof=1)
if isinstance(bw, string_types):
bw = "scotts" if bw == "scott" else bw
bw_x = getattr(kde, "%s_factor" % bw)() * data_std[0]
bw_y = getattr(kde, "%s_factor" % bw)() * data_std[1]
elif np.isscalar(bw):
bw_x, bw_y = bw, bw
else:
msg = ("Cannot specify a different bandwidth for each dimension "
"with the scipy backend. You should install statsmodels.")
raise ValueError(msg)
x_support = _kde_support(data[:, 0], bw_x, gridsize, cut, clip[0])
y_support = _kde_support(data[:, 1], bw_y, gridsize, cut, clip[1])
xx, yy = np.meshgrid(x_support, y_support)
z = kde([xx.ravel(), yy.ravel()]).reshape(xx.shape)
return xx, yy, z
def kdeplot(data, data2=None, shade=False, vertical=False, kernel="gau",
bw="scott", gridsize=100, cut=3, clip=None, legend=True,
cumulative=False, shade_lowest=True, cbar=False, cbar_ax=None,
cbar_kws=None, ax=None, **kwargs):
"""Fit and plot a univariate or bivariate kernel density estimate.
Parameters
----------
data : 1d array-like
Input data.
data2: 1d array-like, optional
Second input data. If present, a bivariate KDE will be estimated.
shade : bool, optional
If True, shade in the area under the KDE curve (or draw with filled
contours when data is bivariate).
vertical : bool, optional
If True, density is on x-axis.
kernel : {'gau' | 'cos' | 'biw' | 'epa' | 'tri' | 'triw' }, optional
Code for shape of kernel to fit with. Bivariate KDE can only use
gaussian kernel.
bw : {'scott' | 'silverman' | scalar | pair of scalars }, optional
Name of reference method to determine kernel size, scalar factor,
or scalar for each dimension of the bivariate plot. Note that the
underlying computational libraries have different interperetations
for this parameter: ``statsmodels`` uses it directly, but ``scipy``
treats it as a scaling factor for the standard deviation of the
data.
gridsize : int, optional
Number of discrete points in the evaluation grid.
cut : scalar, optional
Draw the estimate to cut * bw from the extreme data points.
clip : pair of scalars, or pair of pair of scalars, optional
Lower and upper bounds for datapoints used to fit KDE. Can provide
a pair of (low, high) bounds for bivariate plots.
legend : bool, optional
If True, add a legend or label the axes when possible.
cumulative : bool, optional
If True, draw the cumulative distribution estimated by the kde.
shade_lowest : bool, optional
If True, shade the lowest contour of a bivariate KDE plot. Not
relevant when drawing a univariate plot or when ``shade=False``.
Setting this to ``False`` can be useful when you want multiple
densities on the same Axes.
cbar : bool, optional
If True and drawing a bivariate KDE plot, add a colorbar.
cbar_ax : matplotlib axes, optional
Existing axes to draw the colorbar onto, otherwise space is taken
from the main axes.
cbar_kws : dict, optional
Keyword arguments for ``fig.colorbar()``.
ax : matplotlib axes, optional
Axes to plot on, otherwise uses current axes.
kwargs : key, value pairings
Other keyword arguments are passed to ``plt.plot()`` or
``plt.contour{f}`` depending on whether a univariate or bivariate
plot is being drawn.
Returns
-------
ax : matplotlib Axes
Axes with plot.
See Also
--------
distplot: Flexibly plot a univariate distribution of observations.
jointplot: Plot a joint dataset with bivariate and marginal distributions.
Examples
--------
Plot a basic univariate density:
.. plot::
:context: close-figs
>>> import numpy as np; np.random.seed(10)
>>> import seaborn as sns; sns.set(color_codes=True)
>>> mean, cov = [0, 2], [(1, .5), (.5, 1)]
>>> x, y = np.random.multivariate_normal(mean, cov, size=50).T
>>> ax = sns.kdeplot(x)
Shade under the density curve and use a different color:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, shade=True, color="r")
Plot a bivariate density:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, y)
Use filled contours:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, y, shade=True)
Use more contour levels and a different color palette:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, y, n_levels=30, cmap="Purples_d")
Use a narrower bandwith:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, bw=.15)
Plot the density on the vertical axis:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(y, vertical=True)
Limit the density curve within the range of the data:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, cut=0)
Add a colorbar for the contours:
.. plot::
:context: close-figs
>>> ax = sns.kdeplot(x, y, cbar=True)
Plot two shaded bivariate densities:
.. plot::
:context: close-figs
>>> iris = sns.load_dataset("iris")
>>> setosa = iris.loc[iris.species == "setosa"]
>>> virginica = iris.loc[iris.species == "virginica"]
>>> ax = sns.kdeplot(setosa.sepal_width, setosa.sepal_length,
... cmap="Reds", shade=True, shade_lowest=False)
>>> ax = sns.kdeplot(virginica.sepal_width, virginica.sepal_length,
... cmap="Blues", shade=True, shade_lowest=False)
"""
if ax is None:
ax = plt.gca()
if isinstance(data, list):
data = np.asarray(data)
if len(data) == 0:
return ax
data = data.astype(np.float64)
if data2 is not None:
if isinstance(data2, list):
data2 = np.asarray(data2)
data2 = data2.astype(np.float64)
warn = False
bivariate = False
if isinstance(data, np.ndarray) and np.ndim(data) > 1:
warn = True
bivariate = True
x, y = data.T
elif isinstance(data, pd.DataFrame) and np.ndim(data) > 1:
warn = True
bivariate = True
x = data.iloc[:, 0].values
y = data.iloc[:, 1].values
elif data2 is not None:
bivariate = True
x = data
y = data2
if warn:
warn_msg = ("Passing a 2D dataset for a bivariate plot is deprecated "
"in favor of kdeplot(x, y), and it will cause an error in "
"future versions. Please update your code.")
warnings.warn(warn_msg, UserWarning)
if bivariate and cumulative:
raise TypeError("Cumulative distribution plots are not"
"supported for bivariate distributions.")
if bivariate:
ax = _bivariate_kdeplot(x, y, shade, shade_lowest,
kernel, bw, gridsize, cut, clip, legend,
cbar, cbar_ax, cbar_kws, ax, **kwargs)
else:
ax = _univariate_kdeplot(data, shade, vertical, kernel, bw,
gridsize, cut, clip, legend, ax,
cumulative=cumulative, **kwargs)
return ax
def rugplot(a, height=.05, axis="x", ax=None, **kwargs):
"""Plot datapoints in an array as sticks on an axis.
Parameters
----------
a : vector
1D array of observations.
height : scalar, optional
Height of ticks as proportion of the axis.
axis : {'x' | 'y'}, optional
Axis to draw rugplot on.
ax : matplotlib axes, optional
Axes to draw plot into; otherwise grabs current axes.
kwargs : key, value pairings
Other keyword arguments are passed to ``LineCollection``.
Returns
-------
ax : matplotlib axes
The Axes object with the plot on it.
"""
if ax is None:
ax = plt.gca()
a = np.asarray(a)
vertical = kwargs.pop("vertical", axis == "y")
alias_map = dict(linewidth="lw", linestyle="ls", color="c")
for attr, alias in alias_map.items():
if alias in kwargs:
kwargs[attr] = kwargs.pop(alias)
kwargs.setdefault("linewidth", 1)
if vertical:
trans = tx.blended_transform_factory(ax.transAxes, ax.transData)
xy_pairs = np.column_stack([np.tile([0, height], len(a)),
np.repeat(a, 2)])
else:
trans = tx.blended_transform_factory(ax.transData, ax.transAxes)
xy_pairs = np.column_stack([np.repeat(a, 2),
np.tile([0, height], len(a))])
line_segs = xy_pairs.reshape([len(a), 2, 2])
ax.add_collection(LineCollection(line_segs, transform=trans, **kwargs))
ax.autoscale_view(scalex=not vertical, scaley=vertical)
return ax
| 32.733513 | 79 | 0.597673 |
d463205f8f34ff905fe947bfd7a2a5019e097469 | 252 | py | Python | comprehension/comprehension_v5.py | C3As/COD3R-Curso-Python | 13e778108388e290da433db991838c307750a337 | [
"MIT"
] | null | null | null | comprehension/comprehension_v5.py | C3As/COD3R-Curso-Python | 13e778108388e290da433db991838c307750a337 | [
"MIT"
] | null | null | null | comprehension/comprehension_v5.py | C3As/COD3R-Curso-Python | 13e778108388e290da433db991838c307750a337 | [
"MIT"
] | null | null | null | # { chave: valor/expressao for item in list if condicional }
dicionario = {i: i * 2 for i in range(10) if i % 2 == 0}
print(dicionario) # {0: 0, 2: 4, 4: 8, 6: 12, 8: 16}
for numero, dobro in dicionario.items():
print(f'{numero} x 2 = {dobro}')
| 31.5 | 60 | 0.607143 |
d15e97af04b4bb5044873e7c66f8acacf2700b6a | 7,050 | py | Python | tensorflow/python/keras/layers/noise.py | abhaikollara/tensorflow | 4f96df3659696990cb34d0ad07dc67843c4225a9 | [
"Apache-2.0"
] | 56 | 2018-06-21T13:47:23.000Z | 2020-05-13T09:31:47.000Z | tensorflow/python/keras/layers/noise.py | abhaikollara/tensorflow | 4f96df3659696990cb34d0ad07dc67843c4225a9 | [
"Apache-2.0"
] | 6 | 2022-01-15T07:17:47.000Z | 2022-02-14T15:28:22.000Z | tensorflow/python/keras/layers/noise.py | abhaikollara/tensorflow | 4f96df3659696990cb34d0ad07dc67843c4225a9 | [
"Apache-2.0"
] | 15 | 2018-09-06T14:18:32.000Z | 2020-05-14T06:35:30.000Z | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Layers that operate regularization via the addition of noise."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.python.keras import backend as K
from tensorflow.python.keras.engine.base_layer import Layer
from tensorflow.python.keras.utils import tf_utils
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.util.tf_export import keras_export
@keras_export('keras.layers.GaussianNoise')
class GaussianNoise(Layer):
"""Apply additive zero-centered Gaussian noise.
This is useful to mitigate overfitting
(you could see it as a form of random data augmentation).
Gaussian Noise (GS) is a natural choice as corruption process
for real valued inputs.
As it is a regularization layer, it is only active at training time.
Arguments:
stddev: Float, standard deviation of the noise distribution.
Call arguments:
inputs: Input tensor (of any rank).
training: Python boolean indicating whether the layer should behave in
training mode (adding noise) or in inference mode (doing nothing).
Input shape:
Arbitrary. Use the keyword argument `input_shape`
(tuple of integers, does not include the samples axis)
when using this layer as the first layer in a model.
Output shape:
Same shape as input.
"""
def __init__(self, stddev, **kwargs):
super(GaussianNoise, self).__init__(**kwargs)
self.supports_masking = True
self.stddev = stddev
def call(self, inputs, training=None):
def noised():
return inputs + K.random_normal(
shape=array_ops.shape(inputs),
mean=0.,
stddev=self.stddev,
dtype=inputs.dtype)
return K.in_train_phase(noised, inputs, training=training)
def get_config(self):
config = {'stddev': self.stddev}
base_config = super(GaussianNoise, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
@tf_utils.shape_type_conversion
def compute_output_shape(self, input_shape):
return input_shape
@keras_export('keras.layers.GaussianDropout')
class GaussianDropout(Layer):
"""Apply multiplicative 1-centered Gaussian noise.
As it is a regularization layer, it is only active at training time.
Arguments:
rate: Float, drop probability (as with `Dropout`).
The multiplicative noise will have
standard deviation `sqrt(rate / (1 - rate))`.
Call arguments:
inputs: Input tensor (of any rank).
training: Python boolean indicating whether the layer should behave in
training mode (adding dropout) or in inference mode (doing nothing).
Input shape:
Arbitrary. Use the keyword argument `input_shape`
(tuple of integers, does not include the samples axis)
when using this layer as the first layer in a model.
Output shape:
Same shape as input.
"""
def __init__(self, rate, **kwargs):
super(GaussianDropout, self).__init__(**kwargs)
self.supports_masking = True
self.rate = rate
def call(self, inputs, training=None):
if 0 < self.rate < 1:
def noised():
stddev = np.sqrt(self.rate / (1.0 - self.rate))
return inputs * K.random_normal(
shape=array_ops.shape(inputs),
mean=1.0,
stddev=stddev,
dtype=inputs.dtype)
return K.in_train_phase(noised, inputs, training=training)
return inputs
def get_config(self):
config = {'rate': self.rate}
base_config = super(GaussianDropout, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
@tf_utils.shape_type_conversion
def compute_output_shape(self, input_shape):
return input_shape
@keras_export('keras.layers.AlphaDropout')
class AlphaDropout(Layer):
"""Applies Alpha Dropout to the input.
Alpha Dropout is a `Dropout` that keeps mean and variance of inputs
to their original values, in order to ensure the self-normalizing property
even after this dropout.
Alpha Dropout fits well to Scaled Exponential Linear Units
by randomly setting activations to the negative saturation value.
Arguments:
rate: float, drop probability (as with `Dropout`).
The multiplicative noise will have
standard deviation `sqrt(rate / (1 - rate))`.
seed: A Python integer to use as random seed.
Call arguments:
inputs: Input tensor (of any rank).
training: Python boolean indicating whether the layer should behave in
training mode (adding dropout) or in inference mode (doing nothing).
Input shape:
Arbitrary. Use the keyword argument `input_shape`
(tuple of integers, does not include the samples axis)
when using this layer as the first layer in a model.
Output shape:
Same shape as input.
"""
def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
super(AlphaDropout, self).__init__(**kwargs)
self.rate = rate
self.noise_shape = noise_shape
self.seed = seed
self.supports_masking = True
def _get_noise_shape(self, inputs):
return self.noise_shape if self.noise_shape else array_ops.shape(inputs)
def call(self, inputs, training=None):
if 0. < self.rate < 1.:
noise_shape = self._get_noise_shape(inputs)
def dropped_inputs(inputs=inputs, rate=self.rate, seed=self.seed): # pylint: disable=missing-docstring
alpha = 1.6732632423543772848170429916717
scale = 1.0507009873554804934193349852946
alpha_p = -alpha * scale
kept_idx = math_ops.greater_equal(
K.random_uniform(noise_shape, seed=seed), rate)
kept_idx = math_ops.cast(kept_idx, K.floatx())
# Get affine transformation params
a = ((1 - rate) * (1 + rate * alpha_p**2))**-0.5
b = -a * alpha_p * rate
# Apply mask
x = inputs * kept_idx + alpha_p * (1 - kept_idx)
# Do affine transformation
return a * x + b
return K.in_train_phase(dropped_inputs, inputs, training=training)
return inputs
def get_config(self):
config = {'rate': self.rate}
base_config = super(AlphaDropout, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
@tf_utils.shape_type_conversion
def compute_output_shape(self, input_shape):
return input_shape
| 33.098592 | 109 | 0.703262 |
a666acc1669da4dae2a2ea7791726d8befbbb858 | 852 | py | Python | tests/test_loss.py | pskrunner14/neural-networks | 83d3b41ad4773ee375b8ef9bed736d7e3f2bf334 | [
"MIT"
] | 1 | 2017-10-06T05:55:06.000Z | 2017-10-06T05:55:06.000Z | tests/test_loss.py | pskrunner14/neural-networks | 83d3b41ad4773ee375b8ef9bed736d7e3f2bf334 | [
"MIT"
] | 3 | 2018-09-18T18:57:22.000Z | 2019-07-03T02:57:23.000Z | tests/test_loss.py | pskrunner14/neural-networks | 83d3b41ad4773ee375b8ef9bed736d7e3f2bf334 | [
"MIT"
] | 2 | 2017-10-06T05:55:08.000Z | 2019-01-23T10:17:33.000Z | import sys
sys.path.append('../nn/')
import unittest
import numpy as np
from loss import (
softmax_crossentropy_with_logits,
grad_softmax_crossentropy_with_logits
)
from test_util import eval_numerical_gradient
class TestLoss(unittest.TestCase):
def test_crossentropy_loss_NUMERICAL_GRADIENT_CHECK(self):
logits = np.linspace(-1, 1, 500).reshape([50, 10])
answers = np.arange(50) % 10
softmax_crossentropy_with_logits(logits, answers)
grads = grad_softmax_crossentropy_with_logits(logits, answers)
numeric_grads = eval_numerical_gradient(lambda l: softmax_crossentropy_with_logits(l, answers).mean(), logits)
self.assertTrue(np.allclose(numeric_grads, grads, rtol=1e-5, atol=0),
msg="The reference implementation has just failed. Someone has just changed the rules of math.") | 38.727273 | 118 | 0.746479 |
dd94b827d5c2757c085bb46062645d0585172025 | 681 | py | Python | task1/read-write.py | ValtteriL/ID2210 | 71de5a4ee7cb10719f11e4f3be1cc71355814168 | [
"MIT"
] | null | null | null | task1/read-write.py | ValtteriL/ID2210 | 71de5a4ee7cb10719f11e4f3be1cc71355814168 | [
"MIT"
] | null | null | null | task1/read-write.py | ValtteriL/ID2210 | 71de5a4ee7cb10719f11e4f3be1cc71355814168 | [
"MIT"
] | null | null | null | #!/usr/bin/python3
# -*- coding: utf-8 -*-
from google.cloud import storage
# Authenticate using service account credentials
client = storage.Client.from_service_account_json('/home/vleh/KTH/peer-to-peer_grids/root-boi.json')
# get our bucket
bucket = client.get_bucket('korvbukett')
# create new blob
blob = bucket.blob('test2')
# fill blob with contents of a file (this will upload the file to the cloud storage)
blob.upload_from_filename('ncat.png')
# get the blob back by the name we gave it
fetched_blob = bucket.get_blob('test2')
# download the fetched blob into file (this will download the file from the cloud storage)
fetched_blob.download_to_filename('ncat2.png')
| 29.608696 | 100 | 0.765051 |
9e1bbde5653874ebf124f254fb3ced4f2b7776b1 | 2,899 | py | Python | src/kuappi.py | jussike/kuappi | 985040dc813c023dc1577f31ca7f6744d42c91de | [
"MIT"
] | null | null | null | src/kuappi.py | jussike/kuappi | 985040dc813c023dc1577f31ca7f6744d42c91de | [
"MIT"
] | null | null | null | src/kuappi.py | jussike/kuappi | 985040dc813c023dc1577f31ca7f6744d42c91de | [
"MIT"
] | null | null | null | import logging
from threading import Event
import signal
from common import TEMP
from config import CONFIG
if 'MiTemp' == CONFIG.get('sensor'):
from sensors.mitemp import MiTemp
if 'W1Temp' == CONFIG.get('sensor'):
from sensors.w1temp import W1Temp
if 'MqttSensor' == CONFIG.get('sensor'):
from sensors.mqtt import MqttSensor
if 'NetSensor' == CONFIG.get('sensor'):
from sensors.netsensor import NetSensor
if 'FridgeDecision' == CONFIG.get('decision'):
from decisions.fridgedecision import FridgeDecision
if 'FridgeAlarmDecision' == CONFIG.get('decision'):
from decisions.fridgealarmdecision import FridgeAlarmDecision
if 'FreezerDecision' == CONFIG.get('decision'):
from decisions.freezerdecision import FreezerDecision
if 'ValloxDecision' == CONFIG.get('decision'):
from decisions.valloxdecision import ValloxDecision
if 'PassthruDecision' == CONFIG.get('decision'):
from decisions.passthrudecision import PassthruDecision
if True == CONFIG.get('use_redis'):
from storage.redis_storage import Redis
else:
from storage.null_storage import NullStorage as Redis
from controller import Controller
def setup_logging(log_file=None):
log_format = '%(asctime)s - %(levelname)s - %(message)s'
logging.basicConfig(filename=log_file,
format=log_format,
level=logging.DEBUG)
logging.info('Logging is set')
class Kuappi:
def __init__(self):
setup_logging(CONFIG.get('log_file'))
self.redis = Redis()
self.controller = Controller()
self.sensor = globals()[CONFIG.get('sensor')]()
self.decision = globals()[CONFIG.get('decision')]()
self.event = Event()
signal.signal(signal.SIGTERM, self.cleanup)
def loop(self):
logging.info('Starting main loop')
polling_freq = CONFIG.get('polling_freq', 60)
while not self.event.is_set():
try:
data = self.sensor.get_data()
if data is None:
self.event.wait(polling_freq)
continue
decision = self.decision.get_decision(data, self.controller.state)
self.controller.control(decision)
if isinstance(data, dict) and TEMP in data.keys():
logging.debug('%s %s' % (data, self.controller.state))
self.redis.add_multi((data[TEMP], 1 if self.controller.state else 0))
self.event.wait(polling_freq)
except KeyboardInterrupt:
logging.info("stopping")
self.controller.cleanup()
self.sensor.cleanup()
break
except Exception:
logging.exception("Unknown exception")
def cleanup(self, *_):
self.controller.cleanup()
self.sensor.cleanup()
self.event.set()
Kuappi().loop()
| 35.790123 | 89 | 0.639186 |
163316f54ee61104cf789737ca5f30e3b6d48274 | 5,993 | py | Python | plugins/myparser.py | otherbeast/hackers-tool-kit | 12991889db1f6843dde82e7da4b4cdfb50740da5 | [
"Apache-2.0"
] | 393 | 2019-01-21T05:52:54.000Z | 2022-03-29T06:07:04.000Z | plugins/myparser.py | urantialife/hackers-tool-kit | 34dbabf3e94825684fd1a684f522d3dc3565eb2d | [
"Apache-2.0"
] | 19 | 2019-02-22T00:49:28.000Z | 2021-12-30T20:28:59.000Z | plugins/myparser.py | urantialife/hackers-tool-kit | 34dbabf3e94825684fd1a684f522d3dc3565eb2d | [
"Apache-2.0"
] | 138 | 2019-03-15T23:22:19.000Z | 2022-03-20T17:19:09.000Z | import string
import re
class parser:
def __init__(self, results, word):
self.results = results
self.word = word
self.temp = []
def genericClean(self):
self.results = re.sub('<em>', '', self.results)
self.results = re.sub('<b>', '', self.results)
self.results = re.sub('</b>', '', self.results)
self.results = re.sub('</em>', '', self.results)
self.results = re.sub('%2f', ' ', self.results)
self.results = re.sub('%3a', ' ', self.results)
self.results = re.sub('<strong>', '', self.results)
self.results = re.sub('</strong>', '', self.results)
self.results = re.sub('<wbr>', '', self.results)
self.results = re.sub('</wbr>', '', self.results)
for e in ('>', ':', '=', '<', '/', '\\', ';', '&', '%3A', '%3D', '%3C'):
self.results = string.replace(self.results, e, ' ')
def urlClean(self):
self.results = re.sub('<em>', '', self.results)
self.results = re.sub('</em>', '', self.results)
self.results = re.sub('%2f', ' ', self.results)
self.results = re.sub('%3a', ' ', self.results)
for e in ('<', '>', ':', '=', ';', '&', '%3A', '%3D', '%3C'):
self.results = string.replace(self.results, e, ' ')
def emails(self):
self.genericClean()
reg_emails = re.compile(
# Local part is required, charset is flexible
# https://tools.ietf.org/html/rfc6531 (removed * and () as they provide FP mostly )
'[a-zA-Z0-9.\-_+#~!$&\',;=:]+' +
'@' +
'[a-zA-Z0-9.-]*' +
self.word)
self.temp = reg_emails.findall(self.results)
emails = self.unique()
return emails
def fileurls(self, file):
urls = []
reg_urls = re.compile('<a href="(.*?)"')
self.temp = reg_urls.findall(self.results)
allurls = self.unique()
for x in allurls:
if x.count('webcache') or x.count('google.com') or x.count('search?hl'):
pass
else:
urls.append(x)
return urls
def people_googleplus(self):
self.results = re.sub('</b>', '', self.results)
self.results = re.sub('<b>', '', self.results)
reg_people = re.compile('>[a-zA-Z0-9._ ]* - Google\+')
#reg_people = re.compile('">[a-zA-Z0-9._ -]* profiles | LinkedIn')
self.temp = reg_people.findall(self.results)
resul = []
for x in self.temp:
y = string.replace(x, ' | LinkedIn', '')
y = string.replace(y, ' profiles ', '')
y = string.replace(y, 'LinkedIn', '')
y = string.replace(y, '"', '')
y = string.replace(y, '>', '')
if y != " ":
resul.append(y)
return resul
def people_twitter(self):
reg_people = re.compile('(@[a-zA-Z0-9._ -]*)')
#reg_people = re.compile('">[a-zA-Z0-9._ -]* profiles | LinkedIn')
self.temp = reg_people.findall(self.results)
users = self.unique()
resul = []
for x in users:
y = string.replace(x, ' | LinkedIn', '')
y = string.replace(y, ' profiles ', '')
y = string.replace(y, 'LinkedIn', '')
y = string.replace(y, '"', '')
y = string.replace(y, '>', '')
if y != " ":
resul.append(y)
return resul
def people_linkedin(self):
reg_people = re.compile('">[a-zA-Z0-9._ -]* \| LinkedIn')
#reg_people = re.compile('">[a-zA-Z0-9._ -]* profiles | LinkedIn')
self.temp = reg_people.findall(self.results)
resul = []
for x in self.temp:
y = string.replace(x, ' | LinkedIn', '')
y = string.replace(y, ' profiles ', '')
y = string.replace(y, 'LinkedIn', '')
y = string.replace(y, '"', '')
y = string.replace(y, '>', '')
if y != " ":
resul.append(y)
return resul
def profiles(self):
reg_people = re.compile('">[a-zA-Z0-9._ -]* - <em>Google Profile</em>')
self.temp = reg_people.findall(self.results)
resul = []
for x in self.temp:
y = string.replace(x, ' <em>Google Profile</em>', '')
y = string.replace(y, '-', '')
y = string.replace(y, '">', '')
if y != " ":
resul.append(y)
return resul
def people_jigsaw(self):
res = []
#reg_people = re.compile("'tblrow' title='[a-zA-Z0-9.-]*'><span class='nowrap'/>")
reg_people = re.compile(
"href=javascript:showContact\('[0-9]*'\)>[a-zA-Z0-9., ]*</a></span>")
self.temp = reg_people.findall(self.results)
for x in self.temp:
a = x.split('>')[1].replace("</a", "")
res.append(a)
return res
def hostnames(self):
self.genericClean()
reg_hosts = re.compile('[a-zA-Z0-9.-]*\.' + self.word)
self.temp = reg_hosts.findall(self.results)
hostnames = self.unique()
return hostnames
def set(self):
reg_sets = re.compile('>[a-zA-Z0-9]*</a></font>')
self.temp = reg_sets.findall(self.results)
sets = []
for x in self.temp:
y = string.replace(x, '>', '')
y = string.replace(y, '</a</font', '')
sets.append(y)
return sets
def hostnames_all(self):
reg_hosts = re.compile('<cite>(.*?)</cite>')
temp = reg_hosts.findall(self.results)
for x in temp:
if x.count(':'):
res = x.split(':')[1].split('/')[2]
else:
res = x.split("/")[0]
self.temp.append(res)
hostnames = self.unique()
return hostnames
def unique(self):
self.new = []
for x in self.temp:
if x not in self.new:
self.new.append(x)
return self.new
| 35.886228 | 95 | 0.483064 |
6f5807567399a83cc9241d12da4463d724f19bb7 | 19,120 | py | Python | tempest/api/network/test_ports.py | KiranPawar72/tempest | 1fef3dd92b083055793065dd0693454735ec2c01 | [
"Apache-2.0"
] | null | null | null | tempest/api/network/test_ports.py | KiranPawar72/tempest | 1fef3dd92b083055793065dd0693454735ec2c01 | [
"Apache-2.0"
] | null | null | null | tempest/api/network/test_ports.py | KiranPawar72/tempest | 1fef3dd92b083055793065dd0693454735ec2c01 | [
"Apache-2.0"
] | 1 | 2020-07-21T02:18:23.000Z | 2020-07-21T02:18:23.000Z | # Copyright 2014 OpenStack Foundation
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import socket
import netaddr
from tempest.api.network import base
from tempest.api.network import base_security_groups as sec_base
from tempest.common import custom_matchers
from tempest.common.utils import data_utils
from tempest import config
from tempest import test
CONF = config.CONF
class PortsTestJSON(sec_base.BaseSecGroupTest):
"""
Test the following operations for ports:
port create
port delete
port list
port show
port update
"""
@classmethod
def resource_setup(cls):
super(PortsTestJSON, cls).resource_setup()
cls.network = cls.create_network()
cls.port = cls.create_port(cls.network)
def _delete_port(self, port_id):
self.client.delete_port(port_id)
body = self.client.list_ports()
ports_list = body['ports']
self.assertFalse(port_id in [n['id'] for n in ports_list])
@test.attr(type='smoke')
@test.idempotent_id('c72c1c0c-2193-4aca-aaa4-b1442640f51c')
def test_create_update_delete_port(self):
# Verify port creation
body = self.client.create_port(network_id=self.network['id'])
port = body['port']
# Schedule port deletion with verification upon test completion
self.addCleanup(self._delete_port, port['id'])
self.assertTrue(port['admin_state_up'])
# Verify port update
new_name = "New_Port"
body = self.client.update_port(port['id'],
name=new_name,
admin_state_up=False)
updated_port = body['port']
self.assertEqual(updated_port['name'], new_name)
self.assertFalse(updated_port['admin_state_up'])
@test.idempotent_id('67f1b811-f8db-43e2-86bd-72c074d4a42c')
def test_create_bulk_port(self):
network1 = self.network
name = data_utils.rand_name('network-')
network2 = self.create_network(network_name=name)
network_list = [network1['id'], network2['id']]
port_list = [{'network_id': net_id} for net_id in network_list]
body = self.client.create_bulk_port(port_list)
created_ports = body['ports']
port1 = created_ports[0]
port2 = created_ports[1]
self.addCleanup(self._delete_port, port1['id'])
self.addCleanup(self._delete_port, port2['id'])
self.assertEqual(port1['network_id'], network1['id'])
self.assertEqual(port2['network_id'], network2['id'])
self.assertTrue(port1['admin_state_up'])
self.assertTrue(port2['admin_state_up'])
@classmethod
def _get_ipaddress_from_tempest_conf(cls):
"""Return first subnet gateway for configured CIDR """
if cls._ip_version == 4:
cidr = netaddr.IPNetwork(CONF.network.tenant_network_cidr)
elif cls._ip_version == 6:
cidr = netaddr.IPNetwork(CONF.network.tenant_network_v6_cidr)
return netaddr.IPAddress(cidr)
@test.attr(type='smoke')
@test.idempotent_id('0435f278-40ae-48cb-a404-b8a087bc09b1')
def test_create_port_in_allowed_allocation_pools(self):
network = self.create_network()
net_id = network['id']
address = self._get_ipaddress_from_tempest_conf()
allocation_pools = {'allocation_pools': [{'start': str(address + 4),
'end': str(address + 6)}]}
subnet = self.create_subnet(network, **allocation_pools)
self.addCleanup(self.subnets_client.delete_subnet, subnet['id'])
body = self.client.create_port(network_id=net_id)
self.addCleanup(self.client.delete_port, body['port']['id'])
port = body['port']
ip_address = port['fixed_ips'][0]['ip_address']
start_ip_address = allocation_pools['allocation_pools'][0]['start']
end_ip_address = allocation_pools['allocation_pools'][0]['end']
ip_range = netaddr.IPRange(start_ip_address, end_ip_address)
self.assertIn(ip_address, ip_range)
@test.attr(type='smoke')
@test.idempotent_id('c9a685bd-e83f-499c-939f-9f7863ca259f')
def test_show_port(self):
# Verify the details of port
body = self.client.show_port(self.port['id'])
port = body['port']
self.assertIn('id', port)
# TODO(Santosh)- This is a temporary workaround to compare create_port
# and show_port dict elements.Remove this once extra_dhcp_opts issue
# gets fixed in neutron.( bug - 1365341.)
self.assertThat(self.port,
custom_matchers.MatchesDictExceptForKeys
(port, excluded_keys=['extra_dhcp_opts']))
@test.idempotent_id('45fcdaf2-dab0-4c13-ac6c-fcddfb579dbd')
def test_show_port_fields(self):
# Verify specific fields of a port
fields = ['id', 'mac_address']
body = self.client.show_port(self.port['id'],
fields=fields)
port = body['port']
self.assertEqual(sorted(port.keys()), sorted(fields))
for field_name in fields:
self.assertEqual(port[field_name], self.port[field_name])
@test.attr(type='smoke')
@test.idempotent_id('cf95b358-3e92-4a29-a148-52445e1ac50e')
def test_list_ports(self):
# Verify the port exists in the list of all ports
body = self.client.list_ports()
ports = [port['id'] for port in body['ports']
if port['id'] == self.port['id']]
self.assertNotEmpty(ports, "Created port not found in the list")
@test.idempotent_id('e7fe260b-1e79-4dd3-86d9-bec6a7959fc5')
def test_port_list_filter_by_ip(self):
# Create network and subnet
network = self.create_network()
subnet = self.create_subnet(network)
self.addCleanup(self.subnets_client.delete_subnet, subnet['id'])
# Create two ports
port_1 = self.client.create_port(network_id=network['id'])
self.addCleanup(self.client.delete_port, port_1['port']['id'])
port_2 = self.client.create_port(network_id=network['id'])
self.addCleanup(self.client.delete_port, port_2['port']['id'])
# List ports filtered by fixed_ips
port_1_fixed_ip = port_1['port']['fixed_ips'][0]['ip_address']
fixed_ips = 'ip_address=' + port_1_fixed_ip
port_list = self.client.list_ports(fixed_ips=fixed_ips)
# Check that we got the desired port
ports = port_list['ports']
tenant_ids = set([port['tenant_id'] for port in ports])
self.assertEqual(len(tenant_ids), 1,
'Ports from multiple tenants are in the list resp')
port_ids = [port['id'] for port in ports]
fixed_ips = [port['fixed_ips'] for port in ports]
port_ips = []
for addr in fixed_ips:
port_ips.extend([port['ip_address'] for port in addr])
port_net_ids = [port['network_id'] for port in ports]
self.assertIn(port_1['port']['id'], port_ids)
self.assertIn(port_1_fixed_ip, port_ips)
self.assertIn(network['id'], port_net_ids)
@test.idempotent_id('5ad01ed0-0e6e-4c5d-8194-232801b15c72')
def test_port_list_filter_by_router_id(self):
# Create a router
network = self.create_network()
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet = self.create_subnet(network)
self.addCleanup(self.subnets_client.delete_subnet, subnet['id'])
router = self.create_router(data_utils.rand_name('router-'))
self.addCleanup(self.client.delete_router, router['id'])
port = self.client.create_port(network_id=network['id'])
# Add router interface to port created above
self.client.add_router_interface_with_port_id(
router['id'], port['port']['id'])
self.addCleanup(self.client.remove_router_interface_with_port_id,
router['id'], port['port']['id'])
# List ports filtered by router_id
port_list = self.client.list_ports(device_id=router['id'])
ports = port_list['ports']
self.assertEqual(len(ports), 1)
self.assertEqual(ports[0]['id'], port['port']['id'])
self.assertEqual(ports[0]['device_id'], router['id'])
@test.idempotent_id('ff7f117f-f034-4e0e-abff-ccef05c454b4')
def test_list_ports_fields(self):
# Verify specific fields of ports
fields = ['id', 'mac_address']
body = self.client.list_ports(fields=fields)
ports = body['ports']
self.assertNotEmpty(ports, "Port list returned is empty")
# Asserting the fields returned are correct
for port in ports:
self.assertEqual(sorted(fields), sorted(port.keys()))
@test.idempotent_id('63aeadd4-3b49-427f-a3b1-19ca81f06270')
def test_create_update_port_with_second_ip(self):
# Create a network with two subnets
network = self.create_network()
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet_1 = self.create_subnet(network)
self.addCleanup(self.subnets_client.delete_subnet, subnet_1['id'])
subnet_2 = self.create_subnet(network)
self.addCleanup(self.subnets_client.delete_subnet, subnet_2['id'])
fixed_ip_1 = [{'subnet_id': subnet_1['id']}]
fixed_ip_2 = [{'subnet_id': subnet_2['id']}]
fixed_ips = fixed_ip_1 + fixed_ip_2
# Create a port with multiple IP addresses
port = self.create_port(network,
fixed_ips=fixed_ips)
self.addCleanup(self.client.delete_port, port['id'])
self.assertEqual(2, len(port['fixed_ips']))
check_fixed_ips = [subnet_1['id'], subnet_2['id']]
for item in port['fixed_ips']:
self.assertIn(item['subnet_id'], check_fixed_ips)
# Update the port to return to a single IP address
port = self.update_port(port, fixed_ips=fixed_ip_1)
self.assertEqual(1, len(port['fixed_ips']))
# Update the port with a second IP address from second subnet
port = self.update_port(port, fixed_ips=fixed_ips)
self.assertEqual(2, len(port['fixed_ips']))
def _update_port_with_security_groups(self, security_groups_names):
subnet_1 = self.create_subnet(self.network)
self.addCleanup(self.subnets_client.delete_subnet, subnet_1['id'])
fixed_ip_1 = [{'subnet_id': subnet_1['id']}]
security_groups_list = list()
for name in security_groups_names:
group_create_body = self.client.create_security_group(
name=name)
self.addCleanup(self.client.delete_security_group,
group_create_body['security_group']['id'])
security_groups_list.append(group_create_body['security_group']
['id'])
# Create a port
sec_grp_name = data_utils.rand_name('secgroup')
security_group = self.client.create_security_group(name=sec_grp_name)
self.addCleanup(self.client.delete_security_group,
security_group['security_group']['id'])
post_body = {
"name": data_utils.rand_name('port-'),
"security_groups": [security_group['security_group']['id']],
"network_id": self.network['id'],
"admin_state_up": True,
"fixed_ips": fixed_ip_1}
body = self.client.create_port(**post_body)
self.addCleanup(self.client.delete_port, body['port']['id'])
port = body['port']
# Update the port with security groups
subnet_2 = self.create_subnet(self.network)
fixed_ip_2 = [{'subnet_id': subnet_2['id']}]
update_body = {"name": data_utils.rand_name('port-'),
"admin_state_up": False,
"fixed_ips": fixed_ip_2,
"security_groups": security_groups_list}
body = self.client.update_port(port['id'], **update_body)
port_show = body['port']
# Verify the security groups and other attributes updated to port
exclude_keys = set(port_show).symmetric_difference(update_body)
exclude_keys.add('fixed_ips')
exclude_keys.add('security_groups')
self.assertThat(port_show, custom_matchers.MatchesDictExceptForKeys(
update_body, exclude_keys))
self.assertEqual(fixed_ip_2[0]['subnet_id'],
port_show['fixed_ips'][0]['subnet_id'])
for security_group in security_groups_list:
self.assertIn(security_group, port_show['security_groups'])
@test.idempotent_id('58091b66-4ff4-4cc1-a549-05d60c7acd1a')
def test_update_port_with_security_group_and_extra_attributes(self):
self._update_port_with_security_groups(
[data_utils.rand_name('secgroup')])
@test.idempotent_id('edf6766d-3d40-4621-bc6e-2521a44c257d')
def test_update_port_with_two_security_groups_and_extra_attributes(self):
self._update_port_with_security_groups(
[data_utils.rand_name('secgroup'),
data_utils.rand_name('secgroup')])
@test.idempotent_id('13e95171-6cbd-489c-9d7c-3f9c58215c18')
def test_create_show_delete_port_user_defined_mac(self):
# Create a port for a legal mac
body = self.client.create_port(network_id=self.network['id'])
old_port = body['port']
free_mac_address = old_port['mac_address']
self.client.delete_port(old_port['id'])
# Create a new port with user defined mac
body = self.client.create_port(network_id=self.network['id'],
mac_address=free_mac_address)
self.addCleanup(self.client.delete_port, body['port']['id'])
port = body['port']
body = self.client.show_port(port['id'])
show_port = body['port']
self.assertEqual(free_mac_address,
show_port['mac_address'])
@test.attr(type='smoke')
@test.idempotent_id('4179dcb9-1382-4ced-84fe-1b91c54f5735')
def test_create_port_with_no_securitygroups(self):
network = self.create_network()
self.addCleanup(self.networks_client.delete_network, network['id'])
subnet = self.create_subnet(network)
self.addCleanup(self.subnets_client.delete_subnet, subnet['id'])
port = self.create_port(network, security_groups=[])
self.addCleanup(self.client.delete_port, port['id'])
self.assertIsNotNone(port['security_groups'])
self.assertEmpty(port['security_groups'])
class PortsAdminExtendedAttrsTestJSON(base.BaseAdminNetworkTest):
@classmethod
def setup_clients(cls):
super(PortsAdminExtendedAttrsTestJSON, cls).setup_clients()
cls.identity_client = cls.os_adm.identity_client
@classmethod
def resource_setup(cls):
super(PortsAdminExtendedAttrsTestJSON, cls).resource_setup()
cls.network = cls.create_network()
cls.host_id = socket.gethostname()
@test.idempotent_id('8e8569c1-9ac7-44db-8bc1-f5fb2814f29b')
def test_create_port_binding_ext_attr(self):
post_body = {"network_id": self.network['id'],
"binding:host_id": self.host_id}
body = self.admin_client.create_port(**post_body)
port = body['port']
self.addCleanup(self.admin_client.delete_port, port['id'])
host_id = port['binding:host_id']
self.assertIsNotNone(host_id)
self.assertEqual(self.host_id, host_id)
@test.idempotent_id('6f6c412c-711f-444d-8502-0ac30fbf5dd5')
def test_update_port_binding_ext_attr(self):
post_body = {"network_id": self.network['id']}
body = self.admin_client.create_port(**post_body)
port = body['port']
self.addCleanup(self.admin_client.delete_port, port['id'])
update_body = {"binding:host_id": self.host_id}
body = self.admin_client.update_port(port['id'], **update_body)
updated_port = body['port']
host_id = updated_port['binding:host_id']
self.assertIsNotNone(host_id)
self.assertEqual(self.host_id, host_id)
@test.idempotent_id('1c82a44a-6c6e-48ff-89e1-abe7eaf8f9f8')
def test_list_ports_binding_ext_attr(self):
# Create a new port
post_body = {"network_id": self.network['id']}
body = self.admin_client.create_port(**post_body)
port = body['port']
self.addCleanup(self.admin_client.delete_port, port['id'])
# Update the port's binding attributes so that is now 'bound'
# to a host
update_body = {"binding:host_id": self.host_id}
self.admin_client.update_port(port['id'], **update_body)
# List all ports, ensure new port is part of list and its binding
# attributes are set and accurate
body = self.admin_client.list_ports()
ports_list = body['ports']
pids_list = [p['id'] for p in ports_list]
self.assertIn(port['id'], pids_list)
listed_port = [p for p in ports_list if p['id'] == port['id']]
self.assertEqual(1, len(listed_port),
'Multiple ports listed with id %s in ports listing: '
'%s' % (port['id'], ports_list))
self.assertEqual(self.host_id, listed_port[0]['binding:host_id'])
@test.idempotent_id('b54ac0ff-35fc-4c79-9ca3-c7dbd4ea4f13')
def test_show_port_binding_ext_attr(self):
body = self.admin_client.create_port(network_id=self.network['id'])
port = body['port']
self.addCleanup(self.admin_client.delete_port, port['id'])
body = self.admin_client.show_port(port['id'])
show_port = body['port']
self.assertEqual(port['binding:host_id'],
show_port['binding:host_id'])
self.assertEqual(port['binding:vif_type'],
show_port['binding:vif_type'])
self.assertEqual(port['binding:vif_details'],
show_port['binding:vif_details'])
class PortsIpV6TestJSON(PortsTestJSON):
_ip_version = 6
_tenant_network_cidr = CONF.network.tenant_network_v6_cidr
_tenant_network_mask_bits = CONF.network.tenant_network_v6_mask_bits
class PortsAdminExtendedAttrsIpV6TestJSON(PortsAdminExtendedAttrsTestJSON):
_ip_version = 6
_tenant_network_cidr = CONF.network.tenant_network_v6_cidr
_tenant_network_mask_bits = CONF.network.tenant_network_v6_mask_bits
| 44.988235 | 78 | 0.653138 |
d9549606e75173d6630072e7eff75c2d61f203d1 | 353 | py | Python | scripts/legacy_redirects/clean_up_output.py | EFM-Bobby/docs | 6ee5c8207323097793afc39d8a97f7b3b71ed0d0 | [
"Apache-2.0"
] | 10 | 2021-01-12T19:42:08.000Z | 2022-03-31T13:22:42.000Z | scripts/legacy_redirects/clean_up_output.py | EFM-Bobby/docs | 6ee5c8207323097793afc39d8a97f7b3b71ed0d0 | [
"Apache-2.0"
] | 1,120 | 2020-11-13T06:02:13.000Z | 2022-03-31T22:08:28.000Z | scripts/legacy_redirects/clean_up_output.py | EFM-Bobby/docs | 6ee5c8207323097793afc39d8a97f7b3b71ed0d0 | [
"Apache-2.0"
] | 79 | 2020-11-09T20:07:06.000Z | 2022-03-31T18:08:32.000Z | import fileinput
print('cleaning up legacy redirects')
nginx_file = 'static/nginx_redirects.generated'
for line in fileinput.input(files=[nginx_file], inplace=1):
if line.startswith('rewrite ^/docs/edb-docs/'):
print(line.strip().replace('/docs/edb-docs/', '/edb-docs/'))
print('see nginx redirects file at `static/nginx_redirects.generated`')
| 32.090909 | 71 | 0.74221 |
7c5007b55eb53c9555e06a6763e4fdd4545b45b3 | 1,273 | py | Python | apps/bookmark/migrations/0001_initial.py | coogger/coogger | 9e5e3ca172d8a14272948284a6822000b119119c | [
"MIT"
] | 48 | 2018-04-13T13:00:10.000Z | 2020-03-17T23:35:23.000Z | apps/bookmark/migrations/0001_initial.py | coogger/coogger | 9e5e3ca172d8a14272948284a6822000b119119c | [
"MIT"
] | 77 | 2018-03-25T13:17:12.000Z | 2020-08-11T08:24:49.000Z | apps/bookmark/migrations/0001_initial.py | coogger/coogger | 9e5e3ca172d8a14272948284a6822000b119119c | [
"MIT"
] | 35 | 2018-03-30T21:43:21.000Z | 2020-08-11T05:51:46.000Z | # Generated by Django 3.0.3 on 2020-02-28 13:21
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("contenttypes", "0002_remove_content_type_name"),
]
operations = [
migrations.CreateModel(
name="Bookmark",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("object_id", models.PositiveIntegerField()),
(
"content_type",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="contenttypes.ContentType",
),
),
("user", models.ManyToManyField(to=settings.AUTH_USER_MODEL)),
],
options={"unique_together": {("content_type", "object_id")},},
),
]
| 29.604651 | 78 | 0.485467 |
128a77aa1499859a5347d68c053a726888f9f6d8 | 1,651 | py | Python | tools/pinplay/scripts/dart.py | nus-comparch/looppoint | 3cac7fa1417c83c85c19ca95613b2964041211b5 | [
"AFL-1.1",
"BSD-Source-Code"
] | null | null | null | tools/pinplay/scripts/dart.py | nus-comparch/looppoint | 3cac7fa1417c83c85c19ca95613b2964041211b5 | [
"AFL-1.1",
"BSD-Source-Code"
] | null | null | null | tools/pinplay/scripts/dart.py | nus-comparch/looppoint | 3cac7fa1417c83c85c19ca95613b2964041211b5 | [
"AFL-1.1",
"BSD-Source-Code"
] | null | null | null | # BEGIN_LEGAL
# BSD License
#
# Copyright (c)2014 Intel Corporation. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer. Redistributions
# in binary form must reproduce the above copyright notice, this list of
# conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution. Neither the name of
# the Intel Corporation nor the names of its contributors may be used to
# endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
# ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# END_LEGAL
import gdb
import re
import sys
import traceback
import pin
import slicing
| 42.333333 | 72 | 0.788007 |
af93ba9c5c8eb91780dccef4fbcb24362c272e69 | 2,138 | py | Python | tests/processors/test_dispatcher.py | SuccessionEcologicalServices/eemeter-1 | dc06f42dc64679a5d56771d6900169eef4eaf515 | [
"MIT"
] | null | null | null | tests/processors/test_dispatcher.py | SuccessionEcologicalServices/eemeter-1 | dc06f42dc64679a5d56771d6900169eef4eaf515 | [
"MIT"
] | 1 | 2018-06-14T04:24:49.000Z | 2018-06-14T04:24:49.000Z | tests/processors/test_dispatcher.py | SuccessionEcologicalServices/eemeter-1 | dc06f42dc64679a5d56771d6900169eef4eaf515 | [
"MIT"
] | null | null | null | from datetime import datetime
import pytz
import pytest
import numpy as np
import pandas as pd
from eemeter.processors.dispatchers import get_energy_modeling_dispatches
from eemeter.structures import (
ModelingPeriod,
ModelingPeriodSet,
EnergyTrace,
EnergyTraceSet,
)
from eemeter.modeling.split import SplitModeledEnergyTrace
@pytest.fixture
def modeling_period_set():
modeling_period_1 = ModelingPeriod(
"BASELINE",
end_date=datetime(2000, 1, 3, tzinfo=pytz.UTC),
)
modeling_period_2 = ModelingPeriod(
"REPORTING",
start_date=datetime(2000, 1, 3, tzinfo=pytz.UTC),
)
modeling_periods = {
"modeling_period_1": modeling_period_1,
"modeling_period_2": modeling_period_2,
}
grouping = [
("modeling_period_1", "modeling_period_2"),
]
return ModelingPeriodSet(modeling_periods, grouping)
@pytest.fixture
def trace_set():
columns = {
"value": [1, 1, 1, 1, np.nan],
"estimated": [False, False, False, False, False]
}
column_names = ["value", "estimated"]
index = pd.date_range('2000-01-01', periods=5, freq='D')
data = pd.DataFrame(columns, index=index, columns=column_names)
trace = EnergyTrace("ELECTRICITY_ON_SITE_GENERATION_UNCONSUMED", data=data,
unit="KWH")
return EnergyTraceSet([trace], ["trace"])
@pytest.fixture
def placeholder_trace_set():
trace = EnergyTrace("ELECTRICITY_ON_SITE_GENERATION_UNCONSUMED",
placeholder=True)
return EnergyTraceSet([trace], ["trace"])
def test_basic_usage(modeling_period_set, trace_set):
dispatches = get_energy_modeling_dispatches(modeling_period_set, trace_set)
assert len(dispatches) == 1
dispatch = dispatches["trace"]
assert isinstance(dispatch, SplitModeledEnergyTrace)
def test_placeholder_trace(modeling_period_set, placeholder_trace_set):
dispatches = get_energy_modeling_dispatches(modeling_period_set,
placeholder_trace_set)
assert len(dispatches) == 1
assert dispatches["trace"] is None
| 27.410256 | 79 | 0.689897 |
4bdba8566b660cb03909ce05de8e1125cb9adcbc | 6,981 | py | Python | pythran/analyses/ast_matcher.py | SylvainCorlay/pythran | 908ec070d837baf77d828d01c3e35e2f4bfa2bfa | [
"BSD-3-Clause"
] | 1 | 2018-03-24T00:33:03.000Z | 2018-03-24T00:33:03.000Z | pythran/analyses/ast_matcher.py | SylvainCorlay/pythran | 908ec070d837baf77d828d01c3e35e2f4bfa2bfa | [
"BSD-3-Clause"
] | null | null | null | pythran/analyses/ast_matcher.py | SylvainCorlay/pythran | 908ec070d837baf77d828d01c3e35e2f4bfa2bfa | [
"BSD-3-Clause"
] | null | null | null | """ Module to looks for a specified pattern in a given AST. """
from gast import AST, iter_fields, NodeVisitor, Dict, Set
from itertools import permutations
from math import isnan
MAX_UNORDERED_LENGTH = 10
class DamnTooLongPattern(Exception):
""" Exception for long dict/set comparison to reduce compile time. """
class Placeholder(AST):
""" Class to save information from ast while check for pattern. """
def __init__(self, identifier):
""" Placehorder are identified using an identifier. """
self.id = identifier
super(Placeholder, self).__init__()
class AST_any(AST):
""" Class to specify we don't care about a field value in ast. """
class AST_or(AST):
"""
Class to specify multiple possibles value for a given field in ast.
Attributes
----------
args: [ast field value]
List of possible value for a field of an ast.
"""
def __init__(self, *args):
""" Initialiser to keep track of arguments. """
self.args = args
super(AST_or, self).__init__()
class Check(NodeVisitor):
"""
Checker for ast <-> pattern.
NodeVisitor is needed for specific behavior checker.
Attributs
---------
node : AST
node we want to compare with pattern
placeholders : [AST]
list of placeholder value for later comparison or replacement.
"""
def __init__(self, node, placeholder):
""" Initialize attributs. """
self.node = node
self.placeholders = placeholder
def check_list(self, node_list, pattern_list):
""" Check if list of node are equal. """
if len(node_list) != len(pattern_list):
return False
else:
return all(Check(node_elt,
self.placeholders).visit(pattern_list[i])
for i, node_elt in enumerate(node_list))
def visit_Placeholder(self, pattern):
"""
Save matching node or compare it with the existing one.
FIXME : What if the new placeholder is a better choice?
"""
if (pattern.id in self.placeholders and
not Check(self.node, self.placeholders).visit(
self.placeholders[pattern.id])):
return False
else:
self.placeholders[pattern.id] = self.node
return True
@staticmethod
def visit_AST_any(_):
""" Every node match with it. """
return True
def visit_AST_or(self, pattern):
""" Match if any of the or content match with the other node. """
return any(self.field_match(self.node, value_or)
for value_or in pattern.args)
def visit_Set(self, pattern):
""" Set have unordered values. """
if len(pattern.elts) > MAX_UNORDERED_LENGTH:
raise DamnTooLongPattern("Pattern for Set is too long")
return (isinstance(self.node, Set) and
any(self.check_list(self.node.elts, pattern_elts)
for pattern_elts in permutations(pattern.elts)))
def visit_Dict(self, pattern):
""" Dict can match with unordered values. """
if not isinstance(self.node, Dict):
return False
if len(pattern.keys) > MAX_UNORDERED_LENGTH:
raise DamnTooLongPattern("Pattern for Dict is too long")
for permutation in permutations(range(len(self.node.keys))):
for i, value in enumerate(permutation):
if not self.field_match(self.node.keys[i],
pattern.keys[value]):
break
else:
pattern_values = [pattern.values[i] for i in permutation]
return self.check_list(self.node.values, pattern_values)
return False
def field_match(self, node_field, pattern_field):
"""
Check if two fields match.
Field match if:
- If it is a list, all values have to match.
- If if is a node, recursively check it.
- Otherwise, check values are equal.
"""
is_good_list = (isinstance(pattern_field, list) and
self.check_list(node_field, pattern_field))
is_good_node = (isinstance(pattern_field, AST) and
Check(node_field,
self.placeholders).visit(pattern_field))
def strict_eq(f0, f1):
try:
return f0 == f1 or (isnan(f0) and isnan(f1))
except TypeError:
return f0 == f1
is_same = strict_eq(pattern_field, node_field)
return is_good_list or is_good_node or is_same
def generic_visit(self, pattern):
"""
Check if the pattern match with the checked node.
a node match if:
- type match
- all field match
"""
return (isinstance(pattern, type(self.node)) and
all(self.field_match(value, getattr(pattern, field))
for field, value in iter_fields(self.node)))
class ASTMatcher(NodeVisitor):
"""
Visitor to gather node matching with a given pattern.
Examples
--------
>>> import gast as ast
>>> code = "[(i, j) for i in xrange(a) for j in xrange(b)]"
>>> pattern = ast.Call(func=ast.Name('xrange', ctx=ast.Load(),
... annotation=None),
... args=AST_any(), keywords=[])
>>> len(ASTMatcher(pattern).search(ast.parse(code)))
2
>>> code = "[(i, j) for i in range(a) for j in xrange(b)]"
>>> pattern = ast.Call(func=ast.Name(id=AST_or('xrange', 'range'),
... ctx=ast.Load(),
... annotation=None),
... args=AST_any(), keywords=[])
>>> len(ASTMatcher(pattern).search(ast.parse(code)))
2
>>> code = "{1:2, 3:4}"
>>> pattern = ast.Dict(keys=[ast.Num(n=3), ast.Num(n=1)],
... values=[ast.Num(n=4), ast.Num(n=2)])
>>> len(ASTMatcher(pattern).search(ast.parse(code)))
1
>>> code = "{1, 2, 3}"
>>> pattern = ast.Set(elts=[ast.Num(n=3), ast.Num(n=2), ast.Num(n=1)])
>>> len(ASTMatcher(pattern).search(ast.parse(code)))
1
"""
def __init__(self, pattern):
""" Basic initialiser saving pattern and initialising result set. """
self.pattern = pattern
self.result = set()
super(ASTMatcher, self).__init__()
def visit(self, node):
"""
Visitor looking for matching between current node and pattern.
If it match, save it but whatever happen, keep going.
"""
if Check(node, dict()).visit(self.pattern):
self.result.add(node)
self.generic_visit(node)
def search(self, node):
""" Facility to get values of the matcher for a given node. """
self.visit(node)
return self.result
| 32.774648 | 77 | 0.571408 |
b0ef699ca9151ce375844b6c9abc96e4656d0c1d | 22,618 | py | Python | tensornetwork/matrixproductstates/dmrg.py | adityasharma3/TensorNetwork | 02a290576cab4adbd7dcfeb727eddc49f598b328 | [
"Apache-2.0"
] | null | null | null | tensornetwork/matrixproductstates/dmrg.py | adityasharma3/TensorNetwork | 02a290576cab4adbd7dcfeb727eddc49f598b328 | [
"Apache-2.0"
] | 1 | 2020-08-27T14:38:25.000Z | 2020-08-27T19:01:51.000Z | tensornetwork/matrixproductstates/dmrg.py | adityasharma3/TensorNetwork | 02a290576cab4adbd7dcfeb727eddc49f598b328 | [
"Apache-2.0"
] | null | null | null | # Copyright 2019 The TensorNetwork Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
from tensornetwork.matrixproductstates.base_mps import BaseMPS
from tensornetwork.matrixproductstates.finite_mps import FiniteMPS
from tensornetwork.matrixproductstates.mpo import BaseMPO, FiniteMPO
from tensornetwork.ncon_interface import ncon
from sys import stdout
from typing import Any, Text, Union
Tensor = Any
class BaseDMRG:
"""
A base class for DMRG (and possibly other) simulations.
Finite DMRG and infinite DMRG are subclassed from `BaseDMRG`.
"""
def __init__(self, mps: BaseMPS, mpo: BaseMPO, left_boundary: Tensor,
right_boundary: Tensor, name: Text):
"""
Base class for DMRG simulations.
Args:
mps: The initial mps. Should be either FiniteMPS or InfiniteMPS
(latter is not yet supported).
mpo: A `FiniteMPO` or `InfiniteMPO` object.
lb: The left boundary environment. `lb` has to have shape
(mpo[0].shape[0],mps[0].shape[0],mps[0].shape[0])
rb: The right environment. `rb` has to have shape
(mpo[-1].shape[1],mps[-1].shape[1],mps[-1].shape[1])
name: An optional name for the simulation.
Raises:
TypeError: If mps and mpo have different backends.
ValueError: If len(mps) != len(mpo).
"""
if mps.backend is not mpo.backend:
raise TypeError('mps and mpo use different backends.')
if not mps.dtype == mpo.dtype:
raise TypeError('mps.dtype = {} is different from mpo.dtype = {}'.format(
mps.dtype, mpo.dtype))
if len(mps) != len(mpo):
raise ValueError('len(mps) = {} is different from len(mpo) = {}'.format(
len(mps), len(mpo)))
if mps.center_position is None:
raise ValueError(
"Found mps in non-canonical form. Please canonicalize mps.")
self.mps = mps
self.mpo = mpo
self.left_envs = {0: self.backend.convert_to_tensor(left_boundary)}
self.right_envs = {
len(mps) - 1: self.backend.convert_to_tensor(right_boundary)
}
if self.left_envs[0].dtype != self.dtype:
raise TypeError(
'left_boundary.dtype = {} is different from BaseDMRG.dtype = {}'
.format(self.left_envs[0].dtype.dtype, self.dtype))
if self.right_envs[len(mps) - 1].dtype != self.dtype:
raise TypeError(
'right_boundary.dtype = {} is different from BaseDMRG.dtype = {}'
.format(self.right_envs[0].dtype, self.dtype))
self.name = name
@property
def backend(self):
return self.mps.backend
@property
def dtype(self):
"""
Return the dtype of BaseMPS.
"""
if not self.mps.dtype == self.mpo.dtype:
raise TypeError('mps.dtype = {} is different from mpo.dtype = {}'.format(
self.mps.dtype, self.mpo.dtype))
return self.mps.dtype
def single_site_matvec(self, mpstensor, L, mpotensor, R):
return ncon([L, mpstensor, mpotensor, R],
[[3, 1, -1], [1, 2, 4], [3, 5, -2, 2], [5, 4, -3]],
backend=self.backend.name)
def two_site_matvec(self, mps_bond_tensor, L, left_mpotensor,
right_mpotensor, R):
return ncon([L, mps_bond_tensor, left_mpotensor, right_mpotensor, R],
[[3, 1, -1], [1, 2, 5, 6], [3, 4, -2, 2], [4, 7, -3, 5],
[7, 6, -4]],
backend=self.backend.name)
def add_left_layer(self, L, mps_tensor, mpo_tensor):
return ncon([L, mps_tensor, mpo_tensor,
self.backend.conj(mps_tensor)],
[[2, 1, 5], [1, 3, -2], [2, -1, 4, 3], [5, 4, -3]],
backend=self.backend.name)
def add_right_layer(self, R, mps_tensor, mpo_tensor):
return ncon([R, mps_tensor, mpo_tensor,
self.backend.conj(mps_tensor)],
[[2, 1, 5], [-2, 3, 1], [-1, 2, 4, 3], [-3, 4, 5]],
backend=self.backend.name)
def position(self, site: int):
"""
Shifts the center position `site`, and updates left and
right environments accordingly. Left blocks at sites > `site` are set
to `None`, and right blocks at sites < `site` are `None`.
Args:
site: The site to which the position of the center-site should be shifted.
Returns: BaseDMRG
"""
if site >= len(self.mps):
raise IndexError("site > length of mps")
if site < 0:
raise IndexError("site < 0")
if site == self.mps.center_position:
return self
if site > self.mps.center_position:
pos = self.mps.center_position
self.mps.position(site)
for m in range(pos, site):
self.left_envs[m + 1] = self.add_left_layer(self.left_envs[m],
self.mps.tensors[m],
self.mpo.tensors[m])
elif site < self.mps.center_position:
pos = self.mps.center_position
self.mps.position(site)
for m in reversed(range(site, pos)):
self.right_envs[m] = self.add_right_layer(self.right_envs[m + 1],
self.mps.tensors[m + 1],
self.mpo.tensors[m + 1])
for m in range(site + 1, len(self.mps) + 1):
try:
del self.left_envs[m]
except KeyError:
pass
for m in range(-1, site):
try:
del self.right_envs[m]
except KeyError:
pass
return self
def compute_left_envs(self) -> None:
"""
Compute all left environment blocks of sites up to
(including) self.mps.center_position.
"""
lb = self.left_envs[0]
self.left_envs = {0: lb}
for n in range(self.mps.center_position):
self.left_envs[n + 1] = self.add_left_layer(self.left_envs[n],
self.mps.tensors[n],
self.mpo.tensors[n])
def compute_right_envs(self) -> None:
"""
Compute all right environment blocks of sites up to
(including) self.mps.center_position.
"""
rb = self.right_envs[len(self.mps) - 1]
self.right_envs = {len(self.mps) - 1: rb}
for n in reversed(range(self.mps.center_position + 1, len(self.mps))):
self.right_envs[n - 1] = self.add_right_layer(self.right_envs[n],
self.mps.tensors[n],
self.mpo.tensors[n])
def _optimize_1s_local(self,
sweep_dir,
num_krylov_vecs=10,
tol=1E-5,
delta=1E-6,
ndiag=10) -> np.number:
"""
Single-site optimization at the current position of the center site.
The method shifts the center position of the mps by one site
to the left or to the right, depending on the value of `sweep_dir`.
Args:
sweep_dir: Sweep direction; 'left' or 'l' for a sweep from right to left,
'right' or 'r' for a sweep from left to right.
num_krylov_vecs: Dimension of the Krylov space used in `eighs_lanczos`.
tol: The desired precision of the eigenvalues in `eigsh_lanczos'.
delta: Stopping criterion for Lanczos iteration.
If a Krylov vector :math: `x_n` has an L2 norm
:math:`\\lVert x_n\\rVert < delta`, the iteration
is stopped.
ndiag: Inverse frequencey of tridiagonalizations in `eighs_lanczos`.
Returns:
float/complex: The local energy after optimization.
"""
site = self.mps.center_position
#note: some backends will jit functions
self.left_envs[site]
self.right_envs[site]
energies, states = self.backend.eigsh_lanczos(
A=self.single_site_matvec,
args=[
self.left_envs[site], self.mpo.tensors[site], self.right_envs[site]
],
initial_state=self.mps.tensors[site],
num_krylov_vecs=num_krylov_vecs,
numeig=1,
tol=tol,
delta=delta,
ndiag=ndiag,
reorthogonalize=False)
local_ground_state = states[0]
energy = energies[0]
local_ground_state /= self.backend.norm(local_ground_state)
if sweep_dir in ('r', 'right'):
Q, R = self.mps.qr(local_ground_state)
self.mps.tensors[site] = Q
if site < len(self.mps.tensors) - 1:
self.mps.center_position += 1
self.mps.tensors[site + 1] = ncon([R, self.mps.tensors[site + 1]],
[[-1, 1], [1, -2, -3]],
backend=self.backend.name)
self.left_envs[site + 1] = self.add_left_layer(self.left_envs[site], Q,
self.mpo.tensors[site])
elif sweep_dir in ('l', 'left'):
R, Q = self.mps.rq(local_ground_state)
self.mps.tensors[site] = Q
if site > 0:
self.mps.center_position -= 1
self.mps.tensors[site - 1] = ncon([self.mps.tensors[site - 1], R],
[[-1, -2, 1], [1, -3]],
backend=self.backend.name)
self.right_envs[site - 1] = self.add_right_layer(
self.right_envs[site], Q, self.mpo.tensors[site])
return energy
def _optimize_2s_local(self,
max_bond_dim,
sweep_dir,
num_krylov_vecs=10,
tol=1E-5,
delta=1E-6,
ndiag=10) -> np.number:
"""
Two-site optimization at the current position of the center site.
The method shifts the center position of the mps by one site
to the left or to the right, depending on the value of `sweep_dir`.
Args:
max_bond_dim: Maximum MPS bond dimension. During DMRG optimization,
an MPS exceeding this dimension is truncated via SVD.
sweep_dir: Sweep direction; 'left' or 'l' for a sweep from right to left,
'right' or 'r' for a sweep from left to right.
num_krylov_vecs: Dimension of the Krylov space used in `eighs_lanczos`.
tol: The desired precision of the eigenvalues in `eigsh_lanczos'.
delta: Stopping criterion for Lanczos iteration.
If a Krylov vector :math: `x_n` has an L2 norm
:math:`\\lVert x_n\\rVert < delta`, the iteration
is stopped.
ndiag: Inverse frequencey of tridiagonalizations in `eighs_lanczos`.
Returns:
float/complex: The local energy after optimization.
"""
site = self.mps.center_position
#note: some backends will jit functions
if sweep_dir in ('r', 'right'):
bond_mps = ncon([self.mps.tensors[site], self.mps.tensors[site + 1]],
[[-1, -2, 1], [1, -3, -4]],
backend=self.backend.name)
energies, states = self.backend.eigsh_lanczos(
A=self.two_site_matvec,
args=[
self.left_envs[site], self.mpo.tensors[site],
self.mpo.tensors[site + 1], self.right_envs[site + 1]
],
initial_state=bond_mps,
num_krylov_vecs=num_krylov_vecs,
numeig=1,
tol=tol,
delta=delta,
ndiag=ndiag,
reorthogonalize=False)
local_ground_state = states[0]
energy = energies[0]
local_ground_state /= self.backend.norm(local_ground_state)
u, s, vh, _ = self.mps.svd(local_ground_state,
max_singular_values=max_bond_dim)
s = self.backend.diagflat(s)
self.mps.tensors[site] = u
if site < len(self.mps.tensors) - 1:
self.mps.center_position += 1
self.mps.tensors[site + 1] = ncon([s, vh], [[-1, 1], [1, -2, -3]],
backend=self.backend.name)
self.left_envs[site + 1] = self.add_left_layer(self.left_envs[site], u,
self.mpo.tensors[site])
elif sweep_dir in ('l', 'left'):
bond_mps = ncon([self.mps.tensors[site - 1], self.mps.tensors[site]],
[[-1, -2, 1], [1, -3, -4]],
backend=self.backend.name)
energies, states = self.backend.eigsh_lanczos(
A=self.two_site_matvec,
args=[
self.left_envs[site - 1], self.mpo.tensors[site - 1],
self.mpo.tensors[site], self.right_envs[site]
],
initial_state=bond_mps,
num_krylov_vecs=num_krylov_vecs,
numeig=1,
tol=tol,
delta=delta,
ndiag=ndiag,
reorthogonalize=False)
local_ground_state = states[0]
energy = energies[0]
local_ground_state /= self.backend.norm(local_ground_state)
u, s, vh, _ = self.mps.svd(local_ground_state,
max_singular_values=max_bond_dim)
s = self.backend.diagflat(s)
self.mps.tensors[site] = vh
if site > 0:
self.mps.center_position -= 1
self.mps.tensors[site - 1] = ncon([u, s],
[[-1, -2, 1], [1, -3]],
backend=self.backend.name)
self.right_envs[site - 1] = \
self.add_right_layer(self.right_envs[site], vh,
self.mpo.tensors[site])
return energy
def run_one_site(self,
num_sweeps=4,
precision=1E-6,
num_krylov_vecs=10,
verbose=0,
delta=1E-6,
tol=1E-6,
ndiag=10) -> np.number:
"""
Run a single-site DMRG optimization of the MPS.
Args:
num_sweeps: Number of DMRG sweeps. A sweep optimizes all sites
starting at the left side, moving to the right side, and back
to the left side.
precision: The desired precision of the energy. If `precision` is
reached, optimization is terminated.
num_krylov_vecs: Krylov space dimension used in the iterative
eigsh_lanczos method.
verbose: Verbosity flag. Us`verbose=0` to suppress any output.
Larger values produce increasingly more output.
delta: Convergence parameter of `eigsh_lanczos` to determine if
an invariant subspace has been found.
tol: Tolerance parameter of `eigsh_lanczos`. If eigenvalues in
`eigsh_lanczos` have converged within `tol`, `eighs_lanczos`
is terminted.
ndiag: Inverse frequency at which eigenvalues of the
tridiagonal Hamiltonian produced by `eigsh_lanczos` are tested
for convergence. `ndiag=10` tests at every tenth step.
Returns:
float: The energy upon termination of `run_one_site`.
"""
if num_sweeps == 0:
return self.compute_energy()
converged = False
final_energy = 1E100
iteration = 1
initial_site = 0
self.mps.position(0) #move center position to the left end
self.compute_right_envs()
def print_msg(site):
if verbose < 2:
stdout.write(f"\rSS-DMRG sweep={iteration}/{num_sweeps}, "
f"site={site}/{len(self.mps)}: optimized E={energy}")
stdout.flush()
if verbose >= 2:
print(f"SS-DMRG sweep={iteration}/{num_sweeps}, "
f"site={site}/{len(self.mps)}: optimized E={energy}")
while not converged:
if initial_site == 0:
self.position(0)
#the part outside the loop covers the len(self)==1 case
energy = self._optimize_1s_local(
sweep_dir='right',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
initial_site += 1
print_msg(site=0)
while self.mps.center_position < len(self.mps) - 1:
#_optimize_1site_local shifts the center site internally
energy = self._optimize_1s_local(
sweep_dir='right',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
print_msg(site=self.mps.center_position - 1)
#prepare for left sweep: move center all the way to the right
self.position(len(self.mps) - 1)
while self.mps.center_position > 0:
#_optimize_1site_local shifts the center site internally
energy = self._optimize_1s_local(
sweep_dir='left',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
print_msg(site=self.mps.center_position + 1)
if np.abs(final_energy - energy) < precision:
converged = True
final_energy = energy
iteration += 1
if iteration > num_sweeps:
if verbose > 0:
print()
print("dmrg did not converge to desired precision {0} "
"after {1} iterations".format(precision, num_sweeps))
break
return final_energy
def run_two_site(self,
max_bond_dim,
num_sweeps=4,
precision=1E-6,
num_krylov_vecs=10,
verbose=0,
delta=1E-6,
tol=1E-6,
ndiag=10) -> np.number:
"""
Run a two-site DMRG optimization of the MPS.
Args:
max_bond_dim: Maximum MPS bond dimension. During DMRG optimization,
an MPS exceeding this dimension is truncated via SVD.
num_sweeps: Number of DMRG sweeps. A sweep optimizes all sites
starting at the left side, moving to the right side, and back
to the left side.
precision: The desired precision of the energy. If `precision` is
reached, optimization is terminated.
num_krylov_vecs: Krylov space dimension used in the iterative
eigsh_lanczos method.
verbose: Verbosity flag. Us`verbose=0` to suppress any output.
Larger values produce increasingly more output.
delta: Convergence parameter of `eigsh_lanczos` to determine if
an invariant subspace has been found.
tol: Tolerance parameter of `eigsh_lanczos`. If eigenvalues in
`eigsh_lanczos` have converged within `tol`, `eighs_lanczos`
is terminted.
ndiag: Inverse frequency at which eigenvalues of the
tridiagonal Hamiltonian produced by `eigsh_lanczos` are tested
for convergence. `ndiag=10` tests at every tenth step.
Returns:
float: The energy upon termination of `run_two_site`.
"""
if num_sweeps == 0:
return self.compute_energy()
converged = False
final_energy = 1E100
iteration = 1
initial_site = 0
self.mps.position(0) #move center position to the left end
self.compute_right_envs()
# TODO (pedersor): print max truncation errors
def print_msg(left_site, right_site):
if verbose < 2:
stdout.write(f"\rTS-DMRG sweep={iteration}/{num_sweeps}, "
f"sites=({left_site},{right_site})/{len(self.mps)}: "
f"optimized E={energy}")
stdout.flush()
if verbose >= 2:
print(f"TS-DMRG sweep={iteration}/{num_sweeps}, "
f"sites=({left_site},{right_site})/{len(self.mps)}: "
f"optimized E={energy}")
while not converged:
if initial_site == 0:
self.position(0)
#the part outside the loop covers the len(self)==1 case
energy = self._optimize_2s_local(
max_bond_dim=max_bond_dim,
sweep_dir='right',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
initial_site += 1
print_msg(left_site=0, right_site=1)
while self.mps.center_position < len(self.mps) - 1:
#_optimize_2site_local shifts the center site internally
energy = self._optimize_2s_local(
max_bond_dim=max_bond_dim,
sweep_dir='right',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
print_msg(self.mps.center_position - 1, self.mps.center_position)
#prepare for left sweep: move center all the way to the right
self.position(len(self.mps) - 1)
while self.mps.center_position > 0:
#_optimize_2site_local shifts the center site internally
energy = self._optimize_2s_local(
max_bond_dim=max_bond_dim,
sweep_dir='left',
num_krylov_vecs=num_krylov_vecs,
tol=tol,
delta=delta,
ndiag=ndiag)
print_msg(self.mps.center_position, self.mps.center_position + 1)
if np.abs(final_energy - energy) < precision:
converged = True
final_energy = energy
iteration += 1
if iteration > num_sweeps:
if verbose > 0:
print()
print("dmrg did not converge to desired precision {0} "
"after {1} iterations".format(precision, num_sweeps))
break
return final_energy
def compute_energy(self):
self.mps.position(0) #move center position to the left end
self.compute_right_envs()
return ncon([
self.add_right_layer(self.right_envs[0], self.mps.tensors[0],
self.mpo.tensors[0])
], [[1, 1, -1]], backend=self.backend.name)[0]
class FiniteDMRG(BaseDMRG):
"""
Class for simulating finite DMRG.
"""
def __init__(self,
mps: FiniteMPS,
mpo: FiniteMPO,
name: Text = 'FiniteDMRG') -> None:
"""
Initialize a finite DRMG simulation.
Args:
mps: A FiniteMPS object.
mpo: A FiniteMPO object.
name: An optional name for the simulation.
"""
lshape = (mpo.tensors[0].shape[0], mps.tensors[0].shape[0],
mps.tensors[0].shape[0])
rshape = (mpo.tensors[-1].shape[1], mps.tensors[-1].shape[2],
mps.tensors[-1].shape[2])
lb = mps.backend.ones(lshape, dtype=mps.dtype)
rb = mps.backend.ones(rshape, dtype=mps.dtype)
super().__init__(
mps=mps, mpo=mpo, left_boundary=lb, right_boundary=rb, name=name)
| 38.400679 | 80 | 0.587629 |
4030f39b1aec3aa3eae276256d9e8f27aa9748ae | 2,595 | py | Python | codigos_buenos/sensoresUS_v2.py | fraromesc/conceptos_raspberry | 46179e85e8654dff6eff35599a1cb22f8dad8c35 | [
"CC0-1.0"
] | null | null | null | codigos_buenos/sensoresUS_v2.py | fraromesc/conceptos_raspberry | 46179e85e8654dff6eff35599a1cb22f8dad8c35 | [
"CC0-1.0"
] | null | null | null | codigos_buenos/sensoresUS_v2.py | fraromesc/conceptos_raspberry | 46179e85e8654dff6eff35599a1cb22f8dad8c35 | [
"CC0-1.0"
] | null | null | null | #Libraries
import RPi.GPIO as GPIO
import time
#GPIO Mode (BOARD / BCM)
GPIO.setmode(GPIO.BOARD)
#set GPIO Pins
GPIO_TRIGGER = 8
GPIO_ECHO = 10
GPIO_TRIGGER_1 = 3
GPIO_ECHO_1 = 5
GPIO_TRIGGER_2 = 13
GPIO_ECHO_2 = 15
#set GPIO direction (IN / OUT)
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
GPIO.setup(GPIO_ECHO, GPIO.IN)
GPIO.setup(GPIO_TRIGGER_1, GPIO.OUT)
GPIO.setup(GPIO_ECHO_1, GPIO.IN)
GPIO.setup(GPIO_TRIGGER_2, GPIO.OUT)
GPIO.setup(GPIO_ECHO_2, GPIO.IN)
def distance():
# set Trigger to HIGH
GPIO.output(GPIO_TRIGGER, True)
# set Trigger after 0.01ms to LOW
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER, False)
StartTime = time.time()
StopTime = time.time()
# save StartTime
while GPIO.input(GPIO_ECHO) == 0:
StartTime = time.time()
# save time of arrival
while GPIO.input(GPIO_ECHO) == 1:
StopTime = time.time()
# time difference between start and arrival
TimeElapsed = StopTime - StartTime
# multiply with the sonic speed (34300 cm/s)
# and divide by 2, because there and back
distance = (TimeElapsed * 34300) / 2
print("medida 0 ")
print(distance)
# set Trigger to HIGH
GPIO.output(GPIO_TRIGGER_1, True)
# set Trigger after 0.01ms to LOW
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER_1, False)
StartTime = time.time()
StopTime = time.time()
# save StartTime
while GPIO.input(GPIO_ECHO_1) == 0:
StartTime = time.time()
# save time of arrival
while GPIO.input(GPIO_ECHO_1) == 1:
StopTime = time.time()
# time difference between start and arrival
TimeElapsed = StopTime - StartTime
# multiply with the sonic speed (34300 cm/s)
# and divide by 2, because there and back
distance = (TimeElapsed * 34300) / 2
print("medida 1 ")
print(distance)
# set Trigger to HIGH
GPIO.output(GPIO_TRIGGER_2, True)
# set Trigger after 0.01ms to LOW
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER_2, False)
StartTime = time.time()
StopTime = time.time()
# save StartTime
while GPIO.input(GPIO_ECHO_2) == 0:
StartTime = time.time()
# save time of arrival
while GPIO.input(GPIO_ECHO_2) == 1:
StopTime = time.time()
# time difference between start and arrival
TimeElapsed = StopTime - StartTime
# multiply with the sonic speed (34300 cm/s)
# and divide by 2, because there and back
distance = (TimeElapsed * 34300) / 2
print("medida 2 ")
print(distance)
return distance
if __name__ == '__main__':
try:
while True:
dist = distance()
print ("Measured Distance = %.1f cm" % dist)
time.sleep(1)
# Reset by pressing CTRL + C
except KeyboardInterrupt:
print("Measurement stopped by User")
GPIO.cleanup()
| 21.446281 | 47 | 0.712139 |
6b83870969c3e4fb876c67d97808da38343e534b | 1,000 | py | Python | examples/find_facial_features_in_picture.py | viettriit2110/face_recognition | 0e1821af6538c573ed4a87acc361c44900f849eb | [
"MIT"
] | 3 | 2021-07-26T14:24:41.000Z | 2022-02-27T11:04:34.000Z | examples/find_facial_features_in_picture.py | viettriit2110/face_recognition | 0e1821af6538c573ed4a87acc361c44900f849eb | [
"MIT"
] | 1 | 2021-11-15T17:49:06.000Z | 2021-11-15T17:49:06.000Z | examples/find_facial_features_in_picture.py | viettriit2110/face_recognition | 0e1821af6538c573ed4a87acc361c44900f849eb | [
"MIT"
] | null | null | null | from PIL import Image, ImageDraw
import face_recognition
# Load the jpg file into a numpy array
image = face_recognition.load_image_file("two_people.jpg")
# Find all facial features in all the faces in the image
face_landmarks_list = face_recognition.face_landmarks(image)
print("I found {} face(s) in this photograph.".format(len(face_landmarks_list)))
# Create a PIL imagedraw object so we can draw on the picture
pil_image = Image.fromarray(image)
d = ImageDraw.Draw(pil_image)
for face_landmarks in face_landmarks_list:
# Print the location of each facial feature in this image
for facial_feature in face_landmarks.keys():
print("The {} in this face has the following points: {}".format(facial_feature, face_landmarks[facial_feature]))
# Let's trace out each facial feature in the image with a line!
for facial_feature in face_landmarks.keys():
d.line(face_landmarks[facial_feature], width=5)
# Show the picture
pil_image.show()
| 35.714286 | 121 | 0.743 |
9f7ba1247235cfd5f0724b79e15613855a038411 | 4,796 | py | Python | waifu2x.py | Xnuvers007/Waifu2x | 9857fa7ef07a0cb304c11fea8915e052c264c9e4 | [
"MIT"
] | 4 | 2021-08-22T18:36:42.000Z | 2021-12-19T15:52:15.000Z | waifu2x.py | Xnuvers007/Waifu2x | 9857fa7ef07a0cb304c11fea8915e052c264c9e4 | [
"MIT"
] | null | null | null | waifu2x.py | Xnuvers007/Waifu2x | 9857fa7ef07a0cb304c11fea8915e052c264c9e4 | [
"MIT"
] | null | null | null | import requests, urllib, json
from urllib import request
import time
import socket
#------ Yang Recode Dosa, gw gak terima ini direcode kecuali izin dan ingin mengembangkannya -------------#
def information():
print("Coded By Xnuvers007")
hostname = socket.gethostname()
ip_address = socket.gethostbyname(hostname)
print(f"Hostname / Nama perangkat mu : {hostname}")
print(f"IP Addressmu Adalah : {ip_address}\n")
print("============================")
warn = "file / foto yang sudah dijernihkan akan tersimpan dimana kamu meletakan aplikasi ini".upper()
print(warn)
print("============================\n")
input("Press enter to continue...")
def menu():
print("============= List Menu ===============\n")
print("1. Menjernihkan foto via Link/Url")
print("2. Menjernihkan foto via Foto yang sudah disimpan di komputer/hp")
print("CTRL + C = Exit/Quit/Keluar")
try:
pilih = int(input("Masukan Pilihan : "))
print("\n")
if pilih==1:
uerel()
elif pilih==2:
local()
else:
print("Tidak ada di menu akan mengulang kembali")
print("Akan mengulang dalam waktu 3 detik")
for i in range(1,4):
i += 0
time.sleep(1)
print(i)
menu()
except KeyboardInterrupt or ValueError:
print("Akan Keluar dalam ...")
for i in range(1,4):
i += 0
print(i)
exit(code=None)
def uerel():
url = input("Masukan Url Gambar : ")
r = requests.post("https://api.deepai.org/api/waifu2x",
data={'image':url,
},
headers={'api-key':'6bb16995-6df5-4b3d-a4b7-f0973f56ea82'}
#headers={'api-key':'quickstart-QUdJIGlzIGNvbWluZy4uLi4K'}
)
r_dict = r.json()
link = r_dict['output_url']
print("\nSalin Linknya...!!! : "+link+"\n")
print("Terus Tempel Lagi untuk jernihin...\n")
i = str(input("Ingin menjernihkan lagi ? [Y/n] n/N = Langsung Download : "))
if i=='Y' or i=='y':
uerel()
elif i=='n' or i=='N':
down = requests.get(link, allow_redirects=True)
nama = input("Masukan nama File : ")
bertanya = input("Jpg [J] atau Png [P] ? : ")
if bertanya=='j' or bertanya=='J':
open(nama+".jpg", 'wb').write(down.content)
print("Sudah Terdownload !!!")
elif bertanya=='P' or bertanya=='p':
open(nama+".png", 'wb').write(down.content)
print("Sudah Terdownload !!!")
else:
print("Tidak Ditemukan")
print("Akan Keluar dalam 3 detik")
for i in range(1,4):
i += 0
print(i)
time.sleep(1)
exit(code=None)
else:
print("Not Found")
print("Akan Keluar dalam 3 detik")
for i in range(1,4):
i += 0
print(i)
time.sleep(1)
exit(code=None)
def local():
lofile = input("Silahkan letakan lokasi file foto yang ingin di jernihkan atau drag ke sini : ")
r = requests.post(
"https://api.deepai.org/api/waifu2x",
files={
'image': open(lofile, 'rb'),
},
#headers={'api-key': 'quickstart-QUdJIGlzIGNvbWluZy4uLi4K'}
headers={'api-key':'6bb16995-6df5-4b3d-a4b7-f0973f56ea82'}
)
r_dict = r.json()
link = r_dict['output_url']
print("\nSalin Linknya...!!! : "+link+"\n")
print("Terus Tempel Lagi untuk jernihin...\n")
i = str(input("Ingin menjernihkan lagi ? [Y/n] n/N = Langsung Download : "))
if i=='Y' or i=='y':
uerel()
elif i=='n' or i=='N':
down = requests.get(link, allow_redirects=True)
nama = input("Masukan nama File : ")
bertanya = input("Jpg [J] atau Png [P] ? : ")
if bertanya=='j' or bertanya=='J':
open(nama+".jpg", 'wb').write(down.content)
print("Sudah Terdownload !!!")
elif bertanya=='P' or bertanya=='p':
open(nama+".png", 'wb').write(down.content)
print("Sudah Terdownload !!!")
else:
print("Tidak Ditemukan")
print("Akan Keluar dalam 3 detik")
for i in range(1,4):
i += 0
print(i)
time.sleep(1)
exit(code=None)
else:
print("Not Found")
print("Akan Keluar dalam 3 detik")
for i in range(1,4):
i += 0
print(i)
time.sleep(1)
exit(code=None)
information()
menu()
| 35.264706 | 108 | 0.501251 |
1dc944a10c5012ebb297d9f30943d14936ace767 | 3,781 | py | Python | data/middlebury.py | myungsub/meta-interpolation | f7afee9d1786f67e6f548c2734f91858f803c5dc | [
"MIT"
] | 74 | 2020-04-03T06:26:39.000Z | 2022-03-25T16:51:28.000Z | data/middlebury.py | baiksung/meta-interpolation | 72dd3b2e56054bb411ed20301583a0e67d9ea293 | [
"MIT"
] | 6 | 2020-07-09T20:09:23.000Z | 2021-09-20T11:12:24.000Z | data/middlebury.py | baiksung/meta-interpolation | 72dd3b2e56054bb411ed20301583a0e67d9ea293 | [
"MIT"
] | 19 | 2020-04-16T09:18:38.000Z | 2021-12-28T08:25:12.000Z | import os
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import random
import glob
from subprocess import call
class Middlebury(Dataset):
def __init__(self, args): #data_root, mode='other', n_frames=2):
'''
:param data_root: ./data/Middlebury
'''
self.args = args
self.data_root = args.data_root
self.mode = 'other'
# This decides the number of frames to return
self.nf = 4
if self.nf == 2:
self.image_root = os.path.join(self.data_root, self.mode + '-data-two')
else:
self.image_root = os.path.join(self.data_root, self.mode + '-data-all')
self.gt_root = os.path.join(self.data_root, self.mode + '-gt-interp')
self.imglist = []
self.gt_list = []
dir_data = sorted(glob.glob(self.image_root + '/*'))
for _, d in enumerate(dir_data):
_imglist = sorted(glob.glob(d + '/*.png'))
if self.nf == 2:
self.imglist.append(_imglist)
self.gt_list.append(os.path.join(self.gt_root, d.split('/')[-1], 'frame10i11.png'))
elif self.nf == 4:
if len(_imglist) == 2:
continue
elif len(_imglist) == 8:
_imglist = _imglist[2:6]
self.imglist.append(_imglist)
self.gt_list.append(os.path.join(self.gt_root, d.split('/')[-1], 'frame10i11.png'))
else:
raise ValueError('Unknown number of frames')
self.batch_size = {'train': 1, 'val': 1, 'test': 1}
self.current_set_name = 'val'
self.data_length = {'train': 0, 'val': len(self.imglist), 'test': 0}
if args.model == 'superslomo':
print('SuperSloMo normalization')
mean = [0.429, 0.431, 0.397]
std = [1, 1, 1]
self.normalize = transforms.Normalize(mean=mean, std=std)
elif args.model == 'voxelflow':
print('Voxelflow normalization')
mean = [0.5 * 255, 0.5 * 255, 0.5 * 255]
std = [0.5 * 255, 0.5 * 255, 0.5 * 255]
self.normalize = transforms.Normalize(mean=mean, std=std)
def __getitem__(self, index):
imglist = self.imglist[index]
gt_path = self.gt_list[index]
imgs, imgpath = [], []
for im in imglist:
imgs.append(Image.open(im))
imgpath.append(im)
gt = Image.open(gt_path)
w, h = imgs[0].size
# if w % 32 != 0 or h % 32 != 0:
# w -= w % 32
# h -= h % 32
# T = transforms.Compose([
# transforms.Resize((h, w), interpolation=2),
# transforms.ToTensor()
# ])
# else:
# T = transforms.ToTensor()
T = transforms.ToTensor()
for i in range(len(imgs)):
imgs[i] = T(imgs[i])
gt = T(gt)
if self.args.model == 'voxelflow': # receives 0~255 inputs
imgs = [self.normalize(im * 255.0) for im in imgs]
gt = self.normalize(gt * 255.0)
elif self.args.model == 'superslomo':
imgs = [self.normalize(im) for im in imgs]
gt = self.normalize(gt)
dummy_img = torch.zeros_like(gt)
images = [imgs[0], dummy_img, imgs[1], gt, imgs[2], dummy_img, imgs[3]]
imgpath = [imgpath[0], "", imgpath[1], gt_path, imgpath[2], "", imgpath[3]]
metadata = {'imgpaths': imgpath}
return images, metadata
def switch_set(self, set_name, current_iter=None):
self.current_set_name = set_name
def __len__(self):
return self.data_length[self.current_set_name]
| 34.372727 | 103 | 0.535573 |
2251e9ae0e0905255a1fca2c37c1759425593c09 | 9,241 | py | Python | week2/utilities/ltr_utils.py | vidhyaMani/search_with_machine_learning_course | 0101c8e855ee808e6823dbe17a730c514077d608 | [
"Apache-2.0"
] | null | null | null | week2/utilities/ltr_utils.py | vidhyaMani/search_with_machine_learning_course | 0101c8e855ee808e6823dbe17a730c514077d608 | [
"Apache-2.0"
] | null | null | null | week2/utilities/ltr_utils.py | vidhyaMani/search_with_machine_learning_course | 0101c8e855ee808e6823dbe17a730c514077d608 | [
"Apache-2.0"
] | null | null | null | import json
import requests
def create_rescore_ltr_query(user_query, query_obj, click_prior_query, ltr_model_name, ltr_store_name,
active_features=None, rescore_size=500, main_query_weight=1, rescore_query_weight=2):
# Create the base query, use a much bigger window
#add on the rescore
query_obj["rescore"] = {
"window_size": rescore_size,
"query": {
"rescore_query": {
"sltr": {
"params": {
"keywords": user_query,
"click_prior_query": click_prior_query,
},
"model": ltr_model_name,
"store": ltr_store_name,
}
},
"score_mode": "total",
"query_weight": main_query_weight,
"rescore_query_weight": rescore_query_weight, # Magic number, but let's say LTR matches are 2x baseline matches
},
}
if active_features is not None and len(active_features) > 0:
query_obj["rescore"]["query"]["rescore_query"]["sltr"][
"active_features"
] = active_features
return query_obj
# take an existing query and add in an SLTR so we can use it for explains to see how much SLTR contributes
def create_sltr_simple_query(user_query, query_obj, click_prior_query, ltr_model_name, ltr_store_name, active_features=None):
# Create the base query, use a much bigger window
#add on the rescore
sltr = {
"sltr": {
"params": {
"keywords": user_query,
"click_prior_query": click_prior_query
},
"model": ltr_model_name,
# Since we are using a named store, as opposed to simply '_ltr', we need to pass it in
"store": ltr_store_name,
}
}
if active_features is not None and len(active_features) > 0:
sltr["active_features"] = active_features
query_obj["query"]["bool"]["should"].append(sltr)
return query_obj, len(query_obj["query"]["bool"]["should"])
def create_sltr_hand_tuned_query(user_query, query_obj, click_prior_query, ltr_model_name, ltr_store_name, active_features=None):
# Create the base query, use a much bigger window
#add on the rescore
sltr = {
"sltr": {
"params": {
"keywords": user_query,
"click_prior_query": click_prior_query
},
"model": ltr_model_name,
# Since we are using a named store, as opposed to simply '_ltr', we need to pass it in
"store": ltr_store_name,
}
}
if active_features is not None and len(active_features) > 0:
sltr["active_features"] = active_features
query_obj["query"]["function_score"]["query"]["bool"]["should"].append(sltr)
return query_obj, len(query_obj["query"]["function_score"]["query"]["bool"]["should"])
def create_feature_log_query(query, doc_ids, click_prior_query, featureset_name, ltr_store_name, size=200, terms_field="_id"):
query_obj = {
"query": {
"bool": {
"filter": [ # use a filter so that we don't actually score anything
{"terms": {"_id": doc_ids}},
{ # use the LTR query bring in the LTR feature set
"sltr": {
"_name": "logged_featureset",
"featureset": featureset_name,
"store": ltr_store_name,
"params": {
"keywords": query,
"click_prior_query": click_prior_query,
},
}
},
]
}
},
# Turn on feature logging so that we get weights back for our features
"ext": {
"ltr_log": {
"log_specs": {"name": "log_entry", "named_query": "logged_featureset"}
}
},
}
return query_obj
# Item is a Pandas namedtuple
def get_features(item, exclusions, col_names):
features = {}
for idx, f in enumerate(item):
col_name = col_names[idx]
if col_name not in exclusions:
# add it to the features
# Do we also have a normalized version? If so, skip this one, else add.
# if we do have a normalized one, add it, but name it w/o the norm here so that it matches our featureset in LTR
# there probably is a better way of doing this ^^
normed = "%s_norm" % col_name
if normed not in col_names:
features[col_name.replace('_norm', '')] = f
return features
def to_xgb_format(qid, doc_id, rank, query_str, product_name, grade, features):
if features is not None:
featuresAsStrs = ["%s:%.4f" % (idx + 1, feature) for idx, feature in enumerate(features.values())]
else:
featuresAsStrs = ""
comment = "# %s\t%s\t%s\t%s" % (doc_id, rank, query_str, product_name)
return "%.4f\tqid:%s\t%s %s" % (grade, qid, "\t".join(featuresAsStrs), comment.replace('\n',''))
def write_training_file(train_data, output_file, feat_map):
print("Writing XGB Training file with %s rows to %s" % (train_data.count(), output_file))
col_names = train_data.keys()
# We don't want to write everything out, some items we've been tracking are reserved or not needed for the model
exclusions = {"query_id", "doc_id", "rank", "query", "sku", "product_name", "grade", "clicks", "num_impressions"}
with open(output_file, 'bw') as output:
for item in train_data.itertuples(index=False): # skip the first 'index' element from the DF
# Pull out the specific items from the Pandas named tuple. The rest goes in the features map.
# if there is a norm version, take that
#
features = get_features(item, exclusions, col_names)
xgb_format = to_xgb_format(item.query_id, item.doc_id, item.rank, item.query,
item.product_name, item.grade, features)
output.write(bytes(xgb_format + "\n", 'utf-8'))
# We need to write out the feature map, probably more needed here
if feat_map:
print("Writing feature map to %s" % feat_map)
with open(feat_map, 'w') as feat_map_file:
item = train_data.iloc[1:2]
features = get_features(item, exclusions, col_names)
feat_map_file.write("0\tna\tq\n")
for idx, feat in enumerate(features.keys()):
#https://docs.rs/xgboost/0.1.4/xgboost/struct.FeatureMap.html are the only docs I can find on the format
if feat != "onSale":
feat_map_file.write('{}\t{}\tq\n'.format(idx+1,feat))#idx+2 b/c we are one-based for this
else: #Kludgy way of handling onSale being at some point. For now, write it out as 'q'
# Bug in LTR prevents 'indicator'/boolean features, so model as q for now by
# encoding onSale as a percentage discount
feat_map_file.write('{}\t{}\tq\n'.format(idx+1,feat)) #make the q an i
def write_opensearch_ltr_model(model_name, model, model_file, objective="rank:pairwise"):
model_str = '[' + ','.join(list(model)) + ']'
#print(model_str)
os_model = {
"model": {
"name": model_name,
"model": {
"type": "model/xgboost+json",
"definition": '{"objective":"%s", "splits": %s}' % (objective, model_str)
}
}
}
print("Saving XGB LTR-ready model to %s.ltr" % model_file)
with open("%s.ltr" % model_file, 'w') as ltr_model:
ltr_model.write(json.dumps(os_model))
def create_ltr_store(ltr_model_path, auth, delete_old=True):
if delete_old:
resp = requests.delete(ltr_model_path, auth=auth, verify=False)
print("Deleted old store response status: %s" % resp.status_code)
# Create our new LTR storage
resp = requests.put(ltr_model_path, auth=auth, verify=False)
print("Create the new store at %s response status: %s" % (ltr_model_path, resp.status_code))
return resp
def post_featureset(featureset_path, ltr_feature_set, auth, headers={"Content-Type": 'application/json'}):
print("POSTing the featureset to %s" % (featureset_path))
resp = requests.post(featureset_path, headers=headers, data=json.dumps(ltr_feature_set), auth=auth, verify=False)
return resp
def delete_model(model_path, auth):
print("Deleting model from %s" % model_path)
response = requests.delete(model_path, auth=auth, verify=False)
print("\tDelete Model Response: %s: %s" % (response.status_code, response.text))
return response
def upload_model(model_path, os_model, auth):
print("Uploading model to %s" % model_path)
headers = {"Content-Type": 'application/json'}
response = requests.post(model_path, data=json.dumps(os_model), headers=headers, auth=auth, verify=False)
print("\tUpload Model Response: %s: %s" % (response.status_code, response.text))
return response | 45.29902 | 129 | 0.595715 |
0721054fb24f719e20b86ffb190d1670eb081792 | 470 | py | Python | api/students/migrations/0017_auto_20200613_0833.py | Latiftanga/twysis-api | efec6164bb9b4e46647b55f03f29287418451896 | [
"MIT"
] | null | null | null | api/students/migrations/0017_auto_20200613_0833.py | Latiftanga/twysis-api | efec6164bb9b4e46647b55f03f29287418451896 | [
"MIT"
] | null | null | null | api/students/migrations/0017_auto_20200613_0833.py | Latiftanga/twysis-api | efec6164bb9b4e46647b55f03f29287418451896 | [
"MIT"
] | null | null | null | # Generated by Django 3.1a1 on 2020-06-13 08:33
from django.db import migrations, models
import students.models
class Migration(migrations.Migration):
dependencies = [
('students', '0016_auto_20200612_2047'),
]
operations = [
migrations.AlterField(
model_name='student',
name='image',
field=models.ImageField(blank=True, null=True, upload_to=students.models.student_image_file_path),
),
]
| 23.5 | 110 | 0.648936 |
2450f18ec1fc6f07003808419164843ec324de84 | 2,629 | py | Python | tests/test__plotly.py | soerendip/ms-mint | bf5f5d87d07a0d2108c6cd0d92c278f2ea762e58 | [
"MIT"
] | 1 | 2021-09-03T04:02:25.000Z | 2021-09-03T04:02:25.000Z | tests/test__plotly.py | soerendip/ms-mint | bf5f5d87d07a0d2108c6cd0d92c278f2ea762e58 | [
"MIT"
] | 3 | 2020-09-29T21:43:39.000Z | 2021-07-21T22:18:27.000Z | tests/test__plotly.py | soerendip/ms-mint | bf5f5d87d07a0d2108c6cd0d92c278f2ea762e58 | [
"MIT"
] | 4 | 2019-11-14T13:25:24.000Z | 2021-04-30T22:08:53.000Z | import pandas as pd
import numpy as np
from plotly.graph_objs._figure import Figure
from ms_mint import Mint
from ms_mint.vis.plotly import (
set_template,
plotly_heatmap,
plotly_peak_shapes,
plotly_peak_shapes_3d,
)
from paths import TEST_FEATHER, TEST_TARGETS_FN
def test__plotly_heatmap():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df)
assert isinstance(img, Figure), type(img)
def test__plotly_heatmap__transposed():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df, transposed=True)
assert isinstance(img, Figure), type(img)
def test__plotly_heatmap__normed_by_cols():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df, normed_by_cols=True)
assert isinstance(img, Figure), type(img)
def test__plotly_heatmap__correlation():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df, correlation=True)
assert isinstance(img, Figure), type(img)
def test__plotly_heatmap__clustered_with_dendrogram():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df, clustered=True, add_dendrogram=True)
assert isinstance(img, Figure), type(img)
def test__plotly_heatmap__clustered_correlation():
N = 10
data = np.random.uniform(size=(N, N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
img = plotly_heatmap(df, clustered=True, add_dendrogram=False, correlation=True)
assert isinstance(img, Figure), type(img)
"""
def test__plotly_heatmap__call_show():
N = 10
data = np.random.uniform(size=(N,N)) + np.arange(N) - N / 2
df = pd.DataFrame(data)
df.index.name = 'INDEX'
df.columns.name = 'COLUMNS'
img = plotly_heatmap(df, call_show=True, name='TEST')
assert img is None, type(img)
"""
def test__plotly_peak_shapes():
mint = Mint()
mint.ms_files = TEST_FEATHER
mint.targets_files = TEST_TARGETS_FN
mint.run()
img = plotly_peak_shapes(mint.results)
assert isinstance(img, Figure), type(img)
def test__plotly_peak_shapes_3d():
mint = Mint()
mint.ms_files = TEST_FEATHER
mint.targets_files = TEST_TARGETS_FN
mint.run()
img = plotly_peak_shapes_3d(mint.results, peak_label="11")
assert isinstance(img, Figure), type(img)
def test__set_template():
set_template()
assert True
| 26.555556 | 84 | 0.682008 |
aa7315c92bd2933b92a1a7f406fbee17040048cf | 1,340 | py | Python | leetcode/3sum.py | federicoemartinez/problem_solving | d0352f76bc21ed67d6851a159a00f70a892934b9 | [
"MIT"
] | null | null | null | leetcode/3sum.py | federicoemartinez/problem_solving | d0352f76bc21ed67d6851a159a00f70a892934b9 | [
"MIT"
] | null | null | null | leetcode/3sum.py | federicoemartinez/problem_solving | d0352f76bc21ed67d6851a159a00f70a892934b9 | [
"MIT"
] | null | null | null | # https://leetcode.com/problems/3sum/description/
"""
Given an array nums of n integers, are there elements a, b, c in nums such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
Note:
The solution set must not contain duplicate triplets.
Example:
Given array nums = [-1, 0, 1, 2, -1, -4],
A solution set is:
[
[-1, 0, 1],
[-1, -1, 2]
]
"""
from collections import defaultdict
class Solution:
def threeSum(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
nums_dict = defaultdict(lambda: 0)
for each in nums:
nums_dict[each] +=1
sol = set()
lenght = len(nums)
used_i = set()
for i in range(lenght):
if nums[i] in used_i:
continue
used_j = set()
for j in range(i+1, lenght):
if nums[j] in used_j: continue
k = -1*(nums[i] + nums[j])
if ( k in nums_dict and nums_dict[k] > ((1 if nums[j] == k else 0) + (1 if nums[i] == k else 0))):
l = [nums[i],nums[j],k]
l.sort()
sol.add(tuple(l))
used_i.add(nums[i])
used_j.add(nums[j])
return [list(x) for x in sol]
| 28.510638 | 161 | 0.495522 |
2a46a6da44014cca9299d38705fa2c115deb3c7b | 6,128 | py | Python | torchdata/datapipes/iter/util/dataframemaker.py | jkulhanek/torchdata | 2e8b9f613a13c74b424651649f317c7b322131d6 | [
"BSD-3-Clause"
] | 611 | 2021-09-27T18:19:16.000Z | 2022-03-31T11:36:01.000Z | torchdata/datapipes/iter/util/dataframemaker.py | jkulhanek/torchdata | 2e8b9f613a13c74b424651649f317c7b322131d6 | [
"BSD-3-Clause"
] | 271 | 2021-09-27T19:07:00.000Z | 2022-03-30T19:55:14.000Z | torchdata/datapipes/iter/util/dataframemaker.py | jkulhanek/torchdata | 2e8b9f613a13c74b424651649f317c7b322131d6 | [
"BSD-3-Clause"
] | 36 | 2021-09-27T19:22:32.000Z | 2022-03-29T12:49:06.000Z | # Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
from functools import partial
from typing import List, Optional, TypeVar
from torch.utils.data.datapipes.utils.common import DILL_AVAILABLE
from torchdata.datapipes import functional_datapipe
from torchdata.datapipes.iter import IterDataPipe
try: # TODO: Create dependency on TorchArrow?
import pyarrow.parquet as parquet
import torcharrow
except ImportError:
torcharrow = None
parquet = None
if DILL_AVAILABLE:
import dill
dill.extend(use_dill=False)
T_co = TypeVar("T_co")
@functional_datapipe("dataframe")
class DataFrameMakerIterDataPipe(IterDataPipe): # IterDataPipe[torcharrow.IDataFrame[T_co]]
r"""
Takes rows of data, batches a number of them together and creates `TorchArrow`
DataFrames (functional name: ``dataframe``).
Note:
There is a trade-off between having a large number of rows within a DataFrame and usage of memory. Please
choose a value carefully.
Args:
source_dp: IterDataPipe containing rows of data
dataframe_size: number of rows of data within each DataFrame, page size can be option
dtype: specify the `TorchArrow` dtype for the DataFrame, use ``torcharrow.dtypes.DType``
columns: List of str that specifies the column names of the DataFrame
device: specify the device on which the DataFrame will be stored
Example:
>>> from torchdata.datapipes.iter import IterableWrapper
>>> import torcharrow.dtypes as dt
>>> source_data = [(i,) for i in range(3)]
>>> source_dp = IterableWrapper(source_data)
>>> DTYPE = dt.Struct([dt.Field("Values", dt.int32)])
>>> df_dp = source_dp.dataframe(dtype=DTYPE)
>>> list(df_dp)[0]
index Values
------- --------
0 0
1 1
2 2
dtype: Struct([Field('Values', int32)]), count: 3, null_count: 0
"""
def __new__(
cls,
source_dp: IterDataPipe[T_co],
dataframe_size: int = 1000,
dtype=None,
columns: Optional[List[str]] = None,
device: str = "",
):
if torcharrow is None:
raise ImportError(
"The library 'torcharrow' is necessary for this DataPipe but it is not available."
"Please visit https://github.com/facebookresearch/torcharrow/ to install it."
)
# In this version, DF tracing is not available, which would allow DataPipe to run DataFrame operations
batch_dp = source_dp.batch(dataframe_size)
df_dp = batch_dp.map(partial(torcharrow.dataframe, dtype=dtype, columns=columns, device=device))
return df_dp
@functional_datapipe("load_parquet_as_df")
class ParquetDFLoaderIterDataPipe(IterDataPipe): # IterDataPipe[torcharrow.IDataFrame[T_co]]
r"""
Takes in paths to Parquet files and return a `TorchArrow` DataFrame for each row group
within a Parquet file (functional name: ``load_parquet_as_df``).
Args:
source_dp: source DataPipe containing paths to the Parquet files
columns: List of `str` that specifies the column names of the DataFrame
use_threads: if ``True``, Parquet reader will perform multi-threaded column reads
dtype: specify the `TorchArrow` dtype for the DataFrame, use ``torcharrow.dtypes.DType``
device: specify the device on which the DataFrame will be stored
Example:
>>> from torchdata.datapipes.iter import FileLister
>>> import torcharrow.dtypes as dt
>>> DTYPE = dt.Struct([dt.Field("Values", dt.int32)])
>>> source_dp = FileLister(".", masks="df*.parquet")
>>> parquet_df_dp = source_dp.load_parquet_as_df(dtype=DTYPE)
>>> list(parquet_df_dp)[0]
index Values
------- --------
0 0
1 1
2 2
dtype: Struct([Field('Values', int32)]), count: 3, null_count: 0
"""
def __init__(
self,
source_dp: IterDataPipe[str],
dtype=None,
columns: Optional[List[str]] = None,
device: str = "",
use_threads: bool = False,
):
if torcharrow is None:
raise ImportError(
"The library 'torcharrow' is necessary for this DataPipe but it is not available."
"Please visit https://github.com/facebookresearch/torcharrow/ to install it."
)
if parquet is None:
raise ImportError("The library 'parquet' is necessary for this DataPipe but it is not available.")
self.source_dp = source_dp
self.columns = columns
self.use_threads = use_threads
self.dtype = dtype
self.device = device
def __iter__(self):
for path in self.source_dp:
parquet_file = parquet.ParquetFile(path)
num_row_groups = parquet_file.num_row_groups
for i in range(num_row_groups):
# TODO: More fine-grain control over the number of rows or row group per DataFrame
row_group = parquet_file.read_row_group(i, columns=self.columns, use_threads=self.use_threads)
yield torcharrow.from_arrow(row_group, dtype=self.dtype)
def __getstate__(self):
if IterDataPipe.getstate_hook is not None:
return IterDataPipe.getstate_hook(self)
if DILL_AVAILABLE:
dill_dtype = dill.dumps(self.dtype)
else:
dill_dtype = self.dtype
state = (self.source_dp, dill_dtype, self.columns, self.device, self.use_threads)
return state
def __setstate__(self, state):
(self.source_dp, dill_dtype, self.columns, self.device, self.use_threads) = state
if DILL_AVAILABLE:
self.dtype = dill.loads(dill_dtype) # type: ignore[assignment]
else:
self.dtype = dill_dtype # type: ignore[assignment]
| 39.031847 | 113 | 0.641319 |
95624fb5763eaeccd3f36238d33e21119e5853c0 | 4,787 | py | Python | litex_boards/targets/mercury_xu5.py | stffrdhrn/litex-boards | 6139bd7eba80a866e1e60a0b4bc9f34251fef919 | [
"BSD-2-Clause"
] | null | null | null | litex_boards/targets/mercury_xu5.py | stffrdhrn/litex-boards | 6139bd7eba80a866e1e60a0b4bc9f34251fef919 | [
"BSD-2-Clause"
] | null | null | null | litex_boards/targets/mercury_xu5.py | stffrdhrn/litex-boards | 6139bd7eba80a866e1e60a0b4bc9f34251fef919 | [
"BSD-2-Clause"
] | null | null | null | #!/usr/bin/env python3
#
# This file is part of LiteX-Boards.
#
# Copyright (c) 2020 Antmicro <www.antmicro.com>
# SPDX-License-Identifier: BSD-2-Clause
import os
import argparse
from migen import *
from migen.genlib.resetsync import AsyncResetSynchronizer
from litex_boards.platforms import mercury_xu5
from litex.soc.cores.clock import *
from litex.soc.integration.soc_core import *
from litex.soc.integration.soc_sdram import *
from litex.soc.integration.builder import *
from litex.soc.cores.led import LedChaser
from litedram.modules import MT40A256M16
from litedram.phy import usddrphy
# CRG ----------------------------------------------------------------------------------------------
class _CRG(Module):
def __init__(self, platform, sys_clk_freq):
self.rst = Signal()
self.clock_domains.cd_sys = ClockDomain()
self.clock_domains.cd_sys4x = ClockDomain(reset_less=True)
self.clock_domains.cd_pll4x = ClockDomain(reset_less=True)
self.clock_domains.cd_idelay = ClockDomain()
# # #
self.submodules.pll = pll = USMMCM(speedgrade=-1)
self.comb += pll.reset.eq(self.rst)
pll.register_clkin(platform.request("clk100"), 100e6)
pll.create_clkout(self.cd_pll4x, sys_clk_freq*4, buf=None, with_reset=False)
pll.create_clkout(self.cd_idelay, 500e6)
platform.add_false_path_constraints(self.cd_sys.clk, pll.clkin) # Ignore sys_clk to pll.clkin path created by SoC's rst.
self.specials += [
Instance("BUFGCE_DIV", name="main_bufgce_div",
p_BUFGCE_DIVIDE=4,
i_CE=1, i_I=self.cd_pll4x.clk, o_O=self.cd_sys.clk),
Instance("BUFGCE", name="main_bufgce",
i_CE=1, i_I=self.cd_pll4x.clk, o_O=self.cd_sys4x.clk),
AsyncResetSynchronizer(self.cd_idelay, ~pll.locked),
]
self.submodules.idelayctrl = USIDELAYCTRL(cd_ref=self.cd_idelay, cd_sys=self.cd_sys)
# BaseSoC ------------------------------------------------------------------------------------------
class BaseSoC(SoCCore):
def __init__(self, sys_clk_freq=int(125e6), **kwargs):
platform = mercury_xu5.Platform()
# SoCCore ----------------------------------------------------------------------------------
SoCCore.__init__(self, platform, sys_clk_freq,
ident = "LiteX SoC on Mercury XU5",
ident_version = True,
**kwargs)
# CRG --------------------------------------------------------------------------------------
self.submodules.crg = _CRG(platform, sys_clk_freq)
# DDR4 SDRAM -------------------------------------------------------------------------------
if not self.integrated_main_ram_size:
self.submodules.ddrphy = usddrphy.USPDDRPHY(platform.request("ddram"),
memtype = "DDR4",
sys_clk_freq = sys_clk_freq,
iodelay_clk_freq = 500e6)
self.add_csr("ddrphy")
self.add_sdram("sdram",
phy = self.ddrphy,
module = MT40A256M16(sys_clk_freq, "1:4"),
origin = self.mem_map["main_ram"],
size = kwargs.get("max_sdram_size", 0x40000000),
l2_cache_size = kwargs.get("l2_size", 8192),
l2_cache_min_data_width = kwargs.get("min_l2_data_width", 128),
l2_cache_reverse = True
)
# Leds -------------------------------------------------------------------------------------
self.submodules.leds = LedChaser(
pads = platform.request_all("user_led"),
sys_clk_freq = sys_clk_freq)
self.add_csr("leds")
# Build --------------------------------------------------------------------------------------------
def main():
parser = argparse.ArgumentParser(description="LiteX SoC on Mercury XU5")
parser.add_argument("--build", action="store_true", help="Build bitstream")
parser.add_argument("--load", action="store_true", help="Load bitstream")
parser.add_argument("--sys-clk-freq", default=125e6, help="System clock frequency (default: 125MHz)")
builder_args(parser)
soc_sdram_args(parser)
args = parser.parse_args()
soc = BaseSoC(
sys_clk_freq = int(float(args.sys_clk_freq)),
**soc_sdram_argdict(args)
)
builder = Builder(soc, **builder_argdict(args))
builder.build(run=args.build)
if args.load:
prog = soc.platform.create_programmer()
prog.load_bitstream(os.path.join(builder.gateware_dir, soc.build_name + ".bit"))
if __name__ == "__main__":
main()
| 40.567797 | 128 | 0.545644 |
631e48e6669faabeff01f7a8518f827acd04fdd4 | 346 | py | Python | catalog/Marshall PY/run.py | derwear/bots.hub | 894de2a6325dbb3b5541960c9031cc9ffb36a310 | [
"Unlicense"
] | 8 | 2021-08-31T14:27:38.000Z | 2022-03-28T14:52:47.000Z | catalog/Marshall PY/run.py | derwear/bots.hub | 894de2a6325dbb3b5541960c9031cc9ffb36a310 | [
"Unlicense"
] | null | null | null | catalog/Marshall PY/run.py | derwear/bots.hub | 894de2a6325dbb3b5541960c9031cc9ffb36a310 | [
"Unlicense"
] | 4 | 2021-08-31T15:50:45.000Z | 2022-02-25T09:48:42.000Z | from kutana import Kutana, VKController, load_plugins, load_configuration
# Create engine
kutana = Kutana()
# Create VKController
kutana.add_controller(
VKController(token = "Сюда напиши свой токен API")
)
# Load and register plugins
kutana.executor.register_plugins(*load_plugins("/root/bot/example/plugins"))
# Run engine
kutana.run()
| 20.352941 | 76 | 0.774566 |
780f3dd4f8ab89857b45c8f75eeba724bd64c2bf | 3,196 | py | Python | eurlex2lexparency/transformation/formex/quote.py | Lexparency/eurlex2lexparency | b4958f6fea5c2207eb06d2c3b91be798720c94bd | [
"MIT"
] | null | null | null | eurlex2lexparency/transformation/formex/quote.py | Lexparency/eurlex2lexparency | b4958f6fea5c2207eb06d2c3b91be798720c94bd | [
"MIT"
] | null | null | null | eurlex2lexparency/transformation/formex/quote.py | Lexparency/eurlex2lexparency | b4958f6fea5c2207eb06d2c3b91be798720c94bd | [
"MIT"
] | null | null | null | from lxml import etree as et
from enum import Enum
import logging
from eurlex2lexparency.utils import xtml
from eurlex2lexparency.utils.xtml import unfold
class _QuotationClass(Enum):
inline = 'span'
block = 'div'
class QuoteTransformer:
start_to_type = {
'QUOT.START': _QuotationClass.inline,
'QUOT.S': _QuotationClass.block
}
def __init__(self, start: et.ElementBase, end: et.ElementBase,
logger=None):
self.logger = logger or logging.getLogger()
self.open = start
self.close = end
self.type = self.start_to_type[self.open.tag]
self._transform()
def _remove_attribs(self):
for element in (self.open, self.close):
for key in element.attrib:
if key.isupper():
element.attrib.pop(key, None)
def _transform(self):
if self.open.getparent() == self.close.getparent():
self._transform_siblings()
else:
self._transform_skewed_pair()
def _transform_skewed_pair(self):
self.logger.warning("Moving skew quotation marks!")
fca = self.first_common_ancestor
if fca == self.open.getparent():
if (self.close.tail or '').strip() in ',;.':
# move the closing element
for ancestor in reversed(self.close.xpath('ancestor::*')):
if ancestor != fca:
ancestor.addnext(self.close)
else:
break
else: # if no break occurs
raise RuntimeError('Could not bring quotes on same level.')
elif (self.open.tail or '').strip() == '':
# move opening element down.
while self.close.getparent() != self.first_common_ancestor:
adjacent = self.open.getnext()
if adjacent is None:
break
xtml.push(adjacent, self.open)
fca = self.first_common_ancestor
if fca == self.open.getparent() == self.close.getparent():
self._transform_siblings()
else:
# OK. Maybe that's a cheap way ... should work
xtml.remove(self.open)
xtml.remove(self.close)
def _transform_siblings(self):
self._remove_attribs()
self.open.tag = self.type.value
self.open.attrib['class'] = 'lxp-quotation'
# subsequent transformation asserts open and close are siblings
self.open.text = self.open.tail
self.open.tail = None
for sibling in self.open.itersiblings():
if sibling == self.close:
unfold(sibling)
break
self.open.append(sibling)
@property
def first_common_ancestor(self):
common_ancestor = None
for open_ancestor, close_ancestor in zip(self.open.xpath('ancestor::*'),
self.close.xpath('ancestor::*')):
if open_ancestor == close_ancestor:
common_ancestor = open_ancestor
else:
break
return common_ancestor
| 34.73913 | 82 | 0.560701 |
8808ec2c5c02f855d0bcfd9e44b9fc6a355fccbc | 9,250 | py | Python | venv/lib/python3.6/site-packages/ansible_collections/sensu/sensu_go/tests/unit/plugins/modules/test_event.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | 1 | 2020-01-22T13:11:23.000Z | 2020-01-22T13:11:23.000Z | venv/lib/python3.6/site-packages/ansible_collections/sensu/sensu_go/tests/unit/plugins/modules/test_event.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | 12 | 2020-02-21T07:24:52.000Z | 2020-04-14T09:54:32.000Z | venv/lib/python3.6/site-packages/ansible_collections/sensu/sensu_go/tests/unit/plugins/modules/test_event.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | null | null | null | from __future__ import absolute_import, division, print_function
__metaclass__ = type
import sys
import pytest
from ansible_collections.sensu.sensu_go.plugins.module_utils import (
errors, http,
)
from ansible_collections.sensu.sensu_go.plugins.modules import event
from .common.utils import (
AnsibleExitJson, AnsibleFailJson, ModuleTestCase, set_module_args,
)
pytestmark = pytest.mark.skipif(
sys.version_info < (2, 7), reason="requires python2.7 or higher"
)
class TestGetObjects:
def test_get_entity(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(200, '{"entity": "entity"}')
resp = event.get_entity(client, 'default', 'entity')
assert resp == {'entity': 'entity'}
def test_get_entity_404(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(404, '')
with pytest.raises(errors.SyncError,
match="Entity with name 'entity' does not exist on remote."):
event.get_entity(client, 'default', 'entity')
def test_get_check(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(200, '{"check": "check"}')
resp = event.get_check(client, 'default', 'check')
assert resp == {'check': 'check'}
def test_get_check_404(self, mocker):
client = mocker.Mock()
client.get.return_value = http.Response(404, '')
with pytest.raises(errors.SyncError,
match="Check with name 'check' does not exist on remote."):
event.get_check(client, 'default', 'check')
class TestEvent(ModuleTestCase):
def test_missing_entity_on_remote(self, mocker):
get_entity_mock = mocker.patch.object(event, 'get_entity')
get_entity_mock.side_effect = errors.SyncError('Error')
set_module_args(
entity='awesome_entity',
check='awesome_check',
)
with pytest.raises(AnsibleFailJson, match='Error'):
event.main()
def test_missing_check_on_remote(self, mocker):
mocker.patch.object(event, 'get_entity')
get_check_mock = mocker.patch.object(event, 'get_check')
get_check_mock.side_effect = errors.SyncError('Error')
set_module_args(
entity='awesome_entity',
check='awesome_check',
)
with pytest.raises(AnsibleFailJson, match='Error'):
event.main()
def test_minimal_event_parameters(self, mocker):
send_event_mock = mocker.patch.object(event, 'send_event')
send_event_mock.return_value = True, {}
get_entity_mock = mocker.patch.object(event, 'get_entity')
get_entity_mock.return_value = dict(
metadata=dict(
name='awesome_entity',
namespace='default'
),
entity_class='proxy'
)
get_check_mock = mocker.patch.object(event, 'get_check')
get_check_mock.return_value = dict(
metadata=dict(
name='awesome_check',
namespace='default'
)
)
set_module_args(
entity='awesome_entity',
check='awesome_check',
)
with pytest.raises(AnsibleExitJson):
event.main()
_client, path, payload, check_mode = send_event_mock.call_args[0]
assert path == '/api/core/v2/namespaces/default/events/awesome_entity/awesome_check'
assert payload == dict(
metadata=dict(
namespace='default'
),
entity=dict(
metadata=dict(
name='awesome_entity',
namespace='default'
),
entity_class='proxy'
),
check=dict(
metadata=dict(
name='awesome_check',
namespace='default'
)
)
)
assert check_mode is False
def test_all_event_parameters(self, mocker):
entity_object = dict(
metadata=dict(
name='awesome_entity',
namespace='default'
),
entity_class='proxy'
)
check_object = dict(
metadata=dict(
name='awesome_check',
namespace='default'
),
command="check-cpu.sh -w 75 -c 90",
handlers=["slack"],
interval=60,
publish=True,
subscriptions=["linux"],
)
send_event_mock = mocker.patch.object(event, 'send_event')
send_event_mock.return_value = True, {}
get_entity_mock = mocker.patch.object(event, 'get_entity')
get_entity_mock.return_value = entity_object
get_check_mock = mocker.patch.object(event, 'get_check')
get_check_mock.return_value = check_object
set_module_args(
namespace='my',
timestamp=1234567,
entity='awesome_entity',
check='awesome_check',
check_attributes=dict(
duration=1.945,
executed=1522100915,
history=[
dict(
executed=1552505193,
status=1
),
dict(
executed=1552505293,
status=0
),
dict(
executed=1552505393,
status=0
),
dict(
executed=1552505493,
status=0
)
],
issued=1552506033,
last_ok=1552506033,
output='10',
state='passing',
status='ok',
total_state_change=0
),
metric_attributes=dict(
handlers=['handler1', 'handler2'],
points=[{
'name': 'sensu-go-sandbox.curl_timings.time_total',
'tags': [],
'timestamp': 1552506033,
'value': 0.005
}, {
'name': 'sensu-go-sandbox.curl_timings.time_namelookup',
'tags': [],
'timestamp': 1552506033,
'value': 0.004
}]
)
)
with pytest.raises(AnsibleExitJson):
event.main()
_client, path, payload, check_mode = send_event_mock.call_args[0]
assert path == '/api/core/v2/namespaces/my/events/awesome_entity/awesome_check'
assert payload == dict(
metadata=dict(
namespace='my'
),
timestamp=1234567,
entity=dict(
metadata=dict(
name='awesome_entity',
namespace='default'
),
entity_class='proxy'
),
check=dict(
metadata=dict(
name='awesome_check',
namespace='default'
),
command="check-cpu.sh -w 75 -c 90",
handlers=["slack"],
interval=60,
publish=True,
subscriptions=["linux"],
duration=1.945,
executed=1522100915,
history=[
dict(
executed=1552505193,
status=1
),
dict(
executed=1552505293,
status=0
),
dict(
executed=1552505393,
status=0
),
dict(
executed=1552505493,
status=0
)
],
issued=1552506033,
last_ok=1552506033,
output='10',
state='passing',
status=0,
total_state_change=0
),
metrics=dict(
handlers=['handler1', 'handler2'],
points=[{
'name': 'sensu-go-sandbox.curl_timings.time_total',
'tags': [],
'timestamp': 1552506033,
'value': 0.005
}, {
'name': 'sensu-go-sandbox.curl_timings.time_namelookup',
'tags': [],
'timestamp': 1552506033,
'value': 0.004
}]
)
)
assert check_mode is False
def test_failure(self, mocker):
get_entity_mock = mocker.patch.object(event, 'get_entity')
get_entity_mock.side_effect = errors.Error('Bad error')
set_module_args(
entity='awesome_entity',
check=dict(
name='awesome_check'
)
)
with pytest.raises(AnsibleFailJson):
event.main()
| 32.229965 | 92 | 0.488108 |
c7312057ca2fea1869032068f96198949bf0fef4 | 222 | py | Python | python/strings/split_and_join.py | scouvreur/hackerrank | 93a52ed6a744ce41fd215d8007435a682228fa01 | [
"MIT"
] | 1 | 2021-01-28T14:23:24.000Z | 2021-01-28T14:23:24.000Z | python/strings/split_and_join.py | scouvreur/hackerrank | 93a52ed6a744ce41fd215d8007435a682228fa01 | [
"MIT"
] | null | null | null | python/strings/split_and_join.py | scouvreur/hackerrank | 93a52ed6a744ce41fd215d8007435a682228fa01 | [
"MIT"
] | null | null | null | def split_and_join(line):
# write your code here
line = line.split(" ")
line = "-".join(line)
return line
if __name__ == "__main__":
line = input()
result = split_and_join(line)
print(result)
| 18.5 | 33 | 0.608108 |
6e1a2636c6ccf38c496943600f0e06cc034d1d0c | 21,859 | py | Python | tests/unit/small_text/query_strategies/test_strategies.py | emamarela/small-text | 0df5ad0d42511dd306ab367de7c6c01dab58f653 | [
"MIT"
] | 218 | 2021-05-26T16:38:53.000Z | 2022-03-30T09:48:54.000Z | tests/unit/small_text/query_strategies/test_strategies.py | emamarela/small-text | 0df5ad0d42511dd306ab367de7c6c01dab58f653 | [
"MIT"
] | 9 | 2021-10-16T23:23:02.000Z | 2022-02-22T15:23:11.000Z | tests/unit/small_text/query_strategies/test_strategies.py | emamarela/small-text | 0df5ad0d42511dd306ab367de7c6c01dab58f653 | [
"MIT"
] | 21 | 2021-06-24T11:19:44.000Z | 2022-03-12T16:29:53.000Z | import unittest
import numpy as np
from numpy.testing import assert_array_equal, assert_array_almost_equal
from sklearn.preprocessing import normalize
from unittest.mock import patch, Mock
from small_text.classifiers import ConfidenceEnhancedLinearSVC, SklearnClassifier
from small_text.query_strategies import EmptyPoolException, PoolExhaustedException
from small_text.query_strategies import (RandomSampling,
SubsamplingQueryStrategy,
BreakingTies,
LeastConfidence,
PredictionEntropy,
EmbeddingBasedQueryStrategy,
EmbeddingKMeans)
DEFAULT_QUERY_SIZE = 10
def query_random_data(strategy, num_samples=100, n=10, use_embeddings=False, embedding_dim=100):
x = np.random.rand(num_samples, 10)
kwargs = dict()
if use_embeddings:
kwargs['embeddings'] = np.random.rand(SamplingStrategiesTests.DEFAULT_NUM_SAMPLES,
embedding_dim)
x_indices_labeled = np.random.choice(np.arange(num_samples), size=10, replace=False)
x_indices_unlabeled = np.array([i for i in range(x.shape[0])
if i not in set(x_indices_labeled)])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
return strategy.query(None,
x,
x_indices_unlabeled,
x_indices_labeled,
y,
n=n,
**kwargs)
class SamplingStrategiesTests(object):
DEFAULT_NUM_SAMPLES = 100
def _get_clf(self):
return ConfidenceEnhancedLinearSVC()
def _get_query_strategy(self):
raise NotImplementedError()
def test_simple_query(self):
"""Tests a query of n=5."""
indices = self._query(self._get_query_strategy(),
num_samples=self.DEFAULT_NUM_SAMPLES,
n=5)
self.assertEqual(5, len(indices))
def test_default_query(self):
"""Tests the query with default args."""
indices = self._query(self._get_query_strategy(),
num_samples=self.DEFAULT_NUM_SAMPLES)
self.assertEqual(DEFAULT_QUERY_SIZE, len(indices))
def test_query_takes_remaining_pool(self):
indices = self._query(self._get_query_strategy(),
num_samples=self.DEFAULT_NUM_SAMPLES,
n=10)
self.assertEqual(DEFAULT_QUERY_SIZE, len(indices))
def test_query_exhausts_pool(self):
"""Tests for PoolExhaustedException."""
with self.assertRaises(PoolExhaustedException):
self._query(self._get_query_strategy(), n=11)
def _query(self, strategy, num_samples=20, n=10, **kwargs):
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(num_samples), size=10, replace=False)
x_indices_unlabeled = np.array([i for i in range(x.shape[0])
if i not in set(x_indices_labeled)])
clf_mock = self._get_clf()
if clf_mock is not None:
proba = np.random.random_sample((num_samples, 2))
clf_mock.predict_proba = Mock(return_value=proba)
# TODO: must be of size `num_samples`
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
return strategy.query(clf_mock, x, x_indices_unlabeled, x_indices_labeled, y, n=n, **kwargs)
class RandomSamplingTest(unittest.TestCase, SamplingStrategiesTests):
def _get_clf(self):
return None
def _get_query_strategy(self):
return RandomSampling()
def test_random_sampling_str(self):
strategy = RandomSampling()
self.assertEqual('RandomSampling()', str(strategy))
def test_random_sampling_query_default(self):
indices = query_random_data(self._get_query_strategy())
self.assertEqual(10, len(indices))
def test_random_sampling_empty_pool(self, num_samples=20, n=10):
strategy = RandomSampling()
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = []
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
with self.assertRaises(EmptyPoolException):
strategy.query(None, x, x_indices_unlabeled, x_indices_labeled, y, n=n)
class BreakingTiesTest(unittest.TestCase, SamplingStrategiesTests):
def _get_clf(self):
return ConfidenceEnhancedLinearSVC()
def _get_query_strategy(self):
return BreakingTies()
def test_breaking_ties_str(self):
strategy = self._get_query_strategy()
self.assertEqual('BreakingTies()', str(strategy))
def test_breaking_ties_binary(self):
proba = np.array([
[0.1, 0.9],
[0.45, 0.55],
[0.5, 0.5],
[0.7, 0.3]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([2, 1])
assert_array_equal(expected, indicies)
self.assertIsNotNone(strategy.scores_)
assert_array_almost_equal(np.array([0.8, 0.1, 0, 0.4]), strategy.scores_)
def test_breaking_ties_multiclass(self):
proba = np.array([
[0.1, 0.75, 0.15],
[0.45, 0.5, 0.05],
[0.1, 0.8, 0.1],
[0.7, 0.15, 0.15]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([1, 3])
assert_array_equal(expected, indicies)
self.assertIsNotNone(strategy.scores_)
assert_array_almost_equal(np.array([0.6, 0.05, 0.7, 0.55]), strategy.scores_)
class LeastConfidenceTest(unittest.TestCase, SamplingStrategiesTests):
def _get_clf(self):
return ConfidenceEnhancedLinearSVC()
def _get_query_strategy(self):
return LeastConfidence()
def test_least_confidence_str(self):
strategy = self._get_query_strategy()
self.assertEqual('LeastConfidence()', str(strategy))
def test_least_confidence_binary(self):
proba = np.array([
[0.1, 0.9],
[0.45, 0.55],
[0.2, 0.8],
[0.7, 0.3]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([1, 3])
assert_array_equal(expected, indicies)
self.assertIsNotNone(strategy.scores_)
assert_array_almost_equal(np.array([0.9, 0.55, 0.8, 0.7]), strategy.scores_)
def test_least_confidence_multiclass(self):
proba = np.array([
[0.1, 0.75, 0.15],
[0.45, 0.5, 0.05],
[0.1, 0.8, 0.1],
[0.7, 0.15, 0.15]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([1, 3])
assert_array_equal(expected, indicies)
self.assertIsNotNone(strategy.scores_)
assert_array_almost_equal(np.array([0.75, 0.5, 0.8, 0.7]), strategy.scores_)
class PredictionEntropyTest(unittest.TestCase, SamplingStrategiesTests):
def _get_clf(self):
return ConfidenceEnhancedLinearSVC()
def _get_query_strategy(self):
return PredictionEntropy()
def test_prediction_entropy_str(self):
strategy = self._get_query_strategy()
self.assertEqual('PredictionEntropy()', str(strategy))
def test_prediction_entropy_binary(self):
proba = np.array([
[0.1, 0.9],
[0.45, 0.55],
[0.5, 0.5],
[0.7, 0.3]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([2, 1])
assert_array_equal(expected, indicies)
self.assertIsNotNone(strategy.scores_)
assert_array_almost_equal(np.array([0.325083, 0.688139, 0.693147, 0.610864]),
strategy.scores_)
def test_prediction_entropy_multiclass(self):
proba = np.array([
[0.1, 0.8, 0.1],
[0.45, 0.25, 0.3],
[0.33, 0.33, 0.34],
[0.7, 0.3, 0]
])
clf_mock = self._get_clf()
clf_mock.predict_proba = Mock(return_value=proba)
x = np.random.rand(proba.shape[0], 10)
strategy = self._get_query_strategy()
indicies = strategy.query(clf_mock, x, np.arange(0, 4), np.array([]), np.array([]), n=2)
expected = np.array([2, 1])
assert_array_equal(expected, indicies)
assert_array_almost_equal(np.array([0.639032, 1.067094, 1.098513, 0.610864]),
strategy.scores_)
class SubSamplingTest(unittest.TestCase, SamplingStrategiesTests):
def _get_clf(self):
return ConfidenceEnhancedLinearSVC()
def _get_query_strategy(self):
return SubsamplingQueryStrategy(RandomSampling(), 20)
def test_subsampling_str(self):
strategy = SubsamplingQueryStrategy(RandomSampling(), subsample_size=20)
expected_str = 'SubsamplingQueryStrategy(base_query_strategy=RandomSampling(), ' \
'subsample_size=20)'
self.assertEqual(expected_str, str(strategy))
def test_subsampling_query_default(self):
indices = query_random_data(self._get_query_strategy())
self.assertEqual(10, len(indices))
def test_subsampling_empty_pool(self, num_samples=20, n=10):
strategy = self._get_query_strategy()
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = []
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
with self.assertRaises(EmptyPoolException):
strategy.query(None, x, x_indices_unlabeled, x_indices_labeled, y, n=n)
def test_scores_property(self):
num_samples = 20
scores = np.random.rand(num_samples, 1)
strategy = self._get_query_strategy()
strategy.base_query_strategy.scores_ = scores
assert_array_equal(scores, strategy.scores_)
strategy = self._get_query_strategy()
self.assertIsNone(strategy.scores_)
class EmbeddingBasedQueryStrategyImplementation(EmbeddingBasedQueryStrategy):
def sample(self, clf, x, x_indices_unlabeled, x_indices_labeled, y, n, embeddings,
embeddings_proba=None):
pass
class SklearnClassifierWithRandomEmbeddings(SklearnClassifier):
# TODO: add pbar to the interface or handle it correctly
def embed(self, dataset, embed_dim=5, pbar=None):
self.embeddings_ = np.random.rand(len(dataset), embed_dim)
return self.embeddings_
class SklearnClassifierWithRandomEmbeddingsAndProba(SklearnClassifier):
# TODO: add pbar to the interface or handle it correctly
def embed(self, dataset, return_proba=False, embed_dim=5, pbar=None):
self.embeddings_ = np.random.rand(len(dataset), embed_dim)
if return_proba:
self.proba_ = np.random.rand(len(dataset))
return self.embeddings_, self.proba_
return self.embeddings_
class EmbeddingBasedQueryStrategyTest(unittest.TestCase):
def test_str(self):
query_strategy = EmbeddingBasedQueryStrategyImplementation()
self.assertEqual('EmbeddingBasedQueryStrategy()', str(query_strategy))
def test_query_with_precomputed_embeddings(self, num_samples=20):
clf = SklearnClassifierWithRandomEmbeddingsAndProba(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
indices = np.arange(num_samples)
mask = np.isin(indices, x_indices_labeled)
x_indices_unlabeled = indices[~mask]
y = np.random.randint(0, 2, size=num_samples)
n = 10
embeddings = None
query_strategy = EmbeddingBasedQueryStrategyImplementation()
with patch.object(query_strategy, 'sample', wraps=query_strategy.sample) as sample_spy:
query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n=n, embeddings=embeddings)
sample_spy.assert_called()
def test_query_when_embed_has_return_proba(self, num_samples=20):
clf = SklearnClassifierWithRandomEmbeddingsAndProba(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
indices = np.arange(num_samples)
mask = np.isin(indices, x_indices_labeled)
x_indices_unlabeled = indices[~mask]
y = np.random.randint(0, 2, size=num_samples)
n = 10
embeddings = None
query_strategy = EmbeddingBasedQueryStrategyImplementation()
with patch.object(query_strategy, 'sample', wraps=query_strategy.sample) as sample_spy:
query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n=n, embeddings=embeddings)
sample_spy.assert_called_once_with(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n, clf.embeddings_, embeddings_proba=clf.proba_)
def test_query_when_embed_has_no_return_proba(self, num_samples=20):
clf = SklearnClassifierWithRandomEmbeddings(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
indices = np.arange(num_samples)
mask = np.isin(indices, x_indices_labeled)
x_indices_unlabeled = indices[~mask]
y = np.random.randint(0, 2, size=num_samples)
n = 10
embeddings = None
query_strategy = EmbeddingBasedQueryStrategyImplementation()
with patch.object(query_strategy, 'sample', wraps=query_strategy.sample) as sample_spy:
query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n=n, embeddings=embeddings)
sample_spy.assert_called_once_with(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n, clf.embeddings_)
def test_query_with_nonexistent_embed_kwargs_and_no_return_proba(self, num_samples=20):
clf = SklearnClassifierWithRandomEmbeddings(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
indices = np.arange(num_samples)
mask = np.isin(indices, x_indices_labeled)
x_indices_unlabeled = indices[~mask]
y = np.random.randint(0, 2, size=num_samples)
n = 10
embeddings = None
query_strategy = EmbeddingBasedQueryStrategyImplementation()
with self.assertRaises(TypeError):
query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n=n, embeddings=embeddings, embed_kwargs={'does': 'not exist'})
def test_query_with_nonexistent_embed_kwargs_and_return_proba(self, num_samples=20):
clf = SklearnClassifierWithRandomEmbeddingsAndProba(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
indices = np.arange(num_samples)
mask = np.isin(indices, x_indices_labeled)
x_indices_unlabeled = indices[~mask]
y = np.random.randint(0, 2, size=num_samples)
n = 10
embeddings = None
query_strategy = EmbeddingBasedQueryStrategyImplementation()
with self.assertRaises(TypeError):
query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y,
n=n, embeddings=embeddings, embed_kwargs={'does': 'not exist'})
class EmbeddingKMeansTest(unittest.TestCase):
def test_query(self, n=10, num_samples=100, embedding_dim=60):
query_strategy = EmbeddingKMeans()
# currently does not support embed, but is not used here anyways
clf = SklearnClassifierWithRandomEmbeddingsAndProba(ConfidenceEnhancedLinearSVC)
x = np.random.rand(num_samples, 100)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = np.array([i for i in np.arange(100) if i not in set(x_indices_labeled)])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
indices = query_strategy.query(clf, x, x_indices_unlabeled, x_indices_labeled, y, n)
self.assertIsNotNone(indices)
self.assertEqual(n, indices.shape[0])
@patch('sklearn.preprocessing.normalize', wraps=normalize)
def test_sample(self, normalize_mock, n=10, num_samples=100, embedding_dim=60):
query_strategy = EmbeddingKMeans()
query_strategy._get_nearest_to_centers_iterative = Mock(
wraps=query_strategy._get_nearest_to_centers_iterative)
# currently does not support embed, but is not used here anyways
clf = ConfidenceEnhancedLinearSVC()
x = np.random.rand(num_samples, 100)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = np.array([i for i in np.arange(100) if i not in set(x_indices_labeled)])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
embeddings = np.random.rand(num_samples, embedding_dim)
# make sure we hit the "default" case
query_strategy._get_nearest_to_centers = Mock(
return_value=np.random.choice(x_indices_unlabeled, 10, replace=False))
indices = query_strategy.sample(clf, x, x_indices_unlabeled, x_indices_labeled, y, n, embeddings)
self.assertIsNotNone(indices)
self.assertEqual(n, indices.shape[0])
normalize_mock.assert_called()
np.testing.assert_array_equal(embeddings, normalize_mock.call_args[0][0])
query_strategy._get_nearest_to_centers_iterative.assert_not_called()
@patch('sklearn.preprocessing.normalize', wraps=normalize)
def test_sample_with_normalize_false(self, normalize_mock, n=10, num_samples=100,
embedding_dim=20):
query_strategy = EmbeddingKMeans(normalize=False)
query_strategy._get_nearest_to_centers_iterative = Mock(
wraps=query_strategy._get_nearest_to_centers_iterative)
# currently does not support embed, but is not used here anyways
clf = ConfidenceEnhancedLinearSVC()
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = np.array([i for i in np.arange(100) if i not in set(x_indices_labeled)])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
embeddings = np.random.rand(num_samples, embedding_dim)
indices = query_strategy.sample(clf, x, x_indices_unlabeled, x_indices_labeled, y, n, embeddings)
self.assertIsNotNone(indices)
self.assertEqual(n, indices.shape[0])
normalize_mock.assert_not_called()
def test_sample_with_fallback(self, n=10, num_samples=100, embedding_dim=20):
query_strategy = EmbeddingKMeans()
query_strategy._get_nearest_to_centers = Mock(return_value=np.zeros(n))
query_strategy._get_nearest_to_centers_iterative = Mock(
wraps=query_strategy._get_nearest_to_centers_iterative)
# currently does not support embed, but is not used here anyways
clf = ConfidenceEnhancedLinearSVC()
x = np.random.rand(num_samples, 10)
x_indices_labeled = np.random.choice(np.arange(100), size=10, replace=False)
x_indices_unlabeled = np.array(
[i for i in np.arange(100) if i not in set(x_indices_labeled)])
y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
embeddings = np.random.rand(num_samples, embedding_dim)
indices = query_strategy.sample(clf, x, x_indices_unlabeled, x_indices_labeled, y, n,
embeddings)
self.assertIsNotNone(indices)
self.assertEqual(n, indices.shape[0])
query_strategy._get_nearest_to_centers_iterative.assert_called()
def test_str(self):
query_strategy = EmbeddingKMeans()
self.assertEqual('EmbeddingKMeans(normalize=True)', str(query_strategy))
def test_str_with_normalize_false(self):
query_strategy = EmbeddingKMeans(normalize=False)
self.assertEqual('EmbeddingKMeans(normalize=False)', str(query_strategy))
| 39.314748 | 105 | 0.645318 |
19a919d9b15fd1ed5e1f563f63719b01e5ccbbcf | 472 | py | Python | claf/data/dataset/__init__.py | clovaai/claf | 97d5379b4c6014b527b894cac4e761ec8fec67a6 | [
"MIT"
] | 10 | 2019-06-11T00:59:51.000Z | 2021-11-06T09:58:30.000Z | claf/data/dataset/__init__.py | clovaai/claf | 97d5379b4c6014b527b894cac4e761ec8fec67a6 | [
"MIT"
] | null | null | null | claf/data/dataset/__init__.py | clovaai/claf | 97d5379b4c6014b527b894cac4e761ec8fec67a6 | [
"MIT"
] | 4 | 2019-08-16T20:44:31.000Z | 2020-10-29T11:03:15.000Z |
from claf.data.dataset.squad import SQuADDataset
from claf.data.dataset.squad_bert import SQuADBertDataset
from claf.data.dataset.wikisql import WikiSQLDataset
from claf.data.dataset.seq_cls import SeqClsDataset
from claf.data.dataset.seq_cls_bert import SeqClsBertDataset
from claf.data.dataset.tok_cls_bert import TokClsBertDataset
__all__ = ["SQuADDataset", "SQuADBertDataset", "WikiSQLDataset",
"SeqClsDataset", "SeqClsBertDataset", "TokClsBertDataset"]
| 39.333333 | 69 | 0.822034 |
2e151baf281560468b7491dea734521d3773f29f | 885 | py | Python | proto_2/ddq/fol/node_types.py | jadnohra/connect | 8eb21e6f122898094447bc3d5edb3053d5a2adf2 | [
"Unlicense"
] | null | null | null | proto_2/ddq/fol/node_types.py | jadnohra/connect | 8eb21e6f122898094447bc3d5edb3053d5a2adf2 | [
"Unlicense"
] | 6 | 2021-03-19T12:06:56.000Z | 2022-03-12T00:23:09.000Z | proto_2/ddq/fol/node_types.py | jadnohra/connect | 8eb21e6f122898094447bc3d5edb3053d5a2adf2 | [
"Unlicense"
] | null | null | null | from ddq.node import Node
def is_variable(node: Node) -> bool:
from .variable import VariableNode
return isinstance(node, VariableNode)
def is_function(node: Node) -> bool:
from .function import FunctionNode
return isinstance(node, FunctionNode)
def is_term(node: Node) -> bool:
return is_variable(node) or is_function(node)
def is_predicate(node: Node) -> bool:
from .predicate import PredicateNode
return isinstance(node, PredicateNode)
def is_connective(node: Node) -> bool:
from .connective import ConnectiveNode
return isinstance(node, ConnectiveNode)
def is_quantifier(node: Node) -> bool:
from .quantifier import QuantifierNode
return isinstance(node, QuantifierNode)
def is_variable_declaration(node: Node) -> bool:
from .variable import VariableDeclarationNode
return isinstance(node, VariableDeclarationNode)
| 24.583333 | 52 | 0.749153 |
81935ecb4b673b3707790a6f864db71f53eb1a25 | 1,866 | py | Python | vitrage/datasources/tmfapi639/config.py | openstack/vitrage | 95b33dbf39b040e23915882a2879c87aec239ca9 | [
"Apache-2.0"
] | 89 | 2015-09-30T21:42:17.000Z | 2022-03-28T16:31:19.000Z | vitrage/datasources/tmfapi639/config.py | openstack/vitrage | 95b33dbf39b040e23915882a2879c87aec239ca9 | [
"Apache-2.0"
] | 4 | 2015-12-13T13:06:53.000Z | 2016-01-03T19:51:28.000Z | vitrage/datasources/tmfapi639/config.py | openstack/vitrage | 95b33dbf39b040e23915882a2879c87aec239ca9 | [
"Apache-2.0"
] | 43 | 2015-11-04T15:54:27.000Z | 2021-12-10T14:24:03.000Z | # Copyright 2020
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from oslo_log import log
from vitrage.common.constants import DatasourceOpts as DSOpts
from vitrage.utils import file as file_utils
CONF = cfg.CONF
LOG = log.getLogger(__name__)
class TmfApi639Config(object):
def __init__(self):
try:
tmfapi639_config_file = CONF.tmfapi639[DSOpts.CONFIG_FILE]
tmfapi639_config = file_utils.load_yaml_file(tmfapi639_config_file)
self.endpoints = self._create_mapping(tmfapi639_config)
except Exception as e:
LOG.error("Failed initialization: " + str(e))
self.endpoints = []
@staticmethod
def _create_mapping(config):
"""Read URL list from config dictionary"""
LOG.debug(config)
endpoint_list = []
# Tuple list containing either 1 or 2 elements (Endpoint and updates)
for e in config:
snapshot_url = e["endpoint"]["snapshot"]
update_url = ""
if "update" in e["endpoint"]:
update_url = e["endpoint"]["update"]
if update_url != "":
endpoint_list.append((snapshot_url, update_url))
else:
endpoint_list.append(snapshot_url)
LOG.info("Finished reading endpoints file")
return endpoint_list
| 35.884615 | 79 | 0.67149 |
07e103d97a1fbdd551e2a0a28501b9d7da88ea3a | 2,871 | py | Python | env/lib/python3.6/site-packages/django_tables2/export/export.py | anthowen/duplify | 846d01c1b21230937fdf0281b0cf8c0b08a8c24e | [
"MIT"
] | 3 | 2020-08-03T18:28:24.000Z | 2021-09-07T02:59:29.000Z | env/lib/python3.6/site-packages/django_tables2/export/export.py | anthowen/duplify | 846d01c1b21230937fdf0281b0cf8c0b08a8c24e | [
"MIT"
] | 10 | 2020-03-24T10:47:53.000Z | 2021-04-08T19:51:44.000Z | env/lib/python3.6/site-packages/django_tables2/export/export.py | anthowen/duplify | 846d01c1b21230937fdf0281b0cf8c0b08a8c24e | [
"MIT"
] | 2 | 2021-01-06T19:25:07.000Z | 2021-05-14T02:00:19.000Z | from __future__ import unicode_literals
from django.core.exceptions import ImproperlyConfigured
from django.http import HttpResponse
try:
from tablib import Dataset
except ImportError: # pragma: no cover
raise ImproperlyConfigured(
'You must have tablib installed in order to use the django-tables2 export functionality'
)
class TableExport(object):
'''
Export data from a table to the filetype specified.
Argumenents:
export_format (str): one of `csv, json, latex, ods, tsv, xls, xlsx, yml`
table (`~.Table`): instance of the table to export the data from
exclude_columns (iterable): list of column names to exclude from the export
'''
CSV = 'csv'
JSON = 'json'
LATEX = 'latex'
ODS = 'ods'
TSV = 'tsv'
XLS = 'xls'
XLSX = 'xlsx'
YAML = 'yml'
FORMATS = {
CSV: 'text/csv; charset=utf-8',
JSON: 'application/json',
LATEX: 'text/plain',
ODS: 'application/vnd.oasis.opendocument.spreadsheet',
TSV: 'text/tsv; charset=utf-8',
XLS: 'application/vnd.ms-excel',
XLSX: 'application/vnd.ms-excel',
YAML: 'text/yml; charset=utf-8',
}
def __init__(self, export_format, table, exclude_columns=None):
if not self.is_valid_format(export_format):
raise TypeError('Export format "{}" is not supported.'.format(export_format))
self.format = export_format
self.dataset = Dataset()
for i, row in enumerate(table.as_values(exclude_columns=exclude_columns)):
if i == 0:
self.dataset.headers = row
else:
self.dataset.append(row)
@classmethod
def is_valid_format(self, export_format):
'''
Returns true if `export_format` is one of the supported export formats
'''
return (
export_format is not None and
export_format in TableExport.FORMATS.keys()
)
def content_type(self):
'''
Returns the content type for the current export format
'''
return self.FORMATS[self.format]
def export(self):
'''
Returns the string/bytes for the current export format
'''
return getattr(self.dataset, self.format)
def response(self, filename=None):
'''
Builds and returns a `HttpResponse` containing the exported data
Arguments:
filename (str): if not `None`, the filename is attached to the
`Content-Disposition` header of the response.
'''
response = HttpResponse(content_type=self.content_type())
if filename is not None:
response['Content-Disposition'] = 'attachment; filename="{}"'.format(
filename
)
response.write(self.export())
return response
| 29.90625 | 96 | 0.61024 |
e06f602be991f859a066c1b9a112bc4da8edb90d | 1,146 | py | Python | locallibrary/urls.py | sunilsm7/django_local_library | e490e325fac6a5604af240309fdc293c4b53cb05 | [
"MIT"
] | null | null | null | locallibrary/urls.py | sunilsm7/django_local_library | e490e325fac6a5604af240309fdc293c4b53cb05 | [
"MIT"
] | null | null | null | locallibrary/urls.py | sunilsm7/django_local_library | e490e325fac6a5604af240309fdc293c4b53cb05 | [
"MIT"
] | null | null | null | """locallibrary URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url, include
from django.contrib import admin
from django.views.generic import RedirectView
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^catalog/', include('catalog.urls')),
url(r'^accounts/', include('django.contrib.auth.urls')),
url(r'^$', RedirectView.as_view(url='/catalog/', permanent=True)),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
| 40.928571 | 79 | 0.719895 |
745956408edc233f72440370d5fe793b3f33347b | 6,810 | py | Python | gpssm/models/components/variational/variational_distribution.py | sebascuri/GPSSMtorch | 799db18bebd4cc70ed4c054cadfcf5c4693c95ae | [
"MIT"
] | 3 | 2021-07-17T15:20:57.000Z | 2022-03-19T10:21:32.000Z | gpssm/models/components/variational/variational_distribution.py | sebascuri/GPSSMtorch | 799db18bebd4cc70ed4c054cadfcf5c4693c95ae | [
"MIT"
] | 1 | 2021-04-22T02:09:35.000Z | 2021-04-22T02:43:39.000Z | gpssm/models/components/variational/variational_distribution.py | sebascuri/GPSSMtorch | 799db18bebd4cc70ed4c054cadfcf5c4693c95ae | [
"MIT"
] | 1 | 2021-04-24T08:57:08.000Z | 2021-04-24T08:57:08.000Z | """Delta Variational Distribution."""
import numbers
import torch
from torch.distributions.kl import register_kl
from gpytorch.distributions.distribution import Distribution
from gpytorch.distributions.multivariate_normal import MultivariateNormal
from gpytorch.lazy import CholLazyTensor
from gpytorch.variational import CholeskyVariationalDistribution
class Delta(Distribution):
"""Degenerate discrete distribution (a single point).
Discrete distribution that assigns probability one to the single element in
its support. Delta distribution parameterized by a random choice should not
be used with MCMC based inference, as doing so produces incorrect results.
:param torch.Tensor v: The single support element.
:param torch.Tensor log_density: An optional density for this Delta. This
is useful to keep the class of :class:`Delta` distributions closed
under differentiable transformation.
:param int event_dim: Optional event dimension, defaults to zero.
"""
has_rsample = True
def __init__(self, v, log_density=0.0, event_dim=0, validate_args=None):
if event_dim > v.dim():
raise ValueError("Expected event_dim <= v.dim(), actual {} vs {}".format(
event_dim, v.dim()))
batch_dim = v.dim() - event_dim
batch_shape = v.shape[:batch_dim]
event_shape = v.shape[batch_dim:]
if isinstance(log_density, numbers.Number):
log_density = torch.full(batch_shape, log_density, dtype=v.dtype,
device=v.device)
elif validate_args and log_density.shape != batch_shape:
raise ValueError("Expected log_density.shape = {}, actual {}".format(
log_density.shape, batch_shape))
self.v = v
self.log_density = log_density
super().__init__(batch_shape, event_shape, validate_args=validate_args)
def expand(self, batch_shape: torch.Size, _instance=None):
"""Expand distribution to a given batch size."""
new = self._get_checked_instance(Delta, _instance)
batch_shape = torch.Size(batch_shape)
new.v = self.v.expand(*(batch_shape + self.event_shape), -1)
new.log_density = self.log_density.expand(*batch_shape, -1)
super().__init__(batch_shape, self.event_shape, validate_args=False)
new._validate_args = self._validate_args
return new
@property
def lazy_covariance_matrix(self):
"""Get lazy covariance matrix."""
return CholLazyTensor(torch.diag_embed(self.variance))
def rsample(self, sample_shape=torch.Size()):
"""Sample with reparametrization trick."""
shape = sample_shape + self.v.shape
return self.v.expand(shape)
def log_prob(self, x):
"""Get the log probability of a point x."""
v = self.v.expand(self.batch_shape + self.event_shape)
log_prob = (x == v).type(x.dtype).log()
if len(self.event_shape):
log_prob = log_prob.sum(list(range(-1, -len(self.event_shape) - 1, -1)))
return log_prob + self.log_density
@property
def mean(self):
"""Get the mean of the distribution."""
return self.v
@property
def variance(self):
"""Get the variance of the distribution."""
return torch.zeros_like(self.v)
@register_kl(Delta, MultivariateNormal)
def kl_mvn_mvn(p_dist, q_dist):
"""Register KL between Delta and Multivariate Normal."""
return q_dist.log_prob(p_dist.mean)
class ApproxCholeskyVariationalDistribution(CholeskyVariationalDistribution):
"""Approximate Cholesky variational distribution.
variational_distribution: N(mean, covariance)
approx_variational_distribution: N(mean, covariance)
"""
def __init__(self, num_inducing_points, batch_shape=torch.Size([]), **kwargs):
super().__init__(num_inducing_points, batch_shape, **kwargs)
self.sample = None
@property
def approx_variational_distribution(self):
"""Approximate variaitonal distribution."""
return self.variational_distribution
def resample(self):
"""Resample approximation."""
pass
class DeltaVariationalDistribution(ApproxCholeskyVariationalDistribution):
"""Variational distribution approximated with a single particle.
It is equivalent to doing MAP inference.
variational_distribution: Delta(mean)
approx_variational_distribution: Delta(mean)
"""
def __init__(self, num_inducing_points: int, batch_size=None,
mean_init_std=1e-3, **kwargs):
super().__init__(num_inducing_points=num_inducing_points,
batch_size=batch_size)
batch_shape = torch.Size([batch_size])
mean_init = torch.zeros(num_inducing_points)
mean_init = mean_init.repeat(*batch_shape, 1)
self.mean_init_std = mean_init_std
self.register_parameter(name="variational_mean",
parameter=torch.nn.Parameter(mean_init, True))
@property
def variational_distribution(self):
"""Build and return variational distribution."""
return Delta(self.variational_mean)
@property
def approx_variational_distribution(self):
"""Build and return variational distribution."""
return self.variational_distribution
def initialize_variational_distribution(self, prior_dist):
"""Initialize variational distribution."""
self.variational_mean.data.copy_(prior_dist.mean)
self.variational_mean.data.add_(self.mean_init_std,
torch.randn_like(prior_dist.mean))
class CholeskySampleVariationalDistribution(ApproxCholeskyVariationalDistribution):
"""Variational distribution approximated with a set of inducing points.
variational_distribution: N(mean, covariance)
approx_variational_distribution: Delta(sample from variational_distribution)
"""
def resample(self):
"""Resample approximation."""
self.sample = self.variational_distribution.rsample()
@property
def approx_variational_distribution(self):
"""Return the variational distribution q(u) that this module represents."""
if self.sample is None:
self.resample()
return Delta(self.sample)
class CholeskyMeanVariationalDistribution(ApproxCholeskyVariationalDistribution):
"""Variational distribution approximated with a set of inducing points.
variational_distribution: N(mean, covariance)
approx_variational_distribution: Delta(mean)
"""
@property
def approx_variational_distribution(self):
"""Return the variational distribution q(u) that this module represents."""
return Delta(self.variational_distribution.loc)
| 38.044693 | 85 | 0.694126 |
7183b5e1a4963c28a3e19a223ceee970bff788bd | 3,094 | py | Python | setup.py | ilovelili/counterblock | b1a05b29126b02fbbe269e14cb90bfdf7b96dd62 | [
"MIT"
] | null | null | null | setup.py | ilovelili/counterblock | b1a05b29126b02fbbe269e14cb90bfdf7b96dd62 | [
"MIT"
] | null | null | null | setup.py | ilovelili/counterblock | b1a05b29126b02fbbe269e14cb90bfdf7b96dd62 | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
from setuptools import setup, find_packages, Command
from setuptools.command.install import install as _install
from setuptools.command.bdist_egg import bdist_egg as _bdist_egg
import os
import sys
import logging
from counterblock.lib import config
class generate_configuration_files(Command):
description = "Generate configfiles from old counterparty-server and/or bitcoind config files"
user_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
from counterblock.lib import config_util
config_util.generate_config_files()
class install(_install):
description = "Install counterblock and dependencies"
def run(self):
caller = sys._getframe(2)
caller_module = caller.f_globals.get('__name__','')
caller_name = caller.f_code.co_name
if caller_module == 'distutils.dist' or caller_name == 'run_commands':
_install.run(self)
else:
self.do_egg_install()
self.run_command('generate_configuration_files')
required_packages = [
'appdirs==1.4.0',
'prettytable==0.7.2',
'python-dateutil==2.5.3',
'flask==0.11.1',
'json-rpc==1.10.3',
'pytest==2.9.2',
'pycoin==0.77',
#'python-bitcoinlib==0.10.1', <-- restore this when python-bitcoinlib 0.10.x with bech32 support is released
'pymongo==3.2.2',
'gevent==1.1.1',
'greenlet==0.4.9',
'grequests==0.3.0',
'redis==2.10.5',
'pyzmq==15.2.0',
'pillow==3.2.0',
'lxml==3.6.0',
'jsonschema==2.5.1',
'strict_rfc3339==0.7',
'rfc3987==1.3.6',
'aniso8601==1.1.0',
'pygeoip==0.3.2',
'colorama==0.3.7',
'configobj==5.0.6',
'repoze.lru==0.6'
]
setup_options = {
'name': 'counterblock',
'version': config.VERSION,
'author': 'Counterparty Developers',
'author_email': 'support@counterparty.io',
'maintainer': 'Counteparty Developers',
'maintainer_email': 'dev@counterparty.io',
'url': 'http://counterparty.io',
'license': 'MIT',
'description': 'counterblock server',
'long_description': 'Implements support for extended functionality for counterparty-lib',
'keywords': 'counterparty, bitcoin, counterblock',
'classifiers': [
"Programming Language :: Python",
],
'download_url': 'https://github.com/CounterpartyXCP/counterblock/releases/tag/%s' % config.VERSION,
'provides': ['counterblock'],
'packages': find_packages(),
'zip_safe': False,
'setup_requires': ['appdirs', ],
'install_requires': required_packages,
'include_package_data': True,
'entry_points': {
'console_scripts': [
'counterblock = counterblock:server_main',
]
},
'cmdclass': {
'install': install,
'generate_configuration_files': generate_configuration_files
},
'package_data': {
'counterblock.schemas': ['asset.schema.json', 'feed.schema.json'],
}
}
if os.name == "nt":
sys.exit("Windows installs not supported")
setup(**setup_options)
| 29.466667 | 112 | 0.64512 |
310e49b9c276e270d66cc45d491b2cf13ecb6f34 | 1,832 | py | Python | base.py | nsxy/cr_ctastrategy | 6e139962410cdcf450e5c8bd2176fe07cd829e06 | [
"MIT"
] | null | null | null | base.py | nsxy/cr_ctastrategy | 6e139962410cdcf450e5c8bd2176fe07cd829e06 | [
"MIT"
] | null | null | null | base.py | nsxy/cr_ctastrategy | 6e139962410cdcf450e5c8bd2176fe07cd829e06 | [
"MIT"
] | null | null | null | # coding:utf-8
from typing import Any
from abc import ABC, abstractmethod
from vnpy.trader.utility import virtual
from vnpy_ctastrategy import (
CtaTemplate,
BarData,
TickData,
TradeData,
OrderData,
ArrayManager,
)
class BaseLogic(ABC):
@abstractmethod
def __call__(self, am: ArrayManager, *args: Any, **kwds: Any) -> bool:
pass
class Filter(ABC):
def __init__(self) -> None:
self.trading_toggle = True
self.buy_toggle = True
self.sell_toggle = True
self.short_toggle = True
self.cover_toggle = True
@virtual
def on_start(self):
"""
set strategy toggle when strategy is started.
"""
pass
@virtual
def on_bar(self, bar: BarData) -> None:
'''
set strategy toggle when new bar data update.
'''
pass
@virtual
def on_tick(self, tick: TickData) -> None:
'''
set strategy toggle when new tick data update.
'''
pass
@virtual
def on_order(self, order: OrderData) -> None:
"""
set strategy toggle when new order data update.
"""
pass
@virtual
def on_trade(self, trade: TradeData) -> None:
"""
set strategy toggle when new trade data update.
"""
pass
class BaseFilter(Filter):
def __init__(self, strategy: CtaTemplate) -> None:
super().__init__()
self.__strategy = strategy
@property
def strategy(self) -> CtaTemplate:
return self.__strategy
def close_trading_toggle(self) -> None:
self.__strategy.trading = False
def open_trading_toggle(self) -> None:
self.__strategy.trading = True
def get_trading_toggle(self) -> bool:
return self.__strategy.trading | 21.552941 | 74 | 0.594432 |
1646c9726542793ecb3a94d73b05996e01e2b475 | 2,273 | py | Python | img_aug_merged_bbox.py | yqtianust/ASL | b4a79e0ce7b37cfacac32a3fd0dda7fbb9696cdc | [
"MIT"
] | null | null | null | img_aug_merged_bbox.py | yqtianust/ASL | b4a79e0ce7b37cfacac32a3fd0dda7fbb9696cdc | [
"MIT"
] | null | null | null | img_aug_merged_bbox.py | yqtianust/ASL | b4a79e0ce7b37cfacac32a3fd0dda7fbb9696cdc | [
"MIT"
] | null | null | null | from pycocotools.coco import COCO
# from PIL import Image
from data_loader import CocoObject
import numpy as np
import os
import cv2
from tqdm import tqdm
if __name__ == '__main__':
ann_dir = '/home/ytianas/EMSE_COCO/cocodataset/annotations'
image_dir = '/home/ytianas/EMSE_COCO/cocodataset/'
test_data = CocoObject(ann_dir=ann_dir, image_dir=image_dir,
split='val', transform=None)
image_ids = test_data.image_ids
image_path_map = test_data.image_path_map
# 80 objects
id2object = test_data.id2object
id2labels = test_data.id2labels
# print(id2labels)
# print(id2object)
# exit(-1)
ann_cat_name = test_data.ann_cat_name
ann_cat_id = test_data.ann_cat_id
bboxes = test_data.bbox
masks = test_data.mask
fill_values = [0, 127, 255]
print("start aug")
count = 0
t = tqdm(image_ids)
for image_id in t:
anns = ann_cat_id[image_id]
bbox = bboxes[image_id]
mask = masks[image_id]
path = image_path_map[image_id]
# unique_anns = list(set(anns))
# print(unique_anns)
# for unique_ann in unique_anns:
output_filename = "{}.jpg".format(path[0:-4])
# COCO_val2014_000000240972.jpg
# mask_to_union =[]
# print(len(anns))
# print(len(mask))
if len(anns) > 0:
union_mask = np.zeros_like(mask[0])
for i in range(0, len(anns)):
union_mask = np.add(union_mask, mask[i])
union_mask = union_mask > 0
image_path = os.path.join(image_dir, "val2014", path)
image = cv2.imread(image_path)
for fill_value in fill_values:
obj_image = image.copy()
obj_image[np.nonzero(union_mask)] = fill_value
bg_image = image.copy()
bg_image[np.nonzero(1 - union_mask)] = fill_value
cv2.imwrite("../coco_img/merged_obj2_{}/{}".format(fill_value, output_filename), obj_image)
cv2.imwrite("../coco_img/merged_bg2_{}/{}".format(fill_value, output_filename), bg_image)
count += 1
else:
print("No mask: {}".format(output_filename))
# if count >= 10:
# break | 30.306667 | 107 | 0.604927 |
e093b019be12a533acc3688c4492a2a1988814e4 | 2,336 | py | Python | var/spack/repos/builtin/packages/r-reportingtools/package.py | HaochengLIU/spack | 26e51ff1705a4d6234e2a0cf734f93f7f95df5cb | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 2 | 2018-11-27T03:39:44.000Z | 2021-09-06T15:50:35.000Z | var/spack/repos/builtin/packages/r-reportingtools/package.py | HaochengLIU/spack | 26e51ff1705a4d6234e2a0cf734f93f7f95df5cb | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 1 | 2019-01-11T20:11:52.000Z | 2019-01-11T20:11:52.000Z | var/spack/repos/builtin/packages/r-reportingtools/package.py | HaochengLIU/spack | 26e51ff1705a4d6234e2a0cf734f93f7f95df5cb | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 1 | 2020-10-14T14:20:17.000Z | 2020-10-14T14:20:17.000Z | # Copyright 2013-2018 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class RReportingtools(RPackage):
"""The ReportingTools software package enables users to easily
display reports of analysis results generated from sources such
as microarray and sequencing data. The package allows users to
create HTML pages that may be viewed on a web browser such as
Safari, or in other formats readable by programs such as Excel.
Users can generate tables with sortable and filterable columns,
make and display plots, and link table entries to other data
sources such as NCBI or larger plots within the HTML page. Using
the package, users can also produce a table of contents page to
link various reports together for a particular project that can
be viewed in a web browser. For more examples, please visit our
site: http:// research-pub.gene.com/ReportingTools."""
homepage = "https://bioconductor.org/packages/ReportingTools/"
git = "https://git.bioconductor.org/packages/ReportingTools.git"
version('2.16.0', commit='b1aa0ea302da7f2993ce8087b1d09c11ddf03663')
depends_on('r@3.4.0:3.4.9', when='@2.16.0')
depends_on('r-knitr', type=('build', 'run'))
depends_on('r-biobase', type=('build', 'run'))
depends_on('r-hwriter', type=('build', 'run'))
depends_on('r-category', type=('build', 'run'))
depends_on('r-gostats', type=('build', 'run'))
depends_on('r-limma', type=('build', 'run'))
depends_on('r-limma', type=('build', 'run'))
depends_on('r-lattice', type=('build', 'run'))
depends_on('r-annotationdbi', type=('build', 'run'))
depends_on('r-edger', type=('build', 'run'))
depends_on('r-annotate', type=('build', 'run'))
depends_on('r-pfam-db', type=('build', 'run'))
depends_on('r-gseabase', type=('build', 'run'))
depends_on('r-biocgenerics', type=('build', 'run'))
depends_on('r-xml', type=('build', 'run'))
depends_on('r-utils', type=('build', 'run'))
depends_on('r-deseq2', type=('build', 'run'))
depends_on('r-ggplot2', type=('build', 'run'))
depends_on('r-ggbio', type=('build', 'run'))
depends_on('r-iranges', type=('build', 'run'))
| 47.673469 | 73 | 0.67851 |
5df74fe9c5bf0dfd9c6fc244e9fd4a17a547bbe7 | 439 | py | Python | Logging in Python/.idea/VirtualEnvironment/Scripts/pip-script.py | BillionsRichard/pycharmWorkspace | 709e2681fc6d85ff52fb25717215a365f51073aa | [
"Apache-2.0"
] | null | null | null | Logging in Python/.idea/VirtualEnvironment/Scripts/pip-script.py | BillionsRichard/pycharmWorkspace | 709e2681fc6d85ff52fb25717215a365f51073aa | [
"Apache-2.0"
] | null | null | null | Logging in Python/.idea/VirtualEnvironment/Scripts/pip-script.py | BillionsRichard/pycharmWorkspace | 709e2681fc6d85ff52fb25717215a365f51073aa | [
"Apache-2.0"
] | null | null | null | #!"D:\Python\pycharmWorkspace\Logging in Python\.idea\VirtualEnvironment\Scripts\python.exe"
# EASY-INSTALL-ENTRY-SCRIPT: 'pip==10.0.1','console_scripts','pip'
__requires__ = 'pip==10.0.1'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('pip==10.0.1', 'console_scripts', 'pip')()
)
| 33.769231 | 92 | 0.678815 |
10985edc6f9dc52366aed324ee48594f78664c01 | 45,225 | py | Python | nipype/algorithms/confounds.py | eort/nipype | 04d0159686a8d656905e9e06110287c6c60c1523 | [
"Apache-2.0"
] | null | null | null | nipype/algorithms/confounds.py | eort/nipype | 04d0159686a8d656905e9e06110287c6c60c1523 | [
"Apache-2.0"
] | null | null | null | nipype/algorithms/confounds.py | eort/nipype | 04d0159686a8d656905e9e06110287c6c60c1523 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
'''
Algorithms to compute confounds in :abbr:`fMRI (functional MRI)`
Change directory to provide relative paths for doctests
>>> import os
>>> filepath = os.path.dirname(os.path.realpath(__file__))
>>> datadir = os.path.realpath(os.path.join(filepath, '../testing/data'))
>>> os.chdir(datadir)
'''
from __future__ import (print_function, division, unicode_literals,
absolute_import)
from builtins import range
import os
import os.path as op
import nibabel as nb
import numpy as np
from numpy.polynomial import Legendre
from scipy import linalg
from .. import config, logging
from ..external.due import BibTeX
from ..interfaces.base import (traits, TraitedSpec, BaseInterface,
BaseInterfaceInputSpec, File, isdefined,
InputMultiPath, OutputMultiPath)
from ..utils import NUMPY_MMAP
from ..utils.misc import normalize_mc_params
IFLOGGER = logging.getLogger('interface')
class ComputeDVARSInputSpec(BaseInterfaceInputSpec):
in_file = File(
exists=True, mandatory=True, desc='functional data, after HMC')
in_mask = File(exists=True, mandatory=True, desc='a brain mask')
remove_zerovariance = traits.Bool(
True, usedefault=True, desc='remove voxels with zero variance')
save_std = traits.Bool(
True, usedefault=True, desc='save standardized DVARS')
save_nstd = traits.Bool(
False, usedefault=True, desc='save non-standardized DVARS')
save_vxstd = traits.Bool(
False, usedefault=True, desc='save voxel-wise standardized DVARS')
save_all = traits.Bool(False, usedefault=True, desc='output all DVARS')
series_tr = traits.Float(desc='repetition time in sec.')
save_plot = traits.Bool(False, usedefault=True, desc='write DVARS plot')
figdpi = traits.Int(100, usedefault=True, desc='output dpi for the plot')
figsize = traits.Tuple(
traits.Float(11.7),
traits.Float(2.3),
usedefault=True,
desc='output figure size')
figformat = traits.Enum(
'png', 'pdf', 'svg', usedefault=True, desc='output format for figures')
intensity_normalization = traits.Float(
1000.0,
usedefault=True,
desc='Divide value in each voxel at each timepoint '
'by the median calculated across all voxels'
'and timepoints within the mask (if specified)'
'and then multiply by the value specified by'
'this parameter. By using the default (1000)'
'output DVARS will be expressed in '
'x10 % BOLD units compatible with Power et al.'
'2012. Set this to 0 to disable intensity'
'normalization altogether.')
class ComputeDVARSOutputSpec(TraitedSpec):
out_std = File(exists=True, desc='output text file')
out_nstd = File(exists=True, desc='output text file')
out_vxstd = File(exists=True, desc='output text file')
out_all = File(exists=True, desc='output text file')
avg_std = traits.Float()
avg_nstd = traits.Float()
avg_vxstd = traits.Float()
fig_std = File(exists=True, desc='output DVARS plot')
fig_nstd = File(exists=True, desc='output DVARS plot')
fig_vxstd = File(exists=True, desc='output DVARS plot')
class ComputeDVARS(BaseInterface):
"""
Computes the DVARS.
"""
input_spec = ComputeDVARSInputSpec
output_spec = ComputeDVARSOutputSpec
references_ = [{
'entry':
BibTeX("""\
@techreport{nichols_notes_2013,
address = {Coventry, UK},
title = {Notes on {Creating} a {Standardized} {Version} of {DVARS}},
url = {http://www2.warwick.ac.uk/fac/sci/statistics/staff/academic-\
research/nichols/scripts/fsl/standardizeddvars.pdf},
urldate = {2016-08-16},
institution = {University of Warwick},
author = {Nichols, Thomas},
year = {2013}
}"""),
'tags': ['method']
}, {
'entry':
BibTeX("""\
@article{power_spurious_2012,
title = {Spurious but systematic correlations in functional connectivity {MRI} networks \
arise from subject motion},
volume = {59},
doi = {10.1016/j.neuroimage.2011.10.018},
number = {3},
urldate = {2016-08-16},
journal = {NeuroImage},
author = {Power, Jonathan D. and Barnes, Kelly A. and Snyder, Abraham Z. and Schlaggar, \
Bradley L. and Petersen, Steven E.},
year = {2012},
pages = {2142--2154},
}
"""),
'tags': ['method']
}]
def __init__(self, **inputs):
self._results = {}
super(ComputeDVARS, self).__init__(**inputs)
def _gen_fname(self, suffix, ext=None):
fname, in_ext = op.splitext(op.basename(self.inputs.in_file))
if in_ext == '.gz':
fname, in_ext2 = op.splitext(fname)
in_ext = in_ext2 + in_ext
if ext is None:
ext = in_ext
if ext.startswith('.'):
ext = ext[1:]
return op.abspath('{}_{}.{}'.format(fname, suffix, ext))
def _run_interface(self, runtime):
dvars = compute_dvars(
self.inputs.in_file,
self.inputs.in_mask,
remove_zerovariance=self.inputs.remove_zerovariance,
intensity_normalization=self.inputs.intensity_normalization)
(self._results['avg_std'], self._results['avg_nstd'],
self._results['avg_vxstd']) = np.mean(
dvars, axis=1).astype(float)
tr = None
if isdefined(self.inputs.series_tr):
tr = self.inputs.series_tr
if self.inputs.save_std:
out_file = self._gen_fname('dvars_std', ext='tsv')
np.savetxt(out_file, dvars[0], fmt=b'%0.6f')
self._results['out_std'] = out_file
if self.inputs.save_plot:
self._results['fig_std'] = self._gen_fname(
'dvars_std', ext=self.inputs.figformat)
fig = plot_confound(
dvars[0],
self.inputs.figsize,
'Standardized DVARS',
series_tr=tr)
fig.savefig(
self._results['fig_std'],
dpi=float(self.inputs.figdpi),
format=self.inputs.figformat,
bbox_inches='tight')
fig.clf()
if self.inputs.save_nstd:
out_file = self._gen_fname('dvars_nstd', ext='tsv')
np.savetxt(out_file, dvars[1], fmt=b'%0.6f')
self._results['out_nstd'] = out_file
if self.inputs.save_plot:
self._results['fig_nstd'] = self._gen_fname(
'dvars_nstd', ext=self.inputs.figformat)
fig = plot_confound(
dvars[1], self.inputs.figsize, 'DVARS', series_tr=tr)
fig.savefig(
self._results['fig_nstd'],
dpi=float(self.inputs.figdpi),
format=self.inputs.figformat,
bbox_inches='tight')
fig.clf()
if self.inputs.save_vxstd:
out_file = self._gen_fname('dvars_vxstd', ext='tsv')
np.savetxt(out_file, dvars[2], fmt=b'%0.6f')
self._results['out_vxstd'] = out_file
if self.inputs.save_plot:
self._results['fig_vxstd'] = self._gen_fname(
'dvars_vxstd', ext=self.inputs.figformat)
fig = plot_confound(
dvars[2],
self.inputs.figsize,
'Voxelwise std DVARS',
series_tr=tr)
fig.savefig(
self._results['fig_vxstd'],
dpi=float(self.inputs.figdpi),
format=self.inputs.figformat,
bbox_inches='tight')
fig.clf()
if self.inputs.save_all:
out_file = self._gen_fname('dvars', ext='tsv')
np.savetxt(
out_file,
np.vstack(dvars).T,
fmt=b'%0.8f',
delimiter=b'\t',
header='std DVARS\tnon-std DVARS\tvx-wise std DVARS',
comments='')
self._results['out_all'] = out_file
return runtime
def _list_outputs(self):
return self._results
class FramewiseDisplacementInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc='motion parameters')
parameter_source = traits.Enum(
"FSL",
"AFNI",
"SPM",
"FSFAST",
"NIPY",
desc="Source of movement parameters",
mandatory=True)
radius = traits.Float(
50,
usedefault=True,
desc='radius in mm to calculate angular FDs, 50mm is the '
'default since it is used in Power et al. 2012')
out_file = File(
'fd_power_2012.txt', usedefault=True, desc='output file name')
out_figure = File(
'fd_power_2012.pdf', usedefault=True, desc='output figure name')
series_tr = traits.Float(desc='repetition time in sec.')
save_plot = traits.Bool(False, usedefault=True, desc='write FD plot')
normalize = traits.Bool(
False, usedefault=True, desc='calculate FD in mm/s')
figdpi = traits.Int(
100, usedefault=True, desc='output dpi for the FD plot')
figsize = traits.Tuple(
traits.Float(11.7),
traits.Float(2.3),
usedefault=True,
desc='output figure size')
class FramewiseDisplacementOutputSpec(TraitedSpec):
out_file = File(desc='calculated FD per timestep')
out_figure = File(desc='output image file')
fd_average = traits.Float(desc='average FD')
class FramewiseDisplacement(BaseInterface):
"""
Calculate the :abbr:`FD (framewise displacement)` as in [Power2012]_.
This implementation reproduces the calculation in fsl_motion_outliers
.. [Power2012] Power et al., Spurious but systematic correlations in functional
connectivity MRI networks arise from subject motion, NeuroImage 59(3),
2012. doi:`10.1016/j.neuroimage.2011.10.018
<http://dx.doi.org/10.1016/j.neuroimage.2011.10.018>`_.
"""
input_spec = FramewiseDisplacementInputSpec
output_spec = FramewiseDisplacementOutputSpec
references_ = [{
'entry':
BibTeX("""\
@article{power_spurious_2012,
title = {Spurious but systematic correlations in functional connectivity {MRI} networks \
arise from subject motion},
volume = {59},
doi = {10.1016/j.neuroimage.2011.10.018},
number = {3},
urldate = {2016-08-16},
journal = {NeuroImage},
author = {Power, Jonathan D. and Barnes, Kelly A. and Snyder, Abraham Z. and Schlaggar, \
Bradley L. and Petersen, Steven E.},
year = {2012},
pages = {2142--2154},
}
"""),
'tags': ['method']
}]
def _run_interface(self, runtime):
mpars = np.loadtxt(self.inputs.in_file) # mpars is N_t x 6
mpars = np.apply_along_axis(
func1d=normalize_mc_params,
axis=1,
arr=mpars,
source=self.inputs.parameter_source)
diff = mpars[:-1, :6] - mpars[1:, :6]
diff[:, 3:6] *= self.inputs.radius
fd_res = np.abs(diff).sum(axis=1)
self._results = {
'out_file': op.abspath(self.inputs.out_file),
'fd_average': float(fd_res.mean())
}
np.savetxt(
self.inputs.out_file,
fd_res,
header='FramewiseDisplacement',
comments='')
if self.inputs.save_plot:
tr = None
if isdefined(self.inputs.series_tr):
tr = self.inputs.series_tr
if self.inputs.normalize and tr is None:
IFLOGGER.warn('FD plot cannot be normalized if TR is not set')
self._results['out_figure'] = op.abspath(self.inputs.out_figure)
fig = plot_confound(
fd_res,
self.inputs.figsize,
'FD',
units='mm',
series_tr=tr,
normalize=self.inputs.normalize)
fig.savefig(
self._results['out_figure'],
dpi=float(self.inputs.figdpi),
format=self.inputs.out_figure[-3:],
bbox_inches='tight')
fig.clf()
return runtime
def _list_outputs(self):
return self._results
class CompCorInputSpec(BaseInterfaceInputSpec):
realigned_file = File(
exists=True, mandatory=True, desc='already realigned brain image (4D)')
mask_files = InputMultiPath(
File(exists=True),
desc=('One or more mask files that determines '
'ROI (3D). When more that one file is '
'provided `merge_method` or '
'`merge_index` must be provided'))
merge_method = traits.Enum(
'union',
'intersect',
'none',
xor=['mask_index'],
requires=['mask_files'],
desc=('Merge method if multiple masks are '
'present - `union` uses voxels included in'
' at least one input mask, `intersect` '
'uses only voxels present in all input '
'masks, `none` performs CompCor on '
'each mask individually'))
mask_index = traits.Range(
low=0,
xor=['merge_method'],
requires=['mask_files'],
desc=('Position of mask in `mask_files` to use - '
'first is the default.'))
components_file = traits.Str(
'components_file.txt',
usedefault=True,
desc='Filename to store physiological components')
num_components = traits.Int(6, usedefault=True) # 6 for BOLD, 4 for ASL
pre_filter = traits.Enum(
'polynomial',
'cosine',
False,
usedefault=True,
desc='Detrend time series prior to component '
'extraction')
use_regress_poly = traits.Bool(
True,
deprecated='0.15.0',
new_name='pre_filter',
desc=('use polynomial regression '
'pre-component extraction'))
regress_poly_degree = traits.Range(
low=1, default=1, usedefault=True, desc='the degree polynomial to use')
header_prefix = traits.Str(
desc=('the desired header for the output tsv '
'file (one column). If undefined, will '
'default to "CompCor"'))
high_pass_cutoff = traits.Float(
128,
usedefault=True,
desc='Cutoff (in seconds) for "cosine" pre-filter')
repetition_time = traits.Float(
desc='Repetition time (TR) of series - derived from image header if '
'unspecified')
save_pre_filter = traits.Either(
traits.Bool, File, desc='Save pre-filter basis as text file')
ignore_initial_volumes = traits.Range(
low=0,
usedefault=True,
desc='Number of volumes at start of series to ignore')
class CompCorOutputSpec(TraitedSpec):
components_file = File(
exists=True, desc='text file containing the noise components')
pre_filter_file = File(desc='text file containing high-pass filter basis')
class CompCor(BaseInterface):
"""
Interface with core CompCor computation, used in aCompCor and tCompCor
CompCor provides three pre-filter options, all of which include per-voxel
mean removal:
- polynomial: Legendre polynomial basis
- cosine: Discrete cosine basis
- False: mean-removal only
In the case of ``polynomial`` and ``cosine`` filters, a pre-filter file may
be saved with a row for each volume/timepoint, and a column for each
non-constant regressor.
If no non-constant (mean-removal) columns are used, this file may be empty.
If ``ignore_initial_volumes`` is set, then the specified number of initial
volumes are excluded both from pre-filtering and CompCor component
extraction.
Each column in the components and pre-filter files are prefixe with zeros
for each excluded volume so that the number of rows continues to match the
number of volumes in the input file.
In addition, for each excluded volume, a column is added to the pre-filter
file with a 1 in the corresponding row.
Example
-------
>>> ccinterface = CompCor()
>>> ccinterface.inputs.realigned_file = 'functional.nii'
>>> ccinterface.inputs.mask_files = 'mask.nii'
>>> ccinterface.inputs.num_components = 1
>>> ccinterface.inputs.pre_filter = 'polynomial'
>>> ccinterface.inputs.regress_poly_degree = 2
"""
input_spec = CompCorInputSpec
output_spec = CompCorOutputSpec
references_ = [{
'entry':
BibTeX(
"@article{compcor_2007,"
"title = {A component based noise correction method (CompCor) for BOLD and perfusion based},"
"volume = {37},"
"number = {1},"
"doi = {10.1016/j.neuroimage.2007.04.042},"
"urldate = {2016-08-13},"
"journal = {NeuroImage},"
"author = {Behzadi, Yashar and Restom, Khaled and Liau, Joy and Liu, Thomas T.},"
"year = {2007},"
"pages = {90-101},}"),
'tags': ['method', 'implementation']
}]
def __init__(self, *args, **kwargs):
''' exactly the same as compcor except the header '''
super(CompCor, self).__init__(*args, **kwargs)
self._header = 'CompCor'
def _run_interface(self, runtime):
mask_images = []
if isdefined(self.inputs.mask_files):
mask_images = combine_mask_files(self.inputs.mask_files,
self.inputs.merge_method,
self.inputs.mask_index)
if self.inputs.use_regress_poly:
self.inputs.pre_filter = 'polynomial'
# Degree 0 == remove mean; see compute_noise_components
degree = (self.inputs.regress_poly_degree
if self.inputs.pre_filter == 'polynomial' else 0)
imgseries = nb.load(self.inputs.realigned_file, mmap=NUMPY_MMAP)
if len(imgseries.shape) != 4:
raise ValueError('{} expected a 4-D nifti file. Input {} has '
'{} dimensions (shape {})'.format(
self._header, self.inputs.realigned_file,
len(imgseries.shape), imgseries.shape))
if len(mask_images) == 0:
img = nb.Nifti1Image(
np.ones(imgseries.shape[:3], dtype=np.bool),
affine=imgseries.affine,
header=imgseries.header)
mask_images = [img]
skip_vols = self.inputs.ignore_initial_volumes
if skip_vols:
imgseries = imgseries.__class__(
imgseries.get_data()[..., skip_vols:], imgseries.affine,
imgseries.header)
mask_images = self._process_masks(mask_images, imgseries.get_data())
TR = 0
if self.inputs.pre_filter == 'cosine':
if isdefined(self.inputs.repetition_time):
TR = self.inputs.repetition_time
else:
# Derive TR from NIfTI header, if possible
try:
TR = imgseries.header.get_zooms()[3]
if imgseries.get_xyzt_units()[1] == 'msec':
TR /= 1000
except (AttributeError, IndexError):
TR = 0
if TR == 0:
raise ValueError(
'{} cannot detect repetition time from image - '
'Set the repetition_time input'.format(self._header))
components, filter_basis = compute_noise_components(
imgseries.get_data(), mask_images, self.inputs.num_components,
self.inputs.pre_filter, degree, self.inputs.high_pass_cutoff, TR)
if skip_vols:
old_comp = components
nrows = skip_vols + components.shape[0]
components = np.zeros(
(nrows, components.shape[1]), dtype=components.dtype)
components[skip_vols:] = old_comp
components_file = os.path.join(os.getcwd(),
self.inputs.components_file)
np.savetxt(
components_file,
components,
fmt=b"%.10f",
delimiter='\t',
header=self._make_headers(components.shape[1]),
comments='')
if self.inputs.pre_filter and self.inputs.save_pre_filter:
pre_filter_file = self._list_outputs()['pre_filter_file']
ftype = {
'polynomial': 'Legendre',
'cosine': 'Cosine'
}[self.inputs.pre_filter]
ncols = filter_basis.shape[1] if filter_basis.size > 0 else 0
header = ['{}{:02d}'.format(ftype, i) for i in range(ncols)]
if skip_vols:
old_basis = filter_basis
# nrows defined above
filter_basis = np.zeros(
(nrows, ncols + skip_vols), dtype=filter_basis.dtype)
if old_basis.size > 0:
filter_basis[skip_vols:, :ncols] = old_basis
filter_basis[:skip_vols, -skip_vols:] = np.eye(skip_vols)
header.extend([
'NonSteadyStateOutlier{:02d}'.format(i)
for i in range(skip_vols)
])
np.savetxt(
pre_filter_file,
filter_basis,
fmt=b'%.10f',
delimiter='\t',
header='\t'.join(header),
comments='')
return runtime
def _process_masks(self, mask_images, timeseries=None):
return mask_images
def _list_outputs(self):
outputs = self._outputs().get()
outputs['components_file'] = os.path.abspath(
self.inputs.components_file)
save_pre_filter = self.inputs.save_pre_filter
if save_pre_filter:
if isinstance(save_pre_filter, bool):
save_pre_filter = os.path.abspath('pre_filter.tsv')
outputs['pre_filter_file'] = save_pre_filter
return outputs
def _make_headers(self, num_col):
header = self.inputs.header_prefix if \
isdefined(self.inputs.header_prefix) else self._header
headers = ['{}{:02d}'.format(header, i) for i in range(num_col)]
return '\t'.join(headers)
class ACompCor(CompCor):
"""
Anatomical compcor: for inputs and outputs, see CompCor.
When the mask provided is an anatomical mask, then CompCor
is equivalent to ACompCor.
"""
def __init__(self, *args, **kwargs):
''' exactly the same as compcor except the header '''
super(ACompCor, self).__init__(*args, **kwargs)
self._header = 'aCompCor'
class TCompCorInputSpec(CompCorInputSpec):
# and all the fields in CompCorInputSpec
percentile_threshold = traits.Range(
low=0.,
high=1.,
value=.02,
exclude_low=True,
exclude_high=True,
usedefault=True,
desc='the percentile '
'used to select highest-variance '
'voxels, represented by a number '
'between 0 and 1, exclusive. By '
'default, this value is set to .02. '
'That is, the 2% of voxels '
'with the highest variance are used.')
class TCompCorOutputSpec(CompCorOutputSpec):
# and all the fields in CompCorOutputSpec
high_variance_masks = OutputMultiPath(
File(exists=True),
desc=(("voxels exceeding the variance"
" threshold")))
class TCompCor(CompCor):
"""
Interface for tCompCor. Computes a ROI mask based on variance of voxels.
Example
-------
>>> ccinterface = TCompCor()
>>> ccinterface.inputs.realigned_file = 'functional.nii'
>>> ccinterface.inputs.mask_files = 'mask.nii'
>>> ccinterface.inputs.num_components = 1
>>> ccinterface.inputs.pre_filter = 'polynomial'
>>> ccinterface.inputs.regress_poly_degree = 2
>>> ccinterface.inputs.percentile_threshold = .03
"""
input_spec = TCompCorInputSpec
output_spec = TCompCorOutputSpec
def __init__(self, *args, **kwargs):
''' exactly the same as compcor except the header '''
super(TCompCor, self).__init__(*args, **kwargs)
self._header = 'tCompCor'
self._mask_files = []
def _process_masks(self, mask_images, timeseries=None):
out_images = []
self._mask_files = []
for i, img in enumerate(mask_images):
mask = img.get_data().astype(np.bool)
imgseries = timeseries[mask, :]
imgseries = regress_poly(2, imgseries)[0]
tSTD = _compute_tSTD(imgseries, 0, axis=-1)
threshold_std = np.percentile(
tSTD,
np.round(100. *
(1. - self.inputs.percentile_threshold)).astype(int))
mask_data = np.zeros_like(mask)
mask_data[mask != 0] = tSTD >= threshold_std
out_image = nb.Nifti1Image(
mask_data, affine=img.affine, header=img.header)
# save mask
mask_file = os.path.abspath('mask_{:03d}.nii.gz'.format(i))
out_image.to_filename(mask_file)
IFLOGGER.debug('tCompcor computed and saved mask of shape %s to '
'mask_file %s', str(mask.shape), mask_file)
self._mask_files.append(mask_file)
out_images.append(out_image)
return out_images
def _list_outputs(self):
outputs = super(TCompCor, self)._list_outputs()
outputs['high_variance_masks'] = self._mask_files
return outputs
class TSNRInputSpec(BaseInterfaceInputSpec):
in_file = InputMultiPath(
File(exists=True),
mandatory=True,
desc='realigned 4D file or a list of 3D files')
regress_poly = traits.Range(low=1, desc='Remove polynomials')
tsnr_file = File(
'tsnr.nii.gz',
usedefault=True,
hash_files=False,
desc='output tSNR file')
mean_file = File(
'mean.nii.gz',
usedefault=True,
hash_files=False,
desc='output mean file')
stddev_file = File(
'stdev.nii.gz',
usedefault=True,
hash_files=False,
desc='output tSNR file')
detrended_file = File(
'detrend.nii.gz',
usedefault=True,
hash_files=False,
desc='input file after detrending')
class TSNROutputSpec(TraitedSpec):
tsnr_file = File(exists=True, desc='tsnr image file')
mean_file = File(exists=True, desc='mean image file')
stddev_file = File(exists=True, desc='std dev image file')
detrended_file = File(desc='detrended input file')
class TSNR(BaseInterface):
"""
Computes the time-course SNR for a time series
Typically you want to run this on a realigned time-series.
Example
-------
>>> tsnr = TSNR()
>>> tsnr.inputs.in_file = 'functional.nii'
>>> res = tsnr.run() # doctest: +SKIP
"""
input_spec = TSNRInputSpec
output_spec = TSNROutputSpec
def _run_interface(self, runtime):
img = nb.load(self.inputs.in_file[0], mmap=NUMPY_MMAP)
header = img.header.copy()
vollist = [
nb.load(filename, mmap=NUMPY_MMAP)
for filename in self.inputs.in_file
]
data = np.concatenate(
[
vol.get_data().reshape(vol.shape[:3] + (-1, ))
for vol in vollist
],
axis=3)
data = np.nan_to_num(data)
if data.dtype.kind == 'i':
header.set_data_dtype(np.float32)
data = data.astype(np.float32)
if isdefined(self.inputs.regress_poly):
data = regress_poly(
self.inputs.regress_poly, data, remove_mean=False)[0]
img = nb.Nifti1Image(data, img.affine, header)
nb.save(img, op.abspath(self.inputs.detrended_file))
meanimg = np.mean(data, axis=3)
stddevimg = np.std(data, axis=3)
tsnr = np.zeros_like(meanimg)
tsnr[stddevimg > 1.e-3] = meanimg[stddevimg > 1.e-3] / stddevimg[
stddevimg > 1.e-3]
img = nb.Nifti1Image(tsnr, img.affine, header)
nb.save(img, op.abspath(self.inputs.tsnr_file))
img = nb.Nifti1Image(meanimg, img.affine, header)
nb.save(img, op.abspath(self.inputs.mean_file))
img = nb.Nifti1Image(stddevimg, img.affine, header)
nb.save(img, op.abspath(self.inputs.stddev_file))
return runtime
def _list_outputs(self):
outputs = self._outputs().get()
for k in ['tsnr_file', 'mean_file', 'stddev_file']:
outputs[k] = op.abspath(getattr(self.inputs, k))
if isdefined(self.inputs.regress_poly):
outputs['detrended_file'] = op.abspath(self.inputs.detrended_file)
return outputs
class NonSteadyStateDetectorInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc='4D NIFTI EPI file')
class NonSteadyStateDetectorOutputSpec(TraitedSpec):
n_volumes_to_discard = traits.Int(desc='Number of non-steady state volumes'
'detected in the beginning of the scan.')
class NonSteadyStateDetector(BaseInterface):
"""
Returns the number of non-steady state volumes detected at the beginning
of the scan.
"""
input_spec = NonSteadyStateDetectorInputSpec
output_spec = NonSteadyStateDetectorOutputSpec
def _run_interface(self, runtime):
in_nii = nb.load(self.inputs.in_file)
global_signal = in_nii.get_data()[:, :, :, :50].mean(axis=0).mean(
axis=0).mean(axis=0)
self._results = {'n_volumes_to_discard': is_outlier(global_signal)}
return runtime
def _list_outputs(self):
return self._results
def compute_dvars(in_file,
in_mask,
remove_zerovariance=False,
intensity_normalization=1000):
"""
Compute the :abbr:`DVARS (D referring to temporal
derivative of timecourses, VARS referring to RMS variance over voxels)`
[Power2012]_.
Particularly, the *standardized* :abbr:`DVARS (D referring to temporal
derivative of timecourses, VARS referring to RMS variance over voxels)`
[Nichols2013]_ are computed.
.. [Nichols2013] Nichols T, `Notes on creating a standardized version of
DVARS <http://www2.warwick.ac.uk/fac/sci/statistics/staff/academic-\
research/nichols/scripts/fsl/standardizeddvars.pdf>`_, 2013.
.. note:: Implementation details
Uses the implementation of the `Yule-Walker equations
from nitime
<http://nipy.org/nitime/api/generated/nitime.algorithms.autoregressive.html\
#nitime.algorithms.autoregressive.AR_est_YW>`_
for the :abbr:`AR (auto-regressive)` filtering of the fMRI signal.
:param numpy.ndarray func: functional data, after head-motion-correction.
:param numpy.ndarray mask: a 3D mask of the brain
:param bool output_all: write out all dvars
:param str out_file: a path to which the standardized dvars should be saved.
:return: the standardized DVARS
"""
import numpy as np
import nibabel as nb
from nitime.algorithms import AR_est_YW
import warnings
func = nb.load(in_file, mmap=NUMPY_MMAP).get_data().astype(np.float32)
mask = nb.load(in_mask, mmap=NUMPY_MMAP).get_data().astype(np.uint8)
if len(func.shape) != 4:
raise RuntimeError("Input fMRI dataset should be 4-dimensional")
idx = np.where(mask > 0)
mfunc = func[idx[0], idx[1], idx[2], :]
if intensity_normalization != 0:
mfunc = (mfunc / np.median(mfunc)) * intensity_normalization
# Robust standard deviation (we are using "lower" interpolation
# because this is what FSL is doing
func_sd = (np.percentile(mfunc, 75, axis=1, interpolation="lower") -
np.percentile(mfunc, 25, axis=1, interpolation="lower")) / 1.349
if remove_zerovariance:
mfunc = mfunc[func_sd != 0, :]
func_sd = func_sd[func_sd != 0]
# Compute (non-robust) estimate of lag-1 autocorrelation
ar1 = np.apply_along_axis(AR_est_YW, 1,
regress_poly(0, mfunc,
remove_mean=True)[0].astype(
np.float32), 1)[:, 0]
# Compute (predicted) standard deviation of temporal difference time series
diff_sdhat = np.squeeze(np.sqrt(((1 - ar1) * 2).tolist())) * func_sd
diff_sd_mean = diff_sdhat.mean()
# Compute temporal difference time series
func_diff = np.diff(mfunc, axis=1)
# DVARS (no standardization)
dvars_nstd = np.sqrt(np.square(func_diff).mean(axis=0))
# standardization
dvars_stdz = dvars_nstd / diff_sd_mean
with warnings.catch_warnings(): # catch, e.g., divide by zero errors
warnings.filterwarnings('error')
# voxelwise standardization
diff_vx_stdz = np.square(
func_diff / np.array([diff_sdhat] * func_diff.shape[-1]).T)
dvars_vx_stdz = np.sqrt(diff_vx_stdz.mean(axis=0))
return (dvars_stdz, dvars_nstd, dvars_vx_stdz)
def plot_confound(tseries,
figsize,
name,
units=None,
series_tr=None,
normalize=False):
"""
A helper function to plot :abbr:`fMRI (functional MRI)` confounds.
"""
import matplotlib
matplotlib.use(config.get('execution', 'matplotlib_backend'))
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.backends.backend_pdf import FigureCanvasPdf as FigureCanvas
import seaborn as sns
fig = plt.Figure(figsize=figsize)
FigureCanvas(fig)
grid = GridSpec(1, 2, width_ratios=[3, 1], wspace=0.025)
grid.update(hspace=1.0, right=0.95, left=0.1, bottom=0.2)
ax = fig.add_subplot(grid[0, :-1])
if normalize and series_tr is not None:
tseries /= series_tr
ax.plot(tseries)
ax.set_xlim((0, len(tseries)))
ylabel = name
if units is not None:
ylabel += (' speed [{}/s]' if normalize else ' [{}]').format(units)
ax.set_ylabel(ylabel)
xlabel = 'Frame #'
if series_tr is not None:
xlabel = 'Frame # ({} sec TR)'.format(series_tr)
ax.set_xlabel(xlabel)
ylim = ax.get_ylim()
ax = fig.add_subplot(grid[0, -1])
sns.distplot(tseries, vertical=True, ax=ax)
ax.set_xlabel('Frames')
ax.set_ylim(ylim)
ax.set_yticklabels([])
return fig
def is_outlier(points, thresh=3.5):
"""
Returns a boolean array with True if points are outliers and False
otherwise.
:param nparray points: an numobservations by numdimensions numpy array of observations
:param float thresh: the modified z-score to use as a threshold. Observations with
a modified z-score (based on the median absolute deviation) greater
than this value will be classified as outliers.
:return: A bolean mask, of size numobservations-length array.
.. note:: References
Boris Iglewicz and David Hoaglin (1993), "Volume 16: How to Detect and
Handle Outliers", The ASQC Basic References in Quality Control:
Statistical Techniques, Edward F. Mykytka, Ph.D., Editor.
"""
if len(points.shape) == 1:
points = points[:, None]
median = np.median(points, axis=0)
diff = np.sum((points - median)**2, axis=-1)
diff = np.sqrt(diff)
med_abs_deviation = np.median(diff)
modified_z_score = 0.6745 * diff / med_abs_deviation
timepoints_to_discard = 0
for i in range(len(modified_z_score)):
if modified_z_score[i] <= thresh:
break
else:
timepoints_to_discard += 1
return timepoints_to_discard
def cosine_filter(data, timestep, period_cut, remove_mean=True, axis=-1):
datashape = data.shape
timepoints = datashape[axis]
data = data.reshape((-1, timepoints))
frametimes = timestep * np.arange(timepoints)
X = _full_rank(_cosine_drift(period_cut, frametimes))[0]
non_constant_regressors = X[:, :-1] if X.shape[1] > 1 else np.array([])
betas = np.linalg.lstsq(X, data.T)[0]
if not remove_mean:
X = X[:, :-1]
betas = betas[:-1]
residuals = data - X.dot(betas).T
return residuals.reshape(datashape), non_constant_regressors
def regress_poly(degree, data, remove_mean=True, axis=-1):
"""
Returns data with degree polynomial regressed out.
:param bool remove_mean: whether or not demean data (i.e. degree 0),
:param int axis: numpy array axes along which regression is performed
"""
IFLOGGER.debug('Performing polynomial regression on data of shape %s',
str(data.shape))
datashape = data.shape
timepoints = datashape[axis]
# Rearrange all voxel-wise time-series in rows
data = data.reshape((-1, timepoints))
# Generate design matrix
X = np.ones((timepoints, 1)) # quick way to calc degree 0
for i in range(degree):
polynomial_func = Legendre.basis(i + 1)
value_array = np.linspace(-1, 1, timepoints)
X = np.hstack((X, polynomial_func(value_array)[:, np.newaxis]))
non_constant_regressors = X[:, :-1] if X.shape[1] > 1 else np.array([])
# Calculate coefficients
betas = np.linalg.pinv(X).dot(data.T)
# Estimation
if remove_mean:
datahat = X.dot(betas).T
else: # disregard the first layer of X, which is degree 0
datahat = X[:, 1:].dot(betas[1:, ...]).T
regressed_data = data - datahat
# Back to original shape
return regressed_data.reshape(datashape), non_constant_regressors
def combine_mask_files(mask_files, mask_method=None, mask_index=None):
"""Combines input mask files into a single nibabel image
A helper function for CompCor
mask_files: a list
one or more binary mask files
mask_method: enum ('union', 'intersect', 'none')
determines how to combine masks
mask_index: an integer
determines which file to return (mutually exclusive with mask_method)
returns: a list of nibabel images
"""
if isdefined(mask_index) or not isdefined(mask_method):
if not isdefined(mask_index):
if len(mask_files) == 1:
mask_index = 0
else:
raise ValueError(('When more than one mask file is provided, '
'one of merge_method or mask_index must be '
'set'))
if mask_index < len(mask_files):
mask = nb.load(mask_files[mask_index], mmap=NUMPY_MMAP)
return [mask]
raise ValueError(('mask_index {0} must be less than number of mask '
'files {1}').format(mask_index, len(mask_files)))
masks = []
if mask_method == 'none':
for filename in mask_files:
masks.append(nb.load(filename, mmap=NUMPY_MMAP))
return masks
if mask_method == 'union':
mask = None
for filename in mask_files:
img = nb.load(filename, mmap=NUMPY_MMAP)
if mask is None:
mask = img.get_data() > 0
np.logical_or(mask, img.get_data() > 0, mask)
img = nb.Nifti1Image(mask, img.affine, header=img.header)
return [img]
if mask_method == 'intersect':
mask = None
for filename in mask_files:
img = nb.load(filename, mmap=NUMPY_MMAP)
if mask is None:
mask = img.get_data() > 0
np.logical_and(mask, img.get_data() > 0, mask)
img = nb.Nifti1Image(mask, img.affine, header=img.header)
return [img]
def compute_noise_components(imgseries, mask_images, num_components,
filter_type, degree, period_cut, repetition_time):
"""Compute the noise components from the imgseries for each mask
imgseries: a nibabel img
mask_images: a list of nibabel images
num_components: number of noise components to return
filter_type: type off filter to apply to time series before computing
noise components.
'polynomial' - Legendre polynomial basis
'cosine' - Discrete cosine (DCT) basis
False - None (mean-removal only)
Filter options:
degree: order of polynomial used to remove trends from the timeseries
period_cut: minimum period (in sec) for DCT high-pass filter
repetition_time: time (in sec) between volume acquisitions
returns:
components: a numpy array
basis: a numpy array containing the (non-constant) filter regressors
"""
components = None
basis = np.array([])
for img in mask_images:
mask = img.get_data().astype(np.bool)
if imgseries.shape[:3] != mask.shape:
raise ValueError(
'Inputs for CompCor, timeseries and mask, do not have '
'matching spatial dimensions ({} and {}, respectively)'.format(
imgseries.shape[:3], mask.shape))
voxel_timecourses = imgseries[mask, :]
# Zero-out any bad values
voxel_timecourses[np.isnan(np.sum(voxel_timecourses, axis=1)), :] = 0
# Currently support Legendre-polynomial or cosine or detrending
# With no filter, the mean is nonetheless removed (poly w/ degree 0)
if filter_type == 'cosine':
voxel_timecourses, basis = cosine_filter(
voxel_timecourses, repetition_time, period_cut)
elif filter_type in ('polynomial', False):
# from paper:
# "The constant and linear trends of the columns in the matrix M were
# removed [prior to ...]"
voxel_timecourses, basis = regress_poly(degree, voxel_timecourses)
# "Voxel time series from the noise ROI (either anatomical or tSTD) were
# placed in a matrix M of size Nxm, with time along the row dimension
# and voxels along the column dimension."
M = voxel_timecourses.T
# "[... were removed] prior to column-wise variance normalization."
M = M / _compute_tSTD(M, 1.)
# "The covariance matrix C = MMT was constructed and decomposed into its
# principal components using a singular value decomposition."
u, _, _ = linalg.svd(M, full_matrices=False)
if components is None:
components = u[:, :num_components]
else:
components = np.hstack((components, u[:, :num_components]))
if components is None and num_components > 0:
raise ValueError('No components found')
return components, basis
def _compute_tSTD(M, x, axis=0):
stdM = np.std(M, axis=axis)
# set bad values to x
stdM[stdM == 0] = x
stdM[np.isnan(stdM)] = x
return stdM
# _cosine_drift and _full_rank copied from nipy/modalities/fmri/design_matrix
#
# Nipy release: 0.4.1
# Modified for smooth integration in CompCor classes
def _cosine_drift(period_cut, frametimes):
"""Create a cosine drift matrix with periods greater or equals to period_cut
Parameters
----------
period_cut: float
Cut period of the low-pass filter (in sec)
frametimes: array of shape(nscans)
The sampling times (in sec)
Returns
-------
cdrift: array of shape(n_scans, n_drifts)
cosin drifts plus a constant regressor at cdrift[:,0]
Ref: http://en.wikipedia.org/wiki/Discrete_cosine_transform DCT-II
"""
len_tim = len(frametimes)
n_times = np.arange(len_tim)
hfcut = 1. / period_cut # input parameter is the period
# frametimes.max() should be (len_tim-1)*dt
dt = frametimes[1] - frametimes[0]
# hfcut = 1/(2*dt) yields len_time
# If series is too short, return constant regressor
order = max(int(np.floor(2 * len_tim * hfcut * dt)), 1)
cdrift = np.zeros((len_tim, order))
nfct = np.sqrt(2.0 / len_tim)
for k in range(1, order):
cdrift[:, k - 1] = nfct * np.cos(
(np.pi / len_tim) * (n_times + .5) * k)
cdrift[:, order - 1] = 1. # or 1./sqrt(len_tim) to normalize
return cdrift
def _full_rank(X, cmax=1e15):
"""
This function possibly adds a scalar matrix to X
to guarantee that the condition number is smaller than a given threshold.
Parameters
----------
X: array of shape(nrows, ncols)
cmax=1.e-15, float tolerance for condition number
Returns
-------
X: array of shape(nrows, ncols) after regularization
cmax=1.e-15, float tolerance for condition number
"""
U, s, V = np.linalg.svd(X, 0)
smax, smin = s.max(), s.min()
c = smax / smin
if c < cmax:
return X, c
IFLOGGER.warn('Matrix is singular at working precision, regularizing...')
lda = (smax - cmax * smin) / (cmax - 1)
s = s + lda
X = np.dot(U, np.dot(np.diag(s), V))
return X, cmax
| 35.249415 | 105 | 0.607828 |
c35d330af3627474f1a71e1036f687e2294e3e2c | 15,167 | py | Python | sysmontask/sidepane.py | bastian-src/SysMonTask | 95868e230efa130e820f91893a3c8d5664632ac4 | [
"BSD-3-Clause"
] | null | null | null | sysmontask/sidepane.py | bastian-src/SysMonTask | 95868e230efa130e820f91893a3c8d5664632ac4 | [
"BSD-3-Clause"
] | null | null | null | sysmontask/sidepane.py | bastian-src/SysMonTask | 95868e230efa130e820f91893a3c8d5664632ac4 | [
"BSD-3-Clause"
] | null | null | null | # import gi
# gi.require_version("Gtk", "3.24")
from gi.repository import Gtk as g,cairo
try:
from gi_composites import GtkTemplate
except:
from sysmontask.gi_composites import GtkTemplate
if __name__=='sysmontask.sidepane':
from sysmontask.sysmontask import files_dir
else:
from sysmontask import files_dir
@GtkTemplate(ui=files_dir+'/diskSidepane.glade')
class diskSidepaneWidget(g.Box):
# Required else you would need to specify the full module
# name in mywidget.ui (__main__+MyWidget)
__gtype_name__ = 'diskSidepaneWidget'
disksidepanetextlabel= GtkTemplate.Child()
disksidepanelabelvalue = GtkTemplate.Child()
disksidepanedrawarea=GtkTemplate.Child()
disk_switcher_button=GtkTemplate.Child()
# Alternative way to specify multiple widgets
#label1, entry = GtkTemplate.Child.widgets(2)
def __init__(self):
super(g.Box, self).__init__()
# This must occur *after* you initialize your base
self.init_template()
def givedata(self,secondself,index):
self.diskactiveArray=secondself.diskActiveArray[index]
@GtkTemplate.Callback
def on_diskSidepaneDrawArea_draw(self,dr,cr):
cr.set_line_width(2)
w=self.disksidepanedrawarea.get_allocated_width()
h=self.disksidepanedrawarea.get_allocated_height()
scalingfactor=h/100.0
#creating outer rectangle
cr.set_source_rgba(.109,.670,.0588,1)
cr.set_line_width(3)
cr.rectangle(0,0,w,h)
cr.stroke()
stepsize=w/99.0
#print("in draw stepsize",stepsize)
# for i in range(0,99):
# # not effcient way to fill the bars (drawing)
# cr.set_source_rgba(.431,1,.04,0.25) #for changing the fill color
# cr.move_to(i*stepsize,scalingfactor*(100-self.diskactiveArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(100-self.diskactiveArray[i+1])+2)
# cr.line_to((i+1)*stepsize,h)
# cr.line_to(i*stepsize,h)
# cr.move_to(i*stepsize,scalingfactor*(100-self.diskactiveArray[i])+2)
# cr.fill()
# cr.stroke()
# # for outer line
# cr.set_line_width(1.5)
# cr.set_source_rgba(.109,.670,.0588,1) #for changing the outer line color
# cr.move_to(i*stepsize,scalingfactor*(100-self.diskactiveArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(100-self.diskactiveArray[i+1])+2)
# cr.stroke()
cr.set_source_rgba(.109,.670,.0588,1) #for changing the outer line color
cr.set_line_width(1.5)
cr.move_to(0,scalingfactor*(100-self.diskactiveArray[0])+2)
for i in range(0,99):
cr.line_to((i+1)*stepsize,scalingfactor*(100-self.diskactiveArray[i+1])+2)
cr.stroke_preserve()
cr.set_source_rgba(.431,1,.04,0.25) #for changing the fill color
cr.line_to(w,h)
cr.line_to(0,h)
cr.move_to(0,scalingfactor*(100-self.diskactiveArray[0])+2)
cr.fill()
cr.stroke()
return False
@GtkTemplate(ui=files_dir+'/netSidepane.glade')
class netSidepaneWidget(g.Box):
# Required else you would need to specify the full module
# name in mywidget.ui (__main__+MyWidget)
__gtype_name__ = 'netSidepaneWidget'
netsidepanetextlabel= GtkTemplate.Child()
netsidepanelabelvalue = GtkTemplate.Child()
netsidepanedrawarea=GtkTemplate.Child()
net_switcher_button=GtkTemplate.Child()
# Alternative way to specify multiple widgets
#label1, entry = GtkTemplate.Child.widgets(2)
def __init__(self):
super(g.Box, self).__init__()
# This must occur *after* you initialize your base
self.init_template()
self.netmxScalingFactor=1
def givedata(self,secondself,index):
self.netRecSpeedArray=secondself.netReceiveArray[index]
self.netSendSpeedArray=secondself.netSendArray[index]
@GtkTemplate.Callback
def on_netSidepaneDrawArea_draw(self,dr,cr):
cr.set_line_width(2)
w=self.netsidepanedrawarea.get_allocated_width()
h=self.netsidepanedrawarea.get_allocated_height()
speedstep=250*1024 #250KB/s
maximumcurrentspeed=max(max(self.netRecSpeedArray),max(self.netSendSpeedArray))
currentscalespeed=self.netmxScalingFactor*speedstep
while(currentscalespeed<maximumcurrentspeed):
self.netmxScalingFactor+=1
currentscalespeed=self.netmxScalingFactor*speedstep
while(currentscalespeed>maximumcurrentspeed and self.netmxScalingFactor>1):
self.netmxScalingFactor-=1
currentscalespeed=self.netmxScalingFactor*speedstep
scalingfactor=h/currentscalespeed
#creating outer rectangle
cr.set_source_rgba(.458,.141,.141,1)
cr.set_line_width(3)
cr.rectangle(0,0,w,h)
cr.stroke()
stepsize=w/99.0
#print("in draw stepsize",stepsize)
# for i in range(0,99):
# # not effcient way to fill the bars (drawing)
# cr.set_source_rgba(.709,.164,.164,.2) #for changing the fill color
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i+1])+2)
# cr.line_to((i+1)*stepsize,h)
# cr.line_to(i*stepsize,h)
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i])+2)
# cr.fill()
# cr.stroke()
# # for outer line read speed
# cr.set_line_width(1.5)
# cr.set_source_rgba(.709,.164,.164,1) #for changing the outer line color
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i+1])+2)
# cr.stroke()
# #for write
# cr.set_source_rgba(1,.313,.313,.2) #for changing the fill color
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i+1])+2)
# cr.line_to((i+1)*stepsize,h)
# cr.line_to(i*stepsize,h)
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i])+2)
# cr.fill()
# cr.stroke()
# # cr.set_dash([5.0])
# cr.set_source_rgba(1,.313,.313,1) #for changing the outer line color
# cr.move_to(i*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i+1])+2)
# cr.stroke()
#efficient receive speed drawing
cr.set_source_rgba(.709,.164,.164,1) #for changing the outer line color
cr.set_line_width(1.5)
cr.move_to(0,scalingfactor*(currentscalespeed-self.netRecSpeedArray[0])+2)
for i in range(0,99):
cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netRecSpeedArray[i+1])+2)
cr.stroke_preserve()
cr.set_source_rgba(.709,.164,.164,.2) #for changing the fill color
cr.line_to(w,h)
cr.line_to(0,h)
cr.move_to(0,scalingfactor*(currentscalespeed-self.netRecSpeedArray[0])+2)
cr.fill()
cr.stroke()
#efficient drawing for send
cr.set_source_rgba(1,.313,.313,1) #for changing the outer line color
cr.move_to(0,scalingfactor*(currentscalespeed-self.netSendSpeedArray[0])+2)
cr.set_line_width(1.5)
for i in range(0,99):
cr.line_to((i+1)*stepsize,scalingfactor*(currentscalespeed-self.netSendSpeedArray[i+1])+2)
cr.stroke_preserve()
cr.set_source_rgba(1,.313,.313,.2) #for changing the fill color
cr.line_to(w,h)
cr.line_to(0,h)
cr.move_to(0,scalingfactor*(currentscalespeed-self.netSendSpeedArray[0])+2)
cr.fill()
cr.stroke()
return False
@GtkTemplate(ui=files_dir+'/gpuSidepane.glade')
class gpuSidepaneWidget(g.Box):
# Required else you would need to specify the full module
# name in mywidget.ui (__main__+MyWidget)
__gtype_name__ = 'gpuSidepaneWidget'
gpusidepanetextlabel= GtkTemplate.Child()
gpusidepanelabelvalue = GtkTemplate.Child()
gpusidepanedrawarea=GtkTemplate.Child()
gpu_switcher_button=GtkTemplate.Child()
# Alternative way to specify multiple widgets
#label1, entry = GtkTemplate.Child.widgets(2)
def __init__(self):
super(g.Box, self).__init__()
# This must occur *after* you initialize your base
self.init_template()
def givedata(self,secondself):
self.gpuutilArray=secondself.gpuUtilArray
@GtkTemplate.Callback
def gpuSidepaneDrawArea_draw(self,dr,cr):
cr.set_line_width(2)
w=self.gpusidepanedrawarea.get_allocated_width()
h=self.gpusidepanedrawarea.get_allocated_height()
scalingfactor=h/100.0
#creating outer rectangle
cr.set_source_rgba(0,.454,.878,1)
cr.set_line_width(3)
cr.rectangle(0,0,w,h)
cr.stroke()
stepsize=w/99.0
#print("in draw stepsize",stepsize)
# for i in range(0,99):
# # not effcient way to fill the bars (drawing)
# cr.set_source_rgba(.588,.823,.98,0.25) #for changing the fill color
# cr.move_to(i*stepsize,scalingfactor*(100-self.gpuutilArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(100-self.gpuutilArray[i+1])+2)
# cr.line_to((i+1)*stepsize,h)
# cr.line_to(i*stepsize,h)
# cr.move_to(i*stepsize,scalingfactor*(100-self.gpuutilArray[i])+2)
# cr.fill()
# cr.stroke()
# # for outer line
# cr.set_line_width(1.5)
# cr.set_source_rgba(.384,.749,1.0,1) #for changing the outer line color
# cr.move_to(i*stepsize,scalingfactor*(100-self.gpuutilArray[i])+2)
# cr.line_to((i+1)*stepsize,scalingfactor*(100-self.gpuutilArray[i+1])+2)
# cr.stroke()
cr.set_line_width(1.5)
cr.set_source_rgba(.384,.749,1.0,1) #for changing the outer line color
cr.move_to(0,scalingfactor*(100-self.gpuutilArray[0]))
for i in range(0,99):
cr.line_to((i+1)*stepsize,scalingfactor*(100-self.gpuutilArray[i+1]))
cr.stroke_preserve()
cr.set_source_rgba(.588,.823,.98,0.25) #for changing the fill color
cr.line_to(w,h)
cr.line_to(0,h)
cr.move_to(0,scalingfactor*(100-self.gpuutilArray[0]))
cr.fill()
cr.stroke()
return False
def on_switcher_clicked(button,stack,curr_stack):
if not button.get_name()==stack.get_visible_child_name():
stack.set_visible_child_name(button.get_name())
curr_stack=button.get_name()
def sidepaneinit(self):
print("initialisating sidepane")
button_counter=0 # button name counter
self.cpuSidePaneLabelValue=self.builder.get_object('cpusidepanelabelvalue')
self.cpuSidePaneDrawArea=self.builder.get_object('cpusidepanedrawarea')
cpu_switcher_button=self.builder.get_object("cpu_switcher_button")
cpu_switcher_button.connect('clicked',on_switcher_clicked,self.performanceStack,self.current_stack)
cpu_switcher_button.set_name(f'page{button_counter}')
button_counter+=1
self.memSidePaneLabelValue=self.builder.get_object('memsidepanelabelvalue')
self.memSidePaneDrawArea=self.builder.get_object('memsidepanedrawarea')
mem_switcher_button=self.builder.get_object("mem_switcher_button")
mem_switcher_button.connect('clicked',on_switcher_clicked,self.performanceStack,self.current_stack)
mem_switcher_button.set_name(f'page{button_counter}')
button_counter+=1
self.diskSidepaneWidgetList={}
for i in range(0,self.numOfDisks):
self.diskSidepaneWidgetList[i]=diskSidepaneWidget()
self.sidepaneBox.pack_start(self.diskSidepaneWidgetList[i],True,True,0)
self.diskSidepaneWidgetList[i].disksidepanetextlabel.set_text(self.disklist[i])
self.diskSidepaneWidgetList[i].givedata(self,i)
self.diskSidepaneWidgetList[i].disk_switcher_button.connect('clicked',on_switcher_clicked,self.performanceStack,self.current_stack)
self.diskSidepaneWidgetList[i].disk_switcher_button.set_name(f'page{button_counter}')
button_counter+=1
if len(self.netNameList)!=0:
self.netSidepaneWidgetList={}
for i in range(0,self.numOfNets):
self.netSidepaneWidgetList[i]=netSidepaneWidget()
self.sidepaneBox.pack_start(self.netSidepaneWidgetList[i],True,True,0)
self.netSidepaneWidgetList[i].netsidepanetextlabel.set_text(self.netNameList[i])
self.netSidepaneWidgetList[i].givedata(self,i)
self.netSidepaneWidgetList[i].net_switcher_button.connect('clicked',on_switcher_clicked,self.performanceStack,self.current_stack)
self.netSidepaneWidgetList[i].net_switcher_button.set_name(f'page{button_counter}')
button_counter+=1
if(self.isNvidiagpu==1):
self.gpuSidePaneWidget=gpuSidepaneWidget()
self.sidepaneBox.pack_start(self.gpuSidePaneWidget,True,True,0)
self.gpuSidePaneWidget.gpusidepanetextlabel.set_text(f'{self.gpuName.split()[-2]}{self.gpuName.split()[-1]}')
self.gpuSidePaneWidget.givedata(self)
## unknown signal bug fixed
self.gpuSidePaneWidget.gpu_switcher_button.connect('clicked',on_switcher_clicked,self.performanceStack,self.current_stack)
self.gpuSidePaneWidget.gpu_switcher_button.set_name(f'page{button_counter}')
button_counter+=1
def sidePaneUpdate(self):
self.memSidePaneLabelValue.set_text(f'{self.usedd}/{self.memTotal} GiB\n{self.memPercent} %')
##disk sidepane
for i in range(0,self.numOfDisks):
try:
self.diskSidepaneWidgetList[i].disksidepanelabelvalue.set_text(self.diskActiveString[i])
self.diskSidepaneWidgetList[i].givedata(self,i)
except Exception as e:
print(f"some error in disksidepane update {e}")
# net sidepane
if(len(self.netNameList)!=0):
for i in range(0,self.numOfNets):
try:
self.netSidepaneWidgetList[i].netsidepanelabelvalue.set_text(f'R:{self.byterecpersecString[i]}\nS:{self.bytesendpersecString[i]}')
self.diskSidepaneWidgetList[i].givedata(self,i)
except Exception as e:
print(f"some error in netsidepane update {e}")
if(self.isNvidiagpu==1):
try:
self.gpuSidePaneWidget.gpusidepanelabelvalue.set_text(self.gpuutil)
self.gpuSidePaneWidget.givedata(self)
except Exception as e:
print(f"some error in gpusidepane update {e}") | 40.230769 | 146 | 0.663612 |
a9d4a22e75b33cfc110a69a58cfcd0b4f6367c47 | 6,404 | py | Python | kubernetes/client/models/v1_http_get_action.py | scele/kubernetes-client-python | 9e982cbdb5f19dc1a3935a75bdd92288f3b807fb | [
"Apache-2.0"
] | null | null | null | kubernetes/client/models/v1_http_get_action.py | scele/kubernetes-client-python | 9e982cbdb5f19dc1a3935a75bdd92288f3b807fb | [
"Apache-2.0"
] | null | null | null | kubernetes/client/models/v1_http_get_action.py | scele/kubernetes-client-python | 9e982cbdb5f19dc1a3935a75bdd92288f3b807fb | [
"Apache-2.0"
] | null | null | null | # coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.8.2
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from pprint import pformat
from six import iteritems
import re
class V1HTTPGetAction(object):
"""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'host': 'str',
'http_headers': 'list[V1HTTPHeader]',
'path': 'str',
'port': 'object',
'scheme': 'str'
}
attribute_map = {
'host': 'host',
'http_headers': 'httpHeaders',
'path': 'path',
'port': 'port',
'scheme': 'scheme'
}
def __init__(self, host=None, http_headers=None, path=None, port=None, scheme=None):
"""
V1HTTPGetAction - a model defined in Swagger
"""
self._host = None
self._http_headers = None
self._path = None
self._port = None
self._scheme = None
self.discriminator = None
if host is not None:
self.host = host
if http_headers is not None:
self.http_headers = http_headers
if path is not None:
self.path = path
self.port = port
if scheme is not None:
self.scheme = scheme
@property
def host(self):
"""
Gets the host of this V1HTTPGetAction.
Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.
:return: The host of this V1HTTPGetAction.
:rtype: str
"""
return self._host
@host.setter
def host(self, host):
"""
Sets the host of this V1HTTPGetAction.
Host name to connect to, defaults to the pod IP. You probably want to set \"Host\" in httpHeaders instead.
:param host: The host of this V1HTTPGetAction.
:type: str
"""
self._host = host
@property
def http_headers(self):
"""
Gets the http_headers of this V1HTTPGetAction.
Custom headers to set in the request. HTTP allows repeated headers.
:return: The http_headers of this V1HTTPGetAction.
:rtype: list[V1HTTPHeader]
"""
return self._http_headers
@http_headers.setter
def http_headers(self, http_headers):
"""
Sets the http_headers of this V1HTTPGetAction.
Custom headers to set in the request. HTTP allows repeated headers.
:param http_headers: The http_headers of this V1HTTPGetAction.
:type: list[V1HTTPHeader]
"""
self._http_headers = http_headers
@property
def path(self):
"""
Gets the path of this V1HTTPGetAction.
Path to access on the HTTP server.
:return: The path of this V1HTTPGetAction.
:rtype: str
"""
return self._path
@path.setter
def path(self, path):
"""
Sets the path of this V1HTTPGetAction.
Path to access on the HTTP server.
:param path: The path of this V1HTTPGetAction.
:type: str
"""
self._path = path
@property
def port(self):
"""
Gets the port of this V1HTTPGetAction.
Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
:return: The port of this V1HTTPGetAction.
:rtype: object
"""
return self._port
@port.setter
def port(self, port):
"""
Sets the port of this V1HTTPGetAction.
Name or number of the port to access on the container. Number must be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
:param port: The port of this V1HTTPGetAction.
:type: object
"""
if port is None:
raise ValueError("Invalid value for `port`, must not be `None`")
self._port = port
@property
def scheme(self):
"""
Gets the scheme of this V1HTTPGetAction.
Scheme to use for connecting to the host. Defaults to HTTP.
:return: The scheme of this V1HTTPGetAction.
:rtype: str
"""
return self._scheme
@scheme.setter
def scheme(self, scheme):
"""
Sets the scheme of this V1HTTPGetAction.
Scheme to use for connecting to the host. Defaults to HTTP.
:param scheme: The scheme of this V1HTTPGetAction.
:type: str
"""
self._scheme = scheme
def to_dict(self):
"""
Returns the model properties as a dict
"""
result = {}
for attr, _ in iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""
Returns the string representation of the model
"""
return pformat(self.to_dict())
def __repr__(self):
"""
For `print` and `pprint`
"""
return self.to_str()
def __eq__(self, other):
"""
Returns true if both objects are equal
"""
if not isinstance(other, V1HTTPGetAction):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""
Returns true if both objects are not equal
"""
return not self == other
| 26.683333 | 133 | 0.56371 |
14dfebe98e697d7d83fc221ecd424e2ed91acdef | 942 | py | Python | openstack_dashboard/dashboards/admin/metering/panel.py | enovance/horizon | 2ed6e93c9c4e534883126c93d3283e8c93bc674f | [
"Apache-2.0"
] | 9 | 2016-06-03T03:53:24.000Z | 2017-05-20T16:53:23.000Z | openstack_dashboard/dashboards/admin/metering/panel.py | enovance/horizon | 2ed6e93c9c4e534883126c93d3283e8c93bc674f | [
"Apache-2.0"
] | 1 | 2019-10-27T15:57:25.000Z | 2019-10-27T15:57:25.000Z | openstack_dashboard/dashboards/admin/metering/panel.py | enovance/horizon | 2ed6e93c9c4e534883126c93d3283e8c93bc674f | [
"Apache-2.0"
] | 15 | 2017-01-12T10:40:00.000Z | 2019-04-19T08:28:05.000Z | # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from django.utils.translation import ugettext_lazy as _
import horizon
class Metering(horizon.Panel):
name = _("Resource Usage")
slug = 'metering'
permissions = ('openstack.services.metering', )
policy_rules = (('identity', 'identity:list_projects'),
('telemetry', 'telemetry:compute_statistics'),
('telemetry', 'telemetry:get_meter'),)
| 37.68 | 75 | 0.713376 |
1e09151522217bdc7569ba4becc680427abea683 | 1,201 | py | Python | Chapter_10/ch10_ex2.py | pauldevos/Mastering-Object-Oriented-Python-Second-Edition | 71eab4406364365d902407d5e1774b1bf52e8430 | [
"MIT"
] | 108 | 2019-07-05T21:18:30.000Z | 2022-03-05T23:40:24.000Z | Chapter_10/ch10_ex2.py | pauldevos/Mastering-Object-Oriented-Python-Second-Edition | 71eab4406364365d902407d5e1774b1bf52e8430 | [
"MIT"
] | 1 | 2020-05-08T15:01:00.000Z | 2020-07-21T21:15:09.000Z | Chapter_10/ch10_ex2.py | pauldevos/Mastering-Object-Oriented-Python-Second-Edition | 71eab4406364365d902407d5e1774b1bf52e8430 | [
"MIT"
] | 85 | 2019-06-15T01:27:19.000Z | 2022-03-20T22:14:10.000Z | #!/usr/bin/env python3.7
"""
Mastering Object-Oriented Python 2e
Code Examples for Mastering Object-Oriented Python 2nd Edition
Chapter 10. Example 2. YAML. Base Definitions
"""
# Persistence Classes
# ========================================
from typing import List, Optional, Dict, Any
# Example 2: Cards
# ###################
from enum import Enum
class Suit(str, Enum):
Clubs = "♣"
Diamonds = "♦"
Hearts = "♥"
Spades = "♠"
class Card:
def __init__(self, rank: str, suit: Suit, hard: Optional[int]=None, soft: Optional[int]=None) -> None:
self.rank = rank
self.suit = suit
self.hard = hard or int(rank)
self.soft = soft or int(rank)
def __str__(self) -> str:
return f"{self.rank!s}{self.suit.value!s}"
class AceCard(Card):
def __init__(self, rank: str, suit: Suit) -> None:
super().__init__(rank, suit, 1, 11)
class FaceCard(Card):
def __init__(self, rank: str, suit: Suit) -> None:
super().__init__(rank, suit, 10, 10)
__test__ = {name: value for name, value in locals().items() if name.startswith("test_")}
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=False)
| 21.446429 | 106 | 0.605329 |
f559ba7a39cbae6ad07072d76c18476da11a4531 | 2,576 | py | Python | app/api/v1/views/user_views.py | kelvinbunei/Politico | d7ad9355fe6375ba5d87da56eed100eb31cfd9a0 | [
"MIT"
] | null | null | null | app/api/v1/views/user_views.py | kelvinbunei/Politico | d7ad9355fe6375ba5d87da56eed100eb31cfd9a0 | [
"MIT"
] | null | null | null | app/api/v1/views/user_views.py | kelvinbunei/Politico | d7ad9355fe6375ba5d87da56eed100eb31cfd9a0 | [
"MIT"
] | null | null | null | from flask import jsonify, request
from ...v1 import version_1 as v1
from ..schemas.user_schema import UserSchema
from ..models.user_model import User
db = User()
@v1.route('/', methods=['GET'])
@v1.route('/welcome', methods=['GET'])
def index():
return jsonify({'status': 200, 'message': 'Welcome to Politico. Kura Yako Sauti Yako'}), 200
@v1.route('/signup', methods=['POST'])
def signup():
""" Function to register new user """
json_data = request.get_json()
# No data has been provided
if not json_data:
return jsonify({'status': 400, 'message': 'No Sign up data provided'}), 400
# Check if request is valid
data, errors = UserSchema().load(json_data)
if errors:
return jsonify({'status': 400, 'message' : 'Invalid data. Please fill all the required fields', 'errors': errors}), 400
# Checking if the username exists
if db.exists('username', data['username']):
return jsonify({'status': 409, 'message' : 'Username already exists'}), 409
# Checking if the email exists
if db.exists('email', data['email']):
return jsonify({'status': 409, 'message' : 'Email already exists'}), 409
# Save new user and get result
new_user = db.save(data)
result = UserSchema(exclude=['password']).dump(new_user).data
return jsonify({
'status': 201,
'message' : 'User created successfully',
'data': result,
}), 201
@v1.route('/signin', methods=['POST'])
def signin():
json_data = request.get_json()
# Check if the request contains any data
if not json_data:
return jsonify({'status': 400, 'message': 'No data has provided! Please put your login credentials'}), 400
# Check if credentials have been passed
data, errors = UserSchema().load(json_data, partial=True)
if errors:
return jsonify({'status': 400, 'message': 'Invalid data. Make sure you fill all required fields', 'errors': errors}), 400
try:
username = data['username']
password = data['password']
except:
return jsonify({'status': 400, 'message': 'Kindly confirm your credentials'}), 400
# Check if username exists
if not db.exists('username', username):
return jsonify({'status': 404, 'message' : 'User non existent'}), 404
user = db.find_by_username(username)
# Checking if password match
db.checkpassword(user['password'], password)
return jsonify({
'status': 200,
'message': 'User logged in successfully',
}), 200
| 29.953488 | 129 | 0.629658 |
f1cfad059ceb278b86f203459f8716e77b358de8 | 5,579 | py | Python | datahandler/imdb_extractor.py | israel-santanna/semantic-clustering | cd778c882aff72924c7b2a82f041f53f0e04d356 | [
"MIT"
] | 6 | 2017-12-18T18:17:24.000Z | 2021-03-02T13:42:17.000Z | datahandler/imdb_extractor.py | israel-santanna/semantic-clustering | cd778c882aff72924c7b2a82f041f53f0e04d356 | [
"MIT"
] | null | null | null | datahandler/imdb_extractor.py | israel-santanna/semantic-clustering | cd778c882aff72924c7b2a82f041f53f0e04d356 | [
"MIT"
] | 4 | 2018-04-23T02:47:05.000Z | 2020-11-04T14:59:18.000Z | import re
import sys
import string
from time import sleep
from imdb import IMDb as IMDBPy
from imdbpie import Imdb as IMDBPie
from imdb._exceptions import IMDbDataAccessError
from io import open
class ImdbExtractor(object):
def __init__(self, data_path=None):
super(ImdbExtractor, self).__init__()
self.search_api = IMDBPy()
self.info_api = IMDBPie(anonymize=True)
self.movie_lens = MovieLens(data_path)
# self.data_path = "data/movies_data"
self.data_path = data_path + ".out" if data_path \
else "data/movies_data"
self.errors = []
def retrieve_objects(self):
movies = self.movie_lens.movies()
with open(self.data_path, "w", 1, encoding="utf-8") as file:
for movie in movies:
print("\n")
print(movie.id)
print(movie.data["name"])
while True:
try:
m = self.find_movie(movie.data["name"])
except IMDbDataAccessError as e:
print("========== CONNECTION ERROR ==========")
print(e)
sleep(5)
else:
break
data = str(movie.id)
if m:
plots, genres = self.movie_info(m.movieID)
reviews = self.movie_reviews(m.movieID)
if plots or genres or reviews:
movie.data["genres"].extend(genres)
data += u'::' + movie.data["name"]
data += u'::' + u' '.join(filter(None, plots))
data += u'::' + u' '.join(filter(None,
movie.data["genres"]))
data += u'::' + u' '.join(filter(None, reviews))
data = data.replace('\r', ' ').replace('\n', ' ')
else:
data += u"::ERROR"
else:
data += u"::ERROR"
file.write(data + u"\n")
def movie_reviews(self, movie_id):
try:
reviews = self.info_api.get_title_reviews("tt" + movie_id,
max_results=20)
except ValueError as e:
return []
reviews_arr = []
if reviews:
for r in reviews:
review = r.summary if r.summary else ""
review += " " + r.text if r.text else ""
reviews_arr.append(review)
return reviews_arr
def movie_info(self, movie_id):
try:
movie = self.info_api.get_title_by_id("tt" + movie_id)
except ValueError as e:
return [], []
plots = movie.plots if movie.plots else []
genres = movie.genres if movie.genres else []
return plots, genres
def find_movie(self, name):
movies = self.search_api.search_movie(name)
if not movies:
name = re.sub("\((\D*)\)", "", name)
print("---------- SEARCHING AGAIN: ----------")
print(name)
movies = self.search_api.search_movie(name)
print(movies)
if not movies:
print("########## NO MOVIE FOUND ##########")
return None
def sanitize_name(_str):
new_str = _str.strip().lower()
for char in string.punctuation:
new_str = new_str.replace(char, "")
return new_str
name_split = name.split("(")
title = sanitize_name(name_split[0])
year = int(name_split[-1][:-1].strip())
movie = None
for i in movies:
if "year" in i.keys() and int(i["year"]) == year:
movie = i
break
if not movie:
print("########## NO MOVIE FROM SAME YEAR ##########")
return None
self.search_api.update(movie)
eng_title = ""
if "akas" in movie.keys():
print("tem akas")
for aka in movie["akas"]:
aka_split = aka.split("::")
if len(aka_split) > 1 \
and (aka_split[1].find("(English title)") != -1 \
or aka_split[1].find("USA") != -1):
eng_title = aka_split[0].strip().lower()
break
imdb_title = sanitize_name(movie["title"])
original_title = name_split[1].strip()[:-1].lower()
print("imdb title: " + imdb_title)
print("english title: " + eng_title)
print("year: " + str(movie["year"]))
if imdb_title == title or eng_title == title \
or (len(name_split) == 3 \
and imdb_title == original_title):
return movie
else:
print("########## FOUND DIFFERENT MOVIE ##########")
print(movie["title"] + " (" + str(movie["year"]) + ")")
return None
if __name__ == "__main__":
if __package__ is None:
from os import path
sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
from movie_lens import MovieLens
else:
from .movie_lens import MovieLens
data_path = sys.argv[1] if len(sys.argv) > 1 else None
extractor = ImdbExtractor(data_path)
extractor.retrieve_objects()
else:
from .movie_lens import MovieLens
| 36.464052 | 79 | 0.475712 |
f28ec71457c4ac1036c2b26dbc698ae833e2dda2 | 797 | py | Python | scripts/geodata/i18n/download_cldr.py | Fillr/libpostal | bce153188aff9fbe65aef12c3c639d8069e707fc | [
"MIT"
] | 3,489 | 2015-03-03T00:21:38.000Z | 2022-03-29T09:03:05.000Z | scripts/geodata/i18n/download_cldr.py | StephenHildebrand/libpostal | d8c9847c5686a1b66056e65128e1774f060ff36f | [
"MIT"
] | 488 | 2015-05-29T23:04:28.000Z | 2022-03-29T11:20:24.000Z | scripts/geodata/i18n/download_cldr.py | StephenHildebrand/libpostal | d8c9847c5686a1b66056e65128e1774f060ff36f | [
"MIT"
] | 419 | 2015-11-24T16:53:07.000Z | 2022-03-27T06:51:28.000Z | import os
import shutil
import subprocess
import sys
import tempfile
from unicode_paths import CLDR_DIR
from geodata.file_utils import ensure_dir
this_dir = os.path.realpath(os.path.dirname(__file__))
sys.path.append(os.path.realpath(os.path.join(os.pardir, os.pardir)))
CLDR_URL = 'http://www.unicode.org/Public/cldr/latest/core.zip'
def download_cldr(temp_dir=None):
if os.path.exists(CLDR_DIR):
shutil.rmtree(CLDR_DIR)
ensure_dir(CLDR_DIR)
if not temp_dir:
temp_dir = tempfile.gettempdir()
cldr_filename = os.path.join(temp_dir, CLDR_URL.rsplit('/', 1)[-1])
subprocess.check_call(['wget', CLDR_URL, '-O', cldr_filename])
subprocess.check_call(['unzip', cldr_filename, '-d', CLDR_DIR])
if __name__ == '__main__':
download_cldr(*sys.argv[1:])
| 25.709677 | 71 | 0.723965 |
9f614433f7bf1a5809b1d878c83894bd6160e505 | 689 | py | Python | tests/test_device_types.py | hcallen/python-xmatters | 122b029c1f592e58b39a3a84a17123c2de14951c | [
"MIT"
] | null | null | null | tests/test_device_types.py | hcallen/python-xmatters | 122b029c1f592e58b39a3a84a17123c2de14951c | [
"MIT"
] | null | null | null | tests/test_device_types.py | hcallen/python-xmatters | 122b029c1f592e58b39a3a84a17123c2de14951c | [
"MIT"
] | null | null | null | import xmatters.objects.device_types
import xmatters.factories
from .conftest import my_vcr
class TestGet:
@my_vcr.use_cassette('test_get_device_types.json')
def test_get(self, xm_test):
dts = xm_test.device_types_endpoint().get_device_types()
assert isinstance(dts, xmatters.objects.device_types.DeviceTypes)
class TestAccounting:
@my_vcr.use_cassette('test_device_types_accounting.json')
def test_accounting(self, xm_test):
devices = list(xm_test.devices_endpoint().get_devices())
assert len(devices) > 0
for device in devices:
assert device.device_type in xmatters.factories.DeviceFactory.factory_objects.keys()
| 31.318182 | 96 | 0.744557 |
bcea69ca52ff73c3e5720ef3c2b26568d5bb1b38 | 5,669 | py | Python | toolium/test/pageelements/test_page_elements_groups.py | tanistra/toolium | d7f06c7ab9f264c42fe55eed4f9a3065512d910e | [
"Apache-2.0"
] | null | null | null | toolium/test/pageelements/test_page_elements_groups.py | tanistra/toolium | d7f06c7ab9f264c42fe55eed4f9a3065512d910e | [
"Apache-2.0"
] | null | null | null | toolium/test/pageelements/test_page_elements_groups.py | tanistra/toolium | d7f06c7ab9f264c42fe55eed4f9a3065512d910e | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
u"""
Copyright 2016 Telefónica Investigación y Desarrollo, S.A.U.
This file is part of Toolium.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import mock
import pytest
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
from toolium.driver_wrapper import DriverWrapper
from toolium.driver_wrappers_pool import DriverWrappersPool
from toolium.pageelements import PageElements, Group, InputText, Link
from toolium.pageobjects.page_object import PageObject
class Column(Group):
def init_page_elements(self):
self.input = InputText(By.XPATH, './/input')
self.link = Link(By.XPATH, './/a')
self.input_with_parent = InputText(By.XPATH, './/input', (By.XPATH, './/parent'))
class Columns(PageElements):
page_element_class = Column
class Row(Group):
def init_page_elements(self):
self.columns = Columns(By.XPATH, './/td')
class Rows(PageElements):
page_element_class = Row
class TablePageObject(PageObject):
def init_page_elements(self):
self.rows = Rows(By.XPATH, '//table//tr')
@pytest.fixture
def driver_wrapper():
# Reset wrappers pool values
DriverWrappersPool._empty_pool()
DriverWrapper.config_properties_filenames = None
# Create a new wrapper
driver_wrapper = DriverWrappersPool.get_default_wrapper()
driver_wrapper.driver = mock.MagicMock()
return driver_wrapper
def test_reset_object_page_elements_groups(driver_wrapper):
# Mock Driver.save_web_element = True
driver_wrapper.config = mock.MagicMock()
driver_wrapper.config.getboolean_optional.return_value = True
# Create mock rows
mock_element_1 = mock.MagicMock(spec=WebElement)
mock_element_2 = mock.MagicMock(spec=WebElement)
driver_wrapper.driver.find_elements.side_effect = [[mock_element_1, mock_element_2]]
# Create mock columns
mock_element_11 = mock.MagicMock(spec=WebElement)
mock_element_12 = mock.MagicMock(spec=WebElement)
mock_element_1.find_elements.return_value = [mock_element_11]
mock_element_2.find_elements.return_value = [mock_element_12]
table_page = TablePageObject()
# Get elements for each row and column
for row in table_page.rows.page_elements:
for column in row.columns.page_elements:
column.input.web_element
column.link.web_element
column.input_with_parent.web_element
# Check that web and page elements are filled in rows
assert len(table_page.rows._web_elements) == 2
row_1 = table_page.rows._page_elements[0]
row_2 = table_page.rows._page_elements[1]
assert row_1._web_element is not None
assert row_2._web_element is not None
# Check that web and page elements are filled in columns
assert len(row_1.columns._web_elements) == 1
assert len(row_1.columns._web_elements) == 1
column_11 = row_1.columns._page_elements[0]
column_21 = row_2.columns._page_elements[0]
assert column_11._web_element is not None
assert column_21._web_element is not None
# Check that web elements are filled
assert column_11.input._web_element is not None
assert column_11.link._web_element is not None
assert column_11.input_with_parent._web_element is not None
assert column_21.input._web_element is not None
assert column_21.link._web_element is not None
assert column_21.input_with_parent._web_element is not None
# Check that the group elements have the group as parent
assert column_11.parent == row_1
assert column_21.parent == row_2
assert column_11.input.parent == column_11
assert column_11.link.parent == column_11
assert column_11.input_with_parent.parent == column_11
assert column_21.input.parent == column_21
assert column_21.link.parent == column_21
assert column_21.input_with_parent.parent == column_21
table_page.reset_object()
# Check that web and page elements are reset in rows
assert len(table_page.rows._web_elements) == 0
assert len(table_page.rows._page_elements) == 0
assert row_1._web_element is None
assert row_2._web_element is None
# Check that web and page elements are reset in columns
assert len(row_1.columns._web_elements) == 0
assert len(row_1.columns._web_elements) == 0
assert column_11._web_element is None
assert column_21._web_element is None
# Check that web element are reset
assert column_11.input._web_element is None
assert column_11.link._web_element is None
assert column_11.input_with_parent._web_element is None
assert column_21.input._web_element is None
assert column_21.link._web_element is None
assert column_21.input_with_parent._web_element is None
# Check that the group elements have the group as parent
assert column_11.parent == row_1
assert column_21.parent == row_2
assert column_11.input.parent == column_11
assert column_11.link.parent == column_11
assert column_11.input_with_parent.parent == column_11
assert column_21.input.parent == column_21
assert column_21.link.parent == column_21
assert column_21.input_with_parent.parent == column_21
| 38.04698 | 89 | 0.754454 |
bf9c70d87398801f7ecf74a8b8ebb69daa8d4452 | 1,346 | py | Python | bitcoin_predict.py | hodl2020/Bitcoin_price_prediction | 29214fb3cf94c53ba9626b72419c517d15f2d1a2 | [
"MIT"
] | null | null | null | bitcoin_predict.py | hodl2020/Bitcoin_price_prediction | 29214fb3cf94c53ba9626b72419c517d15f2d1a2 | [
"MIT"
] | null | null | null | bitcoin_predict.py | hodl2020/Bitcoin_price_prediction | 29214fb3cf94c53ba9626b72419c517d15f2d1a2 | [
"MIT"
] | null | null | null | import quandl
import pandas as pd
import numpy as np
import datetime
from sklearn.linear_model import LinearRegression
from sklearn import preprocessing, model_selection, svm
# df = quandl.get("WIKI/FB") #uncomment for stocks
today = datetime.datetime.now()
earlier = today - datetime.timedelta(days=1460)
df = quandl.get("BITFINEX/BTCUSD", start_date=earlier, end_date=today)
df = df.rename(columns={'Mid': 'Adj. Close'}) # comment for stocks
df = df[['Adj. Close']]
forecast_out = int(7) # predicting 7 days into future
# label column with data shifted 7 units up
df['Prediction'] = df[['Adj. Close']].shift(-forecast_out)
x = np.array(df.drop(['Prediction'], 1))
x = preprocessing.scale(x) # Scaling features to normalize the data
x_forecast = x[-forecast_out:] # set it to last 7
x = x[:-forecast_out] # remove last 7 from x
y = np.array(df['Prediction'])
y = y[:-forecast_out]
# splitting of data
x_train, x_test, y_train, y_test = model_selection.train_test_split(
x, y, test_size=0.20)
# Training
clf = LinearRegression()
clf.fit(x_train, y_train)
# Testing
confidence = clf.score(x_test, y_test)
print("confidence: ", confidence)
# Prediction
forecast_prediction = clf.predict(x_forecast)
print(forecast_prediction)
print('\nThis is not a financial advise.')
| 25.396226 | 71 | 0.703566 |
edff6985253a6506550955800a9816f6bb6e9af9 | 526 | py | Python | Cloud API Server/PDF Forms Info Reader/Python/PDFFormInfoReader.py | atkins126/ByteScout-SDK-SourceCode | cc4bc9e779ad95f85be0a8630c17878006059684 | [
"Apache-2.0"
] | 24 | 2017-01-13T13:43:21.000Z | 2021-12-23T07:57:19.000Z | Cloud API Server/PDF Forms Info Reader/Python/PDFFormInfoReader.py | atkins126/ByteScout-SDK-SourceCode | cc4bc9e779ad95f85be0a8630c17878006059684 | [
"Apache-2.0"
] | 1 | 2017-03-29T08:22:18.000Z | 2017-05-13T12:27:02.000Z | Cloud API Server/PDF Forms Info Reader/Python/PDFFormInfoReader.py | atkins126/ByteScout-SDK-SourceCode | cc4bc9e779ad95f85be0a8630c17878006059684 | [
"Apache-2.0"
] | 35 | 2016-08-03T19:15:44.000Z | 2022-03-27T16:38:58.000Z | import requests
# Please NOTE: In this sample we're assuming Cloud Api Server is hosted at "https://localhost".
# If it's not then please replace this with with your hosting url.
url = "https://localhost/pdf/info/fields"
payload = {'url': 'https://bytescout-com.s3-us-west-2.amazonaws.com/files/demo-files/cloud-api/pdf-form/f1040.pdf'}
files = [
]
headers = {
'x-api-key': '{{x-api-key}}'
}
response = requests.request("POST", url, headers=headers, data = payload, files = files)
print(response.text.encode('utf8'))
| 27.684211 | 115 | 0.703422 |
f28ed233634b9f8533d98642367878338dc7899a | 2,901 | py | Python | marketing/migrations/0015_auto_20200912_0301.py | renzyndrome/lits-crm | 32daea8c76f91780b8cc8c3f107d04df606c0ec8 | [
"MIT"
] | 1 | 2021-08-23T05:25:30.000Z | 2021-08-23T05:25:30.000Z | marketing/migrations/0015_auto_20200912_0301.py | MrNevil/Django-CRM | 8cb9803748bb3e03f843c47413232185f78261f2 | [
"MIT"
] | null | null | null | marketing/migrations/0015_auto_20200912_0301.py | MrNevil/Django-CRM | 8cb9803748bb3e03f843c47413232185f78261f2 | [
"MIT"
] | 1 | 2021-12-09T09:38:50.000Z | 2021-12-09T09:38:50.000Z | # Generated by Django 3.1 on 2020-09-11 21:31
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("common", "0022_auto_20200609_1203"),
("marketing", "0014_emailtemplate_company"),
]
operations = [
migrations.AddField(
model_name="blockeddomain",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
to="common.company",
),
),
migrations.AddField(
model_name="blockedemail",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
to="common.company",
),
),
migrations.AddField(
model_name="campaign",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name="marketing_campaigns_company",
to="common.company",
),
),
migrations.AddField(
model_name="contact",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name="marketing_contacts_company",
to="common.company",
),
),
migrations.AddField(
model_name="contactemailcampaign",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name="marketing_contacts_emails_campaign_company",
to="common.company",
),
),
migrations.AddField(
model_name="contactlist",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name="marketing_contactlist_company",
to="common.company",
),
),
migrations.AddField(
model_name="failedcontact",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name="marketing_failed_contacts_company",
to="common.company",
),
),
migrations.AddField(
model_name="tag",
name="company",
field=models.ForeignKey(
null=True,
on_delete=django.db.models.deletion.CASCADE,
to="common.company",
),
),
]
| 31.193548 | 74 | 0.512237 |
7be2cfbc3926d50148dc14348043abe269ca2f5c | 204 | py | Python | holobot/extensions/moderation/__init__.py | rexor12/holobot | 89b7b416403d13ccfeee117ef942426b08d3651d | [
"MIT"
] | 1 | 2021-05-24T00:17:46.000Z | 2021-05-24T00:17:46.000Z | holobot/extensions/moderation/__init__.py | rexor12/holobot | 89b7b416403d13ccfeee117ef942426b08d3651d | [
"MIT"
] | 41 | 2021-03-24T22:50:09.000Z | 2021-12-17T12:15:13.000Z | holobot/extensions/moderation/__init__.py | rexor12/holobot | 89b7b416403d13ccfeee117ef942426b08d3651d | [
"MIT"
] | null | null | null | from .config_provider import ConfigProvider
from .iconfig_provider import IConfigProvider
from .mute_cleanup_processor import MuteCleanupProcessor
from .warn_cleanup_processor import WarnCleanupProcessor
| 40.8 | 56 | 0.901961 |
56b6c53404b9e689adbb0ac6cb492794f3acdd04 | 1,208 | py | Python | utils/upload_sword.py | andreyfedoseev/LearningRegistry | 5b803b882413318b142cf154fa4bccf8a9dbe046 | [
"Apache-2.0"
] | 26 | 2015-04-14T03:11:58.000Z | 2022-01-06T14:31:07.000Z | utils/upload_sword.py | andreyfedoseev/LearningRegistry | 5b803b882413318b142cf154fa4bccf8a9dbe046 | [
"Apache-2.0"
] | 11 | 2015-04-03T21:54:03.000Z | 2017-05-02T17:20:03.000Z | utils/upload_sword.py | andreyfedoseev/LearningRegistry | 5b803b882413318b142cf154fa4bccf8a9dbe046 | [
"Apache-2.0"
] | 16 | 2015-02-11T09:30:18.000Z | 2020-11-20T02:06:24.000Z | #!/usr/bin/python
import urllib2
import os
import json
import ConfigParser
from random import choice
_config = ConfigParser.ConfigParser()
_config.read('testconfig.ini')
root_path = _config.get("upload", "root_path")
publish_url = _config.get("upload", "sword_url")
publish_urls = ['http://node01.public.learningregistry.net/sword','http://node02.public.learningregistry.net/sword','http://node03.public.learningregistry.net/sword']
results = []
def upload_file(doc):
try:
data = json.dumps(doc)
request = urllib2.Request(publish_url,data,{'Content-Type':'application/json'})
response = urllib2.urlopen(request)
result = response.read()
print result
results.append(result)
except urllib2.URLError as er:
print er
print publish_url
except urllib2.HTTPError as er:
with open('error.html','a') as out:
out.write(er.read())
print publish_url
print 'error'
for file in os.listdir(root_path):
publish_url = choice(publish_urls)
file_path = os.path.join(root_path,file)
with open(file_path,'r+') as f:
data = json.load(f)
upload_file(data)
with open('results.xml', 'w') as output:
output.write(str(results))
| 31.789474 | 167 | 0.698675 |
9733c1639766aeff3654d164803eb9d64695c5fd | 863 | py | Python | nlutestframework/has_logger.py | emundo/nlutestframework | fcda0028b4d04557f951c0eacdaf8895d3af2e3d | [
"Apache-2.0"
] | null | null | null | nlutestframework/has_logger.py | emundo/nlutestframework | fcda0028b4d04557f951c0eacdaf8895d3af2e3d | [
"Apache-2.0"
] | null | null | null | nlutestframework/has_logger.py | emundo/nlutestframework | fcda0028b4d04557f951c0eacdaf8895d3af2e3d | [
"Apache-2.0"
] | null | null | null | import logging
# Other imports only for the type hints
from typing import Optional
class HasLogger:
"""
Base class for classes that want to make use of the Python :mod:`logging`-library.
"""
def __init__(self, logger_title: Optional[str] = None):
"""
Instantiate a :class:`~logging.Logger` with given title.
Args:
logger_title: The title of the logger to create for this instance. Defaults to the class
name if omitted or set to :obj:`None`.
"""
self._logger_title = self.__class__.__name__ if logger_title is None else logger_title
@property
def _logger(self) -> logging.Logger:
"""
Returns:
A logger instance with the title set to the value chosen during construction.
"""
return logging.getLogger(self._logger_title)
| 28.766667 | 100 | 0.641947 |
1616488e437019fedf0f6bbe9d8475e7d37b1336 | 3,192 | py | Python | sympy/printing/python.py | ethankward/sympy | 44664d9f625a1c68bc492006cfe1012cb0b49ee4 | [
"BSD-3-Clause"
] | 445 | 2019-01-26T13:50:26.000Z | 2022-03-18T05:17:38.000Z | sympy/printing/python.py | otoosakyidavid/sympy | 636221ff35c78b980f828a285d0c552fac77aaba | [
"BSD-3-Clause"
] | 242 | 2019-01-29T15:48:27.000Z | 2022-03-31T22:09:21.000Z | sympy/printing/python.py | otoosakyidavid/sympy | 636221ff35c78b980f828a285d0c552fac77aaba | [
"BSD-3-Clause"
] | 31 | 2019-03-10T09:51:27.000Z | 2022-02-14T23:11:12.000Z | from __future__ import print_function, division
import keyword as kw
import sympy
from .repr import ReprPrinter
from .str import StrPrinter
# A list of classes that should be printed using StrPrinter
STRPRINT = ("Add", "Infinity", "Integer", "Mul", "NegativeInfinity",
"Pow", "Zero")
class PythonPrinter(ReprPrinter, StrPrinter):
"""A printer which converts an expression into its Python interpretation."""
def __init__(self, settings=None):
super(PythonPrinter, self).__init__(settings)
self.symbols = []
self.functions = []
# Create print methods for classes that should use StrPrinter instead
# of ReprPrinter.
for name in STRPRINT:
f_name = "_print_%s" % name
f = getattr(StrPrinter, f_name)
setattr(PythonPrinter, f_name, f)
def _print_Function(self, expr):
func = expr.func.__name__
if not hasattr(sympy, func) and not func in self.functions:
self.functions.append(func)
return StrPrinter._print_Function(self, expr)
# procedure (!) for defining symbols which have be defined in print_python()
def _print_Symbol(self, expr):
symbol = self._str(expr)
if symbol not in self.symbols:
self.symbols.append(symbol)
return StrPrinter._print_Symbol(self, expr)
def _print_module(self, expr):
raise ValueError('Modules in the expression are unacceptable')
def python(expr, **settings):
"""Return Python interpretation of passed expression
(can be passed to the exec() function without any modifications)"""
printer = PythonPrinter(settings)
exprp = printer.doprint(expr)
result = ''
# Returning found symbols and functions
renamings = {}
for symbolname in printer.symbols:
newsymbolname = symbolname
# Escape symbol names that are reserved python keywords
if kw.iskeyword(newsymbolname):
while True:
newsymbolname += "_"
if (newsymbolname not in printer.symbols and
newsymbolname not in printer.functions):
renamings[sympy.Symbol(
symbolname)] = sympy.Symbol(newsymbolname)
break
result += newsymbolname + ' = Symbol(\'' + symbolname + '\')\n'
for functionname in printer.functions:
newfunctionname = functionname
# Escape function names that are reserved python keywords
if kw.iskeyword(newfunctionname):
while True:
newfunctionname += "_"
if (newfunctionname not in printer.symbols and
newfunctionname not in printer.functions):
renamings[sympy.Function(
functionname)] = sympy.Function(newfunctionname)
break
result += newfunctionname + ' = Function(\'' + functionname + '\')\n'
if renamings:
exprp = expr.subs(renamings)
result += 'e = ' + printer._str(exprp)
return result
def print_python(expr, **settings):
"""Print output of python() function"""
print(python(expr, **settings))
| 35.466667 | 80 | 0.625313 |
d7bd36cea224b53fa09f732860e2c3af241a9e29 | 1,819 | py | Python | gopigo3/hardware_test.py | PascalS86/icts-python | 7dde59d7b5284c190aeeaa89e217132b6fa65703 | [
"MIT"
] | null | null | null | gopigo3/hardware_test.py | PascalS86/icts-python | 7dde59d7b5284c190aeeaa89e217132b6fa65703 | [
"MIT"
] | null | null | null | gopigo3/hardware_test.py | PascalS86/icts-python | 7dde59d7b5284c190aeeaa89e217132b6fa65703 | [
"MIT"
] | null | null | null | #!/usr/bin/env python
# This program is for testing GoPiGo3 Hardware.
'''
## License
GoPiGo3 for the Raspberry Pi: an open source robotics platform for the Raspberry Pi.
Copyright (C) 2017 Dexter Industries
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/gpl-3.0.txt>.
'''
from __future__ import print_function
from __future__ import division
from builtins import input
# the above lines are meant for Python3 compatibility.
# they force the use of Python3 functionality for print(),
# the integer division and input()
# mind your parentheses!
import time
import easygopigo3 as easy
import sys
import atexit
gpg = easy.EasyGoPiGo3()
atexit.register(gpg.stop)
gpg.reset_all()
print("Warning: The robot is about to move forward. ")
time.sleep(1) # let's give the reset_all() some time to finish
gpg.set_speed(300)
print ("Both motors moving Forward with Dex Eyes On")
gpg.open_eyes()
gpg.drive_cm(100)
print ("Both motors stopped with Dex Eyes Off")
gpg.close_eyes()
gpg.stop()
time.sleep(2)
print ("Both motors moving back with blinkers On")
gpg.blinker_on(1)
gpg.blinker_on(0)
gpg.drive_cm(-100)
print ("Both motors stopped with blinkers Off")
gpg.blinker_off(1)
gpg.blinker_off(0)
gpg.stop()
print ("Hardware test finished.")
time.sleep(5) | 28.421875 | 85 | 0.770203 |
975f5a4779ea044dccc997be6a0d88d6af178ed1 | 1,593 | py | Python | test/integration/test_global_load_balancer_events_v1.py | chenshuguang/networking-python-sdk | 3bbf30e2706052e75c0cc847d7ee8a584ba93f11 | [
"Apache-2.0"
] | 1 | 2020-12-22T03:51:33.000Z | 2020-12-22T03:51:33.000Z | test/integration/test_global_load_balancer_events_v1.py | chenshuguang/networking-python-sdk | 3bbf30e2706052e75c0cc847d7ee8a584ba93f11 | [
"Apache-2.0"
] | null | null | null | test/integration/test_global_load_balancer_events_v1.py | chenshuguang/networking-python-sdk | 3bbf30e2706052e75c0cc847d7ee8a584ba93f11 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
# (C) Copyright IBM Corp. 2020.
"""
Integration test code to execute global load balancer events functions
"""
import os
import unittest
from dotenv import load_dotenv, find_dotenv
from ibm_cloud_networking_services.global_load_balancer_events_v1 import GlobalLoadBalancerEventsV1
configFile = "cis.env"
# load the .env file containing your environment variables
try:
load_dotenv(find_dotenv(filename="cis.env"))
except:
print('warning: no cis.env file loaded')
class TestGlobalLoadBalancerEventsV1 (unittest.TestCase):
def setUp(self):
""" test case setup """
if not os.path.exists(configFile):
raise unittest.SkipTest(
'External configuration not available, skipping...')
self.endpoint = os.getenv("API_ENDPOINT")
self.crn = os.getenv("CRN")
# create global load balancer events record class object
self.globalLoadBalancerEvents = GlobalLoadBalancerEventsV1.new_instance(
crn=self.crn, service_name="cis_services")
self.globalLoadBalancerEvents.set_service_url(self.endpoint)
def tearDown(self):
""" tear down """
# Delete the resources
print("Clean up complete")
################## get_load_balancer_events ###################
def test_1_get_load_balancer_events(self):
""" test for success """
response = self.globalLoadBalancerEvents.get_load_balancer_events().get_result()
assert response is not None and response.get('success') is True
if __name__ == '__main__':
unittest.main()
| 31.86 | 99 | 0.684244 |
9bed00dc7228e0097bdfc1e32eed41083e19e27b | 734 | py | Python | exif/tests/test_xp_style.py | chbndrhnns/exif | 65aa2d8bcdecf79d34752390310222a9bd5d5bb3 | [
"MIT"
] | null | null | null | exif/tests/test_xp_style.py | chbndrhnns/exif | 65aa2d8bcdecf79d34752390310222a9bd5d5bb3 | [
"MIT"
] | null | null | null | exif/tests/test_xp_style.py | chbndrhnns/exif | 65aa2d8bcdecf79d34752390310222a9bd5d5bb3 | [
"MIT"
] | null | null | null | """Test special behavior for accessing Windows XP style EXIF attribute."""
import os
import pytest
from exif import Image
read_attributes = [
("xp_author", "XP-Style Author"),
("xp_comment", "XP-Style Comment"),
("xp_keywords", "XP-Style Keywords"),
("xp_subject", "XP-Style Subject"),
("xp_title", "XP-Style Title"),
]
@pytest.mark.parametrize("attribute, value", read_attributes, ids=[params[0] for params in read_attributes])
def test_read(attribute, value):
"""Test reading tags and compare to known baseline values."""
with open(os.path.join(os.path.dirname(__file__), 'windows_xp_tags.jpg'), 'rb') as image_file:
image = Image(image_file)
assert getattr(image, attribute) == value
| 29.36 | 108 | 0.69346 |
a3069d5ccd1d2f67fd486e61d980ecd9c7c4c298 | 269,188 | py | Python | docs/source/make_external_gallery.py | softwareunderground/subsurface | ad5a6d2d24e710ce7a78ec99b2075ddbb9dfeb7d | [
"Apache-2.0"
] | 55 | 2019-05-09T12:26:28.000Z | 2021-11-05T07:35:15.000Z | docs/source/make_external_gallery.py | RajdeepTarafder/subsurface | 1308bc2a1d8e803db1680a1300682a91fec8d5fe | [
"Apache-2.0"
] | 33 | 2019-05-09T16:28:19.000Z | 2022-03-30T13:40:21.000Z | docs/source/make_external_gallery.py | RajdeepTarafder/subsurface | 1308bc2a1d8e803db1680a1300682a91fec8d5fe | [
"Apache-2.0"
] | 14 | 2019-05-09T12:26:33.000Z | 2021-09-01T11:31:27.000Z | """
Modified after https://github.com/pyvista/pyvista/blob/ab70c26edbcfb107286c827bd4914562056219fb/docs/make_external_gallery.py
A helper script to generate the external examples gallery.
"""
import os
def format_icon(title, description, link, image):
body = r"""
.. raw:: html
<div class="sphx-glr-thumbcontainer" tooltip="{}">
.. only:: html
.. figure:: {}
:target: {}
{}
.. raw:: html
</div>
.. toctree::
:hidden:
{} <{}>
"""
content = body.format(description, image, link, title, title, link)
return content
class Example():
def __init__(self, title, description, link, image):
self.title = title
self.description = description
self.link = link
self.image = image
def format(self):
return format_icon(self.title, self.description, self.link, self.image)
###############################################################################
articles = dict(
gempy_well=Example(
title="GemPy - Subsurface Link",
description="Build a model from Subsurface object and export result back to subsurface",
link="https://docs.gempy.org/integrations/gempy_subsurface.html#sphx-glr-integrations-gempy-subsurface-py",
image="https://docs.gempy.org/_images/sphx_glr_gempy_subsurface_002.png",
),
segysag=Example(
title="Using segysak with subsurface",
description="Loading a segy cube into `subsurface.StructuredData`.",
link="https://segysak.readthedocs.io/en/latest/examples/example_subsurface.html",
image="https://raw.githubusercontent.com/trhallam/segysak/main/docs/_static/logo_small.png",
),
pygimli=Example(
title="GemPy To pyGIMLi 3D using subsurface",
description="GemPy To pyGIMLi 3D using subsurface",
link="https://htmlpreview.github.io/?https://raw.githubusercontent.com/andieie/t21_hacksubsurface/main/gempy_to_pygimli.html",
image="data:image/png;base64,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",
)
# entry=Example(
# title="",
# description="",
# link="",
# image="",
# ),
)
###############################################################################
def make_example_gallery():
filename = "external/external_examples.rst"
if os.path.exists(filename):
os.remove(filename)
with open(filename, "w") as f:
f.write("""
External Examples
=================
This is a list of packages using ``subsurface`` as input or output of a
workflow. If you have your own example let us know to be added to the gallery.
.. caution::
Please note that these examples link to external websites.
If any of these links are broken, please raise an issue on the repository.
""")
# Reverse to put the latest items at the top
for Example in list(articles.values())[::-1]:
f.write(Example.format())
f.write("""
.. raw:: html
<div class="sphx-glr-clear"></div>
""")
return
| 2,320.586207 | 266,247 | 0.956335 |
d651b7c32d8e5b34270a07fd8847c6ee3837026a | 5,845 | py | Python | vnpy_ctastrategy/strategies/multi_signal_strategy.py | noranhe/vnpy_ctastrategy | 3ddc296bba8a88f09dc6a216c0fb4bd06ff2e232 | [
"MIT"
] | 28 | 2021-05-25T09:29:30.000Z | 2022-03-12T02:28:45.000Z | vnpy_ctastrategy/strategies/multi_signal_strategy.py | noranhe/vnpy_ctastrategy | 3ddc296bba8a88f09dc6a216c0fb4bd06ff2e232 | [
"MIT"
] | 4 | 2021-07-07T16:40:10.000Z | 2022-03-09T08:30:49.000Z | vnpy_ctastrategy/strategies/multi_signal_strategy.py | noranhe/vnpy_ctastrategy | 3ddc296bba8a88f09dc6a216c0fb4bd06ff2e232 | [
"MIT"
] | 34 | 2021-05-25T07:01:21.000Z | 2022-03-14T09:03:23.000Z | from vnpy_ctastrategy import (
StopOrder,
TickData,
BarData,
TradeData,
OrderData,
BarGenerator,
ArrayManager,
CtaSignal,
TargetPosTemplate
)
class RsiSignal(CtaSignal):
""""""
def __init__(self, rsi_window: int, rsi_level: float):
"""Constructor"""
super().__init__()
self.rsi_window = rsi_window
self.rsi_level = rsi_level
self.rsi_long = 50 + self.rsi_level
self.rsi_short = 50 - self.rsi_level
self.bg = BarGenerator(self.on_bar)
self.am = ArrayManager()
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg.update_tick(tick)
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.am.update_bar(bar)
if not self.am.inited:
self.set_signal_pos(0)
rsi_value = self.am.rsi(self.rsi_window)
if rsi_value >= self.rsi_long:
self.set_signal_pos(1)
elif rsi_value <= self.rsi_short:
self.set_signal_pos(-1)
else:
self.set_signal_pos(0)
class CciSignal(CtaSignal):
""""""
def __init__(self, cci_window: int, cci_level: float):
""""""
super().__init__()
self.cci_window = cci_window
self.cci_level = cci_level
self.cci_long = self.cci_level
self.cci_short = -self.cci_level
self.bg = BarGenerator(self.on_bar)
self.am = ArrayManager()
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg.update_tick(tick)
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.am.update_bar(bar)
if not self.am.inited:
self.set_signal_pos(0)
cci_value = self.am.cci(self.cci_window)
if cci_value >= self.cci_long:
self.set_signal_pos(1)
elif cci_value <= self.cci_short:
self.set_signal_pos(-1)
else:
self.set_signal_pos(0)
class MaSignal(CtaSignal):
""""""
def __init__(self, fast_window: int, slow_window: int):
""""""
super().__init__()
self.fast_window = fast_window
self.slow_window = slow_window
self.bg = BarGenerator(self.on_bar, 5, self.on_5min_bar)
self.am = ArrayManager()
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
self.bg.update_tick(tick)
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
self.bg.update_bar(bar)
def on_5min_bar(self, bar: BarData):
""""""
self.am.update_bar(bar)
if not self.am.inited:
self.set_signal_pos(0)
fast_ma = self.am.sma(self.fast_window)
slow_ma = self.am.sma(self.slow_window)
if fast_ma > slow_ma:
self.set_signal_pos(1)
elif fast_ma < slow_ma:
self.set_signal_pos(-1)
else:
self.set_signal_pos(0)
class MultiSignalStrategy(TargetPosTemplate):
""""""
author = "用Python的交易员"
rsi_window = 14
rsi_level = 20
cci_window = 30
cci_level = 10
fast_window = 5
slow_window = 20
signal_pos = {}
parameters = ["rsi_window", "rsi_level", "cci_window",
"cci_level", "fast_window", "slow_window"]
variables = ["signal_pos", "target_pos"]
def __init__(self, cta_engine, strategy_name, vt_symbol, setting):
""""""
super().__init__(cta_engine, strategy_name, vt_symbol, setting)
self.rsi_signal = RsiSignal(self.rsi_window, self.rsi_level)
self.cci_signal = CciSignal(self.cci_window, self.cci_level)
self.ma_signal = MaSignal(self.fast_window, self.slow_window)
self.signal_pos = {
"rsi": 0,
"cci": 0,
"ma": 0
}
def on_init(self):
"""
Callback when strategy is inited.
"""
self.write_log("策略初始化")
self.load_bar(10)
def on_start(self):
"""
Callback when strategy is started.
"""
self.write_log("策略启动")
def on_stop(self):
"""
Callback when strategy is stopped.
"""
self.write_log("策略停止")
def on_tick(self, tick: TickData):
"""
Callback of new tick data update.
"""
super(MultiSignalStrategy, self).on_tick(tick)
self.rsi_signal.on_tick(tick)
self.cci_signal.on_tick(tick)
self.ma_signal.on_tick(tick)
self.calculate_target_pos()
def on_bar(self, bar: BarData):
"""
Callback of new bar data update.
"""
super(MultiSignalStrategy, self).on_bar(bar)
self.rsi_signal.on_bar(bar)
self.cci_signal.on_bar(bar)
self.ma_signal.on_bar(bar)
self.calculate_target_pos()
def calculate_target_pos(self):
""""""
self.signal_pos["rsi"] = self.rsi_signal.get_signal_pos()
self.signal_pos["cci"] = self.cci_signal.get_signal_pos()
self.signal_pos["ma"] = self.ma_signal.get_signal_pos()
target_pos = 0
for v in self.signal_pos.values():
target_pos += v
self.set_target_pos(target_pos)
def on_order(self, order: OrderData):
"""
Callback of new order data update.
"""
super(MultiSignalStrategy, self).on_order(order)
def on_trade(self, trade: TradeData):
"""
Callback of new trade data update.
"""
self.put_event()
def on_stop_order(self, stop_order: StopOrder):
"""
Callback of stop order update.
"""
pass
| 24.558824 | 71 | 0.572113 |
d02abf622a342922b4ee154c4b6e182c4d57cdae | 15,117 | py | Python | basic_samples/Dataviews/Python3/program.py | osi-awoodall/OSI-Samples-OCS | 1995ccda20e4fe2ae66f3b67afbc1127d638a6fc | [
"Apache-2.0"
] | null | null | null | basic_samples/Dataviews/Python3/program.py | osi-awoodall/OSI-Samples-OCS | 1995ccda20e4fe2ae66f3b67afbc1127d638a6fc | [
"Apache-2.0"
] | null | null | null | basic_samples/Dataviews/Python3/program.py | osi-awoodall/OSI-Samples-OCS | 1995ccda20e4fe2ae66f3b67afbc1127d638a6fc | [
"Apache-2.0"
] | null | null | null | # version 0.0.3
from ocs_sample_library_preview import (
SdsTypeCode, SdsType, SdsTypeProperty, SdsStream, OCSClient, Dataview,
DataviewQuery, DataviewGroupRule, DataviewMapping, DataviewIndexConfig)
import configparser
import datetime
import time
import traceback
###############################################################################
# The following define the identifiers we'll use throughout
###############################################################################
sampleDataviewId = "Dataview_Sample"
sampleDataviewName = "Dataview_Sample_Name"
sampleDataviewDescription = "A Sample Description that describes that this "\
"Dataview is just used for our sample."
sampleDataviewDescription_modified = "A longer sample description that "\
"describes that this Dataview is just "\
"used for our sample and this part shows"\
" a put."
samplePressureTypeId = "Time_Pressure_SampleType"
samplePressureStreamId = "Tank_Pressure_SampleStream"
samplePressureStreamName = "Tank Pressure SampleStream"
sampleTemperatureTypeId = "Time_Temperature_SampleType"
sampleTemperatureStreamId = "Tank_Temperature_SampleStream"
sampleTemperatureStreamName = "Tank Temperature SampleStream"
# In this example we will keep the SDS code in its own function.
# The variable needData is used in the main program to decide if we need to do
# this. In the rest of the code it is assumed this is used.
# The SDS code is not highlighted, but should be straightforward to follow.
# It creates enough Types, Streams and Data to see a result.
# For more details on the creating SDS objects see the SDS python example.
# This is kept seperate because chances are your data collection will occur at
# a different time then your creation of Dataviews, but for a complete
# example we assume a blank start.
needData = True
namespaceId = ''
config = configparser.ConfigParser()
config.read('config.ini')
startTime = None
def supressError(sdsCall):
try:
sdsCall()
except Exception as e:
print(("Encountered Error: {error}".format(error=e)))
def createData(ocsClient):
import random
global namespaceId, startTime
doubleType = SdsType(id="doubleType", sdsTypeCode=SdsTypeCode.Double)
dateTimeType = SdsType(id="dateTimeType", sdsTypeCode=SdsTypeCode.DateTime)
pressureDoubleProperty = SdsTypeProperty(id="pressure", sdsType=doubleType)
temperatureDoubleProperty = SdsTypeProperty(id="temperature",
sdsType=doubleType)
timeDateTimeProperty = SdsTypeProperty(id="time", sdsType=dateTimeType,
isKey=True)
pressure_SDSType = SdsType(
id=samplePressureTypeId,
description="This is a sample Sds type for storing Pressure type "
"events for Dataviews",
sdsTypeCode=SdsTypeCode.Object,
properties=[pressureDoubleProperty, timeDateTimeProperty])
temperature_SDSType = SdsType(
id=sampleTemperatureTypeId,
description="This is a sample Sds type for storing Temperature type "
"events for Dataviews",
sdsTypeCode=SdsTypeCode.Object,
properties=[temperatureDoubleProperty, timeDateTimeProperty])
print('Creating SDS Type')
ocsClient.Types.getOrCreateType(namespaceId, pressure_SDSType)
ocsClient.Types.getOrCreateType(namespaceId, temperature_SDSType)
pressureStream = SdsStream(
id=samplePressureStreamId,
name=samplePressureStreamName,
description="A Stream to store the sample Pressure events",
typeId=samplePressureTypeId)
temperatureStream = SdsStream(
id=sampleTemperatureStreamId,
name=sampleTemperatureStreamName,
description="A Stream to store the sample Temperature events",
typeId=sampleTemperatureTypeId)
print('Creating SDS Streams')
ocsClient.Streams.createOrUpdateStream(namespaceId, pressureStream)
ocsClient.Streams.createOrUpdateStream(namespaceId, temperatureStream)
start = datetime.datetime.now() - datetime.timedelta(hours=1)
pressureValues = []
temperatureValues = []
def valueWithTime(timestamp, sensor, value):
return f'{{"time": "{timestamp}", "{sensor}": {str(value)} }}'
print('Generating Values')
for i in range(1, 30, 1):
pv = str(random.uniform(0, 100))
tv = str(random.uniform(50, 70))
timestamp = (start + datetime.timedelta(minutes=i * 2)).isoformat(timespec='seconds')
pVal = valueWithTime(timestamp, "pressure", random.uniform(0, 100))
tVAl = valueWithTime(timestamp, "temperature", random.uniform(50, 70))
pressureValues.append(pVal)
temperatureValues.append(tVAl)
print('Sending Pressure Values')
ocsClient.Streams.insertValues(
namespaceId,
samplePressureStreamId,
str(pressureValues).replace("'", ""))
print('Sending Temperature Values')
ocsClient.Streams.insertValues(
namespaceId,
sampleTemperatureStreamId,
str(temperatureValues).replace("'", ""))
startTime = start
def main(test=False):
global namespaceId
success = True
exception = {}
try:
print("--------------------------------------------------------------------")
print(" ###### ###### # # ")
print(" # # ## ##### ## # # # ###### # # # # # # ")
print(" # # # # # # # # # # # # # # # # # ")
print(" # # # # # # # # # # ##### # # ###### # ")
print(" # # ###### # ###### # # # # # ## # # # ")
print(" # # # # # # # # # # # ## ## # # ")
print(" ###### # # # # # ## # ###### # # # # ")
print("--------------------------------------------------------------------")
# Step 1
ocsClient = OCSClient(config.get('Access', 'ApiVersion'),
config.get('Access', 'Tenant'),
config.get('Access', 'Resource'),
config.get('Credentials', 'ClientId'),
config.get('Credentials', 'ClientSecret'))
namespaceId = config.get('Configurations', 'Namespace')
print(namespaceId)
print(ocsClient.uri)
# Step 2
if needData:
createData(ocsClient)
sampleStreamId = "SampleStream"
#######################################################################
# Dataviews
#######################################################################
# We need to create the dataview.
# For our dataview we are going to combine the two streams that were
# created, using a search to find the streams,
# using common part of their name.
# We are using the default mappings.
# This means our columns will keep their original names.
# Another typical use of columns is to change what stream properties
# get mapped to which column.
# Mappings allow you to rename a column in the results to something
# different. So if we want to we could rename Pressure to press.
# We then define the IndexDataType. Currently only
# datetime is supported.
# Next we need to define IndexConfig. It holds the default
# startIndex and endIndex to define a time period, mode (interpolated),
# and interpolation interval.
# Our results when looking at it like a table looks like:
#
# time,pressure,temperature
# 2019-06-27T12:23:00Z,36.3668286389033,60.614978497887
# 2019-06-27T12:24:00Z,36.3668286389033,60.614978497887
# 2019-06-27T12:25:00Z,36.3668286389033,60.614978497887
# 2019-06-27T12:26:00Z,40.5653155047711,59.4181700259214
# 2019-06-27T12:27:00Z,54.5602717243303,55.4288084527031
# ...
# Step 3
queryObj = DataviewQuery(sampleDataviewId, f"name:*{sampleStreamId}*")
if startTime:
indexConfigObj = DataviewIndexConfig(startIndex=startTime.isoformat(timespec='minutes'),
endIndex=(startTime + datetime.timedelta(minutes=40)).isoformat(timespec='minutes'),
mode="Interpolated",
interval="00:01:00")
else:
indexConfigObj = None
dataview = Dataview(id=sampleDataviewId, queries=queryObj,
indexDataType="datetime",
name=sampleDataviewName,
indexConfig=indexConfigObj,
description=sampleDataviewDescription)
print
print("Creating dataview")
print(dataview.toJson())
dataviews = ocsClient.Dataviews.postDataview(namespaceId, dataview)
# Step 4
print
print("Getting dataview")
dv = ocsClient.Dataviews.getDataview(namespaceId, sampleDataviewId)
# assert is added to make sure we get back what we are expecting
expectedJSON = '{"Id": "Dataview_Sample", "Queries": [{"Id": "Dataview_Sample", "Query": "name:*SampleStream*"}], "Name": "Dataview_Sample_Name", "Description": "A Sample Description that describes that this Dataview is just used for our sample.", "IndexConfig": {"StartIndex": "2019-09-03T14:10:00.0000000Z", "EndIndex": "2019-09-03T14:50:00.0000000Z", "Mode": "Interpolated", "Interval": "00:01:00"}, "IndexDataType": "DateTime", "GroupRules": []}'
# assert dv.toJson().lower() == expectedJSON.lower(), 'Dataview is different: ' + dv.toJson()
dv.Description = sampleDataviewDescription_modified
# dv.Mappings.IsDefault = False # for now we have to change this to post
# Step 5
print
print("Updating dataview")
# No dataview returned, success is 204
ocsClient.Dataviews.putDataview(namespaceId, dv)
# Step 6
# Getting the complete set of dataviews to make sure it is there
print
print("Getting dataviews")
dataviews = ocsClient.Dataviews.getDataviews(namespaceId)
for dataview1 in dataviews:
if hasattr(dataview1, "Id"):
print(dataview1.toJson())
# Getting the datagroups of the defined dataview.
# The datgroup lets you see what is returned by the Dataview Query.
print
print("Getting Datagroups")
# Step 7
# This works for the automated test. You can use this or the below.
datagroups = ocsClient.Dataviews.getDatagroups(
namespaceId, sampleDataviewId, 0, 100, True)
print('datagroups')
print(datagroups)
# By default the preview get interpolated values every minute over the
# last hour, which lines up with our data that we sent in.
# Beyond the normal API options, this function does have the option
# to return the data in a class if you have created a Type for the
# data you are retrieving.
# Step 8
print
print("Retrieving data preview from the Dataview")
dataviewDataPreview1 = ocsClient.Dataviews.getDataInterpolated(
namespaceId, sampleDataviewId)
print(str(dataviewDataPreview1[0]))
# Step 9
print()
print("Getting data as a table, seperated by commas, with headers")
# Get the first 20 rows, keep token for next 20 rows
dataviewDataTable1, token = ocsClient.Dataviews.getDataInterpolated(
namespaceId, sampleDataviewId, form="csvh", count=20)
# Display received 20 lines showing:
# * First lines with extrapolation (first value replicated of each stream)
# * Interpolated values at 1 minute interval, stream recorded at 2 minutes interval
print(dataviewDataTable1)
print()
# Get the last 20 rows using token, then display (without row header)
dataviewDataTable2, token = ocsClient.Dataviews.getDataInterpolated(
namespaceId, sampleDataviewId, form="csv", count=20, continuationToken=token)
print(dataviewDataTable2, "\n\n")
# Now override startIndex/endIndex/interval of previous Data View
# Ask for last 5 minutes of data, aligned on the seconds, interpolated at 30 seconds
startIndex = (startTime + datetime.timedelta(minutes=55)).isoformat(timespec='seconds')
endIndex = (startTime + datetime.timedelta(minutes=60)).isoformat(timespec='seconds')
dataviewDataTable3, token2 = ocsClient.Dataviews.getDataInterpolated(
namespaceId, sampleDataviewId, form="csvh", count=11, continuationToken=None,
startIndex=startIndex, endIndex=endIndex, interval="00:00:30")
print(dataviewDataTable3)
assert token2 is None, "Continuation token is not None"
except Exception as ex:
print((f"Encountered Error: {ex}"))
print
traceback.print_exc()
print
success = False
exception = ex
finally:
#######################################################################
# Dataview deletion
#######################################################################
print
print
print("Deleting dataview")
# Step 10
supressError(lambda: ocsClient.Dataviews.deleteDataview(
namespaceId, sampleDataviewId))
# check, including assert is added to make sure we deleted it
dv = None
try:
dv = ocsClient.Dataviews.getDataview(namespaceId, sampleDataviewId)
except Exception as ex:
# Exception is expected here since dataview has been deleted
dv = None
finally:
assert dv is None, 'Delete failed'
print("Verification OK: dataview deleted")
if needData:
print("Deleting added Streams")
supressError(lambda: ocsClient.Streams.deleteStream(
namespaceId, samplePressureStreamId))
supressError(lambda: ocsClient.Streams.deleteStream(
namespaceId, sampleTemperatureStreamId))
print("Deleting added Types")
supressError(lambda: ocsClient.Types.deleteType(
namespaceId, samplePressureTypeId))
supressError(lambda: ocsClient.Types.deleteType(
namespaceId, sampleTemperatureTypeId))
if test and not success:
raise exception
main()
print("done")
# Straightforward test to make sure program is working using asserts in
# program. Can run it yourself with pytest program.py
def test_main():
main(True)
| 41.875346 | 458 | 0.599722 |
8d82fd83be269ba27d52991badc68e874691727c | 16,742 | py | Python | gcs_analysis_functions.py | xaviernogueira/gcs_gui | 13001069067460a721927c263ea4c18568cff504 | [
"CNRI-Python"
] | 4 | 2021-08-28T00:00:12.000Z | 2022-03-01T16:12:55.000Z | gcs_analysis_functions.py | xaviernogueira/gcs_gui | 13001069067460a721927c263ea4c18568cff504 | [
"CNRI-Python"
] | null | null | null | gcs_analysis_functions.py | xaviernogueira/gcs_gui | 13001069067460a721927c263ea4c18568cff504 | [
"CNRI-Python"
] | 1 | 2021-09-01T20:31:13.000Z | 2021-09-01T20:31:13.000Z | import arcpy
from arcpy import da
import file_functions
from file_functions import *
import create_station_lines
import statistics
import pandas as pd
import os
arcpy.env.overwriteOutput = True
@err_info
def clean_in_table(table, w_field='W', z_field='Z', dist_field='dist_down'):
"""Renames columns corresponding to W, Z, and dist_down, if they are not already columns"""
check_use(table)
df = pd.read_csv(table)
for old_name, replacement_name in [(w_field, 'W'), (z_field, 'Z'), (dist_field, 'dist_down')]:
if replacement_name not in df.columns.tolist():
if old_name in df.columns.tolist():
df.rename(columns={old_name: replacement_name})
logging.info('Renamed %s to %s in %s' % (old_name, replacement_name, table))
else:
logging.exception('Cannot find column named %s or %s in %s' % (old_name, replacement_name, table))
df.to_csv(table, index=False)
return df
def standardize(table, fields):
"""Makes standardized version of field in csv table by subtracting each value by mean and dividing by standard deviation.
Creates a new column Ws_Zs storing C(Ws,Zs) values"""
check_use(table)
df = pd.read_csv(table)
s_fields = []
if type(fields) == list:
for f in fields:
new_field = f + 's'
df[new_field] = (df[f] - np.mean(df[f])) * 1.0 / np.std(df[f])
s_fields.append(new_field)
df['%s_%s' % (s_fields[0], s_fields[1])] = df[s_fields[0]] * df[s_fields[1]]
df.to_csv(table, index=False)
return df
def landforms(table, zs_field='Zs', ws_field='Ws', na=-9999):
"""Classifies each row by corresponding landform type:
oversized, nozzle, constricted pool, wide bar, normal channel
Adds columns to input table"""
check_use(table)
df = pd.read_csv(table)
df['normal'] = [zs * ws if abs(zs) <= 0.5 or abs(ws) <= 0.5 else na for zs, ws in zip(df[zs_field], df[ws_field])]
df['wide_bar'] = [zs * ws if (zs > 0.5 and ws > 0.5) else na for zs, ws in
zip(df[zs_field], df[ws_field])]
df['const_pool'] = [zs * ws if (zs < -0.5 and ws < -0.5) else na for zs, ws in
zip(df[zs_field], df[ws_field])]
df['nozzle'] = [zs * ws if (zs > 0.5 and ws < -0.5) else na for zs, ws in
zip(df[zs_field], df[ws_field])]
df['oversized'] = [zs * ws if (zs < 0.5 and ws > 0.5) else na for zs, ws in
zip(df[zs_field], df[ws_field])]
df['code'] = [-2 if df['oversized'][i] != na
else -1 if df['const_pool'][i] != na
else 0 if df['normal'][i] != na
else 1 if df['wide_bar'][i] != na
else 2 if df['nozzle'][i] != na
else 0
# Was na, but since for whatever reason normal channel is not mutually exclusive, we are going to hard code this as 0
for i in range(len(df))
]
df["code"].fillna(0, inplace=True)
df.to_csv(table, index=False)
return df
def main_classify_landforms(tables, w_field, z_field, dist_field):
"""Classifies river segments as normal, wide bar, constricted pool, oversized, or nozzle
Args:
tables: a list of attribute table filenames for each set of wetted polygon rectangular XS's
w_field: name of the attribute table field corresponding to width
z_field: name of the attribute table field corresponding to detrended bed elevation
dist_field: name of the attribute table field corresponding to distance downstream
Returns:
For each input table:
a .csv containing dist_down, W, Z, Ws, Zs, Ws_Zs, and landform classification/code fields
adds these computed values to attribute tables of corresponding wetted polygon rectangular XS's
"""
logging.info('Classifying landforms...')
out_polys = []
fields = [w_field, z_field]
for i in range(len(tables)):
table = tables[i]
clean_in_table(table, w_field=w_field, z_field=z_field, dist_field=dist_field)
standardize(table, fields=fields)
landforms(table)
logging.info('Finished.')
return out_polys
# Main function that conducts GCS analysis
############################################
def extract_gcs(detrended_dem, zs, xs_lengths, spacing, clip_poly=''):
'''This function does a full GCS analysis using three specific key Zs that can include any float. Results saved
to the gcs_ready_tables, as well as plotted. Results are aligned to the existing csv to facilitate landform analysis
detrend
wetted_folder is the folder containing small increment wetted polygons
If key_zs parameter is an empty list, a range from 0 to max_stage (deafult is 20) makes gcs csvs at 1ft increments.
wetted_folder parameter (optional) allows for a specific folder containing wetted polygons to be used instead of the assumed file structure.'''
arcpy.env.overwriteOutput = True
del_files = [] # stored deletable files
out_csvs = [] # stores output gcs csv files
# Convert stage heights to list format
if type(zs) == str:
zs = string_to_list(zs, format='float')
if type(xs_lengths) == str:
xs_lengths = string_to_list(xs_lengths, format='float')
if type(spacing) == str:
try:
spacing = int(spacing)
except TypeError:
print('Error: Cross-section spacing parameter must be a integer!')
# set up directories
dem_dir = os.path.dirname(detrended_dem)
if len(dem_dir) == 0:
print('Error: Please select valid detrended DEM file')
return
lines_dir = dem_dir + '\\centerlines'
wetted_dir = dem_dir + '\\wetted_polygons'
temp_files = dem_dir + '\\temp_files'
out_dir = dem_dir + '\\gcs_tables' # Stores output GCS tables
if not os.path.exists(out_dir):
os.makedirs(out_dir)
og_dem = dem_dir + '\\las_dem.tif'
# Get units for string labeling
u, unit, spatial_ref = file_functions.get_label_units(detrended_dem)
for i, z in enumerate(zs):
z_str = float_keyz_format(z)
label = z_str + u
in_list = [wetted_dir + '\\wetted_poly_%s.shp' % label, temp_files + '\\%s_centerline_XS.shp' % label,
lines_dir + '\\%s_centerline.shp' % label]
xs_length = xs_lengths[i]
# Allows a new/updated clip file to clip all data inputs and outputs, and create new XS for the clipped centerlines
if clip_poly != '' and os.path.exists(clip_poly):
for j, file in enumerate(in_list):
no_clip_name = file.replace('.shp', '_delete.shp')
if os.path.exists(no_clip_name):
arcpy.Delete_management(no_clip_name)
try:
arcpy.Rename_management(file, no_clip_name)
del_files.append(no_clip_name)
except PermissionError:
print('Permission Error: Could not rename %s file likely because it does not exist or is open' % file)
if j != 1:
arcpy.Clip_analysis(no_clip_name, clip_poly, out_feature_class=file)
create_station_lines.create_station_lines_function(in_list[2], spacing, xs_length)
# Clip cross-sections by wetted area and create width rectangles
clipped_xs_lines = temp_files + '\\clipped_XS_lines_%s.shp' % label
arcpy.Clip_analysis(in_list[1], in_list[0], out_feature_class=clipped_xs_lines)
width_poly_loc = lines_dir + '\\width_rectangles_%s.shp' % label
arcpy.Buffer_analysis(clipped_xs_lines, width_poly_loc, float(spacing / 2), line_side='FULL', line_end_type='FLAT')
# Extract rectangle width values and create a new attribute table Width field
arcpy.AddField_management(width_poly_loc, "Width", field_type="FLOAT")
expression = ("(float(!Shape.area!)) / %d" % spacing)
arcpy.CalculateField_management(width_poly_loc, "Width", expression, "PYTHON3")
print('Width polygons for %sft stage created...' % z)
arcpy.AddField_management(width_poly_loc, field_name="loc_id", field_type="SHORT")
field_calc = "(int(!LOCATION!))"
arcpy.CalculateField_management(width_poly_loc, field="loc_id", expression=field_calc,
expression_type="PYTHON3")
# Extract the mean detrended DEM raster value from below each width rectangle and join to the shapefile
zonal_table = arcpy.sa.ZonalStatisticsAsTable(width_poly_loc, "loc_id", detrended_dem,
out_table=(temp_files + '\\stats_table_%s.dbf' % label),
statistics_type="ALL")
arcpy.JoinField_management(width_poly_loc, "loc_id", join_table=zonal_table, join_field="loc_id", fields=["MEAN"])
# If las_dem.tif is unmoved and not renamed, we can extract the MEDIAN value and use it to flip tables if necessary
zonal_table = arcpy.sa.ZonalStatisticsAsTable(width_poly_loc, "loc_id", og_dem,
out_table=(temp_files + '\\no_detrend_stats_table_%s.dbf' % label),
statistics_type="ALL")
no_sort = arcpy.JoinField_management(width_poly_loc, "loc_id", join_table=zonal_table, join_field="loc_id",
fields=["MIN"])
# Sort width polygon by location identifier
arcpy.Sort_management(no_sort, width_poly_loc.replace('.shp', '_s.shp'), [["LOCATION", "Ascending"]])
arcpy.Delete_management(no_sort)
width_poly = arcpy.Rename_management(width_poly_loc.replace('.shp', '_s.shp'), width_poly_loc)
# Create flipped dist_down index if necessary
cursor = arcpy.SearchCursor(width_poly)
elevs = []
locations = []
for row in cursor:
elevs.append(row.getValue("MIN"))
locations.append(row.getValue("LOCATION"))
arcpy.AddField_management(width_poly, 'dist_down', "LONG")
max_loc = int(max(locations))
try:
if statistics.mean(elevs[10:20]) < statistics.mean(elevs[-20:-10]):
expression = ("%d - (int(!LOCATION!))" % max_loc)
arcpy.CalculateField_management(width_poly, 'dist_down', expression, "PYTHON3")
else:
expression = "(int(!LOCATION!))"
arcpy.CalculateField_management(width_poly, 'dist_down', expression, "PYTHON3")
except IndexError:
print('Error: Cross-section series not longer than 20, cant establish which side is upstream.')
# Convert width polygon attribute table to a csv and classify landforms
csv_loc = out_dir + "\\%s_gcs_table.csv" % label
tableToCSV(width_poly, csv_filepath=csv_loc, fld_to_remove_override=[])
df = pd.read_csv(csv_loc)
df.rename({'LOCATION': 'location', 'Width': 'W', 'MEAN': 'Z', 'MIN': 'Z_no_detrend'}, axis=1, inplace=True)
df.sort_values(by=['dist_down'], inplace=True)
df = df[['location', 'dist_down', 'Z_no_detrend', 'W', 'Z']]
df.to_csv(csv_loc)
# calculate Ws, Zs, Ws_Zs, and landform codes
main_classify_landforms(tables=[csv_loc], w_field='W', z_field='Z', dist_field='dist_down')
gcs_df = pd.read_csv(csv_loc)
gcs_df.to_csv(csv_loc)
print('GCS csv file made for stage %s...' % label)
out_csvs.append(csv_loc)
for file in del_files:
file_functions.delete_gis_files(file)
print('GCS tables completed @ %s' % out_dir)
return out_csvs
def prep_locations(detrend_folder, flip=False):
'''This function takes a reach and creates a new csv with aligned location identifiers using a Thiessen Polygon methodology.
Returns aligned_locations.csv in the \\landform_analysis sub-folder. This csv can be used to align any data field for any key z or stage range.
When flip==True (false is default) locations are flipped to correctlyly link to an ALREADY FLIPPED GCS stage table. If neither table is flipped, use
the flipped table function in plotting functions file!'''
print('Creating aligned_locations.csv with aligned centerline locations / dist_down...')
detrended_raster = detrend_folder + '\\ras_detren.tif'
landform_folder = detrend_folder + '\\landform_analysis'
centerline_folder = detrend_folder + "\\analysis_centerline_and_XS"
if not os.path.exists(landform_folder):
os.makedirs(landform_folder)
arcpy.env.overwriteOutput = True
arcpy.env.extent = detrended_raster
del_files = []
centerline_nums = find_centerline_nums(detrend_folder)
spacing = find_xs_spacing(detrend_folder)
for num in centerline_nums:
line_loc = ('%s\\stage_centerline_%sft_DS.shp' % (centerline_folder, num))
station_lines = create_station_lines.create_station_lines_function(line_loc, spacing=spacing, xs_length=5, stage=[])
station_lines = centerline_folder + ('\\stage_centerline_%sft_DS_XS_%sx5ft.shp' % (num, spacing))
del_files.append(station_lines)
station_points = arcpy.Intersect_analysis([station_lines, line_loc], out_feature_class=(
centerline_folder + "\\station_points_%sft.shp" % num), join_attributes="ALL", output_type="POINT")
if num != min(centerline_nums):
theis_loc = centerline_folder + "\\thiessen_%sft.shp" % num
arcpy.CreateThiessenPolygons_analysis(station_points, theis_loc, 'ALL')
arcpy.AddField_management(theis_loc, ('loc_%sft' % num), 'SHORT')
arcpy.CalculateField_management(theis_loc, ('loc_%sft' % num), expression='!LOCATION!', expression_type='PYTHON3')
del_fields = [f.name for f in arcpy.ListFields(theis_loc)]
for field in [('loc_%sft' % num), 'FID', 'Shape']:
try:
del_fields.remove(field)
except:
"Can't delete field: %s" % field
arcpy.DeleteField_management(theis_loc, del_fields)
max_count = 0
for counter, num in enumerate(centerline_nums):
theis_loc = (centerline_folder + "\\thiessen_%sft.shp" % num)
out_points = centerline_folder + ("\\align_points%s.shp" % counter)
del_files.append(theis_loc)
del_files.append(out_points)
if counter >= max_count:
max_count = counter
if counter == 1:
arcpy.Identity_analysis(centerline_folder + "\\station_points_%sft.shp" % min(centerline_nums), theis_loc, out_feature_class=out_points, join_attributes='ALL')
elif counter > 1:
arcpy.Identity_analysis(centerline_folder + ("\\align_points%s.shp" % (int(counter - 1))), theis_loc, out_feature_class=out_points, join_attributes='ALL')
index_field = 'loc_%sft' % min(centerline_nums)
aligned_csv = landform_folder + '\\aligned_locations.csv' # Creates a csv with the aligned locations for each centerline. Allows joins to add any data to this for analysis.
aligned_df = pd.read_csv(file_functions.tableToCSV(out_points, csv_filepath=aligned_csv, fld_to_remove_override=['FID_statio', 'FID_thiess']))
aligned_df.rename(columns={'LOCATION': index_field}, inplace=True)
aligned_df.drop_duplicates(subset=[index_field], inplace=True)
headers = list(aligned_df.columns.values)
keep_headers = [i for i in headers if i[:3] == 'loc']
out_aligned_df = aligned_df.loc[:, keep_headers]
out_aligned_df.sort_values(by=[index_field], inplace=True)
out_aligned_df.set_index(index_field, inplace=True)
if flip:
loc_fields = [j for j in list(out_aligned_df.columns.values) if j[:3] == 'loc']
loc_nums = []
for loc_field in loc_fields:
if loc_field[5] == 'f':
loc_nums.append(loc_field[4])
else:
loc_nums.append(loc_field[4:6])
temp_max = np.nanmax(out_aligned_df.loc[:, loc_field].to_numpy())
dist_list = out_aligned_df.loc[:, [loc_field]].squeeze().to_list()
loc_np = np.array([int(temp_max - i) for i in dist_list])
out_aligned_df[loc_field] = loc_np
min_loc = loc_fields[loc_nums.index(min(loc_nums, key=int))]
out_aligned_df.sort_values(str(min_loc), inplace=True)
out_aligned_df.to_csv(aligned_csv)
else:
out_aligned_df.to_csv(aligned_csv)
print('Deleting files: %s' % del_files)
for file in del_files:
file_functions.delete_gis_files(file)
print('Empty aligned csv created @ %s!' % aligned_csv)
return aligned_csv
| 46.248619 | 177 | 0.647473 |
b70a73efd73cf62a7666a34cf737a0f427da5b70 | 531 | py | Python | lino/hello.py | NewRGB/lino | 43799e42107169ff173d3b8bc0324d5773471499 | [
"BSD-2-Clause"
] | 1 | 2019-11-13T19:38:50.000Z | 2019-11-13T19:38:50.000Z | lino/hello.py | khchine5/lino | 64f7ca9c9b83459b5b9f26174e5e3c26a137459d | [
"BSD-2-Clause"
] | null | null | null | lino/hello.py | khchine5/lino | 64f7ca9c9b83459b5b9f26174e5e3c26a137459d | [
"BSD-2-Clause"
] | null | null | null | """If you want to see which version of Lino you have, you can say
"hello" to Lino:
.. code-block:: bash
$ python -m lino.hello
This command just issues a text with the version number of Lino (and
its dependencies) to the console::
Lino 1.6.15, Django 1.6.7, Python 2.7.4, Babel 1.3, Jinja 2.7.2, Sphinx 1.3a0, python-dateutil 2.1, OdfPy ODFPY/0.9.6, docutils 0.11, suds 0.4, PyYaml 3.10, Appy 0.9.0 (2014/06/23 22:15).
"""
from __future__ import print_function
from lino.api.ad import Site
print(Site().using_text())
| 29.5 | 191 | 0.698682 |
89e18330fa5a4c5401573537413cc62018ce2b14 | 1,180 | py | Python | tests/test_related_version_view.py | geekflow/ahoy | 4cbcceed2d20cc162fbf54527a2cdbe9681cba17 | [
"MIT"
] | 1 | 2018-03-02T06:01:28.000Z | 2018-03-02T06:01:28.000Z | tests/test_related_version_view.py | geekflow/ahoy | 4cbcceed2d20cc162fbf54527a2cdbe9681cba17 | [
"MIT"
] | null | null | null | tests/test_related_version_view.py | geekflow/ahoy | 4cbcceed2d20cc162fbf54527a2cdbe9681cba17 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
"""
related_version_view
~~~~~~~~~
.
:copyright: (c) 2018 by geeksaga.
:license: MIT LICENSE 2.0, see license for more details.
"""
import datetime
import pytest
from ahoy.model.related_version_view import RelatedVersionView
from ahoy.model.version import Version
from ahoy.model.view import View
@pytest.fixture(scope='function')
def setup(session):
session.query(Version).delete()
session.query(View).delete()
version = Version('0.0.1', datetime.date.today(), datetime.date.today())
session.add(version)
view = View('DashBoard', 0, 1, 1)
session.add(view)
session.commit()
@pytest.mark.run(before='test_version')
def test_query_model(session, setup):
version = session.query(Version).filter_by(version='0.0.1').first()
view = session.query(View).filter_by(name='DashBoard').first()
related_version_view = RelatedVersionView(version.id, view.id)
session.add(related_version_view)
session.commit()
related_version_views = session.query(RelatedVersionView).filter_by(version_id=version.id, view_id=view.id).first()
assert related_version_views == related_version_view
| 26.222222 | 119 | 0.713559 |
13d4f2272601a952a0889ac34b673ee5c45145bb | 9,094 | py | Python | qiskit/circuit/library/basis_change/qft.py | dhruvbhq/qiskit-terra | 74a6d0d409d42a83f0be56e39274d07f56f1a6d1 | [
"Apache-2.0"
] | 1 | 2021-09-08T05:49:26.000Z | 2021-09-08T05:49:26.000Z | qiskit/circuit/library/basis_change/qft.py | dhruvbhq/qiskit-terra | 74a6d0d409d42a83f0be56e39274d07f56f1a6d1 | [
"Apache-2.0"
] | null | null | null | qiskit/circuit/library/basis_change/qft.py | dhruvbhq/qiskit-terra | 74a6d0d409d42a83f0be56e39274d07f56f1a6d1 | [
"Apache-2.0"
] | null | null | null | # This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Quantum Fourier Transform Circuit."""
from typing import Optional
import numpy as np
from qiskit.circuit import QuantumCircuit, QuantumRegister
from ..blueprintcircuit import BlueprintCircuit
class QFT(BlueprintCircuit):
r"""Quantum Fourier Transform Circuit.
The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
.. math::
|j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle
The circuit that implements this transformation can be implemented using Hadamard gates
on each qubit, a series of controlled-U1 (or Z, depending on the phase) gates and a
layer of Swap gates. The layer of Swap gates can in principle be dropped if the QFT appears
at the end of the circuit, since then the re-ordering can be done classically. They
can be turned off using the ``do_swaps`` attribute.
For 4 qubits, the circuit that implements this transformation is:
.. jupyter-execute::
:hide-code:
from qiskit.circuit.library import QFT
import qiskit.tools.jupyter
circuit = QFT(4)
%circuit_library_info circuit
The inverse QFT can be obtained by calling the ``inverse`` method on this class.
The respective circuit diagram is:
.. jupyter-execute::
:hide-code:
from qiskit.circuit.library import QFT
import qiskit.tools.jupyter
circuit = QFT(4).inverse()
%circuit_library_info circuit
One method to reduce circuit depth is to implement the QFT approximately by ignoring
controlled-phase rotations where the angle is beneath a threshold. This is discussed
in more detail in https://arxiv.org/abs/quant-ph/9601018 or
https://arxiv.org/abs/quant-ph/0403071.
Here, this can be adjusted using the ``approximation_degree`` attribute: the smallest
``approximation_degree`` rotation angles are dropped from the QFT. For instance, a QFT
on 5 qubits with approximation degree 2 yields (the barriers are dropped in this example):
.. jupyter-execute::
:hide-code:
from qiskit.circuit.library import QFT
import qiskit.tools.jupyter
circuit = QFT(5, approximation_degree=2)
%circuit_library_info circuit
"""
def __init__(
self,
num_qubits: Optional[int] = None,
approximation_degree: int = 0,
do_swaps: bool = True,
inverse: bool = False,
insert_barriers: bool = False,
name: Optional[str] = None,
) -> None:
"""Construct a new QFT circuit.
Args:
num_qubits: The number of qubits on which the QFT acts.
approximation_degree: The degree of approximation (0 for no approximation).
do_swaps: Whether to include the final swaps in the QFT.
inverse: If True, the inverse Fourier transform is constructed.
insert_barriers: If True, barriers are inserted as visualization improvement.
name: The name of the circuit.
"""
if name is None:
name = "IQFT" if inverse else "QFT"
super().__init__(name=name)
self._approximation_degree = approximation_degree
self._do_swaps = do_swaps
self._insert_barriers = insert_barriers
self._inverse = inverse
self._data = None
self.num_qubits = num_qubits
@property
def num_qubits(self) -> int:
"""The number of qubits in the QFT circuit.
Returns:
The number of qubits in the circuit.
Note:
This method needs to be overwritten to allow adding the setter for num_qubits while
still complying to pylint.
"""
return super().num_qubits
@num_qubits.setter
def num_qubits(self, num_qubits: int) -> None:
"""Set the number of qubits.
Note that this changes the registers of the circuit.
Args:
num_qubits: The new number of qubits.
"""
if num_qubits != self.num_qubits:
self._invalidate()
if num_qubits:
self.qregs = [QuantumRegister(num_qubits, name="q")]
else:
self.qregs = []
@property
def approximation_degree(self) -> int:
"""The approximation degree of the QFT.
Returns:
The currently set approximation degree.
"""
return self._approximation_degree
@approximation_degree.setter
def approximation_degree(self, approximation_degree: int) -> None:
"""Set the approximation degree of the QFT.
Args:
approximation_degree: The new approximation degree.
Raises:
ValueError: If the approximation degree is smaller than 0.
"""
if approximation_degree < 0:
raise ValueError("Approximation degree cannot be smaller than 0.")
if approximation_degree != self._approximation_degree:
self._invalidate()
self._approximation_degree = approximation_degree
@property
def insert_barriers(self) -> bool:
"""Whether barriers are inserted for better visualization or not.
Returns:
True, if barriers are inserted, False if not.
"""
return self._insert_barriers
@insert_barriers.setter
def insert_barriers(self, insert_barriers: bool) -> None:
"""Specify whether barriers are inserted for better visualization or not.
Args:
insert_barriers: If True, barriers are inserted, if False not.
"""
if insert_barriers != self._insert_barriers:
self._invalidate()
self._insert_barriers = insert_barriers
@property
def do_swaps(self) -> bool:
"""Whether the final swaps of the QFT are applied or not.
Returns:
True, if the final swaps are applied, False if not.
"""
return self._do_swaps
@do_swaps.setter
def do_swaps(self, do_swaps: bool) -> None:
"""Specify whether to do the final swaps of the QFT circuit or not.
Args:
do_swaps: If True, the final swaps are applied, if False not.
"""
if do_swaps != self._do_swaps:
self._invalidate()
self._do_swaps = do_swaps
def is_inverse(self) -> bool:
"""Whether the inverse Fourier transform is implemented.
Returns:
True, if the inverse Fourier transform is implemented, False otherwise.
"""
return self._inverse
def _invalidate(self) -> None:
"""Invalidate the current build of the circuit."""
self._data = None
def inverse(self) -> "QFT":
"""Invert this circuit.
Returns:
The inverted circuit.
"""
if self.name in ("QFT", "IQFT"):
name = "QFT" if self._inverse else "IQFT"
else:
name = self.name + "_dg"
inverted = self.copy(name=name)
super(QFT, inverted)._invalidate()
# data consists of the QFT gate only
iqft = self._data[0][0].inverse()
iqft.name = name
inverted._data = []
inverted._append(iqft, inverted.qubits, [])
inverted._inverse = not self._inverse
return inverted
def _check_configuration(self, raise_on_failure: bool = True) -> bool:
valid = True
if self.num_qubits is None:
valid = False
if raise_on_failure:
raise AttributeError("The number of qubits has not been set.")
return valid
def _build(self) -> None:
"""Construct the circuit representing the desired state vector."""
super()._build()
num_qubits = self.num_qubits
if num_qubits == 0:
return
circuit = QuantumCircuit(*self.qregs, name=self.name)
for j in reversed(range(num_qubits)):
circuit.h(j)
num_entanglements = max(0, j - max(0, self.approximation_degree - (num_qubits - j - 1)))
for k in reversed(range(j - num_entanglements, j)):
lam = np.pi / (2 ** (j - k))
circuit.cp(lam, j, k)
if self.insert_barriers:
circuit.barrier()
if self._do_swaps:
for i in range(num_qubits // 2):
circuit.swap(i, num_qubits - i - 1)
if self._inverse:
circuit._data = circuit.inverse()
wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()
self.compose(wrapped, qubits=self.qubits, inplace=True)
| 32.594982 | 100 | 0.627557 |
87aefcf51e9a5bdd81c4024390ea0e49a68865ac | 3,826 | py | Python | .devablog/lib/python3.5/site-packages/guess_language/data/models/ru.py | jhenriquetdg/devablog | 5a0e8246c0be01117aee0448bf900e5b01e1fb5d | [
"MIT"
] | 3 | 2017-11-11T23:51:24.000Z | 2020-10-23T11:27:42.000Z | .devablog/lib/python3.5/site-packages/guess_language/data/models/ru.py | jhenriquetdg/devablog | 5a0e8246c0be01117aee0448bf900e5b01e1fb5d | [
"MIT"
] | 6 | 2020-06-05T18:39:11.000Z | 2022-01-13T00:49:22.000Z | .devablog/lib/python3.5/site-packages/guess_language/data/models/ru.py | jhenriquetdg/devablog | 5a0e8246c0be01117aee0448bf900e5b01e1fb5d | [
"MIT"
] | 2 | 2018-02-15T10:10:12.000Z | 2018-06-22T19:14:06.000Z | # -*- coding: utf-8 -*-
model = {
' на': 0,
' пр': 1,
'то ': 2,
' не': 3,
'ли ': 4,
' по': 5,
'но ': 6,
' в ': 7,
'на ': 8,
'ть ': 9,
'не ': 10,
' и ': 11,
' ко': 12,
'ом ': 13,
'про': 14,
' то': 15,
'их ': 16,
' ка': 17,
'ать': 18,
'ото': 19,
' за': 20,
'ие ': 21,
'ова': 22,
'тел': 23,
'тор': 24,
' де': 25,
'ой ': 26,
'сти': 27,
' от': 28,
'ах ': 29,
'ми ': 30,
'стр': 31,
' бе': 32,
' во': 33,
' ра': 34,
'ая ': 35,
'ват': 36,
'ей ': 37,
'ет ': 38,
'же ': 39,
'иче': 40,
'ия ': 41,
'ов ': 42,
'сто': 43,
' об': 44,
'вер': 45,
'го ': 46,
'и в': 47,
'и п': 48,
'и с': 49,
'ии ': 50,
'ист': 51,
'о в': 52,
'ост': 53,
'тра': 54,
' те': 55,
'ели': 56,
'ере': 57,
'кот': 58,
'льн': 59,
'ник': 60,
'нти': 61,
'о с': 62,
'рор': 63,
'ств': 64,
'чес': 65,
' бо': 66,
' ве': 67,
' да': 68,
' ин': 69,
' но': 70,
' с ': 71,
' со': 72,
' сп': 73,
' ст': 74,
' чт': 75,
'али': 76,
'ами': 77,
'вид': 78,
'дет': 79,
'е н': 80,
'ель': 81,
'еск': 82,
'ест': 83,
'зал': 84,
'и н': 85,
'ива': 86,
'кон': 87,
'ого': 88,
'одн': 89,
'ожн': 90,
'оль': 91,
'ори': 92,
'ров': 93,
'ско': 94,
'ся ': 95,
'тер': 96,
'что': 97,
' мо': 98,
' са': 99,
' эт': 100,
'ант': 101,
'все': 102,
'ерр': 103,
'есл': 104,
'иде': 105,
'ина': 106,
'ино': 107,
'иро': 108,
'ите': 109,
'ка ': 110,
'ко ': 111,
'кол': 112,
'ком': 113,
'ла ': 114,
'ния': 115,
'о т': 116,
'оло': 117,
'ран': 118,
'ред': 119,
'сь ': 120,
'тив': 121,
'тич': 122,
'ых ': 123,
' ви': 124,
' вс': 125,
' го': 126,
' ма': 127,
' сл': 128,
'ако': 129,
'ани': 130,
'аст': 131,
'без': 132,
'дел': 133,
'е д': 134,
'е п': 135,
'ем ': 136,
'жно': 137,
'и д': 138,
'ика': 139,
'каз': 140,
'как': 141,
'ки ': 142,
'нос': 143,
'о н': 144,
'опа': 145,
'при': 146,
'рро': 147,
'ски': 148,
'ти ': 149,
'тов': 150,
'ые ': 151,
' вы': 152,
' до': 153,
' ме': 154,
' ни': 155,
' од': 156,
' ро': 157,
' св': 158,
' чи': 159,
'а н': 160,
'ает': 161,
'аза': 162,
'ате': 163,
'бес': 164,
'в п': 165,
'ва ': 166,
'е в': 167,
'е м': 168,
'е с': 169,
'ез ': 170,
'ени': 171,
'за ': 172,
'зна': 173,
'ини': 174,
'кам': 175,
'ках': 176,
'кто': 177,
'лов': 178,
'мер': 179,
'мож': 180,
'нал': 181,
'ниц': 182,
'ны ': 183,
'ным': 184,
'ора': 185,
'оро': 186,
'от ': 187,
'пор': 188,
'рав': 189,
'рес': 190,
'рис': 191,
'рос': 192,
'ска': 193,
'т н': 194,
'том': 195,
'чит': 196,
'шко': 197,
' бы': 198,
' о ': 199,
' тр': 200,
' уж': 201,
' чу': 202,
' шк': 203,
'а б': 204,
'а в': 205,
'а р': 206,
'аби': 207,
'ала': 208,
'ало': 209,
'аль': 210,
'анн': 211,
'ати': 212,
'бин': 213,
'вес': 214,
'вно': 215,
'во ': 216,
'вши': 217,
'дал': 218,
'дат': 219,
'дно': 220,
'е з': 221,
'его': 222,
'еле': 223,
'енн': 224,
'ент': 225,
'ете': 226,
'и о': 227,
'или': 228,
'ись': 229,
'ит ': 230,
'ици': 231,
'ков': 232,
'лен': 233,
'льк': 234,
'мен': 235,
'мы ': 236,
'нет': 237,
'ни ': 238,
'нны': 239,
'ног': 240,
'ной': 241,
'ном': 242,
'о п': 243,
'обн': 244,
'ове': 245,
'овн': 246,
'оры': 247,
'пер': 248,
'по ': 249,
'пра': 250,
'пре': 251,
'раз': 252,
'роп': 253,
'ры ': 254,
'се ': 255,
'сли': 256,
'сов': 257,
'тре': 258,
'тся': 259,
'уро': 260,
'цел': 261,
'чно': 262,
'ь в': 263,
'ько': 264,
'ьно': 265,
'это': 266,
'ют ': 267,
'я н': 268,
' ан': 269,
' ес': 270,
' же': 271,
' из': 272,
' кт': 273,
' ми': 274,
' мы': 275,
' пе': 276,
' се': 277,
' це': 278,
'а м': 279,
'а п': 280,
'а т': 281,
'авш': 282,
'аже': 283,
'ак ': 284,
'ал ': 285,
'але': 286,
'ане': 287,
'ачи': 288,
'ают': 289,
'бна': 290,
'бол': 291,
'бы ': 292,
'в и': 293,
'в с': 294,
'ван': 295,
'гра': 296,
'даж': 297,
'ден': 298,
'е к': 299,
}
| 12.585526 | 23 | 0.408782 |
5b8ad1b324eb38ba8cb40ca1368ddf57e5ca36a6 | 34,757 | py | Python | python/ray/util/client/worker.py | siddgoel/ray | 7f3031f451de410b71a5fcb18e04452bfa7351d6 | [
"Apache-2.0"
] | null | null | null | python/ray/util/client/worker.py | siddgoel/ray | 7f3031f451de410b71a5fcb18e04452bfa7351d6 | [
"Apache-2.0"
] | null | null | null | python/ray/util/client/worker.py | siddgoel/ray | 7f3031f451de410b71a5fcb18e04452bfa7351d6 | [
"Apache-2.0"
] | null | null | null | """This file includes the Worker class which sits on the client side.
It implements the Ray API functions that are forwarded through grpc calls
to the server.
"""
import base64
import json
import logging
import os
import threading
import time
import uuid
import warnings
from collections import defaultdict
from concurrent.futures import Future
import tempfile
from typing import Any, Callable, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
import grpc
from ray.job_config import JobConfig
import ray.cloudpickle as cloudpickle
# Use cloudpickle's version of pickle for UnpicklingError
from ray.cloudpickle.compat import pickle
import ray.core.generated.ray_client_pb2 as ray_client_pb2
import ray.core.generated.ray_client_pb2_grpc as ray_client_pb2_grpc
from ray.exceptions import GetTimeoutError
from ray.ray_constants import DEFAULT_CLIENT_RECONNECT_GRACE_PERIOD
from ray.util.client.client_pickler import (
convert_to_arg,
dumps_from_client,
loads_from_server,
)
from ray.util.client.common import (
ClientActorClass,
ClientActorHandle,
ClientActorRef,
ClientObjectRef,
ClientRemoteFunc,
ClientStub,
GRPC_OPTIONS,
GRPC_UNRECOVERABLE_ERRORS,
INT32_MAX,
OBJECT_TRANSFER_WARNING_SIZE,
)
from ray.util.client.dataclient import DataClient
from ray.util.client.logsclient import LogstreamClient
from ray.util.debug import log_once
import ray._private.utils
from ray._private.runtime_env.py_modules import upload_py_modules_if_needed
from ray._private.runtime_env.working_dir import upload_working_dir_if_needed
if TYPE_CHECKING:
from ray.actor import ActorClass
from ray.remote_function import RemoteFunction
logger = logging.getLogger(__name__)
INITIAL_TIMEOUT_SEC = 5
MAX_TIMEOUT_SEC = 30
# The max amount of time an operation can run blocking in the server. This
# allows for Ctrl-C of the client to work without explicitly cancelling server
# operations.
MAX_BLOCKING_OPERATION_TIME_S: float = 2.0
# If the total size (bytes) of all outbound messages to schedule tasks since
# the connection began exceeds this value, a warning should be raised
MESSAGE_SIZE_THRESHOLD = 10 * 2 ** 20 # 10 MB
# Links to the Ray Design Pattern doc to use in the task overhead warning
# message
DESIGN_PATTERN_FINE_GRAIN_TASKS_LINK = "https://docs.google.com/document/d/167rnnDFIVRhHhK4mznEIemOtj63IOhtIPvSYaPgI4Fg/edit#heading=h.f7ins22n6nyl" # noqa E501
DESIGN_PATTERN_LARGE_OBJECTS_LINK = "https://docs.google.com/document/d/167rnnDFIVRhHhK4mznEIemOtj63IOhtIPvSYaPgI4Fg/edit#heading=h.1afmymq455wu" # noqa E501
def backoff(timeout: int) -> int:
timeout = timeout + 5
if timeout > MAX_TIMEOUT_SEC:
timeout = MAX_TIMEOUT_SEC
return timeout
class Worker:
def __init__(
self,
conn_str: str = "",
secure: bool = False,
metadata: List[Tuple[str, str]] = None,
connection_retries: int = 3,
_credentials: Optional[grpc.ChannelCredentials] = None,
):
"""Initializes the worker side grpc client.
Args:
conn_str: The host:port connection string for the ray server.
secure: whether to use SSL secure channel or not.
metadata: additional metadata passed in the grpc request headers.
connection_retries: Number of times to attempt to reconnect to the
ray server if it doesn't respond immediately. Setting to 0 tries
at least once. For infinite retries, catch the ConnectionError
exception.
_credentials: gprc channel credentials. Default ones will be used
if None.
"""
self._client_id = make_client_id()
self.metadata = [("client_id", self._client_id)] + (
metadata if metadata else []
)
self.channel = None
self.server = None
self._conn_state = grpc.ChannelConnectivity.IDLE
self._converted: Dict[str, ClientStub] = {}
self._secure = secure or os.environ.get("RAY_USE_TLS", "0").lower() in (
"1",
"true",
)
self._conn_str = conn_str
self._connection_retries = connection_retries
if _credentials is not None:
self._credentials = _credentials
self._secure = True
else:
self._credentials = None
self._reconnect_grace_period = DEFAULT_CLIENT_RECONNECT_GRACE_PERIOD
if "RAY_CLIENT_RECONNECT_GRACE_PERIOD" in os.environ:
# Use value in environment variable if available
self._reconnect_grace_period = int(
os.environ["RAY_CLIENT_RECONNECT_GRACE_PERIOD"]
)
# Disable retries if grace period is set to 0
self._reconnect_enabled = self._reconnect_grace_period != 0
# Set to True when the connection cannot be recovered and reconnect
# attempts should be stopped
self._in_shutdown = False
# Set to True after initial connection succeeds
self._has_connected = False
self._connect_channel()
self._has_connected = True
# Has Ray been initialized on the server?
self._serverside_ray_initialized = False
# Initialize the streams to finish protocol negotiation.
self.data_client = DataClient(self, self._client_id, self.metadata)
self.reference_count: Dict[bytes, int] = defaultdict(int)
self.log_client = LogstreamClient(self, self.metadata)
self.log_client.set_logstream_level(logging.INFO)
self.closed = False
# Track this value to raise a warning if a lot of data are transferred.
self.total_outbound_message_size_bytes = 0
# Used to create unique IDs for RPCs to the RayletServicer
self._req_id_lock = threading.Lock()
self._req_id = 0
def _connect_channel(self, reconnecting=False) -> None:
"""
Attempts to connect to the server specified by conn_str. If
reconnecting after an RPC error, cleans up the old channel and
continues to attempt to connect until the grace period is over.
"""
if self.channel is not None:
self.channel.unsubscribe(self._on_channel_state_change)
self.channel.close()
if self._secure:
if self._credentials is not None:
credentials = self._credentials
elif os.environ.get("RAY_USE_TLS", "0").lower() in ("1", "true"):
(
server_cert_chain,
private_key,
ca_cert,
) = ray._private.utils.load_certs_from_env()
credentials = grpc.ssl_channel_credentials(
certificate_chain=server_cert_chain,
private_key=private_key,
root_certificates=ca_cert,
)
else:
credentials = grpc.ssl_channel_credentials()
self.channel = grpc.secure_channel(
self._conn_str, credentials, options=GRPC_OPTIONS
)
else:
self.channel = grpc.insecure_channel(self._conn_str, options=GRPC_OPTIONS)
self.channel.subscribe(self._on_channel_state_change)
# Retry the connection until the channel responds to something
# looking like a gRPC connection, though it may be a proxy.
start_time = time.time()
conn_attempts = 0
timeout = INITIAL_TIMEOUT_SEC
service_ready = False
while conn_attempts < max(self._connection_retries, 1) or reconnecting:
conn_attempts += 1
if self._in_shutdown:
# User manually closed the worker before connection finished
break
elapsed_time = time.time() - start_time
if reconnecting and elapsed_time > self._reconnect_grace_period:
self._in_shutdown = True
raise ConnectionError(
"Failed to reconnect within the reconnection grace period "
f"({self._reconnect_grace_period}s)"
)
try:
# Let gRPC wait for us to see if the channel becomes ready.
# If it throws, we couldn't connect.
grpc.channel_ready_future(self.channel).result(timeout=timeout)
# The HTTP2 channel is ready. Wrap the channel with the
# RayletDriverStub, allowing for unary requests.
self.server = ray_client_pb2_grpc.RayletDriverStub(self.channel)
service_ready = bool(self.ping_server())
if service_ready:
break
# Ray is not ready yet, wait a timeout
time.sleep(timeout)
except grpc.FutureTimeoutError:
logger.debug(f"Couldn't connect channel in {timeout} seconds, retrying")
# Note that channel_ready_future constitutes its own timeout,
# which is why we do not sleep here.
except grpc.RpcError as e:
logger.debug(
"Ray client server unavailable, " f"retrying in {timeout}s..."
)
logger.debug(f"Received when checking init: {e.details()}")
# Ray is not ready yet, wait a timeout.
time.sleep(timeout)
# Fallthrough, backoff, and retry at the top of the loop
logger.debug(
"Waiting for Ray to become ready on the server, "
f"retry in {timeout}s..."
)
if not reconnecting:
# Don't increase backoff when trying to reconnect --
# we already know the server exists, attempt to reconnect
# as soon as we can
timeout = backoff(timeout)
# If we made it through the loop without service_ready
# it means we've used up our retries and
# should error back to the user.
if not service_ready:
self._in_shutdown = True
if log_once("ray_client_security_groups"):
warnings.warn(
"Ray Client connection timed out. Ensure that "
"the Ray Client port on the head node is reachable "
"from your local machine. See https://docs.ray.io/en"
"/latest/cluster/ray-client.html#step-2-check-ports for "
"more information."
)
raise ConnectionError("ray client connection timeout")
def _can_reconnect(self, e: grpc.RpcError) -> bool:
"""
Returns True if the RPC error can be recovered from and a retry is
appropriate, false otherwise.
"""
if not self._reconnect_enabled:
return False
if self._in_shutdown:
# Channel is being shutdown, don't try to reconnect
return False
if e.code() in GRPC_UNRECOVERABLE_ERRORS:
# Unrecoverable error -- These errors are specifically raised
# by the server's application logic
return False
if e.code() == grpc.StatusCode.INTERNAL:
details = e.details()
if details == "Exception serializing request!":
# The client failed tried to send a bad request (for example,
# passing "None" instead of a valid grpc message). Don't
# try to reconnect/retry.
return False
# All other errors can be treated as recoverable
return True
def _call_stub(self, stub_name: str, *args, **kwargs) -> Any:
"""
Calls the stub specified by stub_name (Schedule, WaitObject, etc...).
If a recoverable error occurrs while calling the stub, attempts to
retry the RPC.
"""
while not self._in_shutdown:
try:
return getattr(self.server, stub_name)(*args, **kwargs)
except grpc.RpcError as e:
if self._can_reconnect(e):
time.sleep(0.5)
continue
raise
except ValueError:
# Trying to use the stub on a cancelled channel will raise
# ValueError. This should only happen when the data client
# is attempting to reset the connection -- sleep and try
# again.
time.sleep(0.5)
continue
raise ConnectionError("Client is shutting down.")
def _get_object_iterator(
self, req: ray_client_pb2.GetRequest, *args, **kwargs
) -> Any:
"""
Calls the stub for GetObject on the underlying server stub. If a
recoverable error occurs while streaming the response, attempts
to retry the get starting from the first chunk that hasn't been
received.
"""
last_seen_chunk = -1
while not self._in_shutdown:
# If we disconnect partway through, restart the get request
# at the first chunk we haven't seen
req.start_chunk_id = last_seen_chunk + 1
try:
for chunk in self.server.GetObject(req, *args, **kwargs):
if chunk.chunk_id <= last_seen_chunk:
# Ignore repeat chunks
logger.debug(
f"Received a repeated chunk {chunk.chunk_id} "
f"from request {req.req_id}."
)
continue
if last_seen_chunk + 1 != chunk.chunk_id:
raise RuntimeError(
f"Received chunk {chunk.chunk_id} when we expected "
f"{self.last_seen_chunk + 1}"
)
last_seen_chunk = chunk.chunk_id
yield chunk
if last_seen_chunk == chunk.total_chunks - 1:
# We've yielded the last chunk, exit early
return
return
except grpc.RpcError as e:
if self._can_reconnect(e):
time.sleep(0.5)
continue
raise
except ValueError:
# Trying to use the stub on a cancelled channel will raise
# ValueError. This should only happen when the data client
# is attempting to reset the connection -- sleep and try
# again.
time.sleep(0.5)
continue
raise ConnectionError("Client is shutting down.")
def _add_ids_to_metadata(self, metadata: Any):
"""
Adds a unique req_id and the current thread's identifier to the
metadata. These values are useful for preventing mutating operations
from being replayed on the server side in the event that the client
must retry a requsest.
Args:
metadata - the gRPC metadata to append the IDs to
"""
if not self._reconnect_enabled:
# IDs not needed if the reconnects are disabled
return metadata
thread_id = str(threading.get_ident())
with self._req_id_lock:
self._req_id += 1
if self._req_id > INT32_MAX:
self._req_id = 1
req_id = str(self._req_id)
return metadata + [("thread_id", thread_id), ("req_id", req_id)]
def _on_channel_state_change(self, conn_state: grpc.ChannelConnectivity):
logger.debug(f"client gRPC channel state change: {conn_state}")
self._conn_state = conn_state
def connection_info(self):
try:
data = self.data_client.ConnectionInfo()
except grpc.RpcError as e:
raise decode_exception(e)
return {
"num_clients": data.num_clients,
"python_version": data.python_version,
"ray_version": data.ray_version,
"ray_commit": data.ray_commit,
"protocol_version": data.protocol_version,
}
def register_callback(
self,
ref: ClientObjectRef,
callback: Callable[[ray_client_pb2.DataResponse], None],
) -> None:
req = ray_client_pb2.GetRequest(ids=[ref.id], asynchronous=True)
self.data_client.RegisterGetCallback(req, callback)
def get(self, vals, *, timeout: Optional[float] = None) -> Any:
if isinstance(vals, list):
if not vals:
return []
to_get = vals
elif isinstance(vals, ClientObjectRef):
to_get = [vals]
else:
raise Exception(
"Can't get something that's not a "
"list of IDs or just an ID: %s" % type(vals)
)
if timeout is None:
deadline = None
else:
deadline = time.monotonic() + timeout
while True:
if deadline:
op_timeout = min(
MAX_BLOCKING_OPERATION_TIME_S,
max(deadline - time.monotonic(), 0.001),
)
else:
op_timeout = MAX_BLOCKING_OPERATION_TIME_S
try:
res = self._get(to_get, op_timeout)
break
except GetTimeoutError:
if deadline and time.monotonic() > deadline:
raise
logger.debug("Internal retry for get {}".format(to_get))
if len(to_get) != len(res):
raise Exception(
"Mismatched number of items in request ({}) and response ({})".format(
len(to_get), len(res)
)
)
if isinstance(vals, ClientObjectRef):
res = res[0]
return res
def _get(self, ref: List[ClientObjectRef], timeout: float):
req = ray_client_pb2.GetRequest(ids=[r.id for r in ref], timeout=timeout)
data = bytearray()
try:
resp = self._get_object_iterator(req, metadata=self.metadata)
for chunk in resp:
if not chunk.valid:
try:
err = cloudpickle.loads(chunk.error)
except (pickle.UnpicklingError, TypeError):
logger.exception("Failed to deserialize {}".format(chunk.error))
raise
raise err
if chunk.total_size > OBJECT_TRANSFER_WARNING_SIZE and log_once(
"client_object_transfer_size_warning"
):
size_gb = chunk.total_size / 2 ** 30
warnings.warn(
"Ray Client is attempting to retrieve a "
f"{size_gb:.2f} GiB object over the network, which may "
"be slow. Consider serializing the object to a file "
"and using S3 or rsync instead.",
UserWarning,
stacklevel=5,
)
data.extend(chunk.data)
except grpc.RpcError as e:
raise decode_exception(e)
return loads_from_server(data)
def put(self, val, *, client_ref_id: bytes = None):
if isinstance(val, ClientObjectRef):
raise TypeError(
"Calling 'put' on an ObjectRef is not allowed "
"(similarly, returning an ObjectRef from a remote "
"function is not allowed). If you really want to "
"do this, you can wrap the ObjectRef in a list and "
"call 'put' on it (or return it)."
)
data = dumps_from_client(val, self._client_id)
return self._put_pickled(data, client_ref_id)
def _put_pickled(self, data, client_ref_id: bytes):
req = ray_client_pb2.PutRequest(data=data)
if client_ref_id is not None:
req.client_ref_id = client_ref_id
resp = self.data_client.PutObject(req)
if not resp.valid:
try:
raise cloudpickle.loads(resp.error)
except (pickle.UnpicklingError, TypeError):
logger.exception("Failed to deserialize {}".format(resp.error))
raise
return ClientObjectRef(resp.id)
# TODO(ekl) respect MAX_BLOCKING_OPERATION_TIME_S for wait too
def wait(
self,
object_refs: List[ClientObjectRef],
*,
num_returns: int = 1,
timeout: float = None,
fetch_local: bool = True,
) -> Tuple[List[ClientObjectRef], List[ClientObjectRef]]:
if not isinstance(object_refs, list):
raise TypeError(
"wait() expected a list of ClientObjectRef, " f"got {type(object_refs)}"
)
for ref in object_refs:
if not isinstance(ref, ClientObjectRef):
raise TypeError(
"wait() expected a list of ClientObjectRef, "
f"got list containing {type(ref)}"
)
data = {
"object_ids": [object_ref.id for object_ref in object_refs],
"num_returns": num_returns,
"timeout": timeout if (timeout is not None) else -1,
"client_id": self._client_id,
}
req = ray_client_pb2.WaitRequest(**data)
resp = self._call_stub("WaitObject", req, metadata=self.metadata)
if not resp.valid:
# TODO(ameer): improve error/exceptions messages.
raise Exception("Client Wait request failed. Reference invalid?")
client_ready_object_ids = [
ClientObjectRef(ref) for ref in resp.ready_object_ids
]
client_remaining_object_ids = [
ClientObjectRef(ref) for ref in resp.remaining_object_ids
]
return (client_ready_object_ids, client_remaining_object_ids)
def call_remote(self, instance, *args, **kwargs) -> List[Future]:
task = instance._prepare_client_task()
for arg in args:
pb_arg = convert_to_arg(arg, self._client_id)
task.args.append(pb_arg)
for k, v in kwargs.items():
task.kwargs[k].CopyFrom(convert_to_arg(v, self._client_id))
return self._call_schedule_for_task(task, instance._num_returns())
def _call_schedule_for_task(
self, task: ray_client_pb2.ClientTask, num_returns: int
) -> List[Future]:
logger.debug("Scheduling %s" % task)
task.client_id = self._client_id
if num_returns is None:
num_returns = 1
id_futures = [Future() for _ in range(num_returns)]
def populate_ids(resp: Union[ray_client_pb2.DataResponse, Exception]) -> None:
if isinstance(resp, Exception):
if isinstance(resp, grpc.RpcError):
resp = decode_exception(resp)
for future in id_futures:
future.set_exception(resp)
return
ticket = resp.task_ticket
if not ticket.valid:
try:
ex = cloudpickle.loads(ticket.error)
except (pickle.UnpicklingError, TypeError) as e_new:
ex = e_new
for future in id_futures:
future.set_exception(ex)
return
if len(ticket.return_ids) != num_returns:
exc = ValueError(
f"Expected {num_returns} returns but received "
f"{len(ticket.return_ids)}"
)
for future, raw_id in zip(id_futures, ticket.return_ids):
future.set_exception(exc)
return
for future, raw_id in zip(id_futures, ticket.return_ids):
future.set_result(raw_id)
self.data_client.Schedule(task, populate_ids)
self.total_outbound_message_size_bytes += task.ByteSize()
if (
self.total_outbound_message_size_bytes > MESSAGE_SIZE_THRESHOLD
and log_once("client_communication_overhead_warning")
):
warnings.warn(
"More than 10MB of messages have been created to schedule "
"tasks on the server. This can be slow on Ray Client due to "
"communication overhead over the network. If you're running "
"many fine-grained tasks, consider running them inside a "
'single remote function. See the section on "Too '
'fine-grained tasks" in the Ray Design Patterns document for '
f"more details: {DESIGN_PATTERN_FINE_GRAIN_TASKS_LINK}. If "
"your functions frequently use large objects, consider "
"storing the objects remotely with ray.put. An example of "
'this is shown in the "Closure capture of large / '
'unserializable object" section of the Ray Design Patterns '
"document, available here: "
f"{DESIGN_PATTERN_LARGE_OBJECTS_LINK}",
UserWarning,
)
return id_futures
def call_release(self, id: bytes) -> None:
if self.closed:
return
self.reference_count[id] -= 1
if self.reference_count[id] == 0:
self._release_server(id)
del self.reference_count[id]
def _release_server(self, id: bytes) -> None:
if self.data_client is not None:
logger.debug(f"Releasing {id.hex()}")
self.data_client.ReleaseObject(ray_client_pb2.ReleaseRequest(ids=[id]))
def call_retain(self, id: bytes) -> None:
logger.debug(f"Retaining {id.hex()}")
self.reference_count[id] += 1
def close(self):
self._in_shutdown = True
self.closed = True
self.data_client.close()
self.log_client.close()
self.server = None
if self.channel:
self.channel.close()
self.channel = None
def get_actor(
self, name: str, namespace: Optional[str] = None
) -> ClientActorHandle:
task = ray_client_pb2.ClientTask()
task.type = ray_client_pb2.ClientTask.NAMED_ACTOR
task.name = name
task.namespace = namespace or ""
futures = self._call_schedule_for_task(task, 1)
assert len(futures) == 1
handle = ClientActorHandle(ClientActorRef(futures[0]))
# `actor_ref.is_nil()` waits until the underlying ID is resolved.
# This is needed because `get_actor` is often used to check the
# existence of an actor.
if handle.actor_ref.is_nil():
raise ValueError(f"ActorID for {name} is empty")
return handle
def terminate_actor(self, actor: ClientActorHandle, no_restart: bool) -> None:
if not isinstance(actor, ClientActorHandle):
raise ValueError(
"ray.kill() only supported for actors. Got: {}.".format(type(actor))
)
term_actor = ray_client_pb2.TerminateRequest.ActorTerminate()
term_actor.id = actor.actor_ref.id
term_actor.no_restart = no_restart
term = ray_client_pb2.TerminateRequest(actor=term_actor)
term.client_id = self._client_id
try:
self.data_client.Terminate(term)
except grpc.RpcError as e:
raise decode_exception(e)
def terminate_task(
self, obj: ClientObjectRef, force: bool, recursive: bool
) -> None:
if not isinstance(obj, ClientObjectRef):
raise TypeError(
"ray.cancel() only supported for non-actor object refs. "
f"Got: {type(obj)}."
)
term_object = ray_client_pb2.TerminateRequest.TaskObjectTerminate()
term_object.id = obj.id
term_object.force = force
term_object.recursive = recursive
term = ray_client_pb2.TerminateRequest(task_object=term_object)
term.client_id = self._client_id
try:
self.data_client.Terminate(term)
except grpc.RpcError as e:
raise decode_exception(e)
def get_cluster_info(
self,
req_type: ray_client_pb2.ClusterInfoType.TypeEnum,
timeout: Optional[float] = None,
):
req = ray_client_pb2.ClusterInfoRequest()
req.type = req_type
resp = self.server.ClusterInfo(req, timeout=timeout, metadata=self.metadata)
if resp.WhichOneof("response_type") == "resource_table":
# translate from a proto map to a python dict
output_dict = {k: v for k, v in resp.resource_table.table.items()}
return output_dict
elif resp.WhichOneof("response_type") == "runtime_context":
return resp.runtime_context
return json.loads(resp.json)
def internal_kv_get(self, key: bytes) -> bytes:
req = ray_client_pb2.KVGetRequest(key=key)
resp = self._call_stub("KVGet", req, metadata=self.metadata)
return resp.value
def internal_kv_exists(self, key: bytes) -> bytes:
req = ray_client_pb2.KVGetRequest(key=key)
resp = self._call_stub("KVGet", req, metadata=self.metadata)
return resp.value
def internal_kv_put(self, key: bytes, value: bytes, overwrite: bool) -> bool:
req = ray_client_pb2.KVPutRequest(key=key, value=value, overwrite=overwrite)
metadata = self._add_ids_to_metadata(self.metadata)
resp = self._call_stub("KVPut", req, metadata=metadata)
return resp.already_exists
def internal_kv_del(self, key: bytes) -> None:
req = ray_client_pb2.KVDelRequest(key=key)
metadata = self._add_ids_to_metadata(self.metadata)
self._call_stub("KVDel", req, metadata=metadata)
def internal_kv_list(self, prefix: bytes) -> bytes:
req = ray_client_pb2.KVListRequest(prefix=prefix)
return self._call_stub("KVList", req, metadata=self.metadata).keys
def list_named_actors(self, all_namespaces: bool) -> List[Dict[str, str]]:
req = ray_client_pb2.ClientListNamedActorsRequest(all_namespaces=all_namespaces)
return json.loads(self.data_client.ListNamedActors(req).actors_json)
def is_initialized(self) -> bool:
if not self.is_connected() or self.server is None:
return False
if not self._serverside_ray_initialized:
# We only check that Ray is initialized on the server once to
# avoid making an RPC every time this function is called. This is
# safe to do because Ray only 'un-initializes' on the server when
# the Client connection is torn down.
self._serverside_ray_initialized = self.get_cluster_info(
ray_client_pb2.ClusterInfoType.IS_INITIALIZED
)
return self._serverside_ray_initialized
def ping_server(self, timeout=None) -> bool:
"""Simple health check.
Piggybacks the IS_INITIALIZED call to check if the server provides
an actual response.
"""
if self.server is not None:
logger.debug("Pinging server.")
result = self.get_cluster_info(
ray_client_pb2.ClusterInfoType.PING, timeout=timeout
)
return result is not None
return False
def is_connected(self) -> bool:
return not self._in_shutdown and self._has_connected
def _server_init(
self, job_config: JobConfig, ray_init_kwargs: Optional[Dict[str, Any]] = None
):
"""Initialize the server"""
if ray_init_kwargs is None:
ray_init_kwargs = {}
try:
if job_config is None:
serialized_job_config = None
else:
with tempfile.TemporaryDirectory() as tmp_dir:
runtime_env = job_config.runtime_env or {}
runtime_env = upload_py_modules_if_needed(
runtime_env, tmp_dir, logger=logger
)
runtime_env = upload_working_dir_if_needed(
runtime_env, tmp_dir, logger=logger
)
# Remove excludes, it isn't relevant after the upload step.
runtime_env.pop("excludes", None)
job_config.set_runtime_env(runtime_env, validate=True)
serialized_job_config = pickle.dumps(job_config)
response = self.data_client.Init(
ray_client_pb2.InitRequest(
job_config=serialized_job_config,
ray_init_kwargs=json.dumps(ray_init_kwargs),
reconnect_grace_period=self._reconnect_grace_period,
)
)
if not response.ok:
raise ConnectionAbortedError(
f"Initialization failure from server:\n{response.msg}"
)
except grpc.RpcError as e:
raise decode_exception(e)
def _convert_actor(self, actor: "ActorClass") -> str:
"""Register a ClientActorClass for the ActorClass and return a UUID"""
key = uuid.uuid4().hex
cls = actor.__ray_metadata__.modified_class
self._converted[key] = ClientActorClass(cls, options=actor._default_options)
return key
def _convert_function(self, func: "RemoteFunction") -> str:
"""Register a ClientRemoteFunc for the ActorClass and return a UUID"""
key = uuid.uuid4().hex
self._converted[key] = ClientRemoteFunc(
func._function, options=func._default_options
)
return key
def _get_converted(self, key: str) -> "ClientStub":
"""Given a UUID, return the converted object"""
return self._converted[key]
def _converted_key_exists(self, key: str) -> bool:
"""Check if a key UUID is present in the store of converted objects."""
return key in self._converted
def _dumps_from_client(self, val) -> bytes:
return dumps_from_client(val, self._client_id)
def make_client_id() -> str:
id = uuid.uuid4()
return id.hex
def decode_exception(e: grpc.RpcError) -> Exception:
if e.code() != grpc.StatusCode.ABORTED:
# The ABORTED status code is used by the server when an application
# error is serialized into the the exception details. If the code
# isn't ABORTED, then return the original error since there's no
# serialized error to decode.
# See server.py::return_exception_in_context for details
return ConnectionError(f"GRPC connection failed: {e}")
data = base64.standard_b64decode(e.details())
return loads_from_server(data)
| 40.794601 | 161 | 0.601893 |
0b9a0f1f11581e4e60d4fe313ff4954ca84b4674 | 5,374 | py | Python | tests/test_decorators.py | MattyO/changeless | 92ed977e96d4bd40b36a42a199bc210c320d7964 | [
"MIT"
] | 1 | 2015-02-23T05:35:58.000Z | 2015-02-23T05:35:58.000Z | tests/test_decorators.py | MattyO/changeless | 92ed977e96d4bd40b36a42a199bc210c320d7964 | [
"MIT"
] | 1 | 2021-06-10T23:18:02.000Z | 2021-06-10T23:18:02.000Z | tests/test_decorators.py | MattyO/changeless | 92ed977e96d4bd40b36a42a199bc210c320d7964 | [
"MIT"
] | null | null | null | from changeless.decorators import fancy_list, immutable_list, fancy_gen, immutable_gen
from changeless.types import ImmutableHash, ImmutableModel, FancyHash, FancyModel
import unittest
import os
import types
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
from test_helpers import load_fixtures
from django.test.simple import DjangoTestSuiteRunner
from changeless.test.myapp.models import Library, Book, Address
class TestDecorators(unittest.TestCase):
@classmethod
def setUpClass(cls):
test_runner = DjangoTestSuiteRunner(interactive=False, verbosity=1)
test_db = test_runner.setup_databases()
load_fixtures()
def test_fancy_list_returns_correct_types(self):
@fancy_list
def get_books():
return Book.objects.all()
fancy_book_list = get_books()
self.assertIsInstance(fancy_book_list, list)
self.assertEqual(len(fancy_book_list) , 3)
self.assertIsInstance(fancy_book_list[0], FancyModel)
def test_fancy_list_object_gets_attributes(self):
@fancy_list
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_list = get_cities()
self.assertEqual(fancy_book_list[0].title , "A Tale of Two Cities")
def test_immutable_list_returns_correct_types(self):
@immutable_list
def get_books():
return Book.objects.all()
immutable_book_list = get_books()
self.assertIsInstance(immutable_book_list, list)
self.assertEqual(len(immutable_book_list ) , 3)
self.assertIsInstance(immutable_book_list[0], ImmutableModel)
def test_immutable_list_object_gets_attributes(self):
@immutable_list
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
immutable_book_list = get_cities()
self.assertEqual(immutable_book_list[0].title , "A Tale of Two Cities")
def test_fancy_list_should_be_able_to_submit_depth(self):
@fancy_list(depth=1)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_list = get_cities()
self.assertEqual(fancy_book_list[0].title , "A Tale of Two Cities")
def test_fancy_list_depth_attribte_should_effect_depth(self):
@fancy_list(depth=0)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_list = get_cities()
with self.assertRaises(AttributeError):
fancy_book_list[0].readers
def test_immutable_list_should_be_able_to_submit_depth(self):
@immutable_list(depth=1)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
immutable_book_list = get_cities()
self.assertEqual(immutable_book_list[0].title , "A Tale of Two Cities")
def test_immutable_list_depth_attrubte_should_effect_depth(self):
@immutable_list(depth=0)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
immutable_book_list = get_cities()
with self.assertRaises(AttributeError):
immutable_book_list[0].readers
def test_fancy_gen_should_return_a_generator(self):
@fancy_gen
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_list = get_cities()
self.assertIsInstance(fancy_book_list, types.GeneratorType)
def test_fancy_gen_should_be_able_to_submit_depth(self):
@fancy_gen(depth=1)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_generator = get_cities()
fancy_book_list = [ book for book in fancy_book_generator ]
self.assertEqual(fancy_book_list[0].title , "A Tale of Two Cities")
def test_fancy_gen_depth_attrubte_should_effect_depth(self):
@fancy_gen(depth=0)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_generator = get_cities()
fancy_book_list = [ book for book in fancy_book_generator ]
with self.assertRaises(AttributeError):
fancy_book_list[0].readers
def test_immutable_gen_should_return_a_generator(self):
@immutable_gen
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
immutable_book_generator = get_cities()
self.assertIsInstance(immutable_book_generator, types.GeneratorType)
def test_immutable_gen_should_be_able_to_submit_depth(self):
@immutable_gen(depth=1)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_generator = get_cities()
fancy_book_list = [ book for book in fancy_book_generator ]
self.assertEqual(fancy_book_list[0].title , "A Tale of Two Cities")
def test_immutable_gen_depth_attrubte_should_effect_depth(self):
@immutable_gen(depth=0)
def get_cities():
return Book.objects.filter(title="A Tale of Two Cities")
fancy_book_generator = get_cities()
fancy_book_list = [ book for book in fancy_book_generator ]
with self.assertRaises(AttributeError):
fancy_book_list[0].readers
| 32.969325 | 87 | 0.692222 |
8d7af73eebe7817f2c2285288404dec41fd6a8b4 | 2,411 | py | Python | vip.py | Gejfish/MOnika | eecc54783187ccc224ba02d0c6d5624efa241146 | [
"MIT"
] | null | null | null | vip.py | Gejfish/MOnika | eecc54783187ccc224ba02d0c6d5624efa241146 | [
"MIT"
] | null | null | null | vip.py | Gejfish/MOnika | eecc54783187ccc224ba02d0c6d5624efa241146 | [
"MIT"
] | null | null | null | from discord.ext import commands
import discord
import cogs
import random
import asyncio
import requests
from discord import File
import os
from datetime import datetime
import traceback
import tabula
import json
bot = commands.Bot(command_prefix='$')
class VipCog(commands.Cog):
def __init__(self, bot):
self.bot = bot
@commands.command()
async def chujwdupekuczkowiexe(self, ctx):
try:
with open("planlekcji.json", "r") as f:
pl = json.load(f)
dzien = datetime.today().strftime('%A')
if dzien == "Monday":
embed=discord.Embed(title="plan lekcji Poniedzialek",description=str(pl["Monday"]), color=0xE657EE)
embed.add_field(value=str(pl["Tuesday"]), name="Wtorek",inline=False)
await ctx.send(embed=embed)
if dzien == "Tuesday":
embed=discord.Embed(title="Plan lekcji Wtorek", description=str(pl["Tuesday"]), color=0xE657EE)
embed.add_field(value=str(pl["Wednesday"]), name="Sroda",inline=False)
await ctx.send(embed=embed)
if dzien == "Wednesday":
embed=discord.Embed(title="Plan lekcji Sroda", description=str(pl["Wednesday"]), color=0xE657EE)
embed.add_field(value=str(pl["Thursday"]), name="Czwartek",inline=False)
await ctx.send(embed=embed)
if dzien == "Thursday":
embed=discord.Embed(title="Plan lekcji Czwartek", description=str(pl["Thursday"]), color=0xE657EE)
embed.add_field(value=str(pl["Friday"]), name="Piatek",inline=False)
await ctx.send(embed=embed)
if dzien == "Friday":
embed=discord.Embed(title="Plan lekcji Piatek", description=str(pl["Friday"]), color=0xE657EE)
embed.add_field(value=str(pl["Monday"]), name="Poniedzialek",inline=False)
await ctx.send(embed=embed)
except:
await ctx.send(traceback.format_exc())
@commands.command()
async def chujciwdupkekurwo(self, ctx, *, arg):
try:
await ctx.send(arg, tts=True)
except:
await ctx.send(f"```python\n{traceback.format_exc()}```")
def setup(bot):
bot.add_cog(VipCog(bot))
print('Vip Gotowe') | 37.092308 | 116 | 0.582746 |
59fea5eb5cb73898076c95e04acb9cff01165288 | 154 | py | Python | latex2minizinc/GenObj.py | rafaellc28/Latex2MiniZinc | 5c255a712156b915469329a07d13f1e984cbd247 | [
"MIT"
] | null | null | null | latex2minizinc/GenObj.py | rafaellc28/Latex2MiniZinc | 5c255a712156b915469329a07d13f1e984cbd247 | [
"MIT"
] | null | null | null | latex2minizinc/GenObj.py | rafaellc28/Latex2MiniZinc | 5c255a712156b915469329a07d13f1e984cbd247 | [
"MIT"
] | null | null | null | class GenObj(object):
def __init__(self, name):
self.name = name
def getName(self):
return self.name
def setName(self, name):
self.name = name
| 15.4 | 26 | 0.688312 |
7458ff611da79c1217efae99f96c798600e4c163 | 635 | py | Python | lib/wwmgr/test_work_managers/test_threads.py | poharrison/westpa | 8618ab598f9bb38a7bc1479932f5332b137dfcbc | [
"MIT"
] | 140 | 2015-01-07T23:30:36.000Z | 2022-03-28T17:15:30.000Z | lib/wwmgr/test_work_managers/test_threads.py | burntyellow/westpa | 9dc62478fcef0001b9c038cd56a40b6be1b9d64a | [
"MIT"
] | 157 | 2015-01-03T03:38:36.000Z | 2022-03-31T14:12:16.000Z | lib/wwmgr/test_work_managers/test_threads.py | burntyellow/westpa | 9dc62478fcef0001b9c038cd56a40b6be1b9d64a | [
"MIT"
] | 56 | 2015-01-02T21:21:40.000Z | 2022-03-03T16:27:54.000Z |
from work_managers.threads import ThreadsWorkManager
from .tsupport import *
import nose.tools
from nose.tools import raises
class TestThreadsWorkManager(CommonWorkManagerTests,CommonParallelTests):
def setUp(self):
self.work_manager = ThreadsWorkManager()
self.work_manager.startup()
def tearDown(self):
self.work_manager.shutdown()
class TestThreadsWorkManagerAux:
def test_shutdown(self):
work_manager = ThreadsWorkManager()
work_manager.startup()
work_manager.shutdown()
for worker in work_manager.workers:
assert not worker.is_alive()
| 26.458333 | 73 | 0.714961 |
d83f27e1f90ded6a6e175823d429968a872a8d66 | 2,110 | py | Python | api/client/test/test_dataset_service_api.py | Zachary-Fernandes/mlx | d5117c5585b969ca0de5f321d14b5a27cd468280 | [
"Apache-2.0"
] | null | null | null | api/client/test/test_dataset_service_api.py | Zachary-Fernandes/mlx | d5117c5585b969ca0de5f321d14b5a27cd468280 | [
"Apache-2.0"
] | null | null | null | api/client/test/test_dataset_service_api.py | Zachary-Fernandes/mlx | d5117c5585b969ca0de5f321d14b5a27cd468280 | [
"Apache-2.0"
] | null | null | null | # Copyright 2021 The MLX Contributors
#
# SPDX-License-Identifier: Apache-2.0
# coding: utf-8
"""
MLX API
MLX API Extension for Kubeflow Pipelines # noqa: E501
OpenAPI spec version: 0.1.29-filter-categories
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import unittest
import swagger_client
from swagger_client.api.dataset_service_api import DatasetServiceApi # noqa: E501
from swagger_client.rest import ApiException
class TestDatasetServiceApi(unittest.TestCase):
"""DatasetServiceApi unit test stubs"""
def setUp(self):
self.api = swagger_client.api.dataset_service_api.DatasetServiceApi() # noqa: E501
def tearDown(self):
pass
def test_approve_datasets_for_publishing(self):
"""Test case for approve_datasets_for_publishing
"""
pass
def test_create_dataset(self):
"""Test case for create_dataset
"""
pass
def test_delete_dataset(self):
"""Test case for delete_dataset
"""
pass
def test_download_dataset_files(self):
"""Test case for download_dataset_files
Returns the dataset artifacts compressed into a .tgz (.tar.gz) file. # noqa: E501
"""
pass
def test_generate_dataset_code(self):
"""Test case for generate_dataset_code
"""
pass
def test_get_dataset(self):
"""Test case for get_dataset
"""
pass
def test_get_dataset_template(self):
"""Test case for get_dataset_template
"""
pass
def test_list_datasets(self):
"""Test case for list_datasets
"""
pass
def test_set_featured_datasets(self):
"""Test case for set_featured_datasets
"""
pass
def test_upload_dataset(self):
"""Test case for upload_dataset
"""
pass
def test_upload_dataset_file(self):
"""Test case for upload_dataset_file
"""
pass
if __name__ == '__main__':
unittest.main()
| 20.095238 | 91 | 0.638863 |
008a30969be5b227b1225f03be3f525c648e5712 | 5,123 | py | Python | test/test_estg3b.py | Uberspace/libestg3b | 3f544002c655aa70521069bdf1b1e141fb38bd87 | [
"MIT"
] | 5 | 2018-11-05T12:46:49.000Z | 2020-01-06T03:11:10.000Z | test/test_estg3b.py | Uberspace/libestg3b | 3f544002c655aa70521069bdf1b1e141fb38bd87 | [
"MIT"
] | 21 | 2018-09-18T10:27:14.000Z | 2018-09-22T18:54:38.000Z | test/test_estg3b.py | Uberspace/libestg3b | 3f544002c655aa70521069bdf1b1e141fb38bd87 | [
"MIT"
] | null | null | null | import datetime as DT
import itertools
from decimal import Decimal
import pytest
from libestg3b import EStG3b, EStG3bBase, EStG3bs, Match
from libestg3b.rule import Rule, RuleGroup
def _rules(e, *slugs):
found = set()
slugs = set(slugs)
for rule in itertools.chain.from_iterable(e._groups):
if rule._slug in slugs:
found.add(rule)
slugs.remove(rule._slug)
if slugs:
raise LookupError('Could not find ' + ' '.join(slugs))
return found
def test_estg3b_invalid_country():
with pytest.raises(Exception):
EStG3b('MENOEXISTING')
def test_estg3b():
assert issubclass(EStG3b('DE'), EStG3bBase)
def test_estg3bs():
es = EStG3bs()
assert len(es) == 1
langs = [e.aliases[0] for e in es]
assert 'GERMANY' in langs
def test_estg3bbase_list_minutes():
e = EStG3b('DE')()
minutes = e._list_minutes(DT.datetime(2018, 10, 1, 5, 10, 13), DT.datetime(2018, 10, 1, 9, 10))
minutes = list(minutes)
assert len(minutes) == 4*60
assert minutes[0] == DT.datetime(2018, 10, 1, 5, 10)
assert minutes[-1] == DT.datetime(2018, 10, 1, 9, 9)
def test_estg3bbase_list_minutes_wrong_order():
e = EStG3b('DE')()
with pytest.raises(Exception):
list(e._list_minutes(DT.datetime(2018, 10, 1), DT.datetime(2018, 9, 1)))
def test_estg3bbase_calculate_shift():
e = EStG3b('DE')()
match = e.calculate_shift([DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6)])
assert isinstance(match, list)
assert len(match) == 1
assert match[0] == Match(DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6), _rules(e, 'DE_NIGHT'))
def test_estg3bbase_calculate_shift_multimatch():
e = EStG3b('DE')()
match = e.calculate_shift([DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 7)])
assert isinstance(match, list)
assert len(match) == 2
assert match[0] == Match(DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6), _rules(e, 'DE_NIGHT'))
assert match[1] == Match(DT.datetime(2018, 2, 1, 6), DT.datetime(2018, 2, 1, 7), set())
def test_estg3bbase_calculate_shift_nomatch():
e = EStG3b('DE')()
match = e.calculate_shift([DT.datetime(2018, 2, 1, 8), DT.datetime(2018, 2, 1, 9)])
assert isinstance(match, list)
assert len(match) == 1
assert match[0] == Match(DT.datetime(2018, 2, 1, 8), DT.datetime(2018, 2, 1, 9), set())
def test_estg3bbase_calculate_shift_sunday_plus_night():
e = EStG3b('DE')()
match = e.calculate_shift([DT.datetime(2018, 9, 16, 20), DT.datetime(2018, 9, 16, 22)])
assert isinstance(match, list)
assert len(match) == 1
assert match[0] == Match(DT.datetime(2018, 9, 16, 20), DT.datetime(2018, 9, 16, 22), _rules(e, 'DE_NIGHT', 'DE_SUNDAY'))
def test_estg3bbase_calculate_shifts():
e = EStG3b('DE')()
matches = e.calculate_shifts([
[DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6)],
[DT.datetime(2018, 2, 3, 2), DT.datetime(2018, 2, 3, 7)],
])
assert len(matches) == 3
assert matches[0] == Match(DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6), _rules(e, 'DE_NIGHT'))
assert matches[1] == Match(DT.datetime(2018, 2, 3, 2), DT.datetime(2018, 2, 3, 6), _rules(e, 'DE_NIGHT'))
assert matches[2] == Match(DT.datetime(2018, 2, 3, 6), DT.datetime(2018, 2, 3, 7), set())
def test_estg3bbase_calculate_shifts_overlapping():
e = EStG3b('DE')()
matches = e.calculate_shifts([
[DT.datetime(2018, 2, 1, 2), DT.datetime(2018, 2, 1, 6)],
[DT.datetime(2018, 2, 3, 2), DT.datetime(2018, 2, 3, 7)],
[DT.datetime(2018, 2, 1, 1), DT.datetime(2018, 2, 1, 2)],
])
# <Match 2018-02-03T02:00:00~2018-02-03T07:00:00, None, add=0, multiply=0>
# <Match 2018-02-03T06:00:00~2018-02-03T07:00:00, None, add=0, multiply=0>
assert len(matches) == 3
assert matches[0] == Match(DT.datetime(2018, 2, 1, 1), DT.datetime(2018, 2, 1, 6), _rules(e, 'DE_NIGHT'))
assert matches[1] == Match(DT.datetime(2018, 2, 3, 2), DT.datetime(2018, 2, 3, 6), _rules(e, 'DE_NIGHT'))
assert matches[2] == Match(DT.datetime(2018, 2, 3, 6), DT.datetime(2018, 2, 3, 7), set())
def test_estg3bbase_add_rules():
e = EStG3b('DE')(
add_rules=[
RuleGroup('SSPECIAL_GRP1', 'One very special group', rules=[]),
RuleGroup('SSPECIAL_GRP2', 'Two very special group', rules=[]),
]
)
assert 'SSPECIAL_GRP1' in (g._slug for g in e._groups)
assert 'SSPECIAL_GRP2' in (g._slug for g in e._groups)
def test_estg3bbase_add_rules_extend():
e = EStG3b('DE')(
add_rules=[
RuleGroup('GRP_DE_NIGHT', '', rules=[
Rule('SPECIAL', 'Special', lambda m: True, multiply=Decimal("1")),
]),
]
)
group = dict((g._slug, g) for g in e._groups)['GRP_DE_NIGHT']
assert 'SPECIAL' in group
def test_estg3bbase_replace_rules():
e = EStG3b('DE')(
replace_rules=[
RuleGroup('SSPECIAL_GRP', 'One very special group', rules=[]),
]
)
assert len(e._groups) == 1
assert e._groups[0]._slug == 'SSPECIAL_GRP'
| 33.051613 | 124 | 0.62034 |
30536a359589e6443102b04b01d531d8f97791ac | 756 | py | Python | loadLastTrailNumber.py | xlei45/tool_for_experiment_analysis | f1e5ece4caa7c9dd73f7e37001533b6be234501c | [
"Apache-2.0"
] | null | null | null | loadLastTrailNumber.py | xlei45/tool_for_experiment_analysis | f1e5ece4caa7c9dd73f7e37001533b6be234501c | [
"Apache-2.0"
] | null | null | null | loadLastTrailNumber.py | xlei45/tool_for_experiment_analysis | f1e5ece4caa7c9dd73f7e37001533b6be234501c | [
"Apache-2.0"
] | null | null | null | import os.path
from os import path
def lastTrailNumber():
trialNumber = None
if(path.exists('resources/lastTrialNumber.txt')):
with open('resources/lastTrialNumber.txt','r') as file:
trialNumber = file.readline()
if len(trialNumber) == 0:
with open('resources/lastTrialNumber.txt','w+') as file:
trialNumber = 1
file.write(str(trialNumber))
elif int(trialNumber) < 0:
# TODO: exception for trial number < 0
pass
else:
with open('resources/lastTrialNumber.txt','w+') as file:
trialNumber = 1
file.write(str(trialNumber))
return trialNumber | 36 | 74 | 0.539683 |
3232dd778e378dfab9da3444a7f817d583a0136e | 22,411 | py | Python | gpytorch/settings.py | vr308/gpytorch | 1b75edb6d3664222bb3760a968b6bbf97565e39c | [
"MIT"
] | null | null | null | gpytorch/settings.py | vr308/gpytorch | 1b75edb6d3664222bb3760a968b6bbf97565e39c | [
"MIT"
] | 1 | 2021-07-27T21:23:28.000Z | 2021-07-31T20:04:58.000Z | gpytorch/settings.py | vr308/gpytorch | 1b75edb6d3664222bb3760a968b6bbf97565e39c | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
import logging
import warnings
import torch
class _feature_flag:
r"""Base class for feature flag settings with global scope.
The default is set via the `_default` class attribute.
"""
_default = False
_state = None
@classmethod
def is_default(cls):
return cls._state is None
@classmethod
def on(cls):
if cls.is_default():
return cls._default
return cls._state
@classmethod
def off(cls):
return not cls.on()
@classmethod
def _set_state(cls, state):
cls._state = state
def __init__(self, state=True):
self.prev = self.__class__._state
self.state = state
def __enter__(self):
self.__class__._set_state(self.state)
def __exit__(self, *args):
self.__class__._set_state(self.prev)
return False
class _value_context:
_global_value = None
@classmethod
def value(cls):
return cls._global_value
@classmethod
def _set_value(cls, value):
cls._global_value = value
def __init__(self, value):
self._orig_value = self.__class__.value()
self._instance_value = value
def __enter__(self,):
self.__class__._set_value(self._instance_value)
def __exit__(self, *args):
self.__class__._set_value(self._orig_value)
return False
class _dtype_value_context:
_global_float_value = None
_global_double_value = None
_global_half_value = None
@classmethod
def value(cls, dtype):
if torch.is_tensor(dtype):
dtype = dtype.dtype
if dtype == torch.float:
return cls._global_float_value
elif dtype == torch.double:
return cls._global_double_value
elif dtype == torch.half:
return cls._global_half_value
else:
raise RuntimeError(f"Unsupported dtype for {cls.__name__}.")
@classmethod
def _set_value(cls, float_value, double_value, half_value):
if float_value is not None:
cls._global_float_value = float_value
if double_value is not None:
cls._global_double_value = double_value
if half_value is not None:
cls._global_half_value = half_value
def __init__(self, float=None, double=None, half=None):
self._orig_float_value = self.__class__.value()
self._instance_float_value = float
self._orig_double_value = self.__class__.value()
self._instance_double_value = double
self._orig_half_value = self.__class__.value()
self._instance_half_value = half
def __enter__(self,):
self.__class__._set_value(
self._instance_float_value, self._instance_double_value, self._instance_half_value,
)
def __exit__(self, *args):
self.__class__._set_value(self._orig_float_value, self._orig_double_value, self._orig_half_value)
return False
class _fast_covar_root_decomposition(_feature_flag):
r"""
This feature flag controls how matrix root decompositions (:math:`K = L L^\top`) are computed
(e.g. for sampling, computing caches, etc.).
If set to True, covariance matrices :math:`K` are decomposed with low-rank approximations :math:`L L^\top`,
(:math:`L \in \mathbb R^{n \times k}`) using the Lanczos algorithm.
This is faster for large matrices and exploits structure in the covariance matrix if applicable.
If set to False, covariance matrices :math:`K` are decomposed using the Cholesky decomposition.
.. warning ::
Setting this to False will compute a complete Cholesky decomposition of covariance matrices.
This may be infeasible for GPs with structure covariance matrices.
See also: :class:`gpytorch.settings.max_root_decomposition_size` (to control the
size of the low rank decomposition used).
"""
_default = True
class _fast_log_prob(_feature_flag):
r"""
This feature flag controls how to compute the marginal log likelihood of exact GPs
and the log probability of multivariate normal distributions.
If set to True, log_prob is computed using a modified conjugate gradients algorithm (as
described in `GPyTorch: Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration`_.
This is a stochastic computation, but it is much faster for large matrices
and exploits structure in the covariance matrix if applicable.
If set to False, `log_prob` is computed using the Cholesky decomposition.
.. warning ::
Setting this to False will compute a complete Cholesky decomposition of covariance matrices.
This may be infeasible for GPs with structure covariance matrices.
See also: :class:`gpytorch.settings.num_trace_samples` (to control the
stochasticity of the fast `log_prob` estimates).
.. _GPyTorch: Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration:
https://arxiv.org/pdf/1809.11165.pdf
"""
_default = True
class _fast_solves(_feature_flag):
r"""
This feature flag controls how to compute solves with positive definite matrices.
If set to True, solves are computed using preconditioned conjugate gradients.
If set to False, `log_prob` is computed using the Cholesky decomposition.
.. warning ::
Setting this to False will compute a complete Cholesky decomposition of covariance matrices.
This may be infeasible for GPs with structure covariance matrices.
"""
_default = True
class skip_posterior_variances(_feature_flag):
"""
Whether or not to skip the posterior covariance matrix when doing an ExactGP
forward pass. If this is on, the returned gpytorch MultivariateNormal will have a
ZeroLazyTensor as its covariance matrix. This allows gpytorch to not compute
the covariance matrix when it is not needed, speeding up computations.
(Default: False)
"""
_default = False
class detach_test_caches(_feature_flag):
"""
Whether or not to detach caches computed for making predictions. In most cases, you will want this,
as this will speed up derivative computations of the predictions with respect to test inputs. However,
if you also need derivatives with respect to training inputs (e.g., because you have fantasy observations),
then you must disable this.
(Default: True)
"""
_default = True
class deterministic_probes(_feature_flag):
"""
Whether or not to resample probe vectors every iteration of training. If True, we use the same set of probe vectors
for computing log determinants each iteration. This introduces small amounts of bias in to the MLL, but allows us
to compute a deterministic estimate of it which makes optimizers like L-BFGS more viable choices.
NOTE: Currently, probe vectors are cached in a global scope. Therefore, this setting cannot be used
if multiple independent GP models are being trained in the same context (i.e., it works fine with a single GP model)
(Default: False)
"""
probe_vectors = None
@classmethod
def _set_state(cls, state):
super()._set_state(state)
cls.probe_vectors = None
class debug(_feature_flag):
"""
Whether or not to perform "safety" checks on the supplied data.
(For example, that the correct training data is supplied in Exact GP training mode)
Pros: fewer data checks, fewer warning messages
Cons: possibility of supplying incorrect data, model accidentially in wrong mode
(Default: True)
"""
_default = True
class fast_pred_var(_feature_flag):
"""
Fast predictive variances using Lanczos Variance Estimates (LOVE)
Use this for improved performance when computing predictive variances.
As described in the paper:
`Constant-Time Predictive Distributions for Gaussian Processes`_.
See also: :class:`gpytorch.settings.max_root_decomposition_size` (to control the
size of the low rank decomposition used for variance estimates).
(Default: False)
.. _`Constant-Time Predictive Distributions for Gaussian Processes`:
https://arxiv.org/pdf/1803.06058.pdf
"""
_num_probe_vectors = 1
@classmethod
def num_probe_vectors(cls):
return cls._num_probe_vectors
@classmethod
def _set_num_probe_vectors(cls, value):
cls._num_probe_vectors = value
def __init__(self, state=True, num_probe_vectors=1):
self.orig_value = self.__class__.num_probe_vectors()
self.value = num_probe_vectors
super().__init__(state)
def __enter__(self):
self.__class__._set_num_probe_vectors(self.value)
super().__enter__()
def __exit__(self, *args):
self.__class__._set_num_probe_vectors(self.orig_value)
return super().__exit__()
class fast_pred_samples(_feature_flag):
"""
Fast predictive samples using Lanczos Variance Estimates (LOVE).
Use this for improved performance when sampling from a predictive posterior matrix.
As described in the paper:
`Constant-Time Predictive Distributions for Gaussian Processes`_.
See also: :class:`gpytorch.settings.max_root_decomposition_size` (to control the
size of the low rank decomposition used for samples).
(Default: False)
.. _`Constant-Time Predictive Distributions for Gaussian Processes`:
https://arxiv.org/pdf/1803.06058.pdf
"""
_default = False
class fast_computations:
r"""
This feature flag controls whether or not to use fast approximations to various mathematical
functions used in GP inference.
The functions that can be controlled are:
* :attr:`covar_root_decomposition`
This feature flag controls how matrix root decompositions
(:math:`K = L L^\top`) are computed (e.g. for sampling, computing caches, etc.).
* If set to True,
covariance matrices :math:`K` are decomposed with low-rank approximations :math:`L L^\top`,
(:math:`L \in \mathbb R^{n \times k}`) using the Lanczos algorithm.
This is faster for large matrices and exploits structure in the covariance matrix if applicable.
* If set to False,
covariance matrices :math:`K` are decomposed using the Cholesky decomposition.
* :attr:`log_prob`
This feature flag controls how GPyTorch computes the marginal log likelihood for exact GPs
and `log_prob` for multivariate normal distributions
* If set to True,
`log_prob` is computed using a modified conjugate gradients algorithm (as
described in `GPyTorch Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration`_.
This is a stochastic computation, but it is much faster for large matrices
and exploits structure in the covariance matrix if applicable.
* If set to False,
`log_prob` is computed using the Cholesky decomposition.
* :attr:`fast_solves`
This feature flag controls how GPyTorch computes the solves of positive-definite matrices.
* If set to True,
Solves are computed with preconditioned conjugate gradients.
* If set to False,
Solves are computed using the Cholesky decomposition.
.. warning ::
Setting this to False will compute a complete Cholesky decomposition of covariance matrices.
This may be infeasible for GPs with structure covariance matrices.
By default, approximations are used for all of these functions (except for solves).
Setting any of them to False will use exact computations instead.
See also:
* :class:`gpytorch.settings.max_root_decomposition_size`
(to control the size of the low rank decomposition used)
* :class:`gpytorch.settings.num_trace_samples`
(to control the stochasticity of the fast `log_prob` estimates)
.. _GPyTorch Blackbox Matrix-Matrix Gaussian Process Inference with GPU Acceleration:
https://arxiv.org/pdf/1809.11165.pdf
"""
covar_root_decomposition = _fast_covar_root_decomposition
log_prob = _fast_log_prob
solves = _fast_solves
def __init__(self, covar_root_decomposition=True, log_prob=True, solves=True):
self.covar_root_decomposition = _fast_covar_root_decomposition(covar_root_decomposition)
self.log_prob = _fast_log_prob(log_prob)
self.solves = _fast_solves(solves)
def __enter__(self):
self.covar_root_decomposition.__enter__()
self.log_prob.__enter__()
self.solves.__enter__()
def __exit__(self, *args):
self.covar_root_decomposition.__exit__()
self.log_prob.__exit__()
self.solves.__exit__()
return False
class lazily_evaluate_kernels(_feature_flag):
"""
Lazily compute the entries of covariance matrices (set to True by default).
This can result in memory and speed savings - if say cross covariance terms are not needed
or if you only need to compute variances (not covariances).
If set to False, gpytorch will always compute the entire covariance matrix between
training and test data.
(Default: True)
"""
_default = True
class max_eager_kernel_size(_value_context):
"""
If the joint train/test covariance matrix is less than this size, then we will avoid as
much lazy evaluation of the kernel as possible.
(Default: 512)
"""
_global_value = 512
class max_cg_iterations(_value_context):
"""
The maximum number of conjugate gradient iterations to perform (when computing
matrix solves). A higher value rarely results in more accurate solves -- instead, lower the CG tolerance.
(Default: 1000)
"""
_global_value = 1000
class min_variance(_dtype_value_context):
"""
The minimum variance that can be returned from :obj:`~gpytorch.distributions.MultivariateNormal#variance`.
If variances are smaller than this, they are rounded up and a warning is raised.
- Default for `float`: 1e-6
- Default for `double`: 1e-10
- Default for `half`: 1e-3
"""
_global_float_value = 1e-6
_global_double_value = 1e-10
_global_half_value = 1e-3
class cholesky_jitter(_dtype_value_context):
"""
The jitter value passed to `psd_safe_cholesky` when using cholesky solves.
- Default for `float`: 1e-6
- Default for `double`: 1e-8
"""
_global_float_value = 1e-6
_global_double_value = 1e-8
@classmethod
def value(cls, dtype=None):
if dtype is None:
# Deprecated in 1.4: remove in 1.5
warnings.warn(
"cholesky_jitter is now a _dtype_value_context and should be called with a dtype argument",
DeprecationWarning,
)
return cls._global_float_value
return super().value(dtype=dtype)
class cg_tolerance(_value_context):
"""
Relative residual tolerance to use for terminating CG.
(Default: 1)
"""
_global_value = 1
class ciq_samples(_feature_flag):
"""
Whether to draw samples using Contour Integral Quadrature or not.
This may be slower than standard sampling methods for `N < 5000`.
However, it should be faster with larger matrices.
As described in the paper:
`Fast Matrix Square Roots with Applications to Gaussian Processes and Bayesian Optimization`_.
(Default: False)
.. _`Fast Matrix Square Roots with Applications to Gaussian Processes and Bayesian Optimization`:
https://arxiv.org/abs/2006.11267
"""
_default = False
class preconditioner_tolerance(_value_context):
"""
Diagonal trace tolerance to use for checking preconditioner convergence.
(Default: 1e-3)
"""
_global_value = 1e-3
class eval_cg_tolerance(_value_context):
"""
Relative residual tolerance to use for terminating CG when making predictions.
(Default: 1e-2)
"""
_global_value = 0.01
class _use_eval_tolerance(_feature_flag):
_default = False
class max_cholesky_size(_value_context):
"""
If the size of of a LazyTensor is less than `max_cholesky_size`,
then `root_decomposition` and `inv_matmul` of LazyTensor will use Cholesky rather than Lanczos/CG.
(Default: 800)
"""
_global_value = 800
class max_root_decomposition_size(_value_context):
"""
The maximum number of Lanczos iterations to perform
This is used when 1) computing variance estiamtes 2) when drawing from MVNs,
or 3) for kernel multiplication
More values results in higher accuracy
(Default: 100)
"""
_global_value = 100
class max_preconditioner_size(_value_context):
"""
The maximum size of preconditioner to use. 0 corresponds to turning
preconditioning off. When enabled, usually a value of around ~10 works fairly well.
(Default: 15)
"""
_global_value = 15
class max_lanczos_quadrature_iterations(_value_context):
r"""
The maximum number of Lanczos iterations to perform when doing stochastic
Lanczos quadrature. This is ONLY used for log determinant calculations and
computing Tr(K^{-1}dK/d\theta)
(Default: 20)
"""
_global_value = 20
class memory_efficient(_feature_flag):
"""
Whether or not to use Toeplitz math with gridded data, grid inducing point modules
Pros: memory efficient, faster on CPU
Cons: slower on GPUs with < 10000 inducing points
(Default: False)
"""
_default = False
class min_preconditioning_size(_value_context):
"""
If the size of of a LazyTensor is less than `min_preconditioning_size`,
then we won't use pivoted Cholesky based preconditioning.
(Default: 2000)
"""
_global_value = 2000
class minres_tolerance(_value_context):
"""
Relative update term tolerance to use for terminating MINRES.
(Default: 1e-4)
"""
_global_value = 1e-4
class num_contour_quadrature(_value_context):
"""
The number of quadrature points to compute CIQ.
(Default: 15)
"""
_global_value = 15
class num_likelihood_samples(_value_context):
"""
The number of samples to draw from a latent GP when computing a likelihood
This is used in variational inference and training
(Default: 10)
"""
_global_value = 10
class num_gauss_hermite_locs(_value_context):
"""
The number of samples to draw from a latent GP when computing a likelihood
This is used in variational inference and training
(Default: 20)
"""
_global_value = 20
class num_trace_samples(_value_context):
"""
The number of samples to draw when stochastically computing the trace of a matrix
More values results in more accurate trace estimations
If the value is set to 0, then the trace will be deterministically computed
(Default: 10)
"""
_global_value = 10
class prior_mode(_feature_flag):
"""
If set to true, GP models will be evaluated in prior mode.
This allows evaluating any Exact GP model in prior mode, even it if has training data / targets.
(Default: False)
"""
_default = False
class skip_logdet_forward(_feature_flag):
"""
.. warning:
ADVANCED FEATURE. Use this feature ONLY IF you're using
`gpytorch.mlls.MarginalLogLikelihood` as loss functions for optimizing
hyperparameters/variational parameters. DO NOT use this feature if you
need accurate estimates of the MLL (i.e. for model selection, MCMC,
second order optimizaiton methods, etc.)
This feature does not affect the gradients returned by
:meth:`gpytorch.distributions.MultivariateNormal.log_prob`
(used by `gpytorch.mlls.MarginalLogLikelihood`).
The gradients remain unbiased estimates, and therefore can be used with SGD.
However, the actual likelihood value returned by the forward
pass will skip certain computations (i.e. the logdet computation), and will therefore
be improper estimates.
If you're using SGD (or a varient) to optimize parameters, you probably
don't need an accurate MLL estimate; you only need accurate gradients. So
this setting may give your model a performance boost.
(Default: False)
"""
_default = False
class terminate_cg_by_size(_feature_flag):
"""
If set to true, cg will terminate after n iterations for an n x n matrix.
(Default: False)
"""
_default = False
class trace_mode(_feature_flag):
"""
If set to True, we will generally try to avoid calling our built in PyTorch functions, because these cannot
be run through torch.jit.trace.
Note that this will sometimes involve explicitly evaluating lazy tensors and various other slowdowns and
inefficiencies. As a result, you really shouldn't use this feature context unless you are calling torch.jit.trace
on a GPyTorch model.
Our hope is that this flag will not be necessary long term, once https://github.com/pytorch/pytorch/issues/22329
is fixed.
(Default: False)
"""
_default = False
class tridiagonal_jitter(_value_context):
"""
The (relative) amount of noise to add to the diagonal of tridiagonal matrices before
eigendecomposing. root_decomposition becomes slightly more stable with this, as we need
to take the square root of the eigenvalues. Any eigenvalues still negative after adding jitter
will be zeroed out.
(Default: 1e-6)
"""
_global_value = 1e-6
class use_toeplitz(_feature_flag):
"""
Whether or not to use Toeplitz math with gridded data, grid inducing point modules
Pros: memory efficient, faster on CPU
Cons: slower on GPUs with < 10000 inducing points
(Default: True)
"""
_default = True
class verbose_linalg(_feature_flag):
"""
Print out information whenever running an expensive linear algebra routine (e.g. Cholesky, CG, Lanczos, CIQ, etc.)
(Default: False)
"""
_default = False
# Create a global logger
logger = logging.getLogger("LinAlg (Verbose)")
logger.setLevel(logging.DEBUG)
# Output logging results to the stdout stream
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
| 30.162853 | 120 | 0.70104 |
c0e4bb74ea779cedf8cd8fba0759874df89d3d42 | 727 | py | Python | scrapy/signals.py | HyunTruth/scrapy | 9bc5fab870aaee23905057002276fc0e1a48485f | [
"BSD-3-Clause"
] | 32 | 2019-11-14T07:49:33.000Z | 2022-02-16T00:49:22.000Z | scrapy/signals.py | HyunTruth/scrapy | 9bc5fab870aaee23905057002276fc0e1a48485f | [
"BSD-3-Clause"
] | 48 | 2018-11-08T01:31:33.000Z | 2019-03-08T01:18:18.000Z | scrapy/signals.py | HyunTruth/scrapy | 9bc5fab870aaee23905057002276fc0e1a48485f | [
"BSD-3-Clause"
] | 16 | 2019-06-25T13:26:43.000Z | 2022-03-07T07:29:12.000Z | """
Scrapy signals
These signals are documented in docs/topics/signals.rst. Please don't add new
signals here without documenting them there.
"""
engine_started = object()
engine_stopped = object()
spider_opened = object()
spider_idle = object()
spider_closed = object()
spider_error = object()
request_scheduled = object()
request_dropped = object()
request_reached_downloader = object()
response_received = object()
response_downloaded = object()
item_scraped = object()
item_dropped = object()
item_error = object()
# for backwards compatibility
stats_spider_opened = spider_opened
stats_spider_closing = spider_closed
stats_spider_closed = spider_closed
item_passed = item_scraped
request_received = request_scheduled
| 23.451613 | 77 | 0.799175 |
8f5bc15b3fb9ddcf6017cf938c25ad64d6e00875 | 1,222 | py | Python | 03.Complete Python Developer - Zero to Mastery - AN/14.Web Scraping/web_scraper.py | ptyadana/python-dojo | 98c7234b84f0afea99a091c7198342d66bbdff5b | [
"MIT"
] | 3 | 2020-06-01T04:17:18.000Z | 2020-12-18T03:05:55.000Z | 03.Complete Python Developer - Zero to Mastery - AN/14.Web Scraping/web_scraper.py | ptyadana/python-dojo | 98c7234b84f0afea99a091c7198342d66bbdff5b | [
"MIT"
] | 1 | 2020-04-25T08:01:59.000Z | 2020-04-25T08:01:59.000Z | 03.Complete Python Developer - Zero to Mastery - AN/14.Web Scraping/web_scraper.py | ptyadana/python-dojo | 98c7234b84f0afea99a091c7198342d66bbdff5b | [
"MIT"
] | 7 | 2020-04-26T10:02:36.000Z | 2021-06-08T05:12:46.000Z | from bs4 import BeautifulSoup
import requests
import pprint
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36'}
base_url = 'https://news.ycombinator.com/news'
response = requests.get(base_url, headers=headers)
soup = BeautifulSoup(response.text, 'lxml')
with open('hacker_news.html', 'w') as file:
file.write(soup.prettify())
links = soup.select('.storylink')
sub_text = soup.select('.subtext')
def sort_by_votes(hnlist):
#sort by votes by descending order
return sorted(hnlist, key = lambda k:k['votes'], reverse = True)
def create_custom_hacker_news(links, sub_text):
hn = []
for index, item in enumerate(links):
vote = sub_text[index].select('.score')
if len(vote):
points = int(vote[0].getText().strip(' points'))
if points > 150:
title = links[index].getText()
href = links[index].get('href', None)
hn.append({'title':title,'href':href,'votes':points})
return sort_by_votes(hn)
if __name__ == "__main__":
custom_hn_lists = create_custom_hacker_news(links, sub_text)
pprint.pprint(custom_hn_lists)
| 32.157895 | 142 | 0.664484 |
bb90356c8c4e7a1105801880dae3300f54662da5 | 1,751 | py | Python | welib/FEM/derivations/GuyanReduction.py | moonieann/welib | 0e430ad3ca034d0d2d60bdb7bbe06c947ce08f52 | [
"MIT"
] | 24 | 2019-07-24T23:37:10.000Z | 2022-03-30T20:40:40.000Z | welib/FEM/derivations/GuyanReduction.py | moonieann/welib | 0e430ad3ca034d0d2d60bdb7bbe06c947ce08f52 | [
"MIT"
] | null | null | null | welib/FEM/derivations/GuyanReduction.py | moonieann/welib | 0e430ad3ca034d0d2d60bdb7bbe06c947ce08f52 | [
"MIT"
] | 11 | 2019-03-14T13:47:04.000Z | 2022-03-31T15:47:27.000Z | """
Show that Guayan-Reduction of a single element result in rigid body modes
"""
import numpy as np
import sympy
from sympy import Symbol
from sympy import Matrix
from sympy.abc import *
from fem.frame3d import frame3d_KeMe
display=lambda x: sympy.pprint(x, use_unicode=False,wrap_line=False)
Kv = Symbol('Kv')
Ix = Symbol('Ix')
Iy = Symbol('Iy')
Iz = Symbol('Iz')
Mass = Symbol('M')
Ke,Me = frame3d_KeMe(E,G,Kv,E*A,E*Ix,E*Iy,E*Iz,L,A,Mass)
Ke = Matrix(Ke)
Me = Matrix(Me)
Kmm = Ke[:6,:6]
Ksm = Ke[6:,:6]
Kss = Ke[6:,6:]
Kssm1 = Kss.inv()
print('-----------------------------------------------------------------------------------------')
print('--- Ke ')
print('-----------------------------------------------------------------------------------------')
display(Ke)
# display(Me)
print('-----------------------------------------------------------------------------------------')
print('--- Kss ')
print('-----------------------------------------------------------------------------------------')
display(Kss)
print('-----------------------------------------------------------------------------------------')
print('--- Ksm ')
print('-----------------------------------------------------------------------------------------')
display(Ksm)
print('-----------------------------------------------------------------------------------------')
print('--- Kss^-1 ')
print('-----------------------------------------------------------------------------------------')
display(Kssm1)
print('-----------------------------------------------------------------------------------------')
print('--- Phi1 = -Kss^-1 Ksm ')
print('-----------------------------------------------------------------------------------------')
Phi1 = -Kssm1 * Ksm
display(Phi1)
| 34.333333 | 98 | 0.311822 |
4a03e5f60862953c87d4fa20a7e4b461da282c08 | 811 | py | Python | microproxy/layer/proxy/replay.py | mike820324/microProxy | 64c7c5add4759c6e105b9438cd18c0f8c930c7a3 | [
"MIT"
] | 20 | 2016-04-17T08:43:26.000Z | 2021-05-31T04:01:27.000Z | microproxy/layer/proxy/replay.py | mike820324/microProxy | 64c7c5add4759c6e105b9438cd18c0f8c930c7a3 | [
"MIT"
] | 237 | 2016-04-17T07:07:08.000Z | 2017-01-26T09:15:52.000Z | microproxy/layer/proxy/replay.py | mike820324/microProxy | 64c7c5add4759c6e105b9438cd18c0f8c930c7a3 | [
"MIT"
] | 5 | 2016-04-16T14:22:45.000Z | 2019-11-27T04:41:55.000Z | from tornado import gen
from microproxy.protocol import tls
from microproxy.layer.base import ProxyLayer
class ReplayLayer(ProxyLayer):
def __init__(self, context, **kwargs):
super(ReplayLayer, self).__init__(context, **kwargs)
@gen.coroutine
def process_and_return_context(self):
dest_stream = yield self.create_dest_stream(
(self.context.host, self.context.port))
if self.context.scheme in ("https", "h2"):
if self.context.scheme == "h2":
alpn = ["h2"]
else:
alpn = None
dest_stream = yield dest_stream.start_tls(
server_side=False, ssl_options=tls.create_dest_sslcontext(alpn=alpn))
self.context.dest_stream = dest_stream
raise gen.Return(self.context)
| 30.037037 | 85 | 0.639951 |
303d1273430328b32a0740d8391893cdc0103759 | 8,442 | py | Python | Fuzzy_clustering/version3/RBF_CNN_Manager/RBF_CNN_manager.py | joesider9/forecasting_library | db07ff8f0f2693983058d49004f2fc6f8849d197 | [
"Apache-2.0"
] | null | null | null | Fuzzy_clustering/version3/RBF_CNN_Manager/RBF_CNN_manager.py | joesider9/forecasting_library | db07ff8f0f2693983058d49004f2fc6f8849d197 | [
"Apache-2.0"
] | null | null | null | Fuzzy_clustering/version3/RBF_CNN_Manager/RBF_CNN_manager.py | joesider9/forecasting_library | db07ff8f0f2693983058d49004f2fc6f8849d197 | [
"Apache-2.0"
] | null | null | null | import joblib
from Fuzzy_clustering.version3.RBF_CNN_Manager.CNN_tf_core import CNN
from Fuzzy_clustering.version3.RBF_CNN_Manager.RBF_CNN_model import RBF_CNN_model
import pika, uuid, time, json, os
import numpy as np
from rabbitmq_rpc.server import RPCServer
from Fuzzy_clustering.version3.RBF_CNN_Manager.Cluster_object import cluster_object
RABBIT_MQ_HOST = os.getenv('RABBIT_MQ_HOST')
RABBIT_MQ_PASS = os.getenv('RABBIT_MQ_PASS')
RABBIT_MQ_PORT = int(os.getenv('RABBIT_MQ_PORT'))
server = RPCServer(queue_name='RBF_CNN_manager', host=RABBIT_MQ_HOST, port=RABBIT_MQ_PORT, threaded=False)
class rbf_cnn_manager():
def __init__(self, static_data, cluster, method, params):
self.params = params
self.test = params['test']
self.method = str.lower(method)
self.cluster = cluster
self.istrained = False
self.model_dir = os.path.join(cluster.cluster_dir, 'RBF_CNN')
if not os.path.exists(self.model_dir):
os.makedirs(self.model_dir)
self.test_dir = self.model_dir
try:
self.load()
except:
pass
if not self.istrained:
self.test_dir = os.path.join(self.model_dir, 'test_' + str(self.test))
try:
self.load()
except:
if not os.path.exists(self.test_dir):
os.makedirs(self.test_dir)
pass
self.static_data = static_data
self.cluster_name = cluster.cluster_name
self.rated = static_data['rated']
self.data_dir = cluster.data_dir
self.probabilistic = False
def fit(self):
if self.istrained == False:
return self.optimize_rbf_cnn()
else:
return self.acc
def fit_TL(self):
if self.istrained == False:
return self.optimize_rbf_cnn_TL()
else:
return self.acc
def load_data(self):
if os.path.exists(os.path.join(self.data_dir, 'dataset_X.csv')):
cvs = joblib.load(os.path.join(self.data_dir, 'cvs.pickle'))
else:
cvs = np.array([])
return cvs
def load_rbf_models(self):
model_rbfs = RBF_CNN_model(self.static_data, self.cluster, cnn=False)
rbf_models = [model_rbfs.model_rbf_ols.models, model_rbfs.model_rbf_ga.models, model_rbfs.model_rbfnn.model]
return rbf_models
def optimize_rbf_cnn(self):
self.trial = self.params['trial']
self.pool_size = self.params['pool_size']
self.kernels = self.params['kernels']
self.lr = self.params['lr']
self.hsize = self.params['h_size']
cnn_max_iterations = self.static_data['CNN']['max_iterations']
self.filters = self.static_data['CNN']['filters']
cvs = self.load_data()
self.N = cvs[0][0].shape[1]
self.D = cvs[0][0].shape[0] + cvs[0][2].shape[0] + cvs[0][4].shape[0]
self.static_data_cnn = self.static_data['CNN']
self.static_data_rbf = self.static_data['RBF']
X_train = cvs[0][0]
y_train = cvs[0][1].reshape(-1, 1)
X_val = cvs[0][2]
y_val = cvs[0][3].reshape(-1, 1)
X_test = cvs[0][4]
y_test = cvs[0][5].reshape(-1, 1)
self.rbf_models = self.load_rbf_models()
cnn = CNN(self.static_data, self.rated, self.rbf_models, X_train, y_train, X_val, y_val, X_test, y_test, self.pool_size, self.trial)
flag = False
for _ in range(3):
try:
self.acc, self.scale_cnn, self.model = cnn.train_cnn(max_iterations=cnn_max_iterations,
learning_rate=self.lr, kernels=self.kernels,
h_size=self.hsize, filters=self.filters)
flag = True
break
except:
self.filters = int(self.filters / 2)
pass
if not flag:
self.acc = np.inf
self.scale_cnn = None
self.model = None
self.istrained=True
self.save()
return self.acc
def load(self):
if os.path.exists(os.path.join(self.test_dir, self.method + '.pickle')):
try:
tmp_dict = joblib.load(os.path.join(self.test_dir, self.method + '.pickle'))
self.__dict__.update(tmp_dict)
except:
raise ImportError('Cannot open CNN model')
else:
raise ImportError('Cannot find CNN model')
def save(self):
tmp_dict = {}
for k in self.__dict__.keys():
if k not in ['logger', 'static_data_all', 'static_data', 'temp_dir', 'cluster_cnn_dir', 'cluster_dir']:
tmp_dict[k] = self.__dict__[k]
joblib.dump(tmp_dict,os.path.join(self.test_dir, self.method + '.pickle'), compress=9)
def optimize_rbf_cnn_TL(self):
static_data_tl = self.static_data['tl_project']['static_data']
cluster_dir_tl = os.path.join(static_data_tl['path_model'], 'Regressor_layer/' + self.cluster_name)
model_TL_dir = os.path.join(cluster_dir_tl, 'RBF_CNN')
model_TL = joblib.load(os.path.join(model_TL_dir, self.method + '.pickle'))
self.trial = model_TL['trial']
self.pool_size = model_TL['pool_size']
self.kernels = model_TL['kernels']
self.lr = model_TL['lr']
self.hsize = model_TL['h_size']
cnn_max_iterations = self.static_data['CNN']['max_iterations']
self.filters = model_TL['filters']
cvs = self.load_data()
self.N = cvs[0][0].shape[1]
self.D = cvs[0][0].shape[0] + cvs[0][2].shape[0] + cvs[0][4].shape[0]
self.static_data_cnn = self.static_data['CNN']
self.static_data_rbf = self.static_data['RBF']
X_train = cvs[0][0]
y_train = cvs[0][1].reshape(-1, 1)
X_val = cvs[0][2]
y_val = cvs[0][3].reshape(-1, 1)
X_test = cvs[0][4]
y_test = cvs[0][5].reshape(-1, 1)
self.rbf_models = self.load_rbf_models()
cnn = CNN(self.static_data, self.rated, self.rbf_models, X_train, y_train, X_val, y_val, X_test, y_test, self.pool_size, self.trial)
flag = False
for _ in range(3):
try:
self.acc, self.scale_cnn, self.model = cnn.train_cnn(max_iterations=cnn_max_iterations,
learning_rate=self.lr, kernels=self.kernels,
h_size=self.hsize, filters=self.filters)
flag = True
break
except:
self.filters = int(self.filters / 2)
pass
if not flag:
self.acc = np.inf
self.scale_cnn = None
self.model = None
self.istrained=True
self.save()
return self.acc
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.ndarray):
return obj.tolist()
elif isinstance(obj, np.integer) or isinstance(obj, int):
return int(obj)
elif isinstance(obj, np.floating) or isinstance(obj, float):
return float(obj)
elif isinstance(obj, np.str) or isinstance(obj, str):
return str(obj)
elif isinstance(obj, np.bool) or isinstance(obj, bool):
return bool(obj)
try:
return json.JSONEncoder.default(self, obj)
except:
print(obj)
raise TypeError('Object is not JSON serializable')
@server.consumer()
def deep_manager(static_data):
print(" [.] Receive cluster %s)" % static_data['cluster_name'])
cluster = cluster_object(static_data, static_data['cluster_name'])
model_method = static_data['method']
params = static_data['params']
model_3d = rbf_cnn_manager(static_data, cluster, model_method, params=params)
if model_3d.istrained == False:
response = {'result': model_3d.fit(), 'cluster_name': cluster.cluster_name, 'project': static_data['_id'],
'test': params['test'], 'method': model_method}
else:
response = {'result': model_3d.acc, 'cluster_name': cluster.cluster_name, 'project': static_data['_id'],
'test': params['test'], 'method': model_method}
return response
if __name__=='__main__':
server.run()
| 38.027027 | 140 | 0.588486 |
6184abd065d3cc2b699cce336a7e7c05132729eb | 57,396 | py | Python | charmhelpers/contrib/openstack/utils.py | johnsca/charm-helpers | e1157a1edb7ef2cc478af176086998d68de0b193 | [
"Apache-2.0"
] | null | null | null | charmhelpers/contrib/openstack/utils.py | johnsca/charm-helpers | e1157a1edb7ef2cc478af176086998d68de0b193 | [
"Apache-2.0"
] | null | null | null | charmhelpers/contrib/openstack/utils.py | johnsca/charm-helpers | e1157a1edb7ef2cc478af176086998d68de0b193 | [
"Apache-2.0"
] | null | null | null | # Copyright 2014-2015 Canonical Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Common python helper functions used for OpenStack charms.
from collections import OrderedDict
from functools import wraps
import subprocess
import json
import os
import sys
import re
import itertools
import functools
import six
import traceback
import uuid
import yaml
from charmhelpers import deprecate
from charmhelpers.contrib.network import ip
from charmhelpers.core import unitdata
from charmhelpers.core.hookenv import (
action_fail,
action_set,
config,
log as juju_log,
charm_dir,
INFO,
ERROR,
related_units,
relation_ids,
relation_set,
status_set,
hook_name,
application_version_set,
cached,
)
from charmhelpers.core.strutils import BasicStringComparator
from charmhelpers.contrib.storage.linux.lvm import (
deactivate_lvm_volume_group,
is_lvm_physical_volume,
remove_lvm_physical_volume,
)
from charmhelpers.contrib.network.ip import (
get_ipv6_addr,
is_ipv6,
port_has_listener,
)
from charmhelpers.core.host import (
lsb_release,
mounts,
umount,
service_running,
service_pause,
service_resume,
restart_on_change_helper,
)
from charmhelpers.fetch import (
apt_cache,
import_key as fetch_import_key,
add_source as fetch_add_source,
SourceConfigError,
GPGKeyError,
get_upstream_version
)
from charmhelpers.fetch.snap import (
snap_install,
snap_refresh,
valid_snap_channel,
)
from charmhelpers.contrib.storage.linux.utils import is_block_device, zap_disk
from charmhelpers.contrib.storage.linux.loopback import ensure_loopback_device
from charmhelpers.contrib.openstack.exceptions import OSContextError
CLOUD_ARCHIVE_URL = "http://ubuntu-cloud.archive.canonical.com/ubuntu"
CLOUD_ARCHIVE_KEY_ID = '5EDB1B62EC4926EA'
DISTRO_PROPOSED = ('deb http://archive.ubuntu.com/ubuntu/ %s-proposed '
'restricted main multiverse universe')
OPENSTACK_RELEASES = (
'diablo',
'essex',
'folsom',
'grizzly',
'havana',
'icehouse',
'juno',
'kilo',
'liberty',
'mitaka',
'newton',
'ocata',
'pike',
'queens',
'rocky',
)
UBUNTU_OPENSTACK_RELEASE = OrderedDict([
('oneiric', 'diablo'),
('precise', 'essex'),
('quantal', 'folsom'),
('raring', 'grizzly'),
('saucy', 'havana'),
('trusty', 'icehouse'),
('utopic', 'juno'),
('vivid', 'kilo'),
('wily', 'liberty'),
('xenial', 'mitaka'),
('yakkety', 'newton'),
('zesty', 'ocata'),
('artful', 'pike'),
('bionic', 'queens'),
])
OPENSTACK_CODENAMES = OrderedDict([
('2011.2', 'diablo'),
('2012.1', 'essex'),
('2012.2', 'folsom'),
('2013.1', 'grizzly'),
('2013.2', 'havana'),
('2014.1', 'icehouse'),
('2014.2', 'juno'),
('2015.1', 'kilo'),
('2015.2', 'liberty'),
('2016.1', 'mitaka'),
('2016.2', 'newton'),
('2017.1', 'ocata'),
('2017.2', 'pike'),
('2018.1', 'queens'),
])
# The ugly duckling - must list releases oldest to newest
SWIFT_CODENAMES = OrderedDict([
('diablo',
['1.4.3']),
('essex',
['1.4.8']),
('folsom',
['1.7.4']),
('grizzly',
['1.7.6', '1.7.7', '1.8.0']),
('havana',
['1.9.0', '1.9.1', '1.10.0']),
('icehouse',
['1.11.0', '1.12.0', '1.13.0', '1.13.1']),
('juno',
['2.0.0', '2.1.0', '2.2.0']),
('kilo',
['2.2.1', '2.2.2']),
('liberty',
['2.3.0', '2.4.0', '2.5.0']),
('mitaka',
['2.5.0', '2.6.0', '2.7.0']),
('newton',
['2.8.0', '2.9.0', '2.10.0']),
('ocata',
['2.11.0', '2.12.0', '2.13.0']),
('pike',
['2.13.0', '2.15.0']),
('queens',
['2.16.0', '2.17.0']),
])
# >= Liberty version->codename mapping
PACKAGE_CODENAMES = {
'nova-common': OrderedDict([
('12', 'liberty'),
('13', 'mitaka'),
('14', 'newton'),
('15', 'ocata'),
('16', 'pike'),
('17', 'queens'),
('18', 'rocky'),
]),
'neutron-common': OrderedDict([
('7', 'liberty'),
('8', 'mitaka'),
('9', 'newton'),
('10', 'ocata'),
('11', 'pike'),
('12', 'queens'),
('13', 'rocky'),
]),
'cinder-common': OrderedDict([
('7', 'liberty'),
('8', 'mitaka'),
('9', 'newton'),
('10', 'ocata'),
('11', 'pike'),
('12', 'queens'),
('13', 'rocky'),
]),
'keystone': OrderedDict([
('8', 'liberty'),
('9', 'mitaka'),
('10', 'newton'),
('11', 'ocata'),
('12', 'pike'),
('13', 'queens'),
('14', 'rocky'),
]),
'horizon-common': OrderedDict([
('8', 'liberty'),
('9', 'mitaka'),
('10', 'newton'),
('11', 'ocata'),
('12', 'pike'),
('13', 'queens'),
('14', 'rocky'),
]),
'ceilometer-common': OrderedDict([
('5', 'liberty'),
('6', 'mitaka'),
('7', 'newton'),
('8', 'ocata'),
('9', 'pike'),
('10', 'queens'),
('11', 'rocky'),
]),
'heat-common': OrderedDict([
('5', 'liberty'),
('6', 'mitaka'),
('7', 'newton'),
('8', 'ocata'),
('9', 'pike'),
('10', 'queens'),
('11', 'rocky'),
]),
'glance-common': OrderedDict([
('11', 'liberty'),
('12', 'mitaka'),
('13', 'newton'),
('14', 'ocata'),
('15', 'pike'),
('16', 'queens'),
('17', 'rocky'),
]),
'openstack-dashboard': OrderedDict([
('8', 'liberty'),
('9', 'mitaka'),
('10', 'newton'),
('11', 'ocata'),
('12', 'pike'),
('13', 'queens'),
('14', 'rocky'),
]),
}
DEFAULT_LOOPBACK_SIZE = '5G'
class CompareOpenStackReleases(BasicStringComparator):
"""Provide comparisons of OpenStack releases.
Use in the form of
if CompareOpenStackReleases(release) > 'mitaka':
# do something with mitaka
"""
_list = OPENSTACK_RELEASES
def error_out(msg):
juju_log("FATAL ERROR: %s" % msg, level='ERROR')
sys.exit(1)
def get_os_codename_install_source(src):
'''Derive OpenStack release codename from a given installation source.'''
ubuntu_rel = lsb_release()['DISTRIB_CODENAME']
rel = ''
if src is None:
return rel
if src in ['distro', 'distro-proposed']:
try:
rel = UBUNTU_OPENSTACK_RELEASE[ubuntu_rel]
except KeyError:
e = 'Could not derive openstack release for '\
'this Ubuntu release: %s' % ubuntu_rel
error_out(e)
return rel
if src.startswith('cloud:'):
ca_rel = src.split(':')[1]
ca_rel = ca_rel.split('-')[1].split('/')[0]
return ca_rel
# Best guess match based on deb string provided
if (src.startswith('deb') or
src.startswith('ppa') or
src.startswith('snap')):
for v in OPENSTACK_CODENAMES.values():
if v in src:
return v
def get_os_version_install_source(src):
codename = get_os_codename_install_source(src)
return get_os_version_codename(codename)
def get_os_codename_version(vers):
'''Determine OpenStack codename from version number.'''
try:
return OPENSTACK_CODENAMES[vers]
except KeyError:
e = 'Could not determine OpenStack codename for version %s' % vers
error_out(e)
def get_os_version_codename(codename, version_map=OPENSTACK_CODENAMES):
'''Determine OpenStack version number from codename.'''
for k, v in six.iteritems(version_map):
if v == codename:
return k
e = 'Could not derive OpenStack version for '\
'codename: %s' % codename
error_out(e)
def get_os_version_codename_swift(codename):
'''Determine OpenStack version number of swift from codename.'''
for k, v in six.iteritems(SWIFT_CODENAMES):
if k == codename:
return v[-1]
e = 'Could not derive swift version for '\
'codename: %s' % codename
error_out(e)
def get_swift_codename(version):
'''Determine OpenStack codename that corresponds to swift version.'''
codenames = [k for k, v in six.iteritems(SWIFT_CODENAMES) if version in v]
if len(codenames) > 1:
# If more than one release codename contains this version we determine
# the actual codename based on the highest available install source.
for codename in reversed(codenames):
releases = UBUNTU_OPENSTACK_RELEASE
release = [k for k, v in six.iteritems(releases) if codename in v]
ret = subprocess.check_output(['apt-cache', 'policy', 'swift'])
if six.PY3:
ret = ret.decode('UTF-8')
if codename in ret or release[0] in ret:
return codename
elif len(codenames) == 1:
return codenames[0]
# NOTE: fallback - attempt to match with just major.minor version
match = re.match('^(\d+)\.(\d+)', version)
if match:
major_minor_version = match.group(0)
for codename, versions in six.iteritems(SWIFT_CODENAMES):
for release_version in versions:
if release_version.startswith(major_minor_version):
return codename
return None
def get_os_codename_package(package, fatal=True):
'''Derive OpenStack release codename from an installed package.'''
if snap_install_requested():
cmd = ['snap', 'list', package]
try:
out = subprocess.check_output(cmd)
if six.PY3:
out = out.decode('UTF-8')
except subprocess.CalledProcessError as e:
return None
lines = out.split('\n')
for line in lines:
if package in line:
# Second item in list is Version
return line.split()[1]
import apt_pkg as apt
cache = apt_cache()
try:
pkg = cache[package]
except Exception:
if not fatal:
return None
# the package is unknown to the current apt cache.
e = 'Could not determine version of package with no installation '\
'candidate: %s' % package
error_out(e)
if not pkg.current_ver:
if not fatal:
return None
# package is known, but no version is currently installed.
e = 'Could not determine version of uninstalled package: %s' % package
error_out(e)
vers = apt.upstream_version(pkg.current_ver.ver_str)
if 'swift' in pkg.name:
# Fully x.y.z match for swift versions
match = re.match('^(\d+)\.(\d+)\.(\d+)', vers)
else:
# x.y match only for 20XX.X
# and ignore patch level for other packages
match = re.match('^(\d+)\.(\d+)', vers)
if match:
vers = match.group(0)
# Generate a major version number for newer semantic
# versions of openstack projects
major_vers = vers.split('.')[0]
# >= Liberty independent project versions
if (package in PACKAGE_CODENAMES and
major_vers in PACKAGE_CODENAMES[package]):
return PACKAGE_CODENAMES[package][major_vers]
else:
# < Liberty co-ordinated project versions
try:
if 'swift' in pkg.name:
return get_swift_codename(vers)
else:
return OPENSTACK_CODENAMES[vers]
except KeyError:
if not fatal:
return None
e = 'Could not determine OpenStack codename for version %s' % vers
error_out(e)
def get_os_version_package(pkg, fatal=True):
'''Derive OpenStack version number from an installed package.'''
codename = get_os_codename_package(pkg, fatal=fatal)
if not codename:
return None
if 'swift' in pkg:
vers_map = SWIFT_CODENAMES
for cname, version in six.iteritems(vers_map):
if cname == codename:
return version[-1]
else:
vers_map = OPENSTACK_CODENAMES
for version, cname in six.iteritems(vers_map):
if cname == codename:
return version
# e = "Could not determine OpenStack version for package: %s" % pkg
# error_out(e)
# Module local cache variable for the os_release.
_os_rel = None
def reset_os_release():
'''Unset the cached os_release version'''
global _os_rel
_os_rel = None
def os_release(package, base='essex', reset_cache=False):
'''
Returns OpenStack release codename from a cached global.
If reset_cache then unset the cached os_release version and return the
freshly determined version.
If the codename can not be determined from either an installed package or
the installation source, the earliest release supported by the charm should
be returned.
'''
global _os_rel
if reset_cache:
reset_os_release()
if _os_rel:
return _os_rel
_os_rel = (
get_os_codename_package(package, fatal=False) or
get_os_codename_install_source(config('openstack-origin')) or
base)
return _os_rel
@deprecate("moved to charmhelpers.fetch.import_key()", "2017-07", log=juju_log)
def import_key(keyid):
"""Import a key, either ASCII armored, or a GPG key id.
@param keyid: the key in ASCII armor format, or a GPG key id.
@raises SystemExit() via sys.exit() on failure.
"""
try:
return fetch_import_key(keyid)
except GPGKeyError as e:
error_out("Could not import key: {}".format(str(e)))
def get_source_and_pgp_key(source_and_key):
"""Look for a pgp key ID or ascii-armor key in the given input.
:param source_and_key: Sting, "source_spec|keyid" where '|keyid' is
optional.
:returns (source_spec, key_id OR None) as a tuple. Returns None for key_id
if there was no '|' in the source_and_key string.
"""
try:
source, key = source_and_key.split('|', 2)
return source, key or None
except ValueError:
return source_and_key, None
@deprecate("use charmhelpers.fetch.add_source() instead.",
"2017-07", log=juju_log)
def configure_installation_source(source_plus_key):
"""Configure an installation source.
The functionality is provided by charmhelpers.fetch.add_source()
The difference between the two functions is that add_source() signature
requires the key to be passed directly, whereas this function passes an
optional key by appending '|<key>' to the end of the source specificiation
'source'.
Another difference from add_source() is that the function calls sys.exit(1)
if the configuration fails, whereas add_source() raises
SourceConfigurationError(). Another difference, is that add_source()
silently fails (with a juju_log command) if there is no matching source to
configure, whereas this function fails with a sys.exit(1)
:param source: String_plus_key -- see above for details.
Note that the behaviour on error is to log the error to the juju log and
then call sys.exit(1).
"""
if source_plus_key.startswith('snap'):
# Do nothing for snap installs
return
# extract the key if there is one, denoted by a '|' in the rel
source, key = get_source_and_pgp_key(source_plus_key)
# handle the ordinary sources via add_source
try:
fetch_add_source(source, key, fail_invalid=True)
except SourceConfigError as se:
error_out(str(se))
def config_value_changed(option):
"""
Determine if config value changed since last call to this function.
"""
hook_data = unitdata.HookData()
with hook_data():
db = unitdata.kv()
current = config(option)
saved = db.get(option)
db.set(option, current)
if saved is None:
return False
return current != saved
def save_script_rc(script_path="scripts/scriptrc", **env_vars):
"""
Write an rc file in the charm-delivered directory containing
exported environment variables provided by env_vars. Any charm scripts run
outside the juju hook environment can source this scriptrc to obtain
updated config information necessary to perform health checks or
service changes.
"""
juju_rc_path = "%s/%s" % (charm_dir(), script_path)
if not os.path.exists(os.path.dirname(juju_rc_path)):
os.mkdir(os.path.dirname(juju_rc_path))
with open(juju_rc_path, 'wt') as rc_script:
rc_script.write(
"#!/bin/bash\n")
[rc_script.write('export %s=%s\n' % (u, p))
for u, p in six.iteritems(env_vars) if u != "script_path"]
def openstack_upgrade_available(package):
"""
Determines if an OpenStack upgrade is available from installation
source, based on version of installed package.
:param package: str: Name of installed package.
:returns: bool: : Returns True if configured installation source offers
a newer version of package.
"""
import apt_pkg as apt
src = config('openstack-origin')
cur_vers = get_os_version_package(package)
if not cur_vers:
# The package has not been installed yet do not attempt upgrade
return False
if "swift" in package:
codename = get_os_codename_install_source(src)
avail_vers = get_os_version_codename_swift(codename)
else:
avail_vers = get_os_version_install_source(src)
apt.init()
return apt.version_compare(avail_vers, cur_vers) == 1
def ensure_block_device(block_device):
'''
Confirm block_device, create as loopback if necessary.
:param block_device: str: Full path of block device to ensure.
:returns: str: Full path of ensured block device.
'''
_none = ['None', 'none', None]
if (block_device in _none):
error_out('prepare_storage(): Missing required input: block_device=%s.'
% block_device)
if block_device.startswith('/dev/'):
bdev = block_device
elif block_device.startswith('/'):
_bd = block_device.split('|')
if len(_bd) == 2:
bdev, size = _bd
else:
bdev = block_device
size = DEFAULT_LOOPBACK_SIZE
bdev = ensure_loopback_device(bdev, size)
else:
bdev = '/dev/%s' % block_device
if not is_block_device(bdev):
error_out('Failed to locate valid block device at %s' % bdev)
return bdev
def clean_storage(block_device):
'''
Ensures a block device is clean. That is:
- unmounted
- any lvm volume groups are deactivated
- any lvm physical device signatures removed
- partition table wiped
:param block_device: str: Full path to block device to clean.
'''
for mp, d in mounts():
if d == block_device:
juju_log('clean_storage(): %s is mounted @ %s, unmounting.' %
(d, mp), level=INFO)
umount(mp, persist=True)
if is_lvm_physical_volume(block_device):
deactivate_lvm_volume_group(block_device)
remove_lvm_physical_volume(block_device)
else:
zap_disk(block_device)
is_ip = ip.is_ip
ns_query = ip.ns_query
get_host_ip = ip.get_host_ip
get_hostname = ip.get_hostname
def get_matchmaker_map(mm_file='/etc/oslo/matchmaker_ring.json'):
mm_map = {}
if os.path.isfile(mm_file):
with open(mm_file, 'r') as f:
mm_map = json.load(f)
return mm_map
def sync_db_with_multi_ipv6_addresses(database, database_user,
relation_prefix=None):
hosts = get_ipv6_addr(dynamic_only=False)
if config('vip'):
vips = config('vip').split()
for vip in vips:
if vip and is_ipv6(vip):
hosts.append(vip)
kwargs = {'database': database,
'username': database_user,
'hostname': json.dumps(hosts)}
if relation_prefix:
for key in list(kwargs.keys()):
kwargs["%s_%s" % (relation_prefix, key)] = kwargs[key]
del kwargs[key]
for rid in relation_ids('shared-db'):
relation_set(relation_id=rid, **kwargs)
def os_requires_version(ostack_release, pkg):
"""
Decorator for hook to specify minimum supported release
"""
def wrap(f):
@wraps(f)
def wrapped_f(*args):
if os_release(pkg) < ostack_release:
raise Exception("This hook is not supported on releases"
" before %s" % ostack_release)
f(*args)
return wrapped_f
return wrap
def os_workload_status(configs, required_interfaces, charm_func=None):
"""
Decorator to set workload status based on complete contexts
"""
def wrap(f):
@wraps(f)
def wrapped_f(*args, **kwargs):
# Run the original function first
f(*args, **kwargs)
# Set workload status now that contexts have been
# acted on
set_os_workload_status(configs, required_interfaces, charm_func)
return wrapped_f
return wrap
def set_os_workload_status(configs, required_interfaces, charm_func=None,
services=None, ports=None):
"""Set the state of the workload status for the charm.
This calls _determine_os_workload_status() to get the new state, message
and sets the status using status_set()
@param configs: a templating.OSConfigRenderer() object
@param required_interfaces: {generic: [specific, specific2, ...]}
@param charm_func: a callable function that returns state, message. The
signature is charm_func(configs) -> (state, message)
@param services: list of strings OR dictionary specifying services/ports
@param ports: OPTIONAL list of port numbers.
@returns state, message: the new workload status, user message
"""
state, message = _determine_os_workload_status(
configs, required_interfaces, charm_func, services, ports)
status_set(state, message)
def _determine_os_workload_status(
configs, required_interfaces, charm_func=None,
services=None, ports=None):
"""Determine the state of the workload status for the charm.
This function returns the new workload status for the charm based
on the state of the interfaces, the paused state and whether the
services are actually running and any specified ports are open.
This checks:
1. if the unit should be paused, that it is actually paused. If so the
state is 'maintenance' + message, else 'broken'.
2. that the interfaces/relations are complete. If they are not then
it sets the state to either 'broken' or 'waiting' and an appropriate
message.
3. If all the relation data is set, then it checks that the actual
services really are running. If not it sets the state to 'broken'.
If everything is okay then the state returns 'active'.
@param configs: a templating.OSConfigRenderer() object
@param required_interfaces: {generic: [specific, specific2, ...]}
@param charm_func: a callable function that returns state, message. The
signature is charm_func(configs) -> (state, message)
@param services: list of strings OR dictionary specifying services/ports
@param ports: OPTIONAL list of port numbers.
@returns state, message: the new workload status, user message
"""
state, message = _ows_check_if_paused(services, ports)
if state is None:
state, message = _ows_check_generic_interfaces(
configs, required_interfaces)
if state != 'maintenance' and charm_func:
# _ows_check_charm_func() may modify the state, message
state, message = _ows_check_charm_func(
state, message, lambda: charm_func(configs))
if state is None:
state, message = _ows_check_services_running(services, ports)
if state is None:
state = 'active'
message = "Unit is ready"
juju_log(message, 'INFO')
return state, message
def _ows_check_if_paused(services=None, ports=None):
"""Check if the unit is supposed to be paused, and if so check that the
services/ports (if passed) are actually stopped/not being listened to.
if the unit isn't supposed to be paused, just return None, None
@param services: OPTIONAL services spec or list of service names.
@param ports: OPTIONAL list of port numbers.
@returns state, message or None, None
"""
if is_unit_paused_set():
state, message = check_actually_paused(services=services,
ports=ports)
if state is None:
# we're paused okay, so set maintenance and return
state = "maintenance"
message = "Paused. Use 'resume' action to resume normal service."
return state, message
return None, None
def _ows_check_generic_interfaces(configs, required_interfaces):
"""Check the complete contexts to determine the workload status.
- Checks for missing or incomplete contexts
- juju log details of missing required data.
- determines the correct workload status
- creates an appropriate message for status_set(...)
if there are no problems then the function returns None, None
@param configs: a templating.OSConfigRenderer() object
@params required_interfaces: {generic_interface: [specific_interface], }
@returns state, message or None, None
"""
incomplete_rel_data = incomplete_relation_data(configs,
required_interfaces)
state = None
message = None
missing_relations = set()
incomplete_relations = set()
for generic_interface, relations_states in incomplete_rel_data.items():
related_interface = None
missing_data = {}
# Related or not?
for interface, relation_state in relations_states.items():
if relation_state.get('related'):
related_interface = interface
missing_data = relation_state.get('missing_data')
break
# No relation ID for the generic_interface?
if not related_interface:
juju_log("{} relation is missing and must be related for "
"functionality. ".format(generic_interface), 'WARN')
state = 'blocked'
missing_relations.add(generic_interface)
else:
# Relation ID eists but no related unit
if not missing_data:
# Edge case - relation ID exists but departings
_hook_name = hook_name()
if (('departed' in _hook_name or 'broken' in _hook_name) and
related_interface in _hook_name):
state = 'blocked'
missing_relations.add(generic_interface)
juju_log("{} relation's interface, {}, "
"relationship is departed or broken "
"and is required for functionality."
"".format(generic_interface, related_interface),
"WARN")
# Normal case relation ID exists but no related unit
# (joining)
else:
juju_log("{} relations's interface, {}, is related but has"
" no units in the relation."
"".format(generic_interface, related_interface),
"INFO")
# Related unit exists and data missing on the relation
else:
juju_log("{} relation's interface, {}, is related awaiting "
"the following data from the relationship: {}. "
"".format(generic_interface, related_interface,
", ".join(missing_data)), "INFO")
if state != 'blocked':
state = 'waiting'
if generic_interface not in missing_relations:
incomplete_relations.add(generic_interface)
if missing_relations:
message = "Missing relations: {}".format(", ".join(missing_relations))
if incomplete_relations:
message += "; incomplete relations: {}" \
"".format(", ".join(incomplete_relations))
state = 'blocked'
elif incomplete_relations:
message = "Incomplete relations: {}" \
"".format(", ".join(incomplete_relations))
state = 'waiting'
return state, message
def _ows_check_charm_func(state, message, charm_func_with_configs):
"""Run a custom check function for the charm to see if it wants to
change the state. This is only run if not in 'maintenance' and
tests to see if the new state is more important that the previous
one determined by the interfaces/relations check.
@param state: the previously determined state so far.
@param message: the user orientated message so far.
@param charm_func: a callable function that returns state, message
@returns state, message strings.
"""
if charm_func_with_configs:
charm_state, charm_message = charm_func_with_configs()
if charm_state != 'active' and charm_state != 'unknown':
state = workload_state_compare(state, charm_state)
if message:
charm_message = charm_message.replace("Incomplete relations: ",
"")
message = "{}, {}".format(message, charm_message)
else:
message = charm_message
return state, message
def _ows_check_services_running(services, ports):
"""Check that the services that should be running are actually running
and that any ports specified are being listened to.
@param services: list of strings OR dictionary specifying services/ports
@param ports: list of ports
@returns state, message: strings or None, None
"""
messages = []
state = None
if services is not None:
services = _extract_services_list_helper(services)
services_running, running = _check_running_services(services)
if not all(running):
messages.append(
"Services not running that should be: {}"
.format(", ".join(_filter_tuples(services_running, False))))
state = 'blocked'
# also verify that the ports that should be open are open
# NB, that ServiceManager objects only OPTIONALLY have ports
map_not_open, ports_open = (
_check_listening_on_services_ports(services))
if not all(ports_open):
# find which service has missing ports. They are in service
# order which makes it a bit easier.
message_parts = {service: ", ".join([str(v) for v in open_ports])
for service, open_ports in map_not_open.items()}
message = ", ".join(
["{}: [{}]".format(s, sp) for s, sp in message_parts.items()])
messages.append(
"Services with ports not open that should be: {}"
.format(message))
state = 'blocked'
if ports is not None:
# and we can also check ports which we don't know the service for
ports_open, ports_open_bools = _check_listening_on_ports_list(ports)
if not all(ports_open_bools):
messages.append(
"Ports which should be open, but are not: {}"
.format(", ".join([str(p) for p, v in ports_open
if not v])))
state = 'blocked'
if state is not None:
message = "; ".join(messages)
return state, message
return None, None
def _extract_services_list_helper(services):
"""Extract a OrderedDict of {service: [ports]} of the supplied services
for use by the other functions.
The services object can either be:
- None : no services were passed (an empty dict is returned)
- a list of strings
- A dictionary (optionally OrderedDict) {service_name: {'service': ..}}
- An array of [{'service': service_name, ...}, ...]
@param services: see above
@returns OrderedDict(service: [ports], ...)
"""
if services is None:
return {}
if isinstance(services, dict):
services = services.values()
# either extract the list of services from the dictionary, or if
# it is a simple string, use that. i.e. works with mixed lists.
_s = OrderedDict()
for s in services:
if isinstance(s, dict) and 'service' in s:
_s[s['service']] = s.get('ports', [])
if isinstance(s, str):
_s[s] = []
return _s
def _check_running_services(services):
"""Check that the services dict provided is actually running and provide
a list of (service, boolean) tuples for each service.
Returns both a zipped list of (service, boolean) and a list of booleans
in the same order as the services.
@param services: OrderedDict of strings: [ports], one for each service to
check.
@returns [(service, boolean), ...], : results for checks
[boolean] : just the result of the service checks
"""
services_running = [service_running(s) for s in services]
return list(zip(services, services_running)), services_running
def _check_listening_on_services_ports(services, test=False):
"""Check that the unit is actually listening (has the port open) on the
ports that the service specifies are open. If test is True then the
function returns the services with ports that are open rather than
closed.
Returns an OrderedDict of service: ports and a list of booleans
@param services: OrderedDict(service: [port, ...], ...)
@param test: default=False, if False, test for closed, otherwise open.
@returns OrderedDict(service: [port-not-open, ...]...), [boolean]
"""
test = not(not(test)) # ensure test is True or False
all_ports = list(itertools.chain(*services.values()))
ports_states = [port_has_listener('0.0.0.0', p) for p in all_ports]
map_ports = OrderedDict()
matched_ports = [p for p, opened in zip(all_ports, ports_states)
if opened == test] # essentially opened xor test
for service, ports in services.items():
set_ports = set(ports).intersection(matched_ports)
if set_ports:
map_ports[service] = set_ports
return map_ports, ports_states
def _check_listening_on_ports_list(ports):
"""Check that the ports list given are being listened to
Returns a list of ports being listened to and a list of the
booleans.
@param ports: LIST or port numbers.
@returns [(port_num, boolean), ...], [boolean]
"""
ports_open = [port_has_listener('0.0.0.0', p) for p in ports]
return zip(ports, ports_open), ports_open
def _filter_tuples(services_states, state):
"""Return a simple list from a list of tuples according to the condition
@param services_states: LIST of (string, boolean): service and running
state.
@param state: Boolean to match the tuple against.
@returns [LIST of strings] that matched the tuple RHS.
"""
return [s for s, b in services_states if b == state]
def workload_state_compare(current_workload_state, workload_state):
""" Return highest priority of two states"""
hierarchy = {'unknown': -1,
'active': 0,
'maintenance': 1,
'waiting': 2,
'blocked': 3,
}
if hierarchy.get(workload_state) is None:
workload_state = 'unknown'
if hierarchy.get(current_workload_state) is None:
current_workload_state = 'unknown'
# Set workload_state based on hierarchy of statuses
if hierarchy.get(current_workload_state) > hierarchy.get(workload_state):
return current_workload_state
else:
return workload_state
def incomplete_relation_data(configs, required_interfaces):
"""Check complete contexts against required_interfaces
Return dictionary of incomplete relation data.
configs is an OSConfigRenderer object with configs registered
required_interfaces is a dictionary of required general interfaces
with dictionary values of possible specific interfaces.
Example:
required_interfaces = {'database': ['shared-db', 'pgsql-db']}
The interface is said to be satisfied if anyone of the interfaces in the
list has a complete context.
Return dictionary of incomplete or missing required contexts with relation
status of interfaces and any missing data points. Example:
{'message':
{'amqp': {'missing_data': ['rabbitmq_password'], 'related': True},
'zeromq-configuration': {'related': False}},
'identity':
{'identity-service': {'related': False}},
'database':
{'pgsql-db': {'related': False},
'shared-db': {'related': True}}}
"""
complete_ctxts = configs.complete_contexts()
incomplete_relations = [
svc_type
for svc_type, interfaces in required_interfaces.items()
if not set(interfaces).intersection(complete_ctxts)]
return {
i: configs.get_incomplete_context_data(required_interfaces[i])
for i in incomplete_relations}
def do_action_openstack_upgrade(package, upgrade_callback, configs):
"""Perform action-managed OpenStack upgrade.
Upgrades packages to the configured openstack-origin version and sets
the corresponding action status as a result.
If the charm was installed from source we cannot upgrade it.
For backwards compatibility a config flag (action-managed-upgrade) must
be set for this code to run, otherwise a full service level upgrade will
fire on config-changed.
@param package: package name for determining if upgrade available
@param upgrade_callback: function callback to charm's upgrade function
@param configs: templating object derived from OSConfigRenderer class
@return: True if upgrade successful; False if upgrade failed or skipped
"""
ret = False
if openstack_upgrade_available(package):
if config('action-managed-upgrade'):
juju_log('Upgrading OpenStack release')
try:
upgrade_callback(configs=configs)
action_set({'outcome': 'success, upgrade completed.'})
ret = True
except Exception:
action_set({'outcome': 'upgrade failed, see traceback.'})
action_set({'traceback': traceback.format_exc()})
action_fail('do_openstack_upgrade resulted in an '
'unexpected error')
else:
action_set({'outcome': 'action-managed-upgrade config is '
'False, skipped upgrade.'})
else:
action_set({'outcome': 'no upgrade available.'})
return ret
def remote_restart(rel_name, remote_service=None):
trigger = {
'restart-trigger': str(uuid.uuid4()),
}
if remote_service:
trigger['remote-service'] = remote_service
for rid in relation_ids(rel_name):
# This subordinate can be related to two seperate services using
# different subordinate relations so only issue the restart if
# the principle is conencted down the relation we think it is
if related_units(relid=rid):
relation_set(relation_id=rid,
relation_settings=trigger,
)
def check_actually_paused(services=None, ports=None):
"""Check that services listed in the services object and and ports
are actually closed (not listened to), to verify that the unit is
properly paused.
@param services: See _extract_services_list_helper
@returns status, : string for status (None if okay)
message : string for problem for status_set
"""
state = None
message = None
messages = []
if services is not None:
services = _extract_services_list_helper(services)
services_running, services_states = _check_running_services(services)
if any(services_states):
# there shouldn't be any running so this is a problem
messages.append("these services running: {}"
.format(", ".join(
_filter_tuples(services_running, True))))
state = "blocked"
ports_open, ports_open_bools = (
_check_listening_on_services_ports(services, True))
if any(ports_open_bools):
message_parts = {service: ", ".join([str(v) for v in open_ports])
for service, open_ports in ports_open.items()}
message = ", ".join(
["{}: [{}]".format(s, sp) for s, sp in message_parts.items()])
messages.append(
"these service:ports are open: {}".format(message))
state = 'blocked'
if ports is not None:
ports_open, bools = _check_listening_on_ports_list(ports)
if any(bools):
messages.append(
"these ports which should be closed, but are open: {}"
.format(", ".join([str(p) for p, v in ports_open if v])))
state = 'blocked'
if messages:
message = ("Services should be paused but {}"
.format(", ".join(messages)))
return state, message
def set_unit_paused():
"""Set the unit to a paused state in the local kv() store.
This does NOT actually pause the unit
"""
with unitdata.HookData()() as t:
kv = t[0]
kv.set('unit-paused', True)
def clear_unit_paused():
"""Clear the unit from a paused state in the local kv() store
This does NOT actually restart any services - it only clears the
local state.
"""
with unitdata.HookData()() as t:
kv = t[0]
kv.set('unit-paused', False)
def is_unit_paused_set():
"""Return the state of the kv().get('unit-paused').
This does NOT verify that the unit really is paused.
To help with units that don't have HookData() (testing)
if it excepts, return False
"""
try:
with unitdata.HookData()() as t:
kv = t[0]
# transform something truth-y into a Boolean.
return not(not(kv.get('unit-paused')))
except Exception:
return False
def pause_unit(assess_status_func, services=None, ports=None,
charm_func=None):
"""Pause a unit by stopping the services and setting 'unit-paused'
in the local kv() store.
Also checks that the services have stopped and ports are no longer
being listened to.
An optional charm_func() can be called that can either raise an
Exception or return non None, None to indicate that the unit
didn't pause cleanly.
The signature for charm_func is:
charm_func() -> message: string
charm_func() is executed after any services are stopped, if supplied.
The services object can either be:
- None : no services were passed (an empty dict is returned)
- a list of strings
- A dictionary (optionally OrderedDict) {service_name: {'service': ..}}
- An array of [{'service': service_name, ...}, ...]
@param assess_status_func: (f() -> message: string | None) or None
@param services: OPTIONAL see above
@param ports: OPTIONAL list of port
@param charm_func: function to run for custom charm pausing.
@returns None
@raises Exception(message) on an error for action_fail().
"""
services = _extract_services_list_helper(services)
messages = []
if services:
for service in services.keys():
stopped = service_pause(service)
if not stopped:
messages.append("{} didn't stop cleanly.".format(service))
if charm_func:
try:
message = charm_func()
if message:
messages.append(message)
except Exception as e:
message.append(str(e))
set_unit_paused()
if assess_status_func:
message = assess_status_func()
if message:
messages.append(message)
if messages:
raise Exception("Couldn't pause: {}".format("; ".join(messages)))
def resume_unit(assess_status_func, services=None, ports=None,
charm_func=None):
"""Resume a unit by starting the services and clearning 'unit-paused'
in the local kv() store.
Also checks that the services have started and ports are being listened to.
An optional charm_func() can be called that can either raise an
Exception or return non None to indicate that the unit
didn't resume cleanly.
The signature for charm_func is:
charm_func() -> message: string
charm_func() is executed after any services are started, if supplied.
The services object can either be:
- None : no services were passed (an empty dict is returned)
- a list of strings
- A dictionary (optionally OrderedDict) {service_name: {'service': ..}}
- An array of [{'service': service_name, ...}, ...]
@param assess_status_func: (f() -> message: string | None) or None
@param services: OPTIONAL see above
@param ports: OPTIONAL list of port
@param charm_func: function to run for custom charm resuming.
@returns None
@raises Exception(message) on an error for action_fail().
"""
services = _extract_services_list_helper(services)
messages = []
if services:
for service in services.keys():
started = service_resume(service)
if not started:
messages.append("{} didn't start cleanly.".format(service))
if charm_func:
try:
message = charm_func()
if message:
messages.append(message)
except Exception as e:
message.append(str(e))
clear_unit_paused()
if assess_status_func:
message = assess_status_func()
if message:
messages.append(message)
if messages:
raise Exception("Couldn't resume: {}".format("; ".join(messages)))
def make_assess_status_func(*args, **kwargs):
"""Creates an assess_status_func() suitable for handing to pause_unit()
and resume_unit().
This uses the _determine_os_workload_status(...) function to determine
what the workload_status should be for the unit. If the unit is
not in maintenance or active states, then the message is returned to
the caller. This is so an action that doesn't result in either a
complete pause or complete resume can signal failure with an action_fail()
"""
def _assess_status_func():
state, message = _determine_os_workload_status(*args, **kwargs)
status_set(state, message)
if state not in ['maintenance', 'active']:
return message
return None
return _assess_status_func
def pausable_restart_on_change(restart_map, stopstart=False,
restart_functions=None):
"""A restart_on_change decorator that checks to see if the unit is
paused. If it is paused then the decorated function doesn't fire.
This is provided as a helper, as the @restart_on_change(...) decorator
is in core.host, yet the openstack specific helpers are in this file
(contrib.openstack.utils). Thus, this needs to be an optional feature
for openstack charms (or charms that wish to use the openstack
pause/resume type features).
It is used as follows:
from contrib.openstack.utils import (
pausable_restart_on_change as restart_on_change)
@restart_on_change(restart_map, stopstart=<boolean>)
def some_hook(...):
pass
see core.utils.restart_on_change() for more details.
@param f: the function to decorate
@param restart_map: the restart map {conf_file: [services]}
@param stopstart: DEFAULT false; whether to stop, start or just restart
@returns decorator to use a restart_on_change with pausability
"""
def wrap(f):
@functools.wraps(f)
def wrapped_f(*args, **kwargs):
if is_unit_paused_set():
return f(*args, **kwargs)
# otherwise, normal restart_on_change functionality
return restart_on_change_helper(
(lambda: f(*args, **kwargs)), restart_map, stopstart,
restart_functions)
return wrapped_f
return wrap
def ordered(orderme):
"""Converts the provided dictionary into a collections.OrderedDict.
The items in the returned OrderedDict will be inserted based on the
natural sort order of the keys. Nested dictionaries will also be sorted
in order to ensure fully predictable ordering.
:param orderme: the dict to order
:return: collections.OrderedDict
:raises: ValueError: if `orderme` isn't a dict instance.
"""
if not isinstance(orderme, dict):
raise ValueError('argument must be a dict type')
result = OrderedDict()
for k, v in sorted(six.iteritems(orderme), key=lambda x: x[0]):
if isinstance(v, dict):
result[k] = ordered(v)
else:
result[k] = v
return result
def config_flags_parser(config_flags):
"""Parses config flags string into dict.
This parsing method supports a few different formats for the config
flag values to be parsed:
1. A string in the simple format of key=value pairs, with the possibility
of specifying multiple key value pairs within the same string. For
example, a string in the format of 'key1=value1, key2=value2' will
return a dict of:
{'key1': 'value1', 'key2': 'value2'}.
2. A string in the above format, but supporting a comma-delimited list
of values for the same key. For example, a string in the format of
'key1=value1, key2=value3,value4,value5' will return a dict of:
{'key1': 'value1', 'key2': 'value2,value3,value4'}
3. A string containing a colon character (:) prior to an equal
character (=) will be treated as yaml and parsed as such. This can be
used to specify more complex key value pairs. For example,
a string in the format of 'key1: subkey1=value1, subkey2=value2' will
return a dict of:
{'key1', 'subkey1=value1, subkey2=value2'}
The provided config_flags string may be a list of comma-separated values
which themselves may be comma-separated list of values.
"""
# If we find a colon before an equals sign then treat it as yaml.
# Note: limit it to finding the colon first since this indicates assignment
# for inline yaml.
colon = config_flags.find(':')
equals = config_flags.find('=')
if colon > 0:
if colon < equals or equals < 0:
return ordered(yaml.safe_load(config_flags))
if config_flags.find('==') >= 0:
juju_log("config_flags is not in expected format (key=value)",
level=ERROR)
raise OSContextError
# strip the following from each value.
post_strippers = ' ,'
# we strip any leading/trailing '=' or ' ' from the string then
# split on '='.
split = config_flags.strip(' =').split('=')
limit = len(split)
flags = OrderedDict()
for i in range(0, limit - 1):
current = split[i]
next = split[i + 1]
vindex = next.rfind(',')
if (i == limit - 2) or (vindex < 0):
value = next
else:
value = next[:vindex]
if i == 0:
key = current
else:
# if this not the first entry, expect an embedded key.
index = current.rfind(',')
if index < 0:
juju_log("Invalid config value(s) at index %s" % (i),
level=ERROR)
raise OSContextError
key = current[index + 1:]
# Add to collection.
flags[key.strip(post_strippers)] = value.rstrip(post_strippers)
return flags
def os_application_version_set(package):
'''Set version of application for Juju 2.0 and later'''
application_version = get_upstream_version(package)
# NOTE(jamespage) if not able to figure out package version, fallback to
# openstack codename version detection.
if not application_version:
application_version_set(os_release(package))
else:
application_version_set(application_version)
def enable_memcache(source=None, release=None, package=None):
"""Determine if memcache should be enabled on the local unit
@param release: release of OpenStack currently deployed
@param package: package to derive OpenStack version deployed
@returns boolean Whether memcache should be enabled
"""
_release = None
if release:
_release = release
else:
_release = os_release(package, base='icehouse')
if not _release:
_release = get_os_codename_install_source(source)
return CompareOpenStackReleases(_release) >= 'mitaka'
def token_cache_pkgs(source=None, release=None):
"""Determine additional packages needed for token caching
@param source: source string for charm
@param release: release of OpenStack currently deployed
@returns List of package to enable token caching
"""
packages = []
if enable_memcache(source=source, release=release):
packages.extend(['memcached', 'python-memcache'])
return packages
def update_json_file(filename, items):
"""Updates the json `filename` with a given dict.
:param filename: path to json file (e.g. /etc/glance/policy.json)
:param items: dict of items to update
"""
if not items:
return
with open(filename) as fd:
policy = json.load(fd)
# Compare before and after and if nothing has changed don't write the file
# since that could cause unnecessary service restarts.
before = json.dumps(policy, indent=4, sort_keys=True)
policy.update(items)
after = json.dumps(policy, indent=4, sort_keys=True)
if before == after:
return
with open(filename, "w") as fd:
fd.write(after)
@cached
def snap_install_requested():
""" Determine if installing from snaps
If openstack-origin is of the form snap:track/channel[/branch]
and channel is in SNAPS_CHANNELS return True.
"""
origin = config('openstack-origin') or ""
if not origin.startswith('snap:'):
return False
_src = origin[5:]
if '/' in _src:
channel = _src.split('/')[1]
else:
# Handle snap:track with no channel
channel = 'stable'
return valid_snap_channel(channel)
def get_snaps_install_info_from_origin(snaps, src, mode='classic'):
"""Generate a dictionary of snap install information from origin
@param snaps: List of snaps
@param src: String of openstack-origin or source of the form
snap:track/channel
@param mode: String classic, devmode or jailmode
@returns: Dictionary of snaps with channels and modes
"""
if not src.startswith('snap:'):
juju_log("Snap source is not a snap origin", 'WARN')
return {}
_src = src[5:]
channel = '--channel={}'.format(_src)
return {snap: {'channel': channel, 'mode': mode}
for snap in snaps}
def install_os_snaps(snaps, refresh=False):
"""Install OpenStack snaps from channel and with mode
@param snaps: Dictionary of snaps with channels and modes of the form:
{'snap_name': {'channel': 'snap_channel',
'mode': 'snap_mode'}}
Where channel is a snapstore channel and mode is --classic, --devmode
or --jailmode.
@param post_snap_install: Callback function to run after snaps have been
installed
"""
def _ensure_flag(flag):
if flag.startswith('--'):
return flag
return '--{}'.format(flag)
if refresh:
for snap in snaps.keys():
snap_refresh(snap,
_ensure_flag(snaps[snap]['channel']),
_ensure_flag(snaps[snap]['mode']))
else:
for snap in snaps.keys():
snap_install(snap,
_ensure_flag(snaps[snap]['channel']),
_ensure_flag(snaps[snap]['mode']))
| 34.00237 | 79 | 0.624225 |
adbcb07e2fa96e49d908a160193da7150d50cc53 | 1,119 | py | Python | tests/test_q0101.py | mirzadm/ctci-5th-py | ba2f4de0aba4c7c04d7e0ddf3120ce312d9e5d66 | [
"MIT"
] | null | null | null | tests/test_q0101.py | mirzadm/ctci-5th-py | ba2f4de0aba4c7c04d7e0ddf3120ce312d9e5d66 | [
"MIT"
] | 1 | 2018-07-04T23:10:20.000Z | 2018-07-04T23:10:20.000Z | tests/test_q0101.py | mirzadm/ctci-5th-py | ba2f4de0aba4c7c04d7e0ddf3120ce312d9e5d66 | [
"MIT"
] | null | null | null | """Unit tests for q0101.py."""
import unittest
from src.q0101 import (is_all_unique_str as is_unique,
is_all_unique_dict as is_unique_dict,
is_all_unique_set as is_unique_set)
class TestUniqueness(unittest.TestCase):
"""Tests for string, dictionary, and set implementations."""
def test_str(self):
self.assertTrue(is_unique(''))
self.assertTrue(is_unique('a'))
self.assertFalse(is_unique('aa'))
self.assertTrue(is_unique('abc'))
self.assertFalse(is_unique('abb'))
def test_dict(self):
self.assertTrue(is_unique_dict(''))
self.assertTrue(is_unique_dict('a'))
self.assertFalse(is_unique_dict('aa'))
self.assertTrue(is_unique_dict('abc'))
self.assertFalse(is_unique_dict('abb'))
def test_set(self):
self.assertTrue(is_unique_set(''))
self.assertTrue(is_unique_set('a'))
self.assertFalse(is_unique_set('aa'))
self.assertTrue(is_unique_set('abc'))
self.assertFalse(is_unique_set('abb'))
if __name__ == '__main__':
unittest.main()
| 31.083333 | 64 | 0.647006 |
13ce1627d00700f94af2e5894bf5f27226b422c6 | 1,416 | py | Python | test/test_list_incrementor.py | klreeher/python-sdk | b7fe922dcfc3bb73fe4149475fa45fdcb04d956a | [
"Apache-2.0"
] | null | null | null | test/test_list_incrementor.py | klreeher/python-sdk | b7fe922dcfc3bb73fe4149475fa45fdcb04d956a | [
"Apache-2.0"
] | null | null | null | test/test_list_incrementor.py | klreeher/python-sdk | b7fe922dcfc3bb73fe4149475fa45fdcb04d956a | [
"Apache-2.0"
] | null | null | null | # coding: utf-8
"""
OrderCloud
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: 1.0
Contact: ordercloud@four51.com
Generated by: https://github.com/swagger-api/swagger-codegen.git
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from __future__ import absolute_import
import os
import sys
import unittest
import OrderCloud
from OrderCloud.rest import ApiException
from OrderCloud.models.list_incrementor import ListIncrementor
class TestListIncrementor(unittest.TestCase):
""" ListIncrementor unit test stubs """
def setUp(self):
pass
def tearDown(self):
pass
def testListIncrementor(self):
"""
Test ListIncrementor
"""
model = OrderCloud.models.list_incrementor.ListIncrementor()
if __name__ == '__main__':
unittest.main()
| 26.222222 | 105 | 0.722458 |
207696558a38c19e4c5afb0386931fa133df0a00 | 9,107 | py | Python | python/neutrophils/neutrophil_hist.py | mjoppich/miRExplore | 32760d88d65e7bc23b2bfb49415efcd0a7c7c5e1 | [
"Apache-2.0"
] | null | null | null | python/neutrophils/neutrophil_hist.py | mjoppich/miRExplore | 32760d88d65e7bc23b2bfb49415efcd0a7c7c5e1 | [
"Apache-2.0"
] | null | null | null | python/neutrophils/neutrophil_hist.py | mjoppich/miRExplore | 32760d88d65e7bc23b2bfb49415efcd0a7c7c5e1 | [
"Apache-2.0"
] | null | null | null | import argparse
import json
import sys, os
from lxml import etree
from xml.dom import minidom
from neutrophils.allowedSentences import AllowedSentences
sys.path.insert(0, str(os.path.dirname(os.path.realpath(__file__))) + "/../")
import requests
from textmining.SentenceID import SentenceID
parser = argparse.ArgumentParser(description='db query', add_help=False)
parser.add_argument('-o', '--output', type=argparse.FileType("w"), help='outfile', default=None, required=False)
args = parser.parse_args()
fetchAddData = False
def makeSubstr(sent, s, e):
if len(sent) <= e:
return ""
return sent[s:e]
for maxSentDist in [0,1,2,3,4,5]:
query = {"elements": [{'group': 'NEUTROPHIL', 'name': 'PMN', 'termid': 'PMN'}, {'group': 'NEUTROPHIL', 'name': 'neutrophils', 'termid': 'neutrophils'}], "sentences": str(fetchAddData), "obolevel": 1, "messenger_obolevel": 1, "sentence_distance": maxSentDist}
r = requests.post("http://localhost:65522/query", data=json.dumps(query))
res = json.loads(r.content.decode())
sep = "\t"
allPMIDs = set()
allPMC = set()
print("received", len(res['rels']), "relations", file=sys.stderr)
for rel in res['rels']:
for ev in rel['evidences']:
docid = ev['docid']
if docid == None:
continue
if docid.startswith("PMC"):
allPMC.add(docid.replace('PMC', ""))
else:
allPMIDs.add(docid)
elemcount = 0
relEvCount = 0
evCount = 0
evPMID = set()
evSent = set()
evPMC = set()
allowedSentsGen = AllowedSentences(maxSentDist)
for rel in res['rels']:
for ev in rel['evidences']:
docid = ev['docid']
sentid = ev['rel_sentence']
sentence = ev.get("sentence", "")
aSent = sentid.split(".")
aSentNum = int(aSent[-1])
aSent = aSent[0:2]
# remove citations/references
if aSent[0].startswith("PMC") and aSent[1] == '4':
continue
if len(sentence) > 0:
if "///" in sentence:
continue
allowedSentIDs = allowedSentsGen.getDistanceDictBySentID(sentid)
verbdir = ev['rel_direction_verb']
lid = ev['lid']
loid = ev['lontid']
rid = ev['rid']
roid = ev['rontid']
trusts = (ev['trust']['verb'], ev['trust']['stack'], ev['trust']['relex'], ev['trust']['conj'])
# if len([x for x in trusts[0:3] if x > 0]) == 0:
# continue
textLeft = ""
textRight = ""
if len(sentence) > 0:
textLeft = sentence[ev['lpos'][0]:ev['lpos'][1]]
textRight = sentence[ev['rpos'][0]:ev['rpos'][1]]
effect = res['pmidinfo']['categories'].get(docid, [None])
message = res['pmidinfo']['messengers'].get(docid, [None])
effectWords = {}
messageWords = {}
effectDistances = {}
messageDistances = {}
foundEffects = set()
if effect != None:
for termEffect in effect:
for x in termEffect['evidences']:
if x[0] == sentid:
effectElem = (termEffect['termid'], termEffect['termname'], x[0], x[1], x[2])
foundEffects.add(effectElem)
if effectElem in messageDistances:
if allowedSentIDs[x[0]] < effectDistances[effectElem]:
effectDistances[effectElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
effectWords[effectElem] = makeSubstr(sentence, x[1], x[2])
else:
effectDistances[effectElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
effectWords[effectElem] = makeSubstr(sentence, x[1], x[2])
if len(foundEffects) == 0:
for termEffect in effect:
for x in termEffect['evidences']:
if x[0] in allowedSentIDs:
effectElem = (termEffect['termid'], termEffect['termname'], x[0], x[1], x[2])
foundEffects.add(effectElem)
if effectElem in messageDistances:
if allowedSentIDs[x[0]] < effectDistances[effectElem]:
effectDistances[effectElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
effectWords[effectElem] = makeSubstr(sentence, x[1], x[2])
else:
effectDistances[effectElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
effectWords[effectElem] = makeSubstr(sentence, x[1], x[2])
foundMessages = set()
if message != None:
for termMessage in message:
for x in termMessage['evidences']:
if x[0] == sentid:
messageElem = (termMessage['termid'], termMessage['termname'], x[0], x[1], x[2])
foundMessages.add(messageElem)
if messageElem in messageDistances:
if messageElem in messageDistances:
if allowedSentIDs[x[0]] < messageDistances[messageElem]:
messageDistances[messageElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
messageWords[messageElem] = makeSubstr(sentence, x[1], x[2])
else:
messageDistances[messageElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
messageWords[messageElem] = makeSubstr(sentence, x[1], x[2])
if len(foundMessages) == 0:
for termMessage in message:
for x in termMessage['evidences']:
if x[0] in allowedSentIDs:
messageElem = (termMessage['termid'], termMessage['termname'], x[0], x[1], x[2])
foundMessages.add(messageElem)
if messageElem in messageDistances:
if allowedSentIDs[x[0]] < messageDistances[messageElem]:
messageDistances[messageElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
messageWords[messageElem] = makeSubstr(sentence, x[1], x[2])
else:
messageDistances[messageElem] = allowedSentIDs[x[0]]
if x[0] == sentid:
messageWords[messageElem] = makeSubstr(sentence, x[1], x[2])
trustStr = sep.join([str(x) for x in trusts])
# if len(foundEffects) == 0 or len(foundMessages) == 0:
# print("INC EFF MESS", len(foundEffects), len(foundMessages))
relEvCount += 1
for messageElem in foundMessages:
for effectElem in foundEffects:
mDist = messageDistances[messageElem]
eDist = effectDistances[effectElem]
messageWord = messageWords.get(messageElem, "")
effectWord = effectWords.get(effectElem, "")
if messageElem[2] == effectElem[2]:
messageInterval = (messageElem[3], messageElem[4])
effectInterval = (effectElem[3], effectElem[4])
overlap = max([messageInterval[0], effectInterval[0]]) <= min(
[messageInterval[1], effectInterval[1]])
if overlap:
continue
assert(mDist <= maxSentDist)
assert(eDist <= maxSentDist)
evCount += 1
if docid.startswith("PMC"):
evPMC.add(docid)
else:
evPMID.add(docid)
evSent.add(sentid)
print("Distance", maxSentDist)
print("relEvCount", relEvCount)
print("evCount", evCount)
print("evPMID", len(evPMID))
print("evPMC", len(evPMC))
print("evSents", len(evSent))
print("PMIDs", len(allPMIDs))
print("PMCs", len(allPMC))
print("\n\n\n")
# Save the file
#print(elemcount, file=sys.stderr) | 34.496212 | 262 | 0.471615 |
0dafa4920559c01426de2eea447adecd097ee402 | 5,172 | py | Python | tfx/components/evaluator/executor.py | alonsoir/tfx | 359dcc95e6104e183b685a683d502744305e5eba | [
"Apache-2.0"
] | null | null | null | tfx/components/evaluator/executor.py | alonsoir/tfx | 359dcc95e6104e183b685a683d502744305e5eba | [
"Apache-2.0"
] | null | null | null | tfx/components/evaluator/executor.py | alonsoir/tfx | 359dcc95e6104e183b685a683d502744305e5eba | [
"Apache-2.0"
] | null | null | null | # Copyright 2019 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Generic TFX model evaluator executor."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import absl
import apache_beam as beam
import tensorflow_model_analysis as tfma
from typing import Any, Dict, List, Text
from google.protobuf import json_format
from tfx import types
from tfx.components.base import base_executor
from tfx.proto import evaluator_pb2
from tfx.types import artifact_utils
from tfx.utils import io_utils
from tfx.utils import path_utils
class Executor(base_executor.BaseExecutor):
"""Generic TFX model evaluator executor."""
def _get_slice_spec_from_feature_slicing_spec(
self, spec: evaluator_pb2.FeatureSlicingSpec
) -> List[tfma.slicer.SingleSliceSpec]:
"""Given a feature slicing spec, returns a List of SingleSliceSpecs.
Args:
spec: slice specification.
Returns:
List of corresponding SingleSliceSpecs. Always includes the overall slice,
even if it was not specified in the given spec.
"""
result = []
for single_spec in spec.specs:
columns = single_spec.column_for_slicing
result.append(tfma.slicer.SingleSliceSpec(columns=columns))
# Always include the overall slice.
if tfma.slicer.SingleSliceSpec() not in result:
result.append(tfma.slicer.SingleSliceSpec())
return result
def Do(self, input_dict: Dict[Text, List[types.Artifact]],
output_dict: Dict[Text, List[types.Artifact]],
exec_properties: Dict[Text, Any]) -> None:
"""Runs a batch job to evaluate the eval_model against the given input.
Args:
input_dict: Input dict from input key to a list of Artifacts.
- model_exports: exported model.
- examples: examples for eval the model.
output_dict: Output dict from output key to a list of Artifacts.
- output: model evaluation results.
exec_properties: A dict of execution properties.
- feature_slicing_spec: JSON string of evaluator_pb2.FeatureSlicingSpec
instance, providing the way to slice the data.
Returns:
None
"""
if 'model_exports' not in input_dict:
raise ValueError('\'model_exports\' is missing in input dict.')
if 'examples' not in input_dict:
raise ValueError('\'examples\' is missing in input dict.')
if 'output' not in output_dict:
raise ValueError('\'output\' is missing in output dict.')
self._log_startup(input_dict, output_dict, exec_properties)
# Extract input artifacts
model_exports_uri = artifact_utils.get_single_uri(
input_dict['model_exports'])
feature_slicing_spec = evaluator_pb2.FeatureSlicingSpec()
json_format.Parse(exec_properties['feature_slicing_spec'],
feature_slicing_spec)
slice_spec = self._get_slice_spec_from_feature_slicing_spec(
feature_slicing_spec)
output_uri = artifact_utils.get_single_uri(output_dict['output'])
eval_model_path = path_utils.eval_model_path(model_exports_uri)
# Add fairness indicator metric callback if necessary.
fairness_indicator_thresholds = exec_properties.get(
'fairness_indicator_thresholds', None)
add_metrics_callbacks = None
if fairness_indicator_thresholds:
# Need to import the following module so that the fairness indicator
# post-export metric is registered.
import tensorflow_model_analysis.addons.fairness.post_export_metrics.fairness_indicators # pylint: disable=g-import-not-at-top, unused-variable
add_metrics_callbacks = [
tfma.post_export_metrics.fairness_indicators( # pytype: disable=module-attr
thresholds=fairness_indicator_thresholds),
]
absl.logging.info('Using {} for model eval.'.format(eval_model_path))
eval_shared_model = tfma.default_eval_shared_model(
eval_saved_model_path=eval_model_path,
add_metrics_callbacks=add_metrics_callbacks)
absl.logging.info('Evaluating model.')
with self._make_beam_pipeline() as pipeline:
# pylint: disable=expression-not-assigned
(pipeline
| 'ReadData' >> beam.io.ReadFromTFRecord(
file_pattern=io_utils.all_files_pattern(
artifact_utils.get_split_uri(input_dict['examples'], 'eval')))
|
'ExtractEvaluateAndWriteResults' >> tfma.ExtractEvaluateAndWriteResults(
eval_shared_model=eval_shared_model,
slice_spec=slice_spec,
output_path=output_uri))
absl.logging.info(
'Evaluation complete. Results written to {}.'.format(output_uri))
| 39.480916 | 150 | 0.732599 |
6186c106d3df608126c38d7185d3bc464d63b6c8 | 2,940 | py | Python | insta/views.py | lilianwaweru/Instagram | 7a4d4dae3f644646c0aebbd8e69ff32bb2a5323f | [
"MIT"
] | null | null | null | insta/views.py | lilianwaweru/Instagram | 7a4d4dae3f644646c0aebbd8e69ff32bb2a5323f | [
"MIT"
] | 3 | 2021-03-19T00:47:33.000Z | 2021-09-08T00:59:44.000Z | insta/views.py | lilianwaweru/Instagram | 7a4d4dae3f644646c0aebbd8e69ff32bb2a5323f | [
"MIT"
] | null | null | null | from django.shortcuts import render,redirect
from .models import Image,Profile,Comments
from django.contrib.auth.decorators import login_required
from .forms import getProfile,uploadPhoto,Comment
# Create your views here.
def welcome(request):
images = Image.objects.all()
prof=Profile.objects.filter(infor=request.user.id)[0:1]
return render(request,'welcome.html',{"images":images,'prof':prof})
def search_image(request):
if 'image' in request.GET and request.GET["image"]:
search_term = (request.GET.get("image")).title()
searched_images = Image.search_by_image(search_term)
message = f"{search_term}"
return render(request, 'search.html',{"message":message,"images": searched_images})
else:
message = "You haven't searched for any image"
return render(request, 'search.html',{"message":message})
def index(request):
title = "Index Page"
return render (request, 'index.html', {"title":title})
@login_required(login_url='/accounts/login/')
def edit_profile_info(request):
logged_user =request.user.id
if request.method == 'POST':
form = getProfile(request.POST,request.FILES)
if form.is_valid():
edit = form.save(commit=False)
edit.infor = logged_user
edit.save()
return redirect('welcome')
else:
form = getProfile()
return render(request,'Profile.html',{'form':form})
@login_required(login_url='/accounts/login/')
def Photo(request):
logged_user =request.user.id
if request.method == 'POST':
form = uploadPhoto(request.POST,request.FILES)
if form.is_valid():
Photo = form.save(commit=False)
Photo.profile = logged_user
Photo.save()
return redirect('welcome')
else:
form = uploadPhoto()
return render(request,'upload.html',{'form':form})
@login_required(login_url='/accounts/login/')
def comment(request,image_id):
image = Image.objects.get(id = image_id)
if request.method=='POST':
current_user=request.user
form=Comment(request.POST)
if form.is_valid:
comments=form.save(commit=False)
comments.user=current_user
comments.picture=image.id
comments.save()
return redirect('welcome')
else:
form=Comment()
comments = Comments.objects.filter(picture=image_id).all
return render(request,"comment.html",{'form':form, "image":image ,"comments":comments})
@login_required(login_url='/accounts/login/')
def profile(request):
users =request.user.id
try:
profile = Profile.objects.filter(infor=users).first()
all_images = Image.objects.filter(infor=request.user.id).all()
except ObjectDoesNotExist:
return redirect('welcome')
return render (request,"edit.html",{"profile":profile,"all_images":all_images})
| 29.69697 | 91 | 0.655442 |
6e5f8468643b6e3373ce550e6cbe61e8c15b543f | 912 | py | Python | prism/cmds/mod/kick.py | ii-Python/Prism-v3 | 15a43161b41117529c915726e6270259f05d187d | [
"MIT"
] | 3 | 2021-11-26T22:08:11.000Z | 2021-12-23T21:42:22.000Z | prism/cmds/mod/kick.py | wannurhadi/Prism-v3 | 514f8d17072bf208c42e68391bce471c7d608269 | [
"MIT"
] | 1 | 2021-07-07T22:37:10.000Z | 2021-07-07T22:40:11.000Z | prism/cmds/mod/kick.py | wannurhadi/Prism-v3 | 514f8d17072bf208c42e68391bce471c7d608269 | [
"MIT"
] | 1 | 2021-12-23T21:42:24.000Z | 2021-12-23T21:42:24.000Z | # Copyright 2021-xx iiPython
# Modules
import discord
from discord.ext import commands
from discord.commands import Option
# Command class
class Kick(commands.Cog):
def __init__(self, bot) -> None:
self.bot = bot
self.core = bot.core
@commands.slash_command(description = "Kicks a user from the server")
@commands.has_permissions(kick_members = True)
async def kick(self, ctx, user: Option(discord.Member, "The user to kick"), reason: Option(str, "Reason of kick", required = False, default = "None specified.")) -> any:
try:
await user.kick(reason = reason)
except Exception:
return await ctx.respond(embed = self.core.error("Missing permission to kick that user."))
return await ctx.respond(embed = self.core.small_embed(f"Successfully kicked {user.name}."))
# Link
def setup(bot) -> None:
return bot.add_cog(Kick(bot))
| 32.571429 | 173 | 0.679825 |
ef210efa72a822c06ec7719525cf832c98c56a06 | 1,085 | py | Python | examples/test_ps4000a.py | bk90/pico-python | e3b6d99b8ebec4f564f7ba835936492ae099975e | [
"BSD-2-Clause"
] | 84 | 2015-01-28T23:40:50.000Z | 2022-03-15T06:09:27.000Z | examples/test_ps4000a.py | bk90/pico-python | e3b6d99b8ebec4f564f7ba835936492ae099975e | [
"BSD-2-Clause"
] | 123 | 2015-01-16T21:28:36.000Z | 2022-01-31T11:08:39.000Z | examples/test_ps4000a.py | bk90/pico-python | e3b6d99b8ebec4f564f7ba835936492ae099975e | [
"BSD-2-Clause"
] | 97 | 2015-02-18T14:43:14.000Z | 2022-03-15T06:09:28.000Z | from picoscope import ps4000a
import matplotlib.pyplot as plt
import numpy as np
import time
ps = ps4000a.PS4000a()
# rapid block mode
ps.setChannel(channel="A", coupling="DC", VRange=1)
ps.setChannel(channel="B", enabled=False)
ps.setChannel(channel="C", enabled=False)
ps.setChannel(channel="D", enabled=False)
n_captures = 100
sample_interval = 100e-9 # 100 ns
sample_duration = 2e-3 # 1 ms
ps.setResolution('12') # Resolution can only be set on the PS4444
ps.setSamplingInterval(sample_interval, sample_duration)
ps.setSimpleTrigger("A", threshold_V=0.1, timeout_ms=1)
samples_per_segment = ps.memorySegments(n_captures)
ps.setNoOfCaptures(n_captures)
data = np.zeros((n_captures, samples_per_segment), dtype=np.int16)
t1 = time.time()
ps.runBlock()
ps.waitReady()
t2 = time.time()
print("Time to record data to scope: ", str(t2 - t1))
ps.getDataRawBulk(data=data)
t3 = time.time()
print("Time to copy to RAM: ", str(t3 - t2))
plt.imshow(data[:, 0:ps.noSamples], aspect='auto', interpolation='none',
cmap=plt.cm.hot)
plt.colorbar()
plt.show()
ps.close()
| 23.586957 | 72 | 0.731797 |
09a1f2332ba2de84b3e05bb8b737985cec30d56a | 4,227 | py | Python | sagas/nlu/inspector_clauses.py | samlet/stack | 47db17fd4fdab264032f224dca31a4bb1d19b754 | [
"Apache-2.0"
] | 3 | 2020-01-11T13:55:38.000Z | 2020-08-25T22:34:15.000Z | sagas/nlu/inspector_clauses.py | samlet/stack | 47db17fd4fdab264032f224dca31a4bb1d19b754 | [
"Apache-2.0"
] | null | null | null | sagas/nlu/inspector_clauses.py | samlet/stack | 47db17fd4fdab264032f224dca31a4bb1d19b754 | [
"Apache-2.0"
] | 1 | 2021-01-01T05:21:44.000Z | 2021-01-01T05:21:44.000Z | from typing import Text, Any, Dict, List, Union, Set
from sagas.nlu.inspector_common import Inspector, Context, cla_meta_intf
from sagas.nlu.utils import check_chain
from sagas.conf.conf import cf
import abc
def check_clause_sub(sents:Text, lang:Text, domain:Text, cla:Text,
rel:Text, cats:Union[Text, Set, List]):
"""
>>> from sagas.nlu.inspector_clauses import check_clause_sub
>>> check_clause_sub(sents, 'pt', 'verb_domains', 'obl', 'cop', {'be'})
:param sents:
:param lang:
:param domain:
:param cla:
:param rel:
:param cats:
:return:
"""
from sagas.nlu.uni_chunks import get_chunk
from sagas.nlu.ruleset_procs import cached_chunks
# cla = 'obl', rel = 'cop', cat='be'
chunks = cached_chunks(sents, lang, cf.engine(lang))
result = get_chunk(chunks, domain, cla,
lambda w: {'rel': w.dependency_relation,
'pos': w.upos.lower(),
'word': f"{w.text}/{w.lemma}"})
word = next((w['word'] for w in result if w['rel'] == rel), None)
if word:
if isinstance(cats, str):
return check_chain(cats, word, '*', lang)
else:
return any([check_chain(cat, word, '*', lang) for cat in cats])
return False
class cla_expr(object):
"""
>>> from sagas.nlu.inspector_common import cla_meta
>>> from sagas.nlu.inspector_clauses import cla_expr
>>> e=cla_expr('verb:obl', cop={'be'})
>>> e.run('', cla_meta('Ela negou ser minha mãe.', 'pt'))
"""
def __init__(self, domain_path:Text, **kwargs):
self.domain_path=domain_path
parts = domain_path.split(':')
self.domain = f'{parts[0]}_domains'
self.path = parts[1]
self.chckers = kwargs
def run(self, key, ctx:cla_meta_intf, operator=all):
# check_clause_sub(sents, 'pt', 'verb_domains', 'obl', 'cop', {'be'})
rs=[]
for k,v in self.chckers.items():
r=check_clause_sub(ctx.sents, ctx.lang, self.domain,
self.path, k, v)
rs.append(r)
return operator(rs)
def __str__(self):
return f"{self.domain_path}{self.chckers}"
def __repr__(self):
return self.__str__()
class ClausesInspector(Inspector):
"""
>>> from sagas.nlu.inspector_clauses import ClausesInspector as clauses
>>> clauses(all, cla_expr('verb:obl', cop={'be'})),
"""
def __init__(self, operator, *exprs):
self.operator=operator
self.exprs=exprs
def name(self):
return "clauses"
def run(self, key, ctx:Context):
rs=[]
for expr in self.exprs:
r=expr.run(key, ctx)
rs.append(r)
return self.operator(rs)
def __str__(self):
return f"ins_{self.name()}({self.exprs})"
class UnderstructureInspector(Inspector):
def __init__(self, part:Text):
self.part=part
def name(self):
return "unders"
def collect_children(self, chunks, lang, index):
from sagas.nlu.ruleset_procs import children
from sagas.nlu.nlu_cli import retrieve_word_info
from sagas.nlu.utils import get_possible_mean
sent = chunks['doc']
word = next(filter(lambda w: w.index == index, sent.words))
# print(word.index, word.text)
result=[]
for c in children(word, sent):
word = f"{c.text}/{c.lemma}"
rs = retrieve_word_info('get_synsets', word, lang, '*')
mean = get_possible_mean(rs)
result.append({'mean':mean, 'word':word})
return result
def run(self, key, ctx:Context):
from sagas.nlu.ruleset_procs import list_words, cached_chunks, get_main_domains
from sagas.conf.conf import cf
chunks = cached_chunks(ctx.sents, ctx.lang, cf.engine(ctx.lang))
index = next((x[1] for x in ctx.domains if x[0] == self.part), -1)
if index!=-1:
rs=self.collect_children(chunks, ctx.lang, index+1)
if rs:
ctx.add_result(self.name(), 'default', self.part, rs)
return True
def __str__(self):
return f"ins_{self.name()}({self.part})"
| 33.547619 | 87 | 0.592146 |
bd323fbd8b1d5cb9a649e24384b60e774e47e8cb | 1,377 | py | Python | magmap/tests/unit_testing.py | kaparna126/magellanmapper | 6a50e82b3bcdbbb4706f749f366b055f0c6f13f2 | [
"BSD-3-Clause"
] | 10 | 2020-04-14T12:49:38.000Z | 2021-06-10T13:08:52.000Z | magmap/tests/unit_testing.py | kaparna126/magellanmapper | 6a50e82b3bcdbbb4706f749f366b055f0c6f13f2 | [
"BSD-3-Clause"
] | 55 | 2020-10-20T03:40:52.000Z | 2022-03-08T11:13:45.000Z | magmap/tests/unit_testing.py | kaparna126/magellanmapper | 6a50e82b3bcdbbb4706f749f366b055f0c6f13f2 | [
"BSD-3-Clause"
] | 2 | 2020-10-20T03:27:23.000Z | 2020-12-07T21:16:59.000Z | # MagellanMapper unit testing
# Author: David Young, 2018, 2020
"""Unit testing for the MagellanMapper package.
"""
import unittest
from magmap.cv import stack_detect
from magmap.io import cli
from magmap.io import importer
from magmap.settings import config
TEST_IMG = "test.czi"
class TestImageStackProcessing(unittest.TestCase):
def setUp(self):
config.filename = TEST_IMG
config.channel = None
cli.setup_roi_profiles(["lightsheet,4xnuc"])
def test_load_image(self):
img5d = importer.read_file(
config.filename, config.series)
config.image5d = img5d.img
if config.image5d is None:
chls, import_path = importer.setup_import_multipage(
config.filename)
import_md = importer.setup_import_metadata(chls, config.channel)
img5d = importer.import_multiplane_images(
chls, import_path, import_md, channel=config.channel)
config.image5d = img5d.img
self.assertEqual(config.image5d.shape, (1, 51, 200, 200, 2))
def test_process_whole_image(self):
_, _, blobs = stack_detect.detect_blobs_blocks(
config.filename, config.image5d, (30, 30, 8), (70, 70, 10),
config.channel)
self.assertEqual(len(blobs), 54)
if __name__ == "__main__":
unittest.main(verbosity=2)
| 30.6 | 76 | 0.661583 |
428cb80e303868ec65019df61af645e84a6106f1 | 256 | py | Python | respa_admin/views/base.py | MarkoKairinen/respa_testi | 7d7578feab1dccf619acc0edc9ede4506c6b99b1 | [
"MIT"
] | 2 | 2019-05-06T09:29:51.000Z | 2019-05-06T09:30:37.000Z | respa_admin/views/base.py | MarkoKairinen/respa_testi | 7d7578feab1dccf619acc0edc9ede4506c6b99b1 | [
"MIT"
] | 11 | 2020-06-05T20:38:50.000Z | 2022-03-11T23:47:24.000Z | respa_admin/views/base.py | MarkoKairinen/respa_testi | 7d7578feab1dccf619acc0edc9ede4506c6b99b1 | [
"MIT"
] | 1 | 2019-05-08T05:21:02.000Z | 2019-05-08T05:21:02.000Z | from django.conf import settings
class ExtraContextMixin():
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['INSTRUCTIONS_URL'] = settings.RESPA_ADMIN_INSTRUCTIONS_URL
return context
| 28.444444 | 75 | 0.722656 |
206e6f486457080b642f499c21912a8b6b8df36e | 1,794 | py | Python | nuitka/codegen/IdCodes.py | RESP3CT88/Nuitka | 0fcc25d9f00c4fc78c79a863c4b7987f573962e1 | [
"Apache-2.0"
] | 5,421 | 2018-09-24T08:04:06.000Z | 2022-03-31T20:02:37.000Z | nuitka/codegen/IdCodes.py | RESP3CT88/Nuitka | 0fcc25d9f00c4fc78c79a863c4b7987f573962e1 | [
"Apache-2.0"
] | 1,348 | 2018-09-22T13:41:00.000Z | 2022-03-31T22:33:40.000Z | nuitka/codegen/IdCodes.py | RESP3CT88/Nuitka | 0fcc25d9f00c4fc78c79a863c4b7987f573962e1 | [
"Apache-2.0"
] | 396 | 2018-09-28T15:37:03.000Z | 2022-03-29T10:52:09.000Z | # Copyright 2021, Kay Hayen, mailto:kay.hayen@gmail.com
#
# Part of "Nuitka", an optimizing Python compiler that is compatible and
# integrates with CPython, but also works on its own.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
""" Codes for id and hash
"""
from .CodeHelpers import decideConversionCheckNeeded
from .PythonAPICodes import generateCAPIObjectCode
def generateBuiltinIdCode(to_name, expression, emit, context):
generateCAPIObjectCode(
to_name=to_name,
capi="PyLong_FromVoidPtr",
arg_desc=(("id_arg", expression.subnode_value),),
may_raise=False,
conversion_check=decideConversionCheckNeeded(to_name, expression),
source_ref=expression.getCompatibleSourceReference(),
emit=emit,
context=context,
)
def generateBuiltinHashCode(to_name, expression, emit, context):
generateCAPIObjectCode(
to_name=to_name,
capi="BUILTIN_HASH",
arg_desc=(("hash_arg", expression.subnode_value),),
may_raise=expression.mayRaiseExceptionOperation(),
conversion_check=decideConversionCheckNeeded(to_name, expression),
source_ref=expression.getCompatibleSourceReference(),
emit=emit,
context=context,
)
| 35.88 | 78 | 0.712932 |
6581cc3239831b9de2c7a450d3469086d85bb937 | 4,674 | py | Python | flopy/modpath/mp7bas.py | codacy-badger/flopy | de874b02661f59ef4e99f18272883a13a4d55f16 | [
"CC0-1.0",
"BSD-3-Clause"
] | 1 | 2022-03-30T14:48:22.000Z | 2022-03-30T14:48:22.000Z | flopy/modpath/mp7bas.py | codacy-badger/flopy | de874b02661f59ef4e99f18272883a13a4d55f16 | [
"CC0-1.0",
"BSD-3-Clause"
] | null | null | null | flopy/modpath/mp7bas.py | codacy-badger/flopy | de874b02661f59ef4e99f18272883a13a4d55f16 | [
"CC0-1.0",
"BSD-3-Clause"
] | null | null | null | """
mp7bas module. Contains the Modpath7Bas class.
"""
import numpy as np
from ..pakbase import Package
from ..utils import Util2d, Util3d
class Modpath7Bas(Package):
"""
MODPATH 7 Basic Package Class.
Parameters
----------
model : model object
The model object (of type :class:`flopy.modpath.Modpath7`) to which
this package will be added.
porosity : float or array of floats (nlay, nrow, ncol)
The porosity array (the default is 0.30).
defaultiface : dict
Dictionary with keys that are the text string used by MODFLOW in
the budget output file to label flow rates for a stress package
and the values are the cell face (iface) on which to assign flows
(the default is None).
extension : str, optional
File extension (default is 'mpbas').
Examples
--------
>>> import flopy
>>> m = flopy.modflow.Modflow.load('mf2005.nam')
>>> mp = flopy.modpath.Modpath7('mf2005_mp', flowmodel=m)
>>> mpbas = flopy.modpath.Modpath7Bas(mp)
"""
def __init__(self, model, porosity=0.30, defaultiface=None,
extension='mpbas'):
"""
Package constructor.
"""
unitnumber = model.next_unit()
Package.__init__(self, model, extension, 'MPBAS', unitnumber)
shape = model.shape
if len(shape) == 3:
shape3d = shape
elif len(shape) == 2:
shape3d = (shape[0], 1, shape[1])
else:
shape3d = (1, 1, shape[0])
self.heading = '# {} package for'.format(self.name[0]) + \
' {}, '.format(model.version_types[model.version]) + \
'generated by Flopy.'
if model.flowmodel.version == 'mf6':
self.laytyp = Util2d(self.parent, (shape[0],), np.int32,
model.laytyp, name='bas - laytype',
locat=self.unit_number[0])
else:
self.laytyp = Util2d(self.parent, (shape[0],), np.int32,
model.laytyp, name='bas - laytype',
locat=self.unit_number[0])
if model.flowmodel.version != 'mf6':
self.ibound = Util3d(model, shape3d, np.int32, model.ibound,
name='IBOUND', locat=self.unit_number[0])
self.porosity = Util3d(model, shape3d, np.float32, porosity,
name='POROSITY', locat=self.unit_number[0])
# validate and set defaultiface
if defaultiface is None:
defaultifacecount = 0
else:
if not isinstance(defaultiface, dict):
msg = 'defaultiface must be a dictionary with package ' + \
'name keys and values between 0 and 6'
raise ValueError(msg)
defaultifacecount = len(defaultiface.keys())
for key, value in defaultiface.items():
# check iface value
if value < 0 or value > 6:
msg = 'defaultiface for package {}'.format(key) + \
'must be between 0 and 1 ' + \
'({} specified)'.format(value)
raise ValueError(msg)
self.defaultifacecount = defaultifacecount
self.defaultiface = defaultiface
self.parent.add_package(self)
def write_file(self, check=False):
"""
Write the package file
Parameters
----------
check : boolean
Check package data for common errors. (default False)
Returns
-------
None
"""
# Open file for writing
f = open(self.fn_path, 'w')
f.write('# {}\n'.format(self.heading))
if self.parent.flowmodel.version != 'mf6':
f.write('{:g} {:g}\n'.format(self.parent.hnoflo,
self.parent.hdry))
# default IFACE
f.write('{:<20d}{}\n'.format(self.defaultifacecount,
'# DEFAULTIFACECOUNT'))
if self.defaultifacecount > 0:
for key, value in self.defaultiface.items():
f.write('{:20s}{}\n'.format(key, '# PACKAGE LABEL'))
f.write('{:<20d}{}\n'.format(value, '# DEFAULT IFACE VALUE'))
# laytyp
if self.parent.flow_version != 'mf6':
f.write(self.laytyp.string)
# ibound
if self.parent.flow_version != 'mf6':
f.write(self.ibound.get_file_entry())
# porosity
f.write(self.porosity.get_file_entry())
f.close()
| 33.385714 | 77 | 0.529525 |
c689b0fcc5c3dabb23e661f372a06f81a33cd45a | 2,910 | py | Python | base2designs/plates/plateAnn.py | sethusaim/Automatic-Number-Plate-Recognition | 8b26008f8511e52600b150157901079e0fd0ebfe | [
"MIT"
] | null | null | null | base2designs/plates/plateAnn.py | sethusaim/Automatic-Number-Plate-Recognition | 8b26008f8511e52600b150157901079e0fd0ebfe | [
"MIT"
] | null | null | null | base2designs/plates/plateAnn.py | sethusaim/Automatic-Number-Plate-Recognition | 8b26008f8511e52600b150157901079e0fd0ebfe | [
"MIT"
] | null | null | null | import os
class PlateAnn:
def scaleBB(self, box, W, H):
# scale the bounding box from the range [0, 1] to [W, H]
(startY, startX, endY, endX) = box
startX = int(startX * W)
startY = int(startY * H)
endX = int(endX * W)
endY = int(endY * H)
return startX, startY, endX, endY
def xmlStart(self, image_path, imageHeight, imageWidth, imageDepth):
imageFolder = image_path.split(os.sep)[-2]
imageFilename = image_path.split(os.sep)[-1]
pascal_voc_start = (
"<annotation>\n"
" <folder>" + imageFolder + "</folder>\n"
" <filename>" + imageFilename + "</filename>\n"
" <path>" + image_path + "</path>\n"
" <source>\n"
" <database>Unknown</database>\n"
" </source>\n"
" <size>\n"
" <width>" + str(imageWidth) + "</width>\n"
" <height>" + str(imageHeight) + "</height>\n"
" <depth>" + str(imageDepth) + "</depth>\n"
" </size>\n"
" <segmented>0</segmented>\n"
)
return pascal_voc_start
def xmlBox(self, objName, xmin, ymin, xmax, ymax):
pascal_voc_object = (
" <object>\n"
" <name>" + objName + "</name>\n"
" <pose>Unspecified</pose>\n"
" <truncated>0</truncated>\n"
" <difficult>0</difficult>\n"
" <bndbox>\n"
" <xmin>" + str(xmin) + "</xmin>\n"
" <ymin>" + str(ymin) + "</ymin>\n"
" <xmax>" + str(xmax) + "</xmax>\n"
" <ymax>" + str(ymax) + "</ymax>\n"
" </bndbox>\n"
" </object>\n"
)
return pascal_voc_object
def xmlEnd(self):
pascal_voc_end = "</annotation>\n"
return pascal_voc_end
def writeAnnFile(
self,
xmlPath,
image_path,
plateBox,
plateText,
charBoxes,
imageWidth,
imageHeight,
imageDepth,
):
# create the xml file, and write the preamble
xmlFile = open(xmlPath, "w")
xmlFile.write(self.xmlStart(image_path, imageWidth, imageHeight, imageDepth))
# add the plateBox to the xml file
left, top, right, bottom = self.scaleBB(plateBox, imageWidth, imageHeight)
xmlFile.write(self.xmlBox("plate", left, top, right, bottom))
# add the plate char boxes to the xml file
for (char, charBox) in zip(plateText, charBoxes):
# write the box info to file
left, top, right, bottom = self.scaleBB(charBox, imageWidth, imageHeight)
xmlFile.write(self.xmlBox(char.lower(), left, top, right, bottom))
# write final text to xml file and close
xmlFile.write(self.xmlEnd())
xmlFile.close()
# print("[INFO] Created: \"{}\"".format(xmlPath))
| 33.837209 | 85 | 0.516151 |
5384414c13517af2749aa1e027486e8ab06661af | 900 | py | Python | sdks/python/examples/hello-world-from-raw-yaml.py | Siebjee/argo-workflows | 1a3b87bdf8edba02ba5e5aed20f3942be1d6f46c | [
"Apache-2.0"
] | null | null | null | sdks/python/examples/hello-world-from-raw-yaml.py | Siebjee/argo-workflows | 1a3b87bdf8edba02ba5e5aed20f3942be1d6f46c | [
"Apache-2.0"
] | 3 | 2022-03-22T11:49:02.000Z | 2022-03-24T14:13:59.000Z | sdks/python/examples/hello-world-from-raw-yaml.py | Siebjee/argo-workflows | 1a3b87bdf8edba02ba5e5aed20f3942be1d6f46c | [
"Apache-2.0"
] | null | null | null | from pprint import pprint
import requests
import yaml
import openapi_client
from openapi_client.api import workflow_service_api
from openapi_client.model.io_argoproj_workflow_v1alpha1_workflow_create_request import \
IoArgoprojWorkflowV1alpha1WorkflowCreateRequest
configuration = openapi_client.Configuration(host="https://127.0.0.1:2746")
configuration.verify_ssl = False
resp = requests.get('https://raw.githubusercontent.com/argoproj/argo-workflows/master/examples/hello-world.yaml')
manifest = yaml.safe_load(resp.text)
manifest['spec']['serviceAccountName'] = 'argo'
api_client = openapi_client.ApiClient(configuration)
api_instance = workflow_service_api.WorkflowServiceApi(api_client)
api_response = api_instance.workflow_service_create_workflow(
namespace='argo',
body=IoArgoprojWorkflowV1alpha1WorkflowCreateRequest(
workflow=manifest, _check_type=False))
pprint(api_response)
| 36 | 113 | 0.844444 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.