max_stars_repo_path
stringlengths 3
269
| max_stars_repo_name
stringlengths 4
119
| max_stars_count
int64 0
191k
| id
stringlengths 1
7
| content
stringlengths 6
1.05M
| score
float64 0.23
5.13
| int_score
int64 0
5
|
|---|---|---|---|---|---|---|
mindinsight/profiler/proposer/compose_proposer.py | fapbatista/mindinsight | 0 | 12789051 | <reponame>fapbatista/mindinsight
# Copyright 2020 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""The Compose Proposals."""
from collections import OrderedDict
from mindinsight.profiler.common.log import logger
from mindinsight.profiler.common.util import get_options
from mindinsight.profiler.proposer.proposer_factory import ProposerFactory
class ComposeProposal:
"""Get the proposals from multiple different proposers."""
def __init__(self, profiling_path, device_id, type_list=None):
self.profiling_path = profiling_path
self.device_id = device_id
self.compose_proposer_type_list = type_list
# Postfix of category label, used for UI to identify the label as category label.
self.type_label_postfix = "-proposer_type_label"
def get_proposal(self, options=None):
"""
Get compose proposals.
Args:
options (dict): options for composed proposal.
- compose_proposal_result: execution results of the already running proposers.
- step_trace: include optional parameters for step trace，The dictionary key is iter_interval
used to get the analyser options for iteration interval time.
Returns:
dict, the proposals from multiple different proposers.
Examples:
>>> type_list = ['common', 'step_trace']
>>> condition = {"filter_condition": {'mode': "proc", "proc_name": "iteration_interval"}}
>>> options = {'step_trace': {"iter_interval": condition}}
>>> cp = ComposeProposal(self.profiling_dir, self.device_id, type_list)
>>> result_proposal = cp.get_proposal(options=options)
"""
logger.info("The ComposeProposal is running")
options = get_options(options)
logger.debug("The 'options' is %s", str(options))
# The flag whether to write category label.
type_label_flag = options.get("type_label_flag", True)
compose_proposal_result = OrderedDict()
logger.debug("The 'compose_proposer_type_list' is %s", str(self.compose_proposer_type_list))
for proposer_type in self.compose_proposer_type_list:
proposer = ProposerFactory.instance().get_proposer(proposer_type, self.profiling_path, self.device_id)
if proposer is None:
continue
# Write the result of proposals to option for other proposer to get.
options["compose_proposal_result"] = compose_proposal_result
result = proposer.analyze(options)
# Insert category label.
if result and type_label_flag:
proposer_type_label = proposer_type + "-type_label"
# Get the name of the category label, the default is the same as the proposer type.
type_label_name = options.get(proposer_type_label, proposer_type)
# Add postfix to category label name
type_proposal_label = type_label_name + self.type_label_postfix
compose_proposal_result[type_proposal_label] = None
# Merge results to the proposals dictionary.
compose_proposal_result.update(result)
elif result and not type_label_flag:
# Merge results to the proposals dictionary.
compose_proposal_result.update(result)
logger.debug("The 'compose_proposal_result' is %s", str(compose_proposal_result))
return compose_proposal_result
| 1.828125 | 2 |
10.68. Reversed.py | kyumiouchi/python-basic-to-advanced | 0 | 12789052 | <reponame>kyumiouchi/python-basic-to-advanced
"""
Reversed
OBS: It is different from reverse() from list => the function reverse() just work with
list and reversed() with any iterable.
"""
list_number = [1, 2, 3, 4, 5]
result = reversed(list_number)
print(result) # <list_reverseiterator object at 0x0000029BC4B12FD0>
print(type(result)) # <class 'list_reverseiterator'>
# Convert List, Tuple and Set
# List
print(list(reversed(list_number))) # [5, 4, 3, 2, 1]
# Tuple
print(tuple(reversed(list_number))) # (5, 4, 3, 2, 1)
# Set
print(set(reversed(list_number))) # {1, 2, 3, 4, 5} # not define order of the elements
for character in reversed('Geek University'): # ytisrevinU keeG
print(character, end='')
print('\n')
print(''.join(list(reversed('Geek University')))) # ytisrevinU keeG
# the same as slice of strings
print('Yumi Ouchi'[::-1]) # ihcuO imuY
# reversed() to loop reversed
for item in reversed(range(0, 10)): # 9876543210
print(item, end='')
print('\n')
# range does too
for item in range(9, -1, -1): # 9876543210
print(item, end='')
| 4.5625 | 5 |
apps/landing/models.py | pythonvietnam/nms | 19 | 12789053 | <reponame>pythonvietnam/nms
from django.db import models
from apps.base.models import Timestampable
# Create your models here.
class Landing(Timestampable):
email = models.EmailField(blank=False, max_length=255, unique=True)
class Meta:
db_table = 'landing'
def __str__(self):
return self.email
| 2.546875 | 3 |
functionality/kmeans_cluster_ijcai18_4_203.py | neerbek/taboo-selective | 0 | 12789054 | # -*- coding: utf-8 -*-
"""
Created on January 24, 2018
@author: neerbek
"""
# -*- coding: utf-8 -*-
import os
os.chdir("../../taboo-core")
from numpy.random import RandomState # type: ignore
from sklearn.cluster import KMeans # type: ignore
import ai_util
import confusion_matrix
import kmeans_cluster_util as kutil
import similarity.load_trees as load_trees
# import pylab # type: ignore
import matplotlib.pyplot as plt
import importlib
# importlib.reload(kutil)
importlib.reload(confusion_matrix)
# for information type 203
#
#
# run rnn on data (very low emb size)
# OMP_NUM_THREADS=3 ipython3 functionality/train_model.py -- -traintrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$test.txt -validtrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$dev.txt -testtrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$test.txt -nx 50 -nh 20 -lr 0.5 -L1_reg 0 -L2_reg 0 -n_epochs -1 -retain_probability 1 -batch_size 90 -valid_batch_size 300 -glove_path ../code/glove/ -train_report_frequency 445/5 -validation_frequency 445 -file_prefix save_exp164
# Epoch 114. On validation set: Best (110, 1.065507, 77.4675%)
# OMP_NUM_THREADS=2 ipython3 functionality/run_model_verbose.py -- -inputtrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$train.txt -nx 50 -nh 20 -L1_reg 0 -L2_reg 0 -retain_probability 1 -batch_size 90 -glove_path ../code/glove/ -inputmodel ../taboo-jan/functionality/logs/exp164_epoch480.zip\$save_exp164_best.txt -output_embeddings -max_tree_count 100 -max_count 100 -max_embedding_count 10000
#
# for realz
# OMP_NUM_THREADS=2 ipython3 functionality/run_model_verbose.py -- -inputtrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$train.txt -nx 50 -nh 20 -L1_reg 0 -L2_reg 0 -retain_probability 1 -batch_size 90 -glove_path ../code/glove/ -inputmodel ../taboo-jan/functionality/logs/exp164_epoch480.zip\$save_exp164_best.txt -output_embeddings > train.txt
# OMP_NUM_THREADS=2 ipython3 functionality/run_model_verbose.py -- -inputtrees ../taboo-jan/functionality/203/data_full_random_cleaned.zip\$dev.txt -nx 50 -nh 20 -L1_reg 0 -L2_reg 0 -retain_probability 1 -batch_size 90 -glove_path ../code/glove/ -inputmodel ../taboo-jan/functionality/logs/exp164_epoch480.zip\$save_exp164_best.txt -output_embeddings > dev.txt
#
# zip output_embeddings_exp164_e480.zip train.txt dev.txt
# rm train.txt dev.txt
# mv output_embeddings_exp164_e480.zip output
# don't add to git (for now), we should make a backup
totaltimer = ai_util.Timer("Total time: ")
traintimer = ai_util.Timer("Train time: ")
totaltimer.begin()
inputfileTrain = "output/output_embeddings_exp164_e120.zip$train.txt"
inputfileTrain = "output/output_embeddings_exp164_e480.zip$train.txt"
linesTrainFull = confusion_matrix.read_embeddings(inputfileTrain, max_line_count=-1)
linesTrain = [linesTrainFull[i] for i in range(60000)]
inputfileDev = "output/output_embeddings_exp164_e120.zip$dev.txt"
inputfileDev = "output/output_embeddings_exp164_e480.zip$dev.txt"
linesDev = confusion_matrix.read_embeddings(inputfileDev, max_line_count=-1)
numberOfClusters = 35
randomSeed = 7485
doShow = True
low = 3 # 03
high = 22 # 16 not good
rng = RandomState(randomSeed)
aTrain = confusion_matrix.get_embedding_matrix(linesTrain, normalize=True)
aTrainFull = confusion_matrix.get_embedding_matrix(linesTrainFull, normalize=True)
aDev = confusion_matrix.get_embedding_matrix(linesDev, normalize=True)
kmeans = KMeans(n_clusters=numberOfClusters, random_state=rng).fit(aTrain)
# kmeans = KMeans(n_clusters=numberOfClusters, random_state=rng).fit(aTrainFull)
# kmeans = KMeans(n_clusters=numberOfClusters, random_state=rng).fit(aDev)
# sort_order = kutil.get_cluster_sen_ratios_sort_order(aTrainFull, linesTrainFull, kmeans)
sort_order = kutil.get_cluster_sen_ratios_sort_order(aTrain, linesTrain, kmeans)
show = kutil.SHOW_ALL
if doShow:
# plot
y1 = kutil.get_cluster_sen_ratios(aTrain, linesTrain, kmeans, sort_order)
y2 = kutil.getScaledSizes(aTrain, kmeans, sort_order)
# y1 = kutil.get_cluster_sen_ratios(aTrainFull, linesTrainFull, kmeans, sort_order)
# y2 = getScaledSizes(aTrainFull, kmeans, sort_order)
# y3 = kutil.get_cluster_sen_ratios(aDev, linesDev, kmeans, sort_order)
# y4 = getScaledSizes(aDev, kmeans, sort_order)
x = kutil.getXRange(show, low, high, numberOfClusters)
y1 = [y1[i] for i in x]
y2 = [y2[i] for i in x]
# y3 = [y3[i] for i in x]
# y4 = [y4[i] for i in x]
confusion_matrix.new_graph('Clusters', 'Ratio')
plt.plot(x, y1, 'k-', label='Sensitivity')
plt.plot(x, y2, 'k+', label='Accumulate size')
# plt.plot(x, y3, 'b-', label='Sensitivity Dev')
# plt.plot(x, y4, 'b+', label='Accumulate size Dev')
if show == kutil.SHOW_ALL:
# plt.plot((low, low), (0, 1), 'k-')
plt.plot((high, high), (0, 1), 'k:')
plt.legend()
plt.savefig('ijcai18_plot_sensitive_sorted_203.eps')
# plt.savefig('tmp.eps')
# plt.show() don't call show from an interactive prompt :(
# https://github.com/matplotlib/matplotlib/issues/8505/
clusterIds = sort_order # clusterIds == sort_order, it's just syntaxtic sugar
(linesC1, aC1) = kutil.get_sentences_from_clusters(clusterIds[:high], linesTrainFull, aTrainFull, kmeans)
(linesC2, aC2) = kutil.get_sentences_from_clusters(clusterIds[high:], linesTrainFull, aTrainFull, kmeans)
(lines2C1, a2C1) = kutil.get_sentences_from_clusters(clusterIds[:high], linesDev, aDev, kmeans)
(lines2C2, a2C2) = kutil.get_sentences_from_clusters(clusterIds[high:], linesDev, aDev, kmeans)
print(len(linesC1), len(linesC2))
print(len(lines2C1), len(lines2C2))
# after some iterations (unknown random seed)
# 78442 45824
# 17034 9966 (27000)
kutil.get_base_accuracy(linesC1, "train C1").report()
kutil.get_base_accuracy(linesC2, "train C2").report()
# if we want to validation score
kutil.get_base_accuracy(lines2C1, "dev C1").report()
kutil.get_base_accuracy(lines2C2, "dev C2").report()
# don't know if these values are updated!
# Accuracy (train C1): 0.9432 (0.6436), f1=0.9179 (24901 1398 49089 3054)
# Accuracy (train C2): 0.9871 (0.0128), f1=0.9935 (45224 579 8 13)
# Accuracy (dev C1): 0.9304 (0.6318), f1=0.9023 (5470 383 10379 802)
# Accuracy (dev C2): 0.9832 (0.0167), f1=0.9915 (9796 163 3 4)
| 1.75 | 2 |
Libraries/warshallfloyd.py | tonko2/AtCoder | 2 | 12789055 | <filename>Libraries/warshallfloyd.py
N = 10
cost = [[float('inf')] * N] * N
for k in range(N):
for i in range(N):
for j in range(N):
if cost[i][k] != float('inf') and cost[k][j] != float('inf'):
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])
| 3.171875 | 3 |
CodeUP/Python basic 100/6047.py | cmsong111/NJ_code | 0 | 12789056 | <gh_stars>0
import math
a,b = map(int,input().split())
c=pow(2,b)
print(a*c) | 2.875 | 3 |
scraper.py | wind1s/proxyscraper | 0 | 12789057 | """
* Copyright (c) 2022, <NAME> <<EMAIL>>
*
* SPDX-License-Identifier: BSD-2-Clause
Compiles a database of proxy servers with their respective metadata.
Links:
https://geonode.com/free-proxy-list
https://proxylist.geonode.com/api/proxy-list?limit=1000&page=1
Custom proxy key value pair:
key = ip (192.168.127.12)
value = (this dict)
{
"port":
"anonymityLevel":
"protocols": [list of supported protocols]
"google": (true or false if google approved proxy)
"org": [list of all orgs and asn]
"latency":
"responseTime":
"upTime":
"upTimeTryCount":
"created_at":
"updated_at":
"hostname":
"city":
"region":
"postal":
"country":
"timezone":
"loc":
"corruptionindex":
"entry_time":
}
"""
from typing import Iterable, Any
from math import ceil
from datetime import timedelta
from json import loads
from aiohttp import ClientSession
from ipinfo import create_ip_info_parser
from asynchttprequest import AsyncRequest, run_async_requests, ParseRequest
from database import Database
from curlget import curl_get_json
from requestlogging import log_request, get_default_logger, log_db_entry_status
from utility import try_get_key, extract_keys, str_join
from config import IP_DB_NAME, PROXY_DB_NAME
PROXYLIST_RESPONSE_KEYS = (
"anonymityLevel",
"protocols",
"google",
"org",
"speed",
"latency",
"responseTime",
"upTime",
"upTimeTryCount",
"created_at",
"updated_at",
)
def forge_proxy_entry(ip_info: dict[str, str], proxylist: dict[str, str]) -> dict[str, Any]:
"""
Creates the custom database entry for a proxies data.
"""
db_entry = {**extract_keys(proxylist, PROXYLIST_RESPONSE_KEYS), **ip_info}
# Creates string of all possible ip origin names.
db_entry["org"] = ";".join(
origin
for origin in (
try_get_key("org", ip_info),
try_get_key("asn", proxylist),
try_get_key("org", proxylist),
try_get_key("isp", proxylist),
)
if origin is not None
)
db_entry["created_at"].replace("T", " ").replace("Z", "")
db_entry["updated_at"].replace("T", " ").replace("Z", "")
# db_entry["corruptionindex"] = get_corruption_index(ip_info["country"])
return db_entry
def create_proxy_data_parser(
proxy_db: Database, ip_db: Database, proxy_expire_time: timedelta, ip_expire_time: timedelta
) -> ParseRequest:
parse_ip_info = create_ip_info_parser(ip_db, ip_expire_time)
async def parse_proxy_data(session: ClientSession, proxy_data: dict[str, str]) -> None:
"""
Retrieves and stores a proxies data, including it's ip address data separetly.
"""
ip_address = proxy_data["ip"]
await parse_ip_info(session, ip_address)
ip_and_port = f"{ip_address}:{proxy_data['port']}"
if proxy_db.key_expired(ip_and_port, proxy_expire_time):
ip_info = ip_db.get(ip_address)
db_entry = forge_proxy_entry(ip_info, proxy_data)
proxy_db.store_entry(ip_and_port, db_entry)
return parse_proxy_data
def fetch_proxylist(page_limit: int, request_limit: int) -> Iterable[dict[str, str]]:
"""
Asynchronosly requests a list of proxies from proxylist.geonode.com.
"""
base_url = "https://proxylist.geonode.com"
api_ref_template = "/api/proxy-list?limit={}&page={{}}"
proxylist_api_template = api_ref_template.format(page_limit)
single_proxy_query_url = str_join(base_url, api_ref_template.format(1, 1))
log = get_default_logger()
request = AsyncRequest("GET", "", headers={"Accept": "application/json"})
responses = []
def fetch_page_range():
# Get the range of page numbers to use for requesting all proxies
# currently available from the api.
response = curl_get_json(single_proxy_query_url)
if response is None:
log.error("Could not fetch proxy count from %s", single_proxy_query_url)
return range(0)
proxy_count = response["total"]
request_count = ceil(proxy_count / page_limit)
return range(1, request_count + 1)
async def proxylist_request(session: ClientSession, page_number: int):
request.url = proxylist_api_template.format(page_number)
resp = await log_request(request, session)
# If response is none, an error occurred and the fetch could not be made.
if resp is None:
log.warning("Could not fetch proxylist from %s", request.url)
return
# Response contains a key data with all the proxies data.
proxylist_data = loads(resp)["data"]
log.info("Fetched %d proxies from page %d", len(proxylist_data), page_number)
responses.append(proxylist_data)
run_async_requests(
fetch_page_range(), proxylist_request, base_url=base_url, limit=request_limit
)
# Each request contains a data key which holds the proxy list.
return (proxy_data for proxylist in responses for proxy_data in proxylist)
def proxy_scraper(
proxy_db: Database,
ip_db: Database,
proxy_expire_time: timedelta,
ip_expire_time: timedelta,
limit: int,
):
proxylist = fetch_proxylist(100, limit)
prev_proxy_db_count = proxy_db.get_count()
prev_ip_db_count = ip_db.get_count()
run_async_requests(
proxylist,
create_proxy_data_parser(proxy_db, ip_db, proxy_expire_time, ip_expire_time),
limit=limit,
)
# Log new ip and proxies entries.
new_proxies_count = proxy_db.get_count() - prev_proxy_db_count
new_ips_count = ip_db.get_count() - prev_ip_db_count
log_db_entry_status(new_proxies_count, PROXY_DB_NAME)
log_db_entry_status(new_ips_count, IP_DB_NAME)
| 2.046875 | 2 |
lldb/test/API/tools/lldb-server/TestGdbRemoteProcessInfo.py | mkinsner/llvm | 2,338 | 12789058 | import gdbremote_testcase
import lldbgdbserverutils
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
def test_qProcessInfo_returns_running_process(self):
self.build()
procs = self.prep_debug_monitor_and_inferior()
self.add_process_info_collection_packets()
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Ensure the process id looks reasonable.
pid_text = process_info.get("pid")
self.assertIsNotNone(pid_text)
pid = int(pid_text, base=16)
self.assertNotEqual(0, pid)
# If possible, verify that the process is running.
self.assertTrue(lldbgdbserverutils.process_is_running(pid, True))
def test_attach_commandline_qProcessInfo_reports_correct_pid(self):
self.build()
self.set_inferior_startup_attach()
procs = self.prep_debug_monitor_and_inferior()
self.assertIsNotNone(procs)
self.add_process_info_collection_packets()
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Ensure the process id matches what we expected.
pid_text = process_info.get('pid', None)
self.assertIsNotNone(pid_text)
reported_pid = int(pid_text, base=16)
self.assertEqual(reported_pid, procs["inferior"].pid)
def test_qProcessInfo_reports_valid_endian(self):
self.build()
procs = self.prep_debug_monitor_and_inferior()
self.add_process_info_collection_packets()
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Ensure the process id looks reasonable.
endian = process_info.get("endian")
self.assertIsNotNone(endian)
self.assertIn(endian, ["little", "big", "pdp"])
def qProcessInfo_contains_keys(self, expected_key_set):
procs = self.prep_debug_monitor_and_inferior()
self.add_process_info_collection_packets()
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Ensure the expected keys are present and non-None within the process
# info.
missing_key_set = set()
for expected_key in expected_key_set:
if expected_key not in process_info:
missing_key_set.add(expected_key)
self.assertEqual(
missing_key_set,
set(),
"the listed keys are missing in the qProcessInfo result")
def qProcessInfo_does_not_contain_keys(self, absent_key_set):
procs = self.prep_debug_monitor_and_inferior()
self.add_process_info_collection_packets()
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Ensure the unexpected keys are not present
unexpected_key_set = set()
for unexpected_key in absent_key_set:
if unexpected_key in process_info:
unexpected_key_set.add(unexpected_key)
self.assertEqual(
unexpected_key_set,
set(),
"the listed keys were present but unexpected in qProcessInfo result")
@add_test_categories(["debugserver"])
def test_qProcessInfo_contains_cputype_cpusubtype(self):
self.build()
self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype']))
@add_test_categories(["llgs"])
def test_qProcessInfo_contains_triple_ppid(self):
self.build()
self.qProcessInfo_contains_keys(set(['triple', 'parent-pid']))
@add_test_categories(["debugserver"])
def test_qProcessInfo_does_not_contain_triple(self):
self.build()
# We don't expect to see triple on darwin. If we do, we'll prefer triple
# to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
# for the remote Host and Process.
self.qProcessInfo_does_not_contain_keys(set(['triple']))
@add_test_categories(["llgs"])
def test_qProcessInfo_does_not_contain_cputype_cpusubtype(self):
self.build()
self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))
| 1.976563 | 2 |
defuzzyfikasi.py | cahyoardhi/fuzzy-algorithm | 3 | 12789059 | def fdefuzzyfikasi(inputan):
for k,v in inputan.items():
if k == 'kecil':
kecil = v
else:
besar = v
tempbesar = 0
tempkecil = 0
x = 0
y = 0
for i in range(20,90,7):
if i <= 60:
tempkecil += i
x += 1
else:
tempbesar += i
y += 1
x -=1
return ((tempkecil * kecil) + (tempbesar * besar)) / ((kecil * x) + (besar * y))
#((27+34+41+48+55)*0.2 + (62+69+76+83+90)*0.5) / ((0.5)*5 + (0.2)*5) kasus 1
#((45 + 50 + 55) * 0.75 + (60+65+70+75+80+85+90) * 0.25 / ((0.75)*3) + (0.25)*7)) kasus 2 | 2.9375 | 3 |
giftest.py | TimothyBergstrom/Zergy | 0 | 12789060 | import tkinter as tk
from Gifhandler import *
#Main window
top=tk.Tk()
#Icon
top.iconbitmap('gifs/zergyicon.ico')
#Setting color
top.configure(background='gold')
#Title
top.title('Zergy')
#Fixing picture canvas (will load later)
topcanvas=tk.Canvas(top,width=250,height=250,background='gold')
topcanvas.pack()
#Open gif
mainanimation=Gifhandler(top,topcanvas,'gifs/zergysmall.gif',40)
def runwaitgif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/zergysmall.gif',40)
mainanimation.animate()
def runbuggif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/bug.gif',30)
mainanimation.animate_noloop()
def runtraingif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/train.gif',100)
mainanimation.animate()
def rungotitgif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/gotit.gif',30,200,130)
mainanimation.animate_noloop()
def runboomgif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/boom.gif',40,200,130)
mainanimation.animate()
def runburrowgif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/burrow.gif',30,100,130)
mainanimation.animate()
def runmorechasegif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/morechase.gif',30,100,130)
mainanimation.animate()
def runjumpinggif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/jumping.gif',40,100,130)
mainanimation.animate()
def runannoyinggif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/annoying.gif',30,-45,130)
mainanimation.animate()
def runcutegif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/cute.gif',30,140,150)
mainanimation.animate()
def runchasegif():
global topcanvas, mainanimation
mainanimation.stop_animation()
mainanimation=Gifhandler(top,topcanvas,'gifs/chase.gif',30,50,130)
mainanimation.animate()
gifname=input('gif: ')
vars()['run'+gifname+'gif']()
top.mainloop()
| 2.84375 | 3 |
elastic/elastic_driver.py | HungThinhPhung/Miscellaneous | 0 | 12789061 | import json
import pickle
import requests
from elastic.using_requests import get_gov
demo_tax_codes = pickle.load(open('error.p', 'rb'))
host = 'http://0.0.0.0:9201'
host = 'http://10.0.6.21:30152'
e_index = 'index'
e_index = 'sme_autocomplete_index_2'
e_type = 'sme_autocomplete_type'
default_link = host + '/' + e_index + '/' + e_type + '/'
def get(tax_code):
link = 'http://10.0.6.21:30152/sme_autocomplete_index/sme_autocomplete_type/_search?q=taxCode:' + tax_code + '&size=1'
response = requests.get(link)
response = json.loads(response.content.decode('utf-8'))
return response['hits']['hits'][0] if not len(response['hits']['hits']) == 0 else {}
def add_doc(data):
json_sent = data['_source']
link = 'http://0.0.0.0:9201/' + data['_index'] + '/' + data['_type'] + '/' + json_sent['taxCode']
response = requests.put(link, json=json_sent)
print()
def get_tax_codes(start_uid=0, size=10):
query_data = {"size": size, "_source": ["taxCode", "tax_code"], "query": {"match_all": {}},
"search_after": [start_uid],
"sort": [
{"_uid": "asc"}
]}
url = default_link + '_search'
response = requests.post(url=url, json=query_data)
response_data = json.loads(response.content.decode('utf-8'))
return response_data['hits']['hits']
def update(id, d):
link = default_link + id + '/_update'
script = {
"script": "ctx._source.remove('eng_name'); "
"ctx._source.remove('short_name');"
"ctx._source.remove('tax_code');"
"ctx._source.remove('name');"
"ctx._source.remove('active_status');"
"ctx._source.remove('enterprise_type');"
"ctx._source.remove('founding_date');"
"ctx._source.remove('legal_representative');"
"ctx._source.owner='" + d['legal_representative'] + "';"
"ctx._source.address='" + d['address'] + "';"
"ctx._source.engName='" + d[
'eng_name'] + "';"
"ctx._source.shortName='" + d['short_name'] + "';"
"ctx._source.taxCode='" + d['tax_code'] + "';"
"ctx._source.companyName='" +
d['name'] + "';"
"ctx._source.activeStatus='" + d['active_status'] + "';"
"ctx._source.enterpriceType='" + d['enterprise_type'] + "';"
"ctx._source.foundedDate='" +
d['founding_date'] + "';"
"ctx._source.verify=1;"
}
response = requests.post(link, json=script)
if not response.status_code == 200:
print()
def main():
tax_codes = get_tax_codes()
while not len(tax_codes) == 0:
for code in tax_codes:
if len(code['_source']) == 0:
tax_code = code['_id']
else:
tax_code = code['_source']['taxCode'] if 'taxCode' in code['_source'] else code['_source']['tax_code']
print('Id: ' + code['_id'] + ', taxCode: ' + tax_code)
data = get_gov(tax_code, False)
if len(data) == 0:
print('Error')
continue
update(code['_id'], data)
last_code = tax_codes[-1]
tax_codes = get_tax_codes(start_uid=last_code['_type'] + '#' + last_code['_id'])
if __name__ == '__main__':
# for code in demo_tax_codes:
# data = get(code)
# if data == {}:
# continue
# add_doc(data)
main()
| 2.640625 | 3 |
test/test/pytools/viz/dendrogram/test_dendrogram.py | BCG-Gamma/pytools | 17 | 12789062 | """
Tests for package pytools.viz.dendrogram
"""
# noinspection PyPackageRequirements
import hashlib
import logging
from io import StringIO
import numpy as np
# noinspection PyPackageRequirements
import pytest
# noinspection PyPackageRequirements
import scipy.cluster.hierarchy as hc
from pytools.viz.dendrogram import DendrogramDrawer, DendrogramReportStyle, LinkageTree
log = logging.getLogger(__name__)
@pytest.fixture
def linkage_matrix() -> np.ndarray:
"""Create a linkage matrix."""
x = np.array([[i] for i in [2, 8, 0, 4, 1, 9, 9, 0]])
return hc.linkage(x)
@pytest.fixture
def linkage_tree(linkage_matrix: np.ndarray) -> LinkageTree:
"""Create a linkage tree for drawing tests."""
return LinkageTree(
scipy_linkage_matrix=linkage_matrix,
leaf_names=list("ABCDEFGH"),
leaf_weights=[(w + 1) / 36 for w in range(8)],
)
def test_dendrogram_drawer_text(linkage_matrix: np.ndarray) -> None:
checksum_dendrogram_report = "32427095857f0589f68210ad4b2e8210"
leaf_names = list("ABCDEFGH")
leaf_weights = [(w + 1) / 36 for w in range(8)]
with pytest.raises(ValueError) as value_error:
LinkageTree(
scipy_linkage_matrix=linkage_matrix,
leaf_names=leaf_names,
leaf_weights=leaf_weights,
max_distance=1,
)
assert value_error.value.args == (
"arg max_distance=1 must be equal to or greater than the maximum distance "
"(= 4.0) in the linkage tree",
)
linkage_tree = LinkageTree(
scipy_linkage_matrix=linkage_matrix,
leaf_names=leaf_names,
leaf_weights=[(w + 1) / 36 for w in range(8)],
distance_label="distance",
leaf_label="label",
weight_label="weight",
)
with StringIO() as out:
dd = DendrogramDrawer(style=DendrogramReportStyle(out=out))
dd.draw(data=linkage_tree, title="Test")
report_str = str(out.getvalue())
log.debug(f"\n{report_str}")
assert (
hashlib.md5(str(report_str).encode("utf-8")).hexdigest()
) == checksum_dendrogram_report
| 2.46875 | 2 |
tasks/tests/tasknamefilter_test.py | kemmot/PyTasks | 0 | 12789063 | <reponame>kemmot/PyTasks
import unittest
import unittest.mock as mock
import filters.tasknamefilter as tasknamefilter
class TaskNameFilterTests(unittest.TestCase):
def test_constructor_sets_name(self):
target = tasknamefilter.TaskNameFilter(mock.Mock(), 'test')
self.assertEqual('test', target.name)
def test_is_match_returns_true_on_matching_name(self):
mock_context = mock.Mock()
task = mock.Mock()
task.name = 'test'
self.assertTrue(tasknamefilter.TaskNameFilter(mock_context, 'test').is_match(task))
def test_is_match_returns_false_on_non_matching_index(self):
mock_context = mock.Mock()
task = mock.Mock()
task.name = 'woble'
self.assertFalse(tasknamefilter.TaskNameFilter(mock_context, 'test').is_match(task))
def test_is_match_returns_true_when_name_contains_same_case(self):
mock_context = mock.Mock()
task = mock.Mock()
task.name = 'onetesttwo'
self.assertTrue(tasknamefilter.TaskNameFilter(mock_context, 'test').is_match(task))
def test_is_match_returns_true_when_name_contains_different_case(self):
mock_context = mock.Mock()
task = mock.Mock()
task.name = 'oneTESTtwo'
self.assertTrue(tasknamefilter.TaskNameFilter(mock_context, 'test').is_match(task))
class TaskNameFilterParserTests(unittest.TestCase):
def test_parse_none_returns_none(self):
mock_context = mock.Mock()
target = tasknamefilter.TaskNameFilterParser().parse(mock_context, None)
self.assertIsNone(target)
def test_parse_empty_string_returns_none(self):
mock_context = mock.Mock()
target = tasknamefilter.TaskNameFilterParser().parse(mock_context, '')
self.assertIsNone(target)
def test_parse_non_empty_string_returns_filter(self):
mock_context = mock.Mock()
target = tasknamefilter.TaskNameFilterParser().parse(mock_context, 'test')
self.assertIsInstance(target, tasknamefilter.TaskNameFilter)
self.assertEqual('test', target.name)
def test_parse_strips_forward_slashes(self):
mock_context = mock.Mock()
target = tasknamefilter.TaskNameFilterParser().parse(mock_context, '/test/')
self.assertIsInstance(target, tasknamefilter.TaskNameFilter)
self.assertEqual('test', target.name)
| 2.8125 | 3 |
astar_spark/SP_ASTAR version1/graph.py | adoni91/HGraphProject | 0 | 12789064 | from node import *
from nodeitem import *
from math import sqrt, pow
import time
class Graph:
def __init__(self, node=[]):
self.node=node
def createNodeProperty(self, line):
return [int(line.split()[0]), int(line.split()[1])]
def createEdgeProperty(self, line):
return [int(line.split()[0]), [int(line.split()[1]), int(line.split()[2])]]
def getSucessorProperty(self,rdd):
rdd2 = list()
for values in rdd.__iter__():
rdd2.append([values[0],values[1]])
rdd2.sort()
return rdd2
#transform line into key-value pair
def lineToNode(self, line):
key=line[0]
value=line[1]
return Node(key, value)
# return the transition fuction value of a state x. QxW->Q
def getG(self, succesor):
return succesor[1]
# Euclidean distance between the state s1 and s2
def getEuclideanDistance(self, target1, target2):
return sqrt(pow(target2 - target1, 2)) #+ random.random() * 0.1
#Return the neighboard of the current state
def searchNeighboardOfNode(self, current_node, goal_node, open_list):
for next_sucessor in current_node.get_succesors():
G = self.getG(next_sucessor)
H = self.getEuclideanDistance(goal_node.get_targetID(), current_node.get_targetID())
node_item = Nodeitem(next_sucessor[0], G, H, current_node.get_targetID())
open_list.append(node_item)
#Return the most promising state
def getMinOpenListNode(self, open_list, goal_node):
min_f = open_list[0].get_f()
selected_item = open_list[0]
for i in range(1, len(open_list)):
if open_list[i].get_f() <= min_f:
min_f = open_list[i].get_f()
selected_item = open_list[i]
if open_list[i].get_targetID() == goal_node.get_targetID():
selected_item = open_list[i]
break
return selected_item
# Return the new current node
def searchNewCurrentNode(self, node_list, targetID):
current_node = Node()
for node in node_list:
if node.get_targetID() == targetID:
current_node = node
break
return current_node
# Return sequence from the close list
def extractSequenceFromCloseList(self, close_list):
inter_close_list = []
path = []
size = len(close_list)
for i in range(1, size):
if close_list[i].get_idpreviousnode() == close_list[i - 1].get_idpreviousnode():
inter_close_list.append(close_list[i - 1])
for item in inter_close_list:
close_list.remove(item)
for item in close_list:
sequence = item.get_idpreviousnode(), item.get_targetID()
path.append(sequence)
return path
# return the id of boundary nodes
def getBoundaryNodesId(self, rdd, numberPartition):
nodes_id = []
all_rdd_parts=rdd.glom().collect()
for i in range(1, numberPartition):
nodes_id.append(all_rdd_parts[i][0].get_targetID())
return nodes_id
# compute intermediate path
def A_Star_Mapper(self, rdd_part):
intermediate_open_list=[]
intermediate_close_list=[]
node_list_rdd_part= list(rdd_part.__iter__())
intermediate_init_node=node_list_rdd_part.__getitem__(0)
intermediate_goal_node=node_list_rdd_part.__getitem__(len(node_list_rdd_part)-1)
current_node = intermediate_init_node
while current_node.get_targetID() != intermediate_goal_node.get_targetID():
self.searchNeighboardOfNode(current_node, intermediate_goal_node, intermediate_open_list)
selected_item=self.getMinOpenListNode(intermediate_open_list, intermediate_goal_node)
intermediate_open_list.remove(selected_item)
intermediate_close_list.append(selected_item)
current_node = self.searchNewCurrentNode(node_list_rdd_part, selected_item.get_targetID())
intermediate_path=self.extractSequenceFromCloseList(intermediate_close_list)
return intermediate_path
| 2.859375 | 3 |
app/viewer/__init__.py | Dbrown411/py-oct | 0 | 12789065 | from .viewer_panels import * | 1.1875 | 1 |
scripts/2e_gen_direct_ac3d.py | skywalkerisnull/ImageAnalysis | 0 | 12789066 | #!/usr/bin/python3
import sys
#sys.path.insert(0, "/usr/local/opencv3/lib/python2.7/site-packages/")
import argparse
#import commands
import cv2
import fnmatch
import numpy as np
import os.path
import random
import navpy
sys.path.append('../lib')
import AC3D
import Pose
import ProjectMgr
import SRTM
import transformations
# for all the images in the project image_dir, compute the camera
# poses from the aircraft pose (and camera mounting transform).
# Project the image plane onto an SRTM (DEM) surface for our best
# layout guess (at this point before we do any matching/bundle
# adjustment work.)
parser = argparse.ArgumentParser(description='Set the initial camera poses.')
parser.add_argument('--project', required=True, help='project directory')
parser.add_argument('--texture-resolution', type=int, default=512, help='texture resolution (should be 2**n, so numbers like 256, 512, 1024, etc.')
parser.add_argument('--ground', type=float, help='ground elevation in meters')
parser.add_argument('--sba', action='store_true', help='use sba pose')
args = parser.parse_args()
proj = ProjectMgr.ProjectMgr(args.project)
proj.load_image_info()
ref = proj.ned_reference_lla
# setup SRTM ground interpolator
sss = SRTM.NEDGround( ref, 6000, 6000, 30 )
ac3d_steps = 8
# compute the uv grid for each image and project each point out into
# ned space, then intersect each vector with the srtm ground.
# build our local image list for placing
print(args.sba)
if not args.sba:
image_list = proj.image_list
else:
image_list = []
for image in proj.image_list:
if image.camera_pose_sba != None:
#print image.camera_pose_sba
image_list.append(image)
depth = 0.0
camw, camh = proj.cam.get_image_params()
for image in image_list:
print(image.name)
# scale the K matrix if we have scaled the images
scale = float(image.width) / float(camw)
K = proj.cam.get_K(scale)
IK = np.linalg.inv(K)
grid_list = []
u_list = np.linspace(0, image.width, ac3d_steps + 1)
v_list = np.linspace(0, image.height, ac3d_steps + 1)
#print "u_list:", u_list
#print "v_list:", v_list
for v in v_list:
for u in u_list:
grid_list.append( [u, v] )
print('grid_list:', grid_list)
if not args.sba:
proj_list = proj.projectVectors( IK, image.get_body2ned(),
image.get_cam2body(), grid_list )
else:
print(image.get_body2ned_sba())
proj_list = proj.projectVectors( IK, image.get_body2ned_sba(),
image.get_cam2body(), grid_list )
print('proj_list:', proj_list)
if not args.sba:
ned = image.camera_pose['ned']
else:
ned = image.camera_pose_sba['ned']
print('ned', image.camera_pose['ned'], ned)
if args.ground:
pts_ned = proj.intersectVectorsWithGroundPlane(ned,
args.ground, proj_list)
else:
pts_ned = sss.interpolate_vectors(ned, proj_list)
print("pts_3d (ned):\n", pts_ned)
# convert ned to xyz and stash the result for each image
image.grid_list = []
ground_sum = 0
for p in pts_ned:
image.grid_list.append( [p[1], p[0], -(p[2]+depth)] )
ground_sum += -p[2]
depth -= 0.01 # favor last pictures above earlier ones
# call the ac3d generator
AC3D.generate(image_list, src_dir=proj.source_dir,
project_dir=args.project, base_name='direct',
version=1.0, trans=0.1, resolution=args.texture_resolution)
if not args.ground:
print('Avg ground elevation (SRTM):', ground_sum / len(pts_ned))
| 2.3125 | 2 |
focuser.py | chripell/yaaca | 1 | 12789067 | <gh_stars>1-10
from astropy.stats import sigma_clipped_stats
from photutils import DAOStarFinder, IRAFStarFinder
from collections import namedtuple
import numpy as np
FocusData = namedtuple('FocusData', 'bot p10 mean p90 top std back back_std')
class Focuser:
def __init__(self, fwhm=3.0, threshold_stds=100., algo='iraf'):
self.sources = None
self.n = 0
self.par = {}
self.fwhm = fwhm
self.threshold_stds = threshold_stds
self.algo = algo
if self.algo == 'dao':
self.odata = ("sharpness", "roundness1", "roundness2")
else:
self.odata = ("sharpness",)
def evaluate(self, data):
mean, median, std = sigma_clipped_stats(data, sigma=3.0, maxiters=5)
self.back = median
self.back_std = std
if self.algo == 'dao':
finder = DAOStarFinder(
fwhm=self.fwhm, threshold=self.threshold_stds*std)
else:
finder = IRAFStarFinder(
fwhm=self.fwhm, threshold=self.threshold_stds*std)
self.sources = finder(data - median)
for col in self.sources.colnames:
self.sources[col].info.format = "%.8g"
print(self.num())
if self.num() > 0:
for p in self.odata:
self.par[p] = self.calc(p)
return self.sources
def num(self):
if self.sources is not None:
return len(self.sources)
return 0
def calc(self, p):
data = np.absolute(self.sources.field(p))
mean = data.mean()
bot = data.min()
top = data.max()
std = data.std()
p10 = np.percentile(data, 10)
p90 = np.percentile(data, 90)
return FocusData(bot, p10, mean, p90, top, std,
self.back, self.back_std)
def draw(self, cr, par, radius=10):
mean = self.par[par].mean
m_pi = 2 * np.pi
for i in self.sources:
if abs(i[par]) >= mean:
cr.set_source_rgb(0, 1.0, 0)
else:
cr.set_source_rgb(1.0, 0, 0)
cr.arc(i["xcentroid"], i["ycentroid"], radius, 0, m_pi)
cr.stroke()
def get(self, p):
return self.par[p]
| 2.265625 | 2 |
dropout_finetuning.py | alecmeade/ai_for_earth | 1 | 12789068 | import gc
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd
import torch
import torch.nn as nn
import torchvision
import sys
# To view tensorboard metrics
# tensorboard --logdir=logs --port=6006 --bind_all
from torch.utils.tensorboard import SummaryWriter
from functools import partial
from evolver import CrossoverType, MutationType, InitType, MatrixEvolver, VectorEvolver
from unet import UNet
from dataset_utils import PartitionType
from cuda_utils import maybe_get_cuda_device, clear_cuda
from landcover_dataloader import get_landcover_dataloaders, get_landcover_dataloader
from ignite.contrib.handlers.tensorboard_logger import *
from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator
from ignite.metrics import Accuracy, Loss, ConfusionMatrix, mIoU
from ignite.handlers import ModelCheckpoint
from ignite.utils import setup_logger
from ignite.engine import Engine
# Define directories for data, logging and model saving.
base_dir = os.getcwd()
dataset_name = "landcover_large"
dataset_dir = os.path.join(base_dir, "data/" + dataset_name)
experiment_name = "dropout_single_point_finetuning_100_children"
model_name = "best_model_9_validation_accuracy=0.8940.pt"
model_path = os.path.join(base_dir, "logs/" + dataset_name + "/" + model_name)
log_dir = os.path.join(base_dir, "logs/" + dataset_name + "_" + experiment_name)
# Create DataLoaders for each partition of Landcover data.
dataloader_params = {
'batch_size': 8,
'shuffle': True,
'num_workers': 6,
'pin_memory': True}
partition_types = [PartitionType.TRAIN, PartitionType.VALIDATION,
PartitionType.FINETUNING, PartitionType.TEST]
data_loaders = get_landcover_dataloaders(dataset_dir,
partition_types,
dataloader_params,
force_create_dataset=False)
train_loader = data_loaders[0]
finetuning_loader = data_loaders[2]
dataloader_params['shuffle'] = False
test_loader = get_landcover_dataloader(dataset_dir, PartitionType.TEST, dataloader_params)
# Get GPU device if available.
device = maybe_get_cuda_device()
# Determine model and training params.
params = {
'max_epochs': 10,
'n_classes': 4,
'in_channels': 4,
'depth': 5,
'learning_rate': 0.001,
'log_steps': 1,
'save_top_n_models': 4,
'num_children': 100
}
clear_cuda()
model = UNet(in_channels = params['in_channels'],
n_classes = params['n_classes'],
depth = params['depth'])
model.load_state_dict(torch.load(model_path))
# Create Trainer or Evaluators
criterion = nn.NLLLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=params['learning_rate'])
# Determine metrics for evaluation.
metrics = {
"accuracy": Accuracy(),
"loss": Loss(criterion),
"mean_iou": mIoU(ConfusionMatrix(num_classes = params['n_classes'])),
}
for batch in train_loader:
batch_x = batch[0]
_ = model(batch_x)
break
drop_out_layers = model.get_dropout_layers()
del model, batch_x
clear_cuda()
for layer in drop_out_layers:
layer_name = layer.name
size = layer.x_size[1:]
sizes = [size]
clear_cuda()
model = UNet(in_channels = params['in_channels'],
n_classes = params['n_classes'],
depth = params['depth'])
model.load_state_dict(torch.load(model_path))
model.to(device)
criterion = nn.NLLLoss()
optimizer = torch.optim.Adam(model.parameters(),
lr=params['learning_rate'])
num_channels = size[0]
evolver = VectorEvolver(num_channels,
CrossoverType.UNIFORM,
MutationType.FLIP_BIT,
InitType.RANDOM,
flip_bit_prob=0.25,
flip_bit_decay=0.5)
log_dir_test = log_dir + "_" + layer_name
def mask_from_vec(vec, matrix_size):
mask = np.ones(matrix_size)
for i in range(len(vec)):
if vec[i] == 0:
mask[i, :, :] = 0
elif vec[i] == 1:
mask[i, :, :] = 1
return mask
def dropout_finetune_step(engine, batch):
model.eval()
with torch.no_grad():
batch_x, batch_y = batch
batch_x = batch_x.to(device)
batch_y = batch_y.to(device)
loss = sys.float_info.max
for i in range(params['num_children']):
model.zero_grad()
child_vec = evolver.spawn_child()
child_mask = mask_from_vec(child_vec, size)
model.set_dropout_masks({layer_name: torch.tensor(child_mask, dtype=torch.float32).to(device)})
outputs = model(batch_x)
current_loss = criterion(outputs[:, :, 127:128,127:128], batch_y[:,127:128,127:128]).item()
loss = min(loss, current_loss)
if current_loss == 0.0:
current_loss = sys.float_info.max
else:
current_loss = 1.0 / current_loss
evolver.add_child(child_vec, current_loss)
priority, best_child = evolver.get_best_child()
best_mask = mask_from_vec(best_child, size)
model.set_dropout_masks({layer_name: torch.tensor(best_mask, dtype=torch.float32).to(device)})
return loss
# Create Trainer or Evaluators
trainer = Engine(dropout_finetune_step)
train_evaluator = create_supervised_evaluator(model, metrics=metrics, device=device)
validation_evaluator = create_supervised_evaluator(model, metrics=metrics, device=device)
trainer.logger = setup_logger("Trainer")
train_evaluator.logger = setup_logger("Train Evaluator")
validation_evaluator.logger = setup_logger("Validation Evaluator")
@trainer.on(Events.ITERATION_COMPLETED(every=1))
def report_evolver_stats(engine):
priorities = np.array(evolver.get_generation_priorities())
# Take reciprocal since we needed to store priorities in min heap.
priorities = 1.0 / priorities
tb_logger.writer.add_scalar("training/evolver_count",
priorities.shape[0], engine.state.iteration)
tb_logger.writer.add_scalar("training/evolver_mean",
np.mean(priorities), engine.state.iteration)
tb_logger.writer.add_scalar("training/evolver_std",
np.std(priorities), engine.state.iteration)
evolver.update_parents()
@trainer.on(Events.EPOCH_COMPLETED)
def visualize_validation_predictions(engine):
for i, batch in enumerate(test_loader):
batch_x, batch_y = batch
batch_x = batch_x.to(device)
batch_y = batch_y.to(device)
outputs = model(batch_x)
num_images = batch_x.shape[0]
batch_y_detach = batch_y.detach().cpu().numpy()
batch_x_detach = batch_x.detach().cpu().numpy()
outputs_detach = outputs.detach().cpu().numpy()
for j in range(num_images):
f, ax = plt.subplots(1, 3, figsize=(10, 4))
ax[0].imshow(np.moveaxis(batch_x_detach[j, :, :, :], [0], [2]) / 255.0)
ax[1].imshow((np.array(batch_y_detach[j, :, :])))
ax[2].imshow(np.argmax(np.moveaxis(np.array(outputs_detach[j, :, :, :]), [0],[ 2]), axis=2))
ax[0].set_title("X")
ax[1].set_title("Y")
ax[2].set_title("Predict")
f.suptitle("Layer: " + layer_name + " Itteration: " + str(engine.state.iteration) + " Image: " + str(j))
plt.show()
if i > 5:
break
break
# Tensorboard Logger setup below based on pytorch ignite example
# https://github.com/pytorch/ignite/blob/master/examples/contrib/mnist/mnist_with_tensorboard_logger.py
@trainer.on(Events.EPOCH_COMPLETED)
def compute_metrics(engine):
"""Callback to compute metrics on the train and validation data."""
train_evaluator.run(finetuning_loader)
validation_evaluator.run(test_loader)
def score_function(engine):
"""Function to determine the metric upon which to compare model."""
return engine.state.metrics["accuracy"]
# Setup Tensor Board Logging
tb_logger = TensorboardLogger(log_dir=log_dir_test)
tb_logger.attach_output_handler(
trainer,
event_name=Events.ITERATION_COMPLETED(every=params['log_steps']),
tag="training",
output_transform=lambda loss: {"batchloss": loss},
metric_names="all",
)
for tag, evaluator in [("training", train_evaluator), ("validation", validation_evaluator)]:
tb_logger.attach_output_handler(
evaluator,
event_name=Events.EPOCH_COMPLETED,
tag=tag,
metric_names="all",
global_step_transform=global_step_from_engine(trainer),
)
tb_logger.attach_opt_params_handler(trainer,
event_name=Events.ITERATION_COMPLETED(every=params['log_steps']),
optimizer=optimizer)
model_checkpoint = ModelCheckpoint(
log_dir_test,
n_saved=params['save_top_n_models'],
filename_prefix="best",
score_function=score_function,
score_name="validation_accuracy",
global_step_transform=global_step_from_engine(trainer),
)
validation_evaluator.add_event_handler(Events.COMPLETED, model_checkpoint, {"model": model})
trainer.run(finetuning_loader, max_epochs=params['max_epochs'])
tb_logger.close()
| 1.820313 | 2 |
roles/sensu/client/files/plugins/metrics-process-usage.py | Shasthojoy/cuttle | 21 | 12789069 | #!/usr/bin/env python
#
# metrics-process-usage.py
#
# PLATFORMS:
# Linux
#
# DEPENDENCIES:
# Python 2.7+ (untested on Python3, should work though)
# Python module: psutil https://pypi.python.org/pypi/psutil
#
# USAGE:
#
# metrics-process-usage.py -n <process_name> -w <cpu_warning_pct> -c <cpu_critical_pct> -W <mem_warning_pct> -C <mem_critical_pct> [-s <graphite_scheme>] [-z <criticality>]
#
# DESCRIPTION:
# Finds the pid[s] corresponding to a process name and obtains the necessary
# cpu and memory usage stats. Returns WARNING or CRITICAL when these stats
# exceed user specified limits.
#
# Code adapted from Jaime Gogo's script in the Sensu Plugins community:
# https://github.com/sensu-plugins/sensu-plugins-process-checks/blob/master/bin/metrics-per-process.py
#
# Released under the same terms as Sensu (the MIT license); see MITLICENSE
# for details.
#
# <NAME> <<EMAIL>>
import argparse
import sys
import os
import time
import psutil
STATE_OK = 0
STATE_WARNING = 1
STATE_CRITICAL = 2
CRITICALITY = 'critical'
PROC_ROOT_DIR = '/proc/'
def switch_on_criticality():
if CRITICALITY == 'warning':
sys.exit(STATE_WARNING)
else:
sys.exit(STATE_CRITICAL)
def find_pids_from_name(process_name):
'''Find process PID from name using /proc/<pids>/comm'''
pids_in_proc = [ pid for pid in os.listdir(PROC_ROOT_DIR) if pid.isdigit() ]
pids = []
for pid in pids_in_proc:
path = PROC_ROOT_DIR + pid
if 'comm' in os.listdir(path):
file_handler = open(path + '/comm', 'r')
if file_handler.read().rstrip() == process_name:
pids.append(int(pid))
return pids
def sum_dicts(dict1, dict2):
return dict(dict1.items() + dict2.items() +
[(k, dict1[k] + dict2[k]) for k in dict1.viewkeys() & dict2.viewkeys()])
def stats_per_pid(pid):
'''Gets process stats, cpu and memory usage in %, using the psutil module'''
stats = {}
process_handler = psutil.Process(pid)
stats['cpu_percent'] = process_handler.cpu_percent(interval=0.1)
stats['memory_percent'] = process_handler.memory_percent()
return stats
def multi_pid_process_stats(pids):
stats = {'cpu_percent': 0, 'memory_percent': 0}
for pid in pids:
stats = sum_dicts(stats, stats_per_pid(pid))
return stats
def graphite_printer(stats, graphite_scheme):
now = time.time()
for stat in stats:
print "%s.%s %s %d" % (graphite_scheme, stat, stats[stat], now)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-n', '--process_name', required=True)
parser.add_argument('-w', '--cpu_warning_pct', required=True)
parser.add_argument('-c', '--cpu_critical_pct', required=True)
parser.add_argument('-W', '--memory_warning_pct', required=True)
parser.add_argument('-C', '--memory_critical_pct', required=True)
parser.add_argument('-s', '--scheme', required=True)
parser.add_argument('-z', '--criticality', default='critical')
args = parser.parse_args()
CRITICALITY = args.criticality
pids = find_pids_from_name(args.process_name)
if not pids:
print 'Cannot find pids for this process. Enter a valid process name.'
switch_on_criticality()
total_process_stats = multi_pid_process_stats(pids)
graphite_printer(total_process_stats, args.scheme)
if total_process_stats['cpu_percent'] > float(args.cpu_critical_pct) or \
total_process_stats['memory_percent'] > float(args.memory_critical_pct):
print 'CPU Usage and/or memory usage at critical levels!!!'
switch_on_criticality()
if total_process_stats['cpu_percent'] > float(args.cpu_warning_pct) or \
total_process_stats['memory_percent'] > float(args.memory_warning_pct):
print 'Warning: CPU Usage and/or memory usage exceeding normal levels!'
sys.exit(STATE_WARNING)
sys.exit(STATE_OK)
if __name__ == "__main__":
main()
| 2.1875 | 2 |
insta/migrations/0007_remove_post_likes.py | Kennedy-karuri/insta-clone | 0 | 12789070 | <reponame>Kennedy-karuri/insta-clone
# Generated by Django 2.2.8 on 2020-10-22 01:34
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('insta', '0006_auto_20201022_0146'),
]
operations = [
migrations.RemoveField(
model_name='post',
name='likes',
),
]
| 1.359375 | 1 |
setup.py | MarouenMechtri/CNG-Manager | 1 | 12789071 | # Copyright 2010-2012 Institut Mines-Telecom
#
# 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.
"""
Created on Jun 01, 2012
@author: <NAME>
@contact: <EMAIL>
@author: <NAME>
@contact: <EMAIL>
@organization: Institut Mines-Telecom - Telecom SudParis
@license: Apache License, Version 2.0
"""
import os
from setuptools import setup, find_packages
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(name='pyocni',
author='<NAME>',
author_email='<EMAIL>',
version='0.3',
description='PyOCNI: A Python implementation of an extended OCCI with a JSON serialization',
#long_description=read('README'),
url='http://www.example.com/pyocni',
#packages=['pyocni'],
packages=find_packages(), #['pyocni'],
package_data = {
# If any package contains *.txt or *.rst files, include them:
'pyocni': ['*.conf', '*.py'],
# And include any *.msg files found in the 'pyocni' package, too:
'pyocni': ['*.conf', '*.msg'],
},
install_requires=[
'config',
'configobj',
#'logging',
'ordereddict',
'simplejson',
'jsonpickle',
'routes',
'webob',
'pesto',
'eventlet',
'sphinx',
'ZODB3',
'httplib2',
'couchdb',
'couchdbkit',
'tornado'
#'pack>=0.97',
#'pack'
],
classifiers=[
'Development Status :: 3 - Alpha',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'Intended Audience :: End Users/Desktop',
'License :: OSI Approved :: Apache License, Version 2.0',
'Operating System :: POSIX',
'Programming Language :: Python :: 2.7'
]
)
| 1.734375 | 2 |
Preprocessing/Salimi/utils/_init__.py | maliha93/Fairness-Analysis-Code | 0 | 12789072 | <gh_stars>0
###
### FairDB utilities
### | 0.863281 | 1 |
oops/#040_garbageCollection.py | krishankansal/PythonPrograms | 0 | 12789073 | import gc
print(gc.isenabled())
gc.disable()
print(gc.isenabled())
gc.enable()
print(gc.isenabled())
| 1.640625 | 2 |
chembl_webresource_client/scripts/chembl_m2t.py | RowAnalytics/chembl_webresource_client | 248 | 12789074 | #!/usr/bin/env python
from __future__ import print_function
__author__ = 'mnowotka'
# ----------------------------------------------------------------------------------------------------------------------
import sys
import argparse
from chembl_webresource_client.scripts.utils import get_serializer, chembl_id_regex, smiles_regex, convert_to_smiles
from chembl_webresource_client.scripts.utils import resolve, mols_to_targets
AVAILABLE_SOURCE_FORMATS = ('chembl_id', 'sdf', 'smi')
# ----------------------------------------------------------------------------------------------------------------------
def get_options():
description = 'Find related targets for a set of compounds'
parser = argparse.ArgumentParser(description=description, prog='chembl_m2t')
parser.add_argument('-i', '--input', action='store', dest='input',
help='input file, standard input by default')
parser.add_argument('-o', '--output', action='store', dest='output',
help='output file, standard output by default')
parser.add_argument('-s', '--source-format', action='store', dest='source_format', default='csv',
help='input file format. Can be one of 3: chembl_id (a comma separated list of chembl IDs), '
'sdf: (MDL molfile), smi (file containing smiles)')
parser.add_argument('-d', '--destination-format', action='store', dest='dest_format', default='uniprot',
help='output file format. can be chosen from 3 options: '
'[uniprot, gene_name, chembl_id]')
parser.add_argument('-H', '--Human', action='store_true', dest='human',
help='human readable output: prints header and first column with original names')
parser.add_argument('-O', '--organism', action='store', dest='organism',
help='Filter results by organism')
parser.add_argument('-p', '--parent', action='store_true', dest='parent',
help='when fetching targets include also targets from parents of given molecules')
parser.add_argument('-c', '--chunk-size', action='store', dest='chunk', default='1000',
help='Size of chunk of data retrieved from API')
return parser.parse_args()
# ----------------------------------------------------------------------------------------------------------------------
def main():
options = get_options()
source_format = options.source_format.lower()
if source_format not in AVAILABLE_SOURCE_FORMATS:
sys.stderr.write('Unsupported source format', options.source_format)
return
inp = sys.stdin
if source_format == 'sdf':
with open(options.input) if options.input else sys.stdin as in_f:
options.input = None
inp = convert_to_smiles(in_f)
with open(options.input) if options.input else inp as in_f, \
open(options.output, 'w') if options.output else sys.stdout as out_f:
serializer_cls = get_serializer(options.dest_format)
if not serializer_cls:
sys.stderr.write('Unsupported format', options.dest_format)
return
if options.human:
serializer_cls.write_header(out_f)
for line in in_f:
if not line or line.lower().startswith('smiles'):
continue
chunk = line.strip().split()[0]
identifiers = chunk.strip().split(',')
valid_identifiers = list()
for identifier in identifiers:
if chembl_id_regex.match(identifier):
valid_identifiers.append(identifier)
elif smiles_regex.match(identifier):
valid_identifiers.extend([x['molecule_chembl_id'] for x in resolve(identifier)])
targets = mols_to_targets(valid_identifiers,
organism=options.organism,
only_ids=(options.dest_format == 'chembl_id'),
include_parents=options.parent,
chunk_size=int(options.chunk))
out_f.write(serializer_cls.serialize_line(targets, human=options.human, name=','.join(valid_identifiers)))
# ----------------------------------------------------------------------------------------------------------------------
if __name__ == "__main__":
main()
# ----------------------------------------------------------------------------------------------------------------------
| 2.125 | 2 |
tests/api/records/test_loaders.py | galterlibrary/InvenioRDM-at-NU | 6 | 12789075 | """Test record form i.e. marshmallow schema is configured as expected."""
from copy import deepcopy
import pytest
from cd2h_repo_project.modules.records.marshmallow.json import (
AuthorSchemaV1, MetadataSchemaV1, RecordSchemaV1, ResourceTypeSchemaV1
)
@pytest.fixture
def create_input_metadatav1():
"""Factory pattern for the input to the marshmallow.json.MetadataSchemaV1.
"""
def _create_input_metadatav1(data={}):
data_to_use = {
'title': 'A title',
'authors': [
{
'first_name': 'An',
'last_name': 'author'
}
],
'description': 'A description',
'resource_type': {
'general': 'other',
'specific': 'other'
},
'license': 'mit-license',
'permissions': 'all_view',
}
data_to_use.update(data)
return data_to_use
return _create_input_metadatav1
@pytest.fixture
def create_input_record(create_input_metadatav1):
"""Factory pattern for an API input Record.
The returned dict is the input to the marshmallow loader used by the API.
"""
def _create_input_record(data=None):
data = deepcopy(data) if data else {}
data_to_use = {
'metadata': create_input_metadatav1(data.pop('metadata', {}))
}
data_to_use.update(data)
return data_to_use
return _create_input_record
class TestRecordSchemaV1(object):
def test_load_for_empty_json_contains_schema(self, appctx):
unmarshalled_record = RecordSchemaV1().load({})
assert not unmarshalled_record.errors
assert unmarshalled_record.data == {
'$schema': (
'https://localhost:5000/schemas/records/record-v0.1.0.json'
)
}
def test_load_for_valid_json_removes_metadata_envelope(
self, create_input_record):
input_record = create_input_record()
unmarshalled_record = RecordSchemaV1().load(input_record)
assert not unmarshalled_record.errors
loaded_record = unmarshalled_record.data
assert 'metadata' not in loaded_record
def test_load_for_invalid_json_returns_errors(self):
input_record = {'foo': 'bar'}
unmarshalled_record = RecordSchemaV1().load(input_record)
assert 'foo' in unmarshalled_record.errors
assert not unmarshalled_record.data
class TestMetadataSchemaV1(object):
def test_extra_key_is_ignored(self, create_input_metadatav1):
serialized_record = create_input_metadatav1({'foo': 'bar'})
unmarshalled_record = MetadataSchemaV1().load(serialized_record)
loaded_record = unmarshalled_record.data
# marshmallow does not care about additional keys
assert 'foo' not in unmarshalled_record.errors
assert 'foo' not in loaded_record
def test_missing_keys_return_errors(self):
serialized_record = {'foo': 'bar'}
unmarshalled_record = MetadataSchemaV1().load(serialized_record)
required_keys = [
'title', 'description', 'authors', 'resource_type', 'license',
'permissions'
]
assert set(unmarshalled_record.errors.keys()) == set(required_keys)
assert (
unmarshalled_record.errors['title'] ==
['Missing data for required field.']
)
def test_authors_loaded(self, create_input_metadatav1):
authors = [
{
'first_name': 'John',
'middle_name': 'Jacob',
'last_name': 'Smith'
},
{
'first_name': 'Jane',
'middle_name': 'Janet',
'last_name': 'Doe',
'full_name': '<NAME>.' # Should be overwritten
}
]
serialized_record = create_input_metadatav1({
'authors': authors
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'authors' in deserialized_metadata
assert deserialized_metadata['authors'][0] == {
'first_name': 'John',
'middle_name': 'Jacob',
'last_name': 'Smith',
'full_name': 'Smith, <NAME>'
}
assert deserialized_metadata['authors'][1] == {
'first_name': 'Jane',
'middle_name': 'Janet',
'last_name': 'Doe',
'full_name': '<NAME>'
}
def test_resource_type_loaded(self, create_input_metadatav1):
serialized_record = create_input_metadatav1({
'resource_type': {
'general': 'other',
'specific': 'other'
}
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'resource_type' in deserialized_metadata
def test_empty_required_key_returns_errors(self, create_input_metadatav1):
serialized_record = create_input_metadatav1({'title': None})
unmarshalled_record = MetadataSchemaV1().load(serialized_record)
assert 'title' in unmarshalled_record.errors
def test_description_too_short_returns_error(
self, create_input_metadatav1):
serialized_record = create_input_metadatav1({'description': 'A '})
unmarshalled_record = MetadataSchemaV1().load(serialized_record)
assert 'description' in unmarshalled_record.errors
# WHY: We place these tests here because we plan on having terms be a
# first-class citizen of the records schema
def test_one_term_loaded(self, create_input_metadatav1):
terms = [
{
'source': 'MeSH',
'value': 'Cognitive Neuroscience',
'id': 'D000066494'
}
]
serialized_record = create_input_metadatav1({
'terms': [{'data': term} for term in terms]
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert deserialized_metadata['terms'] == terms
def test_multiple_terms_loaded(self, create_input_metadatav1):
terms = [
{
'source': 'MeSH',
'value': 'Cognitive Neuroscience',
'id': 'D000066494'
},
{
'source': 'MeSH',
'value': 'Acanthamoeba',
'id': 'D000048'
}
]
serialized_record = create_input_metadatav1({
'terms': [{'data': term} for term in terms]
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert deserialized_metadata['terms'] == terms
def test_no_terms_loaded(self, create_input_metadatav1):
terms = []
serialized_record = create_input_metadatav1({
'terms': terms
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert deserialized_metadata['terms'] == terms
serialized_record2 = create_input_metadatav1()
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record2)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert deserialized_metadata['terms'] == terms
serialized_record3 = create_input_metadatav1({
'terms': [None, {}, {'data': None}, {'data': {}}, '']
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record3)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert deserialized_metadata['terms'] == []
def test_incorrect_format_terms_returns_error(
self, create_input_metadatav1):
terms = ["bar"]
serialized_record = create_input_metadatav1({
'terms': terms
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert 'terms' in unmarshalled_metadata.errors
assert deserialized_metadata['terms'] == [{}]
def test_coalesce_terms_loaded(self, create_input_metadatav1):
terms = [
{
'source': 'MeSH',
'value': 'Cognitive Neuroscience',
'id': 'D000066494'
},
{
'source': 'FAST',
'value': 'Glucagonoma',
'id': '943672'
}
]
serialized_record = create_input_metadatav1({
'mesh_terms': [{'data': terms[0]}],
'fast_terms': [{'data': terms[1]}]
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert 'terms' in deserialized_metadata
assert 'mesh_terms' not in deserialized_metadata
assert 'fast_terms' not in deserialized_metadata
assert deserialized_metadata['terms'] == terms
def test_permissions_loaded(self, create_input_metadatav1):
serialized_record = create_input_metadatav1({
'permissions': 'restricted_view'
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert not unmarshalled_metadata.errors
assert deserialized_metadata['permissions'] == 'restricted_view'
def test_invalid_permissions_returns_errors(
self, create_input_metadatav1):
serialized_record = create_input_metadatav1({
'permissions': 'foo_view'
})
unmarshalled_metadata = MetadataSchemaV1().load(serialized_record)
deserialized_metadata = unmarshalled_metadata.data
assert 'permissions' in unmarshalled_metadata.errors
class TestAuthorSchemaV1(object):
def test_first_and_last_name_required(self):
author = {
'first_name': 'Jonathan',
}
unmarshalled_author = AuthorSchemaV1().load(author)
assert 'first_name' in unmarshalled_author.data
assert 'middle_name' not in unmarshalled_author.errors
assert 'last_name' in unmarshalled_author.errors
class TestResourceTypeSchemaV1(object):
def test_general_dataset_fills_specific_dataset(self):
resource_type = {
'general': 'dataset'
}
unmarshalled_resource_type = ResourceTypeSchemaV1().load(resource_type)
assert not unmarshalled_resource_type.errors
assert 'general' in unmarshalled_resource_type.data
assert unmarshalled_resource_type.data['specific'] == 'dataset'
def test_valid_general_specific_combination_loads(self):
resource_type = {
'general': 'text resources',
'specific': 'letter'
}
unmarshalled_resource_type = ResourceTypeSchemaV1().load(resource_type)
loaded_resource_type = unmarshalled_resource_type.data
assert not unmarshalled_resource_type.errors
assert loaded_resource_type['general'] == 'text resources'
assert loaded_resource_type['specific'] == 'letter'
def test_invalid_general_specific_combination_errors(self):
resource_type = {
'general': 'articles',
'specific': 'other'
}
unmarshalled_resource_type = ResourceTypeSchemaV1().load(resource_type)
assert (
unmarshalled_resource_type.errors['_schema'][0] ==
'Invalid resource type.'
)
def test_general_specific_combination_maps_to_hierarchy(self):
resource_type = {
'general': 'text resources',
'specific': 'letter'
}
unmarshalled_resource_type = ResourceTypeSchemaV1().load(resource_type)
loaded_resource_type = unmarshalled_resource_type.data
assert loaded_resource_type['full_hierarchy'] == ['text', 'letter']
| 2.703125 | 3 |
python/server/backends/mock.py | liamstar97/searchhub | 48 | 12789076 | <gh_stars>10-100
from collections import defaultdict
import random
from loremipsum import get_sentences
from lucidfind.backends import Backend, Document
from lucidfind.fusion import compare_datasources
class MockBackend(Backend):
def __init__(self):
self.datasources = {}
def get_document(self, doc_id):
return _gen_fake_docs(1).next()
def get_datasource(self, id):
return self.datasources.get(id, None)
def update_datasource(self, id, **config):
datasource = self.get_datasource(id)
if datasource is None:
self.datasources[id] = config
else:
# Update it (maybe)
if compare_datasources(config, datasource) == False:
print "Detected an update in config, updating Fusion"
self.datasources[id] = config
return config
else:
print "No change in datasource, doing nothing"
return
def _gen_fake_docs(count, author=None, source=None, project=None):
authors = ["Joe", "Jane", "Bill", "Mary"]
sources = ["web", "twitter", "email"]
projects = ["solr", "lucene", "elasticsearch"]
def _random_choice(value, choices):
if value is not None:
return value
else:
return random.choice(choices)
for i in range(count):
yield Document(id="doc-%d" % i, author=_random_choice(author, authors), source=_random_choice(source, sources),
project=_random_choice(project, projects), content="".join(get_sentences(random.randint(1, 4))), link="http://example.com/%d" % i,
created_at="2015-01-01T%02d:%02d:00Z" % (random.randint(0,23), random.randint(0,59)))
def _gen_fake_facets(docs, author=None, source=None, project=None):
facets = defaultdict(lambda: defaultdict(int))
for doc in docs:
facets["author"][doc.author] += 1
facets["source"][doc.source] += 1
facets["project"][doc.project] += 1
return facets | 2.3125 | 2 |
pyapps/sensorapp.py | helena-project/beetle | 16 | 12789077 | #!/usr/bin/env python
"""
pygatt cloud monitoring
=======================
This module implements a cloud monitoring application for home sensors
"""
import argparse
import os
import socket
import ssl
import struct
import sys
import threading
from datetime import datetime
from jinja2 import Environment, FileSystemLoader
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
PYGATT_PATH = "../pygatt"
sys.path.append(PYGATT_PATH)
import lib.gatt as gatt
import lib.uuid as uuid
import lib.beetle as beetle
from pygatt import ManagedSocket, GattClient, ClientError
def getArguments():
"""Arguments for script."""
parser = argparse.ArgumentParser()
parser.add_argument("--name", default="sensorapp",
help="name of the application")
parser.add_argument("--app-port", type=int, default="8081",
help="port to run application server")
parser.add_argument("--host", default="localhost",
help="hostname of the Beetle server")
parser.add_argument("--port", "-p", type=int, default=3002,
help="port the server is runnng on")
parser.add_argument("--cert", "-c", type=str,
help="client certificate")
parser.add_argument("--key", "-k", type=str,
help="private key for client certificate")
parser.add_argument("--rootca", "-r",
help="root CA certificate")
parser.add_argument("--nocerts", "-x", action="store_true",
help="disable verification and use of client certificates")
return parser.parse_args()
def printBox(s):
""" Print a header """
print "%s\n|| %s ||\n%s" % ("=" * (len(s) + 6), s, "=" * (len(s) + 6))
ENV_SENSING_SERVICE_UUID = 0x181A
PRESSURE_CHARAC_UUID = 0x2A6D
TEMPERATURE_CHARAC_UUID = 0x2A6E
HUMIDITY_CHARAC_UUID = 0x2A6F
UNK1_CHARAC_UUID = 0xC512
UNK2_CHARAC_UUID = 0xF801
INTERNAL_REFRESH_INTERVAL = 60 * 5
class SensorInstance(object):
def __init__(self, name):
self.name = name
self.address = None
self.connectTime = None
self.gateway = None
self._pressure = None
self._pressure_cached = None
self._temperature = None
self._temperature_cached = None
self._humidity = None
self._humidity_cached = None
self._unk1 = None
self._unk1_cached = None
self._unk2 = None
self._unk2_cached = None
def _unpack_pressure(self, buf):
if len(buf) != 4:
return float("nan")
raw = struct.unpack('<I', bytes(buf))[0]
return float(raw) / 10.0
@property
def pressure(self):
if self._pressure_cached is not None:
return self._pressure_cached
try:
buf = self._pressure.read()
self._pressure_cached = self._unpack_pressure(buf)
return self._pressure_cached
except Exception, err:
print err
return float("nan")
def _unpack_temperature(self, buf):
if len(buf) != 2:
return float("nan")
raw = struct.unpack('<h', bytes(buf))[0]
return float(raw) / 100.0
@property
def temperature(self):
if self._temperature_cached is not None:
return self._temperature_cached
try:
buf = self._temperature.read()
self._temperature_cached = self._unpack_temperature(buf)
return self._temperature_cached
except Exception, err:
print err
return float("nan")
def _unpack_humidity(self, buf):
if len(buf) != 2:
return float("nan")
raw = struct.unpack('<H', bytes(buf))[0]
return float(raw) / 100.0
@property
def humidity(self):
if self._humidity_cached is not None:
return self._humidity_cached
try:
buf = self._humidity.read()
self._humidity_cached = self._unpack_humidity(buf)
return self._humidity_cached
except Exception, err:
print err
return float("nan")
def _unpack_unk1(self, buf):
if len(buf) != 2:
return -1
return struct.unpack('<H', bytes(buf))[0]
@property
def unk1(self):
if self._unk1_cached is not None:
return self._unk1_cached
try:
buf = self._unk1.read()
self._unk1_cached = self._unpack_unk1(buf)
return self._unk1_cached
except Exception, err:
print err
return -1
def _unpack_unk2(self, buf):
if len(buf) != 1:
return -1
return buf[0]
@property
def unk2(self):
if self._unk2_cached is not None:
return self._unk2_cached
try:
buf = self._unk2.read()
self._unk2_cached = self._unpack_unk2(buf)
return self._unk2_cached
except Exception, err:
print err
return -1
@property
def ready(self):
return (self.name is not None and self._pressure is not None
and self._temperature is not None and self._humidity is not None
and self._unk1 is not None and self._unk2 is not None
and self.address is not None and self.connectTime is not None
and self.gateway is not None)
def subscribeAll(self):
assert self.ready
print "Subscribing to notifications: %s" % self.address
def _pressure_handler(buf):
self._pressure_cached = self._unpack_pressure(buf)
self._pressure.subscribe(_pressure_handler)
def _temperature_handler(buf):
self._temperature_cached = self._unpack_temperature(buf)
self._temperature.subscribe(_temperature_handler)
def _humidity_handler(buf):
self._humidity_cached = self._unpack_humidity(buf)
self._humidity.subscribe(_humidity_handler)
def _unk1_handler(buf):
self._unk1_cached = self._unpack_unk1(buf)
self._unk1.subscribe(_unk1_handler)
def _unk2_handler(buf):
self._unk2_cached = self._unpack_unk2(buf)
self._unk2.subscribe(_unk2_handler)
def __str__(self):
return "%s (%s)" % (self.name, self.address)
def runHttpServer(port, client, reset, ready, devices):
"""Start the HTTP server"""
class WebServerHandler(BaseHTTPRequestHandler):
"""Handle HTTP requests and serve a simple web UI"""
def _serve_main(self):
"""Serve the main page"""
ready.wait()
env = Environment(loader=FileSystemLoader("templates"))
template = env.get_template("sensorapp.html")
self.send_response(200, 'OK')
self.send_header('Content-type', 'html')
self.end_headers()
self.wfile.write(template.render(devices=devices))
self.wfile.close()
def _serve_static(self):
if self.path == "" or not os.path.isfile(self.path[1:]):
self.send_error(404)
self.end_headers()
self.wfile.close()
return
path = self.path[1:]
_, extension = os.path.splitext(path)
print extension
if extension == ".css":
extension = "text/css"
elif extension == ".png":
extension = "image/png"
else:
self.send_error(403)
self.end_headers()
self.wfile.close()
return
self.send_response(200, 'OK')
self.send_header('Content-type', extension)
self.end_headers()
with open(path, "rb") as f:
try:
self.wfile.write(f.read())
finally:
self.wfile.close()
def do_GET(self):
if self.path == "/":
self._serve_main()
elif self.path.startswith("/static"):
self._serve_static()
else:
self.send_error(404)
self.end_headers()
self.wfile.close()
def do_POST(self):
if self.path == "/rescan":
ready.clear()
reset.set()
ready.wait()
self.send_response(200, 'OK')
self.end_headers()
self.wfile.close()
else:
self.send_error(404)
self.end_headers()
self.wfile.close()
server = HTTPServer(("", port), WebServerHandler)
try:
server.serve_forever()
finally:
server.socket.close()
def runClient(client, reset, ready, devices):
"""Start a beetle client"""
gapUuid = uuid.UUID(gatt.GAP_SERVICE_UUID)
nameUuid = uuid.UUID(gatt.GAP_CHARAC_DEVICE_NAME_UUID)
envSenseUuid = uuid.UUID(ENV_SENSING_SERVICE_UUID)
pressureUuid = uuid.UUID(PRESSURE_CHARAC_UUID)
temperatureUuid = uuid.UUID(TEMPERATURE_CHARAC_UUID)
humidityUuid = uuid.UUID(HUMIDITY_CHARAC_UUID)
unk1Uuid = uuid.UUID(UNK1_CHARAC_UUID)
unk2Uuid = uuid.UUID(UNK2_CHARAC_UUID)
beetleUuid = uuid.UUID(beetle.BEETLE_SERVICE_UUID)
bdAddrUuid = uuid.UUID(beetle.BEETLE_CHARAC_BDADDR_UUID)
connTimeUuid = uuid.UUID(beetle.BEETLE_CHARAC_CONNECTED_TIME_UUID)
gatewayUuid = uuid.UUID(beetle.BEETLE_CHARAC_CONNECTED_GATEWAY_UUID)
def _daemon():
while True:
del devices[:]
services = client.discoverAll()
currDevice = None
# proceed down the services, separating out devices
printBox("Discovering handles")
for service in services:
print service
if service.uuid == gapUuid:
for charac in service.characteristics:
print " ", charac
if charac.uuid == nameUuid:
currDevice = None
try:
currDeviceName = str(charac.read())
currDevice = SensorInstance(
name=currDeviceName)
except ClientError, err:
print err
except Exception, err:
print err
elif service.uuid == envSenseUuid:
for charac in service.characteristics:
print " ", charac
if currDevice is not None:
if charac.uuid == pressureUuid:
currDevice._pressure = charac
elif charac.uuid == temperatureUuid:
currDevice._temperature = charac
elif charac.uuid == humidityUuid:
currDevice._humidity = charac
elif charac.uuid == unk1Uuid:
currDevice._unk1 = charac
elif charac.uuid == unk2Uuid:
currDevice._unk2 = charac
elif service.uuid == beetleUuid:
for charac in service.characteristics:
print " ", charac
if currDevice is not None:
if charac.uuid == bdAddrUuid:
try:
bdaddr = charac.read()[::-1]
currDevice.address = ":".join(
"%02X" % x for x in bdaddr)
except ClientError, err:
print err
except Exception, err:
print err
elif charac.uuid == connTimeUuid:
try:
raw = charac.read()
if len(raw) != 4:
continue
epoch = struct.unpack('<I', bytes(raw))[0]
currDevice.connectTime = \
datetime.utcfromtimestamp(epoch)
except ClientError, err:
print err
except Exception, err:
print err
elif charac.uuid == gatewayUuid:
try:
gateway = charac.read()
currDevice.gateway = str(gateway)
except ClientError, err:
print err
except Exception, err:
print err
print currDevice, currDevice.ready
if currDevice.ready:
currDevice.subscribeAll()
devices.append(currDevice)
currDevice = None
ready.set()
reset.clear()
reset.wait(INTERNAL_REFRESH_INTERVAL)
ready.clear()
clientThread = threading.Thread(target=_daemon)
clientThread.setDaemon(True)
clientThread.start()
def main(args):
"""Set up a web app"""
def onDisconnect(err):
print "Disconnect:", err
os._exit(0)
# Declare a managed socket, and bind a GATT server and client
managedSocket = ManagedSocket(daemon=True)
client = GattClient(managedSocket, onDisconnect=onDisconnect)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if args.nocerts:
s = ssl.wrap_socket(s, cert_reqs=ssl.CERT_NONE)
else:
s = ssl.wrap_socket(s, keyfile=args.key, certfile=args.cert,
ca_certs=args.rootca, cert_reqs=ssl.CERT_REQUIRED)
s.connect((args.host, args.port))
printBox("Starting as: %s" % args.name)
# Send initial connection parameters.
appParams = ["client %s" % args.name, "server false"]
print ""
printBox("Connection request")
for line in appParams:
print "$ %s" % line
# Send connection request parameters to Beetle
appParamsStr = "\n".join(appParams)
appParamsLength = struct.pack("!i", len(appParamsStr))
s.sendall(appParamsLength.encode('utf-8'))
s.sendall(appParamsStr.encode('utf-8'))
# Read parameters in plaintext from Beetle
serverParamsLength = struct.unpack("!i", s.recv(4))[0]
print ""
printBox("Beetle response")
for serverParam in s.recv(serverParamsLength).split("\n"):
print "$ %s" % serverParam.rstrip()
# Transfer ownership of the socket
managedSocket.bind(s, True)
devices = []
reset = threading.Event()
ready = threading.Event()
runClient(client, reset, ready, devices)
runHttpServer(args.app_port, client, reset, ready, devices)
if __name__ == "__main__":
args = getArguments()
main(args)
os._exit(0)
| 2.625 | 3 |
Remark/Macros/Comment_Macro.py | kaba2/remark | 0 | 12789078 | <gh_stars>0
# -*- coding: utf-8 -*-
# Description: Comment macro
# Detail: Consumes its input and produces no output.
from Remark.Macro_Registry import registerMacro
class Comment_Macro(object):
def name(self):
return 'Comment'
def expand(self, parameter, remark):
# This macro simply eats its parameter. This allows
# for commenting.
text = []
return text
def expandOutput(self):
return False
def htmlHead(self, remark):
return []
def postConversion(self, remark):
None
registerMacro('Comment', Comment_Macro())
| 2.609375 | 3 |
leetcode_python/String/convert-a-number-to-hexadecimal.py | yennanliu/Python_basics | 18 | 12789079 | <reponame>yennanliu/Python_basics<filename>leetcode_python/String/convert-a-number-to-hexadecimal.py
# Time: O(logn)
# Space: O(1)
# Given an integer, write an algorithm to convert it to hexadecimal.
# For negative integer, two’s complement method is used.
#
# IMPORTANT:
# You must not use any method provided by the library which converts/formats
# the number to hex directly. Such solution will result in disqualification of
# all your submissions to this problem. Users may report such solutions after the
# contest ends and we reserve the right of final decision and interpretation
# in the case of reported solutions.
#
# Note:
#
# All letters in hexadecimal (a-f) must be in lowercase.
# The hexadecimal string must not contain extra leading 0s. If the number is zero,
# it is represented by a single zero character '0'; otherwise,
# the first character in the hexadecimal string will not be the zero character.
# The given number is guaranteed to fit within the range of a 32-bit signed integer.
# You must not use any method provided by the library which converts/formats the number to hex directly.
# Example 1:
#
# Input:
# 26
#
# Output:
# "1a"
# Example 2:
#
# Input:
# -1
#
# Output:
# "ffffffff"
# V0
# V1
# IDEA : Decimal -> Hexadecimal
# Decimal : {0,1,2,3,4,5,6,7,8,9}
# Hexadecimal : {0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f}
# https://www.cnblogs.com/grandyang/p/5926674.html
# e.g.
# 50 -> 32 ( 50%16 = 3 + 2)
# 26 -> 1a ( 26%16 = 1 + 10 = 1 + a)
# https://www.jianshu.com/p/2d57cec55393
# divmod(17, 16) = (1,1)
# divmod(3, 1) = (3,0)
def toHex(num):
ret = ''
map = ('0', '1','2','3','4','5','6','7','8','9','a','b','c','d','e','f')
if num == 0:
return '0'
if num < 0:
num += 2**32 # if num < 0, use num = num + 2**32 to deal with it
while num > 0 :
num, val = divmod(num, 16)
ret += map[val]
return ret[::-1]
# V2
# Time: O(logn)
# Space: O(1)
class Solution(object):
def toHex(self, num):
"""
:type num: int
:rtype: str
"""
if not num:
return "0"
result = []
while num and len(result) != 8:
h = num & 15
if h < 10:
result.append(str(chr(ord('0') + h)))
else:
result.append(str(chr(ord('a') + h-10)))
num >>= 4
result.reverse()
return "".join(result)
| 4.3125 | 4 |
generate_confirmation_tokens.py | FiwareULPGC/agreement-mail-utilities | 0 | 12789080 | <reponame>FiwareULPGC/agreement-mail-utilities<gh_stars>0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import getopt
import sys
import uuid
from openpyxl import *
def generate_token():
return uuid.uuid4().hex
def generate_confirmation_tokens(filepath):
wb = load_workbook(filepath)
ws = wb.worksheets[0]
ws.cell(row=1, column=4).value = "Token"
ws.cell(row=1, column=5).value = "Sent"
row_number = 2
for row in ws.iter_rows(row_offset=1):
if (row[0].value is not None or row[1].value is not None or
row[2].value is not None):
try:
# Abort and notify if an empty field is found
if row[0].value is None:
raise ValueError("Name value not found in row {}."
.format(row_number))
if row[1].value is None:
raise ValueError("Surname value not found in row {}."
.format(row_number))
if row[2].value is None:
raise ValueError("Email value not found in row {}."
.format(row_number))
ws.cell(row=row_number, column=4).value = generate_token()
except Exception as e:
ws.cell(row=row_number, column=4).value = None
print " Error generating token : {}".format(str(e))
finally:
ws.cell(row=row_number, column=5).value = 'No'
row_number += 1
wb.save(filepath)
if __name__ == "__main__":
options, remainder = getopt.getopt(sys.argv[1:], 'f:h', ['file=',
'help',
])
example = ("Example of use: python ./generate_confirmation_tokens.py "
"-f ./<filename>.xlsx")
file = None
for opt, arg in options:
if opt in ('-f', '--file'):
file = arg
if file is None:
print example
else:
generate_confirmation_tokens(file)
| 2.5625 | 3 |
tools/bin/pythonSrc/PSI-0.3b2_gp/psi/_version.py | YangHao666666/hawq | 450 | 12789081 | # The MIT License
#
# Copyright (C) 2007 <NAME>
#
# Copyright (C) 2008-2009 <NAME>
#
# Copyright (C) 2008-2009 Abilisoft Ltd.
#
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""psi._version
This is used so that this information can stay easily in sync in both
psi and setup.py.
"""
version = '0.3b2'
author = '<NAME>, <NAME>, <NAME>'
copyright = """\
Copyright (C) 2007-2009 <NAME>
Copyright (C) 2008, 2009 <NAME>
Copyright (C) 2008, 2009 Abilisoft Ltd.
Copyright (C) 2009 <NAME>"""
license = 'MIT'
| 1.257813 | 1 |
main.py | JiwooKimAR/MWP-solver-with-pretrained-language-model | 5 | 12789082 | import os
import sys
import torch
import argparse
from collections import OrderedDict
from dataloader import Dataset
from evaluation import Evaluator
from experiment import EarlyStop, train_model
from utils import Config, Logger, ResultTable, make_log_dir, set_random_seed
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
def main_train_test(argv):
# multiprocessing.set_start_method('spawn')
# read configs
config = Config(main_conf_path='./', model_conf_path='model_config')
# apply system arguments if exist
if len(argv) > 0:
cmd_arg = OrderedDict()
argvs = ' '.join(sys.argv[1:]).split(' ')
for i in range(0, len(argvs), 2):
arg_name, arg_value = argvs[i], argvs[i + 1]
arg_name = arg_name.strip('-')
cmd_arg[arg_name] = arg_value
config.update_params(cmd_arg)
gpu = config.get_param('Experiment', 'gpu')
gpu = str(gpu)
os.environ["CUDA_VISIBLE_DEVICES"] = gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_name = config.get_param('Experiment', 'model_name')
# set seed
seed = config.get_param('Experiment', 'seed')
set_random_seed(seed)
# logger
log_dir = make_log_dir(os.path.join('saves', model_name))
logger = Logger(log_dir)
config.save(log_dir)
# dataset
dataset_name = config.get_param('Dataset', 'dataset')
dataset = Dataset(model_name, **config['Dataset'])
# early stop
early_stop = EarlyStop(**config['EarlyStop'])
# evaluator()
evaluator = Evaluator(early_stop.early_stop_measure, **config['Evaluator'])
# Save log & dataset config.
logger.info(config)
logger.info(dataset)
import model
MODEL_CLASS = getattr(model, model_name)
# build model
model = MODEL_CLASS(dataset, config['Model'], device)
model.logger = logger
################################## TRAIN & PREDICT
# train
try:
valid_score, train_time = train_model(model, dataset, evaluator, early_stop, logger, config)
except (KeyboardInterrupt, SystemExit):
valid_score, train_time = dict(), 0
logger.info("학습을 중단하셨습니다.")
m, s = divmod(train_time, 60)
h, m = divmod(m, 60)
logger.info('\nTotal training time - %d:%d:%d(=%.1f sec)' % (h, m, s, train_time))
# test
model.eval()
model.restore(logger.log_dir)
test_score = dict()
for testset in dataset.testsets:
test_score.update(evaluator.evaluate(model, dataset, testset))
# show result
evaluation_table = ResultTable(table_name='Best Result', header=list(test_score.keys()))
evaluation_table.add_row('Valid', valid_score)
evaluation_table.add_row('Test', test_score)
# evaluation_table.show()
logger.info(evaluation_table.to_string())
logger.info("Saved to %s" % (log_dir))
def main_submit(args):
# read configs
config = Config(main_conf_path=args.path, model_conf_path=args.path)
# Final test set (dataset/problemsheet.json)
config.main_config['Dataset']['dataset'] = '/home/agc2021/dataset'
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_name = config.get_param('Experiment', 'model_name')
log_dir = args.path
logger = Logger(log_dir)
dataset = Dataset(model_name, **config['Dataset'])
# evaluator
evaluator = Evaluator(**config['Evaluator'])
import model
MODEL_CLASS = getattr(model, model_name)
# build model
model = MODEL_CLASS(dataset, config['Model'], device)
# test
model.eval()
model.restore(logger.log_dir)
model.logger = logger
evaluator.evaluate(model, dataset, 'submit')
logger.info("Saved answer")
if __name__ == '__main__':
## For submission
if os.path.exists('/home/agc2021/dataset/problemsheet_5_00.json'):
parser = argparse.ArgumentParser()
parser.add_argument('--path', type=str, default='saves_final/', metavar='P')
args = parser.parse_args()
main_submit(args)
else:
main_train_test(argv=sys.argv[1:]) | 2.1875 | 2 |
servers/web/flask/views/mine.py | ericharmeling/photoblocks | 2 | 12789083 | <reponame>ericharmeling/photoblocks<filename>servers/web/flask/views/mine.py
from flask import request
def mine(blockchain):
# Form data
image_file = request.files['file']
image_loc = blockchain.dir + image_file.filename
label = request.form['label']
last_label = request.form['last_label']
n_key = request.form['node_id']
# Store image file on server
image_file.save(image_loc)
# Go through data
blockchain.last_labels.append(last_label)
iter_block = blockchain.new_block(image_loc, label, blockchain.transactions)
proof = blockchain.proof_of_work(iter_block)
block = blockchain.new_block(image_loc, label, blockchain.transactions, nonce=proof)
blockchain.add_block(block)
blockchain.transactions = []
blockchain.add_transaction_fields(sender="God", recipient=n_key, quantity=1)
return block
| 2.65625 | 3 |
receptiveFields.py | ericrosenbrown/ReceptiveFields | 0 | 12789084 | # -*- coding: utf-8 -*-
# <nbformat>3.0</nbformat>
# <markdowncell>
# We are going to be doing an activity about viewing images through different filters. These filters are similar to things that happen in the brain when the images from our eyes are registered in our brain.
# <codecell>
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import scipy.signal as signal
import numpy as n
# <codecell>
barImg=mpimg.imread('bar.png')
#extract grey values
barImg = barImg[:,:,3]
# <markdowncell>
# We examine the effect on the following images. In the visual pathway the images can be seen as input from our eyes focusing on the center of our vision.
# <codecell>
imgplot = plt.imshow(barImg, cmap=cm.Greys_r)
# <codecell>
img=mpimg.imread('stinkbug.png') #change 'stinkbug.png' into your choice of animal:
# turtle.jpg, turtle2.jpg, zebra.png, doge.png, jaguar.png, leopard.png, mexicanhat.jpg
#extract grey values
bugImg = img[:,:,0]
# <codecell>
imgplot = plt.imshow(bugImg, cmap=cm.Greys_r)
# <markdowncell>
# Receptive field functions
# -------------------
#
# The following function will be used as a blurring filter.
# $$\phi(x,y) = \frac{1}{2\pi\sigma^2}\exp{\{-\frac{1}{2\pi\sigma^2}(x^2+ y^2)\}}$$
# <codecell>
def gaussian2D(x, y, sigma):
return (1.0/(1*math.pi*(sigma**2)))*math.exp(-(1.0/(2*(sigma**2)))*(x**2 + y**2))
"""make matrix from function"""
def receptiveFieldMatrix(func):
h = 30
g = zeros((h,h))
for xi in range(0,h):
for yi in range(0,h):
x = xi-h/2
y = yi-h/2
g[xi, yi] = func(x,y);
return g
def plotFilter(fun):
g = receptiveFieldMatrix(fun)
plt.imshow(g, cmap=cm.Greys_r)
# <markdowncell>
# The function is circular symmetric, meaning it is doing the same thing around a circle.
#
# This filter cancels out higher frequencies, thus blurring the image.
# <codecell>
plotFilter(lambda x,y:gaussian2D(x,y,4))
# <markdowncell>
# Convolution is the process of applying the filter to the input image.
# $$\int \int I(x',y')\phi(x-x',y-y')dx'dy'$$
#
# When applying this filter, the result of the convolution can be visualized in an image.
# <codecell>
Img_barGaussian = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: gaussian2D(x,y,5)), mode='same')
imgplot = plt.imshow(Img_barGaussian, cmap=cm.Greys_r)
# <codecell>
Img_bugGaussian = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: gaussian2D(x,y,3)), mode='same')
imgplot = plt.imshow(Img_bugGaussian, cmap=cm.Greys_r)
# <markdowncell>
# Difference of Gaussians
# ---------------------
#
# The mexican hat function is a difference between two of the function above, which leads to a filter that happens in certain cells in your eye. It can be seen as a basic edge detector.
# <codecell>
def mexicanHat(x,y,sigma1,sigma2):
return gaussian2D(x,y,sigma1) - gaussian2D(x,y,sigma2)
plotFilter(lambda x,y: mexicanHat(x,y,3,4))
# <codecell>
Img_barHat = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y:mexicanHat(x,y,3,4)), mode='same')
imgplot = plt.imshow(Img_barHat, cmap=cm.Greys_r)
# <codecell>
Img_bugHat = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: mexicanHat(x,y,2,3)), mode='same')
imgplot = plt.imshow(Img_bugHat, cmap=cm.Greys_r)
# <markdowncell>
# Gabor functions
# ---------------
#
# Gabor functions are used to detect edges with a specific orientation in images. There are parts in the brain that see an image through these gabor functions and are found throughout a part of your eye.
#
# There are two different types of gabor function:
# $$g_s(x):=sin(\omega_x x + \omega_y y)\exp{\{-\frac{x^2+y^2}{2\sigma^2}\}}$$
# $$g_c(x):=cos(\omega_x x + \omega_y y)\exp{\{-\frac{x^2+y^2}{2\sigma^2}\}}$$
#
# <codecell>
def oddGabor2D(x,y,sigma,orientation):
return math.sin(x + orientation*y) * math.exp(-(x**2 + y**2)/(2*sigma))
def evenGabor2D(x,y, sigma, orientation):
return math.cos(x + orientation*y) * math.exp(-(x**2 + y**2)/(2*sigma))
plotFilter(lambda x,y: oddGabor2D(x,y,7,1))
# <codecell>
Img_barOddGabor = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')
imgplot = plt.imshow(Img_barOddGabor, cmap=cm.Greys_r)
# <codecell>
Img_bugOddGabor = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')
# <markdowncell>
# In the following image one can see the edge orientations appear in the part of the eye.
# <codecell>
imgplot = plt.imshow(Img_bugOddGabor, cmap=cm.Greys_r)
# <markdowncell>
# Using the previous filter (the edge defining one) as an input to the gabor we obtain different results.
# <codecell>
Img_bugOddGaborEdge = signal.convolve(Img_bugHat,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')
imgplot = plt.imshow(Img_bugOddGaborEdge, cmap=cm.Greys_r)
# <markdowncell>
# Here is an example of the other gabor filter
# <codecell>
plotFilter(lambda x,y: evenGabor2D(x,y,7,1))
Img_barEvenGabor = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: evenGabor2D(x,y,5,1)), mode='same')
imgplot = plt.imshow(Img_barEvenGabor, cmap=cm.Greys_r)
# <codecell>
Img_bugEvenGabor = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: evenGabor2D(x,y,5,1)), mode='same')
imgplot = plt.imshow(Img_bugEvenGabor, cmap=cm.Greys_r)
# <markdowncell>
# Quadrature Pairs
# ------------------
#
# Now let's combine both gabor filters to see what will happen.
# <codecell>
def edgeEnergy(x,y,sigma, orientation):
g1= oddGabor2D(x,y,sigma,orientation)
g2= evenGabor2D(x,y,sigma,orientation)
return(g1**2+g2**2)
# <codecell>
plotFilter(lambda x,y:edgeEnergy(x,y,50,0))
# <codecell>
Img_barEdgeEnergy = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: edgeEnergy(x,y,100,1)), mode='same')
imgplot = plt.imshow(Img_barEdgeEnergy, cmap=cm.Greys_r)
# <codecell>
Img_bugEdgeEnergy = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: edgeEnergy(x,y,10,1)), mode='same')
imgplot = plt.imshow(Img_bugEdgeEnergy, cmap=cm.Greys_r)
# <codecell>
| 3.625 | 4 |
object_pool/exception.py | dduraipandian/object_pool | 3 | 12789085 | <filename>object_pool/exception.py
class InvalidMinInitCapacity(Exception):
def __init__(self, pool_name):
self.message = f"ERROR:: {pool_name}: min_init can not be less than 0 with lazy=False option."
class InvalidMaxCapacity(Exception):
def __init__(self, pool_name):
self.message = f"ERROR:: {pool_name}: max capacity should not be negative number."
class InvalidClass(Exception):
def __init__(self, klass):
self.message = f"ERROR:: {klass} is not a valid class."
| 2.984375 | 3 |
memtrain/memtrain_common/question.py | iandorsey00/memtrain | 0 | 12789086 | import decimal
import random
import string
import textwrap
import time
import os
from memtrain.memtrain_common.mtstatistics import MtStatistics
class NoResponsesError(Exception):
pass
class Question:
'''Manages the current cue and response interface'''
def __init__(self, settings, database):
# Initialize core objects
self.settings = settings
self.conn = database.conn
self.cur = self.conn.cursor()
self.database = database
self.responses = self.database.get_all_responses()
self.cue_id = 0
self.response_id = 0
self.f_cue = ''
self.mtags = []
self.mchoices = dict()
self.iam = ' '
self.ascii_range = ['a', 'b', 'c', 'd']
self.response = ''
self.user_input = ''
self.synonyms = []
self.plural_responses = [i for i in self.responses if self.is_plural(i)]
self.nonplural_responses = [i for i in self.responses if not self.is_plural(i)]
## Interface text
self.title_text = ''
self.level_text = ''
self.response_number_text = ''
self.cue_text = ''
self.hint_text = ''
self.correctness_str = ''
self.other_answers_str = ''
def get_value(self, value, value_id):
self.cur.execute('''SELECT {} FROM {} WHERE {} = (?)'''
.format(value, value + 's', value + '_id'),
(str(value_id), ))
rows = self.cur.fetchall()
return rows[0][0]
def get_cue(self, cue_id):
return self.get_value('cue', cue_id)
def get_response(self, response_id):
return self.get_value('response', response_id)
def get_hints(self):
# Translate response_id into hint_id
self.cur.execute('''SELECT hint_id FROM responses_to_hints
WHERE response_id = (?)''', (str(self.response_id), ))
rows = self.cur.fetchall()
rows = list(map(lambda x: x[0], rows))
out = []
# Translate hint_id to hint
for hint_id in rows:
out.append(self.get_value('hint', hint_id))
return out
def get_synonyms(self):
# Translate response_id into synonym_id
self.cur.execute('''SELECT synonym_id FROM responses_to_synonyms
WHERE response_id = (?)''', (str(self.response_id), ))
rows = self.cur.fetchall()
rows = list(map(lambda x: x[0], rows))
out = []
# Translate synonym_id to synonym
for synonym_id in rows:
out.append(self.get_value('synonym', synonym_id))
return out
def get_mtags(self):
# Translate response_id into mtag_id
self.cur.execute('''SELECT mtag_id FROM responses_to_mtags
WHERE response_id = (?)''', (str(self.response_id), ))
rows = self.cur.fetchall()
rows = list(map(lambda x: x[0], rows))
out = []
# Translate mtag_id to mtag
for mtag_id in rows:
out.append(self.get_value('mtag', mtag_id))
return out
def get_placement(self, cue_id, response_id):
self.cur.execute('''SELECT placement FROM cues_to_responses
WHERE cue_id = (?) AND response_id = (?)''',
(str(cue_id), str(response_id)))
rows = self.cur.fetchall()
return rows[0][0]
def get_responses_by_mtag(self, mtag):
# Translate mtag_id to mtag
self.cur.execute('''SELECT mtag_id FROM mtags WHERE mtag = (?)''',
(mtag, ))
rows = self.cur.fetchall()
rows = list(map(lambda x: x[0], rows))
# Translate mtag_id to response_id
response_ids = []
for mtag_id in rows:
self.cur.execute('''SELECT response_id FROM responses_to_mtags
WHERE mtag_id = (?)''', (mtag_id, ))
more_rows = self.cur.fetchall()
response_ids += list(map(lambda x: x[0], more_rows))
# Translate response_id to response
out = []
for response_id in response_ids:
out.append(self.get_value('response', response_id))
return out
def is_plural(self, string):
'''Detects most plural words in English'''
return string[-1:] == 's' or string[-2:] == 'es'
# Question rendering ######################################################
def format_cue(self):
self.f_cue = self.cue.replace('{{}}', '_' * 9)
if self.placement == 1:
self.f_cue = self.f_cue.replace('{{1}}', '___(1)___')
else:
self.f_cue = self.f_cue.replace('{{1}}', '_' * 9)
if self.placement == 2:
self.f_cue = self.f_cue.replace('{{2}}', '___(2)___')
else:
self.f_cue = self.f_cue.replace('{{2}}', '_' * 9)
if self.placement == 3:
self.f_cue = self.f_cue.replace('{{3}}', '___(3)___')
else:
self.f_cue = self.f_cue.replace('{{3}}', '_' * 9)
return self.f_cue
def main_data_loop(self, cue_id, response_id, mtstatistics, final=False):
'''Main data processing for question rendering'''
# Initialize core objects
self.cue_id = cue_id
self.response_id = response_id
self.mtstatistics = mtstatistics
# Other important data
self.cue = self.get_cue(self.cue_id)
self.response = self.get_response(self.response_id)
self.placement = self.get_placement(self.cue_id, self.response_id)
self.synonyms = self.get_synonyms()
self.hints = self.get_hints()
self.mtags = self.get_mtags()
self.mtstatistics.update_percentage()
# Determine the level
if self.settings.level == '1':
self.level_text = 'Level 1'
elif self.settings.level == '2':
self.level_text = 'Level 2'
elif self.settings.level == '3':
self.level_text = 'Level 3'
# Important text
self.title_text = self.settings.settings['title']
self.response_number_text = 'Response ' + str(self.mtstatistics.response_number) + ' of ' + str(self.mtstatistics.total)
self.correct_so_far_text = str(self.mtstatistics.number_correct) + '/' + str(self.mtstatistics.response_number-1) + ' · ' + str(round(self.mtstatistics.percentage, 1)) + '%'
self.cue_text = self.format_cue()
def generate_mchoices(self):
'''Return the choices for the multiple choice questions'''
out = dict()
# Get responses for all mtags for this response
same_mtag_responses = []
for mtag in self.mtags:
same_mtag_responses += self.get_responses_by_mtag(mtag)
# Get responses of the same and the other plurality
plurality = self.is_plural(self.response)
same_plurality_responses = list(self.plural_responses) if plurality else list(self.nonplural_responses)
other_plurality_responses = list(self.nonplural_responses) if plurality else list(self.plural_responses)
# We will select first from same_mtag_responses. Then, if
# that's empty, we'll select from same_plurality_responses. If
# that's also empty, we'll resort to other_plurality_responses.
# Filter all three of these lists to make sure they don't contain
# the correct response
same_mtag_responses = [i for i in same_mtag_responses if i != self.response]
same_plurality_responses = [i for i in same_plurality_responses if i != self.response]
# The response won't be located in other_plurality_responses.
# Filter the pluarlity_responses lists
same_plurality_responses = [i for i in same_plurality_responses if i not in same_mtag_responses]
other_plurality_responses = [i for i in other_plurality_responses if i not in same_mtag_responses]
# Shuffle the response lists.
random.shuffle(same_mtag_responses)
random.shuffle(same_plurality_responses)
random.shuffle(other_plurality_responses)
# Get the index of the correct answer.
correct_letter = random.choice(self.ascii_range)
response_pool_consumption_index = 0
response_pool = same_mtag_responses
# Loop through the ascii range
for i in self.ascii_range:
# If we have the correct letter, output the correct response.
if i == correct_letter:
this_response = self.response
# Otherwise...
else:
# If the response_pool is empty...
while len(response_pool) == 0:
response_pool_consumption_index = response_pool_consumption_index + 1
if response_pool_consumption_index == 1:
response_pool = same_plurality_responses
elif response_pool_consumption_index == 2:
response_pool = other_plurality_responses
elif response_pool_consumption_index > 2:
raise NoResponsesError('There are no more responses available.')
this_response = response_pool.pop()
# Capitalize only the first letter of this_response
this_response = this_response[0].upper() + this_response[1:]
# Now that we have our choice, insert it into self.mchoices
out[i] = this_response
return out
def validate_input(self):
'''Determine if input is valid'''
self.mtstatistics.is_input_valid = False
if self.settings.level == '1':
if self.user_input in self.ascii_range:
self.mtstatistics.is_input_valid = True
else:
if self.user_input:
self.mtstatistics.is_input_valid = True
def standardize_string(self, string):
'''Standardize strings so they can be compared for correctness'''
# The idea here is that a question shouldn't be marked wrong just
# because the user forgot to enter a hyphen or a space or used the
# wrong case.
#
# Standarization involves the removal of all case, whitespace, and
# hyphens. This means the grading of questions is not case, whitespace,
# or hyphen sensitive.
# Remove case (transform to lowercase)
out = string.lower()
# Remove whitespace
out = ''.join(out.split())
# Remove hyphens
out = out.replace('-', '')
out = out.replace('–', '')
out = out.replace('—', '')
return out
def determine_equivalence(self):
'''See if input matches a synonym or standarized string'''
self.mtstatistics.is_input_correct = False
# If not, does the input match the response?
std_input = self.standardize_string(self.user_input)
std_response = self.standardize_string(self.response)
if std_input == std_response:
self.mtstatistics.used_response = self.response
self.mtstatistics.is_input_correct = True
if not self.mtstatistics.is_input_correct:
# If not, does the input match a synonym?
for synonym in self.synonyms:
std_synonym = self.standardize_string(synonym)
if std_input == std_synonym:
self.mtstatistics.used_synonym = synonym
self.mtstatistics.is_input_correct = True
def grade_input(self):
'''Determine whether input is correct.'''
if self.settings.level == '1':
# For level 1, check to see if the right letter was entered.
# First, translate the letter to its corresponding choice.
self.user_input = self.mchoices[self.user_input]
self.mtstatistics.is_input_correct = self.response.lower() == self.user_input.lower()
else:
# For levels 2 or 3, make sure the right input was entered.
self.determine_equivalence()
def finalize(self):
'''Notify the user of correctness, update statistics, and print'''
if self.mtstatistics.is_input_correct:
self.mtstatistics.number_correct += 1
if self.mtstatistics.has_synonym_been_used():
self.remaining_synonyms = [i for i in self.synonyms if i != self.mtstatistics.used_synonym]
self.correctness_str = 'Correct. Default answer: ' + self.response
else:
self.correctness_str = 'Correct.'
self.other_answers_str = 'Other correct responses: ' + ', '.join(self.synonyms)
else:
self.mtstatistics.number_incorrect += 1
self.mtstatistics.incorrect_responses.append(self.response)
self.correctness_str = 'Incorrect. Answer: ' + self.response
self.other_answers_str = 'Other correct responses: ' + ', '.join(self.synonyms)
self.mtstatistics.response_number += 1
# Reset
self.mtstatistics.used_synonym = ''
| 2.46875 | 2 |
uvicore/http/routing/auto_api.py | coboyoshi/uvicore | 0 | 12789087 | <filename>uvicore/http/routing/auto_api.py
# Do not import future here or http/bootstrap.py get_type_hints fails
# See https://bugs.python.org/issue41249
# NO from __future__ import annotations
import uvicore
import json
from uvicore.http.request import Request
from uvicore.http.params import Query
from uvicore.typing import Optional, Union, List, Any, Tuple, Generic, TypeVar
from uvicore.orm.query import OrmQueryBuilder
from uvicore.contracts import AutoApi as AutoApiInterface
from uvicore.support.dumper import dump, dd
from uvicore.http.exceptions import PermissionDenied
from uvicore.contracts import UserInfo
E = TypeVar("E")
@uvicore.service()
class AutoApi(Generic[E], AutoApiInterface[E]):
def __init__(self,
Model: E,
scopes: List = [],
*,
request: Request,
include: Optional[List[str]] = None,
where: Optional[str] = None
):
self.Model = Model
self.scopes = scopes
self.request = request
self.user: UserInfo = request.user
self.includes = self._build_include(include)
self.wheres = self._build_where(where)
@classmethod
def listsig(
request: Request,
include: Optional[List[str]] = Query([]),
where: Optional[str] = '',
):
pass
@classmethod
def getsig(
request: Request,
id: Union[str, int],
include: Optional[List[str]] = Query([]),
):
pass
"""
A URL is a ONE-TO-ONE mapping to an ORM QUERY
---------------------------------------------
HTTP: DELETE /api/posts?where={"creator_id":"1"} // mabe 500 posts
ORM: Post.query().where('creator_id', 1).delete()
SQL: DELETE FROM posts WHERE creator_id=1;
HTTP: PATCH /api/posts?where={"creator_id":"1"}
BODY would be the columns to update
{
'creator_id': 12
'owner_id': 5
}
ORM: Post.query().where('creator_id', 1).update('creator_id', 12).update('owner_id', 5)
SQL: UPDATE posts SET creator_id=12, owner_id=4 WHERE creator_id=1;
"""
def orm_query(self) -> OrmQueryBuilder[OrmQueryBuilder, E]:
"""Start a new Uvicore ORM Model QueryBuilder Query"""
query = self.Model.query()
# Include
#if include: query.include(*include.split(','))
if self.includes: query.include(*self.includes)
# Where
if self.wheres: query.where(self.wheres)
#dump(query.query)
return query
def guard_relations(self):
# No includes, skip
if not self.includes: return self
# User is superadmin, allow
if self.user.superadmin: return self
# Loop each include and parts
for include in self.includes:
# Includes are split into dotnotation "parts". We have to walk down each parts relations
parts = [include]
if '.' in include: parts = include.split('.')
entity = self.Model
for part in parts:
# Get field for this "include part". Remember entity here is not only Model, but a walkdown
# based on each part (separated by dotnotation)
field = entity.modelfields.get(part) # Don't use modelfield() as it throws exception
# Field not found, include string was a typo
if not field: continue
# Field has a column entry, which means its NOT a relation
if field.column: continue
# Field is not an actual relation
if not field.relation: continue
# Get actual relation object
relation = field.relation.fill(field)
# Get model permission string for this relation
model_permissions = [relation.entity.tablename + '.read'] if self.scopes['overridden'] == False else self.scopes['read']
#dump('CHILD MODEL PERMISSIONS:', model_permissions)
# User must have ALL scopes defined on the route (an AND statement)
authorized = True
missing_scopes = []
for scope in model_permissions:
if scope not in self.user.permissions:
authorized = False
missing_scopes.append(scope)
# # Check if user has permissino to child relatoin (or superadmin)
# if model_permission not in user.permissions:
# # I convert model_permissins to a list for consistency with other permission denied errors
# # although there will always be just one model_permission in this function
# # raise HTTPException(
# # status_code=401,
# # detail="Permission denied to {}".format(str([model_permission]))
# # )
# print('be')
# raise PermissionDenied(model_permission)
if not authorized:
raise PermissionDenied(missing_scopes)
# Walk down each "include parts" entities
entity = relation.entity
# if not field: continue
# if not field.relation: continue
# relation: Relation = field.relation.fill(field)
# tablename = relation.entity.tablename
# permission = tablename + '.read'
# # Check if user has permissino to child relatoin (or superadmin)
# if user.superadmin == False and permission not in user.permissions:
# raise HTTPException(
# status_code=401,
# detail="Access denied to {}".format(tablename)
# )
# Chainable
return self
def _build_include(self, includes: List):
if not includes: return
results = []
for include in includes:
if ',' in include:
results.extend(include.split(','))
else:
results.append(include)
return results
def _build_where(self, where_str: str) -> List[Tuple]:
# If where_str is already a Dict (from a JSON blog) convert to str first
if type(where_str) == dict: where_str = json.dumps(where_str)
dump('where_str', where_str)
wheres = []
if not where_str: return wheres
try:
# Convert where string JSON to python object
where_json = json.loads(where_str)
# Where must be a dict
if not isinstance(where_json, dict): return
# WORKS - where={"id": [">", 5]}
# WORKS - where={"id": ["in", [1, 2, 3]]}
# WORKS - where={"title": ["like", "%black%"]}
# WORKS - where={"id": 65, "topic_id": ["in", [1, 2, 3, 4, 5]]}
# WORKS - ?include=topic.section.space&where={"topic.slug": "/tools", "topic.section.slug": "/apps", "topic.section.space.slug": "/dev"}
for (key, value) in where_json.items():
#dump("Key: " + str(key) + " - Value: " + str(value))
if isinstance(value, List):
if len(value) != 2: continue # Valid advanced value must be 2 item List
operator = value[0]
value = value[1]
#query.where(key, operator, value)
wheres.append((key, operator, value))
else:
#query.where(key, value)
wheres.append((key, '=', value))
return wheres
except Exception as e:
#self.log.error(e)
dump(e)
| 2.453125 | 2 |
vmssz.py | muralipi/vmssdashboard | 56 | 12789088 | '''vmssz.py - class of basic Azure VM scale set operations, without UDs, with zones'''
import json
import azurerm
class VMSSZ():
'''VMSSZ class - encapsulates the model and status of a zone redundant VM scale set'''
def __init__(self, vmssname, vmssmodel, subscription_id, access_token):
'''class initializtion routine - set basic VMSS properties'''
self.name = vmssname
vmssid = vmssmodel['id']
self.rgname = vmssid[vmssid.index('resourceGroups/') + 15:vmssid.index('/providers')]
self.sub_id = subscription_id
self.access_token = access_token
self.model = vmssmodel
self.adminuser = \
vmssmodel['properties']['virtualMachineProfile']['osProfile']['adminUsername']
self.capacity = vmssmodel['sku']['capacity']
self.location = vmssmodel['location']
self.nameprefix = \
vmssmodel['properties']['virtualMachineProfile']['osProfile']['computerNamePrefix']
self.overprovision = vmssmodel['properties']['overprovision']
self.vm_instance_view = None
self.vm_model_view = None
self.pg_list = []
self.zones = []
if 'zones' in vmssmodel:
self.zonal = True
else:
self.zonal = False
# see if it's a tenant spanning scale set
self.singlePlacementGroup = True
if 'singlePlacementGroup' in vmssmodel['properties']:
self.singlePlacementGroup = vmssmodel['properties']['singlePlacementGroup']
self.tier = vmssmodel['sku']['tier']
self.upgradepolicy = vmssmodel['properties']['upgradePolicy']['mode']
self.vmsize = vmssmodel['sku']['name']
# if it's a platform image, or managed disk based custom image, it has
# an imageReference
if 'imageReference' in vmssmodel['properties']['virtualMachineProfile']['storageProfile']:
# if it's a managed disk based custom image it has an id
if 'id' in vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']:
self.image_type = 'custom'
self.offer = 'custom'
self.sku = 'custom'
img_ref_id = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']['id']
self.version = img_ref_id.split(".Compute/", 1)[1]
self.image_resource_id = img_ref_id.split(".Compute/", 1)[0]
else: # platform image
self.image_type = 'platform'
self.offer = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']['offer']
self.sku = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']['sku']
self.version = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']['version']
# else it's an unmanaged disk custom image and has an image URI
else:
self.image_type = 'custom'
if 'osType' in vmssmodel['properties']['virtualMachineProfile']['storageProfile']['osDisk']:
self.offer = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['osDisk']['osType']
else:
self.offer = 'custom'
self.sku = 'custom'
self.version = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['osDisk']['image']['uri']
self.provisioningState = vmssmodel['properties']['provisioningState']
self.status = self.provisioningState
def refresh_model(self):
'''update the model, useful to see if provisioning is complete'''
vmssmodel = azurerm.get_vmss(self.access_token, self.sub_id, self.rgname, self.name)
self.model = vmssmodel
self.capacity = vmssmodel['sku']['capacity']
self.vmsize = vmssmodel['sku']['name']
if self.image_type == 'platform':
self.version = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['imageReference']['version']
else:
self.version = vmssmodel['properties']['virtualMachineProfile']['storageProfile']['osDisk']['image']['uri']
self.provisioningState = vmssmodel['properties']['provisioningState']
self.status = self.provisioningState
self.init_vm_details()
def update_token(self, access_token):
'''update the token property'''
self.access_token = access_token
def update_model(self, newsku, newversion, newvmsize):
'''update the VMSS model with any updated properties'''
changes = 0
if self.sku != newsku:
if self.image_type == 'platform': # sku not relevant for custom image
changes += 1
self.model['properties']['virtualMachineProfile']['storageProfile']['imageReference']['sku'] = newsku
self.sku = newsku
else:
self.status = 'You cannot change sku setting for custom image'
if self.version != newversion:
changes += 1
self.version = newversion
if self.image_type == 'platform': # for platform image modify image reference
self.model['properties']['virtualMachineProfile']['storageProfile']['imageReference']['version'] = newversion
else:
# check for managed disk
if 'imageReference' in self.model['properties']['virtualMachineProfile']['storageProfile']:
self.model['properties']['virtualMachineProfile']['storageProfile'][
'imageReference']['id'] = self.image_resource_id + '.Compute/' + newversion
else:
# unmanaged custom image - has a URI which points directly
# to image blob
self.model['properties']['virtualMachineProfile']['storageProfile']['osDisk']['image']['uri'] = newversion
if self.vmsize != newvmsize:
changes += 1
# to do - add a check that the new vm size matches the tier
self.model['sku']['name'] = newvmsize
self.vmsize = newvmsize
if changes == 0:
self.status = 'VMSS model is unchanged, skipping update'
else:
# put the vmss model
updateresult = azurerm.update_vmss(self.access_token, self.sub_id, self.rgname,
self.name, json.dumps(self.model))
self.status = updateresult
def scale(self, capacity):
'''set the VMSS to a new capacity'''
self.model['sku']['capacity'] = capacity
scaleoutput = azurerm.scale_vmss(self.access_token, self.sub_id, self.rgname, self.name,
capacity)
self.status = scaleoutput
def poweron(self):
'''power on all the VMs in the scale set'''
result = azurerm.start_vmss(self.access_token, self.sub_id, self.rgname, self.name)
self.status = result
def restart(self):
'''restart all the VMs in the scale set'''
result = azurerm.restart_vmss(self.access_token, self.sub_id, self.rgname, self.name)
self.status = result
def poweroff(self):
'''power off all the VMs in the scale set'''
result = azurerm.poweroff_vmss(self.access_token, self.sub_id, self.rgname, self.name)
self.status = result
def dealloc(self):
'''stop deallocate all the VMs in the scale set'''
result = azurerm.stopdealloc_vmss(
self.access_token, self.sub_id, self.rgname, self.name)
self.status = result
def init_vm_instance_view(self):
'''get the VMSS instance view and set the class property'''
# get an instance view list in order to build FD heatmap
self.vm_instance_view = \
azurerm.list_vmss_vm_instance_view(self.access_token, self.sub_id, self.rgname,
self.name)
def init_vm_model_view(self):
'''get the VMSS instance view and set the class property'''
# get a model view list in order to build a zones heatmap
self.vm_model_view = \
azurerm.list_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name)
def reimagevm(self, vmstring):
'''reaimge individual VMs or groups of VMs in a scale set'''
result = azurerm.reimage_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def upgradevm(self, vmstring):
'''upgrade individual VMs or groups of VMs in a scale set'''
result = azurerm.upgrade_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def deletevm(self, vmstring):
'''delete individual VMs or groups of VMs in a scale set'''
result = azurerm.delete_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def startvm(self, vmstring):
'''start individual VMs or groups of VMs in a scale set'''
result = azurerm.start_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def restartvm(self, vmstring):
'''restart individual VMs or groups of VMs in a scale set'''
result = azurerm.restart_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def deallocvm(self, vmstring):
'''dealloc individual VMs or groups of VMs in a scale set'''
result = azurerm.stopdealloc_vmss_vms(self.access_token, self.sub_id, self.rgname,
self.name, vmstring)
self.status = result
def poweroffvm(self, vmstring):
'''power off individual VMs or groups of VMs in a scale set'''
result = azurerm.poweroff_vmss_vms(self.access_token, self.sub_id, self.rgname, self.name,
vmstring)
self.status = result
def get_power_state(self, statuses):
'''get power state from a list of VM isntance statuses'''
for status in statuses:
if status['code'].startswith('Power'):
return status['code'][11:]
def init_zones(self):
'''create a structure to represent VMs by zone and FD
- ignore placement groups for now.
'''
self.zones = []
for zone_id in range(1, 4):
zone = {'zone': zone_id}
fds = []
for fd_num in range(5):
fault_domain = {'fd': fd_num, 'vms': []}
fds.append(fault_domain)
zone['fds'] = fds
self.zones.append(zone)
def init_vm_details(self):
'''Populate the self.zones structure
- with a physically ordered representation of the VMs in a scale set.
'''
self.init_zones()
# get the model view
self.vm_model_view = azurerm.list_vmss_vms(self.access_token, self.sub_id, self.rgname,
self.name)
# get the instance view
self.vm_instance_view = azurerm.list_vmss_vm_instance_view(self.access_token, self.sub_id,
self.rgname, self.name)
# do a loop through the number of VMs and populate VMs properties in the zones structure
# make an assumption that len(vm_model_view) == len(vm_instance_view)
# - true if not actively scaling
for idx in range(len(self.vm_model_view['value'])):
vm_id = self.vm_model_view['value'][idx]['instanceId']
zone_num = self.vm_model_view['value'][idx]['zones'][0]
power_state = self.get_power_state(
self.vm_instance_view['value'][idx]['properties']['instanceView']['statuses'])
fault_domain = self.vm_instance_view['value'][idx]['properties']['instanceView']['platformFaultDomain']
vm_data = {'vmid': vm_id, 'power_state': power_state}
self.zones[int(zone_num)-1]['fds'][fault_domain]['vms'].append(vm_data)
#print(json.dumps(self.zones))
| 2.46875 | 2 |
nyc/core/CoreUtils.py | imohitawasthi/nyc | 0 | 12789089 | from nltk.corpus import stopwords
from nltk.stem.lancaster import LancasterStemmer
from utils import Constants
from utils import Utils
####################################################################################
####################################################################################
####################################################################################
# NAIVE BAYES SPECIFIC FUNCTIONS
####################################################################################
####################################################################################
####################################################################################
def create_classification_corpus(data_metric, regex):
"""
:param data_metric:
:param regex: regular expression for text extraction
:param df: path to the data set
:return: tools require for classification engines
df_class,df_words,df_class_count --- refer to ClassificationEngine.py for more details
business logic behind init tools is written here, it basically loops around the
entire data set and separate them into three different components
"""
speech_count, classes, words, word_set, class_words = {}, {}, {}, {}, {}
stem = LancasterStemmer()
stop = set(stopwords.words('english'))
for c in list(set(data[-1] for data in data_metric)):
classes[c] = []
for data in data_metric:
in_class = data[Constants.LABEL_INDEX]
in_speech = data[Constants.CLASSIFICATION_SPEECH_INDEX]
words.update(word_set)
if in_class not in class_words:
class_words[in_class] = [[]]
else:
class_words[in_class].append([])
# word_set = {}
for w in Utils.custom_tokenizer(regex, in_speech.lower()):
# word_set_temp = {}
if w not in stop:
stem_word = stem.stem(w)
word_set[stem_word] = 1 if stem_word not in word_set else word_set[stem_word] + 1
# word_set_temp[stem_word] = word_set[stem_word]
class_words[in_class][len(class_words[in_class])-1].append(stem_word)
# if word_set_temp[stem_word] < 2:
# classes[in_class].extend(word_set_temp)
classes[in_class].append(stem_word)
speech_count[in_class] = 1 if in_class not in speech_count else speech_count[in_class] + 1
return classes, words, speech_count, class_words
def get_word_probabilities(df_class, df_word, df_class_count, frame_class_words):
"""
:param frame_class_words:
:param df_class: all Classes and words (grouped by classes) - dict
:param df_word: all words and word frequencies - dict
:param df_class_count: all classes and class frequencies - dict
:param initial_probabilities: initial probability of any class present in the df_class
:return: every word with probability of classes(word can be in that particular class) - dict
"""
probabilities = {}
for w in df_word:
for c in df_class:
if w not in probabilities:
probabilities[w] = {}
#probability = ((df_class[c].count(w) / len(df_class[c])) * (
# df_class_count[c] / sum(df_class_count.values()))) / (df_word[w] / sum(df_word.values()))
#probability = ((df_class[c].count(w) / len(df_class[c])) * (
# df_word[w] / sum(df_word.values()))) / (df_class_count[c] / sum(df_class_count.values()))
probability_class_words = len([x for x in frame_class_words[c] if w in x]) / len(frame_class_words[c])
probability_words = (df_class[c].count(w) / len(df_class[c]))
#probability_words = (df_word[w] / sum(df_word.values()))
probability_class = (df_class_count[c] / sum(df_class_count.values()))
probability = 0 if probability_words == 0 else (probability_class_words*probability_class)/probability_words
probabilities[w].update({c: probability})
return probabilities
def get_other_class_probabilities(class_probabilities):
"""
:param class_probabilities: probabilities of each class calculated using user input and Naive Bayes word_probabilities
:return: sum of all probabilities
"""
return sum(class_probabilities[c] for c in class_probabilities)
def classify_naive_bayes(speech, probabilities, frame_class, regex):
tokens = Utils.prepare_tokens(speech, regex, set(stopwords.words('english')), LancasterStemmer())
class_probabilities = {}
classify = {}
for c in frame_class:
class_probabilities[c] = 0
for meta in probabilities:
if meta in tokens:
for c in frame_class:
class_probabilities[c] += probabilities[meta][c]
#else:
# for c in frame_class:
# class_probabilities[c] += 1.0 - probabilities[meta][c]
#for c in frame_class:
# class_probabilities[c] = class_probabilities[c]
for c in frame_class:
classify[c] = class_probabilities[c] #/ get_other_class_probabilities(class_probabilities)
return classify
####################################################################################
####################################################################################
####################################################################################
# DECISION TREE SPECIFIC FUNCTIONS
####################################################################################
####################################################################################
####################################################################################
def is_numeric(value): return isinstance(value, int) or isinstance(value, float)
def build_decision_tree(data_metric):
gain, question = find_best_split(data_metric)
if gain == 0:
return Leaf(data_metric)
true_rows, false_rows = partition(data_metric, question)
true_branch = build_decision_tree(true_rows)
false_branch = build_decision_tree(false_rows)
return DecisionNode(question, true_branch, false_branch)
def find_best_split(data_metric):
best_gain = 0
best_question = None
current_uncertainty = gini(data_metric)
n_features = len(data_metric[0]) - 1
for col in range(n_features):
values = set([row[col] for row in data_metric])
for val in values:
question = Question(col, val)
true_rows, false_rows = partition(data_metric, question)
if len(true_rows) == 0 or len(false_rows) == 0:
continue
gain = info_gain(true_rows, false_rows, current_uncertainty)
if gain >= best_gain:
best_gain, best_question = gain, question
return best_gain, best_question
def gini(data_metric):
counts = class_count(data_metric)
impurity = 1
for l in counts:
prob_of_l = counts[l] / float(len(data_metric))
impurity -= prob_of_l ** 2
return impurity
def class_count(data_metric):
counts = {}
for row in data_metric:
label = row[Constants.LABEL_INDEX]
counts[label] = 1 if label not in counts else counts[label] + 1
return counts
def info_gain(left, right, current_uncertainty):
p = float(len(left)) / (len(left) + len(right))
return current_uncertainty - p * gini(left) - (1 - p) * gini(right)
def partition(data_metric, question):
true_rows, false_rows = [], []
for row in data_metric:
true_rows.append(row) if question.match(row) else false_rows.append(row)
return true_rows, false_rows
class Leaf:
def __init__(self, data_metric):
self.predictions = class_count(data_metric)
class DecisionNode:
def __init__(self, question, true_branch, false_branch):
self.question = question
self.true_branch = true_branch
self.false_branch = false_branch
class Question:
def __init__(self, col, val):
self.col = col
self.val = val
def match(self, example):
val = example[self.col]
try:
return val >= self.val if is_numeric(val) else val == self.val
except TypeError:
return False
def classify_decision_tree(row, tree):
if isinstance(tree, Leaf):
return tree.predictions
return \
classify_decision_tree(row,
tree.true_branch) \
if tree.question.match(row) \
else classify_decision_tree(row,
tree.false_branch)
| 1.9375 | 2 |
script/stereograph_pointcloud.py | 7675t/theta_camera | 0 | 12789090 | <reponame>7675t/theta_camera
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function
# THEATAの画像を取得，球体のPointCloudとして出力する
import sys
import rospy
import cv2
from sensor_msgs.msg import Image
from cv_bridge import CvBridge, CvBridgeError
import numpy as np
from sensor_msgs.msg import PointCloud2, PointField
import sensor_msgs.point_cloud2 as pcl2
from std_msgs.msg import Header
def create_cloud_xyz32rgb(header, points):
"""
Create a L{sensor_msgs.msg.PointCloud2} message with 3 float32 fields (x, y, z).
@param header: The point cloud header.
@type header: L{std_msgs.msg.Header}
@param points: The point cloud points.
@type points: iterable
@return: The point cloud.
@rtype: L{sensor_msgs.msg.PointCloud2}
"""
fields = [PointField('x', 0, PointField.FLOAT32, 1),
PointField('y', 4, PointField.FLOAT32, 1),
PointField('z', 8, PointField.FLOAT32, 1),
PointField('rgb', 12, PointField.UINT32, 1)]
return pcl2.create_cloud(header, fields, points)
class point_cloud_converter:
def __init__(self):
self.bridge = CvBridge()
self.center_x = rospy.get_param("center_x", 310)
self.center_y = rospy.get_param("center_y", 320)
self.radius = rospy.get_param("radius", 285)
self.sphere_radius = 1.0
self.step = 2
self.face_sub = rospy.Subscriber("face/image_raw", Image, self.callback_face)
self.rear_sub = rospy.Subscriber("rear/image_raw", Image, self.callback_rear)
self.image_pub = rospy.Publisher("image_out", Image, queue_size=1)
self.face_point_pub = rospy.Publisher("face_points", PointCloud2, queue_size=1)
self.rear_point_pub = rospy.Publisher("rear_points", PointCloud2, queue_size=1)
def callback_face(self,data):
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print(e)
(rows,cols,channels) = cv_image.shape
# cv2.circle(cv_image, (self.center_x, self.center_y), self.radius, (0, 255, 0))
# 単位球面上での等分の離散化(theta, phi)
sphere_image = np.ndarray([int(90 / self.step)+1, int(360 / self.step)+1, channels], dtype=np.uint8)
# 点群もついでに作成
points = []
for theta_i in range(int(90 / self.step) + 1):
for phi_i in range(int(360 / self.step) + 1):
theta = self.step * theta_i * np.pi / 180
phi = self.step * phi_i * np.pi / 180
# 単位球面上の３次元座標(xs, ys, zs)
xs = np.sin(theta)*np.cos(phi)
ys = np.sin(theta)*np.sin(phi)
zs = np.cos(theta)
# 立体射影(THETA)上の座標(xt, yt)
xt = self.center_x + self.radius * xs / (1 + zs)
yt = self.center_y + self.radius * ys / (1 + zs)
try:
color = cv_image[int(xt), int(yt)]
except:
print(xs, ys, zs)
print(int(xt), int(yt))
# 球面に写しとる
sphere_image[theta_i, phi_i] = color
icolor = int((color[2] << 16) | (color[1] << 8) | color[0])
points.append([self.sphere_radius * xs, self.sphere_radius * ys, self.sphere_radius * zs, int(icolor)])
#create pcl from points
header = Header()
header.stamp = rospy.Time.now()
header.frame_id = 'face_frame'
cloud = create_cloud_xyz32rgb(header, points)
try:
self.image_pub.publish(self.bridge.cv2_to_imgmsg(sphere_image, "bgr8"))
except CvBridgeError as e:
print(e)
self.face_point_pub.publish(cloud)
def callback_rear(self,data):
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print(e)
(rows,cols,channels) = cv_image.shape
# cv2.circle(cv_image, (self.center_x, self.center_y), self.radius, (0, 255, 0))
# 単位球面上での等分の離散化(theta, phi)
sphere_image = np.ndarray([int(90 / self.step)+1, int(360 / self.step)+1, channels], dtype=np.uint8)
# 点群もついでに作成
points = []
for theta_i in range(int(90 / self.step) + 1):
for phi_i in range(int(360 / self.step) + 1):
theta = self.step * theta_i * np.pi / 180
phi = self.step * phi_i * np.pi / 180
# 単位球面上の３次元座標(xs, ys, zs)
xs = np.sin(theta)*np.cos(phi)
ys = np.sin(theta)*np.sin(phi)
zs = np.cos(theta)
# 立体射影(THETA)上の座標(xt, yt)
xt = self.center_x + self.radius * xs / (1 + zs)
yt = self.center_y + self.radius * ys / (1 + zs)
try:
color = cv_image[int(xt), int(yt)]
except:
print(xs, ys, zs)
print(int(xt), int(yt))
# 球面に写しとる
sphere_image[theta_i, phi_i] = color
icolor = int((color[2] << 16) | (color[1] << 8) | color[0])
points.append([self.sphere_radius * xs, self.sphere_radius * ys, self.sphere_radius * zs, int(icolor)])
#create pcl from points
header = Header()
header.stamp = rospy.Time.now()
header.frame_id = 'rear_frame'
cloud = create_cloud_xyz32rgb(header, points)
self.rear_point_pub.publish(cloud)
def main(args):
pc = point_cloud_converter()
rospy.init_node('point_cloud_converter', anonymous=True)
try:
rospy.spin()
except KeyboardInterrupt:
print("Shutting down")
cv2.destroyAllWindows()
if __name__ == '__main__':
main(sys.argv)
| 2.484375 | 2 |
senko.py | mtsev/senko | 6 | 12789091 | #!/usr/bin/env python3
import os
import logging
import yaml
from discord.ext.commands import Bot, Context, CommandError, CommandOnCooldown
# create logger
log = logging.getLogger(__package__)
log.setLevel(logging.DEBUG)
# create file handler which logs even debug messages
fh = logging.FileHandler('../senko.log')
fh.setLevel(logging.DEBUG)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.WARNING)
# create formatter and add it to the handlers
formatter = logging.Formatter('[%(asctime)s] %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# add the handlers to the logger
log.addHandler(fh)
log.addHandler(ch)
# Import config file
with open('config.yaml') as stream:
config = yaml.safe_load(stream)
# Initialise bot
bot = Bot(command_prefix=config['prefix'])
bot.remove_command('help')
bot.owner = config['owner']
bot.keys = config['keys']
bot.db = config['database']
bot.quiet = config['quiet']
bot.dt = config['dt_channels']
# Load cogs
for file in filter(lambda file: file.endswith('.py'), os.listdir('./cogs')):
bot.load_extension(f'cogs.{file[:-3]}')
# Log bot startup
@bot.event
async def on_ready() -> None:
log.warning(f'We have logged in as {bot.user} in these servers:')
for guild in bot.guilds:
log.warning(f'{guild.name} ({guild.id})')
log.warning(f'({len(bot.guilds)} servers)')
log.warning('************************')
# Handle command cooldown
@bot.event
async def on_command_error(ctx: Context, error: CommandError) -> None:
if isinstance(error, CommandOnCooldown):
await ctx.send(error)
# Start bot
bot.run(config['token']) | 2.265625 | 2 |
instagramNotifier.py | akaeme/InstagramNotifier | 0 | 12789092 | import argparse
# from fbchat.models import *
import logging
import os
import sys
import urllib.request
from getpass import getpass
from time import sleep
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from fbchat import Client
from API.InstagramAPI import InstagramAPI
from databaseUtils import Database
logger = logging.getLogger('instagramNotifier')
hdlr = logging.FileHandler('instagramNotifier.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.INFO)
database = Database('InstagramNotifier.db')
MESSAGE_HEADER = 'Check out the new %s\'s photo on instagram! \n'
MESSAGE_BODY = 'The photo was taken in %s, it has size %sx%s and as we can see it is of great quality :) \n'
MESSAGE_FOOTER = 'This was generated by a bot to help you by notifying you of everything that is important. ' \
'Do not consider it as spam.\n'
def login(user_, passw):
"""Login on Instagram"""
instagram_api = InstagramAPI(username=user_, password=<PASSWORD>)
if instagram_api.login(): # login
return True, instagram_api
else:
return False, ''
def follow_closely(api_, follow_username):
"""Search for the user"""
big_list = True
max_id = ''
following = []
while big_list:
api_.getSelfUsersFollowing(maxid=max_id)
followers_ = api_.LastJson
for f in followers_['users']:
following.append(f)
big_list = followers_['big_list']
if not big_list:
break
# this key only exists if there is more pages
max_id = followers_['next_max_id']
for f in following:
if f['username'] == follow_username:
return True, f
def get_message(message_type, source, data=None):
"""Get the notify message"""
if message_type == 'image':
header = (MESSAGE_HEADER % source)
body = (MESSAGE_BODY % (data['location'], data['width'], data['height']))
urllib.request.urlretrieve(data['last_media'], 'tmp.jpg')
return header + body
else:
header = (MESSAGE_HEADER % source)
return header + MESSAGE_FOOTER
def alert(user, follow, data, client_fb):
"""Get the notify message"""
users_notify = database.get_from_notify(username=user, username_follow=follow)
for user in users_notify:
if user['thread_type'] == '0':
if user['image_flag']:
message = get_message(message_type='image', source=follow, data=data)
client_fb.sendLocalImage(image_path='tmp.jpg', message=message, thread_id=str(user['thread_id']))
client_fb.sendMessage(message=MESSAGE_FOOTER, thread_id=str(user['thread_id']))
logger.info('User %s notified %s on facebook.', user, str(user['thread_id']))
# clean image created
os.remove('tmp.jpg')
else:
message = get_message(message_type='no_image', source=follow)
client_fb.sendMessage(message=message, thread_id=str(user['thread_id']))
logger.info('%s got notified on facebook.', str(user['thread_id']))
def run(api_, user_):
"""Run bot"""
email_fb = input('Facebook email: ')
pass_fb = getpass(prompt='Facebook password: ')
client_fb = Client(email=email_fb, password=pass_fb, logging_level=logging.CRITICAL)
try:
print('Running..')
while True:
follows = database.get_from_follows(username=user_)
medias = database.get_from_media(username=user_)
for f_closely, username_follow, id_ in follows:
data = dict(last_media_id=0, media_count=0, user_id=0, last_media='', width=0, height=0, location='')
data['user_id'] = f_closely
api_.getUsernameInfo(str(f_closely))
media_results = api_.LastJson
data['media_count'] = media_results['user']['media_count']
api_.getUserFeed(str(f_closely))
media_results = api_.LastJson
last_media = media_results['items'][0]
try:
data['last_media_id'] = int(last_media['pk'])
data['last_media'] = last_media['image_versions2']['candidates'][0]['url']
data['width'] = last_media['image_versions2']['candidates'][0]['width']
data['height'] = last_media['image_versions2']['candidates'][0]['height']
data['location'] = last_media['location']['name']
except KeyError:
# for debugging
print('KeyError')
data_ = [media for media in medias if media['user_id'] == data['user_id']][0]
if data['last_media_id'] != data_['last_media_id']:
alert(user=user_, follow=username_follow, data=data, client_fb=client_fb)
# Update info on database
database.update_media(last_media_id=data['last_media_id'], media_count=data['media_count'],
foreign_id=id_, last_media=data['last_media'], width=data['width'],
height=data['height'],
location=data['location'], last_media_id_=data_['last_media_id'])
logger.info('Update media for user %s.', data['user_id'])
print('Sleeping')
sleep(120)
except KeyboardInterrupt:
print('Interrupted!')
def get_info(api_, user_id):
"""Save info of the follower"""
data = dict(last_media_id=0, media_count=0, user_id=0, last_media='', width=0, height=0, location='')
data['user_id'] = user_id
api_.getUsernameInfo(user_id)
media_results = api_.LastJson
data['media_count'] = media_results['user']['media_count']
api_.getUserFeed(user_id)
media_results = api_.LastJson
last_media = media_results['items'][0]
try:
data['last_media_id'] = int(last_media['pk'])
data['last_media'] = last_media['image_versions2']['candidates'][0]['url']
data['width'] = last_media['image_versions2']['candidates'][0]['width']
data['height'] = last_media['image_versions2']['candidates'][0]['height']
data['location'] = last_media['location']['name']
except KeyError:
# for debugging
print('KeyError')
exit()
return data
def validate_user(user_, passw, service):
"""Validate a user according to the service"""
if service == 'instagram':
results = database.get_from_users(username=user_, service=service)
elif service == 'facebook':
results = database.get_from_users(username=user_, service=service)
else:
print('Unknown service')
return False
if len(results) == 0:
print('User not registered.')
return False
# it return a list of tuples, dunno why
password_hash = str(results[0][0])
digest_ = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest_.update(bytes(passw, 'utf8'))
if password_hash == str(digest_.finalize().hex()):
logger.info('User %s validated on %s', user_, service)
return True
logger.warning('User %s not validated on %s. Hash do not match.', user_, service)
return False
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='Instagram Notifier. It get new posts from user that we want to follow closely and notify other '
'users on facebook messenger')
parser.add_argument('-u', action="store_true", dest='user', help='Add a valid user to the database.')
parser.add_argument('-f', action="store_true", dest='follow', help='Add someone to follow closely.')
parser.add_argument('-n', action="store_true", dest='notify', help='Add someone to get notified on facebook '
'messenger.')
parser.add_argument('-r', action="store_true", dest='run', help='Run Instagram Notifier.')
args = parser.parse_args()
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
args = vars(args)
username = input('Instagram username: ')
password = getpass(prompt='Instagram password: ')
if args['user']:
flag, api = login(user_=username, passw=password)
if flag:
print('Login success!')
email = input('Facebook email: ')
password_fb = getpass(prompt='Facebook password: ')
try:
client = Client(email, password_fb, logging_level=logging.CRITICAL)
except Exception:
print('Facebook - invalid username or password. Try again!')
else:
print('Login success!')
# Add confirmed user to database
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(bytes(password, 'utf8'))
insta_hash = digest.finalize().hex()
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(bytes(password_fb, 'utf8'))
fb_hash = digest.finalize().hex()
database.insert_user(username=username, password=<PASSWORD>, email=email, password_fb=fb_hash)
logger.info('User %s inserted on database.', username)
client.logout()
else:
print('Invalid username or password. Try again!')
exit()
if args['follow']:
if validate_user(user_=username, passw=password, service='instagram'):
# flag will be always True
flag, api = login(user_=username, passw=password)
follow_user = input('Let\'s follow (you must know the instagram username of the person ): ')
flag, info = follow_closely(api_=api, follow_username=follow_user)
if flag:
# add to the database
id_row = database.insert_follow(user_id=info['pk'], username=info['username'], user=username,
full_name=info['full_name'], is_private=info['is_private'],
profile_pic=info['profile_pic_url'])
# get actual info about feed and save it
data = get_info(api_=api, user_id=info['pk'])
database.insert_media(last_media_id=data['last_media_id'], media_count=data['media_count'],
foreign_id=id_row, last_media=data['last_media'], width=data['width'],
height=data['height'], location=data['location'])
logger.info('User %s is now following closely %s.', username, follow_user)
else:
print('You are not following the user with the instagram username: ' + follow_user)
else:
print('Invalid username or password. Try again!')
exit()
if args['notify']:
email = input('Facebook email: ')
password_fb = getpass(prompt='Facebook password: ')
if validate_user(user_=email, passw=<PASSWORD>, service='facebook'):
client = Client(email=email, password=<PASSWORD>, logging_level=logging.CRITICAL)
notify = input('Let\'s notify (you must know the facebook name of the person ): ')
# It take in consideration only the first 10 friends, exclude non friends
notify = client.searchForUsers(name=notify, limit=10)
friends = sorted([x for x in notify if x.is_friend], key=lambda x: x.uid)
print('There are many friends with this name: ')
print('\n'.join('{} -> name: {}, photo: {}'.format(i, k.name, k.photo) for i, k in
enumerate(friends)))
io = input('Choose one of them: ')
notify = friends[int(io)]
print('This person should receive notifications about whom?')
follow_ = sorted([f[1] for f in database.get_from_follows(username=username)])
print('\n'.join('{}: {}'.format(*k) for k in enumerate(follow_)))
to_notify = input('Choose the people you want to notify(ie: 1,2): ')
to_notify = [int(s.replace(' ', '')) for s in to_notify.split(',')]
to_notify = [follow_[x] for x in to_notify]
for person in to_notify:
id_follow = database.get_from_follows_find(username=username, username_follow=person)[0]
database.insert_notify(foreign_id=id_follow, thread_id=notify.uid, thread_type=0, image_flag=1)
logger.info('User %s will notify %s about something.', username, notify)
if args['run']:
if validate_user(user_=username, passw=password, service='instagram'):
# flag will be always True
flag, api = login(user_=username, passw=password)
run(api_=api, user_=username)
| 2.484375 | 2 |
ros/src/control/servers/heave.py | srmauvsoftware/URSim | 30 | 12789093 | #!/usr/bin/env python
from control.msg import heaveFeedback, heaveAction, heaveResult
import rospy
import time
import actionlib
class Heave(object):
feedback = heaveFeedback()
result = heaveResult()
def __init__(self, name):
self.heavePub = rospy.Publisher('/heave_setpoint', Float64, queue_size=1)
rospy.Subscriber("/heave", Float64, self.heaveCallback)
self.serverName = name
self.heaveServer = actionlib.SimpleActionServer(
self.serverName,
heaveAction,
execute_cb=self.heaveActionCallback,
auto_start=False)
self.heaveServer.start()
def heaveCallback(self, data):
self.heave = data.data
def heaveActionCallback(self, goal):
success = False
while(goal.heave_setpoint != self.heave):
start = int(time.time())
while(abs(goal.heave_setpoint - self.heave) < 3):
if(int(time.time()) == start + 10):
success = True
break
if(successt):
break
self.heavePub.publish(goal.heave_setpoint)
rospy.loginfo('heave: %f, heave Setpoint: %f, Error: %f', \
self._heave, req.heave_setpoint, \
req.heave_setpoint-self.heave)
if success:
self.result.heave_final = self.heave
rospy.loginfo('%s : Success' % self.serverName)
self.heaveServer.set_succeeded(self.result)
if __name__ == '__main__':
rospy.init_node('heaveServer')
server = Heave(rospy.get_name())
rospy.spin()
| 2.453125 | 2 |
denma_contact_form/migrations/0004_remove_contactform_subscribed_user.py | denma-group/website-backend-django | 0 | 12789094 | <filename>denma_contact_form/migrations/0004_remove_contactform_subscribed_user.py
# Generated by Django 2.2 on 2019-09-05 23:51
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('denma_contact_form', '0003_auto_20190905_1300'),
]
operations = [
migrations.RemoveField(
model_name='contactform',
name='subscribed_user',
),
]
| 1.335938 | 1 |
Pyton_Exp/__temp_migrations/vote_s/0003_group_tipo_votante.py | hbahamonde/Vote_Buying_Inequality | 0 | 12789095 | <gh_stars>0
# Generated by Django 2.2.12 on 2021-03-26 13:39
from django.db import migrations
import otree.db.models
class Migration(migrations.Migration):
dependencies = [
('vote_s', '0002_auto_20210326_1039'),
]
operations = [
migrations.AddField(
model_name='group',
name='tipo_votante',
field=otree.db.models.IntegerField(default=0, null=True),
),
]
| 1.453125 | 1 |
src/main/resources/archetype-resources/src/test/resources/robotframework/quickstart/testlibs/LoginLibrary.py | MarkusBernhardt/robotframework-archetype-quickstart | 2 | 12789096 | import os
import sys
class LoginLibrary:
def __init__(self):
self._sut_path = os.path.join(os.path.dirname(__file__),
'..', 'sut', 'login.py')
self._status = ''
def create_user(self, username, password):
self._run_command('create', username, password)
def change_password(self, username, old_pwd, new_pwd):
self._run_command('change-password', username, old_pwd, new_pwd)
def attempt_to_login_with_credentials(self, username, password):
self._run_command('login', username, password)
def status_should_be(self, expected_status):
if expected_status != self._status:
raise AssertionError("Expected status to be '%s' but was '%s'"
% (expected_status, self._status))
def _run_command(self, command, *args):
command = '"%s" %s %s' % (self._sut_path, command, ' '.join(args))
process = os.popen(command)
self._status = process.read().strip()
process.close()
| 2.875 | 3 |
development/workflow/raw_container.py | pingsutw/flyte-app | 7 | 12789097 | import logging
from flytekit import ContainerTask, kwtypes, task, workflow
logger = logging.getLogger(__file__)
calculate_ellipse_area_shell = ContainerTask(
name="ellipse-area-metadata-shell",
input_data_dir="/var/inputs",
output_data_dir="/var/outputs",
inputs=kwtypes(a=float, b=float),
outputs=kwtypes(area=float, metadata=str),
image="pingsutw/raw:v2",
command=[
"sh",
"-c",
"./calculate-ellipse-area.sh /var/inputs /var/outputs;",
],
)
@task
def report_all_calculated_areas(
area_shell: float,
metadata_shell: str,
):
logger.info(f"shell: area={area_shell}, metadata={metadata_shell}")
@workflow
def wf(a: float = 2.0, b: float = 3.0):
area_shell, metadata_shell = calculate_ellipse_area_shell(a=a, b=b)
report_all_calculated_areas(
area_shell=area_shell,
metadata_shell=metadata_shell,
)
if __name__ == "__main__":
print(f"Running wf() {wf(a=2.0, b=3.0)}")
| 2.15625 | 2 |
core_pipeline.py | Kelsiii/Gaze | 0 | 12789098 | <gh_stars>0
from gaze.pipes import Graph
from gaze.nodes import NetworkSource
from gaze.nodes import NetworkSink
import os
IN_IP="0.0.0.0"
IN_PORT=5001
OUT_IP = os.getenv("OUT_IP") if os.getenv("OUT_IP") else "127.0.0.1"
OUT_PORT = int(os.getenv("OUT_PORT")) if os.getenv("OUT_PORT") else 5001
print(IN_IP,IN_PORT,OUT_IP,OUT_PORT)
x = NetworkSource(ip=IN_IP,port=IN_PORT)
x = NetworkSink(ip=OUT_IP,port=OUT_PORT)(x)
graph = Graph(x)
graph.run()
| 2.453125 | 2 |
research-analytics/dashboard.py | jhupiterz/research-analytics | 0 | 12789099 | #--------------------------------------------------------------------------#
# This code makes use of all other functions of #
# the package to build a Dash Web App #
#--------------------------------------------------------------------------#
# imports ------------------------------------------------------------------
import plots
import utils
from data_collection import semantic_api
from data_preprocessing import data_preprocess
import requests
import pandas as pd
import dash
import dash_cytoscape as cyto
from dash import dcc
from dash import html
from dash.dependencies import Input, Output
# Data loading and cleaning with Semantic Scholar API -----------------------
#df, all_references_df, total_results, query = semantic_api.get_all_results_from_semantic_scholar()
# Instantiate Dash App ------------------------------------------------------
app = dash.Dash(
__name__, suppress_callback_exceptions = True,
meta_tags=[{"name": "viewport", "content": "width=device-width, initial-scale=1", 'charSet':'“UTF-8”'}])
server = app.server
app.title = "Research Analytics"
# Layout --------------------------------------------------------------------
app.layout = html.Div(
[
# Banner ------------------------------------------------------------
html.Div(
[
html.A(
[
html.Img(
src="/assets/web.png",
alt="research intelligence"
),
html.H3("research analytics")
],
href="https://jhupiterz.notion.site/Welcome-to-research-intelligence-\
a36796f418b040f6ade944f9c54e87cb",
target='_blank',
className="logo-banner",
),
html.Div(
[
html.A(
"Contribute",
href="https://github.com/jhupiterz/research-analytics",
target='_blank',
className="doc-link"
),
html.A(
"Documentation",
href="https://github.com/jhupiterz/research-analytics/blob/main/README.md",
target='_blank',
className="doc-link"
),
],
className="navbar"
),
],
className="banner",
),
# Search bar ------------------------------------------------------------
html.Div(
[
html.H1(id='topic', children=[]),
html.Div(
[
html.Img(
src='/assets/loupe.png',
className="loupe-img",
),
dcc.Input(
id='search-query',
type = 'text',
placeholder = "Search for keywords (e.g. \"carbon nanotubes\")",
debounce = True,
spellCheck = True,
inputMode = 'latin',
name = 'text',
autoFocus = False,
minLength = 1, maxLength = 60,
autoComplete='off',
disabled = False,
readOnly = False,
size = '60',
n_submit = 0,
),
],
className="search-bar",
),
],
className="search-wrapper"
),
dcc.Store(id='store-initial-query-response', storage_type='memory'),
dcc.Store(id='store-references-query-response', storage_type='memory'),
# Main content ----------------------------------------------------------
html.Div(id='start-page', children=[], className = 'main-body'),
# Footer ----------------------------------------------------------------
html.Footer(
[
html.P(
[
"Built with ",
html.A("Plotly Dash", href="https://plotly.com/dash/", target="_blank")
],
),
html.P(
[
"Powered by ",
html.A("Semantic Scholar", href="https://www.semanticscholar.org/", target="_blank")
],
),
]
),
],
className="app-layout",
)
# Callbacks --------------------------------------------------------------------
# Store response of initial API query
@app.callback(
Output('store-initial-query-response', 'data'),
Input('search-query', 'n_submit'),
Input('search-query', 'value'))
def store_primary_data(n_submit, value):
if n_submit > 0:
url = f"https://api.semanticscholar.org/graph/v1/paper/search?query={value}&limit=30&fields=url,title,abstract,authors,venue,year,referenceCount,citationCount,influentialCitationCount,isOpenAccess,fieldsOfStudy"
response = requests.get(url).json()
df = pd.DataFrame(response['data'])
df = data_preprocess.extract_key_words(df)
return {
'data': df.to_dict("records")
}
# Store dictionary of references of all initial papers
@app.callback(
Output('store-references-query-response', 'data'),
Input('store-initial-query-response', 'data'))
def store_references_data(data):
if data != None:
ref_dict = []
for paper in data['data']:
paper_id = paper['paperId']
url = f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/references?limit=50&fields=intents,isInfluential,paperId,url,title,abstract,venue,year,referenceCount,citationCount,influentialCitationCount,isOpenAccess,fieldsOfStudy,authors"
response = requests.get(url).json()
ref_data = response['data']
for cited_paper in ref_data:
cited_paper['citedPaper']['citedBy'] = paper_id
ref_dict.append(cited_paper['citedPaper'])
return ref_dict
# Displays start page
@app.callback(
Output('start-page', 'children'),
Input('search-query', 'n_submit'))
def render_content(n_submit):
""" Returns the content of start page.
If there is data then returns tabs
Else, returns default content of start page (blog posts)"""
if n_submit > 0:
return (
html.Div([
dcc.Tabs(id="tabs-example-graph", value = 'tab-1-example-graph', className= "tabs",
children=[
dcc.Tab(label='📊 Search results 📊', value='tab-1-example-graph',
className= "single-tab", selected_className= "single-tab-selected"),
dcc.Tab(label='🤝 Author network 🤝', value='tab-2-example-graph',
className= "single-tab", selected_className= "single-tab-selected"),
dcc.Tab(label='🌐 Paper network 🌐', value='tab-3-example-graph',
className= "single-tab", selected_className= "single-tab-selected")
])
], className= "tabs-container"),
html.Br(),
html.Div(id='tabs-content-example-graph'))
else:
return html.Div(
[
html.Hr(),
html.P("👇 Or check out the latest blog posts about data-driven academia 👇"), html.Br(),
html.Div([
html.A(
href="https://medium.com/@juhartz/are-scholarly-papers-really-the-best-way-to-disseminate-research-f8d85d3eee62",
children=[
html.Img(
alt="Link to my twitter",
src="assets/blogpost_1.png",
className="zoom"
)
], target= '_blank', className= "blog-post-1"
),
html.A(
href="https://medium.com/@juhartz/what-makes-a-research-paper-impactful-a40f33206fd1",
children=[
html.Img(
alt="Link to my twitter",
src="assets/blogpost_2.png",
className='zoom'
)
], target= '_blank', className= "blog-post-2"
)
],className= "blog-posts")],
className= "start-page")
# Returns content of each tab when selected
@app.callback(Output('tabs-content-example-graph', 'children'),
Input('tabs-example-graph', 'value'),
Input('store-references-query-response', 'data'))
def render_tab_content(tab, data_ref = None):
if tab == 'tab-1-example-graph':
if data_ref != None:
return (
html.Div([
html.Div([
html.Div([
html.P("Filter results in time "),
dcc.RangeSlider(1940, 2030, 10, value=[1940, 2030], id='time-range-slider',
allowCross=False, className= "range-slider",
marks={
1940: {'label': '1940', 'style': {'color': 'black'}},
1950: {'label': '1950', 'style': {'color': 'black'}},
1960: {'label': '1960', 'style': {'color': 'black'}},
1970: {'label': '1970', 'style': {'color': 'black'}},
1980: {'label': '1980', 'style': {'color': 'black'}},
1990: {'label': '1990', 'style': {'color': 'black'}},
2000: {'label': '2000', 'style': {'color': 'black'}},
2010: {'label': '2010', 'style': {'color': 'black'}},
2020: {'label': '2020', 'style': {'color': 'black'}},
2030: {'label': '2030', 'style': {'color': 'black'}},
})], className = "global-time-filter"),
html.Div([html.Button(
"Download data",
title = "Downloads data as .CSV file",
id = "btn-download-data",
className="doc-link-download",
n_clicks= 0
),
dcc.Download(id="download-csv")], style = {'order': '2'})],
className= "upper-filters"),
html.Div([
html.Div([
dcc.Loading(id = "loading-icon-1",
children=[
html.Div([
html.Div(id = 'dp-keywords', children= [], className = "keywords-dropdown"),
html.Div(id = 'keywords-graph-all', children= [], className= "keywords-plot")],
className = "keywords-graph")],
type = 'default', className= "loading-keywords"),
html.Div(id = 'accessibility-pie-all', children = [
html.Div([
html.Div(id = 'dp-access', children=[], style = {'order': '2'}),
html.Div(id = 'access-pie-all', children= [], style = {'order': '1', 'margin': 'auto'})],
className= "accessibility-graph"),
html.Div(id = 'fields-pie-all', children = [], className= "fields-pie-graph")],
className= "fields-pie-and-dropdown")],
className= "tab-1-upper-graphs"),
html.Br(),
html.Br(),
html.Div([
html.Div(id = 'active-authors-graph-all', children = [], className= "active-authors-graph"),
html.Div(id = 'publication-graph-all', children = [], className= "citations-graph")],
className= "tab-1-lower-graphs"),
],
className= "tab-1")], className= "tab-1-with-download"))
else:
return html.Div([html.P("Retrieving info about 1000s of papers, please give it a few seconds",
style = {'order': '1', 'font-size': '1.5rem', 'color':'rgba(3, 3, 3, 0.2)',
'text-align': 'center', 'margin-top': '10vh'}),
html.Img(src='/assets/spinner.gif', style= {'order':'2', 'margin': 'auto'})],
style= {'display': 'flex', 'flex-direction':'column', 'justify-content': 'center',
'align-items': 'center', 'min-height': '400px', 'width':'60vw', 'margin': 'auto'})
if tab == 'tab-2-example-graph':
return html.Div([
html.Div([
html.Div([
html.Button('Reset view', id='bt-reset', className= 'reset-button'),
html.Div(id = 'dp-access-cytoscape', children = [], style={'order':'2'})],
className= "dropdown-and-button-cyto-1"),
cyto.Cytoscape(
id='cytoscape-event-callbacks-1',
layout={'name': 'random', 'height': '58vh', 'width': '44vw'},
className= "cyto-1",
stylesheet = [
{
'selector': 'label',
'style': {
'content': 'data(label)',
'color': 'rgba(60, 25, 240, 0.8)',
'font-size':'14vh',
'font-family':'Arial, sans serif',
}
},
{
'selector': 'node',
'style': {
'label': 'data(label)'
}
},
{
'selector': '[selected ^= "True"]',
'style': {
'background-color': 'green',
'line-color': 'green'
}
},
{
'selector': '.author',
'style': {
'background-color': 'rgba(60, 25, 240, 0.8)'
}
},
{
'selector': '.collaboration',
'style': {
'line-color': '#737373',
'width': 1
}
}
])],
className= "cyto-1-and-button-container"),
html.Div(className= 'vl', style = {'order': '2'}),
html.Div([
html.Div([
html.Div(id = 'author-info-1', className= "author-info")],
className= "author-info-container")],
className= "author-info-big-container")
], className= "tab-2")
if tab == 'tab-3-example-graph':
return html.Div([
html.Div([
html.Button('Reset view', id='bt-reset-papers', className= 'reset-button'),
cyto.Cytoscape(
id='cytoscape-event-callbacks-2',
layout={'name': 'random', 'height': '58vh', 'width': '50vw'},
style={'order':'2','height': '58vh', 'width': '50vw'},
#className= "cyto-2",
stylesheet = [
{
'selector': 'node',
'style': {
'background-color': 'rgba(60, 25, 240, 0.8)',
'height': '9vh',
'width': '9vh'
}
},
{
'selector': '.res',
'style': {
'background-color': 'green',
'color': 'red',
'height': '1.2vh',
'width': '1.2vh'
}
},
{
'selector': '.ref',
'style': {
'background-color': 'white',
'color': 'white',
'height': '0.8vh',
'width': '0.8vh'
}
},
{
'selector': '.citation',
'style': {
'line-color': '#737373',
'width': 1
}
}
])],
className= "cyto-2-and-button-container"),
html.Div(className= 'vl', style = {'order': '2'}),
html.Div([
html.Div([
html.Div(id = 'paper-info-1', className= "paper-info")],
className= "paper-info-container")],
className= "paper-info-big-container")],
className= "tab-3")
# Welcome title
@app.callback(
Output('topic', 'children'),
Input('search-query', 'value'))
def display_topic(value):
return "Welcome researcher!"
# Download data as CSV button
@app.callback(
Output("download-csv", "data"),
Input("btn-download-data", "n_clicks"),
Input("store-initial-query-response", "data"),
Input("store-references-query-response", "data"),
Input("time-range-slider", "value"),
prevent_initial_call=True,
)
def func(n_clicks, data_res, data_ref, filter_values):
if data_ref:
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
if n_clicks > 0:
return dcc.send_data_frame(dff_all.to_csv, "research_data.csv")
# Plots and graphs ----------------------------------------------
# keywords
@app.callback(
Output('keywords-graph-all', 'children'),
Input('store-initial-query-response', 'data'),
Input('search-query', 'value'),
Input('dp-keywords-component', 'value'),
Input('time-range-slider', 'value'))
def create_top_key_words_all(data_res, query, filter, filter_values):
"""Returns keywords graph as dcc.Graph component
Only displays it when all data is retrieved"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_res = data_preprocess.filter_data_by_time(dff_res, filter_values)
if filter == 'All':
fig = plots.make_top_key_words(dff_res, query)
else:
index_list = []
for index, row in dff_res.iterrows():
if isinstance(row.fieldsOfStudy, list):
if filter in row.fieldsOfStudy:
index_list.append(index)
dff_filtered = dff_res.loc[index_list]
fig = plots.make_top_key_words(dff_filtered,query)
return dcc.Graph(figure=fig, className= "keywords-plotly")
@app.callback(
Output('dp-keywords', 'children'),
Input('store-initial-query-response', 'data'),
Input('time-range-slider', 'value'))
def create_keywords_dorpdown(data_res, filter_values):
"""Returns the dropdown menu according to all fields of study in data
as a dcc.Dropdown component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_res = data_preprocess.filter_data_by_time(dff_res, filter_values)
fields_of_study = dff_res['fieldsOfStudy'].tolist()
res = [field for field in fields_of_study if isinstance(field, list)]
flat_list_fields = utils.flatten_list(res)
options = ['All'] + list(set(flat_list_fields))
return dcc.Dropdown(id = 'dp-keywords-component', value = 'All',
options = options, clearable=False,
placeholder= 'Select a field of study', className= 'dp-access-piie')
# loading states for keyword graphs
@app.callback(Output('loading-icon-1', 'children'),
Input('keywords-graph-res', 'children'))
@app.callback(Output('loading-icon-2', 'children'),
Input('keywords-graph-ref', 'children'))
# Accessibility
@app.callback(
Output('dp-access', 'children'),
Input('store-initial-query-response', 'data'),
Input('store-references-query-response', 'data'),
Input('time-range-slider', 'value'))
def create_accessibility_pie_dorpdown(data_res, data_ref, filter_values):
"""Returns the dropdown menu according to all fields of study in data
as a dcc.Dropdown component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
fields_of_study = dff_all['fieldsOfStudy'].tolist()
res = [field for field in fields_of_study if isinstance(field, list)]
flat_list_fields = utils.flatten_list(res)
options = ['All'] + list(set(flat_list_fields))
return dcc.Dropdown(id = 'dp-access-component', value = 'All',
options = options, clearable=False,
placeholder= 'Select a field of study', className= 'dp-access-piie')
@app.callback(
Output('access-pie-all', 'children'),
Input('store-initial-query-response', 'data'),
Input('store-references-query-response', 'data'),
Input('dp-access-component', 'value'),
Input('time-range-slider', 'value'))
def create_accessibility_pie(data_res, data_ref, filter, filter_values):
"""Returns the accessibility pie graph for all data
as a dcc.Graph component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
if filter == 'All':
fig = plots.make_access_pie(dff_all)
else:
index_list = []
for index, row in dff_all.iterrows():
if isinstance(row.fieldsOfStudy, list):
if filter in row.fieldsOfStudy:
index_list.append(index)
dff_filtered = dff_all.loc[index_list]
fig = plots.make_access_pie(dff_filtered)
return dcc.Graph(figure = fig, className= "access-pie-plotly")
# Publications & citations per year
@app.callback(
Output('publication-graph-all', 'children'),
Input('store-initial-query-response', 'data'),
Input('store-references-query-response', 'data'),
Input('time-range-slider', 'value'))
def create_publication_graph_all(data_res, data_ref, filter_values):
"""Returns the pubs + citations graph as a dcc.Graph component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
fig = plots.make_pubs_cites_per_year_line(dff_all, filter_values)
return dcc.Graph(figure=fig, className= "pub-graph-plotly")
# Fields of study
@app.callback(
Output('fields-pie-all', 'children'),
Input('store-initial-query-response', 'data'),
Input('store-references-query-response', 'data'),
Input('time-range-slider', 'value'))
def create_fields_pie_res(data_res, data_ref, filter_values):
"""Returns the fields pie as a dcc.Graph component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
fig = plots.make_fields_pie(dff_all)
return dcc.Graph(figure=fig, className= "fields-pie-plotly")
# Most active authors
@app.callback(
Output('active-authors-graph-all', 'children'),
Input('store-initial-query-response', 'data'),
Input('store-references-query-response', 'data'),
Input('time-range-slider', 'value'))
def create_active_authors_graph_res(data_res, data_ref, filter_values):
"""Returns the most active authors graph as a dcc.Graph component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
dff_ref = pd.DataFrame(data_ref)
dff_ref['result'] = 'reference'
dff_all = pd.concat([dff_res, dff_ref])
dff_all = data_preprocess.filter_data_by_time(dff_all, filter_values)
fig = plots.make_active_authors(dff_all)
return dcc.Graph(figure=fig, className = "pub-graph-plotly")
# Cytoscapes -------------------------------------------------------------------
@app.callback(
Output('dp-access-cytoscape', 'children'),
Input('store-initial-query-response', 'data'))
def create_dropdown_cytoscape(data_res):
"""Returns the dropdown menu according to all fields
of study as a dcc.Dropdown component"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
fields_of_study = dff_res['fieldsOfStudy'].tolist()
res = [field for field in fields_of_study if isinstance(field, list)]
flat_list_fields = utils.flatten_list(res)
options = ['All'] + list(set(flat_list_fields))
return dcc.Dropdown(id = 'dp-access-component_cytoscape', value = 'All',
options = options, clearable=False,
placeholder= 'Select a field of study', className= 'dp-access-pie')
@app.callback(
Output('cytoscape-event-callbacks-1', 'elements'),
Output('cytoscape-event-callbacks-1', 'zoom'),
Input('store-initial-query-response', 'data'),
Input('bt-reset', 'n_clicks'),
Input('dp-access-component_cytoscape', 'value'),
Input('cytoscape-event-callbacks-1', 'zoom'))
def generate_collaboration_network(data_res, n_clicks, filter, zoom):
"""Returns the elements of the collaboaration cytoscape in tab 2"""
dff_res = pd.DataFrame(data_res['data'])
dff_res['result'] = 'direct'
if filter == 'All':
elements = plots.generate_graph_elements_collab(dff_res)
else:
index_list = []
for index, row in dff_res.iterrows():
if isinstance(row.fieldsOfStudy, list):
if filter in row.fieldsOfStudy:
index_list.append(index)
dff_filtered = dff_res.loc[index_list]
elements = plots.generate_graph_elements_collab(dff_filtered)
if n_clicks:
if n_clicks > 0:
zoom = 1
return elements, zoom
return elements, zoom
@app.callback(
Output('cytoscape-event-callbacks-2', 'elements'),
Output('cytoscape-event-callbacks-2', 'zoom'),
Input('store-references-query-response', 'data'),
Input('store-initial-query-response', 'data'),
Input('bt-reset-papers', 'n_clicks'),
Input('cytoscape-event-callbacks-2', 'zoom'))
def generate_citation_network(data_ref, data_res, n_clicks, zoom):
"""Returns the elements of the citation cytoscape in tab 3"""
ref_df = pd.DataFrame(data_ref)
ref_df['reference'] = semantic_api.build_references(ref_df)
res_df = pd.DataFrame(data_res['data'])
res_df['reference'] = semantic_api.build_references(res_df)
elements= plots.generate_graph_elements_network(ref_df, res_df)
if n_clicks:
if n_clicks > 0:
zoom = 1
return elements, zoom
return elements, zoom
# Retrieves info on author
@app.callback(Output('author-info-1', 'children'),
Input('cytoscape-event-callbacks-1', 'tapNodeData'))
def displayTapNodeData(data):
"""Requests and returns the info about an author when node is clicked on"""
if data:
author_info = semantic_api.get_author_info(data['id'])
paragraph = html.Div([
html.B(author_info['name']), html.Br(),html.Br(),
html.Span("Published "), html.B(author_info['paperCount']), html.Span(" papers."), html.Br(),html.Br(),
html.Span("Received "), html.B(author_info['citationCount']), html.Span(" citations."), html.Br(),html.Br(),
html.Span(f"h index: "), html.B(author_info['hIndex']), html.Br(), html.Br(),
html.A("Semantic Scholar profile", href = author_info['url'], target= '_blank')],
className = "author-info-text"),
return paragraph
else:
return html.P("Click on a node to display information about an author",
className= "author-info-default-text")
# Retrieves info on paper
@app.callback(Output('paper-info-1', 'children'),
Input('cytoscape-event-callbacks-2', 'tapNodeData'))
def displayTapNodeData(data):
"""Requests and returns the info about a paper when node is clicked on"""
if data:
paper_info = semantic_api.get_paper_info(data['id'])
if 'paperId' in paper_info:
if paper_info['isOpenAccess']:
oa = ''
else:
oa = 'NOT'
if paper_info['abstract'] == None:
paper_info['abstract'] = 'No abstract available for this paper.'
paragraph = html.Div([html.Br(), html.B(paper_info['title']), html.Br(),html.Br(),
html.Li([html.Span("Published in "), html.B(paper_info['year'])]),
html.Li([html.Span("Includes "), html.B(paper_info['referenceCount']), html.Span(" references.")]),
html.Li([html.Span("Received "), html.B(paper_info['citationCount']), html.Span(" citations.")]),
html.Li([html.Span("Is "), html.B(oa), html.Span(" open access.", style = {'font-size': '1.5vh', 'color': 'black'})]),
html.Li([html.A(' Semantic Scholar URL', href = paper_info['url'], target = '_blank')]), html.Br(),
html.B("Abstract"), html.Br(),
html.Span(paper_info['abstract'])],
className= "paper-info-text")
else:
paragraph = html.P("No info available for this paper", className= "paper-info-default-no-info")
return paragraph
else:
return html.P("Click on a node to display information about a paper",
className= "paper-info-default-text")
# Runs the app ------------------------------------------------------------
if __name__ == '__main__':
app.run_server(debug=True, use_reloader=False) | 2.21875 | 2 |
suppliers/models.py | yanwarsolahudin/regensi_api | 1 | 12789100 | <filename>suppliers/models.py
from django.db import models
from utils.models import Timestamp, generate_string_code
class Supplier(Timestamp):
PREFIX = 'SPR'
supplier_code = models.CharField(max_length=100, unique=True)
name = models.CharField(max_length=100, default='Ex: <NAME>')
address = models.TextField()
phone = models.CharField(max_length=20, default='Ex: +6299999999')
pic = models.CharField(max_length=100, blank=True, null=True)
def save(self, *args, **kwargs):
if not self.supplier_code:
# Newly created object, so set slug
self.supplier_code = generate_string_code(Supplier)
super(Supplier, self).save(*args, **kwargs)
def __str__(self):
return self.supplier_code
| 2.359375 | 2 |
src/python/dnsresolvd.py | rgolubtsov/dnsresolvd-multilang | 2 | 12789101 | <reponame>rgolubtsov/dnsresolvd-multilang
#
# src/python/dnsresolvd.py
# =============================================================================
# DNS Resolver Daemon (dnsresolvd). Version 0.9.9
# =============================================================================
# A daemon that performs DNS lookups for the given hostname
# passed in an HTTP request, with the focus on its implementation
# using various programming languages. (Twisted-boosted impl.)
# =============================================================================
# Copyright (C) 2017-2022 Radislav (Radicchio) Golubtsov
#
# (See the LICENSE file at the top of the source tree.)
#
from twisted.web.resource import Resource
from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet import reactor
from twisted.web.server import Site
import json
from dns_resolv.dns_lookup_controller import DnsLookupController
class DnsResolvd:
"""The main class of the daemon."""
def startup(self, port_number, aux):
"""Starts up the daemon.
Args:
port_number: The server port number to listen on.
aux: The controller helper object instance.
Returns:
The server exit code when interrupted.
"""
ret = aux._EXIT_SUCCESS
class Daemon(Resource):
"""The server class of the daemon.
Used by Twisted engine to run an event loop.
Extends:
Resource: The Twisted web-accessible resource class.
"""
isLeaf = True
def render_GET(self, req):
"""Renders the HTTP response based on the incoming HTTP
request using the HTTP GET method.
It also calls the method to perform DNS lookup for a hostname
passed in the HTTP request.
Args:
req: The incoming HTTP request object.
Returns:
The HTTP response has to be rendered.
"""
query = req.args
h = b"h"
f = b"f"
fmt = aux._PRM_FMT_JSON
# Parsing and validating query params.
if (h in query):
hostname = query[h][0].decode()
# ^
# |
# +----------------+
else: # |
hostname = aux._DEF_HOSTNAME # |
# |
# http://localhost:<port_number>/?h=<hostname>&f=<fmt>
# |
# +-----------------------------+
# |
if (f in query): # v
fmt = query[f][0].decode().lower()
if (fmt not in {
aux._PRM_FMT_HTML,
aux._PRM_FMT_JSON,
}):
fmt = aux._PRM_FMT_JSON
# Instantiating the controller class.
ctrl = DnsLookupController()
# Performing DNS lookup for the given hostname.
(addr, ver) = ctrl.dns_lookup(hostname, aux)
if (fmt == aux._PRM_FMT_HTML):
resp_buffer = ("<!DOCTYPE html>" + aux._NEW_LINE
+ "<html lang=\"en-US\" dir=\"ltr\">" + aux._NEW_LINE
+ "<head>" + aux._NEW_LINE
+ "<meta http-equiv=\"" + aux._HDR_CONTENT_TYPE_N + "\" content=\""
+ aux._HDR_CONTENT_TYPE_V_HTML + "\" />" + aux._NEW_LINE
+ "<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />" + aux._NEW_LINE
+ "<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\" />" + aux._NEW_LINE
+ "<title>" + aux._DMN_NAME + "</title>" + aux._NEW_LINE
+ "</head>" + aux._NEW_LINE
+ "<body>" + aux._NEW_LINE
+ "<div>" + hostname + aux._ONE_SPACE_STRING)
if (addr == aux._ERR_PREFIX):
resp_buffer += (aux._ERR_PREFIX
+ aux._COLON_SPACE_SEP
+ aux._ERR_COULD_NOT_LOOKUP)
else:
resp_buffer += (str(addr) + aux._ONE_SPACE_STRING
+ aux._DAT_VERSION_V
+ str(ver))
resp_buffer += ("</div>" + aux._NEW_LINE
+ "</body>" + aux._NEW_LINE
+ "</html>" + aux._NEW_LINE)
elif (fmt == aux._PRM_FMT_JSON):
if (addr == aux._ERR_PREFIX):
resp_buffer = json.dumps({
aux._DAT_HOSTNAME_N : hostname,
aux._ERR_PREFIX : aux._ERR_COULD_NOT_LOOKUP,
})
else:
resp_buffer = json.dumps({
aux._DAT_HOSTNAME_N : hostname,
aux._DAT_ADDRESS_N : str(addr),
aux._DAT_VERSION_N : aux._DAT_VERSION_V
+ str(ver),
})
# Adding headers to the response.
aux.add_response_headers(req, fmt)
return resp_buffer.encode()
def render_POST(self, req):
"""Renders the HTTP response based on the incoming HTTP
request using the HTTP POST method.
It simply calls its "GET" counterpart
<code>render_GET()</code>.
Args:
req: The incoming HTTP request object.
Returns:
The HTTP response has to be rendered.
"""
return self.render_GET(req)
## Default constructor.
def __init__(self):
self = []
return None
# Setting up the TCP IPv4-configured server.
TCP4ServerEndpoint(reactor, port_number).listen(Site(Daemon()))
# Running the event loop.
ret = reactor.run()
return ret
def __init__(self):
"""Default constructor."""
self = []
return None
# vim:set nu et ts=4 sw=4:
| 2.484375 | 2 |
src/aceinna/tools/cli.py | LukaszChl/ros_openimu | 6 | 12789102 | import os
import sys
import argparse
try:
from aceinna.bootstrap.cli import CommandLine
from aceinna.framework.constants import BAUDRATE_LIST
except: # pylint: disable=bare-except
print('load package from local')
sys.path.append('./src')
from aceinna.bootstrap.cli import CommandLine
from aceinna.framework.constants import BAUDRATE_LIST
def receive_args():
"""parse input arguments
"""
parser = argparse.ArgumentParser(
description='Aceinna python driver input args command:')
# parser.add_argument("-host", type=str, help="host type", default='web')
# for host as web
parser.add_argument("-p", "--port", type=int,
help="Webserver port")
parser.add_argument("--device-type", type=str,
help="Open Device Type")
parser.add_argument("-b", "--baudrate", type=int,
help="Baudrate for uart", choices=BAUDRATE_LIST)
parser.add_argument("-c", "--com-port", type=str,
help="COM Port")
parser.add_argument("--console-log", dest='console_log', action='store_true',
help="Output log on console", default=False)
parser.add_argument("--debug", dest='debug', action='store_true',
help="Log debug information", default=False)
parser.add_argument("--with-data-log", dest='with_data_log', action='store_true',
help="Contains internal data log (OpenIMU only)", default=False)
parser.add_argument("--with-raw-log", dest='with_raw_log', action='store_true',
help="Contains raw data log (OpenRTK only)", default=False)
return parser.parse_args()
def main():
'''start'''
input_args = receive_args()
command_line = CommandLine(
device_type=input_args.device_type,
com_port=input_args.com_port,
port=input_args.port,
baudrate=input_args.baudrate,
console_log=input_args.console_log,
debug=input_args.debug,
with_data_log=input_args.with_data_log,
with_raw_log=input_args.with_raw_log
)
command_line.listen()
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt: # response for KeyboardInterrupt such as Ctrl+C
print('User stop this program by KeyboardInterrupt! File:[{0}], Line:[{1}]'.format(
__file__, sys._getframe().f_lineno))
sys.exit()
except: # pylint: disable=bare-except
os._exit(1)
| 2.34375 | 2 |
pypardot/objects_v3/accounts.py | andyoneal/PyPardotSF | 18 | 12789103 | class Accounts(object):
"""
A class to query and use Pardot accounts.
Account field reference: http://developer.pardot.com/kb/api-version-3/object-field-references/#prospectAccount
"""
def __init__(self, client):
self.client = client
def query(self, **kwargs):
"""
Returns the prospect accounts matching the specified criteria parameters.
Supported search criteria: http://developer.pardot.com/kb/api-version-3/prospect-accounts/#supported-search-criteria
"""
response = self._get(path='/do/query', params=kwargs)
# Ensure result['prospectAccount'] is a list, no matter what.
result = response.get('result')
if result['total_results'] == 0:
result['prospectAccount'] = []
elif result['total_results'] == 1:
result['prospectAccount'] = [result['prospectAccount']]
return result
def create(self, **kwargs):
"""Creates a new prospect account."""
response = self._post(path='/do/create', params=kwargs)
return response
def describe(self, **kwargs):
"""
Returns the field metadata for prospect accounts, explaining what fields are available, their types, whether
they are required, and their options (for dropdowns, radio buttons, etc).
"""
response = self._get(path='/do/describe', params=kwargs)
return response
def read(self, id=None, **kwargs):
"""
Returns the data for the prospect account specified by <id>. <id> is the Pardot ID of the target prospect
account.
"""
response = self._post(path='/do/read/id/{id}'.format(id=id), params=kwargs)
return response
def update(self, id=None, **kwargs):
"""
Updates the data for the prospect account specified by <id>. <id> is the Pardot ID of the target prospect
account.
"""
response = self._post(path='/do/update/id/{id}'.format(id=id), params=kwargs)
return response
def _get(self, object_name='prospectAccount', path=None, params=None):
"""GET requests for the Account object."""
if params is None:
params = {}
response = self.client.get(object_name=object_name, path=path, params=params)
return response
def _post(self, object_name='prospectAccount', path=None, params=None):
"""POST requests for the Account object."""
if params is None:
params = {}
response = self.client.post(object_name=object_name, path=path, params=params)
return response
| 3.15625 | 3 |
day24/aoc2018-day24.py | SebastiaanZ/aoc-2018 | 1 | 12789104 | from reindeer import Disease
# Part I
disease = Disease("day24-input.txt")
found, result = disease.battle()
print(f"Answer part I: {result}")
# Part II
for boost in range(10000):
body = Disease("day24-input.txt", boost)
found, result = body.battle()
if found:
break
print(f"Answer part II: {result} (with boost={boost})")
| 2.828125 | 3 |
Curso Udemy 2022/Curso_Luiz_Otavio/Aula 41.py | Matheusfarmaceutico/Exercicios-Python | 0 | 12789105 | # uso do split e count
'''string = 'O Brasil Brasil I I I I'
lista_1 = string.split(' ')
palavra = ''
cont = 0
for valor in lista_1:
quantvezes = lista_1.count(valor)
if quantvezes > cont:
cont = quantvezes
palavra = valor
print(f'A palavra que mais apareceu nessa frase foi {palavra} ')'''
# uso do Join
'''lista = ['Ana','Vitória']
juntar = '***'.join(lista)
print(juntar)'''
# uso do enumerate: retorna tuplas
'''lista = ['Jogador','Numero']
for indice, valor in enumerate(lista):
print(indice,valor)'''
| 3.65625 | 4 |
tests/test_data.py | lgray/AwkwardQL | 1 | 12789106 | import pytest
def test_data():
from awkwardql.data import (RecordArray,
PrimitiveArray,
ListArray,
UnionArray,
instantiate)
# data in columnar form
events = RecordArray({
"muons": ListArray([0, 3, 3, 5], [3, 3, 5, 9], RecordArray({
"pt": PrimitiveArray([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]),
"iso": PrimitiveArray([0, 0, 100, 50, 30, 1, 2, 3, 4])
})),
"jets": ListArray([0, 5, 6, 8], [5, 6, 8, 12], RecordArray({
"pt": PrimitiveArray([1, 2, 3, 4, 5, 100, 30, 50, 1, 2, 3, 4]),
"mass": PrimitiveArray([10, 10, 10, 10, 10, 5, 15, 15, 9, 8, 7, 6])
})),
"met": PrimitiveArray([100, 200, 300, 400])
})
# same data in rowwise form
assert events == [
{'muons': [
{'pt': 1.1, 'iso': 0},
{'pt': 2.2, 'iso': 0},
{'pt': 3.3, 'iso': 100}],
'jets': [
{'pt': 1, 'mass': 10},
{'pt': 2, 'mass': 10},
{'pt': 3, 'mass': 10},
{'pt': 4, 'mass': 10},
{'pt': 5, 'mass': 10}],
'met': 100},
{'muons': [],
'jets': [{'pt': 100, 'mass': 5}],
'met': 200},
{'muons': [
{'pt': 4.4, 'iso': 50},
{'pt': 5.5, 'iso': 30}],
'jets': [
{'pt': 30, 'mass': 15},
{'pt': 50, 'mass': 15}],
'met': 300},
{'muons': [
{'pt': 6.6, 'iso': 1},
{'pt': 7.7, 'iso': 2},
{'pt': 8.8, 'iso': 3},
{'pt': 9.9, 'iso': 4}],
'jets': [
{'pt': 1, 'mass': 9},
{'pt': 2, 'mass': 8},
{'pt': 3, 'mass': 7},
{'pt': 4, 'mass': 6}],
'met': 400}]
# projection down to the numerical values
assert events["muons"]["pt"] == [[1.1, 2.2, 3.3], [], [4.4, 5.5], [6.6, 7.7, 8.8, 9.9]]
# single record object
assert events[0] == {
'muons': [
{'pt': 1.1, 'iso': 0},
{'pt': 2.2, 'iso': 0},
{'pt': 3.3, 'iso': 100}],
'jets': [
{'pt': 1, 'mass': 10},
{'pt': 2, 'mass': 10},
{'pt': 3, 'mass': 10},
{'pt': 4, 'mass': 10},
{'pt': 5, 'mass': 10}],
'met': 100}
# integer and string indexes commute, but string-string and integer-integer do not
assert events["muons"][0] == events[0]["muons"]
assert events["muons"][0]["pt"] == events[0]["muons"]["pt"]
assert events["muons"][0][2] == events[0]["muons"][2]
assert events["muons"][0]["pt"][2] == events[0]["muons"]["pt"][2]
assert events["muons"][0]["pt"][2] == events[0]["muons"][2]["pt"]
assert events["muons"][0]["pt"][2] == events["muons"][0][2]["pt"]
assert events["muons"][0]["pt"][2] == events["muons"]["pt"][0][2]
events.setindex()
muonpt = events.contents["muons"].content.contents["pt"]
assert muonpt.row == [(0, 0), (0, 1), (0, 2), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3)]
assert muonpt.col == ("muons", "pt")
muoniso = events.contents["muons"].content.contents["iso"]
assert muonpt.row == muoniso.row
assert muonpt.row.same(muoniso.row)
c1, c2 = muonpt.col.tolist()
for i, (r1, r2) in enumerate(muonpt.row):
assert events[c1][c2][r1][r2] == muonpt[i]
instantiate(events)
egamma = UnionArray([0, 0, 1, 0, 1, 1, 1, 0, 0], [0, 1, 0, 2, 1, 2, 3, 3, 4], [
RecordArray({
"q": PrimitiveArray([1, -1, -1, 1, 1]),
"pt": PrimitiveArray([10, 20, 30, 40, 50])
}),
RecordArray({
"pt": PrimitiveArray([1.1, 2.2, 3.3, 4.4])
})
])
assert egamma == [
{'pt': 10, 'q': 1},
{'pt': 20, 'q': -1},
{'pt': 1.1},
{'pt': 30, 'q': -1},
{'pt': 2.2},
{'pt': 3.3},
{'pt': 4.4},
{'pt': 40, 'q': 1},
{'pt': 50, 'q': 1}]
assert egamma["pt"] == [10, 20, 1.1, 30, 2.2, 3.3, 4.4, 40, 50]
egamma.setindex()
assert egamma.contents[0].contents["pt"].row == [(0,), (1,), (3,), (7,), (8,)]
assert egamma.contents[1].contents["pt"].row == [(2,), (4,), (5,), (6,)]
assert egamma.contents[0].contents["pt"].col == ("pt",)
assert egamma.contents[1].contents["pt"].col == ("pt",)
instantiate(egamma)
| 2.484375 | 2 |
general/chainerrl/baselines/train_dqfd.py | marioyc/baselines | 127 | 12789107 | """original source: https://github.com/chainer/chainerrl/pull/480
MIT License
Copyright (c) Preferred Networks, Inc.
"""
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
from __future__ import absolute_import
from builtins import *
from future import standard_library
standard_library.install_aliases()
import argparse
from inspect import getsourcefile
import os
import sys
import numpy as np
import chainer
import minerl # noqa: register MineRL envs as Gym envs.
import gym
import chainerrl
from chainerrl import experiments, explorers
from chainerrl.experiments.evaluator import Evaluator
from dqfd import DQfD, PrioritizedDemoReplayBuffer
from q_functions import CNNBranchingQFunction
from env_wrappers import (
BranchedRandomizedAction, BranchedActionWrapper,
MoveAxisWrapper, FrameSkip, FrameStack, ObtainPoVWrapper,
PoVWithCompassAngleWrapper, FullObservationSpaceWrapper)
from expert_converter import choose_top_experts, fill_buffer
class ScaleGradHook(object):
name = 'ScaleGrad'
call_for_each_param = True
timing = 'pre'
def __init__(self, scale):
self.scale = scale
def __call__(self, rule, param):
if getattr(param, 'scale_param', False):
param.grad *= self.scale
def main():
"""Parses arguments and runs the example
"""
parser = argparse.ArgumentParser()
parser.add_argument('--env', type=str, default='MineRLTreechop-v0',
choices=[
'MineRLTreechop-v0',
'MineRLNavigate-v0', 'MineRLNavigateDense-v0', 'MineRLNavigateExtreme-v0', 'MineRLNavigateExtremeDense-v0',
'MineRLObtainIronPickaxe-v0', 'MineRLObtainIronPickaxeDense-v0',
'MineRLObtainDiamond-v0', 'MineRLObtainDiamondDense-v0',
'MineRLNavigateDenseFixed-v0' # for debug use
],
help='MineRL environment identifier')
parser.add_argument('--outdir', type=str, default='results',
help='Directory path to save output files.'
' If it does not exist, it will be created.')
parser.add_argument('--seed', type=int, default=0,
help='Random seed [0, 2 ** 31)')
parser.add_argument('--gpu', type=int, default=-1,
help='GPU to use, set to -1 if no GPU.')
parser.add_argument('--final-exploration-frames',
type=int, default=10**6,
help='Timesteps after which we stop ' +
'annealing exploration rate')
parser.add_argument('--final-epsilon', type=float, default=0.01,
help='Final value of epsilon during training.')
parser.add_argument('--eval-epsilon', type=float, default=0.001,
help='Exploration epsilon used during eval episodes.')
parser.add_argument('--replay-start-size', type=int, default=1000,
help='Minimum replay buffer size before ' +
'performing gradient updates.')
parser.add_argument('--target-update-interval', type=int, default=10**4,
help='Frequency (in timesteps) at which ' +
'the target network is updated.')
parser.add_argument('--update-interval', type=int, default=4,
help='Frequency (in timesteps) of network updates.')
parser.add_argument('--eval-n-runs', type=int, default=10)
parser.add_argument('--no-clip-delta',
dest='clip_delta', action='store_false')
parser.add_argument('--error-max', type=float, default=1.0)
parser.add_argument('--num-step-return', type=int, default=10)
parser.set_defaults(clip_delta=True)
parser.add_argument('--logging-level', type=int, default=20,
help='Logging level. 10:DEBUG, 20:INFO etc.')
parser.add_argument('--logging-filename', type=str, default=None)
parser.add_argument('--monitor', action='store_true', default=False,
help='Monitor env. Videos and additional information are saved as output files when evaluation')
# parser.add_argument('--render', action='store_true', default=False,
# help='Render env states in a GUI window.')
parser.add_argument('--optimizer', type=str, default='rmsprop',
choices=['rmsprop', 'adam'])
parser.add_argument('--lr', type=float, default=2.5e-4, help='Learning rate')
parser.add_argument("--replay-buffer-size", type=int, default=10**6,
help="Size of replay buffer (Excluding demonstrations)")
parser.add_argument("--minibatch-size", type=int, default=32)
parser.add_argument('--batch-accumulator', type=str, default="sum")
parser.add_argument('--demo', action='store_true', default=False)
parser.add_argument('--load', type=str, default=None)
parser.add_argument("--save-demo-trajectories", action="store_true",
default=False)
# DQfD specific parameters for loading and pretraining.
parser.add_argument('--n-experts', type=int, default=10)
parser.add_argument('--expert-demo-path', type=str, default=None)
parser.add_argument('--n-pretrain-steps', type=int, default=750000)
parser.add_argument('--demo-supervised-margin', type=float, default=0.8)
parser.add_argument('--loss-coeff-l2', type=float, default=1e-5)
parser.add_argument('--loss-coeff-nstep', type=float, default=1.0)
parser.add_argument('--loss-coeff-supervised', type=float, default=1.0)
parser.add_argument('--bonus-priority-agent', type=float, default=0.001)
parser.add_argument('--bonus-priority-demo', type=float, default=1.0)
# Action branching architecture
parser.add_argument('--gradient-clipping', action='store_true', default=False)
parser.add_argument('--gradient-rescaling', action='store_true', default=False)
# NoisyNet parameters
parser.add_argument('--use-noisy-net', type=str, default=None,
choices=['before-pretraining', 'after-pretraining'])
parser.add_argument('--noisy-net-sigma', type=float, default=0.5)
# Parameters for state/action handling
parser.add_argument('--frame-stack', type=int, default=None, help='Number of frames stacked (None for disable).')
parser.add_argument('--frame-skip', type=int, default=None, help='Number of frames skipped (None for disable).')
parser.add_argument('--camera-atomic-actions', type=int, default=10)
parser.add_argument('--max-range-of-camera', type=float, default=10.)
parser.add_argument('--use-full-observation', action='store_true', default=False)
args = parser.parse_args()
assert args.expert_demo_path is not None,"DQfD needs collected \
expert demonstrations"
import logging
if args.logging_filename is not None:
logging.basicConfig(filename=args.logging_filename, filemode='w',
level=args.logging_level)
else:
logging.basicConfig(level=args.logging_level)
logger = logging.getLogger(__name__)
train_seed = args.seed
test_seed = 2 ** 31 - 1 - args.seed
chainerrl.misc.set_random_seed(args.seed, gpus=(args.gpu,))
args.outdir = experiments.prepare_output_dir(args, args.outdir)
logger.info('Output files are saved in {}'.format(args.outdir))
if args.env == 'MineRLTreechop-v0':
branch_sizes = [9, 16, args.camera_atomic_actions, args.camera_atomic_actions]
elif args.env in ['MineRLNavigate-v0', 'MineRLNavigateDense-v0',
'MineRLNavigateExtreme-v0', 'MineRLNavigateExtremeDense-v0']:
branch_sizes = [9, 16, args.camera_atomic_actions, args.camera_atomic_actions, 2]
elif args.env in ['MineRLObtainIronPickaxe-v0', 'MineRLObtainIronPickaxeDense-v0',
'MineRLObtainDiamond-v0', 'MineRLObtainDiamondDense-v0']:
branch_sizes = [9, 16, args.camera_atomic_actions, args.camera_atomic_actions, 32]
else:
raise Exception("Unknown environment")
def make_env(env, test):
# wrap env: observation...
# NOTE: wrapping order matters!
if args.use_full_observation:
env = FullObservationSpaceWrapper(env)
elif args.env.startswith('MineRLNavigate'):
env = PoVWithCompassAngleWrapper(env)
else:
env = ObtainPoVWrapper(env)
if test and args.monitor:
env = gym.wrappers.Monitor(
env, os.path.join(args.outdir, 'monitor'),
mode='evaluation' if test else 'training', video_callable=lambda episode_id: True)
if args.frame_skip is not None:
env = FrameSkip(env, skip=args.frame_skip)
# convert hwc -> chw as Chainer requires
env = MoveAxisWrapper(env, source=-1, destination=0,
use_tuple=args.use_full_observation)
#env = ScaledFloatFrame(env)
if args.frame_stack is not None:
env = FrameStack(env, args.frame_stack, channel_order='chw',
use_tuple=args.use_full_observation)
# wrap env: action...
env = BranchedActionWrapper(env, branch_sizes, args.camera_atomic_actions, args.max_range_of_camera)
if test:
env = BranchedRandomizedAction(env, branch_sizes, args.eval_epsilon)
env_seed = test_seed if test else train_seed
env.seed(int(env_seed))
return env
core_env = gym.make(args.env)
env = make_env(core_env, test=False)
eval_env = make_env(core_env, test=True)
# Q function
if args.env.startswith('MineRLNavigate'):
if args.use_full_observation:
base_channels = 3 # RGB
else:
base_channels = 4 # RGB + compass
elif args.env.startswith('MineRLObtain'):
base_channels = 3 # RGB
else:
base_channels = 3 # RGB
if args.frame_stack is None:
n_input_channels = base_channels
else:
n_input_channels = base_channels * args.frame_stack
q_func = CNNBranchingQFunction(branch_sizes,
n_input_channels=n_input_channels,
gradient_rescaling=args.gradient_rescaling,
use_tuple=args.use_full_observation)
def phi(x):
# observation -> NN input
if args.use_full_observation:
pov = np.asarray(x[0], dtype=np.float32)
others = np.asarray(x[1], dtype=np.float32)
return (pov / 255, others)
else:
return np.asarray(x, dtype=np.float32) / 255
explorer = explorers.LinearDecayEpsilonGreedy(
1.0, args.final_epsilon,
args.final_exploration_frames,
lambda: np.array([np.random.randint(n) for n in branch_sizes]))
# Draw the computational graph and save it in the output directory.
if args.use_full_observation:
sample_obs = tuple([x[None] for x in env.observation_space.sample()])
else:
sample_obs = env.observation_space.sample()[None]
chainerrl.misc.draw_computational_graph(
[q_func(phi(sample_obs))], os.path.join(args.outdir, 'model'))
if args.optimizer == 'rmsprop':
opt = chainer.optimizers.RMSpropGraves(args.lr, alpha=0.95, momentum=0.0, eps=1e-2)
elif args.optimizer == 'adam':
opt = chainer.optimizers.Adam(args.lr)
if args.use_noisy_net is None:
opt.setup(q_func)
if args.gradient_rescaling:
opt.add_hook(ScaleGradHook(1 / (1 + len(q_func.branch_sizes))))
if args.gradient_clipping:
opt.add_hook(chainer.optimizer_hooks.GradientClipping(10.0))
# calculate corresponding `steps` and `eval_interval` according to frameskip
maximum_frames = 8640000 # = 1440 episodes if we count an episode as 6000 frames.
if args.frame_skip is None:
steps = maximum_frames
eval_interval = 6000 * 100 # (approx.) every 100 episode (counts "1 episode = 6000 steps")
else:
steps = maximum_frames // args.frame_skip
eval_interval = 6000 * 100 // args.frame_skip # (approx.) every 100 episode (counts "1 episode = 6000 steps")
# Anneal beta from beta0 to 1 throughout training
betasteps = steps / args.update_interval
replay_buffer = PrioritizedDemoReplayBuffer(
args.replay_buffer_size, alpha=0.4,
beta0=0.6, betasteps=betasteps,
error_max=args.error_max,
num_steps=args.num_step_return)
# Fill the demo buffer with expert transitions
if not args.demo:
chosen_dirs = choose_top_experts(args.expert_demo_path, args.n_experts,
logger=logger)
fill_buffer(args.env, chosen_dirs, replay_buffer, args.frame_skip,
args.frame_stack, args.camera_atomic_actions,
args.max_range_of_camera, args.use_full_observation,
logger=logger)
logger.info("Demo buffer loaded with {} transitions".format(
len(replay_buffer)))
def reward_transform(x):
return np.sign(x) * np.log(1 + np.abs(x))
if args.use_noisy_net is not None and args.use_noisy_net == 'before-pretraining':
chainerrl.links.to_factorized_noisy(q_func, sigma_scale=args.noisy_net_sigma)
explorer = explorers.Greedy()
opt.setup(q_func)
agent = DQfD(q_func, opt, replay_buffer,
gamma=0.99,
explorer=explorer,
n_pretrain_steps=args.n_pretrain_steps,
demo_supervised_margin=args.demo_supervised_margin,
bonus_priority_agent=args.bonus_priority_agent,
bonus_priority_demo=args.bonus_priority_demo,
loss_coeff_nstep=args.loss_coeff_nstep,
loss_coeff_supervised=args.loss_coeff_supervised,
loss_coeff_l2=args.loss_coeff_l2,
gpu=args.gpu,
replay_start_size=args.replay_start_size,
target_update_interval=args.target_update_interval,
clip_delta=args.clip_delta,
update_interval=args.update_interval,
batch_accumulator=args.batch_accumulator,
phi=phi, reward_transform=reward_transform,
minibatch_size=args.minibatch_size)
if args.use_noisy_net is not None and args.use_noisy_net == 'after-pretraining':
chainerrl.links.to_factorized_noisy(q_func, sigma_scale=args.noisy_net_sigma)
explorer = explorers.Greedy()
if args.optimizer == 'rmsprop':
opt = chainer.optimizers.RMSpropGraves(args.lr, alpha=0.95, momentum=0.0, eps=1e-2)
elif args.optimizer == 'adam':
opt = chainer.optimizers.Adam(args.lr)
opt.setup(q_func)
opt.add_hook(
chainer.optimizer_hooks.WeightDecay(args.loss_coeff_l2))
agent.optimizer = opt
agent.target_model = None
agent.sync_target_network()
if args.load:
agent.load(args.load)
if args.demo:
eval_stats = experiments.eval_performance(
env=eval_env, agent=agent, n_steps=None, n_episodes=args.eval_n_runs)
logger.info('n_runs: {} mean: {} median: {} stdev: {}'.format(
args.eval_n_runs, eval_stats['mean'], eval_stats['median'], eval_stats['stdev']))
else:
agent.pretrain()
evaluator = Evaluator(agent=agent,
n_steps=None,
n_episodes=args.eval_n_runs,
eval_interval=eval_interval,
outdir=args.outdir,
max_episode_len=None,
env=eval_env,
step_offset=0,
save_best_so_far_agent=True,
logger=logger)
# Evaluate the agent BEFORE training begins
evaluator.evaluate_and_update_max_score(t=0, episodes=0)
experiments.train_agent(agent=agent,
env=env,
steps=steps,
outdir=args.outdir,
max_episode_len=None,
step_offset=0,
evaluator=evaluator,
successful_score=None,
step_hooks=[])
env.close()
if __name__ == "__main__":
main()
| 2.125 | 2 |
pygraph/test/testutil.py | emliunix/pygraph | 0 | 12789108 | # -*- coding: utf-8 -*-
import unittest
from pygraph import util
class TestUtil(unittest.TestCase):
def test_pointsToEdges(self):
points = [(1, 1), (2, 2), (3, 3)]
expected = [
((1, 1), (2, 2)),
((2, 2), (3, 3)),
((3, 3), (1, 1))
]
self.assertListEqual(expected, util.pointsToEdges(points))
| 2.984375 | 3 |
modules/py/bindings/setup.py | ICHEC/QNLP | 29 | 12789109 | import setuptools
setuptools.setup(
name="PyQNLPSimulator",
version="0.1",
author="<NAME> (ICHEC), <NAME> (ICHEC)",
author_email="<EMAIL>, <EMAIL>",
description="Quantum NLP package",
long_description="Quantum NLP project @ ICHEC",
url="https://github.com/ichec/qnlp",
packages=setuptools.find_packages(),
package_data={'': ['_PyQNLPSimulator.*.so'],},
classifiers=[
"Programming Language :: Python :: 3",
],
)
| 1.210938 | 1 |
monitoring/plugins/ref_matching_threshold_real/run.py | CrossRef/reference-matching-evaluation | 14 | 12789110 | #!/usr/bin/env python3
import numpy as np
import matching.cr_search_validation_matcher
import utils.data_format_keys as dfk
import sys
from evaluation.link_metrics import LinkMetricsResults
from multiprocessing import Pool
from utils.utils import read_json, save_json
def modify_simple_threshold(dataset, threshold):
for item in dataset:
if item[dfk.DATASET_SCORE] is not None and \
item[dfk.DATASET_SCORE] < threshold:
item[dfk.DATASET_TARGET_TEST][dfk.CR_ITEM_DOI] = None
return dataset
def find_best(results):
overall = [r[1].get(dfk.EVAL_F1) for r in results]
index = len(overall) - overall[::-1].index(max(overall)) - 1
return index, results[index][0], results[index][1].get(dfk.EVAL_PREC), \
results[index][1].get(dfk.EVAL_REC), results[index][1].get(dfk.EVAL_F1)
dataset = read_json(sys.argv[1])['dataset']
matcher = matching.cr_search_validation_matcher.Matcher(0.4, 0, [])
with Pool(10) as p:
results = p.map(matcher.match,
[item.get('ref_string') for item in dataset])
for item, target in zip(dataset, results):
item['target_test']['DOI'] = target[0]
item['score'] = target[1]
save_json(dataset, sys.argv[2])
results_valid_threshold = \
[(t, LinkMetricsResults(modify_simple_threshold(dataset, t)))
for t in np.arange(0.0, 1.0, 0.01)]
print(','.join([str(i) for i in find_best(results_valid_threshold)[1:]]))
| 2.125 | 2 |
pymclevel/id_definitions_2.py | bennettdc/MCEdit-Unified | 237 | 12789111 | <gh_stars>100-1000
import os
import json
from logging import getLogger
import collections
#from pymclevel import MCEDIT_DEFS, MCEDIT_IDS
#import pymclevel
import re
#import id_definitions
log = getLogger(__name__)
def get_deps(base_version, file_name):
deps = [base_version]
print "Base: {}".format(base_version)
fp = open(os.path.join('mcver', base_version, file_name))
data = json.loads(fp.read())
fp.close()
if "load" in data:
deps.extend(get_deps(data["load"], file_name))
return deps
def update(orig_dict, new_dict):
for key, val in new_dict.iteritems():
if isinstance(val, collections.Mapping):
tmp = update(orig_dict.get(key, { }), val)
orig_dict[key] = tmp
elif isinstance(val, list):
orig_dict[key] = (orig_dict.get(key, []) + val)
else:
orig_dict[key] = new_dict[key]
return orig_dict
def aggregate(base_version, file_name):
deps = get_deps(base_version, file_name)
deps.reverse()
print deps
aggregate_data = {}
for dep in deps:
fp = open(os.path.join('mcver', dep, file_name))
data = json.loads(fp.read())
fp.close()
update(aggregate_data, data)
print aggregate_data
with open("out.json", 'wb') as out:
json.dump(aggregate_data, out)
#print get_deps("1.12", "entities.json")
aggregate("1.12", "entities.json")
| 2.28125 | 2 |
big_data/maps/convert_rates_tsv_to_json.py | paulhtremblay/big-data | 0 | 12789112 | import pprint
import json
pp = pprint.PrettyPrinter(indent = 4)
def convert(path):
with open(path, 'r') as read_obj:
line = 'init'
counter = 0
l = []
while line:
line = read_obj.readline()
counter += 1
if counter == 1:
continue
fields = line.split('\t')
if len(fields) != 2:
continue
l.append({'id':fields[0], 'rate':float(fields[1].strip())})
return l
def main():
return convert('unemployment.tsv')
if __name__ == '__main__':
pp.pprint(main())
| 2.90625 | 3 |
models/nin_.py | billhhh/model-quantization-1 | 66 | 12789113 | <filename>models/nin_.py
import torch.nn as nn
import torch
import torch.nn.functional as F
from .quant import custom_conv
from .layers import norm, actv
class Net(nn.Module):
def __init__(self, args):
super(Net, self).__init__()
self.args = args
self.body = nn.Sequential(
nn.Conv2d(3, 192, kernel_size=5, stride=1, padding=2),
norm(192, args),
actv(args),
custom_conv(192, 160, kernel_size=1, stride=1, padding=0, args=args,),
norm(160, args),
actv(args),
custom_conv(160, 96, kernel_size=1, stride=1, padding=0, args=args),
norm(96, args),
actv(args),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
custom_conv( 96, 192, kernel_size=5, stride=1, padding=2, args=args),
norm(192, args),
actv(args),
custom_conv(192, 192, kernel_size=1, stride=1, padding=0, args=args),
norm(192, args),
actv(args),
custom_conv(192, 192, kernel_size=1, stride=1, padding=0, args=args),
norm(192, args),
actv(args),
nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
custom_conv(192, 192, kernel_size=3, stride=1, padding=1, args=args),
norm(192, args),
actv(args),
custom_conv(192, 192, kernel_size=1, stride=1, padding=0, args=args),
norm(192, args),
actv(args),
nn.Conv2d(192, 10, kernel_size=1, stride=1, padding=0),
norm(10, args),
actv(args),
nn.AvgPool2d(kernel_size=8, stride=1, padding=0),
)
def forward(self, x):
x = self.body(x)
x = x.view(x.size(0), self.args.num_classes)
return x
def nin(args=None):
model = Net(args)
return model
| 2.40625 | 2 |
sync_operation.py | judsoncrouch/photo_sync | 0 | 12789114 | from dirsync import sync
import win32api as win
import os
import click
def get_drive_names():
drives = win.GetLogicalDriveStrings()
drives = drives.split('\000')[:-1]
drive_map = {}
for d in drives:
drive_name = win.GetVolumeInformation(d)[0]
drive_map[drive_name] = d
return drive_map
def sync_raw_to_hdd(raw_dir, hdd):
print "Syncing RAW to %s\n..." % hdd
sync(raw_dir, hdd, "sync")
print " Complete\n"
def sync_catalog_to_backup(catalog, backup):
print "Syncing Catalog to %s\n..." % backup
sync(catalog, backup, "sync")
print " Complete\n"
def sync_hdd_to_backup(hdd, backup):
print "Syncing %s to %s\n..." % (hdd, backup)
sync(hdd, backup, "sync")
print " Complete\n"
@click.command()
@click.option('--raw', 'processes', flag_value='raw')
@click.option('--catalog', 'processes', flag_value='catalog')
@click.option('--all', 'processes', flag_value='all')
def main(processes):
raw_dir = r"E:\Pictures\RAW"
catalog_nm = "Catalog_JC"
hdd_nm = "Photos_A1"
backup_nm = "Photos_A1_Backup"
try:
drives = get_drive_names()
hdd = drives[hdd_nm]
backup = drives[backup_nm]
catalog = drives[catalog_nm]
if processes == 'raw':
sync_raw_to_hdd(raw_dir, hdd)
sync_hdd_to_backup(hdd, backup)
elif processes == 'catalog':
sync_catalog_to_backup(catalog, backup)
else:
sync_raw_to_hdd(raw_dir, hdd)
sync_hdd_to_backup(hdd, backup)
sync_catalog_to_backup(catalog, backup)
except KeyError:
print "Photo drives not found."
if __name__ == '__main__':
main() | 2.96875 | 3 |
fluxgapfill/metrics/metrics.py | stanfordmlgroup/methane-gapfill-ml | 8 | 12789115 | <gh_stars>1-10
import numpy as np
from sklearn.metrics import (
mean_squared_error,
mean_absolute_error,
r2_score
)
from scipy.stats import pearsonr
def pearson_r_squared(truth, prediction):
return pearsonr(truth, prediction)[0] ** 2
def reference_standard_dev(truth, prediction):
return np.std(truth)
def normalized_mean_absolute_error(truth, prediction):
return (mean_absolute_error(truth, prediction) /
reference_standard_dev(truth, prediction))
def bias(truth, prediction):
return (prediction - truth).mean()
metric_dict = {
"mse": mean_squared_error,
"mae": mean_absolute_error,
"nmae": normalized_mean_absolute_error,
"r2": r2_score,
"pr2": pearson_r_squared,
"bias": bias
}
def get_pred_interval(pred_dist):
return np.array([dist.dist.interval(0.95) for dist in pred_dist])
def calibration(truth, pred_dist):
pred_interval = get_pred_interval(pred_dist)
frac_of_truth_in_interval = (
(truth > pred_interval[:, 0]) &
(truth < pred_interval[:, 1])
).mean()
return frac_of_truth_in_interval
def sharpness(truth, pred_dist):
pred_interval = get_pred_interval(pred_dist)
widths = np.diff(pred_interval, axis=1)
return widths.mean()
def normalized_sharpness(truth, pred_dist):
pred_interval = get_pred_interval(pred_dist)
widths = np.diff(pred_interval, axis=1)
return widths.mean() / np.std(truth)
uncertainty_metric_dict = {
"calibration": calibration,
"sharpness": sharpness,
"normalized_sharpness": normalized_sharpness
}
| 2.515625 | 3 |
versions/v1/v1_tb/aux_kfold.py | otavares93/rxpix2pix | 0 | 12789116 | <filename>versions/v1/v1_tb/aux_kfold.py<gh_stars>0
import os
import numpy as np
import argparse
from sklearn.model_selection import StratifiedKFold
#from data.image_folder import make_dataset
#from tensorflow.keras.preprocessing.image import ImageDataGenerator
import tensorflow as tf
import json
import pandas as pd
import numpy as np
import os, sys
import glob
import re
import hashlib
import pathlib
import cv2
#TO-DO acrescentar isTB no options
isTB = True
#from options.train_options import TrainOptions
#from data import create_dataset
#from models import create_model
#from rxwgan.models import *
#from rxwgan.wgangp import wgangp_optimizer
#from rxcore import stratified_train_val_test_splits
def run(command: object) -> object:
print(command)
exit_status = os.system(command)
if exit_status > 0:
exit(1)
IMG_EXTENSIONS = [
'.jpg', '.JPG', '.jpeg', '.JPEG',
'.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP',
'.tif', '.TIF', '.tiff', '.TIFF',
]
def is_image_file(filename):
return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
def expand_folder( path , extension):
l = glob.glob(path+'/*.'+extension)
l.sort()
return l
def get_md5(path):
return hashlib.md5(pathlib.Path(path).read_bytes()).hexdigest()
#import numpy as np
#
# Split train/val/test splits
#
def stratified_train_val_test_splits( df_kfold, seed=512 ):
cv_train_test = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
cv_train_val = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
sorts_train_test = []
for train_val_idx, test_idx in cv_train_test.split( df_kfold.values,df_kfold.target.values ):
train_val_df = df_kfold.iloc[train_val_idx]
sorts = []
for train_idx, val_idx in cv_train_val.split( train_val_df.values, train_val_df.target.values ):
sorts.append((train_val_df.index[train_idx].values, train_val_df.index[val_idx].values, test_idx))
sorts_train_test.append(sorts)
return sorts_train_test
def make_dataset(dir, max_dataset_size=float("inf")):
images = []
assert os.path.isdir(dir), '%s is not a valid directory' % dir
for root, _, fnames in sorted(os.walk(dir)):
for fname in fnames:
if is_image_file(fname):
path = os.path.join(root, fname)
images.append(path)
return images[:min(max_dataset_size, len(images))]
def prepare_my_table(clinical_path, images_path, masks_path, combine = False):
d = {
'target': [],
'image_ID': [],
'raw_image_path': [],
'mask_image_path': [],
'paired_image_path': [],
'raw_image_md5': [],
'age': [],
'sex': [],
'comment': [],
}
def treat_string(lines):
string = ''
for s in lines:
string += s.replace('\n', '').replace('\t', '')
return re.sub(' +', ' ', string)
for idx, path in enumerate(expand_folder(clinical_path, 'txt')):
with open(path, 'r') as f:
lines = f.readlines()
sex = 'male' if 'male' in lines[0] else 'female' # 1 for male and 0 for female
age = int(re.sub('\D', '', lines[0]))
# get TB by file name (_1.txt is PTB or _0.txt is NTB)
target = 1 if '_1.txt' in path else 0
filename = path.split('/')[-1]
image_filename = filename.replace('txt', 'png')
# image_path = images_path+('/tb/' if target else '/no_tb/')+image_filename
image_path = images_path + '/' + image_filename
d['target'].append(target)
d['age'].append(age)
d['sex'].append(sex)
d['raw_image_path'].append(image_path)
d['raw_image_md5'].append(get_md5(image_path))
d['mask_image_path'].append('')
d['paired_image_path'].append('')
d['comment'].append(treat_string(lines[1::]))
d['image_ID'].append(filename.replace('.txt', ''))
l_masks = make_dataset(masks_path)
for mask in l_masks:
if image_path[-17:] == mask[-17:]:
idx = np.where(np.array(d['raw_image_path']) == image_path)[0][0]
d['mask_image_path'][idx] = mask
if combine == True:
path_paired = image_path[:-25] + 'foldAB'
path_paired_img = path_paired + '/' + image_path[-17:]
d['paired_image_path'][idx] = path_paired_img
if not os.path.isdir(path_paired):
os.makedirs(path_paired)
im_A = cv2.imread(image_path)
im_B = cv2.imread(mask)
im_AB = np.concatenate([im_B, im_A], 1)
cv2.imwrite(path_paired_img, im_AB)
return pd.DataFrame(d)
# NOTE: this is optional.
#from rxcore import allow_tf_growth
#allow_tf_growth()
#
# Start your job here
#
#job = json.load(open(args.job, 'r'))
#sort = job['sort']
#target = 1 # tb active
#test = job['test']
seed = 512
#epochs = 1000
#batch_size = 32
base_data_raw_path = '/Users/ottotavares/Documents/COPPE/projetoTB/China/CXR_png/unaligned'
clinical_path = base_data_raw_path + '/ClinicalReadings'
images_path = base_data_raw_path + '/trainA'
masks_path = base_data_raw_path + '/trainB'
df = prepare_my_table(clinical_path, images_path, masks_path, combine = True)
splits = stratified_train_val_test_splits(df,seed)[0]
training_data = df.iloc[splits[0][0]]
validation_data = df.iloc[splits[0][1]]
if(isTB == True):
train_tb = training_data.loc[df.target==1]
val_tb = validation_data.loc[df.target==1]
else:
train_ntb = training_data.loc[df.target==0]
val_ntb = validation_data.loc[df.target == 0]
#training_data = training_data.loc[training_data.target==target]
#validation_data = validation_data.loc[validation_data.target==target]
extra_d = {'sort' : sort, 'test':test, 'target':target, 'seed':seed}
# Run!
#history = optimizer.fit( train_generator , val_generator, extra_d=extra_d, wandb=wandb )
combine_ab = 'python datasets/combine_A_and_B.py --fold_A /Users/ottotavares/Documents/COPPE/projetoTB/China/CXR_png/unaligned/trainA --fold_B /Users/ottotavares/Documents/COPPE/projetoTB/China/CXR_png/unaligned/trainB --fold_AB /Users/ottotavares/Documents/COPPE/projetoTB/China/CXR_png/unaligned'
run(combine_ab)
# pix2pix train/test
#train_cmd = 'python train.py --model pix2pix --name ' + 'test_%d_sort_%d'%(test,sort) + '--dataroot . --n_epochs 1 --n_epochs_decay 5 --save_latest_freq 10 --display_id -1'
#run(train_cmd)
#run('python test.py --model pix2pix --name temp_pix2pix --dataroot ./datasets/mini_pix2pix --num_test 1')
| 2.140625 | 2 |
libs/jsconsole/jsconsolescript.py | bugbound/webnuke | 23 | 12789117 | class JSConsoleScript:
def __init__(self, jsinjector):
self.version=0.1
self.jsinjector = jsinjector
self.jsinjector.add_help_topic('wn_help()', 'Shows WebNuke Help')
| 1.734375 | 2 |
flask_plots/core.py | juniors90/Flask-Plots | 1 | 12789118 | <reponame>juniors90/Flask-Plots
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# This docstring was part of Matplotlib. All rights reserved.
# Full Text:
# https://matplotlib.org/stable/users/project/license.html
#
# This file is part of the
# Flask-Plots Project https://github.com/juniors90/Flask-Plots/
#
# Copyright (c) 2021, <NAME>
# License: MIT
# Full Text:
# https://github.com/juniors90/Flask-Plots/blob/master/LICENSE
#
# =============================================================================
# DOCS
# =============================================================================
"""Flask-Plots.
Implementation of Matplotlib in Flask.
"""
# =============================================================================
# IMPORTS
# =============================================================================
import base64
import io
from flask import Blueprint, current_app
def raise_helper(message): # pragma: no cover
"""Handle for raise in jinja templates."""
raise RuntimeError(message)
class Plots(object):
"""Base extension class for different Plots versions.
.. versionadded:: 0.0.1
"""
static_folder = "plots"
# Generate the figure **without using pyplot**.
def __init__(self, app=None):
if app is not None:
self.init_app(app)
def init_app(self, app):
"""Sample factory function for initialize the extension."""
app.config.setdefault("PLOTS_CMAP", "Greys")
app.config.setdefault("STATIC_FOLDER", "plots")
app.config.setdefault("BAR_HEIGHT", 50)
if not hasattr(app, "extensions"): # pragma: no cover
app.extensions = {}
app.extensions["plots"] = self
blueprint = Blueprint(
"plots",
__name__,
static_folder=f"static/{self.static_folder}",
static_url_path=f"{app.static_url_path}",
template_folder="templates",
)
app.register_blueprint(blueprint)
app.jinja_env.globals["plots"] = self
app.jinja_env.globals["raise"] = raise_helper
app.jinja_env.add_extension("jinja2.ext.do")
def get_data(self, fig, fmt="png", decode="ascii"):
"""
Create a data for embed the result in the html output.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
format : str, default: "png"
A extension type for the images.
decode : str, default: "ascii"
A buffer decode.
"""
buf = io.BytesIO()
fig.savefig(buf, format=fmt)
data = base64.b64encode(buf.getbuffer()).decode(decode)
return data
# Statistics plots: Plots for statistical analysis.
def hist(self, fig, x, ax=None, hist_kws=None):
"""
Plot a histogram using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x : (n,) array or sequence of (n,) arrays
Input values, this takes either a single array or a sequence of
arrays which are not required to be of the same length.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
hist_kwargs : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
hist_kws = {} if hist_kws is None else hist_kws
ax.hist(x, **hist_kws)
return ax
def errorbar(self, fig, x, y, ax=None, errorbar_kws=None):
"""
Plot y versus x as lines and/or markers with attached errorbars.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : float or array-like
The data positions.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
errorbar_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
errorbar_kws = {} if errorbar_kws is None else errorbar_kws
ax.errorbar(x, y, **errorbar_kws)
return ax
def violinplot(
self, fig, dataset, positions, ax=None, violinplot_kws=None
):
"""
Make a violin plot using Matlotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
dataset : Array or a sequence of vectors.
The input data.
positions : array-like, default: [1, 2, ..., n]
The positions of the violins. The ticks and limits are
automatically set to match the positions.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
violinplot_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
violinplot_kws = {} if violinplot_kws is None else violinplot_kws
vp = ax.violinplot(dataset, positions, **violinplot_kws)
return vp
def eventplot(self, fig, positions, ax=None, eventplot_kws=None):
"""
Plot identical parallel lines at the given positions.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
positions : array-like or list of array-like
A 1D array-like defines the positions of one sequence of events.
Multiple groups of events may be passed as a list of array-likes.
Each group can be styled independently by passing lists of values
to *lineoffsets*, *linelengths*, *linewidths*, *colors* and
*linestyles*.
Note that *positions* can be a 2D array, but in practice different
event groups usually have different counts so that one will use a
list of different-length arrays rather than a 2D array.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
eventplot_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
eventplot_kws = {} if eventplot_kws is None else eventplot_kws
ax.eventplot(positions, **eventplot_kws)
return ax
def hist2d(self, fig, x, y, ax=None, hist2d_kws=None):
"""
Make a 2D histogram plot using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : array-like, shape (n, )
Input values
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
hist2d_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
hist2d_kws = {} if hist2d_kws is None else hist2d_kws
ax.hist2d(x, y, **hist2d_kws)
return ax
def hexbin(self, fig, x, y, ax=None, hexbin_kws=None):
"""
Make a 2D hexagonal binning plot of points *x*, *y* using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : array-like
The data positions. *x* and *y* must be of the same length.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
hexbin_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
hexbin_kws = {} if hexbin_kws is None else hexbin_kws
ax.hexbin(x, y, **hexbin_kws)
return ax
def scatter_hist2d(
self, fig, x, y, ax=None, hist2d_kws=None, scatter_kws=None
):
"""
Make a 2D histogram plot using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : array-like, shape (n, )
Input values
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
hist2d_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
scatter_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot in term scatter method.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
hist2d_kws = {} if hist2d_kws is None else hist2d_kws
scatter_kws = {} if scatter_kws is None else scatter_kws
hist2d_kws.setdefault("cmap", current_app.config["PLOTS_CMAP"])
ax.hist2d(x, y, **hist2d_kws)
ax.scatter(x, y, **scatter_kws)
return ax
def scatter_hexbin(
self, fig, x, y, ax=None, hexbin_kws=None, scatter_kws=None
):
"""
Make a 2D scatter-hexagonal binning plot of points *x*, *y*.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : array-like
The data positions. *x* and *y* must be of the same length.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
hexbin_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot in term hexbin method.
scatter_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot in term scatter method.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
hexbin_kws = {} if hexbin_kws is None else hexbin_kws
scatter_kws = {} if scatter_kws is None else scatter_kws
hexbin_kws.setdefault("cmap", current_app.config["PLOTS_CMAP"])
ax.hexbin(x, y, **hexbin_kws)
ax.scatter(x, y, **scatter_kws)
return ax
def bar(self, fig, x, bar_height=None, ax=None, bar_kws=None):
"""
Make a bar plot using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x : float or array-like
The x coordinates of the bars. See also *align* for the
alignment of the bars to the coordinates.
bar_height : float or array-like,
The height(s) of the bars. You can config this value
using ``app.config["BAR_HEIGHT"]``.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
bar_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
bar_kws = {} if bar_kws is None else bar_kws
bar_height = (
current_app.config["BAR_HEIGHT"]
if bar_height is None
else bar_height
)
ax.bar(x, bar_height, **bar_kws)
return ax
def pie(self, fig, x, ax=None, pie_kws=None):
"""
Make a pie plot using Matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x : 1D array-like
The wedge sizes.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
bar_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
pie_kws = {} if pie_kws is None else pie_kws
ax.pie(x, **pie_kws)
return ax
def boxplot(self, fig, x, ax=None, boxplot_kws=None):
"""
Draw a box and whisker plot using MAtplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x : Array or a sequence of vectors.
The input data. If a 2D array, a boxplot is drawn for each column
in *x*. If a sequence of 1D arrays, a boxplot is drawn for each
array in *x*.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
boxplot_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
boxplot_kws = {} if boxplot_kws is None else boxplot_kws
ax.boxplot(x, **boxplot_kws)
return ax
def quiver(self, fig, x, y, u, v, ax=None, quiver_kws=None):
"""
Plot a 2D field of arrows using matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : 1D or 2D array-like, optional
The x and y coordinates of the arrow locations.
If not given, they will be generated as a uniform integer meshgrid
based on the dimensions of *u* and *v*.
If *x* and *y* are 1D but *u*, *v* are 2D, *x*, *y* are expanded
to 2D using ``x, y = np.meshgrid(x, y)``. In this case ``len(x)``
and ``len(y)`` must match the column and row dimensions of
*u* and *v*.
u, v : 1D or 2D array-like
The x and y direction components of the arrow vectors.
They must have the same number of elements, matching the
number of arrow locations. *u* and *v* may be masked. Only
locations unmasked in *u*, *v*, and *C* will be drawn.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
quiver_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
quiver_kws = {} if quiver_kws is None else quiver_kws
ax.quiver(x, y, u, v, **quiver_kws)
return ax
def streamplot(self, fig, x, y, u, v, ax=None, streamplot_kws=None):
"""
Draw streamlines of a vector flow using matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : 1D/2D arrays
Evenly spaced strictly increasing arrays to make a grid.
If 2D, all rows of *x* must be equal and all columns of
*y* must be equal; i.e., they must be as if generated
by ``np.meshgrid(x_1d, y_1d)``.
u, v : 2D arrays
*x* and *y*-velocities. The number of rows and columns
must match the length of *y* and *x*, respectively.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
streamplot_kws : ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
"""
ax = fig.gca() if ax is None else ax
streamplot_kws = {} if streamplot_kws is None else streamplot_kws
ax.streamplot(x, y, u, v, **streamplot_kws)
return ax
def contourf(self, fig, x, y, z, levels, ax=None, contourf_kws=None):
"""
Plot contour lines using matplotlib.
Parameters
----------
fig : matplotlib.Figure
A instance of Figure Object.
x, y : array-like, optional
The coordinates of the values in *z*.
*x* and *y* must both be 2D with the same shape as *z* (e.g.
created via `numpy.meshgrid`), or they must both be 1-D such
that ``len(x) == N`` is the number of columns in *z* and
``len(y) == M`` is the number of rows in *z*.
*X* and *Y* must both be ordered monotonically.
If not given, they are assumed to be integer indices, i.e.
``x = range(N)``, ``y = range(M)``.
levels : int or array-like, optional
Determines the number and positions of the contour lines / regions.
If an int *n*, use `~matplotlib.ticker.MaxNLocator`, which tries
to automatically choose no more than *n+1* "nice" contour levels
between *vmin* and *vmax*.
If array-like, draw contour lines at the specified levels.
The values must be in increasing order.
ax : matplotlib.Figure.Axis, (optional)
A matplotlib axis.
contourf_kws: ``dict`` or ``None`` (optional)
The parameters to send to the data plot.
Returns
-------
ax : matplotlib.Figure.Axis
A matplotlib axis.
"""
ax = fig.gca() if ax is None else ax
contourf_kws = {} if contourf_kws is None else contourf_kws
ax.contourf(x, y, z, levels, **contourf_kws)
return ax
| 1.6875 | 2 |
m26-py/m26/speed.py | cjoakim/oss | 0 | 12789119 | __author__ = 'cjoakim'
import math
from .elapsed_time import ElapsedTime
class Speed(object):
def __init__(self, d, et):
self.dist = d # an instance of Distance
self.etime = et # an instance of ElapsedTime
def mph(self):
return self.dist.as_miles() / self.etime.hours()
def kph(self):
return self.dist.as_kilometers() / self.etime.hours()
def yph(self):
return self.dist.as_yards() / self.etime.hours()
def pace_per_mile(self):
spm = self.seconds_per_mile()
mm = math.floor(spm / 60.0)
ss = spm - (mm * 60.0)
if ss < 10:
ss = "0{0}".format(ss)
else:
ss = "{0}".format(ss)
if len(ss) > 5:
ss = ss[0:5]
return "{0}:{1}".format(mm, ss)
def seconds_per_mile(self):
return float(self.etime.secs / self.dist.as_miles())
def projected_time(self, another_distance, algorithm='simple'):
if algorithm is 'riegel':
t1 = float(self.etime.secs)
d1 = self.dist.as_miles()
d2 = another_distance.as_miles()
t2 = t1 * math.pow(float(d2 / d1), float(1.06))
et = ElapsedTime(t2)
return et.as_hhmmss()
else:
secs = float(self.seconds_per_mile() * another_distance.as_miles())
et = ElapsedTime(secs)
return et.as_hhmmss()
def age_graded(self, event_age, graded_age):
ag_factor = event_age.max_pulse() / graded_age.max_pulse()
graded_secs = float((self.etime.secs)) * float(ag_factor)
graded_et = ElapsedTime(graded_secs)
return Speed(self.dist, graded_et)
def __str__(self):
template = "<Speed dist:{0} etime:{1}>"
return template.format(self.dist, self.etime)
| 3.46875 | 3 |
huskar_api/models/instance/__init__.py | mowangdk/huskar | 59 | 12789120 | from __future__ import absolute_import
from .management import InstanceManagement
from .schema import InfraInfo
__all__ = ['InstanceManagement', 'InfraInfo']
| 1.023438 | 1 |
cogs/orb_control.py | azsry/orb | 3 | 12789121 | <reponame>azsry/orb
"""
Handles general control tasks and acts as a function generaliser for other commands. Also contains some admin-only commands and runs the database
"""
import discord
from discord.ext import commands as bot_commands
import csv
import os
from google.cloud import firestore
from utils import repo, logger
# Verifies if the command is allowed to be executed
# This is a utility function and shouldn't be called on it's own (hence the lack of .command decorator)
# Not async because a). Incredibly low complexity (aka fast)
# b). This is a priority to execute
# c). Nothing would be awaited in here so an async function would work the same as a regular
def allowed_channel(ctx):
if ctx in BANNED_CHANNELS:
return False
else:
return True
# Connects to Cloud Firestore
logger.log_and_print("control", "Verifiying with server")
os.environ["GOOGLE_APPLICATION_CREDENTIALS"]=repo.config['keys']['firestore_key_path']
db = firestore.Client()
logger.log_and_print("control", "Connected to Google Cloud Firestore")
BANNED_CHANNELS = []
ADMINS = repo.config['controllers']
with open("data/banned_channels.csv", mode="r") as file:
reader = csv.reader(file, delimiter=",")
for line in reader:
try:
BANNED_CHANNELS.append(int(line[0]))
except:
pass
class ControlCog(bot_commands.Cog):
def __init__(self, bot):
self.bot = bot
# Manual speaking
@bot_commands.command()
async def say(self, ctx, channel, *, target=None):
if str(ctx.author.id) in ADMINS:
if target == None:
await ctx.send("Need a message")
else:
channel = self.bot.get_channel(int(channel))
logger.log_and_print("control", f"Sent message {str(target)} to channel {str(channel)}")
await channel.send(target)
# Update banned channels
@bot_commands.command()
async def update_banned(self, ctx):
if ctx.author.id in ADMINS:
BANNED_CHANNELS = []
with open("data/banned_channels.csv", mode="r", newline="") as file:
reader = csv.reader(file, delimiter=",")
for line in reader:
BANNED_CHANNELS.append(int(line[0]))
logger.log_and_print("control", "Updated internal banned channels list")
await ctx.send("Done!")
# Add a new banned channel
@bot_commands.command()
async def add_banned(self, ctx, target, *, comment=None):
if ctx.author.id in ADMINS:
logger.log_and_print("control", f"Adding {target} to banned channels list with comment {comment}")
with open("data/banned_channels.csv", mode="a", newline="") as file:
writer = csv.writer(file, delimiter=",", quotechar='"', quoting=csv.QUOTE_MINIMAL)
writer.writerow([target, str(" # " + str(comment))])
await ctx.send("Done!")
# Remove a banned channel
@bot_commands.command()
async def remove_banned(self, ctx, target):
if ctx.author.id in ADMINS:
logger.log_and_print("control", f"Removing {target} from banned channels list")
temp = []
with open("data/banned_channels.csv", mode="r", newline="") as file:
try:
temp = list(csv.reader(file, delimiter=","))
except:
pass
with open("data/banned_channels.csv", mode="w", newline="") as file:
writer = csv.writer(file, delimiter=",", quotechar='"', quoting=csv.QUOTE_MINIMAL)
for line in temp:
try:
if line[0] != target:
try:
writer.writerow(line)
except:
pass
except:
pass
temp=[]
await ctx.send("Done!")
# Lists banned channels
@bot_commands.command()
async def list_banned(self, ctx):
if ctx.author.id in ADMINS:
output = ""
with open("data/banned_channels.csv", mode="r", newline="") as file:
for line in file:
output += "Channel: " + line + "\n"
await ctx.send(output)
def setup(bot):
bot.add_cog(ControlCog(bot))
| 2.734375 | 3 |
customer/migrations/0008_contact.py | martinlehoux/erp-reloaded | 0 | 12789122 | <reponame>martinlehoux/erp-reloaded
# Generated by Django 3.0.3 on 2020-03-02 02:54
from django.db import migrations, models
import django.db.models.deletion
import phonenumber_field.modelfields
class Migration(migrations.Migration):
dependencies = [
('customer', '0007_customer_logo'),
]
operations = [
migrations.CreateModel(
name='Contact',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', models.CharField(max_length=256)),
('last_name', models.CharField(max_length=256)),
('email', models.EmailField(blank=True, max_length=254)),
('phone_number', phonenumber_field.modelfields.PhoneNumberField(blank=True, max_length=128, region=None)),
('customer', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='customer.Customer')),
],
),
]
| 1.734375 | 2 |
script/my_codes/train.py | ThivakaranThana/AlignedReid-Reproduction-Pytorch | 0 | 12789123 | <gh_stars>0
"""Train with optional Global Distance, Local Distance, Identification Loss."""
from __future__ import print_function
import sys
sys.path.insert(0, '.')
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.optim as optim
from torch.nn.parallel import DataParallel
import time
import os.path as osp
from tensorboardX import SummaryWriter
import numpy as np
import argparse
from aligned_reid.dataset import create_dataset
from aligned_reid.model.Model import Model
from aligned_reid.model.TripletLoss import TripletLoss
from aligned_reid.model.loss import global_loss
from aligned_reid.model.loss import local_loss
from aligned_reid.utils.utils import time_str
from aligned_reid.utils.utils import str2bool
from aligned_reid.utils.utils import tight_float_str as tfs
from aligned_reid.utils.utils import may_set_mode
from aligned_reid.utils.utils import load_state_dict
from aligned_reid.utils.utils import load_ckpt
from aligned_reid.utils.utils import save_ckpt
from aligned_reid.utils.utils import set_devices
from aligned_reid.utils.utils import AverageMeter
from aligned_reid.utils.utils import to_scalar
from aligned_reid.utils.utils import ReDirectSTD
from aligned_reid.utils.utils import set_seed
from aligned_reid.utils.utils import adjust_lr_exp
from aligned_reid.utils.utils import adjust_lr_staircase
class Config(object):
def __init__(self):
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--sys_device_ids', type=eval, default=(0,))
parser.add_argument('-r', '--run', type=int, default=1)
parser.add_argument('--set_seed', type=str2bool, default=False)
parser.add_argument('--dataset', type=str, default='custom_input',
choices=['market1501', 'cuhk03', 'duke', 'custom_input', 'combined'])
parser.add_argument('--trainset_part', type=str, default='trainval',
choices=['trainval', 'train'])
# Only for training set.
parser.add_argument('--resize_h_w', type=eval, default=(256, 128))
parser.add_argument('--crop_prob', type=float, default=0)
parser.add_argument('--crop_ratio', type=float, default=1)
parser.add_argument('--ids_per_batch', type=int, default=32)
parser.add_argument('--ims_per_id', type=int, default=4)
parser.add_argument('--log_to_file', type=str2bool, default=True)
parser.add_argument('--normalize_feature', type=str2bool, default=False)
parser.add_argument('--local_dist_own_hard_sample',
type=str2bool, default=False)
parser.add_argument('-gm', '--global_margin', type=float, default=0.3)
parser.add_argument('-lm', '--local_margin', type=float, default=0.3)
parser.add_argument('-glw', '--g_loss_weight', type=float, default=1.)
parser.add_argument('-llw', '--l_loss_weight', type=float, default=0.)
parser.add_argument('-idlw', '--id_loss_weight', type=float, default=0.)
parser.add_argument('--only_test', type=str2bool, default=True)
parser.add_argument('--resume', type=str2bool, default=False)
parser.add_argument('--exp_dir', type=str, default='/home/niruhan/AlignedReID-Re-Production-Pytorch/my_codes')
parser.add_argument('--model_weight_file', type=str,
default='/home/niruhan/AlignedReID-Re-Production-Pytorch/model_weight.pth')
parser.add_argument('--base_lr', type=float, default=2e-4)
parser.add_argument('--lr_decay_type', type=str, default='exp',
choices=['exp', 'staircase'])
parser.add_argument('--exp_decay_at_epoch', type=int, default=76)
parser.add_argument('--staircase_decay_at_epochs',
type=eval, default=(101, 201,))
parser.add_argument('--staircase_decay_multiply_factor',
type=float, default=0.1)
parser.add_argument('--total_epochs', type=int, default=150)
args = parser.parse_known_args()[0]
# gpu ids
self.sys_device_ids = args.sys_device_ids
if args.set_seed:
self.seed = 1
else:
self.seed = None
# The experiments can be run for several times and performances be averaged.
# `run` starts from `1`, not `0`.
self.run = args.run
###########
# Dataset #
###########
# If you want to exactly reproduce the result in training, you have to set
# num of threads to 1.
if self.seed is not None:
self.prefetch_threads = 1
else:
self.prefetch_threads = 2
self.dataset = args.dataset
self.trainset_part = args.trainset_part
# Image Processing
# Just for training set
self.crop_prob = args.crop_prob
self.crop_ratio = args.crop_ratio
self.resize_h_w = args.resize_h_w
# Whether to scale by 1/255
self.scale_im = True
self.im_mean = [0.486, 0.459, 0.408]
self.im_std = [0.229, 0.224, 0.225]
self.ids_per_batch = args.ids_per_batch
self.ims_per_id = args.ims_per_id
self.train_final_batch = False
self.train_mirror_type = ['random', 'always', None][0]
self.train_shuffle = True
self.test_batch_size = 32
self.test_final_batch = True
self.test_mirror_type = ['random', 'always', None][2]
self.test_shuffle = False
dataset_kwargs = dict(
name=self.dataset,
resize_h_w=self.resize_h_w,
scale=self.scale_im,
im_mean=self.im_mean,
im_std=self.im_std,
batch_dims='NCHW',
num_prefetch_threads=self.prefetch_threads)
prng = np.random
if self.seed is not None:
prng = np.random.RandomState(self.seed)
self.train_set_kwargs = dict(
part=self.trainset_part,
ids_per_batch=self.ids_per_batch,
ims_per_id=self.ims_per_id,
final_batch=self.train_final_batch,
shuffle=self.train_shuffle,
crop_prob=self.crop_prob,
crop_ratio=self.crop_ratio,
mirror_type=self.train_mirror_type,
prng=prng)
self.train_set_kwargs.update(dataset_kwargs)
prng = np.random
if self.seed is not None:
prng = np.random.RandomState(self.seed)
self.test_set_kwargs = dict(
part='test',
batch_size=self.test_batch_size,
final_batch=self.test_final_batch,
shuffle=self.test_shuffle,
mirror_type=self.test_mirror_type,
prng=prng)
self.test_set_kwargs.update(dataset_kwargs)
###############
# ReID Model #
###############
self.local_dist_own_hard_sample = args.local_dist_own_hard_sample
self.normalize_feature = args.normalize_feature
self.local_conv_out_channels = 128
self.global_margin = args.global_margin
self.local_margin = args.local_margin
# Identification Loss weight
self.id_loss_weight = args.id_loss_weight
# global loss weight
self.g_loss_weight = args.g_loss_weight
# local loss weight
self.l_loss_weight = args.l_loss_weight
#############
# Training #
#############
self.weight_decay = 0.0005
# Initial learning rate
self.base_lr = args.base_lr
self.lr_decay_type = args.lr_decay_type
self.exp_decay_at_epoch = args.exp_decay_at_epoch
self.staircase_decay_at_epochs = args.staircase_decay_at_epochs
self.staircase_decay_multiply_factor = args.staircase_decay_multiply_factor
# Number of epochs to train
self.total_epochs = args.total_epochs
# How often (in batches) to log. If only need to log the average
# information for each epoch, set this to a large value, e.g. 1e10.
self.log_steps = 1e10
# Only test and without training.
self.only_test = args.only_test
self.resume = args.resume
#######
# Log #
#######
# If True,
# 1) stdout and stderr will be redirected to file,
# 2) training loss etc will be written to tensorboard,
# 3) checkpoint will be saved
self.log_to_file = args.log_to_file
# The root dir of logs.
if args.exp_dir == '':
self.exp_dir = osp.join(
'exp/train',
'{}'.format(self.dataset),
#
('nf_' if self.normalize_feature else 'not_nf_') +
('ohs_' if self.local_dist_own_hard_sample else 'not_ohs_') +
'gm_{}_'.format(tfs(self.global_margin)) +
'lm_{}_'.format(tfs(self.local_margin)) +
'glw_{}_'.format(tfs(self.g_loss_weight)) +
'llw_{}_'.format(tfs(self.l_loss_weight)) +
'idlw_{}_'.format(tfs(self.id_loss_weight)) +
'lr_{}_'.format(tfs(self.base_lr)) +
'{}_'.format(self.lr_decay_type) +
('decay_at_{}_'.format(self.exp_decay_at_epoch)
if self.lr_decay_type == 'exp'
else 'decay_at_{}_factor_{}_'.format(
'_'.join([str(e) for e in args.staircase_decay_at_epochs]),
tfs(self.staircase_decay_multiply_factor))) +
'total_{}'.format(self.total_epochs),
#
'run{}'.format(self.run),
)
else:
self.exp_dir = args.exp_dir
self.stdout_file = osp.join(
self.exp_dir, 'stdout_{}.txt'.format(time_str()))
self.stderr_file = osp.join(
self.exp_dir, 'stderr_{}.txt'.format(time_str()))
# Saving model weights and optimizer states, for resuming.
self.ckpt_file = osp.join(self.exp_dir, 'ckpt.pth')
# Just for loading a pretrained model; no optimizer states is needed.
self.model_weight_file = args.model_weight_file
class ExtractFeature(object):
"""A function to be called in the val/test set, to extract features.
Args:
TVT: A callable to transfer images to specific device.
"""
def __init__(self, model, TVT):
self.model = model
self.TVT = TVT
def __call__(self, ims):
old_train_eval_model = self.model.training
# Set eval mode.
# Force all BN layers to use global mean and variance, also disable
# dropout.
self.model.eval()
ims = Variable(self.TVT(torch.from_numpy(ims).float()))
global_feat, local_feat = self.model(ims)[:2]
global_feat = global_feat.data.cpu().numpy()
local_feat = local_feat.data.cpu().numpy()
# Restore the model to its old train/eval mode.
self.model.train(old_train_eval_model)
return global_feat, local_feat
def main():
cfg = Config()
# Redirect logs to both console and file.
if cfg.log_to_file:
ReDirectSTD(cfg.stdout_file, 'stdout', False)
ReDirectSTD(cfg.stderr_file, 'stderr', False)
# Lazily create SummaryWriter
writer = None
TVT, TMO = set_devices(cfg.sys_device_ids)
if cfg.seed is not None:
set_seed(cfg.seed)
# Dump the configurations to log.
import pprint
print('-' * 60)
print('cfg.__dict__')
pprint.pprint(cfg.__dict__)
print('-' * 60)
###########
# Dataset #
###########
train_set = create_dataset(**cfg.train_set_kwargs)
test_sets = []
test_set_names = []
if cfg.dataset == 'combined':
for name in ['market1501', 'cuhk03', 'duke']:
cfg.test_set_kwargs['name'] = name
test_sets.append(create_dataset(**cfg.test_set_kwargs))
test_set_names.append(name)
else:
test_sets.append(create_dataset(**cfg.test_set_kwargs))
test_set_names.append(cfg.dataset)
###########
# Models #
###########
model = Model(local_conv_out_channels=cfg.local_conv_out_channels,
num_classes=len(train_set.ids2labels))
# Model wrapper
model_w = DataParallel(model)
#############################
# Criteria and Optimizers #
#############################
id_criterion = nn.CrossEntropyLoss()
g_tri_loss = TripletLoss(margin=cfg.global_margin)
l_tri_loss = TripletLoss(margin=cfg.local_margin)
optimizer = optim.Adam(model.parameters(),
lr=cfg.base_lr,
weight_decay=cfg.weight_decay)
# Bind them together just to save some codes in the following usage.
modules_optims = [model, optimizer]
################################
# May Resume Models and Optims #
################################
if cfg.resume:
resume_ep, scores = load_ckpt(modules_optims, cfg.ckpt_file)
# May Transfer Models and Optims to Specified Device. Transferring optimizer
# is to cope with the case when you load the checkpoint to a new device.
TMO(modules_optims)
########
# Test #
########
def test(load_model_weight=False):
if load_model_weight:
if cfg.model_weight_file != '':
map_location = (lambda storage, loc: storage)
sd = torch.load(cfg.model_weight_file, map_location=map_location)
load_state_dict(model, sd)
print('Loaded model weights from {}'.format(cfg.model_weight_file))
else:
load_ckpt(modules_optims, cfg.ckpt_file)
use_local_distance = (cfg.l_loss_weight > 0) \
and cfg.local_dist_own_hard_sample
for test_set, name in zip(test_sets, test_set_names):
test_set.set_feat_func(ExtractFeature(model_w, TVT))
print('\n=========> Test on dataset: {} <=========\n'.format(name))
best_match = test_set.predict(
normalize_feat=cfg.normalize_feature,
use_local_distance=True)
count = 0
for i in range(len(test_set.marks)):
if test_set.marks[i] == 1:
if count == best_match:
best_match_id = test_set.im_names[i][:8]
count += 1
print(best_match_id)
if cfg.only_test:
test(load_model_weight=True)
return
############
# Training #
############
start_ep = resume_ep if cfg.resume else 0
for ep in range(start_ep, cfg.total_epochs):
# Adjust Learning Rate
if cfg.lr_decay_type == 'exp':
adjust_lr_exp(
optimizer,
cfg.base_lr,
ep + 1,
cfg.total_epochs,
cfg.exp_decay_at_epoch)
else:
adjust_lr_staircase(
optimizer,
cfg.base_lr,
ep + 1,
cfg.staircase_decay_at_epochs,
cfg.staircase_decay_multiply_factor)
may_set_mode(modules_optims, 'train')
g_prec_meter = AverageMeter()
g_m_meter = AverageMeter()
g_dist_ap_meter = AverageMeter()
g_dist_an_meter = AverageMeter()
g_loss_meter = AverageMeter()
l_prec_meter = AverageMeter()
l_m_meter = AverageMeter()
l_dist_ap_meter = AverageMeter()
l_dist_an_meter = AverageMeter()
l_loss_meter = AverageMeter()
id_loss_meter = AverageMeter()
loss_meter = AverageMeter()
ep_st = time.time()
step = 0
epoch_done = False
while not epoch_done:
step += 1
step_st = time.time()
ims, im_names, labels, mirrored, epoch_done = train_set.next_batch()
ims_var = Variable(TVT(torch.from_numpy(ims).float()))
labels_t = TVT(torch.from_numpy(labels).long())
labels_var = Variable(labels_t)
global_feat, local_feat, logits = model_w(ims_var)
g_loss, p_inds, n_inds, g_dist_ap, g_dist_an, g_dist_mat = global_loss(
g_tri_loss, global_feat, labels_t,
normalize_feature=cfg.normalize_feature)
if cfg.l_loss_weight == 0:
l_loss = 0
elif cfg.local_dist_own_hard_sample:
# Let local distance find its own hard samples.
l_loss, l_dist_ap, l_dist_an, _ = local_loss(
l_tri_loss, local_feat, None, None, labels_t,
normalize_feature=cfg.normalize_feature)
else:
l_loss, l_dist_ap, l_dist_an = local_loss(
l_tri_loss, local_feat, p_inds, n_inds, labels_t,
normalize_feature=cfg.normalize_feature)
id_loss = 0
if cfg.id_loss_weight > 0:
id_loss = id_criterion(logits, labels_var)
loss = g_loss * cfg.g_loss_weight \
+ l_loss * cfg.l_loss_weight \
+ id_loss * cfg.id_loss_weight
optimizer.zero_grad()
loss.backward()
optimizer.step()
############
# Step Log #
############
# precision
g_prec = (g_dist_an > g_dist_ap).data.float().mean()
# the proportion of triplets that satisfy margin
g_m = (g_dist_an > g_dist_ap + cfg.global_margin).data.float().mean()
g_d_ap = g_dist_ap.data.mean()
g_d_an = g_dist_an.data.mean()
g_prec_meter.update(g_prec)
g_m_meter.update(g_m)
g_dist_ap_meter.update(g_d_ap)
g_dist_an_meter.update(g_d_an)
g_loss_meter.update(to_scalar(g_loss))
if cfg.l_loss_weight > 0:
# precision
l_prec = (l_dist_an > l_dist_ap).data.float().mean()
# the proportion of triplets that satisfy margin
l_m = (l_dist_an > l_dist_ap + cfg.local_margin).data.float().mean()
l_d_ap = l_dist_ap.data.mean()
l_d_an = l_dist_an.data.mean()
l_prec_meter.update(l_prec)
l_m_meter.update(l_m)
l_dist_ap_meter.update(l_d_ap)
l_dist_an_meter.update(l_d_an)
l_loss_meter.update(to_scalar(l_loss))
if cfg.id_loss_weight > 0:
id_loss_meter.update(to_scalar(id_loss))
loss_meter.update(to_scalar(loss))
if step % cfg.log_steps == 0:
time_log = '\tStep {}/Ep {}, {:.2f}s'.format(
step, ep + 1, time.time() - step_st, )
if cfg.g_loss_weight > 0:
g_log = (', gp {:.2%}, gm {:.2%}, '
'gd_ap {:.4f}, gd_an {:.4f}, '
'gL {:.4f}'.format(
g_prec_meter.val, g_m_meter.val,
g_dist_ap_meter.val, g_dist_an_meter.val,
g_loss_meter.val, ))
else:
g_log = ''
if cfg.l_loss_weight > 0:
l_log = (', lp {:.2%}, lm {:.2%}, '
'ld_ap {:.4f}, ld_an {:.4f}, '
'lL {:.4f}'.format(
l_prec_meter.val, l_m_meter.val,
l_dist_ap_meter.val, l_dist_an_meter.val,
l_loss_meter.val, ))
else:
l_log = ''
if cfg.id_loss_weight > 0:
id_log = (', idL {:.4f}'.format(id_loss_meter.val))
else:
id_log = ''
total_loss_log = ', loss {:.4f}'.format(loss_meter.val)
log = time_log + \
g_log + l_log + id_log + \
total_loss_log
print(log)
#############
# Epoch Log #
#############
time_log = 'Ep {}, {:.2f}s'.format(ep + 1, time.time() - ep_st, )
if cfg.g_loss_weight > 0:
g_log = (', gp {:.2%}, gm {:.2%}, '
'gd_ap {:.4f}, gd_an {:.4f}, '
'gL {:.4f}'.format(
g_prec_meter.avg, g_m_meter.avg,
g_dist_ap_meter.avg, g_dist_an_meter.avg,
g_loss_meter.avg, ))
else:
g_log = ''
if cfg.l_loss_weight > 0:
l_log = (', lp {:.2%}, lm {:.2%}, '
'ld_ap {:.4f}, ld_an {:.4f}, '
'lL {:.4f}'.format(
l_prec_meter.avg, l_m_meter.avg,
l_dist_ap_meter.avg, l_dist_an_meter.avg,
l_loss_meter.avg, ))
else:
l_log = ''
if cfg.id_loss_weight > 0:
id_log = (', idL {:.4f}'.format(id_loss_meter.avg))
else:
id_log = ''
total_loss_log = ', loss {:.4f}'.format(loss_meter.avg)
log = time_log + \
g_log + l_log + id_log + \
total_loss_log
print(log)
# Log to TensorBoard
if cfg.log_to_file:
if writer is None:
writer = SummaryWriter(log_dir=osp.join(cfg.exp_dir, 'tensorboard'))
writer.add_scalars(
'loss',
dict(global_loss=g_loss_meter.avg,
local_loss=l_loss_meter.avg,
id_loss=id_loss_meter.avg,
loss=loss_meter.avg, ),
ep)
writer.add_scalars(
'tri_precision',
dict(global_precision=g_prec_meter.avg,
local_precision=l_prec_meter.avg, ),
ep)
writer.add_scalars(
'satisfy_margin',
dict(global_satisfy_margin=g_m_meter.avg,
local_satisfy_margin=l_m_meter.avg, ),
ep)
writer.add_scalars(
'global_dist',
dict(global_dist_ap=g_dist_ap_meter.avg,
global_dist_an=g_dist_an_meter.avg, ),
ep)
writer.add_scalars(
'local_dist',
dict(local_dist_ap=l_dist_ap_meter.avg,
local_dist_an=l_dist_an_meter.avg, ),
ep)
# save ckpt
if cfg.log_to_file:
save_ckpt(modules_optims, ep + 1, 0, cfg.ckpt_file)
########
# Test #
########
test(load_model_weight=False)
if __name__ == '__main__':
main()
| 1.703125 | 2 |
process_model.py | hdm-dt-fb/rvt_model_services | 28 | 12789124 | <reponame>hdm-dt-fb/rvt_model_services<filename>process_model.py
""" process_model.py
Usage:
process_model.py <command> <project_code> <full_model_path> [options]
Arguments:
command action to be run on model, like: qc, audit or dwf
currently available: qc, audit, dwf
project_code unique project code consisting of 'projectnumber_projectModelPart'
like 456_11 , 416_T99 or 377_S
full_model_path revit model path including file name
use cfg shortcut if your full model path is already set in config.ini
Options:
-h, --help Show this help screen.
--viewer run revit in viewer mode (-> no transactions)
--html_path=<html> path to store html bokeh graphs, default in /commands/qc/*.html
--write_warn_ids write warning ids from warning command
--rvt_path=<rvt> full path to force specific rvt version other than detected
--rvt_ver=<rvtver> specify revit version and skip checking revit file version
(helpful if opening revit server files)
--audit activate open model with audit
--noworkshared open non-workshared model
--nodetach do not open workshared model detached
--notify choose to be notified with configured notify module(s)
--nofilecheck skips verifying model path actually exists
(helpful if opening revit server files)
--skip_hash_unchanged skips processing unchanged file
--timeout=<seconds> timeout in seconds before revit process gets terminated
"""
from docopt import docopt
import os
import pathlib
import hashlib
import subprocess
import psutil
import configparser
import time
import datetime
import logging
import colorful as col
import rvt_detector
from collections import defaultdict
from importlib import machinery
from tinydb import TinyDB, Query
from utils import rvt_journal_parser, rvt_journal_purger
from utils.win_utils import proc_open_files
from utils.rms_paths import get_paths
from notify.email import send_mail
from notify.slack import send_slack
from notify.req_post import send_post
def check_cfg_path(prj_number, cfg_str_or_path, cfg_path):
config = configparser.ConfigParser()
ini_file = cfg_path / "config.ini"
if cfg_str_or_path == "cfg":
if not cfg_str_or_path.exists():
if ini_file.exists():
config.read(ini_file)
if prj_number in config:
config_path = config[prj_number]["path"]
return config_path
return pathlib.Path(cfg_str_or_path)
def get_model_hash(rvt_model_path):
"""
Creates a hash of provided rvt model file
:param rvt_model_path:
:return: hash string
"""
BLOCKSIZE = 65536
hasher = hashlib.sha256()
with open(rvt_model_path, "rb") as rvt:
buf = rvt.read(BLOCKSIZE)
while len(buf) > 0:
hasher.update(buf)
buf = rvt.read(BLOCKSIZE)
return hasher.hexdigest()
def check_hash_unchanged(hash_db, rvt_model_path, model_hash, date):
model_info = {"<full_model_path>": str(rvt_model_path),
">last_hash": model_hash,
">last_hash_date": date,
}
unchanged = hash_db.search((Query()["<full_model_path>"] == str(rvt_model_path)) &
(Query()[">last_hash"] == model_hash)
)
if unchanged:
return True
else:
hash_db.upsert(model_info, Query()["<full_model_path>"] == str(rvt_model_path)
)
def exit_with_log(message, severity=logging.warning, exit_return_code=1):
"""
Ends the whole script with a warning.
:param message:
:param exit_return_code:
:return:
"""
severity(f"{project_code};{current_proc_hash};{exit_return_code};;{message}")
exit()
def get_jrn_and_post_process(search_command, commands_dir):
"""
Searches command paths for register dict in __init__.py in command roots to
prepare appropriate command strings to be inserted into the journal file
:param search_command: command name to look up
:param commands_dir: commands directory
:return: command module, post process dict
"""
found_dir = False
module_rjm = None
post_proc_dict = defaultdict()
for directory in os.scandir(commands_dir):
command_name = directory.name
# print(command_name)
if search_command == command_name:
found_dir = True
print(f" found appropriate command directory {commands_dir / command_name}")
mod_init = commands_dir / command_name / "__init__.py"
if mod_init.exists():
mod = machinery.SourceFileLoader(command_name, str(mod_init)).load_module()
if "register" in dir(mod):
if mod.register["name"] == command_name:
if "rjm" in mod.register:
module_rjm = mod.register["rjm"]
if "post_process" in mod.register:
external_args = []
for arg in mod.register["post_process"]["args"]:
external_args.append(globals().get(arg))
post_proc_dict["func"] = mod.register["post_process"]["func"]
post_proc_dict["args"] = external_args
else:
exit_with_log('__init__.py in command directory not found')
if not found_dir:
print(col.bold_red(f" appropriate command directory for '{search_command}' not found - aborting."))
exit_with_log('command directory not found')
return module_rjm, post_proc_dict
def get_rvt_proc_journal(process, jrn_file_path):
open_files = process.open_files()
for proc_file in open_files:
file_name = pathlib.Path(proc_file.path).name
if file_name.startswith("journal"):
return proc_file.path
# if nothing found using the process.open_files
# dig deeper and get nasty
for proc_res in proc_open_files(process):
res_name = pathlib.Path(proc_res).name
if res_name.startswith("journal") and res_name.endswith("txt"):
return jrn_file_path / res_name
today_int = int(datetime.date.today().strftime("%Y%m%d"))
rms_paths = get_paths(__file__)
args = docopt(__doc__)
command = args["<command>"]
project_code = args["<project_code>"]
full_model_path = args["<full_model_path>"]
full_model_path = check_cfg_path(project_code, full_model_path, rms_paths.root)
model_path = full_model_path.parent
model_file_name = full_model_path.name
timeout = args["--timeout"]
html_path = args["--html_path"]
write_warn_ids = args["--write_warn_ids"]
rvt_override_path = args["--rvt_path"]
rvt_override_version = args["--rvt_ver"]
notify = args["--notify"]
disable_filecheck = args["--nofilecheck"]
disable_detach = args["--nodetach"]
disable_ws = args["--noworkshared"]
skip_hash_unchanged = args["--skip_hash_unchanged"]
audit = args["--audit"]
viewer = args["--viewer"]
if viewer:
viewer = "/viewer"
comma_concat_args = ",".join([f"{k}={v}" for k, v in args.items()])
print(col.bold_blue(f"+process model job control started with command: {command}"))
print(col.bold_orange(f"-detected following root path:"))
print(f" {rms_paths.root}")
format_json = {"sort_keys": True, "indent": 4, "separators": (',', ': ')}
hashes_db = TinyDB(rms_paths.db / "model_hashes.json", **format_json)
journal_file_path = rms_paths.journals / f"{project_code}.txt"
model_exists = full_model_path.exists()
timeout = int(timeout) if timeout else 60
if not html_path:
if command == "qc":
html_path = rms_paths.com_qc
elif command == "warnings":
html_path = rms_paths.com_warnings
elif not pathlib.Path(html_path).exists():
if command == "qc":
html_path = rms_paths.com_qc
print(f"your specified html path was not found - will export html graph to {rms_paths.com_qc} instead")
elif command == "warnings":
html_path = rms_paths.com_warnings
print(f"your specified html path was not found - will export html graph to {rms_paths.com_warnings} instead")
if write_warn_ids:
warn_ids_path = model_path / "RVT_fixme"
pathlib.Path(warn_ids_path).mkdir(exist_ok=True)
print(warn_ids_path)
else:
warn_ids_path = ""
job_logging = rms_paths.logs / "job_logging.csv"
header_logging = "time_stamp;level;project;process_hash;error_code;args;comments\n"
if not job_logging.exists():
with open(job_logging, "w") as logging_file:
logging_file.write(header_logging)
print(col.bold_blue(f"logging goes to: {job_logging}"))
logging.basicConfig(format='%(asctime)s;%(levelname)s;%(message)s',
datefmt="%Y%m%dT%H%M%SZ",
filename=job_logging,
level=logging.INFO)
logger = logging.getLogger(__name__)
logging.getLogger("bokeh").setLevel(logging.CRITICAL)
print(col.bold_orange('-detected following process structure:'))
current_proc_hash = hash(psutil.Process())
print(f" current process hash: {col.cyan(current_proc_hash)}")
logging.info(f"{project_code};{current_proc_hash};;{comma_concat_args};{'task_started'}")
if skip_hash_unchanged:
model_hash = get_model_hash(full_model_path)
print(f" model hash: {col.cyan(model_hash)}")
hash_unchanged = check_hash_unchanged(hashes_db, full_model_path, model_hash, today_int)
if hash_unchanged:
print(col.bold_red(f" model hash has not changed since last run!"))
print(col.bold_red(f" processing this model is skipped!!"))
time.sleep(1)
exit_with_log("unchanged_model", severity=logging.info, exit_return_code=0)
os.environ["RVT_QC_PRJ"] = project_code
os.environ["RVT_QC_PATH"] = str(full_model_path)
os.environ["RVT_LOG_PATH"] = str(rms_paths.logs)
if not rvt_override_version:
rvt_model_version = rvt_detector.get_rvt_file_version(full_model_path)
else:
rvt_model_version = rvt_override_version
if not rvt_override_path:
rvt_install_path = rvt_detector.installed_rvt_detection().get(rvt_model_version)
if not rvt_install_path:
print(f"no installed rvt versions for {rvt_model_version} detected - please use '--rvt_path' to specify path.")
logging.warning(f"{project_code};{current_proc_hash};1;;{'no rvt versions for {rvt_model_version} detected'}")
exit()
rvt_install_path = pathlib.Path(rvt_install_path)
else:
rvt_install_path = pathlib.Path(rvt_override_path)
mod_rjm, post_proc = get_jrn_and_post_process(command, rms_paths.commands)
if disable_filecheck or model_exists:
mod_rjm(project_code, full_model_path, journal_file_path, rms_paths.commands, rms_paths.logs)
proc_args = [arg for arg in [str(rvt_install_path), str(journal_file_path), viewer] if arg]
# print(proc_args)
run_proc = psutil.Popen(proc_args, cwd=str(rms_paths.root), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
run_proc_name = run_proc.name()
# let's wait half a second for rvt process to fire up
time.sleep(0.5)
if run_proc.name() == "Revit.exe":
proc_name_colored = col.bold_green(run_proc_name)
else:
proc_name_colored = col.bold_red(run_proc_name)
print(f" process info: {run_proc.pid} - {proc_name_colored}")
print(col.bold_orange("-detected revit:"))
print(f" version:{rvt_model_version} at path: {rvt_install_path}")
print(col.bold_orange("-process termination countdown:"))
# print(f" timeout until termination of process: {run_proc_id} - {proc_name_colored}:")
log_journal = get_rvt_proc_journal(run_proc, rms_paths.journals)
return_code = 9
return_logging = logging.info
# the main timeout loop
for sec in range(timeout):
time.sleep(1)
poll = run_proc.poll()
print(f" {str(timeout-sec).zfill(4)} seconds, proc poll: {poll}", end="\r")
if poll == 0:
print(col.bold_green(f" {poll} - revit finished!"))
return_code = "0"
return_logging = logging.info
break
elif timeout-sec-1 == 0:
print("\n")
print(col.bold_red(" timeout!!"))
if not poll:
print(col.bold_red(f" kill process now: {run_proc.pid}"))
run_proc.kill()
return_code = "1"
return_logging = logging.warning
# post loop processing, naively parsing journal files
print(col.bold_orange("-post process:"))
print(f" process open journal for post process parsing:\n {log_journal}")
log_journal_result = rvt_journal_parser.read_journal(log_journal)
log_journal_result = ",".join([f"{k}: {v}" for k, v in log_journal_result.items()])
if log_journal_result:
print(f" detected: {log_journal_result}")
if "corrupt" in log_journal_result:
return_logging = logging.critical
# run all notify modules
if notify:
notify_modules = [send_mail, send_slack, send_post]
for notify_function in notify_modules:
notify_function.notify(project_code, full_model_path, log_journal_result)
# getting post process funcs and args from command module for updating graphs and custom functionality
if post_proc:
post_proc["func"](*post_proc["args"])
# write log according to return code
logged_journal_excerpt = log_journal_result.strip('\n').strip('\r')
return_logging(f"{project_code};{current_proc_hash};{return_code};;{logged_journal_excerpt}")
# finally journal cleanup
rvt_journal_purger.purge(rms_paths.journals)
else:
print("model not found")
logging.warning(f"{project_code};{current_proc_hash};1;;{'model not found'}")
print(col.bold_blue("+process model job control script ended"))
| 1.851563 | 2 |
main.py | localhoct/os-remote | 0 | 12789125 | import telebot
from telebot import types
import os
import random
from PIL import ImageGrab
from winsound import Beep
import requests
import platform
import psutil
import time
# proxy = 'http://192.168.88.170:8888'
# os.environ['http_proxy'] = proxy
# os.environ['HTTP_PROXY'] = proxy
# os.environ['https_proxy'] = proxy
# os.environ['HTTPS_PROXY'] = proxy
start_time = time.time()
os.system("cls")
token = 'Your Token Here ;) ' #str
bot = telebot.TeleBot(token)
admin = 440904809 # here Enter Your Telegram UserId (int)
bot.send_message(admin, 'سیستم روشن شد!')
def getfile(filename):
myfile = open(filename, "r+", encoding='utf-8')
return myfile.read()
def putfile(filename, filedata):
myfile = open(filename, "w+", encoding='utf-8')
myfile.write(filedata)
myfile.close()
def startcm(user):
chat_id = user.from_user.id
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True)
btn1 = types.KeyboardButton('ScreenShot📸')
btn2 = types.KeyboardButton('Power Option ⚠️')
btn3 = types.KeyboardButton('Sound🔉')
btn4 = types.KeyboardButton('File Manager🗄')
btn5 = types.KeyboardButton('System Info💻')
btn6 = types.KeyboardButton('Open Web🌍')
btns.add(btn1, btn2, btn3, btn4, btn5, btn6)
message = '''
سلام خوش آمدید.😄
لیست دستورات برای فقط شماست😜
'''
bot.send_message(chat_id, message, reply_markup=btns)
# print(id)
def savedb(user):
chat_id = user.from_user.id
text = user.text
con_text = text.replace('/save ', '')
# con_text = con_text.encode("utf-8")
mesid = random.randint(1111, 9999)
message = f'پیام شما: \n {con_text} \n شناسه پیام : {mesid}'
bot.send_message(chat_id, message)
putfile(f'database/data_{mesid}.txt', str(con_text))
# print(con_text, mesid)
def savedb_lsit(user):
chat_id = user.from_user.id
list_file = ''
for r, d, f in os.walk('database'):
for file in f:
list_file = list_file + '\n' + str(file)
bot.send_message(chat_id, 'پیام های شما: \n' + str(list_file))
def power(user):
chat_id = user.from_user.id
# text = user.text
btns = types.ReplyKeyboardMarkup(row_width=1, one_time_keyboard=True)
btn1 = types.KeyboardButton('ShoutDown | خاموش کردن')
btn2 = types.KeyboardButton('ریستارت | Restart')
btn3 = types.KeyboardButton('بازگشت')
btns.add(btn1, btn2, btn3, )
bot.send_message(chat_id, 'شما به بخش power option وارد شدید.لیست دستورات: \n', reply_markup=btns)
def home(user):
chat_id = user.from_user.id
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True)
btn1 = types.KeyboardButton('ScreenShot📸')
btn2 = types.KeyboardButton('Power Option ⚠️')
btn3 = types.KeyboardButton('Sound🔉')
btn4 = types.KeyboardButton('File Manager🗄')
btn5 = types.KeyboardButton('System Info💻')
btn6 = types.KeyboardButton('Open Web🌍')
btns.add(btn1, btn2, btn3, btn4, btn5, btn6)
bot.send_message(chat_id, '🏛صفحه اصلی: ', reply_markup=btns)
def playmusic_btn(user):
chat_id = user.from_user.id
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True, row_width=1)
btn1 = types.KeyboardButton('Music 🎧')
btn2 = types.KeyboardButton('Beep')
btn3 = types.KeyboardButton('بازگشت')
btns.add(btn1, btn2, btn3)
message = '''
🤔لطفا نوع صدا را انتخاب کنید
'''
bot.send_message(chat_id, message, reply_markup=btns)
def bep(user):
chat_id = user.from_user.id
bot.send_message(chat_id, 'بوق پخش شد😉')
for x in range(1, 6):
Beep(1000 * x, 200)
Beep(1000 * x, 200 - (x * 50))
def music(user):
chat_id = user.from_user.id
message = '''
لطفا آهنگ خود را بفرستید تا برایتان پخش کنم!😊
یا از دستور زیر استفاده کنید👇:
/music [File_id]
برای دریافت آیدی ها دستور زیر را بزنید👇:
/music_list
'''
bot.send_message(chat_id, message)
def music_id(user):
chat_id = user.from_user.id
list_file = ''
music_count = 0
for r, d, f in os.walk('music'):
for file in f:
if 'mp3' in file:
music_count += 1
list_file = list_file + '\n' + str(file)
else:
pass
message = f'''
تعداد آهنگ ها:{music_count}
لیست آهنگ های ذخیره شده:
{list_file}
'''
bot.send_message(chat_id, message)
def music_play(user):
chat_id = user.from_user.id
text = user.text
music_name = text.replace('/music ', '')
os.system(f'start music/{str(music_name)}.mp3')
musiv = open(f'music/{str(music_name)}.mp3', 'rb')
message = f'''
آهنگ با کد اختصاصی زیر درحال پخش:🎶
{str(music_name)}
'''
bot.send_message(chat_id, message)
bot.send_chat_action(chat_id, 'upload_document')
bot.send_audio(chat_id, musiv, caption='آهنگ درحال پخش😐')
def screenshot(user):
chat_id = user.from_user.id
message = 'گرفتن اسکرین...'
bot.send_message(chat_id, message)
photo = ImageGrab.grab()
photo.save('screen.png')
message = 'اسکرین شات گرفته شد!😋'
bot.send_message(chat_id, message)
photo = open('screen.png', 'rb')
bot.send_photo(chat_id, photo)
photo.close()
photo = open('screen.png', 'rb')
bot.send_document(chat_id, photo, caption='اسکرین گرفته شده نسخه با کیفیت 🙄')
photo.close()
os.remove('screen.png')
# print(chat_id)
def systeminfo(user):
chat_id = user.from_user.id
uname = platform.uname()
runtime = time.time() - start_time
if runtime < 60:
runtime = f'{int(runtime)} Second'
else:
runtime = runtime / 60
runtime = f'{int(runtime)} Minutes'
message = f'''
🔰 System: {uname.system} {uname.release}
👥 Node Name: {uname.node}
🔺 CPU Usage {psutil.cpu_percent()} Percent
🔺 RAM Usage: {psutil.virtual_memory()[2]} Percent
📝 Machine Architecture: {uname.machine}
⏱ Bot Run Time: {runtime}
'''
bot.send_message(chat_id, message)
def shutdown_btn(user):
chat_id = user.from_user.id
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True, row_width=1)
btn1 = types.KeyboardButton('آره مطمئنم میخوام خاموش بشه!!')
btn2 = types.KeyboardButton('نه دستم خورد !!')
btns.add(btn1, btn2, )
message = '''
آیا مطمئن هستید که سیستم خاموش شود؟🤨
'''
bot.send_message(chat_id, message, reply_markup=btns)
def restart_btn(user):
chat_id = user.from_user.id
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True, row_width=1)
btn1 = types.KeyboardButton('آره مطمئنم میخوام ریستارت بشه!!')
btn2 = types.KeyboardButton('نه دستم خورد !!')
btns.add(btn1, btn2)
message = '''
آیا مطمئن هستید که سیستم ریستارت شود؟🤨
'''
bot.send_message(chat_id, message, reply_markup=btns)
def download_btn(user):
chat_id = user.from_user.id
text = user.text
btns = types.ReplyKeyboardMarkup(one_time_keyboard=True, row_width=1)
btn1 = types.KeyboardButton('Download File From System📥')
btn2 = types.KeyboardButton('File List📂')
btn3 = types.KeyboardButton('بازگشت')
btns.add(btn1, btn2, btn3)
bot.send_message(chat_id, 'به فایل منجر خوش آمدید😅', reply_markup=btns)
def downlaod_message(user):
chat_id = user.from_user.id
# text = user.text
bot.send_message(chat_id, 'نحوه استفاده \n /download [file name or file address]')
def download_file(user):
chat_id = user.from_user.id
text = user.text
filename_or_address = text.replace('/download ', '')
if os.path.isdir(filename_or_address):
bot.send_message(chat_id, 'این یک فولدر هست و قابل دانلود نیست😑')
else:
if os.path.isfile(filename_or_address):
file = open(filename_or_address, 'rb')
bot.send_message(chat_id, 'درحال آپلود کردن فایل درخواستی شما...')
bot.send_document(chat_id, file, caption='این فایل درخواستی شماست 😁')
else:
bot.send_message(chat_id, 'فایل یا فولدری با این نام پیدا نشد.🤐')
def web_btn(user):
chat_id = user.from_user.id
text = user.text
bot.send_message(chat_id, 'نحوه استفاده \n /web [URL]')
def filemanagerlist(user):
userchatid = user.chat.id
usertext = user.text
directory = usertext.replace("/filemanager ", "")
if (os.path.isdir(directory)):
bot.send_message(userchatid, "🔎 درحال اسکن کردن فولدر ...")
foldercount = 0
folderlist = ""
filecount = 0
filelist = ""
for r, d, f in os.walk(directory):
for folder in d:
if (foldercount > 30 or foldercount == 30):
break
else:
if ("\\" in r):
pass
else:
foldercount += 1
folderlist = folderlist + "\n" + "📁 " + r + "/" + folder
for file in f:
if (filecount > 30 or filecount == 30):
break
else:
filecount += 1
filelist = filelist + "\n" + "🧾 " + r + "/" + file
bot.send_message(userchatid, "🗂 30 First Folders In " + directory + " : \n\n" + str(folderlist))
bot.send_message(userchatid, "🗃 30 First File In " + directory + " : \n\n" + str(filelist))
else:
bot.send_message(userchatid, "چیزی پیدا نکردم 😐")
def justfilelist(user):
userchatid = user.chat.id
bot.send_message(userchatid, "نحوه استفاده:\n/filemanager [dir]")
@bot.message_handler(content_types=['text'])
def main(user):
chat_id = user.from_user.id
text = user.text
# print(chat_id)
if chat_id == admin:
if text == '/start':
startcm(user)
if text == '/save':
bot.send_message(chat_id, 'لطفا بعد از دستور پیام خود را اضافه کنید\n به این صورت : \n /save [message] ')
if text.startswith('/save '):
savedb(user)
if text == '/message':
savedb_lsit(user)
if text == 'Power Option ⚠️':
power(user)
if text == 'ShoutDown | خاموش کردن':
shutdown_btn(user)
if text == 'ریستارت | Restart':
restart_btn(user)
if text == 'آره مطمئنم میخوام خاموش بشه!!':
bot.send_message(chat_id, 'سیستم شما خاموش شد!😐')
os.system('shutdown /s /t 1')
home(user)
if text == 'آره مطمئنم میخوام ریستارت بشه!!':
bot.send_message(chat_id, 'سیستم شما ریستارت شد!😐')
os.system('shutdown /r /t 1')
home(user)
if text == 'بازگشت':
home(user)
if text == 'نه دستم خورد !!':
bot.send_message(chat_id, 'کنترل دستت هم نداری بدبخت 😂')
home(user)
if text == 'ScreenShot📸':
screenshot(user)
if text == 'Sound🔉':
playmusic_btn(user)
if text == 'Beep':
bep(user)
if text == 'Music 🎧':
music(user)
if text == 'System Info💻':
systeminfo(user)
if text == 'File Manager🗄':
download_btn(user)
if text == 'Download File From System📥':
downlaod_message(user)
if text.startswith('/download '):
download_file(user)
if text == '/download':
downlaod_message(user)
if text == 'Open Web🌍':
web_btn(user)
if text.startswith('/web '):
url = text.replace('/web ', '')
bot.send_message(chat_id, f'گوگل کروم با آدرس شما[{url}] باز شد🥳')
os.system(f"start chrome {url}")
if text == '/web':
web_btn(user)
if (text == "File List📂" or text == "/filemanager"):
justfilelist(user)
if (text.startswith("/filemanager ")):
filemanagerlist(user)
if text.startswith('/music '):
music_play(user)
if text == '/music':
music(user)
if text == '/music_list':
music_id(user)
else:
bot.send_message(chat_id, 'شما ادمین نیستید 😐')
@bot.message_handler(content_types=['audio'])
def audio(message):
chat_id = message.from_user.id
# print(message.audio)
raw = message.audio.file_id
# file_name = message.audio.file_unique_id
title = message.audio.title
title = title.strip()
title = title.replace(' ', '_')
performer = message.audio.performer
performer = performer.strip()
performer = performer.replace(' ', '_')
file_size = message.audio.file_size
if file_size > 20971520:
bot.send_message(chat_id, 'محدودیت های تلگرام حجم فایل بیش از 20مگابایت هست 🤐')
else:
try:
file_info = bot.get_file(raw)
downloaded_file = bot.download_file(file_info.file_path)
with open(f'music/{str(performer)}-{str(title).strip()}.mp3', 'wb') as new_file:
new_file.write(downloaded_file)
os.system(f'start music/{str(performer)}-{str(title).strip()}.mp3')
bot.send_message(chat_id, 'درحال پخش آهنگ شما...😯')
bot.send_message(chat_id, 'کد اختصاصی این آهنگ👇')
bot.send_message(chat_id, f'``` /music {str(performer)}-{str(title).strip()}```', parse_mode='markdown')
except:
bot.send_message(chat_id, 'این آهنگ درحال پخش است😒')
try:
bot.polling(True)
except:
print(' I Got Error :( ')
| 2.234375 | 2 |
apriori/apriori.py | TCphysics/MLlearning | 0 | 12789126 | <gh_stars>0
class ApriopriCT(object):
'''
This python script finds the frequency list FL with maximum length and
then build rules based on each list in FL.
'''
def __init__(self, dataList, itemList, minSupport=0.2, minConfidence=0.8):
'''
param dataList: original dataList
param minSupport: minimum Support
param minConfidence: minimum Confidence
param itemList: list of all items
param processedData: processed Data with 1 and 0 in each raw representing
if items are included.
param supportDictionary: Dictionary of support
param confidenceList: List of confidence
param Ck: optimal frequency list depending on minSupport
'''
self.dataList = dataList
self.minSupport = minSupport
self.minConfidence = minConfidence
self.itemList = itemList
self.processedData = []
self.supportDictionary = dict()
self.confidenceList = []
self.C0 = self.C0 = [[i] for i in range(len(self.itemList))]
self.freqList = []
self.prepareData()
def prepareData(self):
processedData = []
for raw in self.dataList:
temp = []
for item in self.itemList:
if item in raw:
temp.append(1)
else:
temp.append(0)
self.processedData.append(temp)
return
def match(self, items, dataL):
# decide if a items combo is contained in a single data
for i in items:
if dataL[i] == 0:
return False
return True
def updateC(self, C):
# Drop effective combo when its freq lower than minSuport
c_update = []
for ci in C:
count = 0
for raw in self.processedData:
if self.match(ci, raw):
count += 1
if count > len(self.dataList)*self.minSupport:
c_update.append(ci)
# print(ci)
self.supportDictionary[frozenset(ci)] = count/len(self.dataList)
return c_update
def isApriori(self,l,C):
# decide if a Ck have sublist outside the Ck-1.
for i in range(len(l)):
subList = l[:i]+l[i+1:]
if subList not in C:
return False
return True
def create_Ck(self,C,k):
#generate Ck based on Ck-1
Ck = []
lenC = len(C)
for i in range(lenC):
for j in range(i+1,lenC):
l1, l2 = C[i], C[j]
l1.sort()
l2.sort()
if l1 ==[] or l1[:-1] == l2[:-1]:
l = l1.copy()
l.append(l2[-1])
if i == 1 or self.isApriori(l, C):
Ck.append(sorted(l))
return Ck
def findFreqList(self):
# find the frequency list
C = self.C0.copy()
C = self.updateC(C)
i = 1
while i<len(self.itemList)+1:
updateC = self.create_Ck(C,i)
Ck = self.updateC(updateC)
if len(Ck) == 0:
break
else:
C = Ck
i+=1
self.freqList = C.copy()
return
def printFreqList(self):
for k in self.freqList:
combo = [self.itemList[i] for i in k]
print('Freq list:',combo,',freq:', round(self.supportDictionary[frozenset(k)],5))
# for k in self.supportDictionary.keys():
# combo = [self.itemList[i] for i in k]
# print('combo:',k,',freq:', round(self.supportDictionary[k],5))
return
def calConfidence(self,l,freqCombo):
#calculate Conf of a sublist based on a combo
set1 = frozenset(freqCombo)
set2 = frozenset(freqCombo) - frozenset(l)
ratio = self.supportDictionary[set1]/self.supportDictionary[set2]
return ratio
def updateCr(self, Cr, freqCombo):
# drop items list if its conf is lower han minConfidence
c_update = []
for c in Cr:
if self.calConfidence(c, freqCombo) > self.minConfidence:
c_update.append(c)
return c_update
def findRule(self, freqCombo):
# build rule list for a combo
Cr = [[f] for f in freqCombo]
i = 1
ruleList = []
while i < len(freqCombo):
updateCr = self.updateCr(Cr,freqCombo)
ruleList += updateCr
if len(updateCr) == 0:
break
Cr = self.create_Ck(updateCr,i)
i+=1
return ruleList
def addRuleToConfDict(self,ruleList, freqCombo):
# find rule and fulfill confidenceList for a freqCombo
for rule in ruleList:
conf = self.calConfidence(rule, freqCombo)
tag = [rule, list(frozenset(freqCombo)-frozenset(rule))]
self.confidenceList.append( [tag, conf] )
def buildRules(self):
# iterates over each combo in freqList.
freqList = self.freqList.copy()
for combo in freqList:
# print('combo:',combo)
ruleList = self.findRule(combo)
self.addRuleToConfDict(ruleList, combo)
# print('ruleList:',ruleList)
return
def printRules(self):
for k in self.confidenceList:
r1 = [self.itemList[i] for i in k[0][1]]
r2 = [self.itemList[i] for i in k[0][0]]
print('rule:',r1,' to ',r2 ,', conf=',round(k[1],4))
def run(self):
self.findFreqList()
self.printFreqList()
self.buildRules()
self.printRules()
if __name__ == '__main__':
f = open('MBA_data.txt').readlines()
dataList = []
for x in f:
L = x.split()
dataList.append(L)
itemSet = set()
for raw in dataList:
for l in raw:
itemSet.add(l)
itemList = sorted(list(itemSet),reverse=False)
apriSolution = ApriopriCT(dataList,itemList)
apriSolution.run()
| 3.03125 | 3 |
test/unit/puzzles/student_prizes_test.py | dclark87/pytools | 0 | 12789127 | <reponame>dclark87/pytools
#
#
#
'''
'''
import unittest
from pytools.puzzles import student_prizes
class StudentPrizesTestCase(unittest.TestCase):
'''
'''
def test_student_prizes(self):
'''
:return:
'''
# Import packages
import itertools
# Init variables
n = 3
letters = 'ALO'
expected = len(list(itertools.product(letters, repeat=n)))
returned = student_prizes.prize_combos(n)
self.assertEqual(expected, returned)
if __name__ == '__main__':
unittest.main() | 3.34375 | 3 |
tests/ncoghlan.py | jeamland/asciicompat | 2 | 12789128 | """Test cases for dual bytes/str APIs"""
import unittest
"""
The Python 2 str type conveniently permitted the creation of APIs that
could be used as either binary APIs (8-bit str in, 8-bit str out) or as
text APIs (unicode in, unicode out).
The critical enabler for this feature was the ability to define any
*constants* used in these algorithms as 8 bit strings, and then rely on
the implicit promotion to Unicode to handle text input.
In Python 3, that implicit conversion to Unicode is gone, so APIs that
handle both binary and text data need to be written to either have two
separate code paths, or else to automatically decode binary input to text
and then convert it back to binary output again when returning the result.
However, it should be possible to create a Python 3 extension type that
inherits from str (providing interoperability with str objects) and *also*
implements the buffer API (providing interoperability with bytes and
bytearray, and likely other types).
This is a test suite developed on Python 2, demonstrating the convenience
of the implicit conversion in the case of such dual binary/text interfaces.
While the general recommendation for Python 3 code is to ensure APIs are
either binary *or* text rather than a hybrid combination, libraries
migrating from Python 2 that already publish such hybrid APIs may need to
continue to support both styles of usage for the benefit of clients (as
some clients may be using the binary half of the interface, while others
are using the text half).
The URL parsing APIs in Python 3's urllib.parse module are an example of
such an API. It supported both str and unicode in Python 2 and supports
both str and any type with a decode method in Python 3"""
try:
from asciicompat import asciistr
except ImportError:
# Python 2 fallback
asciistr = str
# Developing the tests on Python 2
try:
text_type = unicode
except:
text_type = str
binary_type = bytes
asciistr = str
# Some test values
TEXT = u"text"
BINARY = b"binary"
HYBRID = asciistr("ascii")
class TestHybridAddition(unittest.TestCase):
def test_text_addition(self):
self.assertEqual(TEXT + HYBRID, u"textascii")
self.assertIsInstance(TEXT + HYBRID, text_type)
self.assertEqual(HYBRID + TEXT, u"asciitext")
self.assertIsInstance(HYBRID + TEXT, text_type)
def test_binary_addition(self):
self.assertEqual(BINARY + HYBRID, b"binaryascii")
self.assertIsInstance(BINARY + HYBRID, binary_type)
# Next two are likely to be affected by
# http://bugs.python.org/issue11477
# as the str subclass on the LHS will throw TypeError directly
# as returning NotImplemented from sq_concat is not currently
# supported correctly
self.assertEqual(HYBRID + BINARY, b"asciibinary")
self.assertIsInstance(HYBRID + BINARY, binary_type)
class HybridTestMixin(object):
input_data = None
output_type = None
exists = asciistr("data")
missing = asciistr("not data")
def test_containment(self):
self.assertIn(self.exists, self.input_data)
self.assertIn(self.exists[:2], self.input_data)
self.assertNotIn(self.missing, self.input_data)
def test_partitioning(self):
before, sep, after = self.input_data.partition(self.exists)
self.assertIsInstance(before, self.output_type)
self.assertIsInstance(sep, self.output_type)
self.assertIsInstance(after, self.output_type)
self.assertEqual(sep, self.exists)
def test_casting(self):
self.assertEqual(self.output_type(self.exists), self.exists)
self.assertIs(type(self.output_type(self.exists)), self.output_type)
# Formatting tests: in Python 2, str formatting always produces
# str objects, *except* when a Unicode object is passed to mod-formatting
def test_mod_formatting(self):
formatted = asciistr("%s") % self.input_data
self.assertEqual(formatted, self.input_data)
self.assertIs(type(formatted), self.output_type)
formatted_int = asciistr("%d") % 42
# asciistr also avoids the byte constructor length init quirk
self.assertEqual(formatted_int, asciistr(42))
self.assertIs(type(formatted_int), binary_type)
def test_format_method(self):
formatted = asciistr("{}").format(self.input_data)
self.assertEqual(formatted, self.input_data)
self.assertIs(type(formatted), binary_type)
formatted_int = asciistr("{:d}").format(42)
# asciistr also avoids the byte constructor length init quirk
self.assertEqual(formatted_int, asciistr(42))
self.assertIs(type(formatted_int), binary_type)
class TestBinaryInteraction(unittest.TestCase, HybridTestMixin):
input_data = b"there is binary data in this test case"
output_type = binary_type
class TestTextInteraction(unittest.TestCase, HybridTestMixin):
input_data = u"there is text data in this test case"
output_type = text_type
if __name__ == "__main__":
unittest.main()
| 3.484375 | 3 |
BOJ/1697.py | Jaesin22/TIL | 0 | 12789129 | <reponame>Jaesin22/TIL
from collections import deque
max = 10 ** 5
n, k = map(int, input().split())
visited = [0] * (max + 1)
def BFS():
queue = deque()
queue.append(n)
while queue:
x = queue.popleft()
if x == k:
print(visited[x])
break
for nx in (x-1, x+1, x * 2):
if 0 <= nx <= max and not visited[nx]:
visited[nx] = visited[x] + 1
queue.append(nx)
BFS() | 2.984375 | 3 |
app/api/routers/auth.py | ABGEO/magtifun.abgeo.dev | 0 | 12789130 | """
This file is part of the magtifun.abgeo.dev.
(c) 2021 <NAME> <<EMAIL>>
For the full copyright and license information, please view the LICENSE
file that was distributed with this source code.
"""
from datetime import timedelta
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm
from fastapi import APIRouter
from app.core.config import ACCESS_TOKEN_EXPIRE_MINUTES
from app.models.schemas.jwt import Token
from app.resources import strings
from app.services.jwt import create_access_token
from app.services.magtifun import authenticate_user
router = APIRouter(tags=["Auth"])
@router.post("/token", response_model=Token)
async def token_authentication(
form_data: OAuth2PasswordRequestForm = Depends(),
) -> Token:
"""
Create Authentication JWT Token.
"""
user = authenticate_user(form_data.username, form_data.password)
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=strings.INCORRECT_LOGIN_INPUT,
headers={"WWW-Authenticate": "Bearer"},
)
access_token = create_access_token(
data={"sub": user.key},
expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES),
)
return Token(access_token=access_token, token_type="bearer")
| 2.609375 | 3 |
piot/inputs/pozyx.py | frantp/iot-sensor-reader | 0 | 12789131 | <gh_stars>0
from collections import OrderedDict
import time
from ..core import DriverBase
import pypozyx
class Driver(DriverBase):
def __init__(self, i2c=False, bus=1, port=None):
super().__init__()
self._sensor = pypozyx.PozyxI2C(bus) if i2c else \
pypozyx.PozyxSerial(port or pypozyx.get_first_pozyx_serial_port())
def close(self):
if isinstance(self._sensor, pypozyx.PozyxI2C):
self._sensor.bus.close()
super().close()
def run(self):
position = pypozyx.Coordinates()
while position.x == position.y == position.z == 0:
self._sensor.doPositioning(position)
return [(self.sid(), time.time_ns(), OrderedDict([
("pos_x", position.x),
("pos_y", position.y),
("pos_z", position.z),
]))]
| 2.46875 | 2 |
Algorithms_medium/1288. Remove Covered Intervals.py | VinceW0/Leetcode_Python_solutions | 4 | 12789132 | """
1288. Remove Covered Intervals
Medium
Given a list of intervals, remove all intervals that are covered by another interval in the list.
Interval [a,b) is covered by interval [c,d) if and only if c <= a and b <= d.
After doing so, return the number of remaining intervals.
Example 1:
Input: intervals = [[1,4],[3,6],[2,8]]
Output: 2
Explanation: Interval [3,6] is covered by [2,8], therefore it is removed.
Example 2:
Input: intervals = [[1,4],[2,3]]
Output: 1
Example 3:
Input: intervals = [[0,10],[5,12]]
Output: 2
Example 4:
Input: intervals = [[3,10],[4,10],[5,11]]
Output: 2
Example 5:
Input: intervals = [[1,2],[1,4],[3,4]]
Output: 1
Constraints:
1 <= intervals.length <= 1000
intervals[i].length == 2
0 <= intervals[i][0] < intervals[i][1] <= 10^5
All the intervals are unique.
"""
class Solution:
def removeCoveredIntervals(self, intervals: List[List[int]]) -> int:
res = right = 0
intervals.sort(key = lambda x: (x[0], -x[1]))
for i, j in intervals:
res += j > right
right = max(right, j)
return res
| 3.78125 | 4 |
Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalIsoTrkProducerFilter_cff.py | malbouis/cmssw | 852 | 12789133 | <reponame>malbouis/cmssw
import FWCore.ParameterSet.Config as cms
#------------------------------------------------
#AlCaReco filtering for HCAL isotrk:
#------------------------------------------------
from Calibration.HcalAlCaRecoProducers.alcaHcalIsotrkProducer_cfi import *
from Calibration.HcalAlCaRecoProducers.alcaHcalIsotrkFilter_cfi import *
seqALCARECOHcalCalIsoTrkProducerFilter = cms.Sequence(alcaHcalIsotrkProducer * alcaHcalIsotrkFilter)
| 0.960938 | 1 |
cuffdiffgui.py | AgazW/Seq-Pip | 0 | 12789134 | <reponame>AgazW/Seq-Pip
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'bowtiegui.ui'
#
# Created: Tue Mar 1 14:46:40 2016
# by: PyQt4 UI code generator 4.10.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(870, 1500)
MainWindow.setMinimumSize(QtCore.QSize(0, 1500))
MainWindow.setMaximumSize(QtCore.QSize(16777215, 1500))
MainWindow.setWhatsThis(_fromUtf8(""))
MainWindow.setLayoutDirection(QtCore.Qt.LeftToRight)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.scrollArea = QtGui.QScrollArea(self.centralwidget)
self.centralWidget = QtGui.QWidget(MainWindow)
layout = QtGui.QVBoxLayout(self.centralWidget)
layout.addWidget(self.scrollArea)
#self.scrollArea.setGeometry(QtCore.QRect(0, 0, 41, 111))
#self.scrollArea.setWidgetResizable(True)
#self.scrollArea.setObjectName(_fromUtf8("scrollArea"))
#self.scrollAreaWidgetContents = QtGui.QWidget()
# self.scrollArea.setGeometry(QtCore.QRect(230, 0, 841, 2481))
self.scrollArea.setFrameShape(QtGui.QFrame.WinPanel)
self.scrollArea.setFrameShadow(QtGui.QFrame.Plain)
self.scrollArea.setLineWidth(7)
self.scrollArea.setWidgetResizable(False)
# self.scrollArea.setToolTip("place cursor over the controls for information")
self.scrollAreaWidgetContents = QtGui.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 812,3052))
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollAreaWidgetContents.sizePolicy().hasHeightForWidth())
self.scrollAreaWidgetContents.setSizePolicy(sizePolicy)
self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
layout = QtGui.QHBoxLayout(self.scrollAreaWidgetContents)
self.frame = QtGui.QFrame(self.scrollAreaWidgetContents)
self.frame.setGeometry(QtCore.QRect(50, 10, 741, 3000))
self.frame.setFocusPolicy(QtCore.Qt.ClickFocus)
self.frame.setFrameShape(QtGui.QFrame.WinPanel)
self.frame.setFrameShadow(QtGui.QFrame.Raised)
self.frame.setLineWidth(10)
#self.setStyleSheet('background-image: url("/home/amrata/PycharmProjects/bowtieuser/images/images/logn.jpg")')
self.frame.setObjectName(_fromUtf8("frame"))
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.selgtflbl = QtGui.QLabel(self.frame) # select gtf file
self.selgtflbl.setGeometry(QtCore.QRect(10, 30, 291, 16))
font = QtGui.QFont()
font.setBold(True)
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setWeight(75)
self.selgtflbl.setFont(font)
self.selgtflbl.setToolTip("select the GTF file produced by cufflinks")
self.selgtflbl.setObjectName(_fromUtf8("selgtflbl"))
self.selfile = QtGui.QPushButton(self.frame) # single gtf file
self.selfile.setGeometry(QtCore.QRect(10, 50, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.selfile.setFont(font)
self.selfile.setToolTip("Click here to select single GTF file")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.selfile.setIcon(icon)
self.selfile.setToolTip("click here to select the file")
self.selfile.setObjectName(_fromUtf8("selfile"))
self.mulfile = QtGui.QPushButton(self.frame)
self.mulfile.setGeometry(QtCore.QRect(50, 50, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.mulfile.setFont(font)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index1.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.mulfile.setIcon(icon)
self.mulfile.setToolTip("Click here to select multiple GTF file")
self.mulfile.setObjectName(_fromUtf8("mulfile"))
self.builselcom = QtGui.QComboBox(self.frame)
self.builselcom.setGeometry(QtCore.QRect(90, 50, 641, 27))
self.builselcom.setToolTip("Please select the file")
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
#font.setBold(True)
#font.setPointSize(11)
#font.setBold(False)
#font.setItalic(False)
font.setWeight(50)
self.builselcom.setFont(font)
self.builselcom.setObjectName(_fromUtf8("builselcom"))
self.omitlbl = QtGui.QLabel(self.frame) #Do you want to Omit Tabular Datasets
self.omitlbl.setGeometry(QtCore.QRect(10, 100, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.omitlbl.setFont(font)
self.omitlbl.setObjectName(_fromUtf8("omitlbl"))
self.asno = QtGui.QPushButton(self.frame)
self.asno.setGeometry(QtCore.QRect(60, 120, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asno.setFont(font)
self.asno.setObjectName(_fromUtf8("asno"))
self.asyes = QtGui.QPushButton(self.frame)
self.asyes.setGeometry(QtCore.QRect(10, 120, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asyes.setFont(font)
self.asyes.setObjectName(_fromUtf8("asyes"))
self.sqlbl = QtGui.QLabel(self.frame) #Do you want to Generate SQLite
self.sqlbl.setGeometry(QtCore.QRect(10, 170, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.sqlbl.setFont(font)
self.sqlbl.setObjectName(_fromUtf8("sqlbl"))
self.asno1 = QtGui.QPushButton(self.frame)
self.asno1.setGeometry(QtCore.QRect(60, 190, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asno1.setFont(font)
self.asno1.setObjectName(_fromUtf8("asno1"))
self.asyes1 = QtGui.QPushButton(self.frame)
self.asyes1.setGeometry(QtCore.QRect(10, 190, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asyes1.setFont(font)
self.asyes1.setObjectName(_fromUtf8("asyes1"))
self.inputdatalbl = QtGui.QLabel(self.frame) #Do you want to Provide Input data type
self.inputdatalbl.setGeometry(QtCore.QRect(10, 240, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.inputdatalbl.setFont(font)
self.inputdatalbl.setObjectName(_fromUtf8("inputdatalbl"))
self.inpcmb = QtGui.QComboBox(self.frame)
self.inpcmb.setToolTip("Select any one of the option")
self.inpcmb.setGeometry(QtCore.QRect(10, 260, 721, 27))
self.inpcmb.addItem(_fromUtf8(""))
self.inpcmb.addItem(_fromUtf8(""))
self.inpcmb.addItem(_fromUtf8(""))
self.inpcmb.addItem(_fromUtf8(""))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setBold(False)
font.setWeight(50)
self.inpcmb.setFont(font)
self.inpcmb.setObjectName(_fromUtf8("inpcmb"))
self.frame1 = QtGui.QFrame(self.scrollAreaWidgetContents) #frame that containes sam bam cxb option
self.frame1.setGeometry(QtCore.QRect(50, 10, 741, 3000))
self.frame1.setFocusPolicy(QtCore.Qt.ClickFocus)
self.frame1.setFrameShape(QtGui.QFrame.WinPanel)
self.frame1.setFrameShadow(QtGui.QFrame.Raised)
self.frame1.setLineWidth(10)
#self.setStyleSheet('background-image: url("/home/amrata/PycharmProjects/bowtieuser/images/images/logn.jpg")')
self.frame1.setObjectName(_fromUtf8("frame1"))
self.ovrhngtollbl0 = QtGui.QLabel(self.frame1) #Conditions
self.ovrhngtollbl0.setGeometry(QtCore.QRect(10, 10, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.ovrhngtollbl0.setFont(font)
self.ovrhngtollbl0.setObjectName(_fromUtf8("ovrhngtollbl0"))
self.groupBox = QtGui.QGroupBox(self.frame1)
self.groupBox.setGeometry(QtCore.QRect(10, 30, 711, 261))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.groupBox.setFont(font)
self.groupBox.setTitle(_fromUtf8(""))
self.groupBox.setObjectName(_fromUtf8("groupBox"))
self.ovrhngtollbl = QtGui.QLabel(self.groupBox) #Name
self.ovrhngtollbl.setGeometry(QtCore.QRect(10, 10, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.ovrhngtollbl.setFont(font)
self.ovrhngtollbl.setObjectName(_fromUtf8("ovrhngtollbl"))
self.ovrtoltxt = QtGui.QLineEdit(self.groupBox)
self.ovrtoltxt.setGeometry(QtCore.QRect(10, 30, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.ovrtoltxt.setFont(font)
self.ovrtoltxt.setToolTip("Please provide the name for the file")
self.ovrtoltxt.setObjectName(_fromUtf8("ovrtoltxt"))
self.subrefanlbl1 = QtGui.QLabel(self.groupBox) # Replicates
self.subrefanlbl1.setGeometry(QtCore.QRect(10, 80, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanlbl1.setFont(font)
self.subrefanlbl1.setObjectName(_fromUtf8("subrefanlbl1"))
self.subrefanpushgrp1 = QtGui.QPushButton(self.groupBox)
self.subrefanpushgrp1.setGeometry(QtCore.QRect(10, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanpushgrp1.setFont(font)
self.subrefanpushgrp1.setToolTip("Click here to select single file")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.subrefanpushgrp1.setIcon(icon)
self.subrefanpushgrp1.setObjectName(_fromUtf8("subrefanpushgrp1"))
self.mulfile1 = QtGui.QPushButton(self.groupBox)
self.mulfile1.setToolTip("Click here to select mutiple file")
self.mulfile1.setGeometry(QtCore.QRect(50, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.mulfile1.setFont(font)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index1.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.mulfile1.setIcon(icon)
self.mulfile1.setObjectName(_fromUtf8("mulfile1"))
self.subrefcombgrp1 = QtGui.QComboBox(self.groupBox)
self.subrefcombgrp1.setGeometry(QtCore.QRect(90, 100, 601, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.subrefcombgrp1.setFont(font)
self.subrefcombgrp1.setObjectName(_fromUtf8("subrefcomb"))
self.groupBox1 = QtGui.QGroupBox(self.frame1) # another groupbox that contain replicates and sam files
self.groupBox1.setGeometry(QtCore.QRect(10, 170, 711, 261))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.groupBox1.setFont(font)
self.groupBox1.setTitle(_fromUtf8(""))
self.groupBox1.setObjectName(_fromUtf8("groupBox1"))
self.ovrhngtollbl1 = QtGui.QLabel(self.groupBox1) # Name
self.ovrhngtollbl1.setGeometry(QtCore.QRect(10, 10, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.ovrhngtollbl1.setFont(font)
self.ovrhngtollbl1.setObjectName(_fromUtf8("ovrhngtollbl1"))
self.ovrtoltxt1 = QtGui.QLineEdit(self.groupBox1)
self.ovrtoltxt1.setToolTip("Please provide the name for the file")
self.ovrtoltxt1.setGeometry(QtCore.QRect(10, 30, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.ovrtoltxt1.setFont(font)
self.ovrtoltxt1.setObjectName(_fromUtf8("ovrtoltxt1"))
self.subrefanlbl = QtGui.QLabel(self.groupBox1)
self.subrefanlbl.setGeometry(QtCore.QRect(10, 80, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanlbl.setFont(font)
self.subrefanlbl.setObjectName(_fromUtf8("subrefanlbl"))
self.subrefanpushgrp2 = QtGui.QPushButton(self.groupBox1)
self.subrefanpushgrp2.setGeometry(QtCore.QRect(10, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanpushgrp2.setFont(font)
self.subrefanpushgrp2.setToolTip("Click here to select single file")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.subrefanpushgrp2.setIcon(icon)
self.subrefanpushgrp2.setObjectName(_fromUtf8("subrefanpushgrp2"))
self.mulfile3 = QtGui.QPushButton(self.groupBox1)
self.mulfile3.setGeometry(QtCore.QRect(50, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.mulfile3.setFont(font)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index1.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.mulfile3.setIcon(icon)
self.mulfile3.setToolTip("Click here to select multiple file")
self.mulfile3.setObjectName(_fromUtf8("mulfile3"))
self.subrefcombgrp2 = QtGui.QComboBox(self.groupBox1)
self.subrefcombgrp2.setGeometry(QtCore.QRect(90, 100, 601, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.subrefcombgrp2.setFont(font)
self.subrefcombgrp2.setObjectName(_fromUtf8("subrefcombgrp2"))
self.subrefanpushp = QtGui.QPushButton(self.frame1)
self.subrefanpushp.setGeometry(QtCore.QRect(10, 330, 155, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanpushp.setFont(font)
self.subrefanpushp.setText(_fromUtf8(""))
self.subrefanpushp.setToolTip("Click here to Submite these files and insert some other files")
self.subrefanpushp.setObjectName(_fromUtf8("subrefanpushp"))
self.subrefanpushok = QtGui.QPushButton(self.frame1)
self.subrefanpushok.setGeometry(QtCore.QRect(620, 330, 85, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.subrefanpushok.setFont(font)
self.subrefanpushok.setToolTip("Click here to submit these values and go-back to previous menu")
self.subrefanpushok.setObjectName(_fromUtf8("subrefanpushok"))
self.sublib = QtGui.QLabel(self.frame) #Select Library normalization method
self.sublib.setGeometry(QtCore.QRect(10, 310, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.sublib.setFont(font)
self.sublib.setObjectName(_fromUtf8("sublib"))
self.subrefcomb = QtGui.QComboBox(self.frame)
self.subrefcomb.setGeometry(QtCore.QRect(10, 330, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.subrefcomb.setFont(font)
self.subrefcomb.setToolTip("Select any one of the options")
self.subrefcomb.addItem(_fromUtf8(""))
self.subrefcomb.addItem(_fromUtf8(""))
self.subrefcomb.addItem(_fromUtf8(""))
self.subrefcomb.setObjectName(_fromUtf8("subrefcomb"))
self.displib = QtGui.QLabel(self.frame) #Select Dispersion estimation method
self.displib.setGeometry(QtCore.QRect(10, 380, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.displib.setFont(font)
self.displib.setObjectName(_fromUtf8("displib"))
self.dispcomb = QtGui.QComboBox(self.frame)
self.dispcomb.setGeometry(QtCore.QRect(10, 400, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.dispcomb.setFont(font)
self.dispcomb.setToolTip("Select any one of the options")
self.dispcomb.addItem(_fromUtf8(""))
self.dispcomb.addItem(_fromUtf8(""))
self.dispcomb.addItem(_fromUtf8(""))
self.dispcomb.addItem(_fromUtf8(""))
self.dispcomb.setObjectName(_fromUtf8("dispcomb"))
self.faldlbl = QtGui.QLabel(self.frame) #Set vaue for False Discovery Rate
self.faldlbl.setGeometry(QtCore.QRect(10, 450, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.faldlbl.setFont(font)
self.faldlbl.setObjectName(_fromUtf8("faldlbl"))
self.faldtxt = QtGui.QLineEdit(self.frame)
self.faldtxt.setGeometry(QtCore.QRect(10, 470, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.faldtxt.setFont(font)
self.faldtxt.setToolTip("Please Provide integer value")
self.faldtxt.setObjectName(_fromUtf8("faldtxt"))
self.faldlbl1 = QtGui.QLabel(self.frame) #Set vaue for Min Alignment Count
self.faldlbl1.setGeometry(QtCore.QRect(10, 520, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.faldlbl1.setFont(font)
self.faldlbl1.setObjectName(_fromUtf8("faldlbl1"))
self.faldtxt1 = QtGui.QLineEdit(self.frame)
self.faldtxt1.setGeometry(QtCore.QRect(10, 540, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.faldtxt1.setFont(font)
self.faldtxt1.setToolTip("Please Provide integer value")
self.faldtxt1.setObjectName(_fromUtf8("faldtxt"))
self.sqlbl1 = QtGui.QLabel(self.frame) #Do you want to Use multi-read correct
self.sqlbl1.setGeometry(QtCore.QRect(10, 590, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.sqlbl1.setFont(font)
self.sqlbl1.setObjectName(_fromUtf8("sqlbl1"))
self.asno11 = QtGui.QPushButton(self.frame)
self.asno11.setGeometry(QtCore.QRect(60, 610, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asno11.setFont(font)
self.asno11.setObjectName(_fromUtf8("asno11"))
self.asyes11 = QtGui.QPushButton(self.frame)
self.asyes11.setToolTip(("Click here to Use multi-read correct otherwise click no"))
self.asyes11.setGeometry(QtCore.QRect(10, 610, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.asyes11.setFont(font)
self.asyes11.setObjectName(_fromUtf8("asyes11"))
self.multireadlbl = QtGui.QLabel(self.frame) #Do you want to Include Read Group Datasets
self.multireadlbl.setGeometry(QtCore.QRect(10, 660, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.multireadlbl.setFont(font)
self.multireadlbl.setObjectName(_fromUtf8("multireadlbl"))
self.multireadcmb = QtGui.QComboBox(self.frame)
self.multireadcmb.setGeometry(QtCore.QRect(10, 680, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.multireadcmb.setFont(font)
self.multireadcmb.setObjectName(_fromUtf8("multireadcmb"))
self.multireadcmb.setToolTip("Click yes to include Read Group Datasets otherwise Click No")
self.multireadcmb.addItem(_fromUtf8(""))
self.multireadcmb.addItem(_fromUtf8(""))
self.multireadlbl1 = QtGui.QLabel(self.frame) #Do you want to Include Count Based output files
self.multireadlbl1.setGeometry(QtCore.QRect(10, 730, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.multireadlbl1.setFont(font)
self.multireadlbl1.setObjectName(_fromUtf8("multireadlbl1"))
self.multireadcmb1 = QtGui.QComboBox(self.frame)
self.multireadcmb1.setGeometry(QtCore.QRect(10, 750, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.multireadcmb1.setFont(font)
self.multireadcmb1.setObjectName(_fromUtf8("multireadcmb1"))
self.multireadcmb1.setToolTip("Click yes to include Count Based output files otherwise click No")
self.multireadcmb1.addItem(_fromUtf8(""))
self.multireadcmb1.addItem(_fromUtf8(""))
self.lengthcorlbl = QtGui.QLabel(self.frame) #Do you want to Apply length correction
self.lengthcorlbl.setGeometry(QtCore.QRect(10, 800, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.lengthcorlbl.setFont(font)
self.lengthcorlbl.setObjectName(_fromUtf8("lengthcorlbl"))
self.lengthcorcmb = QtGui.QComboBox(self.frame)
self.lengthcorcmb.setToolTip("Select any one of the following options")
self.lengthcorcmb.setGeometry(QtCore.QRect(10, 820, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.lengthcorcmb.setFont(font)
self.lengthcorcmb.setObjectName(_fromUtf8("lengthcorcmb"))
self.lengthcorcmb.addItem(_fromUtf8(""))
self.lengthcorcmb.addItem(_fromUtf8(""))
self.lengthcorcmb.addItem(_fromUtf8(""))
self.advcufoptlbl = QtGui.QLabel(self.frame) #Do you want to Set Additional Parameters for single end reads
self.advcufoptlbl.setGeometry(QtCore.QRect(10, 870, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.advcufoptlbl.setFont(font)
self.advcufoptlbl.setObjectName(_fromUtf8("advcufoptlbl"))
self.advcufoptcmb = QtGui.QComboBox(self.frame)
self.advcufoptcmb.setGeometry(QtCore.QRect(10, 890, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.advcufoptcmb.setFont(font)
self.advcufoptcmb.setObjectName(_fromUtf8("advcufoptcmb"))
self.advcufoptcmb.setToolTip("Click yes to set additional Cuffdiff option otherwise click No")
self.advcufoptcmb.addItem(_fromUtf8(""))
self.advcufoptcmb.addItem(_fromUtf8(""))
self.groupBox_4 = QtGui.QGroupBox(self.frame) #groupbox that containes additional Cuffdiff option
self.groupBox_4.setGeometry(QtCore.QRect(10, 910, 741, 1081))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.groupBox_4.setFont(font)
self.groupBox_4.setObjectName(_fromUtf8("groupBox_4"))
self.avgfraglbl = QtGui.QLabel(self.groupBox_4) #Do you want to set the Average Fragment Length
self.avgfraglbl.setGeometry(QtCore.QRect(0, 20, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.avgfraglbl.setFont(font)
self.avgfraglbl.setObjectName(_fromUtf8("avgfraglbl"))
self.avgtxt = QtGui.QLineEdit(self.groupBox_4)
self.avgtxt.setGeometry(QtCore.QRect(0, 40, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.avgtxt.setFont(font)
self.avgtxt.setToolTip("Please provide integer value")
self.avgtxt.setObjectName(_fromUtf8("avgtxt"))
self.intdiststddevlbl = QtGui.QLabel(self.groupBox_4) #Do you want to set the Fragment Length Standard Deviation
self.intdiststddevlbl.setGeometry(QtCore.QRect(0,90, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.intdiststddevlbl.setFont(font)
self.intdiststddevlbl.setObjectName(_fromUtf8("intdiststddevlbl"))
self.intdiststddevtxt = QtGui.QLineEdit(self.groupBox_4)
self.intdiststddevtxt.setToolTip("Please provide integer value")
self.intdiststddevtxt.setGeometry(QtCore.QRect(0, 110, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.intdiststddevtxt.setFont(font)
self.intdiststddevtxt.setObjectName(_fromUtf8("intdiststddevtxt"))
self.advgrp = QtGui.QGroupBox(self.frame) # groupbox that containes advanced cuffdiff options
self.advgrp.setGeometry(QtCore.QRect(10, 940, 741, 1081))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.advgrp.setFont(font)
self.advgrp.setObjectName(_fromUtf8("advgrp"))
self.advcufoptlbl1 = QtGui.QLabel(self.advgrp) #Do you want to Set Advanced Cuffdiff parameters
self.advcufoptlbl1.setGeometry(QtCore.QRect(0,0, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.advcufoptlbl1.setFont(font)
self.advcufoptlbl1.setObjectName(_fromUtf8("advcufoptlbl1"))
self.advcufoptcmb1 = QtGui.QComboBox(self.advgrp)
self.advcufoptcmb1.setGeometry(QtCore.QRect(0, 20, 721, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.advcufoptcmb1.setFont(font)
self.advcufoptcmb1.setObjectName(_fromUtf8("advcufoptcmb"))
self.advcufoptcmb1.setToolTip("Click yes to set advanced Cuffdiff option otherwise click No")
self.advcufoptcmb1.addItem(_fromUtf8(""))
self.advcufoptcmb1.addItem(_fromUtf8(""))
self.advancegrp = QtGui.QFrame(self.scrollAreaWidgetContents) # frame that containes advanced cuffdiff options
self.advancegrp.setGeometry(QtCore.QRect(50, 50, 761, 2081))
self.advancegrp.setFocusPolicy(QtCore.Qt.ClickFocus)
self.advancegrp.setFrameShape(QtGui.QFrame.WinPanel)
self.advancegrp.setFrameShadow(QtGui.QFrame.Raised)
self.advancegrp.setLineWidth(10)
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.advancegrp.setFont(font)
self.advancegrp.setObjectName(_fromUtf8("advancegrp"))
self.libinplbl = QtGui.QLabel(self.advancegrp) #Do you want to use Library prep used for input reads
self.libinplbl.setGeometry(QtCore.QRect(30, 10, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.libinplbl.setFont(font)
self.libinplbl.setObjectName(_fromUtf8("libinplbl"))
self.libinpcmb = QtGui.QComboBox(self.advancegrp)
self.libinpcmb.setGeometry(QtCore.QRect(30, 30, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.libinpcmb.setFont(font)
self.libinpcmb.setToolTip("Select any one option")
self.libinpcmb.setObjectName(_fromUtf8("libinpcmb"))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.libinpcmb.addItem(_fromUtf8(""))
self.masklbl = QtGui.QLabel(self.advancegrp) #Select Mask File
self.masklbl.setGeometry(QtCore.QRect(30, 80, 711, 20))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.masklbl.setFont(font)
self.masklbl.setObjectName(_fromUtf8("masklbl"))
self.maskpush = QtGui.QPushButton(self.advancegrp)
self.maskpush.setToolTip("Click here to select single mask file")
self.maskpush.setGeometry(QtCore.QRect(30, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.maskpush.setFont(font)
self.maskpush.setText(_fromUtf8(""))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.maskpush.setIcon(icon)
self.maskpush.setObjectName(_fromUtf8("maskpush"))
self.mulfile5 = QtGui.QPushButton(self.advancegrp)
self.mulfile5.setGeometry(QtCore.QRect(70, 100, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.mulfile5.setFont(font)
self.mulfile5.setToolTip("Click here to select mulitiple mask file")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index1.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.mulfile5.setIcon(icon)
self.mulfile5.setObjectName(_fromUtf8("mulfile5"))
self.maskcmb = QtGui.QComboBox(self.advancegrp)
self.maskcmb.setGeometry(QtCore.QRect(110, 100, 601, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
# font.setBold(True)
font.setWeight(50)
self.maskcmb.setFont(font)
self.maskcmb.setObjectName(_fromUtf8("maskcmb"))
self.timlbl = QtGui.QLabel(self.advancegrp) #Do you want to Perform Time Series analysis
self.timlbl.setGeometry(QtCore.QRect(30, 150, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.timlbl.setFont(font)
self.timlbl.setObjectName(_fromUtf8("timlbl"))
self.no1 = QtGui.QPushButton(self.advancegrp)
self.no1.setGeometry(QtCore.QRect(80, 170, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.no1.setFont(font)
self.no1.setObjectName(_fromUtf8("no1"))
self.yes1 = QtGui.QPushButton(self.advancegrp)
self.yes1.setToolTip("Click here if want to Perform Time Series analysis otherwise Click NO")
self.yes1.setGeometry(QtCore.QRect(30, 170, 51, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setWeight(50)
self.yes1.setFont(font)
self.yes1.setObjectName(_fromUtf8("yes1"))
self.maxmlelbl = QtGui.QLabel(self.advancegrp) #Do you want to set the Max MLE iterations
self.maxmlelbl.setGeometry(QtCore.QRect(30, 220, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.maxmlelbl.setFont(font)
self.maxmlelbl.setObjectName(_fromUtf8("maxmlelbl"))
self.maxmletxt = QtGui.QLineEdit(self.advancegrp)
self.maxmletxt.setToolTip("Please provide integer value")
self.maxmletxt.setGeometry(QtCore.QRect(30, 240, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.maxmletxt.setFont(font)
self.maxmletxt.setObjectName(_fromUtf8("maxmletxt"))
self.hitslbl1 = QtGui.QLabel(self.advancegrp) #Do you want to Select the Hits included in normalization
self.hitslbl1.setGeometry(QtCore.QRect(30, 290, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.hitslbl1.setFont(font)
self.hitslbl1.setObjectName(_fromUtf8("hitslbl1"))
self.hitscmb = QtGui.QComboBox(self.advancegrp)
self.hitscmb.setToolTip("Select any one option")
self.hitscmb.setGeometry(QtCore.QRect(30, 310, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
#font.setBold(True)
font.setWeight(50)
self.hitscmb.setFont(font)
self.hitscmb.setObjectName(_fromUtf8("hitscmb"))
self.hitscmb.addItem(_fromUtf8(""))
self.hitscmb.addItem(_fromUtf8(""))
self.maxfraglbl = QtGui.QLabel(self.advancegrp) #Do you want to set Maximum number of fragments per locus
self.maxfraglbl.setGeometry(QtCore.QRect(30, 360, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.maxfraglbl.setFont(font)
self.maxfraglbl.setObjectName(_fromUtf8("maxfraglbl"))
self.maxtxt = QtGui.QLineEdit(self.advancegrp)
self.maxtxt.setToolTip("Please provide integer values")
self.maxtxt.setGeometry(QtCore.QRect(30, 380, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.maxtxt.setFont(font)
self.maxtxt.setObjectName(_fromUtf8("maxtxt"))
self.numfraglbl = QtGui.QLabel(self.advancegrp) #Do you want to set Number of fragment generation sample
self.numfraglbl.setGeometry(QtCore.QRect(30, 430, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.numfraglbl.setFont(font)
self.numfraglbl.setObjectName(_fromUtf8("numfraglbl"))
self.numtxt = QtGui.QLineEdit(self.advancegrp)
self.numtxt.setToolTip("Please provide integer values")
self.numtxt.setGeometry(QtCore.QRect(30, 450, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.numtxt.setFont(font)
self.numtxt.setObjectName(_fromUtf8("numtxt"))
self.assamplbl = QtGui.QLabel(self.advancegrp) #Do you want to set Number of fragment assignment samples per generations
self.assamplbl.setGeometry(QtCore.QRect(30, 500, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.assamplbl.setFont(font)
self.assamplbl.setObjectName(_fromUtf8("assamplbl"))
self.asamptxt = QtGui.QLineEdit(self.advancegrp)
self.asamptxt.setToolTip("Please provide integer values")
self.asamptxt.setGeometry(QtCore.QRect(30, 520, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.asamptxt.setFont(font)
self.asamptxt.setObjectName(_fromUtf8("asamptxt"))
self.minreplbl = QtGui.QLabel(self.advancegrp) #Do you want to set Minimal Replicates for isoform shift testing
self.minreplbl.setGeometry(QtCore.QRect(30, 570, 711, 17))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.minreplbl.setFont(font)
self.minreplbl.setObjectName(_fromUtf8("minreplbl"))
self.minreptxt = QtGui.QLineEdit(self.advancegrp)
self.minreptxt.setToolTip("Please provide integer values")
self.minreptxt.setGeometry(QtCore.QRect(30, 590, 681, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.minreptxt.setFont(font)
self.minreptxt.setObjectName(_fromUtf8("minreptxt"))
self.otherfrm = QtGui.QFrame(self.advancegrp) #frame that contains other options
self.otherfrm.setGeometry(QtCore.QRect(20, 640, 791, 1521))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.otherfrm.setFont(font)
self.otherfrm.setObjectName(_fromUtf8("otherfrm"))
self.help = QtGui.QLabel(self.otherfrm) #Do you want to Prints the help message
self.help.setGeometry(QtCore.QRect(10, 20, 511, 17))
self.help.setObjectName(_fromUtf8("help"))
self.helpyes = QtGui.QPushButton(self.otherfrm)
self.helpyes.setToolTip("Click here if you want to Prints the help message otherwise click NO")
self.helpyes.setGeometry(QtCore.QRect(10, 40, 51, 27))
self.helpyes.setObjectName(_fromUtf8("helpyes"))
self.helpno = QtGui.QPushButton(self.otherfrm)
self.helpno.setGeometry(QtCore.QRect(60, 40, 51, 27))
self.helpno.setObjectName(_fromUtf8("helpno"))
self.threadl = QtGui.QLabel(self.otherfrm) #Please enter the number of alignment threads to launch
self.threadl.setGeometry(QtCore.QRect(10, 160, 641, 17))
self.threadl.setObjectName(_fromUtf8("threadl"))
self.thrdtxt = QtGui.QLineEdit(self.otherfrm)
self.thrdtxt.setToolTip("Please provide integer values")
self.thrdtxt.setGeometry(QtCore.QRect(10, 180, 681, 27))
self.thrdtxt.setObjectName(_fromUtf8("thrdtxt"))
self.outlb = QtGui.QLabel(self.otherfrm) #Do you want to write all output files to this directory
self.outlb.setGeometry(QtCore.QRect(10, 90, 541, 17))
self.outlb.setObjectName(_fromUtf8("outlb"))
self.outdirtxt = QtGui.QLineEdit(self.otherfrm)
self.outdirtxt.setToolTip("Please Provide path of the directory")
self.outdirtxt.setGeometry(QtCore.QRect(10, 110, 681, 27))
self.outdirtxt.setObjectName(_fromUtf8("outdirtxt"))
self.idl = QtGui.QLabel(self.otherfrm) #Do you want to assembled transcripts have this ID prefix
self.idl.setGeometry(QtCore.QRect(10, 230, 711, 17))
self.idl.setObjectName(_fromUtf8("idl"))
self.idtxt = QtGui.QLineEdit(self.otherfrm)
self.idtxt.setToolTip("Please provide ID value")
self.idtxt.setGeometry(QtCore.QRect(10, 250, 681, 27))
self.idtxt.setObjectName(_fromUtf8("idtxt"))
self.biasln = QtGui.QLabel(self.otherfrm) #Do you want to use bias correction
self.biasln.setGeometry(QtCore.QRect(10, 300, 491, 17))
self.biasln.setObjectName(_fromUtf8("biasln"))
self.biastxtcor = QtGui.QComboBox(self.otherfrm)
self.biastxtcor.setGeometry(QtCore.QRect(90, 320, 601, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.biastxtcor.setFont(font)
self.biastxtcor.setObjectName(_fromUtf8("biastxtcor"))
self.biaspus = QtGui.QPushButton(self.otherfrm)
self.biaspus.setToolTip("Click here to select single file")
self.biaspus.setGeometry(QtCore.QRect(10, 320, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.biaspus.setFont(font)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.biaspus.setIcon(icon)
self.biaspus.setObjectName(_fromUtf8("biaspus"))
self.mulfile4 = QtGui.QPushButton(self.otherfrm)
self.mulfile4.setGeometry(QtCore.QRect(50, 320, 31, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.mulfile4.setFont(font)
self.mulfile4.setToolTip("Click here to select multiple file for bias correction")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("/home/amrata/PycharmProjects/bowtieuser/images/index1.png")),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.mulfile4.setIcon(icon)
self.mulfile4.setObjectName(_fromUtf8("mulfile4"))
self.difanal = QtGui.QLabel(self.otherfrm) #Do you want to generate differential analysis files
self.difanal.setGeometry(QtCore.QRect(10, 370, 611, 17))
self.difanal.setObjectName(_fromUtf8("difanal"))
self.diffno = QtGui.QPushButton(self.otherfrm)
self.diffno.setGeometry(QtCore.QRect(60, 390, 51, 27))
self.diffno.setObjectName(_fromUtf8("diffno"))
self.diffyes = QtGui.QPushButton(self.otherfrm)
self.diffyes.setToolTip("Click here if you want to generate differential analysis files otherwise click No" )
self.diffyes.setGeometry(QtCore.QRect(10, 390, 51, 27))
self.diffyes.setObjectName(_fromUtf8("diffyes"))
self.iso = QtGui.QLabel(self.otherfrm) #Do you want to perform isoform switching tests
self.iso.setGeometry(QtCore.QRect(10, 440, 601, 17))
self.iso.setObjectName(_fromUtf8("iso"))
self.isono = QtGui.QPushButton(self.otherfrm)
self.isono.setGeometry(QtCore.QRect(60, 460, 51, 27))
self.isono.setObjectName(_fromUtf8("isono"))
self.isoyes = QtGui.QPushButton(self.otherfrm)
self.isoyes.setToolTip("Click here if you want to perform isoform switching tests otherwise click No")
self.isoyes.setGeometry(QtCore.QRect(10, 460, 51, 27))
self.isoyes.setObjectName(_fromUtf8("isoyes"))
self.dias = QtGui.QLabel(self.otherfrm) #Do you want to Print lots of status updates and other diagnostic information
self.dias.setGeometry(QtCore.QRect(10, 510, 631, 17))
self.dias.setObjectName(_fromUtf8("dias"))
self.printyes = QtGui.QPushButton(self.otherfrm)
self.printyes.setToolTip("Click here if you want to Print lots of status updates and other diagnostic information otherwise click No")
self.printyes.setGeometry(QtCore.QRect(10, 530, 51, 27))
self.printyes.setObjectName(_fromUtf8("printyes"))
self.prntno = QtGui.QPushButton(self.otherfrm)
self.prntno.setGeometry(QtCore.QRect(60, 530, 51, 27))
self.prntno.setObjectName(_fromUtf8("prntno"))
self.warn = QtGui.QLabel(self.otherfrm) #Do you want to Suppress messages other than serious warnings and errors
self.warn.setGeometry(QtCore.QRect(10, 580, 611, 17))
self.warn.setObjectName(_fromUtf8("warn"))
self.suppno = QtGui.QPushButton(self.otherfrm)
self.suppno.setGeometry(QtCore.QRect(60, 600, 51, 27))
self.suppno.setObjectName(_fromUtf8("suppno"))
self.suppyes = QtGui.QPushButton(self.otherfrm)
self.suppyes.setToolTip("Click here if you want to Suppress messages other than serious warnings and errors otherwise click No")
self.suppyes.setGeometry(QtCore.QRect(10, 600, 51, 27))
self.suppyes.setObjectName(_fromUtf8("suppyes"))
self.updat = QtGui.QLabel(self.otherfrm) #Do you want to contact server to check for update availability
self.updat.setGeometry(QtCore.QRect(10, 650, 661, 17))
self.updat.setObjectName(_fromUtf8("updat"))
self.servyes = QtGui.QPushButton(self.otherfrm)
self.servyes.setToolTip("Click here if you want to contact server to check for update availability otherwise click No")
self.servyes.setGeometry(QtCore.QRect(10, 670, 51, 27))
self.servyes.setObjectName(_fromUtf8("servyes"))
self.servno = QtGui.QPushButton(self.otherfrm)
self.servno.setGeometry(QtCore.QRect(60, 670, 51, 27))
self.servno.setObjectName(_fromUtf8("servno"))
self.dispersion = QtGui.QLabel(self.otherfrm) #Want to Use the Poisson fragment dispersion model instead of learning one in each condition
self.dispersion.setGeometry(QtCore.QRect(10, 720, 771, 17))
self.dispersion.setObjectName(_fromUtf8("dispersion"))
self.poisno = QtGui.QPushButton(self.otherfrm)
self.poisno.setGeometry(QtCore.QRect(60, 740, 51, 27))
self.poisno.setObjectName(_fromUtf8("poisno"))
self.Poiyes = QtGui.QPushButton(self.otherfrm)
self.Poiyes.setToolTip("click here if you Want to Use the Poisson fragment dispersion model instead of learning one in each condition otherwise click No")
self.Poiyes.setGeometry(QtCore.QRect(10, 740, 51, 27))
self.Poiyes.setObjectName(_fromUtf8("Poiyes"))
self.overdisp = QtGui.QLabel(self.otherfrm) #Do you want to print count tables used to fit overdispersion
self.overdisp.setGeometry(QtCore.QRect(10, 790, 641, 17))
self.overdisp.setObjectName(_fromUtf8("overdisp"))
self.tabno = QtGui.QPushButton(self.otherfrm)
self.tabno.setGeometry(QtCore.QRect(60, 810, 51, 27))
self.tabno.setObjectName(_fromUtf8("tabno"))
self.tabyes = QtGui.QPushButton(self.otherfrm)
self.tabyes.setToolTip("Click here if you want to print count tables used to fit overdispersion otherwise click No")
self.tabyes.setGeometry(QtCore.QRect(10, 810, 51, 27))
self.tabyes.setObjectName(_fromUtf8("tabyes"))
self.skipl = QtGui.QLabel(self.otherfrm) #Set the maximum fragments allowed in a bundle before skipping
self.skipl.setGeometry(QtCore.QRect(10, 860, 671, 17))
self.skipl.setObjectName(_fromUtf8("skipl"))
self.skiptxt = QtGui.QLineEdit(self.otherfrm)
self.skiptxt.setToolTip("Please provide integer value")
self.skiptxt.setGeometry(QtCore.QRect(10, 880, 681, 27))
self.skiptxt.setObjectName(_fromUtf8("skiptxt"))
self.numsaml = QtGui.QLabel(self.otherfrm) #Set the Number of fragment generation samples
self.numsaml.setGeometry(QtCore.QRect(10, 930, 641, 17))
self.numsaml.setObjectName(_fromUtf8("numsaml"))
self.fragentxsm = QtGui.QLineEdit(self.otherfrm)
self.fragentxsm.setToolTip("Please provide integer value")
self.fragentxsm.setGeometry(QtCore.QRect(10, 950, 681, 27))
self.fragentxsm.setObjectName(_fromUtf8("fragentxsm"))
self.assgn = QtGui.QLabel(self.otherfrm) #Set the Number of fragment assignment samples per generation
self.assgn.setGeometry(QtCore.QRect(10, 1000, 731, 17))
self.assgn.setObjectName(_fromUtf8("assgn"))
self.pergen = QtGui.QLineEdit(self.otherfrm)
self.pergen.setToolTip("Please provide integer value")
self.pergen.setGeometry(QtCore.QRect(10, 1020, 681, 27))
self.pergen.setObjectName(_fromUtf8("pergen"))
self.testing = QtGui.QLabel(self.otherfrm) #Set Replicates needed for relative isoform shift testing
self.testing.setGeometry(QtCore.QRect(10, 1070, 681, 17))
self.testing.setObjectName(_fromUtf8("testing"))
self.pergen_2 = QtGui.QLineEdit(self.otherfrm)
self.pergen_2.setToolTip("Please provide integer value")
self.pergen_2.setGeometry(QtCore.QRect(10, 1090, 681, 27))
self.pergen_2.setObjectName(_fromUtf8("pergen_2"))
self.ok = QtGui.QPushButton(self.advancegrp)
self.ok.setGeometry(QtCore.QRect(550, 1800, 98, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setBold(False)
font.setWeight(50)
self.ok.setFont(font)
self.ok.setToolTip("Click here to goback previous menu")
self.ok.setObjectName(_fromUtf8("ok"))
self.execute = QtGui.QPushButton(self.frame)
self.execute.setToolTip("Click here if you are submit these values")
self.execute.setGeometry(QtCore.QRect(600, 1030, 98, 27))
font = QtGui.QFont()
font.setFamily(_fromUtf8("Droid Serif"))
font.setPointSize(11)
font.setBold(False)
font.setWeight(50)
self.execute.setFont(font)
self.execute.setObjectName(_fromUtf8("execute"))
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 829, 25))
self.menubar.setObjectName(_fromUtf8("menubar"))
MainWindow.setMenuBar(self.menubar)
self.toolBar = QtGui.QToolBar(MainWindow)
self.toolBar.setObjectName(_fromUtf8("toolBar"))
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
MainWindow.setCentralWidget(self.centralWidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "CUFFDIFF", None))
self.selgtflbl.setText(_translate("MainWindow","Transcripts",None))
self.omitlbl.setText(_translate("MainWindow", "Do you want to Omit Tabular Datasets.", None))
self.asno.setText(_translate("MainWindow", "No", None))
self.asyes.setText(_translate("MainWindow", "Yes", None))
self.sqlbl.setText(_translate("MainWindow", "Do you want to Generate SQLite.", None))
self.asno1.setText(_translate("MainWindow", "No", None))
self.asyes1.setText(_translate("MainWindow", "Yes", None))
self.inputdatalbl.setText(_translate("MainWindow", "Do you want to Provide Input data type.", None))
self.inpcmb.setItemText(0, _translate("MainWindow", "SAM/BAM", None))
self.inpcmb.setItemText(1, _translate("MainWindow", "Cuffquant(CXB)", None))
self.inpcmb.setItemText(2, _translate("MainWindow", "List of single replicate condition", None))
self.inpcmb.setItemText(3, _translate("MainWindow", "List of multiple replicate condition", None))
self.ovrhngtollbl0.setText(_translate("MainWindow", "Conditions.", None))
self.ovrhngtollbl.setText(_translate("MainWindow", "Name.", None))
self.ovrhngtollbl1.setText(_translate("MainWindow", "Name.", None))
self.subrefanlbl1.setText(_translate("MainWindow", "Replicates", None))
self.subrefanlbl.setText(_translate("MainWindow", "Replicates.", None))
self.subrefanpushp.setText(_translate("MainWindow", " + Insert condition", None))
self.sublib.setText(_translate("MainWindow", "Select Library normalization method\n"
"", None))
self.subrefcomb.setItemText(0, _translate("MainWindow", "geometric", None))
self.subrefcomb.setItemText(1, _translate("MainWindow", "classic-fpkm", None))
self.subrefcomb.setItemText(2, _translate("MainWindow", "quartile", None))
self.displib.setText(_translate("MainWindow", "Select Dispersion estimation method\n"
"", None))
self.dispcomb.setItemText(0, _translate("MainWindow", "pooled", None))
self.dispcomb.setItemText(1, _translate("MainWindow", "per-condition", None))
self.dispcomb.setItemText(2, _translate("MainWindow", "blind", None))
self.dispcomb.setItemText(2, _translate("MainWindow", "poisson", None))
self.faldlbl.setText(_translate("MainWindow", "Set vaue for False Discovery Rate", None))
self.faldlbl1.setText(_translate("MainWindow", "Set vaue for Min Alignment Count", None))
self.sqlbl1.setText(_translate("MainWindow", "Do you want to Use multi-read correct.", None))
self.asno11.setText(_translate("MainWindow", "No", None))
self.asyes11.setText(_translate("MainWindow", "Yes", None))
self.multireadlbl.setText(_translate("MainWindow", "Do you want to Include Read Group Datasets?", None))
self.multireadcmb.setItemText(0, _translate("MainWindow", "No", None))
self.multireadcmb.setItemText(1, _translate("MainWindow", "Yes", None))
self.multireadlbl1.setText(_translate("MainWindow", "Do you want to Include Count Based output files", None))
self.multireadcmb1.setItemText(0, _translate("MainWindow", "No", None))
self.multireadcmb1.setItemText(1, _translate("MainWindow", "Yes", None))
self.lengthcorlbl.setText(_translate("MainWindow", "Do you want to Apply length correction?", None))
self.lengthcorcmb.setItemText(0, _translate("MainWindow", "Cufflinks Effective Length Correction", None))
self.lengthcorcmb.setItemText(1, _translate("MainWindow", "Standard alength Correction", None))
self.lengthcorcmb.setItemText(2, _translate("MainWindow", "No Length Correction at all (use raw counts)", None))
self.advcufoptlbl.setText(_translate("MainWindow", "Do you want to Set Additional Parameters for single end reads?", None))
self.advcufoptcmb.setItemText(0, _translate("MainWindow", "Yes", None))
self.advcufoptcmb.setItemText(1, _translate("MainWindow", "No", None))
self.avgfraglbl.setText(_translate("MainWindow", "Do you want to set the Average Fragment Length", None))
self.intdiststddevlbl.setText(_translate("MainWindow", "Do you want to set the Fragment Length Standard Deviation.", None))
self.advcufoptlbl1.setText(_translate("MainWindow", "Do you want to Set Advanced Cuffdiff parameters? ", None))
self.advcufoptcmb1.setItemText(0, _translate("MainWindow", "Yes", None))
self.advcufoptcmb1.setItemText(1, _translate("MainWindow", "No", None))
self.libinplbl.setText(_translate("MainWindow", "Do you want to use Library prep used for input reads?", None))
self.libinpcmb.setItemText(0, _translate("MainWindow", "Auto Detect", None))
self.libinpcmb.setItemText(1, _translate("MainWindow", "ff-firststrand", None))
self.libinpcmb.setItemText(2, _translate("MainWindow", "ff-secondstrand", None))
self.libinpcmb.setItemText(3, _translate("MainWindow", "ff-unstranded", None))
self.libinpcmb.setItemText(4, _translate("MainWindow", "fr-firststrand", None))
self.libinpcmb.setItemText(5, _translate("MainWindow", "fr-secondstrand", None))
self.libinpcmb.setItemText(6, _translate("MainWindow", "fr-unstranded", None))
self.libinpcmb.setItemText(7, _translate("MainWindow", "transfrags", None))
self.masklbl.setText(_translate("MainWindow", "Select Mask File", None))
self.timlbl.setText(_translate("MainWindow", "Do you want to Perform Time Series analysis.", None))
self.no1.setText(_translate("MainWindow", "No", None))
self.yes1.setText(_translate("MainWindow", "Yes", None))
self.maxmlelbl.setText(_translate("MainWindow", "Do you want to set the Max MLE iterations.", None))
self.hitslbl1.setText(_translate("MainWindow", "Do you want to Select the Hits included in normalization?", None))
self.hitscmb.setItemText(0, _translate("MainWindow", "Compatible Hits", None))
self.hitscmb.setItemText(1, _translate("MainWindow", "All Hits", None))
self.maxfraglbl.setText(_translate("MainWindow", "Do you want to set Maximum number of fragments per locus?", None))
self.numfraglbl.setText(_translate("MainWindow", "Do you want to set Number of fragment generation samples", None))
self.assamplbl.setText(_translate("MainWindow", "Do you want to set Number of fragment assignment samples per generations", None))
self.minreplbl.setText(_translate("MainWindow", "Do you want to set Minimal Replicates for isoform shift testing", None))
self.execute.setText(_translate("MainWindow", "Execute", None))
self.ok.setText(_translate("MainWindow", "OK", None))
self.help.setText(_translate("MainWindow", "Do you want to Prints the help message", None))
self.helpyes.setText(_translate("MainWindow", "Yes", None))
self.helpno.setText(_translate("MainWindow", "No", None))
self.threadl.setText(_translate("MainWindow", "Please enter the number of alignment threads to launch", None))
self.outlb.setText(_translate("MainWindow", "Do you want to write all output files to this directory ", None))
self.idl.setText(_translate("MainWindow", "Do you want to assembled transcripts have this ID prefix", None))
self.biasln.setText(_translate("MainWindow", "Do you want to use bias correction", None))
self.biaspus.setToolTip(_translate("MainWindow", "<html><head/><body><p>single</p></body></html>", None))
self.difanal.setText(_translate("MainWindow", "Do you want to generate differential analysis files", None))
self.diffno.setText(_translate("MainWindow", "No", None))
self.diffyes.setText(_translate("MainWindow", "Yes", None))
self.iso.setText(_translate("MainWindow", "Do you want to perform isoform switching tests", None))
self.isono.setText(_translate("MainWindow", "No", None))
self.isoyes.setText(_translate("MainWindow", "Yes", None))
self.dias.setText(
_translate("MainWindow", "Do you want to Print lots of status updates and other diagnostic information.",
None))
self.printyes.setText(_translate("MainWindow", "Yes", None))
self.prntno.setText(_translate("MainWindow", "No", None))
self.warn.setText(
_translate("MainWindow", "Do you want to Suppress messages other than serious warnings and errors.", None))
self.suppno.setText(_translate("MainWindow", "No", None))
self.suppyes.setText(_translate("MainWindow", "Yes", None))
self.updat.setText(
_translate("MainWindow", "Do you want to contact server to check for update availability", None))
self.servyes.setText(_translate("MainWindow", "Yes", None))
self.servno.setText(_translate("MainWindow", "No", None))
self.subrefanpushok.setText(_translate("MainWindow", "OK", None))
self.dispersion.setText(_translate("MainWindow",
"Want to Use the Poisson fragment dispersion model instead of learning one in each condition.",
None))
self.poisno.setText(_translate("MainWindow", "No", None))
self.Poiyes.setText(_translate("MainWindow", "Yes", None))
self.overdisp.setText(
_translate("MainWindow", "Do you want to print count tables used to fit overdispersion", None))
self.tabno.setText(_translate("MainWindow", "No", None))
self.tabyes.setText(_translate("MainWindow", "Yes", None))
self.skipl.setText(
_translate("MainWindow", "Set the maximum fragments allowed in a bundle before skipping", None))
self.numsaml.setText(_translate("MainWindow", "Set the Number of fragment generation samples", None))
self.assgn.setText(
_translate("MainWindow", "Set the Number of fragment assignment samples per generation", None))
self.testing.setText(
_translate("MainWindow", "Set Replicates needed for relative isoform shift testing ", None))
| 1.757813 | 2 |
LeNet5/mnist_inference.py | carbo-T/TF | 1 | 12789135 | <filename>LeNet5/mnist_inference.py
# -*- coding: utf8 -*-
import tensorflow as tf
# define basic params
INPUT_NODE = 784
OUTPUT_NODE = 10
IMAGE_SIZE = 28
NUM_CHANNELS = 1
NUM_LABELS = 10
CONV1_DEPTH = 6
CONV1_SIZE = 5
CONV2_DEPTH = 16
CONV2_SIZE = 5
FC_SIZE = 84
def inference(input_tensor, train, regularizer):
# define layer1 forward propagation
with tf.variable_scope('layer1-conv1'):
conv1_weights = tf.get_variable(
"weight", [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEPTH],
initializer=tf.truncated_normal_initializer(stddev=0.1)
)
conv1_biases = tf.get_variable("bias", [CONV1_DEPTH], initializer=tf.constant_initializer(0.0))
# strides 中间两项表示长宽方向步长1
conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))
# define layer2 forward propagation, max pooling, size 2*2, step 2*2, all 0 filling
with tf.variable_scope('layer2-pool1'):
pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
with tf.variable_scope('layer3-conv2'):
conv2_weights = tf.get_variable(
"weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEPTH, CONV2_DEPTH],
initializer=tf.truncated_normal_initializer(stddev=0.1)
)
conv2_biases = tf.get_variable("bias", [CONV2_DEPTH], initializer=tf.constant_initializer(0.0))
# size 5*5, depth 64, step 1, all 0 filling
conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1, ], padding='SAME')
relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
with tf.variable_scope('layer4-poll2'):
pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
# pool_shape[0] means the num of data from a batch, get_shape->[num, width, height, depth]
pool_shape = pool2.get_shape().as_list()
nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]
reshaped = tf.reshape(pool2, [pool_shape[0], nodes])
with tf.variable_scope('layer5-fc1'):
fc1_weights = tf.get_variable(
'weights',
[nodes, FC_SIZE],
initializer=tf.truncated_normal_initializer(stddev=0.1)
)
# fc layer regularize
if regularizer is not None:
tf.add_to_collection('losses', regularizer(fc1_weights))
fc1_biases = tf.get_variable('bias', [FC_SIZE], initializer=tf.constant_initializer(0.1))
fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)
if train:
fc1 = tf.nn.dropout(fc1, 0.5)
with tf.variable_scope('layer6-fc2'):
fc2_weight = tf.get_variable(
'weight',
[FC_SIZE, NUM_LABELS],
initializer=tf.truncated_normal_initializer(stddev=0.1)
)
if regularizer is not None:
tf.add_to_collection('losses', regularizer(fc2_weight))
fc2_biases = tf.get_variable('bias', [NUM_LABELS], initializer=tf.constant_initializer(0.1))
logit = tf.matmul(fc1, fc2_weight)+fc2_biases
return logit
| 2.65625 | 3 |
geninv.py | manticode/wow-inventory-offline | 1 | 12789136 | <gh_stars>1-10
import argparse
import re
import csv
from slpp import slpp as lua
def prerun():
""" Check input args are valid. """
argparser = argparse.ArgumentParser(description="Inventory database file.")
argparser.add_argument("-i", help="the lua datafile", dest="infilename")
argparser.add_argument("-o", help="Output filename in CSV format", dest="outfilename")
argparser.add_argument("-n", "--toon_name", help="Character (toon) nam", dest="toon_name")
argparser.add_argument("-r", "--realm_name", help="Realm (server) name. Defaults to Hydraxian Waterlords if not "
"specified", dest="realm_name")
argparser.print_help()
args = argparser.parse_args()
luafile = open(args.infilename, "r")
gu_char_name = get_unique_char_name(args.toon_name, args.realm_name)
return luafile, gu_char_name
def parse_lua(luadb, gu_toon_name):
""" Parse the lua data"""
inventorydata = luadb.read()
inventorydata = "{ "+inventorydata+" }"
inventorydataparsed = lua.decode(inventorydata)
itemid_list, itemname_list = iter_luadb(inventorydataparsed, gu_toon_name)
qty_list = get_item_qty(inventorydataparsed, gu_toon_name, itemid_list)
return itemid_list, itemname_list, qty_list
def extract_item_name(item_string):
item_name = re.search("^.*\[([a-zA-Z0-9\s\:\',\-]*)\].*$", item_string)
if item_name:
return item_name.group(1)
def get_item_qty(lua_obj, gu_toon_name, item_id_list):
""" Correlate quantities for respective items."""
bank_inv_qty_lookup = lua_obj["AskMrRobotDbClassic"]["char"][gu_toon_name]["BankItemsAndCounts"]
storage_list_qty = []
qty_insert = 0
for item_id_lookup in item_id_list:
for container_id in bank_inv_qty_lookup:
bank_container = bank_inv_qty_lookup[container_id]
item_qty = bank_container.get(item_id_lookup)
if item_qty:
qty_insert = qty_insert + item_qty
else:
pass
storage_list_qty.append(qty_insert)
qty_insert = 0
return storage_list_qty
def get_unique_char_name(toon_name, realm_name):
""" globally unique toon name in Name - Realm format"""
gu_char_name = toon_name + " - " + realm_name
return gu_char_name
def iter_luadb(lua_obj, gu_char_name):
""" Extract the stuff we want. Each bag """
bank_inv_lookup = lua_obj["AskMrRobotDbClassic"]["char"][gu_char_name]["BankItems"]
storage_list_itemid = []
storage_list_itemname = []
for key in bank_inv_lookup:
bank_container = bank_inv_lookup[key]
for slot_item in bank_container:
if slot_item["id"] in storage_list_itemid:
pass
else:
storage_list_itemid.append(slot_item["id"])
storage_list_itemname.append(extract_item_name(slot_item["link"]))
if isinstance(bank_inv_lookup[key], dict):
iter_luadb(bank_inv_lookup[key], toon_name, realm_name)
return storage_list_itemid, storage_list_itemname
def create_combined_inv(item_id_list, item_name_list, item_qty_list):
zip_inv = zip(item_name_list, item_qty_list)
dict_inv = dict(zip_inv)
return dict_inv
def write_out_csv(inv_dict, outfile):
with open(outfile, "w") as file_handle:
writer = csv.writer(file_handle)
writer.writerows(inv_dict.items())
file_handle.close()
if __name__ == "__main__":
databaseobj, gu_name = prerun()
itemid_list, itemname_list, itemqty_list = parse_lua(databaseobj, gu_name)
inventory_dict = create_combined_inv(itemid_list, itemname_list, itemqty_list)
write_out_csv(inventory_dict, "inventory.csv") | 2.9375 | 3 |
SalesforceApi.py | mvogelgesang/SF-Event-Monitoring-Log-Retrieval | 0 | 12789137 | <reponame>mvogelgesang/SF-Event-Monitoring-Log-Retrieval<filename>SalesforceApi.py
import datetime
import getopt
import json
import logging
import os
import requests
import sys
from FileWriter import FileWriter
from requests.auth import HTTPBasicAuth
"""
Salesforce API
"""
class SalesforceApi:
def __init__(self,environment,debug=0):
self.username = environment['username']
self.password = environment['password']
self.securityToken = environment['securityToken']
self.sfConsumerKey = environment['consumerKey']
self.sfConsumerSecret = environment['consumerSecret']
self.sfURL = environment['salesforceURL']
self.accessToken = ''
self.debug = debug
self.logPath = 'logs/tmp_'+datetime.datetime.now().strftime('%Y%m%d-%H%M.%S')+'.json'
if self.debug:
print "salesforce api initiated"
def authenticate(self):
"""Authenticate against Salesforce using an OAuth connection. Sets the accessToken attribute of the SalesforceApi class
Parameters
----------
Returns
-------
void
"""
# Login Step 1, Request Access token
# To do so, you must have created a connected App in Salesforce and have a clientId and clientSecret available along with username, password, and securityToken
authHeaders = {'Content-Type': 'application/x-www-form-urlencoded'}
# Constrcut the body of the request for access token
payload = {'grant_type':'password','client_id':self.sfConsumerKey,'client_secret':self.sfConsumerSecret,'username':self.username,'password':self.password+self.securityToken}
# Post to https://login.salesforce.com/services/oauth2/token
rawResponse = requests.post('https://'+self.sfURL+'/services/oauth2/token',headers=authHeaders, data=payload)
response = json.loads(rawResponse.text)
if self.debug:
print "[DEBUG] authenticate >> "
print response
self.accessToken = response['access_token']
def queryEventLogFile(self, eventType=''):
"""Query the Event Log File object for API events. Requires that accessToken is set
Parameters
----------
Returns
-------
json query response
"""
# If accessToken is not set, throw error
if (self.accessToken == ''):
raise ValueError('accessToken has not been set, run authenticate method to set token')
exit
# Set headers
headers = {'Content-Type': 'application/json','Authorization':'Bearer '+self.accessToken}
# Build WHERE clause
whereClause = ''
if eventType != '':
whereClause = "WHERE++EventType+=+'"+eventType+"'"
# post the request
rawResponse = requests.get("https://"+self.sfURL+"/services/data/v32.0/query?q=SELECT+Id+,+EventType+,+LogFile+,+LogDate+,+LogFileLength+FROM+EventLogFile+"+whereClause, headers=headers)
response = json.loads(rawResponse.text)
if self.debug:
print "[DEBUG] queryEventLogFile >> "
print response
return response
def eventLogFile(self,eventLogFile):
"""Retrieves a single Event File Log and writes it to the appropriate directory
Parameters
----------
param: eventLogFile
ex:
{
'LogFileLength': 5199.0,
'EventType': 'API',
'LogDate': '2016-11-22T00:00:00.000+0000',
'attributes': {
'url': '/services/data/v32.0/sobjects/EventLogFile/0ATr00000000TWHGA2',
'type': 'EventLogFile'
},
'LogFile': '/services/data/v32.0/sobjects/EventLogFile/0ATr00000000TWHGA2/LogFile',
'Id': '0ATr00000000TWHGA2'
}
Returns
-------
csv containing event file log
"""
if (self.accessToken == ''):
raise ValueError('accessToken has not been set, run authenticate method to set token')
exit
eventFileId = eventLogFile['Id']
headers = {'Authorization':'Bearer '+self.accessToken,'X-PrettyPrint':'1','Accept-Encoding': 'gzip'}
rawResponse = requests.get('https://'+self.sfURL+'/services/data/v32.0/sobjects/EventLogFile/'+eventFileId+'/LogFile',headers=headers)
if self.debug:
print "[DEBUG] eventLogFile >> "
print rawResponse
print rawResponse.content
# if self.log:
# w = FileWriter('log', eventFileId)
# w.writeFile(rawResponse.content)
w = FileWriter(eventLogFile)
w.writeFile(rawResponse.content)
return rawResponse
| 2.6875 | 3 |
randomstate/prng/mt19937/__init__.py | bashtage/ng-numpy-randomstate | 43 | 12789138 | <gh_stars>10-100
from .mt19937 import * | 1.210938 | 1 |
code/python/visualize_contingency_tables.py | vishalbelsare/S3M | 52 | 12789139 | #!/usr/bin/env python3
#
# visualize_contingency_tables.py: Visualizes all contingency tables
# obtained by our method in the form of a diagram in the plane.
#
# Input: JSON file with shapelets
#
# Output: A set of points in the plane, each representing one table,
# such that the distance to the origin refers to preferences
# in splitting behaviour.
#
# The output will be written to `stdout`.
import argparse
import json
import sys
import numpy as np
def transform_table(table):
"""
Transforms a contingency table into a point on a two-dimensional
plane, in which the distance to the origin shows the suitability
of a contingency table for separating cases and controls.
"""
# Yes, this ordering is correct. Please refer to our paper for
# more details.
a, b, d, c = table
n1 = a+b
n0 = c+d
return (a-b) / n1, (c-d) / n0
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Contingency Table Visualization")
parser.add_argument("input",
metavar = "INPUT",
help = "Input file"
)
parser.add_argument("-f", "--flip",
required = False,
action = "store_true",
help = "If set, flips values in the visualization to ensure that quadrant 3 is not used"
)
parser.add_argument("-p", "--prune",
required = False,
action = "store_true",
help = "If set, prunes duplicates points"
)
arguments = parser.parse_args()
input_file = arguments.input
flip = arguments.flip
prune = arguments.prune
with open(input_file) as f:
data = json.load(f)
shapelets = data["shapelets"]
tables = []
for shapelet in shapelets:
tables.append( shapelet["table"] )
points = []
for table in tables:
x,y = transform_table(table)
if flip and ( (x < 0 and y < 0) or (np.sign(x) != np.sign(y) and -x > y) ):
x,y = -y,-x
points.append( (x,y) )
if prune:
points = set(points)
for x,y in points:
print("{}\t{}".format(x,y))
| 3.328125 | 3 |
app/auth/forms.py | INASIC/AnnotateChange | 13 | 12789140 | # -*- coding: utf-8 -*-
# Author: <NAME> <<EMAIL>>
# License: See LICENSE file
# Copyright: 2020 (c) The Alan Turing Institute
from flask import current_app, flash
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, BooleanField
from wtforms.validators import (
DataRequired,
Email,
EqualTo,
Optional,
ValidationError,
)
from app.models import User
class LoginForm(FlaskForm):
username = StringField("Username", validators=[DataRequired()])
password = PasswordField("Password", validators=[DataRequired()])
submit = SubmitField("Sign In")
class RegistrationForm(FlaskForm):
username = StringField("Username", validators=[DataRequired()])
email = StringField("Email", validators=[DataRequired(), Email()])
fullname = StringField("Full Name (optional)", validators=[])
password = PasswordField("Password", validators=[DataRequired()])
password2 = PasswordField(
"Repeat Password", validators=[DataRequired(), EqualTo("password")]
)
toc = BooleanField(
"I agree to the Terms and Conditions.", validators=[DataRequired()]
)
credit = BooleanField(
"Check this box if you would like to be publically credited with having "
"contributed to this work. By default, users will remain anonymous.",
validators=[Optional()],
)
updated = BooleanField(
"Check this box if you wish to be kept up to date with the "
"progress of this work by email.",
validators=[Optional()],
)
submit = SubmitField("Register")
def validate_username(self, username):
user = User.query.filter_by(username=username.data).first()
if user is not None:
raise ValidationError(
"Username already in use, please use a different one."
)
def validate_email(self, email):
user = User.query.filter_by(email=email.data).first()
if user is not None:
raise ValidationError(
"Email address already in use, please use a different one."
)
if current_app.config["USER_EMAILS"]:
if email.data in current_app.config["USER_EMAILS"]:
return
if current_app.config["USER_EMAIL_DOMAINS"]:
if (
not email.data.split("@")[-1]
in current_app.config["USER_EMAIL_DOMAINS"]
):
raise ValidationError(
"Access to AnnotateChange is restricted to "
"individuals with email addresses from specific "
"institutions. Please use your employee email address "
"when signing up. If that does not solve the issue, "
"you unfortunately do not have access to "
"AnnotateChange at this time."
)
def validate_credit(self, credit):
if credit.data and not self.fullname.data:
flash(
"Please provide your full name if you wish to "
"be credited with contributing to this work.", "error")
raise ValidationError(
"Please provide your full name if you wish to "
"be credited with contributing to this work."
)
class ResetPasswordRequestForm(FlaskForm):
email = StringField("Email", validators=[DataRequired(), Email()])
submit = SubmitField("Request password reset")
class ResetPasswordForm(FlaskForm):
password = PasswordField("Password", validators=[DataRequired()])
password2 = PasswordField(
"<PASSWORD>", validators=[DataRequired(), EqualTo("password")]
)
submit = SubmitField("Request Password Reset")
| 3 | 3 |
{{cookiecutter.project_slug}}/backend/app/app/core/config.py | abnerjacobsen/full-stack | 516 | 12789141 | <filename>{{cookiecutter.project_slug}}/backend/app/app/core/config.py
import os
def getenv_boolean(var_name, default_value=False):
result = default_value
env_value = os.getenv(var_name)
if env_value is not None:
result = env_value.upper() in ("TRUE", "1")
return result
API_V1_STR = "/api/v1"
SECRET_KEY = os.getenvb(b"SECRET_KEY")
if not SECRET_KEY:
SECRET_KEY = os.urandom(32)
ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 8 # 60 minutes * 24 hours * 8 days
SERVER_NAME = os.getenv("SERVER_NAME")
BACKEND_CORS_ORIGINS = os.getenv("BACKEND_CORS_ORIGINS")
PROJECT_NAME = os.getenv("PROJECT_NAME")
SENTRY_DSN = os.getenv("SENTRY_DSN")
POSTGRES_SERVER = os.getenv("POSTGRES_SERVER")
POSTGRES_USER = os.getenv("POSTGRES_USER")
POSTGRES_PASSWORD = os.getenv("POSTGRES_PASSWORD")
POSTGRES_DB = os.getenv("POSTGRES_DB")
SQLALCHEMY_DATABASE_URI = (
f"postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_SERVER}/{POSTGRES_DB}"
)
FIRST_SUPERUSER = os.getenv("FIRST_SUPERUSER")
FIRST_SUPERUSER_PASSWORD = os.getenv("FIRST_SUPERUSER_PASSWORD")
USERS_OPEN_REGISTRATION = getenv_boolean("USERS_OPEN_REGISTRATION")
| 1.890625 | 2 |
metrics.py | theletterf/collectd-spark | 3 | 12789142 | GAUGE = 'gauge'
COUNTER = 'counter'
SPARK_PROCESS_METRICS = {
# jvm generics
"jvm.total.used": (
GAUGE,
"gauges",
"value"
),
"jvm.total.committed": (
GAUGE,
"gauges",
"value"
),
# heap memory
"jvm.heap.used": (
GAUGE,
"gauges",
"value"
),
"jvm.heap.committed": (
GAUGE,
"gauges",
"value"
),
# non-heap memory
# if max = -1, this is technically unbounded
# (switching calculation to used/committed)
"jvm.non-heap.used": (
GAUGE,
"gauges",
"value"
),
"jvm.non-heap.committed": (
GAUGE,
"gauges",
"value"
),
# marksweep
"jvm.MarkSweepCompact.count": (
GAUGE,
"gauges",
"value"
),
"jvm.MarkSweepCompact.time": (
GAUGE,
"gauges",
"value"
),
# worker specific
"worker.coresFree": (
GAUGE,
"gauges",
"value"
),
"worker.coresUsed": (
GAUGE,
"gauges",
"value"
),
"worker.executors": (
GAUGE,
"gauges",
"value"
),
"worker.memFree_MB": (
GAUGE,
"gauges",
"value"
),
"worker.memUsed_MB": (
GAUGE,
"gauges",
"value"
),
# master specific
"master.aliveWorkers": (
GAUGE,
"gauges",
"value"
),
"master.apps": (
GAUGE,
"gauges",
"value"
),
"master.waitingApps": (
GAUGE,
"gauges",
"value"
),
"master.workers": (
GAUGE,
"gauges",
"value"
)
}
SPARK_PROCESS_METRICS_ENHANCED = {
# memory pool
"jvm.pools.Code-Cache.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Code-Cache.committed": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Compressed-Class-Space.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Compressed-Class-Space.committed": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Metaspace.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Metaspace.committed": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Eden-Space.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Eden-Space.committed": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Survivor-Space.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Survivor-Space.committed": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Tenured-Gen.used": (
GAUGE,
"gauges",
"value"
),
"jvm.pools.Tenured-Gen.committed": (
GAUGE,
"gauges",
"value"
),
# hive specifics
"HiveExternalCatalog.fileCacheHits": (
COUNTER,
"counters",
"count"
),
"HiveExternalCatalog.filesDiscovered": (
COUNTER,
"counters",
"count"
),
"HiveExternalCatalog.hiveClientCalls": (
COUNTER,
"counters",
"count"
),
"HiveExternalCatalog.parallelListingJobCount": (
COUNTER,
"counters",
"count"
),
"HiveExternalCatalog.partitionsFetched": (
COUNTER,
"counters",
"count"
)
}
SPARK_JOB_METRICS = {
"numTasks": (GAUGE, "spark.job.num_tasks"),
"numActiveTasks": (GAUGE, "spark.job.num_active_tasks"),
"numCompletedTasks": (GAUGE, "spark.job.num_completed_tasks"),
"numSkippedTasks": (GAUGE, "spark.job.num_skipped_tasks"),
"numFailedTasks": (GAUGE, "spark.job.num_failed_tasks"),
"numActiveStages": (GAUGE, "spark.job.num_active_stages"),
"numCompletedStages": (GAUGE, "spark.job.num_completed_stages"),
"numSkippedStages": (GAUGE, "spark.job.num_skipped_stages"),
"numFailedStages": (GAUGE, "spark.job.num_failed_stages")
}
SPARK_STAGE_METRICS = {
"executorRunTime": (GAUGE, "spark.stage.executor_run_time"),
"inputBytes": (GAUGE, "spark.stage.input_bytes"),
"inputRecords": (GAUGE, "spark.stage.input_records"),
"outputBytes": (GAUGE, "spark.stage.output_bytes"),
"outputRecords": (GAUGE, "spark.stage.output_records"),
"memoryBytesSpilled": (GAUGE, "spark.stage.memory_bytes_spilled"),
"diskBytesSpilled": (GAUGE, "spark.stage.disk_bytes_spilled")
}
SPARK_STAGE_METRICS_ENHANCED = {
"shuffleReadBytes": (GAUGE, "spark.stage.shuffle_read_bytes"),
"shuffleReadRecords": (GAUGE, "spark.stage.shuffle_read_records"),
"shuffleWriteBytes": (GAUGE, "spark.stage.shuffle_write_bytes"),
"shuffleWriteRecords": (GAUGE, "spark.stage.shuffle_write_records"),
}
SPARK_DRIVER_METRICS = {
"memoryUsed": (COUNTER, "spark.driver.memory_used"),
"diskUsed": (COUNTER, "spark.driver.disk_used"),
"totalInputBytes": (COUNTER, "spark.driver.total_input_bytes"),
"totalShuffleRead": (COUNTER, "spark.driver.total_shuffle_read"),
"totalShuffleWrite": (COUNTER, "spark.driver.total_shuffle_write"),
"totalTasks": (COUNTER, "spark.driver.total_tasks"),
"maxMemory": (GAUGE, "spark.driver.max_memory")
}
SPARK_DRIVER_METRICS_ENHANCED = {
"rddBlocks": (GAUGE, "spark.driver.rdd_blocks"),
"activeTasks": (GAUGE, "spark.driver.active_tasks"),
"failedTasks": (COUNTER, "spark.driver.failed_tasks"),
"completedTasks": (COUNTER, "spark.driver.completed_tasks"),
"totalDuration": (COUNTER, "spark.driver.total_duration")
}
SPARK_EXECUTOR_METRICS = {
"memoryUsed": (COUNTER, "spark.executor.memory_used"),
"diskUsed": (COUNTER, "spark.executor.disk_used"),
"totalInputBytes": (COUNTER, "spark.executor.total_input_bytes"),
"totalShuffleRead": (COUNTER, "spark.executor.total_shuffle_read"),
"totalShuffleWrite": (COUNTER, "spark.executor.total_shuffle_write"),
"maxMemory": (GAUGE, "spark.executor.max_memory")
}
SPARK_EXECUTOR_METRICS_ENHANCED = {
"rddBlocks": (GAUGE, "spark.executor.rdd_blocks"),
"activeTasks": (GAUGE, "spark.executor.active_tasks"),
"failedTasks": (COUNTER, "spark.executor.failed_tasks"),
"completedTasks": (COUNTER, "spark.executor.completed_tasks"),
"totalTasks": (COUNTER, "spark.executor.total_tasks"),
"totalDuration": (COUNTER, "spark.executor.total_duration")
}
SPARK_STREAMING_METRICS = {
"avgInputRate": (GAUGE, "spark.streaming.avg_input_rate"),
"numTotalCompletedBatches":
(COUNTER, "spark.streaming.num_total_completed_batches"),
"numActiveBatches": (GAUGE, "spark.streaming.num_active_batches"),
"numInactiveReceivers": (GAUGE, "spark.streaming.num_inactive_receivers"),
"numReceivedRecords": (COUNTER, "spark.streaming.num_received_records"),
"numProcessedRecords": (COUNTER, "spark.streaming.num_processed_records"),
"avgProcessingTime": (GAUGE, "spark.streaming.avg_processing_time"),
"avgSchedulingDelay": (GAUGE, "spark.streaming.avg_scheduling_delay"),
"avgTotalDelay": (GAUGE, "spark.streaming.avg_total_delay")
}
| 2.203125 | 2 |
setup.py | petejh/catclass | 0 | 12789143 | <reponame>petejh/catclass<gh_stars>0
from setuptools import setup
setup(
name = 'cat-class',
version = '0.1.0',
description = ('An image classifier employing a deep neural network '
'to identify pictures of cats.'),
url = 'https://github.com/petejh/cat-class',
author = '<NAME>',
author_email = '<EMAIL>',
license = 'MIT',
packages = ['catclass'],
python_requires = '',
install_requires = ['deepen', 'h5py', 'numpy'],
zip_safe = False
)
| 1.539063 | 2 |
tests/test_quadrature/test_quadrature.py | AI-Pranto/OpenMOC | 97 | 12789144 | <reponame>AI-Pranto/OpenMOC<gh_stars>10-100
#!/usr/bin/env python
import os
import sys
import math
sys.path.insert(0, os.pardir)
sys.path.insert(0, os.path.join(os.pardir, 'openmoc'))
from testing_harness import TestHarness
from input_set import LatticeGridInput
import openmoc
class QuadratureTestHarness(TestHarness):
"""Tests tracking over a lattice geometry."""
def __init__(self):
super(QuadratureTestHarness, self).__init__()
self.quadratures = list()
quadratures = openmoc.Quadrature.__subclasses__()
for quadrature in quadratures:
self.quadratures.append(quadrature())
self._result = ''
def _setup(self):
return
def _run_openmoc(self):
"""Segment tracks over the geometry and save the result to a string"""
# Segmentize tracks over the geometry
for azim in [4, 8, 16, 32, 64]:
for polar in [4, 6]:
for quad in self.quadratures:
sum_weights = 0
int_sine = 0
quad.setNumAzimAngles(azim)
quad.setNumPolarAngles(polar)
quad.initialize()
for a in range(int(azim/4)):
quad.setAzimSpacing(1.0, a)
quad.precomputeWeights(False)
for a in range(int(azim/2)):
for p in range(polar):
sum_weights += quad.getWeight(a, p) / \
math.sin(quad.getTheta(a, p))
int_sine += quad.getWeight(a, p)
if abs(sum_weights - 4 * math.pi) > 0.005:
self._result += 'Calculated ' + str(sum_weights) + \
' for sum of weights for ' + type(quad).__name__\
+ ' with ' + str(azim) + ' azimuthal angles and '\
+ str(polar) + ' which exceeds tolerance of 0.005'\
' from 4 PI\n'
if abs(int_sine - 9.8696) > 0.5:
self._result += 'Calculated ' + str(int_sine)\
+ ' for the integral of sine for '\
+ type(quad).__name__ + ' with ' + str(azim)\
+ ' azimuthal angles and ' + str(polar)\
+ ' which exceeds tolerance of 0.5 from 9.8696\n'
if (self._result == ''):
self._result += 'All Quadrature sets correctly summed their ' \
'weights to 4 PI with tolerance 0.005 and calculated the ' \
'integral of sine as 9.8696 with tolerance 0.5'
def _get_results(self, num_iters=False, keff=False, fluxes=False,
num_fsrs=True, num_segments=True, num_tracks=True,
hash_output=False):
"""Return the result string"""
return self._result
if __name__ == '__main__':
harness = QuadratureTestHarness()
harness.main()
| 2.28125 | 2 |
2014-2015/2-jan2015/p2/CowRouting2.py | esqu1/USACO | 0 | 12789145 | <reponame>esqu1/USACO<gh_stars>0
#########
# USACO CONTEST 1 PROBLEM 2
# SOLUTION BY <NAME>
# PYTHON 2.7.6
#########
import sys
def readin():
f = open("cowroute.in",'r')
s = f.read().split("\n")
f.close()
return s
def find(list,el):
if el in list:
return list.index(el)
else:
return -1
l = readin()
min = sys.maxint
firstline = l[0].split()
count = 2
count = 2
while count < len(l):
if int(l[count - 1].split()[0]) < min and find(l[count].split(),firstline[0]) != -1 and find(l[count].split(),firstline[1]) != -1 and find(l[count].split(),firstline[0]) < find(l[count].split(),firstline[1]): # Same code from Cow Routing 1
min = int(l[count - 1].split()[0])
count += 2
count = 2
while count < len(l):
inc = 2
while inc < len(l) - count:
if find(l[count].split(),firstline[0]) == -1 and find(l[count].split(),firstline[1]) == -1: # Break if neither of them has the cities
break;
count2 = count + inc
if find(l[count].split(),firstline[0]) != -1: # If we can find first city in first line
listofone = l[count].split()[find(l[count].split(),firstline[0]):] # Make a list of everything afterwards
if find(l[count2].split(),firstline[1]) != -1: # If we can find second city in second line
listoftwo = l[count2].split()[:find(l[count2].split(),firstline[1])] # make a list of everything beforehand
print listofone
print listoftwo
if len([i for i in listofone if i in listoftwo]) > 0 and int(l[count-1].split()[0]) + int(l[count2-1].split()[0]) < min:
min = int(l[count-1].split()[0]) + int(l[count2-1].split()[0]) # If we find a common city, make this the new min
print min
if find(l[count2].split(),firstline[0]) != -1: # Likewise
listofone = l[count2].split()[:find(l[count2].split(),firstline[0])]
if find(l[count].split(),firstline[1]) != -1:
listoftwo = l[count].split()[find(l[count].split(),firstline[1]):]
print listofone
print listoftwo
if len([i for i in listofone if i in listoftwo]) > 0 and int(l[count-1].split()[0]) + int(l[count2-1].split()[0]) < min:
min = int(l[count-1].split()[0]) + int(l[count2-1].split()[0])
print min
inc += 2
count += 2
if min == sys.maxint:
min = -1
g = open("cowroute.out",'w')
g.write(str(min) + "\n")
g.close()
| 2.984375 | 3 |
62.py | r9y9/nlp100 | 18 | 12789146 | <filename>62.py
import plyvel
from tqdm import tqdm
db = plyvel.DB("artist.ldb", create_if_missing=False)
r = []
for k, v in tqdm(db):
if v == b"Japan":
r.append(k.decode("utf-8"))
for k in r:
print(k)
print("Total: {}".format(len(r)))
| 2.5 | 2 |
terrascript/provider/hashicorp/googleworkspace.py | mjuenema/python-terrascript | 507 | 12789147 | # terrascript/provider/hashicorp/googleworkspace.py
# Automatically generated by tools/makecode.py (24-Sep-2021 15:17:22 UTC)
import terrascript
class googleworkspace(terrascript.Provider):
"""terraform-provider-googleworkspace"""
__description__ = "terraform-provider-googleworkspace"
__namespace__ = "hashicorp"
__name__ = "googleworkspace"
__source__ = "https://github.com/hashicorp/terraform-provider-googleworkspace"
__version__ = "0.4.1"
__published__ = "2021-08-16T19:18:13Z"
__tier__ = "official"
__all__ = ["googleworkspace"]
| 1.53125 | 2 |
misc_files/GPSVehicle.py | twardokus/v2verifier | 9 | 12789148 | <gh_stars>1-10
import math
import json
import time
import subprocess
import pynmea2
from txrx import Utility
from WavePacketBuilder import WAVEPacketBuilder
class GPSVehicle:
def __init__(self, vehicle_num, gps_sock, gui_sock, gui_lock):
self.vehicle_num = vehicle_num
self.gps_sock = gps_sock
self.sock = gui_sock
self.lock = gui_lock
self.wave_builder = WAVEPacketBuilder()
self.util = Utility()
self.key = "keys/0/p256.key"
def start(self):
last_nmea = pynmea2.parse("$GPGGA,000000.00,0000.0000,N,00000.0000,E,0,99,1.0,0.0,M,0.0,M,,*5C")
while True:
gps_loc = self.gps_sock.recv(1024)
nmea = pynmea2.parse(gps_loc.split(b":")[1].decode().replace("GPS_GPGGA", "").strip())
print(nmea)
lat = float(nmea.latitude)
lon = float(nmea.longitidue)
last_lat = float(last_nmea.latitude)
last_lon = float(last_nmea.longitude)
speed = (
math.sqrt(math.pow(lat - last_lat, 2) + math.pow(lon - last_lon, 2))
* 36
)
heading = self.get_heading(nmea, last_nmea)
bsm_text = f"{self.vehicle_num},{nmea.latitude},{nmea.longitude},{heading},{speed}\n"
message = self.build_packet(nmea.latitude, nmea.longitude, heading, speed, self.key)
last_nmea = nmea
self.send_to_radio(message)
self.send_to_gui(bsm_text)
def get_heading(self, nmea, last_nmea):
if nmea.longitude == last_nmea.longitude:
# no change
if nmea.latitude == last_nmea.latitude:
return "-"
# heading North
elif nmea.latitude > last_nmea.latitude:
return N
# heading South
else:
return "S"
# heading East
elif nmea.longitude > last_nmea.longitude:
if nmea.latitude > last_nmea.latitude:
return "NE"
elif nmea.latitude < last_nmea.latitude:
return "SE"
else:
return "E"
# heading West
else:
if nmea.latitude > last_nmea.latitude:
return "NW"
elif nmea.latitude < last_nmea.latitude:
return "SW"
else:
return "W"
def build_packet(self, lat, lng, heading, speed, key):
speed = str(round(speed, 2))
bsm_text = f"{self.vehicle_num},{nmea.latitude},{nmea.longitude},{heading},{speed}\n"
return self.wave_builder.get_wsm_payload(bsm_text, key)
def send_to_radio(self, message):
print("Sending BSM to radio")
bsm = self.util.inject_time(message)
loader = subprocess.Popen(("echo", "-n", "-e", bsm), stdout=subprocess.PIPE)
sender = subprocess.check_output(
("nc", "-w0", "-u", "localhost", "52001"), stdin=loader.stdout
)
def send_to_gui(self, message):
bsm = message.split(",")
decoded_data = {}
decoded_data['id'] = bsm[0]
decoded_data['x'] = bsm[1]
decoded_data['y'] = bsm[2]
decoded_data['heading'] = bsm[3]
decoded_data['speed'] = bsm[4]
decoded_data['sig'] = True
decoded_data['elapsed'] = 0
decoded_data['recent'] = True
decoded_data['receiver'] = True
vehicle_data_json = json.dumps(decoded_data)
with self.lock:
self.sock.send(vehicle_data_json.encode())
| 2.65625 | 3 |
networkmonitor/src/configuration/contextConfig.py | luther38/NetworkMonitor | 0 | 12789149 | <reponame>luther38/NetworkMonitor
import os
from networkmonitor.src.configuration import IConfig, YamlConfig, JsonConfig
from networkmonitor.src.collections import Configuration
class ContextConfig:
"""
ConfigContext is the handler for the IConfig and tells the process who needs to do what.
Methods are the same as IConfig
"""
def __init__(self, config: IConfig):
self.config:IConfig = config
self.type:str = self.__GetConfigType__()
self.configuration = Configuration()
#self.SleepInterval:int = -1
#self.Nodes:Nodes = []
pass
def __GetConfigType__(self):
# Did we get our IConfig on its own?
try:
if self.config.argPathConfig.endswith('yaml'):
return 'yaml'
elif self.config.argPathConfig.endswith('json'):
return 'json'
else:
return None
except:
pass
# it came in with another class attached.
# Looks like it should be YamlConfig or JsonConfig then IConfig
try:
if self.config.config.PathConfig.endswith('yaml'):
return 'yaml'
elif self.config.config.PathConfig.endswith('json'):
return 'json'
else:
return None
except:
pass
def GetWorkingConfigClass(self, replaceConfig:bool = False):
"""
This is used to generate a working class based off the config type.
If we know the type and have a class we can use, make a new instance and return it.
Currently returns YamlConfig or JsonConfig.
@param:replaceConfig = If True it will take the generated class and place it in self.config. If False, return value.
"""
if self.type == "yaml":
c = YamlConfig(self.config)
return self.__ReplaceWorkingConfig(replaceConfig, c)
elif self.type == "json":
j = JsonConfig(self.config)
return self.__ReplaceWorkingConfig(replaceConfig, j)
else:
pass
def __ReplaceWorkingConfig(self, replaceConfig:bool, passedClass):
if replaceConfig == True:
self.config = passedClass
else:
return passedClass
def ReadConfig(self):
self.configuration.nodes = []
self.config.ReadConfig()
self.configuration = self.config.configuration
#self.configuration.nodes = self.config.nodes
#self.configuration.sleepInterval = self.config.sleepInterval
#self.Nodes = self.config.config.Nodes
#self.SleepInterval = self.config.config.SleepInterval
pass
def NewConfig(self):
"""
Handler for NewConfig requests.
"""
default = {
"SleepInterval":{
"Hours": 0,
"Minutes": 2,
"Seconds": 0
},
"Protocols":{
"ICMP":{
"Timeout":0
}
},
'Nodes': [
{
'Name':'LocalHost',
'Address': '192.168.127.12',
'Protocol': 'ICMP',
'Required': True,
'Category': "local"
},
{
'Name' : 'Wan',
'Address' : '192.168.0.1',
'Protocol' : 'ICMP',
'Required' : True,
'Category' : "Local"
},
{
'Name' : 'Google',
'Address' : 'google.com',
'Protocol' : 'ICMP',
'Required' : False,
'Category' : "External"
},
{
'Name' : 'Google',
'Address' : 'https://google.com',
'Protocol' : 'Http:Get',
'Required' : False,
'Category' : "External"
}
]
}
self.config.NewConfig(default)
pass
| 2.890625 | 3 |
roles/openshift_health_checker/test/curator_test.py | KoteikinyDrova/openshift-ansible | 1 | 12789150 | import pytest
from openshift_checks.logging.curator import Curator
def canned_curator(exec_oc=None):
"""Create a Curator check object with canned exec_oc method"""
check = Curator("dummy") # fails if a module is actually invoked
if exec_oc:
check._exec_oc = exec_oc
return check
def assert_error(error, expect_error):
if expect_error:
assert error
assert expect_error in error
else:
assert not error
plain_curator_pod = {
"metadata": {
"labels": {"component": "curator", "deploymentconfig": "logging-curator"},
"name": "logging-curator-1",
},
"status": {
"containerStatuses": [{"ready": True}],
"conditions": [{"status": "True", "type": "Ready"}],
"podIP": "10.10.10.10",
}
}
not_running_curator_pod = {
"metadata": {
"labels": {"component": "curator", "deploymentconfig": "logging-curator"},
"name": "logging-curator-2",
},
"status": {
"containerStatuses": [{"ready": False}],
"conditions": [{"status": "False", "type": "Ready"}],
"podIP": "10.10.10.10",
}
}
@pytest.mark.parametrize('pods, expect_error', [
(
[],
"no Curator pods",
),
(
[plain_curator_pod],
None,
),
(
[not_running_curator_pod],
"not currently in a running state",
),
(
[plain_curator_pod, plain_curator_pod],
"more than one Curator pod",
),
])
def test_get_curator_pods(pods, expect_error):
check = canned_curator()
error = check.check_curator(pods)
assert_error(error, expect_error)
| 2.234375 | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.