Datasets:

kaizen9

/

starcoder_python_HQ

like 0

Scripts/VRM_DeleteLeafBones.py

TheHoodieGuy02/VRoid2UE4_BlenderScripts

12797355

# Obliterate unused leaf bones in VRoid models! import bpy context = bpy.context obj = context.object # By default, VRM Importer includes leaf bones automatically. # It's cool and stuff, but it's not necessary for Blender, and will spew out # scary long warning when imported to UE4. # Use this script to obliterate those leaf bones in one click. if obj.type == 'ARMATURE': armature = obj.data bpy.ops.object.mode_set(mode='EDIT') for bone in armature.edit_bones: if bone.name.endswith("_end") : armature.edit_bones.remove(bone) else: continue bpy.ops.object.mode_set(mode='OBJECT')

proteinham/lattice/turn_circuit.py

couteiral/proteinham

12797483

<filename>proteinham/lattice/turn_circuit.py import math import numpy as np import sympy as sp import symengine as se from abc import * from tqdm import tqdm, trange from copy import deepcopy from itertools import chain from functools import reduce from .qlogic import * from proteinham.core.hamiltonian import Hamiltonian class CommonTurnCircuitHamiltonian(Hamiltonian): is_TurnCircuit = True def __init__(self, pepstring, ss_fmat='babej'): """Encapsulates the expression and methods of a protein hamiltonian of the "turn circuit encoding" form, described by Babbush et al., 2012.""" self._proc_input(pepstring) self.ss_fmat = ss_fmat self.n_bits = self.dim * (self.naas-1) self._sum_strings = dict() self._create_bitreg() @property def encoding(self): return 'turn_circuit' def build_exp(self): self.expr = (self.naas+1) * self.back_term() if self.dim == 3: self.expr += (self.naas+1)**2 * self.redun_term() self.expr += (self.naas+1) * self.steric_term() self.expr += self.interaction_term() #self.expr = se.expand(self.expr) self.n_terms = len(self.expr.args) def get(self, k): """Access the kth bit of the hamiltonian.""" return self.bit_list[k] def half_adder(self, q_i, q_j): """Applies a half-adder.""" return qand([q_i, q_j]), qxor(q_i, q_j) @property @abstractmethod def dim(self): pass class TurnCircuitHamiltonian2D(CommonTurnCircuitHamiltonian): is_2D = True @property def dim(self): return 2 def pointer(self, i): """Points to the start of the string describing the ith turn.""" return 2*i def circuit_xp(self, q_i, q_j): """Implements a circuit that returns 1 if the chain moves in the direction x+.""" return (1-q_i)*q_j def circuit_xn(self, q_i, q_j): """Implements a circuit that returns 1 if the chain moves in the direction x-.""" return q_i*(1-q_j) def circuit_yp(self, q_i, q_j): """Implements a circuit that returns 1 if the chain moves in the direction y+.""" return q_i*q_j def circuit_yn(self, q_i, q_j): """Implements a circuit that returns 1 if the chain moves in the direction y-.""" return (1-q_i)*(1-q_j) def sum_string(self, i, j, k): """Computes the sum string.""" if i > j: raise ValueError("i > j") if (i, j, k) in self._sum_strings.keys(): return self._sum_strings[(i, j, k)] if k == 'x+': sum_string = [self.circuit_xp(self.get(self.pointer(t)), self.get(self.pointer(t)+1)) for t in range(i, j)] elif k == 'x-': sum_string = [self.circuit_xn(self.get(self.pointer(t)), self.get(self.pointer(t)+1)) for t in range(i, j)] elif k == 'y+': sum_string = [self.circuit_yp(self.get(self.pointer(t)), self.get(self.pointer(t)+1)) for t in range(i, j)] elif k == 'y-': sum_string = [self.circuit_yn(self.get(self.pointer(t)), self.get(self.pointer(t)+1)) for t in range(i, j)] else: raise ValueError('k was {:s}'.format(k)) n_layers = j-i-1 counter = np.zeros(n_layers) # lazy way to keep track of half-adders sum_string = list(reversed(sum_string)) for t in chain(range(n_layers), reversed(range(n_layers-1))): if t % 2 == 0: iterator = range(0, t+1, 2) if t > 0 else [0] else: iterator = range(1, t+1, 2) if t > 1 else [1] for h in iterator: if self.ss_fmat == 'babej': if counter[h] > math.log2(j-i): continue else: counter[h] += 1 a, b = self.half_adder(sum_string[h], sum_string[h+1]) sum_string[h] = a sum_string[h+1] = b maximum = int(math.ceil(math.log2(j-i))) sum_string = list(reversed(sum_string)) self._sum_strings[(i, j, k)] = [sp.expand(sum_string[x]) for x in range(maximum)] return self._sum_strings[(i, j, k)] def back_term(self): """Ensures that the chain does not go back on itself.""" return sum([ self.circuit_xp(self.get(self.pointer(i)), self.get(self.pointer(i)+1)) * self.circuit_xn(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1)) + \ self.circuit_xn(self.get(self.pointer(i)), self.get(self.pointer(i)+1)) * self.circuit_xp(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1)) + \ self.circuit_yp(self.get(self.pointer(i)), self.get(self.pointer(i)+1)) * self.circuit_yn(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1)) + \ self.circuit_yn(self.get(self.pointer(i)), self.get(self.pointer(i)+1)) * self.circuit_yp(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1)) for i in range(self.naas-2)]) def overlap(self, i, j): """Computes the overlap term for residues i and j.""" maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j != 0 else 0 if (j-i) % 2 != 0 or maximum < 2: return sp.numbers.Integer(0) sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-') } return qand( [qxnor(sumstring['x+'][r], sumstring['x-'][r]) for r in range(maximum)] + \ [qxnor(sumstring['y+'][r], sumstring['y-'][r]) for r in range(maximum)] ) def steric_term(self): """Ensures that the chain does not overlap.""" return sum([ sum([ self.overlap(i, j) for j in range(i+1, self.naas)]) for i in range(self.naas)]) def a_x(self, i, j): sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-') } maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j !=0 else 0 if maximum == 0: return 0 prefactor = qand([ qxnor(sumstring['y+'][r], sumstring['y-'][r]) for r in range(maximum)]) return prefactor * \ ( qxor(sumstring['x+'][0], sumstring['x-'][0]) \ * qand([ qxnor(sumstring['x+'][r], sumstring['x-'][r]) for r in range(1, maximum)]) \ + sum([ qxor(sumstring['x+'][p-2], sumstring['x+'][p-1]) \ * qand([ qxnor(sumstring['x+'][r-1], sumstring['x+'][r]) for r in range(1, p-1)]) \ * qand([ qxor(sumstring['x+'][r-1], sumstring['x-'][r-1]) for r in range(1, p+1)]) \ * qand([ qxnor(sumstring['x+'][r-1], sumstring['x-'][r-1]) for r in range(p+1, maximum+1)]) for p in range(2, maximum+1)])) def a_y(self, i, j): sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-') } maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j != 0 else 0 if maximum == 0: return 0 prefactor = qand([ qxnor(sumstring['x+'][r], sumstring['x-'][r]) for r in range(maximum)]) return prefactor *\ ( qxor(sumstring['y+'][0], sumstring['y-'][0]) \ * qand([ qxnor(sumstring['y+'][r], sumstring['y-'][r]) for r in range(1, maximum)]) \ + sum([ qxor(sumstring['y+'][p-2], sumstring['y+'][p-1]) \ * qand([ qxnor(sumstring['y+'][r-1], sumstring['y+'][r]) for r in range(1, p-1)]) \ * qand([ qxor(sumstring['y+'][r-1], sumstring['y-'][r-1]) for r in range(1, p+1)]) \ * qand([ qxnor(sumstring['y+'][r-1], sumstring['y-'][r-1]) for r in range(p+1, maximum+1)]) for p in range(2, maximum+1)])) def interaction_term_ij(self, i, j): return -1 * self.int_mat[i, j] * (self.a_x(i, j) + \ self.a_y(i, j)) def interaction_term(self): """Computes contacts between residues.""" expr = sp.numbers.Integer(0) for i in range(self.naas-3): for j in range(1, math.ceil((self.naas-i-1)/2)): if self.int_mat[i, 1+i+2*j] == 0: continue expr += self.interaction_term_ij(i, 1+i+2*j) return expr class TurnCircuitHamiltonian3D(CommonTurnCircuitHamiltonian): is_3D = True @property def dim(self): return 3 def pointer(self, i): """Points to the start of the string describing the ith turn.""" return 3*i def circuit_xp(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction x+.""" return q_i * q_j * q_k def circuit_xn(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction x-.""" return q_i * (1-q_j) * (1-q_k) def circuit_yp(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction y+.""" return q_i * (1-q_j) * q_k def circuit_yn(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction y-.""" return q_i * q_j * (1-q_k) def circuit_zp(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction z+.""" return (1-q_i) * (1-q_j) * q_k def circuit_zn(self, q_i, q_j, q_k): """Implements a circuit that returns 1 if the chain moves in the direction z-.""" return (1-q_i) * q_j * (1-q_k) def circuit_000(self, q_i, q_j, q_k): """Implements a circuit that checks the nonsensical string 000.""" return (1-q_i) * (1-q_j) * (1-q_k) def circuit_011(self, q_i, q_j, q_k): """Implements a circuit that checks the nonsensical string 000.""" return (1-q_i) * q_j * q_k def sum_string(self, i, j, k): """Computes the sum string.""" if i > j: raise ValueError("i > j") if (i, j, k) in self._sum_strings.keys(): return self._sum_strings[(i, j, k)] if k == 'x+': sum_string = [self.circuit_xp(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] elif k == 'x-': sum_string = [self.circuit_xn(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] elif k == 'y+': sum_string = [self.circuit_yp(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] elif k == 'y-': sum_string = [self.circuit_yn(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] elif k == 'z+': sum_string = [self.circuit_zp(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] elif k == 'z-': sum_string = [self.circuit_zn(self.get(self.pointer(t)), self.get(self.pointer(t)+1), self.get(self.pointer(t)+2)) for t in range(i, j)] else: raise ValueError('k was {:s}'.format(k)) n_layers = j-i-1 counter = np.zeros(n_layers) # lazy way to keep track of half-adders sum_string = list(reversed(sum_string)) for t in chain(range(n_layers), reversed(range(n_layers-1))): if t % 2 == 0: iterator = range(0, t+1, 2) if t > 0 else [0] else: iterator = range(1, t+1, 2) if t > 1 else [1] for h in iterator: if self.ss_fmat == 'babej': if counter[h] > math.log2(j-i): continue else: counter[h] += 1 a, b = self.half_adder(sum_string[h], sum_string[h+1]) sum_string[h] = a sum_string[h+1] = b maximum = int(math.ceil(math.log2(j-i))) sum_string = list(reversed(sum_string)) self._sum_strings[(i, j, k)] = [sp.expand(sum_string[x]) for x in range(maximum)] return self._sum_strings[(i, j, k)] def redun_term(self): """Implements the term that penalises meaningless residue bitstrings 000 and 011.""" return sum([ self.circuit_000(self.get(self.pointer(k)), self.get(self.pointer(k)+1), self.get(self.pointer(k)+2)) + \ self.circuit_011(self.get(self.pointer(k)), self.get(self.pointer(k)+1), self.get(self.pointer(k)+2)) for k in range(self.naas-1)]) def back_term(self): """Ensures that the chain does not go back on itself.""" return sum([ self.circuit_xp(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_xn(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) + \ self.circuit_xn(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_xp(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) + \ self.circuit_yp(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_yn(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) + \ self.circuit_yn(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_yp(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) + \ self.circuit_zp(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_zn(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) + \ self.circuit_zn(self.get(self.pointer(i)), self.get(self.pointer(i)+1), self.get(self.pointer(i)+2)) * self.circuit_zp(self.get(self.pointer(i+1)), self.get(self.pointer(i+1)+1), self.get(self.pointer(i+1)+2)) for i in range(self.naas-2)]) def overlap(self, i, j): """Computes the overlap term for residues i and j.""" maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j != 0 else 0 if (j-i) % 2 != 0 or maximum < 2: return sp.numbers.Integer(0) sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-'), 'z+': self.sum_string(i, j, 'z+'), 'z-': self.sum_string(i, j, 'z-'), } return qand( [qxnor(sumstring['x+'][r], sumstring['x-'][r]) for r in range(maximum)] + \ [qxnor(sumstring['y+'][r], sumstring['y-'][r]) for r in range(maximum)] + \ [qxnor(sumstring['z+'][r], sumstring['z-'][r]) for r in range(maximum)] ) def steric_term(self): """Ensures that the chain does not overlap.""" return sum([ sum([ self.overlap(i, j) for j in range(i+1, self.naas)]) for i in range(self.naas)]) def a_x(self, i, j): sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-'), 'z+': self.sum_string(i, j, 'z+'), 'z-': self.sum_string(i, j, 'z-') } maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j !=0 else 0 if maximum == 0: return 0 prefactor = qand([ qand([ qxnor(sumstring['%s+' % k][r], sumstring['%s-' % k][r]) for r in range(maximum)]) for k in ['y', 'z']]) return prefactor * \ ( qxor(sumstring['x+'][0], sumstring['x-'][0]) \ * qand([ qxnor(sumstring['x+'][r], sumstring['x-'][r]) for r in range(1, maximum)]) \ + sum([ qxor(sumstring['x+'][p-2], sumstring['x+'][p-1]) \ * qand([ qxnor(sumstring['x+'][r-1], sumstring['x+'][r]) for r in range(1, p-1)]) \ * qand([ qxor(sumstring['x+'][r-1], sumstring['x-'][r-1]) for r in range(1, p+1)]) \ * qand([ qxnor(sumstring['x+'][r-1], sumstring['x-'][r-1]) for r in range(p+1, maximum+1)]) for p in range(2, maximum+1)])) def a_y(self, i, j): sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-'), 'z+': self.sum_string(i, j, 'z+'), 'z-': self.sum_string(i, j, 'z-') } maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j !=0 else 0 if maximum == 0: return 0 prefactor = qand([ qand([ qxnor(sumstring['%s+' % k][r], sumstring['%s-' % k][r]) for r in range(maximum)]) for k in ['x', 'z']]) return prefactor * \ ( qxor(sumstring['y+'][0], sumstring['y-'][0]) \ * qand([ qxnor(sumstring['y+'][r], sumstring['y-'][r]) for r in range(1, maximum)]) \ + sum([ qxor(sumstring['y+'][p-2], sumstring['y+'][p-1]) \ * qand([ qxnor(sumstring['y+'][r-1], sumstring['y+'][r]) for r in range(1, p-1)]) \ * qand([ qxor(sumstring['y+'][r-1], sumstring['y-'][r-1]) for r in range(1, p+1)]) \ * qand([ qxnor(sumstring['y+'][r-1], sumstring['y-'][r-1]) for r in range(p+1, maximum+1)]) for p in range(2, maximum+1)])) def a_z(self, i, j): sumstring = { 'x+': self.sum_string(i, j, 'x+'), 'x-': self.sum_string(i, j, 'x-'), 'y+': self.sum_string(i, j, 'y+'), 'y-': self.sum_string(i, j, 'y-'), 'z+': self.sum_string(i, j, 'z+'), 'z-': self.sum_string(i, j, 'z-') } maximum = int(math.ceil(math.log2(abs(i-j)))) if i-j !=0 else 0 if maximum == 0: return 0 prefactor = qand([ qand([ qxnor(sumstring['%s+' % k][r], sumstring['%s-' % k][r]) for r in range(maximum)]) for k in ['x', 'y']]) return prefactor * \ ( qxor(sumstring['z+'][0], sumstring['z-'][0]) \ * qand([ qxnor(sumstring['z+'][r], sumstring['z-'][r]) for r in range(1, maximum)]) \ + sum([ qxor(sumstring['z+'][p-2], sumstring['z+'][p-1]) \ * qand([ qxnor(sumstring['z+'][r-1], sumstring['z+'][r]) for r in range(1, p-1)]) \ * qand([ qxor(sumstring['z+'][r-1], sumstring['z-'][r-1]) for r in range(1, p+1)]) \ * qand([ qxnor(sumstring['z+'][r-1], sumstring['z-'][r-1]) for r in range(p+1, maximum+1)]) for p in range(2, maximum+1)])) def interaction_term_ij(self, i, j): return -1* self.int_mat[i, j] * (self.a_x(i, j) + \ self.a_y(i, j) + \ self.a_z(i, j)) def interaction_term(self): """Computes contacts between residues.""" expr = sp.numbers.Integer(0) for i in range(self.naas-3): for j in range(1, math.ceil((self.naas-i-1)/2)): if self.int_mat[i, 1+i+2*j] == 0: continue expr += interaction_term_ij(i, 1+i+2*j) return expr

django/website/wagtail_vue/apps/pages/models.py

hyshka/wagtail-vue-talk

12797611

<reponame>hyshka/wagtail-vue-talk # -*- coding: utf-8 -*- """Page models.""" from django.db import models from wagtail.admin.edit_handlers import FieldPanel, StreamFieldPanel from wagtail.images.edit_handlers import ImageChooserPanel from wagtail.core.models import Page from wagtail.api import APIField from wagtail.images.api.fields import ImageRenditionField from wagtail.core.fields import StreamField from .streamfields import ContentBlock, ImageGalleryBlock, CallToActionBlock class HomePage(Page): """A home page class.""" template = "cms/pages/home_page.html" subpage_types = ['pages.FlexPage'] banner_subtitle = models.CharField( max_length=50, blank=True, null=True, help_text="An optional banner subtitle" ) banner_image = models.ForeignKey( "wagtailimages.Image", null=True, blank=False, on_delete=models.SET_NULL, related_name="+", help_text="An optional banner image", ) content = StreamField([ ('ContentBlock', ContentBlock()), ('ImageGalleryBlock', ImageGalleryBlock()), ('CallToActionBlock', CallToActionBlock()), ], null=True, blank=True) content_panels = [ FieldPanel("title", classname="full title"), ImageChooserPanel("banner_image"), FieldPanel("banner_subtitle"), StreamFieldPanel('content'), ] api_fields = [ APIField("title"), APIField("banner_subtitle"), APIField("banner_image"), APIField("banner_image_thumbnail", serializer=ImageRenditionField("fill-100x100", source="banner_image")), APIField("content"), ] class Meta: """Meta information.""" verbose_name = "Home Page" verbose_name_plural = "Home Pages" class FlexPage(Page): """A Flexible page class. Used for generic pages that don't have a true purpose.""" template = "cms/pages/flex_page.html" subpage_types = [] content = StreamField([ ('ContentBlock', ContentBlock()), ('ImageGalleryBlock', ImageGalleryBlock()), ('CallToActionBlock', CallToActionBlock()), ], null=True, blank=True) content_panels = [ FieldPanel("title", classname="full title"), StreamFieldPanel('content'), ] api_fields = [ APIField("title"), APIField("content"), ] class Meta: """Meta information.""" verbose_name = "Flex Page" verbose_name_plural = "Flex Pages"

easyai/train_task.py

lpj0822/image_point_cloud_det

12797739

<reponame>lpj0822/image_point_cloud_det<gh_stars>1-10 #!/usr/bin/env python # -*- coding:utf-8 -*- # Author: from easyai.helper.arguments_parse import TaskArgumentsParse from easyai.tasks.cls.classify_train import ClassifyTrain from easyai.tasks.det2d.detect2d_train import Detection2dTrain from easyai.tasks.seg.segment_train import SegmentionTrain from easyai.tasks.pc_cls.pc_classify_train import PointCloudClassifyTrain from easyai.tools.model_to_onnx import ModelConverter from easyai.base_name.task_name import TaskName class TrainTask(): def __init__(self, train_path, val_path, pretrain_model_path, is_convert=False): self.train_path = train_path self.val_path = val_path self.pretrain_model_path = pretrain_model_path self.is_convert = is_convert def classify_train(self, cfg_path, gpu_id, config_path): cls_train_task = ClassifyTrain(cfg_path, gpu_id, config_path) cls_train_task.load_pretrain_model(self.pretrain_model_path) cls_train_task.train(self.train_path, self.val_path) self.image_model_convert(cls_train_task, cfg_path) def detect2d_train(self, cfg_path, gpu_id, config_path): det2d_train = Detection2dTrain(cfg_path, gpu_id, config_path) det2d_train.load_pretrain_model(self.pretrain_model_path) det2d_train.train(self.train_path, self.val_path) self.image_model_convert(det2d_train, cfg_path) def segment_train(self, cfg_path, gpu_id, config_path): seg_train = SegmentionTrain(cfg_path, gpu_id, config_path) seg_train.load_pretrain_model(self.pretrain_model_path) seg_train.train(self.train_path, self.val_path) self.image_model_convert(seg_train, cfg_path) def pc_classify_train(self, cfg_path, gpu_id, config_path): pc_cls_train_task = PointCloudClassifyTrain(cfg_path, gpu_id, config_path) pc_cls_train_task.load_pretrain_model(self.pretrain_model_path) pc_cls_train_task.train(self.train_path, self.val_path) def image_model_convert(self, train_task, cfg_path): if self.is_convert: converter = ModelConverter(train_task.train_task_config.image_size) converter.model_convert(cfg_path, train_task.train_task_config.best_weights_file, train_task.train_task_config.snapshot_path) def main(): print("process start...") options = TaskArgumentsParse.train_input_parse() train_task = TrainTask(options.trainPath, options.valPath, options.pretrainModel) if options.task_name == TaskName.Classify_Task: train_task.classify_train(options.model, 0, options.config_path) elif options.task_name == TaskName.Detect2d_Task: train_task.detect2d_train(options.model, 0, options.config_path) elif options.task_name == TaskName.Segment_Task: train_task.segment_train(options.model, 0, options.config_path) elif options.task_name == TaskName.PC_Classify_Task: train_task.pc_classify_train(options.model, 0, options.config_path) print("process end!") if __name__ == '__main__': main()

study/study8.py

tanyong-cq/pythonlearning

12797867

<reponame>tanyong-cq/pythonlearning #!/usr/bin/env python # -*- coding: utf-8 -*- ''' dict ''' d1 = {'a':1, 'b':2, 'c':3} print(d1) print(d1.keys()) print(d1.values()) print(str(d1)) print(len(d1)) print(d1['a']) d1['a'] = 10 print(d1['a']) del d1['a'] print(d1) d1.clear() print(d1) print(d1.get('a'))

Python/sum.py

AbdalrohmanGitHub/Logik

12797995

<gh_stars>10-100 # This program reads a number n and computes the sum 1 + 2 + ... + n. n = input('Type a natural number and press return: ') n = int(n) s = { i for i in range(1, n+1) } s = sum(s) print('The sum 1 + 2 + ... + ', n, ' is equal to ', s, '.', sep= '')

examples/misc/hexapod_z.py

brutzl/pymbs

12798123

# -*- coding: utf-8 -*- ''' This file is part of PyMbs. PyMbs is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. PyMbs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with PyMbs. If not, see <http://www.gnu.org/licenses/>. Copyright 2011, 2012 <NAME>, <NAME>, <NAME>, <NAME> ''' ''' Created on 13.05.2011 @author: <NAME> Pfade für Visualisierung anpassen !!! ''' ################################# # import PyMbs & Lib. # ################################# from PyMbs.Input import * from PyMbs.Symbolics import Matrix,cos,sin pi = 3.1415926535897932384626433832795 ################################# # set up inertial frame # ################################# world=MbsSystem([0,0,-1]) ################################# # Parameters # ################################# # Länge der Zylinderstangen und Gehäuse hoehe = 0.01 R_AP=0.3 R_BP=0.5 R_Zyl_stange=0.02 R_Zyl_geh=0.04 l_zyl=0.6 m_z_geh = 0.1 m_z_st = 0.1 c=world.addParam('c',10) c1=world.addParam('c1',5) m1=world.addParam('m1', 1.0) R1=world.addParam('R1', R_BP) m2=world.addParam('m2', 50) R2=world.addParam('R2', R_AP) H2=world.addParam('H2',hoehe) I2x=world.addParam( 'I2x', (m2*H2**2)/12) # Traägheit eines Vollzylinders um x die x-Achse I2y=world.addParam( 'I2y', (m2*H2**2)/12) # Traägheit eines Vollzylinders um y die x-Achse I2z=world.addParam( 'I2z', (m2*R2**2)/2) # Traägheit eines Vollzylinders um z die x-Achse ################################################ m_Zyl_Geh=world.addParam('m_Zyl_Geh', 18.6) l_Zyl_Geh=world.addParam('l_Zyl_Geh',0.74) cg_Zyl_Geh_x=world.addParam('cg_Zyl_Geh_x',0.353) I_Zyl_Geh_x=world.addParam( 'I_Zyl_Geh_x', 0.027) I_Zyl_Geh_y=world.addParam( 'I_Zyl_Geh_y', 1.061) I_Zyl_Geh_z=world.addParam( 'I_Zyl_Geh_z', 1.061) m_Zyl_Stange=world.addParam('m_Zyl_Stange', 8.4) l_Zyl_Stange=world.addParam('l_Zyl_Stange',0.66) cg_Zyl_Stange_x=world.addParam('cg_Zyl_Stange_x',-0.347) I_Zyl_Stange_x=world.addParam('I_Zyl_Stange_x', 0.003) I_Zyl_Stange_y=world.addParam('I_Zyl_Stange_y', 0.433) I_Zyl_Stange_z=world.addParam('I_Zyl_Stange_z', 0.432) ############### # Anordnungen # ############### phi_BP_1 = pi/2-pi/18 phi_BP_2 = phi_BP_1 + pi/9 phi_BP_3 = phi_BP_1 + 2*pi/3 phi_BP_4 = phi_BP_2 + 2*pi/3 phi_BP_5 = phi_BP_3 + 2*pi/3 phi_BP_6 = phi_BP_4 + 2*pi/3 phi_AP_1 = pi/6+pi/18 phi_AP_2 = phi_AP_1 + 2*pi/3-pi/9 phi_AP_3 = phi_AP_1 + 2*pi/3 phi_AP_4 = phi_AP_3 + 2*pi/3-pi/9 phi_AP_5 = phi_AP_3 + 2*pi/3 phi_AP_6 = phi_AP_4 + 2*pi/3 ################ # Hexapod # ################ ################################# # Bodies & KS # ################################# Ground = world.addBody(name='Ground',mass=1) Ground.addFrame(name='KS_1',p=[0,0,0]) BP = Ground.KS_1 BP.addFrame(name='BP_visual', p=[0,0,0],R=rotMat(pi/2,'x')) BP.addFrame(name='BP_Anlenkpunkt_1', p=[R1*cos(phi_BP_1),R1*sin(phi_BP_1),0]) BP.addFrame(name='BP_Anlenkpunkt_2', p=[R1*cos(phi_BP_2),R1*sin(phi_BP_2),0]) BP.addFrame(name='BP_Anlenkpunkt_3', p=[R1*cos(phi_BP_3),R1*sin(phi_BP_3),0]) BP.addFrame(name='BP_Anlenkpunkt_4', p=[R1*cos(phi_BP_4),R1*sin(phi_BP_4),0]) BP.addFrame(name='BP_Anlenkpunkt_5', p=[R1*cos(phi_BP_5),R1*sin(phi_BP_5),0]) BP.addFrame(name='BP_Anlenkpunkt_6', p=[R1*cos(phi_BP_6),R1*sin(phi_BP_6),0]) BP.addFrame(name='BP_Feder',p=[0,0,1.1]) ################################################################################ AP = world.addBody(name='Arbeitsplattform', mass=m2,inertia=diag([I2x,I2y,I2z])) AP.addFrame(name='AP_visual', p=[0,0,0],R=rotMat(pi/2,'x')) AP.addFrame(name='AP_Anlenkpunkt_1', p=[R2*cos(phi_AP_1),R2*sin(phi_AP_1),0]) AP.addFrame(name='AP_Anlenkpunkt_2', p=[R2*cos(phi_AP_2),R2*sin(phi_AP_2),0]) AP.addFrame(name='AP_Anlenkpunkt_3', p=[R2*cos(phi_AP_3),R2*sin(phi_AP_3),0]) AP.addFrame(name='AP_Anlenkpunkt_4', p=[R2*cos(phi_AP_4),R2*sin(phi_AP_4),0]) AP.addFrame(name='AP_Anlenkpunkt_5', p=[R2*cos(phi_AP_5),R2*sin(phi_AP_5),0]) AP.addFrame(name='AP_Anlenkpunkt_6', p=[R2*cos(phi_AP_6),R2*sin(phi_AP_6),0]) ################################################################################ ''' #Für Visualisierung im Dymola Zyl_geh_1 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_1') Zyl_geh_1.addFrame('Zyl_geh_1_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_1.addFrame('Zyl_geh_1_cs', p=[0,0,0]) Zyl_geh_1.addFrame('Zyl_geh_1_cs_2', p=[0,0,0]) Zyl_geh_2 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_2') Zyl_geh_2.addFrame('Zyl_geh_2_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_2.addFrame('Zyl_geh_2_cs', p=[0,0,0]) Zyl_geh_2.addFrame('Zyl_geh_2_cs_2', p=[0,0,0]) Zyl_geh_3 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_3') Zyl_geh_3.addFrame('Zyl_geh_3_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_3.addFrame('Zyl_geh_3_cs', p=[0,0,0]) Zyl_geh_3.addFrame('Zyl_geh_3_cs_2', p=[0,0,0]) Zyl_geh_4 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_4') Zyl_geh_4.addFrame('Zyl_geh_4_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_4.addFrame('Zyl_geh_4_cs', p=[0,0,0]) Zyl_geh_4.addFrame('Zyl_geh_4_cs_2', p=[0,0,0]) Zyl_geh_5 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_5') Zyl_geh_5.addFrame('Zyl_geh_5_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_5.addFrame('Zyl_geh_5_cs', p=[0,0,0]) Zyl_geh_5.addFrame('Zyl_geh_5_cs_2', p=[0,0,0]) Zyl_geh_6 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_6') Zyl_geh_6.addFrame('Zyl_geh_6_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_geh_6.addFrame('Zyl_geh_6_cs', p=[0,0,0]) Zyl_geh_6.addFrame('Zyl_geh_6_cs_2', p=[0,0,0]) ################################################################################ Zyl_stange_1 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_1') Zyl_stange_1.addFrame('Zyl_stange_1_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_1.addFrame('Zyl_stange_1_cs', p=[0,0,0]) Zyl_stange_1.addFrame('Zyl_stange_1_cs_2', p=[0,0,0]) Zyl_stange_2 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_2') Zyl_stange_2.addFrame('Zyl_stange_2_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_2.addFrame('Zyl_stange_2_cs', p=[0,0,0]) Zyl_stange_2.addFrame('Zyl_stange_2_cs_2', p=[0,0,0]) Zyl_stange_3 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_3') Zyl_stange_3.addFrame('Zyl_stange_3_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_3.addFrame('Zyl_stange_3_cs', p=[0,0,0]) Zyl_stange_3.addFrame('Zyl_stange_3_cs_2', p=[0,0,0]) Zyl_stange_4 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_4') Zyl_stange_4.addFrame('Zyl_stange_4_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_4.addFrame('Zyl_stange_4_cs', p=[0,0,0]) Zyl_stange_4.addFrame('Zyl_stange_4_cs_2', p=[0,0,0]) Zyl_stange_5 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_5') Zyl_stange_5.addFrame('Zyl_stange_5_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_5.addFrame('Zyl_stange_5_cs', p=[0,0,0]) Zyl_stange_5.addFrame('Zyl_stange_5_cs_2', p=[0,0,0]) Zyl_stange_6 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_6') Zyl_stange_6.addFrame('Zyl_stange_6_visual', p=[0,0,0],R=rotMat(pi/2,'y')*rotMat(pi/2,'x')) Zyl_stange_6.addFrame('Zyl_stange_6_cs', p=[0,0,0]) Zyl_stange_6.addFrame('Zyl_stange_6_cs_2', p=[0,0,0]) ''' # Für Visualisierung im PyMbs Zyl_geh_1 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_1') Zyl_geh_1.addFrame('Zyl_geh_1_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_1.addFrame('Zyl_geh_1_cs', p=[0,0,0]) Zyl_geh_1.addFrame('Zyl_geh_1_cs_2', p=[0,0,0]) Zyl_geh_2 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_2') Zyl_geh_2.addFrame('Zyl_geh_2_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_2.addFrame('Zyl_geh_2_cs', p=[0,0,0]) Zyl_geh_2.addFrame('Zyl_geh_2_cs_2', p=[0,0,0]) Zyl_geh_3 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_3') Zyl_geh_3.addFrame('Zyl_geh_3_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_3.addFrame('Zyl_geh_3_cs', p=[0,0,0]) Zyl_geh_3.addFrame('Zyl_geh_3_cs_2', p=[0,0,0]) Zyl_geh_4 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_4') Zyl_geh_4.addFrame('Zyl_geh_4_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_4.addFrame('Zyl_geh_4_cs', p=[0,0,0]) Zyl_geh_4.addFrame('Zyl_geh_4_cs_2', p=[0,0,0]) Zyl_geh_5 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_5') Zyl_geh_5.addFrame('Zyl_geh_5_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_5.addFrame('Zyl_geh_5_cs', p=[0,0,0]) Zyl_geh_5.addFrame('Zyl_geh_5_cs_2', p=[0,0,0]) Zyl_geh_6 = world.addBody( mass=m_Zyl_Geh,cg=[cg_Zyl_Geh_x,0,0], inertia=diag([I_Zyl_Geh_x,I_Zyl_Geh_y,I_Zyl_Geh_z]),name='Zyl_geh_6') Zyl_geh_6.addFrame('Zyl_geh_6_visual', p=[0,0,l_zyl/2],R=rotMat(pi/2,'x')) Zyl_geh_6.addFrame('Zyl_geh_6_cs', p=[0,0,0]) Zyl_geh_6.addFrame('Zyl_geh_6_cs_2', p=[0,0,0]) ################################################################################ Zyl_stange_1 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_1') Zyl_stange_1.addFrame('Zyl_stange_1_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_1.addFrame('Zyl_stange_1_cs', p=[0,0,0]) Zyl_stange_1.addFrame('Zyl_stange_1_cs_2', p=[0,0,0]) Zyl_stange_2 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_2') Zyl_stange_2.addFrame('Zyl_stange_2_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_2.addFrame('Zyl_stange_2_cs', p=[0,0,0]) Zyl_stange_2.addFrame('Zyl_stange_2_cs_2', p=[0,0,0]) Zyl_stange_3 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_3') Zyl_stange_3.addFrame('Zyl_stange_3_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_3.addFrame('Zyl_stange_3_cs', p=[0,0,0]) Zyl_stange_3.addFrame('Zyl_stange_3_cs_2', p=[0,0,0]) Zyl_stange_4 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_4') Zyl_stange_4.addFrame('Zyl_stange_4_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_4.addFrame('Zyl_stange_4_cs', p=[0,0,0]) Zyl_stange_4.addFrame('Zyl_stange_4_cs_2', p=[0,0,0]) Zyl_stange_5 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_5') Zyl_stange_5.addFrame('Zyl_stange_5_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_5.addFrame('Zyl_stange_5_cs', p=[0,0,0]) Zyl_stange_5.addFrame('Zyl_stange_5_cs_2', p=[0,0,0]) Zyl_stange_6 = world.addBody( mass=m_Zyl_Stange,cg=[cg_Zyl_Stange_x,0,0], inertia=diag([I_Zyl_Stange_x,I_Zyl_Stange_y,I_Zyl_Stange_z]),name='Zyl_stange_6') Zyl_stange_6.addFrame('Zyl_stange_6_visual', p=[0,0,-l_zyl/2],R=rotMat(pi/2,'x')) Zyl_stange_6.addFrame('Zyl_stange_6_cs', p=[0,0,0]) Zyl_stange_6.addFrame('Zyl_stange_6_cs_2', p=[0,0,0]) ################################# # Joints # ################################# #world.addJoint('fix_BP', world, BP) world.addJoint( world, Ground, name='fix_BP') jAP=world.addJoint(world, AP,['Tx', 'Ty', 'Tz','Rx', 'Ry', 'Rz'],[0,0,1,0,0,0],name='free_AP') world.addJoint(BP.BP_Anlenkpunkt_1,Zyl_geh_1.Zyl_geh_1_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_1') world.addJoint(BP.BP_Anlenkpunkt_2,Zyl_geh_2.Zyl_geh_2_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_2') world.addJoint(BP.BP_Anlenkpunkt_3,Zyl_geh_3.Zyl_geh_3_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_3') world.addJoint(BP.BP_Anlenkpunkt_4,Zyl_geh_4.Zyl_geh_4_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_4') world.addJoint(BP.BP_Anlenkpunkt_5,Zyl_geh_5.Zyl_geh_5_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_5') world.addJoint(BP.BP_Anlenkpunkt_6,Zyl_geh_6.Zyl_geh_6_cs_2,['Rz', 'Ry'],[0,0],name='Zyl_geh_1_an_BP_6') world.addJoint(Zyl_geh_1.Zyl_geh_1_cs,Zyl_stange_1.Zyl_stange_1_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_1') world.addJoint(Zyl_geh_2.Zyl_geh_2_cs,Zyl_stange_2.Zyl_stange_2_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_2') world.addJoint(Zyl_geh_3.Zyl_geh_3_cs,Zyl_stange_3.Zyl_stange_3_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_3') world.addJoint(Zyl_geh_4.Zyl_geh_4_cs,Zyl_stange_4.Zyl_stange_4_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_4') world.addJoint(Zyl_geh_5.Zyl_geh_5_cs,Zyl_stange_5.Zyl_stange_5_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_5') world.addJoint(Zyl_geh_6.Zyl_geh_6_cs,Zyl_stange_6.Zyl_stange_6_cs_2,'Tz',0,name='Zyl_stange_1_an_Zyl_geh_6') ######################## # Constraints or Loops # ######################## world.addLoop.Hexapod(AP.AP_Anlenkpunkt_1, Zyl_stange_1.Zyl_stange_1_cs, 'Verbindung_1') world.addLoop.Hexapod(AP.AP_Anlenkpunkt_2, Zyl_stange_2.Zyl_stange_2_cs, 'Verbindung_2') world.addLoop.Hexapod(AP.AP_Anlenkpunkt_3, Zyl_stange_3.Zyl_stange_3_cs, 'Verbindung_3') world.addLoop.Hexapod(AP.AP_Anlenkpunkt_4, Zyl_stange_4.Zyl_stange_4_cs, 'Verbindung_4') world.addLoop.Hexapod(AP.AP_Anlenkpunkt_5, Zyl_stange_5.Zyl_stange_5_cs, 'Verbindung_5') world.addLoop.Hexapod(AP.AP_Anlenkpunkt_6, Zyl_stange_6.Zyl_stange_6_cs, 'Verbindung_6') ##################### # add visualisation # ##################### world.addVisualisation.Cylinder(BP.BP_visual,R_BP, hoehe) world.addVisualisation.Cylinder(AP.AP_visual,R_AP, hoehe) ''' # Für Visualisierung im Dymola world.addVisualisation.File(Zyl_geh_1.Zyl_geh_1_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_1') world.addVisualisation.File(Zyl_geh_2.Zyl_geh_2_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_2') world.addVisualisation.File(Zyl_geh_3.Zyl_geh_3_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_3') world.addVisualisation.File(Zyl_geh_4.Zyl_geh_4_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_4') world.addVisualisation.File(Zyl_geh_5.Zyl_geh_5_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_5') world.addVisualisation.File(Zyl_geh_6.Zyl_geh_6_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_geh_001.stl',1,name='Zylinder_geh_6') world.addVisualisation.File(Zyl_stange_1.Zyl_stange_1_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_1') world.addVisualisation.File(Zyl_stange_2.Zyl_stange_2_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_2') world.addVisualisation.File(Zyl_stange_3.Zyl_stange_3_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_3') world.addVisualisation.File(Zyl_stange_4.Zyl_stange_4_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_4') world.addVisualisation.File(Zyl_stange_5.Zyl_stange_5_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_5') world.addVisualisation.File(Zyl_stange_6.Zyl_stange_6_visual, 'C:\\Users\JeSche\Desktop\Diplom_Arbeit\Hexapod/zyl_stange_001.stl',1,name='Zylinder_stange_6') ''' # Für Visualisierung im Dymola world.addVisualisation.Cylinder(Zyl_geh_1.Zyl_geh_1_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_geh_2.Zyl_geh_2_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_geh_3.Zyl_geh_3_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_geh_4.Zyl_geh_4_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_geh_5.Zyl_geh_5_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_geh_6.Zyl_geh_6_visual, R_Zyl_geh,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_1.Zyl_stange_1_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_2.Zyl_stange_2_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_3.Zyl_stange_3_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_4.Zyl_stange_4_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_5.Zyl_stange_5_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Cylinder(Zyl_stange_6.Zyl_stange_6_visual, R_Zyl_stange,l_zyl) world.addVisualisation.Frame(AP,0.4) #world.addVisualisation.Frame(BP.BP_Feder,1) world.addVisualisation.Frame(Ground,0.6) ################################# # add visualisation # ################################# print("System has been assembled") ################################# # add Sensors # ################################# #world.addSensor.Position(world,AP.AP_Anlenkpunkt_1,"P_AP_1") #world.addSensor.Energy(AP,'E_AP') ##################### # add Imput & Load # ##################### #l = world.addSensor.Distance(AP,BP.BP_Feder, 'l', 'DistanceSensor') #lz = world.addSensor.Distance(BP,AP, 'lz', 'DistanceSensor_Cylinder') #c=50 #F_c = world.addExpression('SpringForce', 'F_c', -c*l[0]) #world.addLoad.PtPForce(AP,BP.BP_Feder, F_c, name='Spring') ################################# # generate equations & sim Code # ################################# world.genEquations.Recursive() #world.genCode.Modelica('hexapod_z_kpl','.\HP_Output',inputsAsInputs=True, debugMode=False) world.show('hexapod_z_kpl')

src/train/test.py

jiangqn/RNNLM

12798251

<filename>src/train/test.py<gh_stars>1-10 import os import torch from torch import nn from torch.utils.data.dataloader import DataLoader from src.data_process.dataset import LMDataset from src.train.eval import eval from src.utils.constants import PAD_INDEX from src.utils.logger import Logger def test(args): os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu) base_path = os.path.join('./data', args.data) processed_base_path = os.path.join(base_path, 'processed') processed_test_path = os.path.join(processed_base_path, 'test.npz') save_path = os.path.join(processed_base_path, 'rnnlm.pkl') log_base_path = os.path.join(base_path, 'log') log_path = os.path.join(log_base_path, 'test_log.txt') logger = Logger(log_path) test_data = LMDataset(processed_test_path) test_loader = DataLoader( dataset=test_data, batch_size=args.batch_size, shuffle=False, pin_memory=True ) model = torch.load(save_path) model = model.cuda() criterion = nn.CrossEntropyLoss(ignore_index=PAD_INDEX) test_loss, test_ppl = eval(model, test_loader, criterion) logger.log('test_loss: %.4f\ttest_ppl: %.4f' % (test_loss, test_ppl))

interface.py

Kapil-Shyam-M/riscv-isac

12798379

<reponame>Kapil-Shyam-M/riscv-isac import importlib import pluggy from riscv_isac.plugins.specification import * import riscv_isac.plugins as plugins def interface (trace, arch, mode): ''' Arguments: Trace - Log_file_path Arch - Architecture Mode - Execution trace format ''' parser_pm = pluggy.PluginManager("parser") decoder_pm = pluggy.PluginManager("decoder") parser_pm.add_hookspecs(ParserSpec) decoder_pm.add_hookspecs(DecoderSpec) parserfile = importlib.import_module("riscv_isac.plugins."+mode) parserclass = getattr(parserfile, "mode_"+mode) parser_pm.register(parserclass()) parser = parser_pm.hook parser.setup(trace=trace,arch=arch) instructionObjectfile = importlib.import_module("riscv_isac.plugins.internalDecoder") decoderclass = getattr(instructionObjectfile, "disassembler") decoder_pm.register(decoderclass()) decoder = decoder_pm.hook decoder.setup(arch=arch) iterator = iter(parser.__iter__()[0]) for instr, mnemonic, addr, commitvalue in iterator: if instr is not None: instrObj = decoder.decode(instr=instr, addr=addr)

bin/tests/test_design.py

broadinstitute/adapt

12798507

<filename>bin/tests/test_design.py """Tests for design.py """ import random import os import copy import tempfile import unittest import logging from collections import OrderedDict from argparse import Namespace from adapt import alignment from adapt.prepare import align, ncbi_neighbors, prepare_alignment from adapt.utils import seq_io from bin import design __author__ = '<NAME> <<EMAIL>>' # Default args: window size 3, guide size 2, allow GU pairing # GU pairing allows AA to match GG in 1st window SEQS = OrderedDict() SEQS["genome_1"] = "AACTA" SEQS["genome_2"] = "AAACT" SEQS["genome_3"] = "GGCTA" SEQS["genome_4"] = "GGCTT" # Specificity seq stops AA from being the best guide in the 1st window SP_SEQS = OrderedDict() SP_SEQS["genome_5"] = "AA---" class TestDesign(object): """General class for testing design.py Defines helper functions for test cases and basic setUp and tearDown functions. """ class TestDesignCase(unittest.TestCase): def setUp(self): # Disable logging logging.disable(logging.INFO) # Create a temporary input file self.input_file = tempfile.NamedTemporaryFile(mode='w', delete=False) # Closes the file so that it can be reopened on Windows self.input_file.close() # Create a temporary output file self.output_file = tempfile.NamedTemporaryFile(mode='w', delete=False) self.output_file.close() self.files_to_delete = [self.input_file.name, self.output_file.name] def check_results(self, file, expected, header='target-sequences'): """Check the results of the test output Given a TSV file of test output and expected output, fails the test if the test output guide target sequences do not equal the expected guide target sequences Args: file: string, path name of the file expected: list of lists of strings, all the expected guide target sequences in each line of the output header: the header of the CSV that contains the guide target sequences """ col_loc = None with open(file) as f: for i, line in enumerate(f): if i == 0: headers = line.split('\t') # Will raise an error if header is not in output col_loc = headers.index(header) continue self.assertLess(i, len(expected) + 1) guide_line = line.split('\t')[col_loc] guides = guide_line.split(' ') for guide in guides: self.assertIn(guide, expected[i-1]) self.assertEqual(len(guides), len(expected[i-1])) self.assertEqual(i, len(expected)) def baseArgv(self, search_type='sliding-window', input_type='fasta', objective='minimize-guides', model=False, specific=None, specificity_file=None, output_loc=None): """Get arguments for tests Produces the correct arguments for a test case given details of what the test case is testing. See design.py help for details on input Args: search_type: 'sliding-window' or 'complete-targets' input_type: 'fasta', 'auto-from-args', or 'auto-from-file' objective: 'minimize-guides' or 'maximize-activity' model: boolean, true to use Cas13a built in model, false to use simple binary prediction specific: None, 'fasta', or 'taxa'; what sort of input to be specific against output_loc: path to the output file/directory; set to self.output_file.name if None Returns: List of strings that are the arguments of the test """ input_file = self.input_file.name if output_loc is None: output_loc = self.output_file.name argv = ['design.py', search_type, input_type] if input_type == 'fasta': argv.extend([input_file, '-o', output_loc]) elif input_type == 'auto-from-args': argv.extend(['64320', 'None', output_loc]) elif input_type == 'auto-from-file': argv.extend([input_file, output_loc]) if input_type in ['auto-from-args', 'auto-from-file']: argv.extend(['--sample-seqs', '1', '--mafft-path', 'fake_path']) if search_type == 'sliding-window': argv.extend(['-w', '3']) if search_type == 'complete-targets': argv.extend(['--best-n-targets', '2', '-pp', '.75', '-pl', '1', '--max-primers-at-site', '2']) if objective == 'minimize-guides': argv.extend(['-gm', '0', '-gp', '.75']) elif objective =='maximize-activity': argv.extend(['--maximization-algorithm', 'greedy']) # ID-M (mismatches to be considered identical) must be set to 0 since otherwise # having 1 base in common with a 2 base guide counts as a match if specific == 'fasta': argv.extend(['--specific-against-fastas', specificity_file, '--id-m', '0']) elif specific == 'taxa': argv.extend(['--specific-against-taxa', specificity_file, '--id-m', '0']) if model: argv.append('--predict-cas13a-activity-model') elif objective =='maximize-activity': argv.extend(['--use-simple-binary-activity-prediction', '-gm', '0']) argv.extend(['--obj', objective, '--seed', '0', '-gl', '2']) return argv def tearDown(self): for file in self.files_to_delete: if os.path.isfile(file): os.unlink(file) # Re-enable logging logging.disable(logging.NOTSET) class TestDesignFasta(TestDesign.TestDesignCase): """Test design.py given an input FASTA """ def setUp(self): super().setUp() self.real_output_file = self.output_file.name + '.tsv' self.files_to_delete.append(self.real_output_file) # Write to temporary input fasta seq_io.write_fasta(SEQS, self.input_file.name) def test_min_guides(self): argv = super().baseArgv() args = design.argv_to_args(argv) design.run(args) # Base args set the percentage of sequences to match at 75% expected = [["AA"], ["CT"], ["CT"]] self.check_results(self.real_output_file, expected) def test_max_activity(self): argv = super().baseArgv(objective='maximize-activity') args = design.argv_to_args(argv) design.run(args) # Doesn't use model, just greedy binary prediction with 0 mismatches # (so same outputs as min-guides) expected = [["AA"], ["CT"], ["CT"]] self.check_results(self.real_output_file, expected) def test_complete_targets(self): argv = super().baseArgv(search_type='complete-targets') args = design.argv_to_args(argv) design.run(args) # Since sequences are short and need 1 base for primer on each side, # only finds 1 target in middle expected = [["CT"]] self.check_results(self.real_output_file, expected, header='guide-target-sequences') def test_specificity_fastas(self): # Create a temporary fasta file for specificity self.sp_fasta = tempfile.NamedTemporaryFile(mode='w', delete=False) # Closes the file so that it can be reopened on Windows self.sp_fasta.close() seq_io.write_fasta(SP_SEQS, self.sp_fasta.name) self.files_to_delete.append(self.sp_fasta.name) argv = super().baseArgv(specific='fasta', specificity_file=self.sp_fasta.name) args = design.argv_to_args(argv) design.run(args) # AA isn't allowed in 1st window by specificity fasta, # so 1st window changes expected = [["AC", "GG"], ["CT"], ["CT"]] self.check_results(self.real_output_file, expected) class TestDesignAutos(TestDesign.TestDesignCase): """Test design.py given arguments to automatically download FASTAs Does not run the entire design.py; prematurely stops by giving a fake path to MAFFT. All are expected to return a FileNotFoundError """ def setUp(self): super().setUp() # Write to temporary input file with open(self.input_file.name, 'w') as f: f.write("Zika virus\t64320\tNone\tNC_035889\n") # Create a temporary output directory self.output_dir = tempfile.TemporaryDirectory() def test_auto_from_file(self): argv = super().baseArgv(input_type='auto-from-file', output_loc=self.output_dir.name) args = design.argv_to_args(argv) try: design.run(args) except FileNotFoundError: pass def test_auto_from_args(self): argv = super().baseArgv(input_type='auto-from-args') args = design.argv_to_args(argv) try: design.run(args) except FileNotFoundError: pass def test_specificity_taxa(self): argv = super().baseArgv(input_type='auto-from-args', specific='taxa', specificity_file='') args = design.argv_to_args(argv) try: design.run(args) except FileNotFoundError: pass def tearDown(self): super().tearDown() self.output_dir.cleanup() class TestDesignFull(TestDesign.TestDesignCase): """Test design.py fully through """ def setUp(self): super().setUp() # Write to temporary input file with open(self.input_file.name, 'w') as f: f.write("Zika virus\t64320\tNone\tNC_035889\n") # Create a temporary specificity file self.sp_file = tempfile.NamedTemporaryFile(mode='w', delete=False) self.sp_file.write("123\tNone\n") # Closes the file so that it can be reopened on Windows self.sp_file.close() # 'auto-from-args' gives different outputs for every cluster # Our test only produces 1 cluster, so store the name of that file self.real_output_file = self.output_file.name + '.0.tsv' self.files_to_delete.extend([self.sp_file.name, self.real_output_file]) # We cannot access MAFFT, so override this function; store original so # it can be fixed for future tests self.set_mafft_exec = align.set_mafft_exec align.set_mafft_exec = lambda mafft_path: None # Curating requires MAFFT, so override this function; store original so # it can be fixed for future tests self.curate_against_ref = align.curate_against_ref def small_curate(seqs, ref_accs, asm=None, remove_ref_accs=[]): return {seq: seqs[seq] for seq in seqs \ if seq.split('.')[0] not in remove_ref_accs} align.curate_against_ref = small_curate # Aligning requires MAFFT, so override this function and output simple # test sequences; store original so it can be fixed for future tests self.align = align.align align.align = lambda seqs, am=None: SEQS # We don't want to fetch sequences for the specificity file since we're # doing a simple test case, so override this function; store original # so it can be fixed for future tests self.fetch_sequences_for_taxonomy = prepare_alignment.fetch_sequences_for_taxonomy def small_fetch(taxid, segment): # 123 is the taxonomic ID used in our specificity file if taxid == 123: return SP_SEQS # If it's not the specificity taxonomic ID, test fetching the real # sequences, but don't return them as they won't be used else: self.fetch_sequences_for_taxonomy(taxid, segment) return SEQS prepare_alignment.fetch_sequences_for_taxonomy = small_fetch # Disable warning logging to avoid annotation warning logging.disable(logging.WARNING) def test_specificity_taxa(self): argv = super().baseArgv(input_type='auto-from-args', specific='taxa', specificity_file=self.sp_file.name) args = design.argv_to_args(argv) design.run(args) # Same output as test_specificity_fasta, as sequences are the same expected = [["AC", "GG"], ["CT"], ["CT"]] self.check_results(self.real_output_file, expected) def tearDown(self): # Fix all overridden functions align.set_mafft_exec = self.set_mafft_exec align.curate_against_ref = self.curate_against_ref align.align = self.align prepare_alignment.fetch_sequences_for_taxonomy = self.fetch_sequences_for_taxonomy super().tearDown()

test/test_del_contact.py

vyacheslavmarkov/python_training

12798635

<gh_stars>0 from model.contact import Contact import random def test_delete_first_contact(app, db, check_ui): if len(db.get_contact_list()) == 0: app.contact.create(Contact(firstname="Tester", middlename="Something", lastname="Trump", photo="picture.jpg", nickname="super nickname", title="QA engineer", company="Google", address="Kremlin", homephone="1111111", mobilephone="2222222", workphone="3333333", fax="4444444", email="<EMAIL>", email2="<EMAIL>", email3="<EMAIL>", homepage="google.com", bday="29", bmonth="April", byear="1991", aday="22", amonth="August", ayear="2015", address_2="Moscow", secondaryphone="5555555", notes="Cool guy")) old_contacts = db.get_contact_list() contact = random.choice(old_contacts) app.contact.delete_contact_by_id(contact.id) new_contacts = db.get_contact_list() assert len(old_contacts) - 1 == len(new_contacts) old_contacts.remove(contact) assert sorted(old_contacts, key=Contact.id_or_max) == sorted(new_contacts, key=Contact.id_or_max) if check_ui: # tune db contact data to be appropriate for the homepage representation old_contacts = app.contact.make_contacts_like_on_homepage(old_contacts) assert sorted(old_contacts, key=Contact.id_or_max) == sorted(app.contact.get_contacts_list(), key=Contact.id_or_max)

py/fingerboard.py

Takayoshi-Aoyagi/Jazz-Chords

12798763

# coding: UTF-8 from tone import Tone class Fingerboard: @classmethod def getPos(cls): _pos = {} openTones = ["E", "B", "G", "D", "A", "E"] tone = Tone() for stringIndex, openTone in enumerate(openTones): toneIndex = tone.getToneNumberByName(openTone) arr = [] for i in range(13): toneString = tone.getToneName(openTone, i) arr.append(toneString) _pos[stringIndex + 1] = arr return _pos @classmethod def dump(cls, includes): _pos = cls.getPos() if len(includes) > 0: for key in _pos.keys(): arr = _pos[key] for i, tone in enumerate(arr): if tone not in includes.keys(): arr[i] = " " else: arr[i] = "%2s(%3s)" % (tone, includes[tone]) flets = map(lambda x: " %7s " % x, range(13)) print " " + " ".join(flets) for key in sorted(_pos.keys()): tones = _pos[key] tones = map(lambda x: " %7s " % x, tones) print '%s弦: |%s|' % (key, "|".join(tones))

unifi/objects/device.py

BastiG/unifi-py

12798891

from unifi.objects.base import UnifiBaseObject from unifi.helper import find_by_attr, json_print class UnifiDeviceObject(UnifiBaseObject): def get_port_profile(self, **filter_kwargs): port = find_by_attr(self.port_table, **filter_kwargs) port_override = find_by_attr(self.port_overrides, port_idx=port['port_idx']) portconf_id = port_override['portconf_id'] if port_override and 'portconf_id' in port_override else port['portconf_id'] portconf = find_by_attr(self.controller.portconf(), _id=portconf_id) return portconf def set_port_profile(self, portconf, **filter_kwargs): port = find_by_attr(self.port_table, **filter_kwargs) port_override = find_by_attr(self.port_overrides, port_idx=port['port_idx']) if port_override: port_override['portconf_id'] = portconf['_id'] else: port_override = { 'port_idx': port['port_idx'], 'portconf_id': portconf['_id'] } self.port_overrides.append(port_override)

pipekit/__init__.py

DrDub/pipekit

12799019

<reponame>DrDub/pipekit #!/usr/bin/env python3 from .pipe import NullPipe # noqa: W0611

Bioinformatics VI/Week II/SuffixArray.py

egeulgen/Bioinformatics_Specialization

12799147

<gh_stars>1-10 import sys def SuffixArray(Text): ''' Suffix Array Input: A string Text. Output: SuffixArray(Text). ''' suffixes = [] suffix_array = [] for i in range(len(Text)): suffixes.append(Text[i:]) suffix_array.append(i) suffix_array = [x for _, x in sorted(zip(suffixes, suffix_array), key=lambda pair: pair[0])] return suffix_array if __name__ == "__main__": Text = sys.stdin.read().rstrip() suffix_array = SuffixArray(Text) print(', '.join(str(x) for x in suffix_array))

jsymbols.py

agnosticlines/ghidra_kernelcache

12799275

# Symbolicate the kernelcache from jtool2 #@author simo #@category iOS.kernel from utils.methods import * if __name__ == "__main__": default_file = "test" fname = askString("Kernelcache symbol file","Symbol file: ",default_file) f = open(fname,"rb+") buf = f.read().split('\n') i = 0 for line in buf: if len(line) == 0: continue addr , symbol , empty = line.split("|") if len(symbol) == 0: continue if "func_" in symbol: continue print addr,symbol symbol = symbol.strip()#.replace(" ","_") symbolicate(addr,symbol) i+= 1

04-FaceRecognition-II/thetensorclan-backend-heroku/models/__init__.py

amitkml/TSAI-DeepVision-EVA4.0-Phase-2

12799403

from .utils import get_classifier, MODEL_REGISTER

conditions/toy_shop.py

MaggieIllustrations/softuni-github-programming

12799531

<reponame>MaggieIllustrations/softuni-github-programming holiday_price = float(input()) puzzle_count = int(input()) dolls_count = int(input()) teddy_bears_count = int(input()) minions_count = int(input()) trucks_count = int(input()) # total_price_dolls = dolls_count * 3 total_price_puzzles = puzzle_count * 2.6 total_price_teddy_bears = teddy_bears_count * 4.10 total_price_minions = minions_count * 8.20 total_price_trucks = trucks_count * 2 total_price = total_price_puzzles + total_price_dolls + \ total_price_teddy_bears + total_price_minions + \ total_price_trucks total_amount_toys = puzzle_count + dolls_count + teddy_bears_count + minions_count + trucks_count if total_amount_toys >= 50: discount = total_price * 0.25 total_price = total_price - discount rent = total_price * 0.1 earning_after_rent = total_price - rent if earning_after_rent >= holiday_price: earning_left = earning_after_rent - holiday_price print(f"Yes! {earning_left:.2f} lv left.") else: needed_money = holiday_price - earning_after_rent print(f"Not enough money! {needed_money:.2f} lv left.") else: rent = total_price * 0.1 earning_after_rent = total_price - rent if earning_after_rent >= holiday_price: earning_left = earning_after_rent - holiday_price print(f"Yes! {earning_left:.2f} lv left.") else: needed_money = holiday_price - earning_after_rent print(f"Not enough money! {needed_money:.2f} lv needed.")

queries/charQuery.py

Kadantte/AniPy-Bot

12799659

def searchChar(): query = ''' query ($search: String) { Character(search: $search) { siteUrl name { full } media(perPage: 1) { nodes { title { romaji english } siteUrl } } image { large } description(asHtml: true) } } ''' return query

neuralizer/tests/test_data_process.py

BeckResearchLab/Neuralizer

12799787

<filename>neuralizer/tests/test_data_process.py from __future__ import absolute_import,division,print_function import os import pandas as pd import numpy as np import numpy.testing as npt import data_process as dp def test_read_file(): X,Y = dp.read_file('test.tsv',["A","B"],"y") npt.assert_equal(X,np.array[[0,1],[3,2],[4,3]]) npt.assert_equal(Y,np.array[0,1,5]) def test_data_info(): data = {"filename":"test.tsv","X_var":["A","B"],"Y_var":"y"} X,Y,input_dim,output_dim = dp.data_info(data) assert input_dim == 2,"Dimension of input layer is not correct" assert output_dim == 1 , "Dimension of output layer is not correct"

load_data.py

penguin2048/StockIt

12799915

""" handle preprocessing and loading of data. """ import html import os.path import pandas as pd import re from nltk import word_tokenize, pos_tag from nltk.corpus import stopwords, wordnet from nltk.stem.wordnet import WordNetLemmatizer class LoadData: @classmethod def preprocess_stocktwits_data(cls, file_location, columns=['datetime', 'message']): """ preprocess the data in file location and saves it as a csv file (appending '_preprocessed' before '.csv). The preprocessing us in following ways: 1) extract message and datetime columns. 2) sort according to datetime in descending order (newest first) 3) remove links, @ and $ references, extra whitespaces, extra '.', digits, slashes, hyphons 4) decode html entities 5) convert everything to lower case """ if 'datetime' in columns: dataFrame = pd.read_csv(file_location, usecols=columns, parse_dates=['datetime'], infer_datetime_format=True) dataFrame.sort_values(by='datetime', ascending=False) else: dataFrame = pd.read_csv(file_location, usecols=columns) dataFrame['message'] = dataFrame['message'].apply(lambda x: html.unescape(x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: re.sub(r'(www\.|https?://).*?(\s|$)|@.*?(\s|$)|\$.*?(\s|$)|\d|\%|\\|/|-|_', ' ', x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: re.sub(r'\.+', '. ', x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: re.sub(r'\,+', ', ', x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: re.sub(r'\?+', '? ', x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: re.sub(r'\s+', ' ', x)) dataFrame['message'] = dataFrame['message'].apply(lambda x: x.lower()) dataFrame.to_csv(file_location[:-4]+'_preprocessed.csv', index=False) @classmethod def labelled_data_lexicon_analysis(cls): """ extract keywords from labelled stocktwits data for improved accuracy in scoring for each labelled message do 1) tokenize the message 2) perform POS tagging 3) if a sense is present in wordnet then, lemmatize the word and remove stop words else ignore the word remove intersections from the two lists before saving """ dataFrame = LoadData.get_labelled_data() bullish_keywords = set() bearish_keywords = set() lemmatizer = WordNetLemmatizer() stop_words = set(stopwords.words('english')) for index, row in dataFrame.iterrows(): tokens = word_tokenize(row['message']) pos = pos_tag(tokens) selected_tags = set() for i in range(len(pos)): if len(wordnet.synsets(pos[i][0])): if pos[i][1].startswith('J'): selected_tags.add(lemmatizer.lemmatize(pos[i][0], 'a')) elif pos[i][1].startswith('V'): selected_tags.add(lemmatizer.lemmatize(pos[i][0], 'v')) elif pos[i][1].startswith('N'): selected_tags.add(lemmatizer.lemmatize(pos[i][0], 'n')) elif pos[i][1].startswith('R'): selected_tags.add(lemmatizer.lemmatize(pos[i][0], 'r')) selected_tags -= stop_words if row['sentiment'] == 'Bullish': bullish_keywords = bullish_keywords.union(selected_tags) elif row['sentiment'] == 'Bearish': bearish_keywords = bearish_keywords.union(selected_tags) updated_bullish_keywords = bullish_keywords - bearish_keywords updated_bearish_keywords = bearish_keywords - bullish_keywords with open('data-extractor/lexicon_bullish_words.txt', 'a') as file: for word in updated_bullish_keywords: file.write(word+"\n") with open('data-extractor/lexicon_bearish_words.txt', 'a') as file: for word in updated_bearish_keywords: file.write(word+"\n") @classmethod def get_stocktwits_data(cls, symbol): """ get_data loads the preprocessed data of 'symbol' from data-extractor and returns a pandas dataframe with columns [message(object), datetime(datetime64[ns])]. """ file_location = 'data-extractor/stocktwits_'+symbol+'_preprocessed.csv' if os.path.isfile(file_location) is False: LoadData.preprocess_stocktwits_data('data-extractor/stocktwits_'+symbol+'.csv') dataFrame = pd.read_csv(file_location) return dataFrame @classmethod def get_price_data(cls, symbol): """ loads the price data of 'symbol' from data-extractor and returns a pandas dataframe with columns [Date(datetime64[ns]), Opening Price(float64), Closing Price(float64), Volume(float64)]. """ file_location = 'data-extractor/stock_prices_'+symbol+'.csv' dataFrame = pd.read_csv(file_location, usecols=['Date', 'Opening Price', 'Closing Price', 'Volume'], parse_dates=['Date'], infer_datetime_format=True) return dataFrame @classmethod def get_labelled_data(cls, type='complete'): """ get_labelled_data loads the preprocessed labelled data of stocktwits from data-extractor and returns a pandas dataframe with columns [sentiment(object), message(object)]. """ if type == 'complete': file_location = 'data-extractor/labelled_data_complete_preprocessed.csv' if os.path.isfile(file_location) is False: LoadData.preprocess_stocktwits_data('data-extractor/labelled_data_complete.csv', columns=['sentiment', 'message']) elif type == 'training': file_location = 'data-extractor/labelled_data_training_preprocessed.csv' if os.path.isfile(file_location) is False: LoadData.get_training_data() elif type == 'test': file_location = 'data-extractor/labelled_data_test_preprocessed.csv' if os.path.isfile(file_location) is False: LoadData.preprocess_stocktwits_data('data-extractor/labelled_data_test.csv', columns=['sentiment', 'message']) dataFrame = pd.read_csv(file_location) return dataFrame @classmethod def get_custom_lexicon(cls): """ get custom lexicon of bearish and bullish words respectively """ file_location1 = 'data-extractor/lexicon_bearish_words.txt' file_location2 = 'data-extractor/lexicon_bullish_words.txt' if os.path.isfile(file_location1) is False or os.path.isfile(file_location2) is False: LoadData.labelled_data_lexicon_analysis() dataFrameBearish = pd.read_csv(file_location1, header=None, names=['word']) dataFrameBullish = pd.read_csv(file_location2, header=None, names=['word']) return dataFrameBearish, dataFrameBullish @classmethod def get_training_data(cls): """ get labelled training data with equal bearish and bullish messages """ try: os.remove('data-extractor/labelled_data_training.csv') except OSError: pass dataFrame = LoadData.get_labelled_data(type='complete') dataFrameBearish = dataFrame[dataFrame['sentiment']=='Bearish'] dataFrameBullish = dataFrame[dataFrame['sentiment']=='Bullish'] dataFrameBearishTraining = dataFrameBearish dataFrameBullishTraining = dataFrameBullish[:len(dataFrameBearish)] dataFrameTraining = dataFrameBearishTraining.append(dataFrameBullishTraining, ignore_index=True).sample(frac=1).reset_index(drop=True) dataFrameTraining.to_csv('data-extractor/labelled_data_training_preprocessed.csv', index=False) @classmethod def combine_price_and_sentiment(cls, sentimentFrame, priceFrame): from datetime import timedelta """ receive sentimentFrame as (date, sentiment, message) indexed by date and sentiment and priceFrame as (Date, Opening Price, Closing Price, Volume) and return a combined frame as (sentiment_calculated_bullish, sentiment_calculated_bearish, sentiment_actual_previous, tweet_volume_change, cash_volume, label) """ dataFrame = pd.DataFrame() for date, df in sentimentFrame.groupby(level=0, sort=False): price_current = priceFrame[priceFrame['Date'] == date] if price_current.empty or date-timedelta(days=1) not in sentimentFrame.index: continue tweet_minus1 = sentimentFrame.loc[date-timedelta(days=1)] days = 1 price_plus1 = priceFrame[priceFrame['Date'] == date+timedelta(days=days)] while price_plus1.empty: days += 1 price_plus1 = priceFrame[priceFrame['Date'] == date+timedelta(days=days)] days = 1 price_minus1 = priceFrame[priceFrame['Date'] == date-timedelta(days=days)] while price_minus1.empty: days += 1 price_minus1 = priceFrame[priceFrame['Date'] == date-timedelta(days=days)] new_row = {} new_row['date'] = date new_row['sentiment_calculated_bullish'] = df.loc[(date, 'Bullish')]['message'] new_row['sentiment_calculated_bearish'] = df.loc[(date, 'Bearish')]['message'] new_row['sentiment_actual_previous'] = 1 if ((price_minus1.iloc[0]['Closing Price'] - price_minus1.iloc[0]['Opening Price']) >= 0) else -1 new_row['tweet_volume_change'] = df['message'].sum() - tweet_minus1['message'].sum() new_row['cash_volume'] = price_current['Volume'].iloc[0] new_row['label'] = 1 if ((price_plus1.iloc[0]['Closing Price'] - price_current.iloc[0]['Closing Price']) >= 0) else -1 print(new_row) dataFrame = dataFrame.append(new_row, ignore_index=True) return dataFrame @classmethod def aggregate_stock_price_data(cls): """ compile stocktwits data for stock prediction analysis in the following form (date, sentiment_calculated_bullish, sentiment_calculated_bearish, sentiment_actual_previous, tweet_volume_change, cash_volume, label) we have choice to take previous n days sentiment_calculated and using label of next nth day returns dataframes for AAPL, AMZN, GOOGL respectively """ if not (os.path.isfile('data-extractor/stocktwits_AAPL_sharedata.csv') and os.path.isfile('data-extractor/stocktwits_AMZN_sharedata.csv') and os.path.isfile('data-extractor/stocktwits_GOOGL_sharedata.csv')): from sklearn.externals import joblib file_location = 'naive_bayes_classifier.pkl' priceAAPL = LoadData.get_price_data('AAPL') priceAMZN = LoadData.get_price_data('AMZN') priceGOOGL = LoadData.get_price_data('GOOGL') sentimented_file = 'data-extractor/stocktwits_AAPL_withsentiment.csv' if os.path.isfile(sentimented_file) is False: tweet_classifier = joblib.load(file_location) dataAAPL = LoadData.get_stocktwits_data('AAPL') dataAAPL['sentiment'] = dataAAPL['message'].apply(lambda x: tweet_classifier.predict([x])[0]) dataAAPL['datetime'] = dataAAPL['datetime'].apply(lambda x: x.date()) dataAAPL.rename(columns={'datetime':'date'}, inplace=True) dataAAPL.to_csv('data-extractor/stocktwits_AAPL_withsentiment.csv', index=False) sentimented_file = 'data-extractor/stocktwits_AMZN_withsentiment.csv' if os.path.isfile(sentimented_file) is False: tweet_classifier = joblib.load(file_location) dataAMZN = LoadData.get_stocktwits_data('AMZN') dataAMZN['sentiment'] = dataAMZN['message'].apply(lambda x: tweet_classifier.predict([x])[0]) dataAMZN['datetime'] = dataAMZN['datetime'].apply(lambda x: x.date()) dataAMZN.rename(columns={'datetime':'date'}, inplace=True) dataAMZN.to_csv('data-extractor/stocktwits_AMZN_withsentiment.csv', index=False) sentimented_file = 'data-extractor/stocktwits_GOOGL_withsentiment.csv' if os.path.isfile(sentimented_file) is False: tweet_classifier = joblib.load(file_location) dataGOOGL = LoadData.get_stocktwits_data('GOOGL') dataGOOGL['sentiment'] = dataGOOGL['message'].apply(lambda x: tweet_classifier.predict([x])[0]) dataGOOGL['datetime'] = dataGOOGL['datetime'].apply(lambda x: x.date()) dataGOOGL.rename(columns={'datetime':'date'}, inplace=True) dataGOOGL.to_csv('data-extractor/stocktwits_GOOGL_withsentiment.csv', index=False) dataAAPL = pd.read_csv('data-extractor/stocktwits_AAPL_withsentiment.csv', parse_dates=['date'], infer_datetime_format=True) dataAMZN = pd.read_csv('data-extractor/stocktwits_AMZN_withsentiment.csv', parse_dates=['date'], infer_datetime_format=True) dataGOOGL = pd.read_csv('data-extractor/stocktwits_GOOGL_withsentiment.csv', parse_dates=['date'], infer_datetime_format=True) dataAAPL = dataAAPL.groupby(['date','sentiment'], sort=False).count() dataAMZN = dataAMZN.groupby(['date','sentiment'], sort=False).count() dataGOOGL = dataGOOGL.groupby(['date','sentiment'], sort=False).count() dataAAPL = LoadData.combine_price_and_sentiment(dataAAPL, priceAAPL) dataAMZN = LoadData.combine_price_and_sentiment(dataAMZN, priceAMZN) dataGOOGL = LoadData.combine_price_and_sentiment(dataGOOGL, priceGOOGL) dataAAPL.to_csv('data-extractor/stocktwits_AAPL_sharedata.csv', index=False) dataAMZN.to_csv('data-extractor/stocktwits_AMZN_sharedata.csv', index=False) dataGOOGL.to_csv('data-extractor/stocktwits_GOOGL_sharedata.csv', index=False) dataAAPL = pd.read_csv('data-extractor/stocktwits_AAPL_sharedata.csv', parse_dates=['date'], infer_datetime_format=True) dataAMZN = pd.read_csv('data-extractor/stocktwits_AMZN_sharedata.csv', parse_dates=['date'], infer_datetime_format=True) dataGOOGL = pd.read_csv('data-extractor/stocktwits_GOOGL_sharedata.csv', parse_dates=['date'], infer_datetime_format=True) return dataAAPL, dataAMZN, dataGOOGL @classmethod def get_stock_prediction_data(cls, symbol='ALL', type='training'): """ get the training and test data for stock prediction in format (sentiment_calculated_bullish, sentiment_calculated_bearish, sentiment_actual_previous, tweet_volume_change, cash_volume, label) Standardize the data before using. """ file_location = 'data-extractor/stockdata_'+symbol+'_'+type+'.csv' if not os.path.isfile(file_location): import numpy as np dataAAPL, dataAMZN, dataGOOGL = LoadData.aggregate_stock_price_data() combined_data = dataAAPL.append([dataAMZN, dataGOOGL], ignore_index=True) combined_data.sort_values('date') combined_data.drop(columns='date', inplace=True) combined_training, combined_test = np.split(combined_data.sample(frac=1), [int(.9*len(combined_data))]) combined_training.to_csv('data-extractor/stockdata_ALL_training.csv', index=False) combined_test.to_csv('data-extractor/stockdata_ALL_test.csv', index=False) dataAAPL.sort_values('date') dataAAPL.drop(columns='date', inplace=True) AAPL_training, AAPL_test = np.split(dataAAPL.sample(frac=1), [int(.9*len(dataAAPL))]) AAPL_training.to_csv('data-extractor/stockdata_AAPL_training.csv', index=False) AAPL_test.to_csv('data-extractor/stockdata_AAPL_test.csv', index=False) dataAMZN.sort_values('date') dataAMZN.drop(columns='date', inplace=True) AMZN_training, AMZN_test = np.split(dataAMZN.sample(frac=1), [int(.9*len(dataAMZN))]) AMZN_training.to_csv('data-extractor/stockdata_AMZN_training.csv', index=False) AMZN_test.to_csv('data-extractor/stockdata_AMZN_test.csv', index=False) dataGOOGL.sort_values('date') dataGOOGL.drop(columns='date', inplace=True) GOOGL_training, GOOGL_test = np.split(dataGOOGL.sample(frac=1), [int(.9*len(dataGOOGL))]) GOOGL_training.to_csv('data-extractor/stockdata_GOOGL_training.csv', index=False) GOOGL_test.to_csv('data-extractor/stockdata_GOOGL_test.csv', index=False) data = pd.read_csv(file_location) return data