Datasets:

anton-l

/

python_sample_10k

like 0

squaresLab/Houston

e6997b3ba693ef07ccf08a7fc7cff0ef66c2dd13

5332f9f303d38dfabf367cfaab3f75627163e4f3

/houston/ardu/home.py

b6e4c9351deadecc33cd2d38bddba5fc947c59fc

permissive

https://github.com/squaresLab/Houston

59d81aa61cf6c8d0c6172a67b382bf25843d358e

088cb52fe2d36dfb25b03b98f51b09d56f7d47d0

refs/heads/master

MIT

Python

__all__ = ('HomeLocation',) from typing import Dict, Any import attr @attr.s(frozen=True) class HomeLocation: latitude = attr.ib(type=float) longitude = attr.ib(type=float) altitude = attr.ib(type=int) heading = attr.ib(type=int) def __str__(self) -> str: return "{},{},{},{}".format(self.latitude, self.longitude, self.altitude, self.heading) @staticmethod def from_dict(d: Dict[str, Any]) -> 'HomeLocation': return HomeLocation(**d) def to_dict(self) -> Dict[str, Any]: return {'latitude': self.latitude, 'longitude': self.longitude, 'altitude': self.altitude, 'heading': self.heading}

UTF-8

Python

py

home.py

developer0hye/PyTorch-DLA

952818fa82a11ede5e83b726a97122c4754a0a49

52c7d43eb42198d1d198bfb14618e9d418e6273d

/dla.py

ece64398fa8c4152b5eae4cdcc6528b91aec142d

no_license

https://github.com/developer0hye/PyTorch-DLA

16fcc81cea2b17724d540864c504c9763b731185

b8eb62aac7c32f3387773da7164e3e7cc45e90ff

refs/heads/main

import os, sys import math import torch import torch.nn as nn import numpy as np def conv_bn_relu(in_channels, out_channels, kernel_size=3, stride=1): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=kernel_size//2, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=False)) def conv_bn(in_channels, out_channels, kernel_size=3, stride=1): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=kernel_size//2, bias=False), nn.BatchNorm2d(out_channels)) class Aggregation(nn.Module): def __init__(self, in_channels, out_channels): super(Aggregation, self).__init__() self.aggregation = conv_bn_relu(in_channels, out_channels, kernel_size=1) def forward(self, *x): x = torch.cat(x, dim=1) return self.aggregation(x) class BasicBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super(BasicBlock, self).__init__() if stride == 1: self.shortcut = nn.Identity() else: self.shortcut = nn.Sequential(nn.MaxPool2d(2), conv_bn(in_channels, out_channels, kernel_size=1)) self.conv1 = conv_bn_relu(in_channels, out_channels, stride=stride) self.conv2 = conv_bn(out_channels, out_channels) def forward(self, x): return torch.relu(self.shortcut(x) + self.conv2(self.conv1(x))) class HDATree(nn.Module): def __init__(self, depth, aggregate_root, root_channels, in_channels, out_channels, stride=1, block=BasicBlock): super(HDATree, self).__init__() self.depth = depth self.aggregate_root = aggregate_root if root_channels == 0: root_channels = out_channels * 2 if aggregate_root: root_channels += in_channels self.downsample = nn.MaxPool2d(2) if depth == 1: self.child1 = block(in_channels, out_channels, stride) self.child2 = block(out_channels, out_channels) self.aggregation = Aggregation(root_channels, out_channels) else: #recursively generate layers self.child1 = HDATree(depth=depth-1, aggregate_root=False, root_channels=0, in_channels=in_channels, out_channels=out_channels, stride=stride) self.child2 = HDATree(depth=depth-1, aggregate_root=False, root_channels=root_channels + out_channels, in_channels=out_channels, out_channels=out_channels) def forward(self, x, aggregated_features=None): if aggregated_features is None: aggregated_features = [] if self.aggregate_root: aggregated_features.append(self.downsample(x)) x1 = self.child1(x) if self.depth == 1: x2 = self.child2(x1) x = self.aggregation(x1, x2, *aggregated_features) else: aggregated_features.append(x1) x = self.child2(x1, aggregated_features) return x class DLA(nn.Module): def __init__(self, stages_depth, channels, num_classes=1000, block=BasicBlock): super(DLA, self).__init__() #Refer to 4.1. Classification Networks in paper "Deep Layer Aggregation" #"basic block" means conv_bn_relu layer in stage1 and stage2 and means one of three types of residual blocks in all other stages. #The stage 1 is composed of a 7×7 convolution followed by a basic block. self.stage1 = conv_bn_relu(3, channels[0], stride=2) #The stage 2 is only a basic block. self.stage2 = conv_bn_relu(channels[0], channels[1], stride=2) #For all other stages, we make use of combined IDA and HDA on the backbone blocks and stages. self.stage3 = HDATree(depth=stages_depth[2], aggregate_root=False, root_channels=0, in_channels=channels[1], out_channels=channels[2], stride=2) self.stage4 = HDATree(depth=stages_depth[3], aggregate_root=True, root_channels=0, in_channels=channels[2], out_channels=channels[3], stride=2) self.stage5 = HDATree(depth=stages_depth[4], aggregate_root=True, root_channels=0, in_channels=channels[3], out_channels=channels[4], stride=2) self.stages = nn.ModuleList([self.stage1, self.stage2, self.stage3, self.stage4, self.stage5]) self.gap = nn.AdaptiveAvgPool2d((1, 1))#global average pooling self.fc = nn.Conv2d(channels[4], num_classes, kernel_size=1, stride=1, padding=0, bias=True) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): nn.init.constant_(m.weight, 1.) nn.init.constant_(m.bias, 0.) def forward(self, x): y = [] for stage in self.stages: x = stage(x) y.append(x) print(x.shape) x = self.gap(x) x = self.fc(x) x = x.flatten(start_dim=1) return x if __name__ == '__main__': model = DLA([1, 1, 1, 2, 1], [32, 64, 128, 256, 512]).cuda() model.eval() x = torch.randn(1, 3, 224, 224).cuda() import time model(x) avg_time = 0 for i in range(0, 10): torch.cuda.synchronize() t2 = time.time() model(x) torch.cuda.synchronize() t3 = time.time() avg_time += t3 - t2 avg_time /= 10.0 print('avg_time: ', avg_time) # base_name = 'dla34' # x = torch.randn(1, 3, 256, 256) # model = globals()[base_name](pretrained=True, return_levels=False) # 모델 변환 torch.onnx.export(model, # 실행될 모델 x, # 모델 입력값 (튜플 또는 여러 입력값들도 가능) "dla34_yh.onnx", # 모델 저장 경로 (파일 또는 파일과 유사한 객체 모두 가능) export_params=True, # 모델 파일 안에 학습된 모델 가중치를 저장할지의 여부 opset_version=10, # 모델을 변환할 때 사용할 ONNX 버전 do_constant_folding=True, # 최적하시 상수폴딩을 사용할지의 여부 input_names = ['input'], # 모델의 입력값을 가리키는 이름 output_names = ['output'], # 모델의 출력값을 가리키는 이름 dynamic_axes={'input' : {0 : 'batch_size'}, # 가변적인 길이를 가진 차원 'output' : {0 : 'batch_size'}})

UTF-8

Python

py

dla.py

sim1234/Labirynt

a05d8eab1f3dad40b2682236f93ff0338ce09d90

ba1591113393cde9d5a06ea1d43092482ce9b9f1

/main.py

8e89d39de3271045884ac3f475341804e5a39db7

no_license

https://github.com/sim1234/Labirynt

9b67e66a950f71f97a1929ec47cbba1f76923e7e

c47b9f18c57a1b62d3a3e713168c8701f9d15177

refs/heads/master

from game import game def main(): gra = game(640,480) gra.play() if __name__ == '__main__': main()

UTF-8

Python

py

main.py

Idbruh/TrabalhosPyhton

117c8bfde1bcc9dc04019b22d6be4e52ee61ec89

43f557b2d6aa3db3c1e156c10d11813051e1902b

/Aula40/aula40.py

f3292d2eec5181d9e49624c4f14969738899ca6b

no_license

https://github.com/Idbruh/TrabalhosPyhton

3d379342c1a46a6151c6d44e4a0dfec6d0976b70

b14091b1f22959abd173622b36a84ec58506f8c5

refs/heads/master

# FLASK RESTFUL # GET N # POST # PUT # DELETE # controller herança em python - pega uma classe j gerada(importando tudo que tem em uma classe já existente)

UTF-8

Python

py

aula40.py

ressay/ArchToCE

493608a2f20ff26c3794e0c49489d81683c9bdbd

b07304822e097cc17f374c400a2b493694b47904

/Samples/tryTwo.py

9a2b1736a14b13688ad7007a5b4ba0d866484ed3

no_license

https://github.com/ressay/ArchToCE

585583cb2860be2085f5a0ee11de11c37b3c39e4

ccd194ace8257476952fbc82a1401a0ee7ca779d

refs/heads/master

Python

from OCC.Display.SimpleGui import init_display display, start_display, add_menu, add_function_to_menu = init_display() def simple_test(event=None): display.Test() def simple_cylinder(event=None): from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeCylinder s = BRepPrimAPI_MakeCylinder(60, 200).Shape() display.DisplayShape(s) add_menu('simple test') add_function_to_menu('simple test',simple_test) add_function_to_menu('simple test',simple_cylinder) display.View_Iso() display.FitAll() from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeBox my_box = BRepPrimAPI_MakeBox(10., 20., 30.).Shape() display.DisplayShape(my_box, update=True) start_display() # display loop

UTF-8

Python

py

tryTwo.py

frenck/iaqualink-py

c162d1d7a22f7137ebbf743bedc57788e83f8b3e

23c06cce660a7211e59a1e18aa5ce40b8ba9cf49

/tests/test_system.py

dd39737299db58c256d5145ebb840584e04e209a

permissive

https://github.com/frenck/iaqualink-py

0ac46f8e9f9f830efdd0df9425ded08fdd48a0a1

c75d693225556ec59e32088479be9c0fd84f6e9c

refs/heads/master

BSD-3-Clause

import asynctest import pytest from iaqualink.exception import AqualinkSystemOfflineException from iaqualink.system import AqualinkSystem, AqualinkPoolSystem from .common import async_noop, async_raises class TestAqualinkSystem(asynctest.TestCase): def setUp(self) -> None: pass @asynctest.fail_on(unused_loop=False) def test_from_data_iaqua(self): aqualink = asynctest.MagicMock() data = {"id": 1, "serial_number": "ABCDEFG", "device_type": "iaqua"} r = AqualinkSystem.from_data(aqualink, data) assert r is not None assert isinstance(r, AqualinkPoolSystem) @asynctest.fail_on(unused_loop=False) def test_from_data_unsupported(self): aqualink = asynctest.MagicMock() data = {"id": 1, "serial_number": "ABCDEFG", "device_type": "foo"} r = AqualinkSystem.from_data(aqualink, data) assert r is None @asynctest.strict async def test_update_success(self): aqualink = asynctest.MagicMock() data = {"id": 1, "serial_number": "ABCDEFG", "device_type": "iaqua"} r = AqualinkSystem.from_data(aqualink, data) r.aqualink.send_home_screen_request = async_noop r.aqualink.send_devices_screen_request = async_noop r._parse_home_response = async_noop r._parse_devices_response = async_noop await r.update() assert r.last_run_success is True assert r.online is True @asynctest.strict async def test_update_failure(self): aqualink = asynctest.MagicMock() data = {"id": 1, "serial_number": "ABCDEFG", "device_type": "iaqua"} r = AqualinkSystem.from_data(aqualink, data) r.aqualink.send_home_screen_request = async_raises await r.update() assert r.last_run_success is False assert r.online is None @asynctest.strict async def test_update_offline(self): aqualink = asynctest.MagicMock() data = {"id": 1, "serial_number": "ABCDEFG", "device_type": "iaqua"} r = AqualinkSystem.from_data(aqualink, data) r.aqualink.send_home_screen_request = async_noop r.aqualink.send_devices_screen_request = async_noop r._parse_home_response = async_raises(AqualinkSystemOfflineException) await r.update() assert r.last_run_success is True assert r.online is False

UTF-8

Python

py

test_system.py

eapb99/Commerce-Django

6f3ace025f57beea4c2110fc3b93625a4d40028d

d98d7a606b6c25e3c698cdac069b6039868bf4b9

/commerce/auctions/migrations/0002_bid_category_comment_listing.py

80b160c07b043c8cdd5e9bfb0c547f3d2f7e3e7b

no_license

https://github.com/eapb99/Commerce-Django

8def756b405e8803c7ae8272936a9b2aa43d9a3d

4303c2dc2b06145ec7178df12aba31e325f27f5f

refs/heads/master

# Generated by Django 3.1.3 on 2021-03-04 22:52 from django.conf import settings import django.core.validators from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ ('auctions', '0001_initial'), ] operations = [ migrations.CreateModel( name='Category', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('code', models.CharField(blank=True, max_length=8, null=True, unique=True)), ('name', models.CharField(max_length=32, unique=True)), ('description', models.CharField(blank=True, max_length=128, null=True)), ('image', models.URLField(max_length=500)), ], ), migrations.CreateModel( name='Listing', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('lis_name', models.CharField(max_length=50)), ('lis_description', models.CharField(max_length=500)), ('lis_image', models.CharField(max_length=500)), ('lis_active', models.BooleanField(default=False)), ('lis_date', models.DateTimeField(auto_now=True)), ('lis_price', models.DecimalField(decimal_places=2, max_digits=10, validators=[django.core.validators.MinValueValidator(1)])), ('category', models.ManyToManyField(blank=True, related_name='listing_category', to='auctions.Category')), ('lis_user', models.ForeignKey(blank=True, on_delete=django.db.models.deletion.CASCADE, related_name='listing_user', to=settings.AUTH_USER_MODEL)), ('watchlist', models.ManyToManyField(blank=True, related_name='watchlist', to=settings.AUTH_USER_MODEL)), ], ), migrations.CreateModel( name='Comment', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('content', models.CharField(max_length=500)), ('date', models.DateTimeField(auto_now_add=True)), ('listings', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='comment_listing', to='auctions.listing')), ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='comment_user', to=settings.AUTH_USER_MODEL)), ], ), migrations.CreateModel( name='Bid', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('initial', models.DecimalField(decimal_places=2, default=0, max_digits=6, validators=[django.core.validators.MinValueValidator(0.01)])), ('date', models.DateTimeField(auto_now_add=True)), ('listings', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='bid_listings', to='auctions.listing')), ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='bid_user', to=settings.AUTH_USER_MODEL)), ], ), ]

UTF-8

Python

py

0002_bid_category_comment_listing.py

Ash515/awesomeScripts

01999ca80febb3a4f4749b8c88e083e0c2d63063

54489f723841157ff6f9d3aa3d9d9590f27d2ed5

/send-discord_message/auth.py

3860d3f437292f804949ff0c01eb286f70a2aafc

permissive

https://github.com/Ash515/awesomeScripts

8126751d9cd47564e6d76726cbde38a4291cf223

3a2c0888207aca044e03ec9f387035e14879fd15

refs/heads/master

MIT

# Enter your discord channel webhook_url WEBHOOK_URL = ""

UTF-8

Python

py

auth.py

joao3872/exercios-Python

32850215bc807d4357a5c0f0a9b4259209050c8b

63a1fde24dceff2361e40d3f367bcd51b90baede

/Parte 2/desafio42.py

689cf3a13c49cb0fcd9a38d1556dee2b18686690

no_license

https://github.com/joao3872/exercios-Python

44ef9a0f17cc1c90f01f582169ff444438b53403

3d8d07635903baf78a8ca13d53016f1a1038296a

refs/heads/main

s1 = int(input('Informe o primeiro segmento: ')) s2 = int(input('Informe o segundo segmento: ')) s3 = int(input('Informe o terceiro segmento: ')) veja = ((s2 - s3) < s1 < s2 + s3) and ((s1 - s3) < s2 < s1 + s3) and ((s1 - s2) < s3 < s1 + s2) e = (s1 == s2 != s3) or (s1 != s2 == s3) or (s2 != s1 == s3) if(e and veja): print('Os Segmentos Formam um Triângulo ISÓSCELES !') elif(s1 == s2 == s3 and veja): print('Os Segmentos Formam um Triângulo EQUILÁTERO !') elif(s1 != s2 != s3 and veja): print('Os Segmentos Formam um Triângulo ESCALENO !') else: print('Os Segmentos Não formam um Triângulo.')

UTF-8

Python

py

desafio42.py

jjmalina/tumblrgifsfeed

bfc5de37ac9dba68efa04bea613cfee1f0b739e1

eaa9703b8a91de94484ac3497298c5e4595dbd8c

/app/gifs/migrations/0002_auto__add_field_photo_timestamp.py

ab1f89aa26fcf0d1c5ef4d21786d076b06892377

no_license

https://github.com/jjmalina/tumblrgifsfeed

99fb8e1b56b3c12bf20f112a07632254ad1c8c6c

16c8af8e944c37ba236880915b89fab58d84e0cf

refs/heads/master

# -*- coding: utf-8 -*- import datetime from south.db import db from south.v2 import SchemaMigration from django.db import models class Migration(SchemaMigration): def forwards(self, orm): # Adding field 'Photo.timestamp' db.add_column('gifs_photo', 'timestamp', self.gf('django.db.models.fields.IntegerField')(null=True, blank=True), keep_default=False) def backwards(self, orm): # Deleting field 'Photo.timestamp' db.delete_column('gifs_photo', 'timestamp') models = { 'gifs.photo': { 'Meta': {'object_name': 'Photo'}, 'date_downloaded': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}), 'date_posted': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}), 'height': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'note_count': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'post_url': ('django.db.models.fields.URLField', [], {'unique': 'True', 'max_length': '255'}), 'tags': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'photos'", 'symmetrical': 'False', 'to': "orm['gifs.Tag']"}), 'tags_json': ('jsonfield.fields.JSONField', [], {'null': 'True', 'blank': 'True'}), 'timestamp': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}), 'url': ('django.db.models.fields.URLField', [], {'max_length': '255'}), 'width': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}) }, 'gifs.tag': { 'Meta': {'object_name': 'Tag'}, 'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}) } } complete_apps = ['gifs']

UTF-8

Python

py

0002_auto__add_field_photo_timestamp.py

Zhiguo-Uconn/hrs_django

1802ee7ed2fa606b8d0cc4893c57c33c47d7b10c

5d828263fdd7efcf7c35061388d6e413040b6784

/hrs/PatientIdMiddleware.py

6e902e83ac5776b6207774ab3674b5b507de454c

no_license

https://github.com/Zhiguo-Uconn/hrs_django

11fee91d4b20104e8b616feb7c4f7238a8e9dfaa

c18a90fe3cdcf0192a8863689e382615d0f515f3

refs/heads/master

from django.utils.deprecation import MiddlewareMixin from django.urls import resolve class PatientIdMiddleware(MiddlewareMixin): def process_request(self, request): print("------------\n") print(hasattr(request, 'pid')) if not hasattr(request, 'pid'): request._cached_pid = 0 print(request.pid) print(resolve(request.path_info).url_name)

UTF-8

Python

py

PatientIdMiddleware.py

khs50851/git-pydjgproject1

c765aacfe66525a85111852fe0a88ca736f80e79

43c8f8f47ebe3aaff56c39a9e78d8d407f6a9aa8

/py_community/user1/models.py

a3bc5a20745585a20c42e8b08b361970667bbe9c

no_license

https://github.com/khs50851/git-pydjgproject1

d23ad38630b351d585c6fc85e32162a6ecb177c7

b6918144b43990615744e0c7b36b0d971b140ea3

refs/heads/master

from django.db import models # Create your models here. class User1(models.Model): objects = models.Manager() username = models.CharField(max_length=32, verbose_name='사용자명') useremail = models.EmailField(max_length=128, # 이메일필드는 char필드랑 비슷한데 이메일 형식으로 받게함 verbose_name='이메일') # 만약에 이메일 필드를 추가할 경우 먼저 데이터베이스에 이메일 필드 없이 데이터가 있을때 # 이메일 필드를 추가해서 migrations하면 내가 직접 default값 넣을건지 default='', verbose_name='이메일' # 아니면 지정되 default값 넣을건지 물어봄 # 우선 여기서 1번을 눌러 기본값 넣음 password = models.CharField(max_length=64, verbose_name='비밀번호') registered_dttm = models.DateTimeField(auto_now_add=True, verbose_name='등록시간') def __str__(self): # 장고 페이지에서 아이디 명에 표현된건 그냥 클래스를 문자로 나타낸거 # 파이썬에는 이 클래스가 문자열로 변환할때 어떻게 변환할지 하는 함수를 호출하는데 그게 str임 # 그렇게 유저네임을 반환하게함 return self.username class Meta: db_table = 'pydjgproject_user1' # 위에 필드에 verbose name한것처럼 여기서도 지정 verbose_name = '유저' verbose_name_plural = '유저'

UTF-8

Python

py

models.py

memimo/Timothee

a7f0b5db84b1ecf23dbb0e39e59f6c2c29c9eb35

fc2640f9cc10539c4d5475906563c05b1c2cdba5

/python/test_module.py

0491297cdb4767fb045df1b8c193dae575f83456

no_license

https://github.com/memimo/Timothee

b27c82e296e55760da177822906e124100d7b19c

0329ccbcc16855de2205013e8dbf361272368ef3

refs/heads/master

import unittest import scipy.io as sio from config import * import layer_lgn import layer_s1 import layer_c1 class timothee_model_test(unittest.TestCase): ''' All test are run with saved data from MAtlab implenetation on same data ''' def setUp(self): #Parameter initializations self.test_data_path = 'test_mat_data/' params['test_mode'] = True paths['image'] = paths['home'] + 'data/' paths['map'] = paths['home'] + 'map-test/' #params['s']['n_iter'] = 1000 params['c']['n_iter'] = 1000 #layer_lgn.compute_layer() layer_s1.layer_s1() #layer_c1.learn_c1('timothee', common) #--- LGN Layer -------------------------- def test_dog_filter(self): m_file = sio.loadmat(self.test_data_path + 'dog_filter.mat') filter_matlab = m_file['dog_filter'] self.assertTrue(allclose(filter_matlab, filter_matlab)) def test_compute_map(self): import layer_lgn internal_pos = [-3, -3] on_off_map = layer_lgn.compute_map(params['dog_filter'], paths['test_image'], params['crop_pos'], internal_pos, params['s']['rf_size'], params['on_off']['sub_sampling'], params['zoom']) m_file = sio.loadmat(self.test_data_path + 'on_off_map.mat') map_matlab = m_file['onOffMap'] for i_ind in range(len(on_off_map)): self.assertTrue(allclose(map_matlab[0,i_ind], on_off_map[i_ind])) def test_layer_lgn(self): for i_ind in range(params['c']['rf_size'][0]): for j_ind in range(params['c']['rf_size'][1]): on_off_map = load(paths['map'] + 'onoff.' + str(i_ind) + '.' + str(j_ind) + '.npy') m_file = sio.loadmat(self.test_data_path + 'onOff.' + str(i_ind + 1) + '.' + str(j_ind + 1) + '.mat') map_matlab = m_file['onOffMap'] for f_ind in range(len(on_off_map)): self.assertTrue(allclose(map_matlab[0,f_ind], on_off_map[f_ind])) #--- Layer S1 ----------------------- def test_learn_unlearn(self): import learn_unlearn common = {} common['on_off_map'] = load(paths['map'] + 'onoff.' + str(0) + '.' + str(0) + '.npy') center = learn_unlearn.learn_unlearn(len(common['on_off_map']), params['s']['n_iter'], [], [], params['rec_filter'], params['s'], common) m_file = sio.loadmat(self.test_data_path + 'center_s1.mat') center_matlab = m_file['center'] for i_ind in range(params['s']['n']): #print center[i_ind]['activity'],'\n', center_matlab[0][i_ind].activity, 'activity\n\n' #print center[i_ind]['n_firing'] ,'\n', center_matlab[0][i_ind].nFiring, 'nFiring\n\n' #print center[i_ind]['evol_theta_original'],'\n' ,center_matlab[0][i_ind].evolThetaOriginal, 'evolThetaOriginal\n\n' #print center[i_ind]['evol_threshold'],'\n' , center_matlab[0][i_ind].evolThreshold, 'evolThreshold\n\n' #print center[i_ind]['activity_threshold'],'\n' , center_matlab[0][i_ind].activityThreshold, 'activityThreshold\n\n' #print center[i_ind]['learning_rate'] ,'\n',center_matlab[0][i_ind].learningRate, 'learningRate\n\n' #print center[i_ind]['patch'] ,'\n', center_matlab[0][i_ind].patch, 'patch\n\n' #print center[i_ind]['patch'].mean() ,'\n', center_matlab[0][i_ind].patch.mean(), 'patch mean\n\n' self.assertAlmostEqual(center[i_ind]['patch'].mean(), center_matlab[0][i_ind].patch.mean(),2) self.assertTrue(allclose(center[i_ind]['patch'], center_matlab[0][i_ind].patch,2)) ''' def test_layer_s1(self): s1_map = load(paths['map'] + 's1.0.nS16_inhibMean0.0.npy') m_file = sio.loadmat(self.test_data_path + 's1.01.nS16_inhibMean0.00.mat') map_matlab = m_file['s1Map'] self.assertTrue(allclose(s1_map, map_matlab)) def test_record_responce(self): import layer_s1 m_file = sio.loadmat(self.test_data_path + 'response.mat') in_range = m_file['range'] center = m_file['center'] m_output = m_file['response'] common = {} common['on_off_map'] = load(paths['map'] + 'onoff.' + str(0) + '.' + str(0) + '.npy') response = layer_s1.record_response(in_range - 1, False, center, common) self.assertTrue(allclose(m_output, response)) #--- Layer C1 -------------------------------- def test_layer_c1_timothee(self): import pickle import learn_invariance cfile = open(paths['map'] + 'common.' + params['comp_name'] + '.' + params['s']['type'] + '.pck', 'r') common = pickle.load(cfile) common['weight'], common['evol'], common['thr'], common['n_firing_input'], common['n_firing_output'], common['n_above_thr'] = learn_invariance.learn_invariance([], params['c'], common) m_file = sio.loadmat(self.test_data_path + 'c1-timothee.mat') matlab_common = m_file['COMMON'][0][0] self.assertTrue(allclose(common['weight'], matlab_common.weight)) self.assertTrue(allclose(common['evol'], matlab_common.evol)) self.assertTrue(allclose(common['thr'], matlab_common.thr)) self.assertTrue(allclose(common['n_firing_input'], matlab_common.nFiringInput)) self.assertTrue(allclose(common['n_above_thr'], matlab_common.nAboveThr)) #--- Analyze ------------------------ def rf_reconstruction(self): from analyze import * m_file = sio.loadmat(self.test_data_path + 'rf.mat') rf = m_file['rf'] py_rf = rf_reconstruction(rf, params['rec_filter'], False) mat_rf = m_file['reconst_rf'] self.assertTrue(allclose(py_rf, mat_rf)) ''' if __name__ == "__main__": unittest.main()

UTF-8

Python

py

test_module.py

deddokatana/RestCart

b682e40d053431abae79648e3b79c8f58a700f61

b4025cb015feb804018109adf88564bc5ded2f02

/Transactions/objects.py

ec20f7baf45b65d284f02f5445236451eacedd3a

no_license

https://github.com/deddokatana/RestCart

7ae186a0837932dadf3411bf885969991a7d5469

9ae647d6fe913d0e178a3a28ab55fe6f3418d349

refs/heads/master

from decimal import * from money import Money, xrates xrates.install('money.exchange.SimpleBackend') # counting tools from collections import Counter from itertools import chain import json # use google datastore to pickle an order! class Order: def __init__(self,currency_code:str='GBP'): self.currency_code = currency_code self.order_dict = {} print(self.currency_code) self.total = Money(amount=0,currency=self.currency_code) def _new_total(self): for name,properties in self.order_dict.items(): # print("Properties",properties["price"]) debbuging subtotal = Decimal(properties["price"]) * Decimal(int(properties["quantity"])) self.total = self.total + Money(subtotal,self.currency_code) def add_to_order_from_dict(self, paypal_transaction_item_list:dict): self.order_dict.update(paypal_transaction_item_list) self._new_total() return self.order_dict def from_json(self,order_json:str): self.order_dict = json.loads(order_json) self._new_total() return self.order_dict def total_to_gbp(self): return self.total.to('GBP') def total_to_currency(self,new_currency_code:str): return self.total.to(new_currency_code) def add_line(self,item:str,cost:str,quantity:int=1): for line in range(quantity): self.order_dict.update({str(item):str(cost)}) self._new_total() return self.order_dict def to_paypal_transaction_items_list(self): # convert order_dict to {"wax":{price:"1.00",quantity:1},"candle":{price:"1.00",quantity:2}} self._new_total() # just for foolproofing paypal_items = {"items":[]} print(self.order_dict) for item, properties in self.order_dict.items(): paypal_items["items"].append({"name":item,"sku":item,"price":properties["price"],"currency":str(self.total.currency),"quantity":properties["quantity"]}) print(paypal_items) return paypal_items def __money__(self): assert isinstance(self.total,Money) return self.total def __decimal__(self): return Decimal(self.total.amount)

UTF-8

Python

py

objects.py

edt-yxz-zzd/python3_src

e2939486698ce754c59fe25e3340e16559ab2f20

13f4a06cd439f579e34bf38406a9d5647fe7a0f3

/nn_ns/ply_yacc_tools/app/show_yacc_productions.py

eac2b479877acdd9079ba75f749a258389ec3052

no_license

https://github.com/edt-yxz-zzd/python3_src

43d6c2a8ef2a618f750b59e207a2806132076526

41f3a506feffb5f33d4559e5b69717d9bb6303c9

refs/heads/master

r''' pym -jq parse__grammar_units.py pym show_yacc_productions.py M -m nn_ns.my_fileformat.configuration.utils.parses.parse__grammar_units -da .P pym show_yacc_productions.py S -p nn_ns.my_fileformat.configuration.utils.parses -np parse__grammar_units@E:\my_data\program_source\github\edt-yxz-zzd\python3_src\nn_ns\my_fileformat\configuration\utils\parses\parse__grammar_units.py -da .P ''' __all__ = ''' show_extracted_yacc_rules extract_rules_from_yacc_productions extract_rules_from_yacc_lrparser extract_rules_from_lex_postprocessor_with_parser show_yacc_productions show_yacc_productions_from_yacc_lrparser show_yacc_productions_from_lex_postprocessor_with_parser '''.split() from ..make_yacc_LRParser import make_yacc_LRParser from ..LexPostprocessors.ILexPostprocessorWithParser import \ ILexPostprocessorWithParser from seed.pkg_tools.get_python_object import GetPythonObjectHelper import ply.yacc from collections import defaultdict def show_extracted_yacc_rules(rules): '''rules :: [(name, [[name]])] see: extract_rules_from_yacc_productions ''' for name, body in rules: print(name) op = ':' for names in body: line = ' '.join(names) print(f' {op} {line}') op = '|' return def extract_rules_from_yacc_productions(productions): '''[production] -> [rule] [ply.yacc.MiniProduction] -> [(name, [[name]])] productions :: [ply.yacc.MiniProduction] rules :: [(name, [[name]])] body :: [[name]] rules = name_body_pairs ''' d = defaultdict(list) for production in productions: name = production.name name_, _names_ = production.str.split('->') names = _names_.split() d[name].append(names) rules = name_body_pairs = sorted(d.items()) return rules def extract_rules_from_yacc_lrparser(lrparser): '''ply.yacc.LRParser -> [(name, [[name]])]''' productions = lrparser.productions return extract_rules_from_yacc_productions(productions) def extract_rules_from_lex_postprocessor_with_parser( lex_postprocessor_with_parser): '''LexPostprocessorWithParser -> [(name, [[name]])]''' lrparser = lex_postprocessor_with_parser.lrparser return extract_rules_from_yacc_lrparser(lrparser) ############################################# def show_yacc_productions(productions): rules = extract_rules_from_yacc_productions(productions) show_extracted_yacc_rules(rules) def show_yacc_productions_from_yacc_lrparser(lrparser): rules = extract_rules_from_yacc_lrparser(lrparser) show_extracted_yacc_rules(rules) def show_yacc_productions_from_lex_postprocessor_with_parser( lex_postprocessor_with_parser): rules = extract_rules_from_lex_postprocessor_with_parser(lex_postprocessor_with_parser) show_extracted_yacc_rules(rules) ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# ############################################# def main(argv=None): #seed.io.get_python_object.get_python_object/GetPythonObjectHelper ''' ModuleSystem --module x.y.z --dot_attrs .XXX.YYY ScriptAsModule # to set the __name__ --parent x.y [--name_with_path z@path/to/XXX.py]+ --dot_attrs .XXX.YYY #from file/stdin/arg Exec/Eval file --input_path path/to/XXX.py --encoding utf8] --dot_attrs .XXX.YYY stdin --dot_attrs .XXX.YYY arg --python_source --dot_attrs .XXX.YYY ''' import argparse parser_main = argparse.ArgumentParser(prog='show_yacc_productions') subparsers_main = parser_main.add_subparsers( dest='sub_command_name__level1' #, required=True , help='level1 sub-command help' ) subparsers_main.required=True parser_ModuleSystem = subparsers_main.add_parser('ModuleSystem' , aliases='M'.split() , help='via ModuleSystem') parser_ScriptAsModule = subparsers_main.add_parser('ScriptAsModule' , aliases='S'.split() , help='via ScriptAsModule') parser_Exec = subparsers_main.add_parser('Exec' , aliases='X'.split() , help='via Exec') parser_Eval = subparsers_main.add_parser('Eval' , aliases='V'.split() , help='via Eval') init_parser_ModuleSystem(parser_ModuleSystem) init_parser_ScriptAsModule(parser_ScriptAsModule) init_parser_Exec_or_Eval(parser_Exec) init_parser_Exec_or_Eval(parser_Eval) #init_parser__dot_attrs(parser_main) ################ args = parser_main.parse_args(argv) #dot_attrs = args.dot_attrs #cmd = parser_main.sub_command_name__level1 # the 'dest' x = the_object = args._handler_1_(args) if isinstance(x, ILexPostprocessorWithParser): rules = extract_rules_from_lex_postprocessor_with_parser(x) elif isinstance(x, ply.yacc.LRParser): rules = extract_rules_from_yacc_lrparser(x) else: #assume it is an module/class required by yacc lrparser = make_yacc_LRParser(x) rules = extract_rules_from_yacc_lrparser(lrparser) show_extracted_yacc_rules(rules) def init_parser__level1(_handler_1_, parser_level1): init_parser__dot_attrs(parser_level1) init_parser__level1__without_dot_attrs(_handler_1_, parser_level1) def init_parser__level1__without_dot_attrs(_handler_1_, parser_level1): parser_level1.set_defaults(_handler_1_=_handler_1_) def init_parser__level2(_handler_2_, parser_level2): init_parser__dot_attrs(parser_level2) parser_level2.set_defaults(_handler_2_=_handler_2_) def init_parser_ModuleSystem(parser_ModuleSystem): parser_ModuleSystem.add_argument('-m', '--module', type=str , required=True , help='module fullname; qname; x.y.z' ) def _handler_1_(args): return GetPythonObjectHelper.ModuleSystem( module=args.module ,dot_attrs=args.dot_attrs ) init_parser__level1(_handler_1_, parser_ModuleSystem) def init_parser_ScriptAsModule(parser_ScriptAsModule): parser_ScriptAsModule.add_argument('-p', '--parent', type=str , required=True , help='normal package fullname; qname; x.y.z' ) parser_ScriptAsModule.add_argument('-np', '--name_path_pairs' , type=str, action = 'append', default = [] #not required#, required=True , help='bare module name with path to its source file; aaa@path/to/aaa.py' ) def _handler_1_(args): return GetPythonObjectHelper.ScriptAsModule( parent=args.parent ,name_path_pair_strs= args.name_path_pairs ,dot_attrs=args.dot_attrs ) init_parser__level1(_handler_1_, parser_ScriptAsModule) def init_parser_Exec_or_Eval(parser_E): Exec_or_Eval = sub_command_name__level1 = parser_E.prog subparsers_E = parser_E.add_subparsers( dest='Exec_or_Eval_sub_command_name' , help='{Exec_or_Eval} sub-command help') parser_E_file = subparsers_E.add_parser('file' , aliases='f'.split() , help='from file') parser_E_stdin = subparsers_E.add_parser('stdin' , aliases='i'.split() , help='from stdin') parser_E_arg = subparsers_E.add_parser('arg' , aliases='a'.split() , help='from arg') init_parser_Exec_or_Eval_file(parser_E_file) init_parser_Exec_or_Eval_stdin(parser_E_stdin) init_parser_Exec_or_Eval_arg(parser_E_arg) def _handler_1_(args): Exec_or_Eval = args.sub_command_name__level1 G = GetPythonObjectHelper E = G.Exec if Exec_or_Eval == 'Exec' else G.Eval return args._handler_2_(E, args) # well, we can set _handler_2_ to _handler_1_ #not!!!: init_parser__level1(_handler_1_, parser_E) # donot: init_parser__dot_attrs init_parser__level1__without_dot_attrs(_handler_1_, parser_E) def init_parser_Exec_or_Eval_file(parser_E_file): parser_E_file.add_argument('-i', '--input_path', type=str , required=True , help='path to input file' ) parser_E_file.add_argument('-e', '--encoding', type=str , required=True , help='encoding for input file' ) def _handler_2_(E, args): return E.file( input_path=args.input_path ,encoding= args.encoding ,dot_attrs=args.dot_attrs ) init_parser__level2(_handler_2_, parser_E_file) def init_parser_Exec_or_Eval_stdin(parser_E_stdin): def _handler_2_(E, args): return E.stdin( dot_attrs=args.dot_attrs ) init_parser__level2(_handler_2_, parser_E_stdin) def init_parser_Exec_or_Eval_arg(parser_E_arg): parser_E_arg.add_argument('python_source', type=str #, required=True , help='python source code' ) def _handler_2_(E, args): return E.stdin( python_source=args.python_source ,dot_attrs=args.dot_attrs ) init_parser__level2(_handler_2_, parser_E_arg) def init_parser__dot_attrs(parser): parser.add_argument('-da', '--dot_attrs', type=str , required=True , help='attrs to object; .XXX.YYY' ) if __name__ == "__main__": main()

UTF-8

Python

py

show_yacc_productions.py

suraj93/IITM-Course-Codes

7dd364d8d1cff14995e272ac807673efb33a76b4

326940c9e5ca002ec8c3400e45cd6e3cb4c2b98c

/Computational Methods for EE/Assignment 1 - Polynomial Interpolation/q6/pypolint.py

6a15659abf43a61c029de9f56b583bdafb88c7fe

no_license

https://github.com/suraj93/IITM-Course-Codes

d33de57b7b8759a8f56d77e6f00d3110cba4c5c6

ed0ca14cdff0341580122f0d4e1a196f1417e1e4

refs/heads/master

import numpy as np def polint(xa,ya,n,x): diffarr=np.array([(xai-x) for xai in xa]) diff=min(abs(diffarr)) ns=np.where(abs(diffarr)==diff)[0][0] c=np.array(ya) d=np.array(ya) y=ya[ns] for m in range(1,(n)): ho=diffarr[0:n-m] hp=diffarr[m:n] # print c # print d w=c[1:n-m+1]-d[0:n-m] den=ho-hp den=w*(1./den) c=ho*den d=hp*den if 2*ns < n-m: dy=c[ns] else: ns-=1 dy=d[ns] y+=dy # print "%d %f %d %d" %(m,y,ns,n-m) return [y,dy] def findnearest(xa,n,x): diffarr=np.array([(xai-x) for xai in xa]) len_diffarr=len(diffarr) diff=min(abs(diffarr)) ns=np.where(abs(diffarr)==diff)[0][0] if abs(diff) <1: if diff<=0.5: lower=ns-np.floor((n-1)/2)-1 upper=ns+np.ceil((n)/2)-1 else: lower=ns-np.floor((n-1)/2) upper=ns+np.ceil((n)/2) else: lower=ns-np.floor((n-1)/2) upper=ns+np.ceil((n)/2) if lower<0: upper+=(-1*lower) lower=0 elif upper>(len_diffarr-1): lower-=(upper-len_diffarr+1) upper=len_diffarr-1 upper+=1 return [int(lower),int(upper)] def nearestpolint(xa,ya,n,xx): y=np.zeros_like(xx) dy=np.zeros_like(xx) for i in range(0,len(xx)): x=xx[i] [lower,upper]=findnearest(xa,n,x) [y[i],dy[i]]=polint(xa[lower:upper],ya[lower:upper],n,x) return [y,dy] # xa=[1,2,3,4,5]; # ya=[1,2,3,2,1]; # n=5; # x=1.2 # [lower,upper] = findnearest(xa,n,x) # print xa[lower:upper] # print ya[lower:upper] # [y,dy]=polint(xa[lower:upper],ya[lower:upper],n,x) # print y # print dy

UTF-8

Python

py

pypolint.py

jameschanwz/LegalDocGenerator

d9ef1e7a9acaf6674c2aa5e8ab3f7ad4747a4df6

c9f9b19837c96f51d63ace524836110abb51d09f

/app/email.py

98b843e4e6def342be3e403b3cb3095dbeb1649b

no_license

https://github.com/jameschanwz/LegalDocGenerator

7856fcae2dd56355d42a75248b977ef423fb768d

5225353bf12cbc0871b0ad5ef7101680bb8da143

refs/heads/main

Python

from flask_mail import Message from app import mail def send_email(subject,sender, recipients, text_body,html_body): msg = Message(subject, sender=sender, recipients=recipients) msg.body = text_body msg.html = html_body mail.send(msg)

UTF-8

Python

py

email.py

pong-xxyz/SaRA

13e7d4b2770f3183b2db443554d1d23daf102834

e5b51b92430a7f13f81ebec251c4b53bea730c21

/Pi_navigatorClient.py

f5347a71011f34f449b54610772ff302b79b22b0

no_license

https://github.com/pong-xxyz/SaRA

27cf1267a977fffa5d471c32985a765bdfda25eb

4f72248c583cd0922e25cd3336bb063316bb75db

refs/heads/master

import socket import time import RPi.GPIO as gpio import sys host = 'xxx.xxx.xx.xxx' #address of the pi in the Lan, find through ifonfig port = xxxx #random unused port, ie above 1000 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.bind((host,port)) #socket for getting data from surf program..ie centroid host2 = 'xxx.xxx.xx.xx' #address of the pi in the Lan, find through ifonfig port2 = xxx #random unused port, diff from previous one , ie above 1000 e = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) e.bind((host2,port2)) #socket for getting distance from ultransonic sensor program e.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1) #sets the buffer queue length to 1, ie. dont need to save previous values more than one in number def init(): gpio.setmode(gpio.BOARD) gpio.setup(19, gpio.OUT) gpio.setup(11, gpio.OUT) gpio.setup(13, gpio.OUT) gpio.setup(15, gpio.OUT) def rotateleft(tf): init() gpio.output(19,True) gpio.output(11,False) gpio.output(13,True) gpio.output(15,False) time.sleep(tf) gpio.cleanup() def rotateright(tf): init() gpio.output(19,False) gpio.output(11,True) gpio.output(13,False) gpio.output(15,True) time.sleep(tf) gpio.cleanup() def foreward(tf): init() gpio.output(19,False) gpio.output(11,False) gpio.output(13,True) gpio.output(15,True) time.sleep(tf) gpio.cleanup() def search(): while True: print "searching .." rotateright(0.030) data, addr = s.recvfrom(1024) #get centroid form surf program as string end = len(data) clon = data[1:(end-1)] p, q = map(float, clon.split(',')) # string decoded into float if (p == -1)&(q == -1): pass #if object not found do nothing and go to next iteration else: #if object found start to verify count = 0 r = time.time() t = time.time() while t-r < 1.5: #verification period = 1.5 sec, t=stop, r=start times respectively print "verifying" data, addr = s.recvfrom(1024) end = len(data) clon = data[1:(end-1)] p, q = map(float, clon.split(',')) if p!=-1 and q!=-1: #object found count = count+1 #increment count if obj found t = time.time() #stop time increases till t-r < 1.5, ie. verification runs till 1.5 sec if count > 5: #if object found more than 5 time in verify period, search phase complete print "verified" break else: pass return 2 def allignment(): flag = 0 lag = 0 while True: data, addr = s.recvfrom(1024) end = len(data) clon = data[1:(end-1)] p, q = map(float, clon.split(',')) if p ==-1 and flag==0: #if obj dissapears durng allignment start timer start = time.time() flag = 1 if p ==-1 and flag!=0: #if object not found still , increment counter stop = time.time() lag = stop - start # lag gives time elapsed for which object dosent appear once if lag > 5: #if object dissapears for more than 5 sec search again return 1 if p<283.0 and p!=-1: print "rotating left" rotateleft(0.030) start = time.time() flag = 0 #if the object appears even once reset timer if p>339.0: print "rotating right" rotateright(0.030) start = time.time() flag = 0 if 283 < p < 339: print 'aligned' start = time.time() break #if alligned break and go to ram(), to move closer to the target return 3 def ram(): datak, adres= e.recvfrom(1024) d = float(datak) #get distance from ultrasonic sensor program print d flag=0 lg=0 while d>10: data, addr = s.recvfrom(1024) end = len(data) clon = data[1:(end-1)] p, q = map(float, clon.split(',')) datak, adres = e.recvfrom(1024) d = float(datak) print d if 283 < p < 339: #if still alligned move foreward foreward(0.030) flag=0 elif not(283 < p < 339) and p!=-1: #if allignment lost goto allignment() r = allignment() flag=0 else: #if object lost for more than 5 sec go back to search() if flag==0: st = time.time() flag=1 else: en = time.time() lg = en-st if lg>5: return 1 return 4 def pickup(): #pickup rputine to be written print "pickup routine" time.sleep(5) return 5 def fetch(): print "fetching routine" time.sleep(5) return 6 def Main(): c = 1 try: while True: if c==1: c = search() if c==2: c = allignment() if c==3: c = ram() if c==4: c = pickup() if c==5: c = fetch() if c==6: s.close() e.close() gpio.cleanup() print "port closed" break except KeyboardInterrupt: s.close() e.close() gpio.cleanup() print "port closed" if __name__=='__main__': Main()

UTF-8

Python

py

Pi_navigatorClient.py

MnM3882/Laboratorio-remoto

8ebe36ac1cfa63e06389959523ed67d1400498d4

70fe9c43026169aca02144a9a7f47e074185783a

/SerialCommunication y GUI/180404Lab_remoto .py

eaa482f36058f76befe43782bbee2684a6291051

no_license

https://github.com/MnM3882/Laboratorio-remoto

55be641b3633f435ee52bb55cf7a0bab439cb01d

a8376d98fb34bbfc7c667c08bfa4c43f8c5bd021

refs/heads/master

import os import demoscope3 from tkinter import * from tkinter import ttk, Canvas master = Tk() master.title("Laboratorio remoto- LFN USB") master.geometry('700x700') top_frame = Frame(master, bg='white', width = 700, height=700, padx=10, pady=10) #top_frame.grid(column=0, row=0) top_frame.pack(side= TOP, fill=BOTH) lbl = Label(top_frame, text="Laboratorio remoto - Espectrometría gamma", font=("Times New Roman", 20),bg='white') lbl.pack(side=TOP, padx=10, pady=10) #left_frame = Frame(master, bg='white', width = 300) #left_frame.grid(column=0, row=5) #left_frame.pack(side= LEFT, fill=BOTH) #right_frame = Frame(master, bg='white', width = 300) #right_frame.grid(column=10, row=5) #right_frame.pack(side= RIGHT, fill=BOTH) #center_frame=Frame(master, bg='white', width=500, height=1000) #center_frame.pack(side=TOP, fill=X) #Para probar que los indices de los obstáculos sean los correctos def cambiar_obstaculo(): demoscope3.move_noria(obstaculo.get()) def def_distancia(): demoscope3.move_Zahlrohr_sharp(distancia.get()) #print(distancia.get()) #Lista de obstáculos de la noria obstaculo = IntVar() lbl_obs=Label(top_frame, text="Seleccione el atenuador que desea\n interponer entre la muestra y el detector", font=("Times New Roman", 12),bg='white', padx=10,pady=10) lbl_obs=lbl_obs.pack(side= TOP, fill=Y) #lbl_obs.grid(pady=20,column=0, row=2) # left_canvas=Canvas(left_frame) # left_canvas.create_line(15, 25, 200, 25) # left_canvas.grid(column=0, row=2) obs0 = Radiobutton(top_frame,text='Sin atenuador', value=0, variable=obstaculo, bg='white',font=("Times New Roman", 12)) obs1 = Radiobutton(top_frame,text='Al 2.550cm', value=1, variable=obstaculo,bg='white',font=("Times New Roman", 12)) obs2 = Radiobutton(top_frame,text='Pb 0.080cm', value=2, variable=obstaculo,bg='white',font=("Times New Roman", 12)) obs4 = Radiobutton(top_frame,text='Al 0.935cm', value=4, variable=obstaculo,bg='white',font=("Times New Roman", 12)) obs5 = Radiobutton(top_frame,text='Pb 0.320cm', value=5, variable=obstaculo,bg='white',font=("Times New Roman", 12)) obs6 = Radiobutton(top_frame,text='Al 0.450cm ', value=6, variable=obstaculo,bg='white',font=("Times New Roman", 12)) obs7 = Radiobutton(top_frame,text='Pb 0.160cm', value=7, variable=obstaculo,bg='white',font=("Times New Roman", 12)) btn = Button(top_frame, text="Cambiar obstáculo", command=cambiar_obstaculo, font=("Times New Roman", 12)) obs0.pack(side= TOP, fill=Y) obs1.pack(side= TOP, fill=Y) obs2.pack(side= TOP, fill=Y) obs4.pack(side= TOP, fill=Y) obs5.pack(side= TOP, fill=Y) obs6.pack(side= TOP, fill=Y) obs7.pack(side= TOP, fill=Y) btn.pack(side= TOP, fill=Y, pady=10) # obs0.grid(padx=2, pady=2, column=0, row=4) # obs1.grid(padx=2, pady=2, column=0, row=5) # obs2.grid(padx=2, pady=2, column=0, row=6) # obs4.grid(padx=2, pady=2, column=0, row=7) # obs5.grid(padx=2, pady=2, column=0, row=8) # obs6.grid(padx=2, pady=2, column=0, row=9) # obs7.grid(padx=2, pady=2, column=0, row=10) # btn.grid(padx=2, pady=2, column=0, row=12) #Lista de distancias distancia=StringVar() lbl_distancia=Label(top_frame, text="Defina la distancia en cm\nentre el detector y la muestra", font=("Times New Roman", 12),bg='white') lbl_distancia.pack(side= TOP, fill=Y) dist_array=['8.3','10','11.7','13.4','15.1','16.8','18.5','20.2','21.9','23.6','25.3','27','28.7','30.4','32.1','33.8'] #lbl_distancia.grid(column=0, row=15, pady=20) dist_menu=OptionMenu(top_frame, distancia, *dist_array) distancia.set('8.3') dist_menu.pack(side=TOP, fill=Y, pady=10) # distancia = Spinbox(top_frame, from_=0, to=5, width=5) # distancia.pack(side= TOP, fill=Y,pady=10) #distancia.grid(pady=10,column=0,row=20) #lbl_cm=Label(left_frame, text="cm",font=("Times New Roman", 12),bg='white') #lbl_cm.grid(column=1,row=20) btn = Button(top_frame, text="Seleccionar", command=def_distancia, font=("Times New Roman", 12)) btn.pack(side= TOP, fill=Y,pady=10) #btn.grid(padx=2, pady=2, column=0, row=22) Nbuttons = 6 def buttonfunction(index): for i in range(Nbuttons): buttons[i].config(state="disabled") if index == 0: demoscope3.scope() elif index == 1: demoscope3.storedata(300) elif index == 2: demoscope3.plotsignal() elif index == 3: demoscope3.plotfourier() elif index == 4: demoscope3.plothistogram() elif index == 5: os.system('clear') exit() for i in range(Nbuttons): buttons[i].config(state="active") button_names = ['Plotear en tiempo real', 'Adquirir y almacenar', 'Graficar senal adquirida', 'Transformada de Fourier', 'Histograma', 'Salir'] buttons = [] for index in range(Nbuttons): n=button_names[index] button = Button(top_frame, bg="White", text=n, relief=GROOVE, command=lambda index=index, n=n: buttonfunction(index),font=("Times New Roman", 12)) # Add the button to the window button.pack(side=TOP, fill=Y) # Add a reference to the button to 'buttons' buttons.append(button) mainloop()

UTF-8

Python

py

180404Lab_remoto .py

goddess5321/classifier_gar

79d6f4fe3eaf57ab4ff6ca369cf08926bcf5477a

0679d3e3b0725c9c912f2d60117c027dbd064166

/data_enhance.py

089a3bd1120f740531324338707189805a4e28c3

no_license

https://github.com/goddess5321/classifier_gar

8ca14459dccb9b3b47d4f5d093af04e3c954183e

86b3522ad9d545816cb5e56fa5e9edf5a9140e67

refs/heads/master

import torch as t from torchvision import transforms import random def image_transforms(size=224): fr_transforms = transforms.Compose([ transforms.Resize(size), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(45), #transforms.ColorJitter(brightness=0.05, contrast=0.1, saturation=0.3, hue=0.2), transforms.ToTensor(), transforms.Normalize(mean=(0.5,0.5,0.5), std=(0.5,0.5,0.5)) ]) return fr_transforms def enhance_transforms(): possibility = random.randint(0, 19) if possibility % 20 ==0: output_transforms = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=(0.5,0.5,0.5), std=(0.5,0.5,0.5))]) return output_transforms else: possibility2 = random.randint(0, 3) if possibility2%5==0: return image_transforms(224) elif possibility2%5==1: return image_transforms(245) elif possibility2%5==2: return image_transforms(274) elif possibility2%5==3: return image_transforms(316) def transform_standard(): output_transforms = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=(0.5,0.5,0.5), std=(0.5,0.5,0.5)) ]) return output_transforms

UTF-8

Python

py

data_enhance.py

renjch/PythonTeachingProgram

8801192f93ae582743fae3ad815b978fcbf793d1

012793075896cc2a3db3c85b23258166567e94f8

/tutor/hello-world-third-edition/Listing_13-4_creating_and_using_a_function_that_returns_a_value.py

b341d9587a1847ca7237f33a89ee915363d015ca

no_license

https://github.com/renjch/PythonTeachingProgram

64e8b7aebd6624dd61213a5c093e1ac6dd071c35

7d14fe0719a19f674664e03bb69e7a43547ac8d5

refs/heads/master

# Listing_13-4_creating_and_using_a_function_that_returns_a_value.py # Copyright Warren & Carter Sande, 2009-2019 # Released under MIT license https://opensource.org/licenses/mit-license.php # ------------ # Function calculates tax and returns total def calculateTax(price, tax_rate): total = price + (price * tax_rate) return total # Sends result back to the main program my_price = float(input("Enter a price: ")) totalPrice = calculateTax(my_price, 0.06) # Calls function and stores the result in `totalPrice` print("price = ", my_price, " Total price = ", totalPrice)

UTF-8

Python

py

Listing_13-4_creating_and_using_a_function_that_returns_a_value.py

gmdsam/perched-peacock-api

8fbdbb6a04ef7e153fac0f041a990d628de44150

4d2eb0c849892d9d43d239be5a687bc5c297d1f0

/parking/core/models/parking_entry.py

5db3e9cafa47857abb70cf099f177cbd3a04f10c

no_license

https://github.com/gmdsam/perched-peacock-api

7a5599a0aeb59b5b7ee6427ce1e89d83404aa1b3

37b5edfa015d5dc44dd08083ef88898566c7cbb0

refs/heads/master

Python

class ParkingEntryModel: def __init__(self, arrival_date, arrival_time, departure_date, departure_time, vehicle_type, vehicle_number=None): self._arrival_date = arrival_date self._arrival_time = arrival_time self._departure_date = departure_date self._departure_time = departure_time self._vehicle_type = vehicle_type self._vehicle_number = vehicle_number

UTF-8

Python

py

parking_entry.py

azad17/api_test

1acb37ff430a04a4f2e396789a71f2a373917d43

3e552827febbef77de1e0c1e6d4de693c24565d3

/global_api/api/v1/views.py

9416e9aaa13074422d649386e0a1ccb97f420e37

no_license

https://github.com/azad17/api_test

72c1b64abc07e838a1aada051631bf64c77cd16b

48b526c1a2cb4c71e6258814572be417f664aef4

refs/heads/main

import datetime as dt import json import time import urllib from collections import defaultdict from rest_framework import status from rest_framework.response import Response from rest_framework.views import APIView SHIFT_API_URL = 'https://gitlab.com/-/snippets/2094509/raw/master/sample_json_1.json' MACHINE_API_URL = 'https://gitlab.com/-/snippets/2094509/raw/master/sample_json_2.json' BELT_API_URL = 'https://gitlab.com/-/snippets/2094509/raw/master/sample_json_3.json' '''creating a class to calculate the shift count''' class ShiftCountApi(APIView): def get(self, request): #checking the user queries in a try block try: start_time = dt.datetime.strptime(request.query_params.get("start_time"), "%Y-%m-%dT%H:%M:%SZ") end_time = dt.datetime.strptime(request.query_params.get("end_time"), "%Y-%m-%dT%H:%M:%SZ") except TypeError: return Response({}, status=status.HTTP_400_BAD_REQUEST) result = urllib.request.urlopen(SHIFT_API_URL) data = json.loads(result.read()) #lambda function to filter out values in the given time intervals filter_date_range = lambda x: True if start_time <= dt.datetime.strptime( x['time'], "%Y-%m-%d %H:%M:%S") < end_time else False filtered_data = filter(filter_date_range, data) shifts = {"shiftA": { "start": dt.time(6), "end": dt.time(14) }, "shiftB": { "start": dt.time(14), "end": dt.time(20) }, "shiftC": { "start": dt.time(20), "end": dt.time(6) }, } shift_count = { "shiftA": {"production_A_count": 0, "production_B_count": 0}, "shiftB": {"production_A_count": 0, "production_B_count": 0}, "shiftC": {"production_A_count": 0, "production_B_count": 0}, } for shift in filtered_data: time1 = dt.datetime.strptime(shift['time'], "%Y-%m-%d %H:%M:%S").time() if shifts['shiftA']['start'] < time1 < shifts['shiftA']['end']: shift_count['shiftA']['production_A_count'] = shift_count['shiftA']['production_A_count'] + 1 if shift[ 'production_A'] else shift_count['shiftA']['production_A_count'] shift_count['shiftA']['production_B_count'] = shift_count['shiftA']['production_B_count'] + 1 if shift[ 'production_B'] else shift_count['shiftA']['production_B_count'] elif shifts['shiftB']['start'] < time1 < shifts['shiftB']['end']: shift_count['shiftB']['production_A_count'] = shift_count['shiftB']['production_A_count'] + 1 if shift[ 'production_A'] else shift_count['shiftB']['production_A_count'] shift_count['shiftB']['production_B_count'] = shift_count['shiftB']['production_B_count'] + 1 if shift[ 'production_B'] else shift_count['shiftB']['production_B_count'] else: shift_count['shiftC']['production_A_count'] = shift_count['shiftC']['production_A_count'] + 1 if shift[ 'production_A'] else shift_count['shiftC']['production_A_count'] shift_count['shiftC']['production_B_count'] = shift_count['shiftC']['production_B_count'] + 1 if shift[ 'production_B'] else shift_count['shiftC']['production_B_count'] return Response(shift_count) '''class to find out the total run time, downtime and machine utilization in a given time inetrval''' class MachineUtilization(APIView): def get(self, request): try: start_time = dt.datetime.strptime(request.query_params.get("start_time"), "%Y-%m-%dT%H:%M:%SZ") end_time = dt.datetime.strptime(request.query_params.get("end_time"), "%Y-%m-%dT%H:%M:%SZ") except TypeError: return Response({}, status=status.HTTP_400_BAD_REQUEST) result = urllib.request.urlopen(MACHINE_API_URL) data = json.loads(result.read()) filter_daterange = lambda x: True if start_time < dt.datetime.strptime( x['time'], "%Y-%m-%d %H:%M:%S") < end_time else False filtered_data = filter(filter_daterange, data) max_runtime = 1021 machine_data = { 'runtime': 0, 'downtime': 0, 'utilisation': 0 } for data in filtered_data: machine_data['runtime'] += data['runtime'] if data['runtime'] > max_runtime: machine_data['downtime'] += (data['runtime'] - max_runtime) machine_data['utilisation'] = (machine_data['runtime']) / ( machine_data['runtime'] + machine_data['downtime']) * 100 machine_data['runtime'] = time.strftime("%Hh:%Mm:%Ss", time.gmtime(machine_data['runtime'])) machine_data['downtime'] = time.strftime("%Hh:%Mm:%Ss", time.gmtime(machine_data['downtime'])) return Response(machine_data) ''' a class to find out average of belt1 and belt2 in the given time interval''' class BeltAverage(APIView): def get(self, request): try: start_time = dt.datetime.strptime(request.query_params.get("start_time"), "%Y-%m-%dT%H:%M:%SZ") end_time = dt.datetime.strptime(request.query_params.get("end_time"), "%Y-%m-%dT%H:%M:%SZ") except TypeError: return Response({}, status=status.HTTP_400_BAD_REQUEST) result = urllib.request.urlopen(BELT_API_URL) data = json.loads(result.read()) filter_daterange = lambda x: True if start_time <= dt.datetime.strptime( x['time'], "%Y-%m-%d %H:%M:%S") <= end_time else False filtered_data = filter(filter_daterange, data) total_data = defaultdict(dict) for data in filtered_data: if data['state'] == True: data['belt1'] = 0 else: data['belt2'] = 0 if data['id'][-1] not in total_data.keys(): total_data[data['id'][-1]]['avg_belt1'] = data['belt1'] total_data[data['id'][-1]]['avg_belt2'] = data['belt2'] total_data[data['id'][-1]]['count'] = 1 total_data[data['id'][-1]]['id'] = data['id'][-1] else: total_data[data['id'][-1]]['avg_belt1'] += data['belt1'] total_data[data['id'][-1]]['avg_belt2'] += data['belt2'] total_data[data['id'][-1]]['count'] += 1 total_data[data['id'][-1]]['id'] = data['id'][-1] #creating a dictionary with the output values output_data = [ { "id": v['id'], "avg_belt1": (v['avg_belt1'] / v['count']), "avg_belt2": (v['avg_belt2'] / v['count'])} for k, v in sorted(total_data.items()) ] return Response(output_data)

UTF-8

Python

py

views.py

mullenkamp/ecan-water-reports

a0ac5a8483e5b693bfafb3d72269649e98404e03

016ffb3019de50a03230a7bde6ce164fea75fc9f

/core/util.py

e49298b9f46029d6c92ec8ca08d8740eb3eac703

permissive

https://github.com/mullenkamp/ecan-water-reports

0b9a44a49304315e80ff9903f7365e755b61bd5f

ca6b903e0df8889e81fa1efc31abc8c9e25f04d4

refs/heads/master

# -*- coding: utf-8 -*- """ Created on Wed Aug 8 13:07:42 2018 @author: MichaelEK """ import pandas as pd import geopandas as gpd def grp_ts_agg(df, grp_col, ts_col, freq_code): """ Simple function to aggregate time series with dataframes with a single column of sites and a column of times. Parameters ---------- df : DataFrame Dataframe with a datetime column. grp_col : str or list of str Column name that contains the sites. ts_col : str The column name of the datetime column. freq_code : str The pandas frequency code for the aggregation (e.g. 'M', 'A-JUN'). Returns ------- Pandas resample object """ df1 = df.copy() if type(df[ts_col].iloc[0]) is pd.Timestamp: df1.set_index(ts_col, inplace=True) if type(grp_col) is list: grp_col.extend([pd.Grouper(freq=freq_code)]) else: grp_col = [grp_col, pd.Grouper(freq=freq_code)] df_grp = df1.groupby(grp_col) return (df_grp) else: print('Make one column a timeseries!') def multipoly_to_poly(geodataframe): """ Function to convert a GeoDataFrame with some MultiPolygons to only polygons. Creates additional rows in the GeoDataFrame. Parameters ---------- geodataframe: GeoDataFrame Returns ------- GeoDataFrame """ gpd1 = geodataframe.copy() gpd2 = gpd.GeoDataFrame() for i in gpd1.index: geom1 = gpd1.loc[[i]] geom2 = geom1.loc[i, 'geometry'] if geom2.type == 'MultiPolygon': polys = [j for j in geom2] new1 = geom1.loc[[i] * len(polys)] new1.loc[:, 'geometry'] = polys else: new1 = geom1.copy() gpd2 = pd.concat([gpd2, new1]) return gpd2.reset_index(drop=True) def tsreg(ts, freq=None, interp=False): """ Function to regularize a time series object (pandas). The first three indeces must be regular for freq=None!!! ts -- pandas time series dataframe.\n freq -- Either specify the known frequency of the data or use None and determine the frequency from the first three indices.\n interp -- Should linear interpolation be applied on all missing data? """ if freq is None: freq = pd.infer_freq(ts.index[:3]) ts1 = ts.resample(freq).mean() if interp: ts1 = ts1.interpolate('time') return ts1 def getPolyCoords(row, coord_type, geom='geometry'): """Returns the coordinates ('x' or 'y') of edges of a Polygon exterior""" # Parse the exterior of the coordinate exterior = row[geom].exterior if coord_type == 'x': # Get the x coordinates of the exterior return list(exterior.coords.xy[0]) elif coord_type == 'y': # Get the y coordinates of the exterior return list(exterior.coords.xy[1])

UTF-8

Python

py

util.py

ChMcg/oop-labs

48519ebe24b0391862e4d8451a71cb0c33c22c9f

2ecae2d06656e5677faf7d347d7137c9d0809830

/src_07/App.py

90cbb792f2eadca942f3f07e78c1e1be46c3161d

no_license

https://github.com/ChMcg/oop-labs

ee6fed35539341e75fe1d4ee73c1fcd7586f5674

ca321941540ab3fd40e86ab0d090fc4f0ae559ec

refs/heads/master

from src_07.ui.lab_7_ui import Ui_Form as MainDialog from src_07.MyWidget import MyWidget from src_07.Drawable import GridType, DrawableType from PyQt5.QtCore import Qt from PyQt5.QtWidgets import QApplication, QWidget from PyQt5.QtCore import QRect class MainDialog_mock(MainDialog): def __init__(self): super().__init__() # self.old_setupUi = self.setupUi def setupUi(self, Form): # self.old_setupUi(Form) super().setupUi(Form) self.widget = MyWidget(self) self.widget.setGeometry(QRect(20, 20, 481, 521)) self.widget.setObjectName("widget") class MyWindow(QWidget): def __init__(self): super(MyWindow, self).__init__() self.ui = MainDialog() self.ui.setupUi(self) self.setup_custom_classes() # ---- figure selection ---- self.ui.rectangle.clicked.connect(self.updateFugureType) self.ui.square.clicked.connect(self.updateFugureType) self.ui.circle.clicked.connect(self.updateFugureType) self.ui.ellipse.clicked.connect(self.updateFugureType) # ---- figure parameters update ---- self.ui.line_a.valueChanged.connect(self.updateParameters) self.ui.line_b.valueChanged.connect(self.updateParameters) self.ui.radius.valueChanged.connect(self.updateParameters) # ---- grid selection ---- self.ui.random.clicked.connect(self.updateGrid) self.ui.random.clicked.connect(self.updateGridSelection) self.ui.regular.clicked.connect(self.updateGrid) self.ui.regular.clicked.connect(self.updateGridSelection) # ---- clean button ---- self.ui.clean.clicked.connect(self.cleanup) # ---- update grid button ---- self.ui.generate_new.clicked.connect(self.updateGrid) # ---- grid parameters updated ---- self.ui.dense_x.valueChanged.connect(self.updateGrid) self.ui.dense_x.valueChanged.connect(self.balanceByX) self.ui.dense_y.valueChanged.connect(self.updateGrid) self.ui.dense_y.valueChanged.connect(self.balanceByY) # ---- update initial settings ---- self.updateFugureType() self.updateParameters() self.updateGridSelection() self.updateGrid() # ---- custom signals ---- self.widget.objectAdded.connect(self.updateInfo) def setup_custom_classes(self): self.widget = MyWidget(self) # self.widget.setGeometry(QRect(10, 30, 500, 500)) self.widget.setGeometry(QRect(11, 31, 498, 498)) def keyPressEvent(self, e): if e.key() == Qt.Key_Escape: self.close() def balanceByX(self): if self.ui.balance.isChecked(): self.ui.dense_y.setValue(self.ui.dense_x.value()) def balanceByY(self): if self.ui.balance.isChecked(): self.ui.dense_x.setValue(self.ui.dense_y.value()) def updateGrid(self): x = int(self.ui.dense_x.value()) y = int(self.ui.dense_y.value()) if self.ui.regular.isChecked(): self.widget.updateGrid(x, y, GridType.REGULAR) self.updateInfo() elif self.ui.random.isChecked(): self.widget.updateGrid(x, y, GridType.RANDOM) self.updateInfo() def updateInfo(self): x = int(self.ui.dense_x.value()) y = int(self.ui.dense_y.value()) info = self.widget.getIntersectResult() current, total = info gt = self.widget.getGridType() self.ui.info.setText(f"Сетка: ({x}, {y}) [{gt}]\n" f"Заплнено: {current}/{total} ({(1-current/total)*100:.2f}%)") def updateGridSelection(self): if self.ui.regular.isChecked(): self.ui.generate_new.setEnabled(False) else: self.ui.generate_new.setEnabled(True) def updateParameters(self): self.widget.setCurrentParameters( a=self.ui.line_a.value(), b=self.ui.line_b.value(), radius=self.ui.radius.value() ) def updateFugureType(self): if self.ui.rectangle.isChecked(): self.widget.setCurrentFigure(DrawableType.RECTANGLE) self.ui.line_a.setEnabled(True) self.ui.line_b.setEnabled(True) self.ui.radius.setEnabled(False) if self.ui.square.isChecked(): self.widget.setCurrentFigure(DrawableType.SQUARE) self.ui.line_a.setEnabled(True) self.ui.line_b.setEnabled(False) self.ui.radius.setEnabled(False) if self.ui.circle.isChecked(): self.widget.setCurrentFigure(DrawableType.CIRCLE) self.ui.line_a.setEnabled(False) self.ui.line_b.setEnabled(False) self.ui.radius.setEnabled(True) if self.ui.ellipse.isChecked(): self.widget.setCurrentFigure(DrawableType.ELLIPSE) self.ui.line_a.setEnabled(True) self.ui.line_b.setEnabled(True) self.ui.radius.setEnabled(False) def cleanup(self): print('cleaning') self.widget.cleanup() class MyApp(): def exec(self) -> int: app = QApplication([]) app.setStyle('Fusion') window = MyWindow() window.show() return app.exec()

UTF-8

Python

py

App.py

Liberty3000/plato

5e19307c0294673a52ddfe2286881f7bf82fcb55

cfce9c7fd43f48c28740e76cb02313adbb5624bd

/plato/environment.py

54be5c197a539b75cbdb7635fcfb997cf928413f

no_license

https://github.com/Liberty3000/plato

eaa6ae5d53cb3c8c92ced13241c18aca9790cb43

db9a68bcd78bbcfd4791f980e4abc9cbbffbd870

refs/heads/master

import gym, random, os, time, tqdm import numpy as np, matplotlib.pyplot as mp from plato.actions import attack, patrol from plato.features import global_features from plato.entity.util import plot_entities, randomize_entities from plato.objective.util import plot_objectives, encode_objectives from plato.router import pathfinder from plato.terrain import perlin from plato.util import coverage, quantize_area class Environment(gym.Env): def __init__(self, config=None, shape=(64,64), objectives=[], controlled=[], time_limit=2**14): self.config, self.shape = config, shape self.state_space = (len(global_features), *shape) self.pathfinder = pathfinder() self.global_reward, self.local_rewards = 0, {} self.objectives = objectives self.controlled = controlled self.time_limit = time_limit def initialize_terrain(self): self.air = np.zeros(self.shape) self.sea = np.zeros(self.shape) self.land= perlin(self.shape[0], self.shape[1], seed=0) def reset(self): self.state, self.reward, self.timer = None,0,0 cfg = self.config['whites'] init_params = cfg['params'].values() init_area = quantize_area(cfg['init'], self.shape) self.whites = randomize_entities(*init_params, init_area, 'whites') cfg = self.config['blacks'] init_params = cfg['params'].values() init_area = quantize_area(cfg['init'], self.shape) self.blacks = randomize_entities(*init_params, init_area, 'blacks') self.white_detections, self.black_detections = [],[] self.white_casualties, self.black_casualties = [],[] self.initialize_terrain() return self.observation(self.whites, self.blacks) def terrain(self): return np.asarray([self.sea, self.land, self.air]) def observation(self, positive, negative=None): minimap = np.zeros((len(global_features),*self.shape)) minimap[global_features.index('land'),:]= self.land minimap[global_features.index('air'),:] = self.air minimap[global_features.index('sea'),:] = self.sea for ent in positive.values(): x,y = ent.xy[0],ent.xy[1] minimap[global_features.index(ent.entity_type),x,y] += 1 if ent.weapons: weapon_model = ent.weapons[0] minimap[global_features.index('weapon_power'), x,y] += weapon_model['weapon_power'] for xy in coverage(ent.xy, weapon_model['weapon_range'], self.shape): for (i,j) in coverage(xy, weapon_model['weapon_radius'], self.shape): minimap[global_features.index('weapon_radius'),i,j] += weapon_model['weapon_radius'] for (x,y) in coverage(ent.xy, weapon_model['weapon_range'], self.shape): minimap[global_features.index('weapon_range'),x,y] += weapon_model['weapon_range'] if ent.sensors: sensor_model = ent.sensors[0] minimap[global_features.index('sensor_coverage'),x,y]+= sensor_model['sensor_coverage'] for (x,y) in coverage(ent.xy, sensor_model['sensor_range'], self.shape): minimap[global_features.index('sensor_range'),x,y] += weapon_model['sensor_range'] minimap[global_features.index('durability'),x,y] += ent.properties['durability'] for (x,y) in coverage(ent.xy, ent.properties['mobility'], self.shape): minimap[global_features.index('mobility'),x,y] += (1 - ent.properties['mobility']) for (x,y) in coverage(ent.xy, ent.properties['visibility'], self.shape): minimap[global_features.index('visibility'),x,y] += ent.properties['visibility'] if any([ent.id in self.blacks.keys() for ent in positive.values()]): dets,kills,casts = self.white_detections,self.white_casualties,self.black_casualties else: dets,kills,casts = self.black_detections,self.black_casualties,self.white_casualties minimap = encode_objectives(self.objectives, minimap, self.white_detections, self.shape) for ent in dets: x,y = ent.xy minimap[global_features.index(ent.entity_type + '_detections'),x,y] += 1 for ent in kills: x,y = ent.xy minimap[global_features.index('positive_casualties'),x,y] += 1 for ent in casts: x,y = ent.xy minimap[global_features.index('negative_casualties'),x,y] += 1 return minimap def observe_detections(self): self.white_detections, self.black_detections = [],[] for white in self.whites.values(): for black in self.blacks.values(): operational = white.operational and black.operational white_cells = coverage(white.xy, white.properties['visibility'], self.shape) black_cells = coverage(black.xy, black.properties['visibility'], self.shape) if black.xy in white_cells and operational: self.white_detections += [black] if white.xy in black_cells and operational: self.white_detections += [white] self.white_detections = set(self.white_detections) self.black_detections = set(self.black_detections) def calculate_damage(self, damage_map, targets): casualities = [] for target in targets.values(): x,y = target.xy target.properties['durability'] -= damage_map[x,y] if target.properties['durability'] < 0: target.operational = False casualities.append(target) return set(casualities) def shape_reward(self): reward = 0 # reward kills for _ in self.black_casualties: reward += 0.2 # penalize casualties for _ in self.white_casualties: reward -= 0.2 # reward survival if all([not ent.operational for ent in self.blacks.values()]): reward += 1 # penalize extinction if all([not ent.operational for ent in self.whites.values()]): reward -= 1 # reward objectives reward += sum([obj.reward for obj in self.objectives]) return reward def termination_condition(self): terminal,status = False,'neutral' args = dict(entities=self.whites, enemies=self.blacks, timer=self.timer) terminal = any([obj(**args) for obj in self.objectives]) if terminal: status = 'success' if self.timer >= self.time_limit: terminal,status = True,'neutral' if all([not ent.operational for ent in self.whites.values()]): terminal,status = True,'failure' if all([not ent.operational for ent in self.blacks.values()]): terminal,status = True,'success' return terminal,status def step(self, white_actions={}, black_actions={}, verbose=False): self.timer += 1 metadata = {'positive_observables': None, # what we see 'negative_observables': None, # what they see 'fully_observable': None} # everything # white's actions positive_damage_map = np.zeros((*self.shape,)) for id_,action in white_actions.items(): entity = self.whites[id_] if entity.operational: if action in entity.patrol_actions: entity.xy = patrol(entity, action, self.terrain()) if action in entity.attack_actions: positive_damage_map = attack(entity, action, positive_damage_map) self.black_casualties = self.calculate_damage(positive_damage_map, self.blacks) # blacks's actions negative_damage_map = np.zeros((*self.shape,)) for id_,action in black_actions.items(): entity = self.blacks[id_] if entity.operational: if action in entity.patrol_actions: entity.xy = patrol(entity, action, self.terrain()) if action in entity.attack_actions: negative_damage_map = attack(entity, action, negative_damage_map) self.white_casualties = self.calculate_damage(negative_damage_map, self.whites) self.observe_detections() metadata['positive_observables'] = self.observation(self.whites, self.blacks) metadata['negative_observables'] = self.observation(self.blacks, self.whites) metadata[ 'positive_damage_map'] = positive_damage_map metadata[ 'negative_damage_map'] = negative_damage_map metadata[ 'positive_casualties'] = self.white_casualties metadata[ 'negative_casualties'] = self.black_casualties white_map = np.zeros((*self.shape,)) for ent in self.whites.values(): x,y = ent.xy[0],ent.xy[1] white_map[x,y] += 1 metadata['white_map'] = white_map black_map = np.zeros((*self.shape,)) for ent in self.blacks.values(): x,y = ent.xy[0],ent.xy[1] black_map[x,y] += 1 metadata['black_map'] = black_map self.global_reward = self.shape_reward() self.terminal, status = self.termination_condition() metadata['status'] = status return metadata['positive_observables'], self.global_reward, self.terminal, metadata def render(self, notebook=False, show=True, routes=False): fig,ax = mp.subplots(1,1,figsize=(10,10)) canvas = np.zeros((*self.shape,3)) ax.set_aspect('equal') controlled = [ent for ent in self.whites.values() if ent.controlled == True] canvas,ax,wpatches = plot_entities(self.whites, controlled, canvas, ax) canvas,ax,bpatches = plot_entities(self.blacks, [], canvas, ax) canvas,ax,opatches = plot_objectives(self.objectives, self.timer, canvas, ax) mp.title('PLATO Environment', size=16) ax.imshow(canvas.astype(np.uint8)) mp.show(block=False) mp.pause(1e-9) fig.canvas.draw_idle() try: fig.canvas.flush_events() except NotImplementedError: pass for p in wpatches: p.remove() for p in bpatches: p.remove() for p in opatches: p.remove() return canvas

UTF-8

Python

py

environment.py

plovesm/filesorter

88b41f0d8ea3ff45f2f66fdcd916778021593783

1194525ce6479cd8f69ea69a2c00a648cb1aeecd

/app/db_util.py

bcc187be70bf3cb14e7d0bfa6a715e47a3025bde

no_license

https://github.com/plovesm/filesorter

6bcb05b140ea48350f42c29d14c4d818d19ca7b3

34e8cbce2605569036417a404090da5803c12967

refs/heads/master

# Copyright 2017 # Author Paul Ottley import sqlite3 from objects import FSfile from datetime import date class DatabaseUtil: def __init__(self): self.conn = None @staticmethod def open_connection(name="test.db", detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES): conn = sqlite3.connect(name, detect_types) cur = conn.cursor() print("Opened database successfully") return conn, cur @staticmethod def create_files_table(cur, table_name="Files", ): cur.execute('''DROP TABLE IF EXISTS FILES;''') cur.execute('''CREATE TABLE IF NOT EXISTS FILES ( ID INTEGER PRIMARY KEY NOT NULL, FILENAME TEXT NOT NULL, DATE_TAKEN DATETIME, FILE_TYPE TEXT, FILE_SIZE NUMBER, SRC_DIR VARCHAR(50), TGT_DIR VARCHAR(50));''') return True @staticmethod def insert_record(cur, file=FSfile()): cur.execute('''INSERT INTO FILES (FILENAME, DATE_TAKEN, FILE_TYPE, FILE_SIZE, SRC_DIR, TGT_DIR) VALUES (?, ?, ?, ?, ?, ?);''', (file.get_filename(), file.get_date_taken(), file.get_type(), file.get_size(), file.get_src_dir(), file.get_tgt_dir())) DatabaseUtil.commit_transaction(cur.connection) return True @staticmethod def read_all_records(cur): cur.execute("SELECT * FROM FILES;") return cur.fetchall(); @staticmethod def read_first_record(cur): cur.execute("SELECT * FROM FILES;") return cur.fetchone(); @staticmethod def read_one_record(c, fields_values=[{'FILENAME':'frog.jpg'}]): select_script = "SELECT * FROM FILES WHERE (" for x in fields_values.keys(): select_script += "{0} = {1}".format(x, fields_values[x]) if x.index() < len(fields_values.keys())-1: select_script += "," select_script += ");" c.execute(select_script) # Update @staticmethod def update_record(cur, date_taken, filename): cur.execute('''UPDATE FILES SET (?) TO (?) WHEre ? = ?''', ("DATE_TAKEN", date_taken, "FILENAME", filename)) DatabaseUtil.commit_transaction(cur.connection) return True # Delete @staticmethod def delete_record(cur, id): cur.execute('''DELETE from FILES WHERE ID = ?''', id) DatabaseUtil.commit_transaction(cur.connection) return True @staticmethod def commit_transaction(connection): connection.commit() @staticmethod def close_connection(connection): connection.close() print("Database connection closed")

UTF-8

Python

py

db_util.py

cobuildlab/ezonseller-backend

a5c5d68471f5666ae6d93d15c529fec24f65aef1

c763799e28b94847edfa31e0a81792d0631b2911

/payment/migrations/0003_auto_20180111_0413.py

600d5024f1a57153c93083896d7c4d8168e4e545

no_license

https://github.com/cobuildlab/ezonseller-backend

4680ddbe0dc4dbe866dde9a19e954918365f290d

5ece80c6c2974790744035a5ae95d9df77648583

refs/heads/master

Python

# Generated by Django 2.0 on 2018-01-11 04:13 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('payment', '0002_auto_20180111_0247'), ] operations = [ migrations.RemoveField( model_name='plansubscription', name='accept', ), migrations.AddField( model_name='paymenthistory', name='accept', field=models.BooleanField(default=False, help_text='Accept the terms and conditions?', verbose_name='Accept'), ), ]

UTF-8

Python

py

0003_auto_20180111_0413.py

rcisterna/perchess-py

8b2ed93ffb097e260b00913a829bad69d9cf264d

cf5d2b3cce51ae4ada792720164f92edf13db3ea

/perchess/pieces/__init__.py

e61ff3022b6353f94322c89712f1fa4e8af3d060

no_license

https://github.com/rcisterna/perchess-py

95d6f49d5e884f1433d4572f882701765e00a742

fbd6650df6806345deb8bd801c3886e2f87cc54b

refs/heads/master

""" Piezas de ajedrez. """ __all__ = [ "Movement", "Colors", "Piece", "Pawn", "Bishop", "Knight", "Rook", "Queen", "King", ] from perchess.pieces.colors import Colors from perchess.pieces.movement import Movement from perchess.pieces.piece import Piece from perchess.pieces.bishop import Bishop from perchess.pieces.king import King from perchess.pieces.knight import Knight from perchess.pieces.pawn import Pawn from perchess.pieces.queen import Queen from perchess.pieces.rook import Rook

UTF-8

Python

py

__init__.py

Geek-Tekina/Coding

dbfefd322cf9249eb5261e52d33ddebbbb7df616

6e652507874d4f6835092e6e504525d71bc1a48d

/Python/hackerrank/Polar cordinates.py

ac07b0e78c15c33ec6904ce4f03d8f8c9d9ca58e

no_license

https://github.com/Geek-Tekina/Coding

be4876b2b3b9a16f32c92bb1cabb3694fb03a837

15ee5c830dbf02d90cc972355c5054471985ebc5

refs/heads/main

import cmath a = complex(input()) b = list(cmath.polar(a)) print(b[0]) print(b[1])

UTF-8

Python

py

Polar cordinates.py

fjy960120/python-9th-exercise

70fc99279eb8e70eacf3625c86b609b58e53fbc7

a8bd91d5b39bd9cc436c0b1454bc485ab9431109

/9.1.py

bcada02014900b99cef098a9626c5d03a69f7390

no_license

https://github.com/fjy960120/python-9th-exercise

28d05b03164d3590bead9724ccc1ef5fcfc94930

38d2ff72c3068ca541164941a63a63350a2b988b

refs/heads/master

class Dog(): """一次模拟小狗的简单尝试""" def __init__(self,name,age): """初始化属性name和age""" self.name = name self.age = age def sit(self): """模拟小狗被命令时蹲下""" print(self.name.title()+" is siting now") def roll_over(self): """模拟小狗被命令时打滚""" print(self.name.title()+" is rulling over now") my_dog = Dog('willian',6) print("My dog's name is : "+my_dog.name.title()) print("My dog's age is : "+ str(my_dog.age)) my_dog.sit() my_dog.roll_over() your_dog = Dog('alice',5) lily_dog = Dog('beta',5) print("Lily have a dog ,It's name is : "+lily_dog.name.title()) print("Your dog's name is : " + your_dog.name.title()) print("Lily have a dog,It's age is "+str(lily_dog.age)) lily_dog.sit() lily_dog.roll_over() """9.1.1练习""" class Resaurant(): def __init__(self,restaurant_name,cuisine_type): self.name = restaurant_name self.cuisinetype = cuisine_type def describe_restaurant(self): print("\nThis restaurant's name is : "+ self.name.title()) print("The restaurant's cuisine type are : "+self.cuisinetype.title()) def open_restaurant(self): print("This reataurant is openning!") restaurant = Resaurant('homoo','chinese') restaurant.describe_restaurant() restaurant.open_restaurant() restaurant_0 = Resaurant('毛肚火锅店','川菜') restaurant_0.describe_restaurant() restaurant_1 = Resaurant('炸酱面店','北京菜') restaurant_1.describe_restaurant() restaurant_2 = Resaurant('早茶店','粤菜') restaurant_2.describe_restaurant() """9.1.3练习""" class User(): def __init__(self,frist_name,last_name,**users): self.fristname = frist_name self.lastname = last_name self.users = users # for j,k in users.items(): # users[j]=k #self.users = user # self.j = k def describe_user(self): print("\nUsers information is: ") print("\t users frist name is: "+ self.fristname.title()) print("\t users last name is: "+ self.lastname.title()) print("\n Users other information are: ") for j,k in self.users.items(): users[j]=k print("\t"+j.title()+" : "+ k.title()) def greet_user(self): print("\nHello! "+self.fristname.title()+self.lastname.title()) users={} user_0 = User('lily','edward',age='16',hometown='beijing') user_0.describe_user() user_0.greet_user() print(users)

UTF-8

Python

py

9.1.py

adafruit/Adafruit_Learning_System_Guides

61ef9a3984f5b534b9ea259f2652f551219d0243

091a6200be74bf6577c86f623665bcc24e16b02b

/NeoKey_BFF_Examples/CP_Keyboard_Example/code.py

8814a1ab9f2df376b6247bdd0e8346d631f31cb8

permissive

https://github.com/adafruit/Adafruit_Learning_System_Guides

b5f7bce40a16da64e7a79d4b39de032f2cca41d4

5eaa7a15a437c533b89f359a25983e24bb6b5438

refs/heads/main

MIT

C

# SPDX-FileCopyrightText: 2023 Liz Clark for Adafruit Industries # # SPDX-License-Identifier: MIT """Basic HID Macro with NeoKey BFF Example""" import time import board from digitalio import DigitalInOut, Direction, Pull import neopixel import usb_hid from adafruit_hid.keyboard import Keyboard from adafruit_hid.keycode import Keycode # setup onboard NeoPixel pixel_pin = board.A3 num_pixels = 1 pixel_color = (0, 255, 0) off = (0, 0, 0) pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.3, auto_write=False) # The Keycode sent for each button, will be paired with a control key key = Keycode.F modifier_key = Keycode.CONTROL # The keyboard object! time.sleep(1) # Sleep for a bit to avoid a race condition on some systems keyboard = Keyboard(usb_hid.devices) # setup onboard button switch = DigitalInOut(board.A2) switch.direction = Direction.INPUT switch.pull = Pull.UP switch_state = False while True: # if the button is not pressed.. if switch.value and switch_state: pixels.fill(off) pixels.show() keyboard.release_all() switch_state = False # if the button is pressed.. elif not switch.value and not switch_state: pixels.fill(pixel_color) pixels.show() keyboard.press(modifier_key, key) switch_state = True time.sleep(0.05)

UTF-8

Python

py

code.py

aikinogard/basis1d

eabebe8417da5d1472831ae701ed96c3cecd6769

c739c9d6ec368bf06fd7da2b95ccf15a11c6ef90

/basis1d/cgbf.py

7aedc19f64e35708a70192c248e756355f4df513

no_license

https://github.com/aikinogard/basis1d

fe08c4bfa81764368b6b7adfb035e60832eaf02f

5fb6cf05371dbd0cbfa45159935d621c4326bd0c

refs/heads/master

import numpy as np import array from basis1d.pgbf import pgbf from basis1d.tools import S class cgbf: contracted = True def __init__(self,origin=0,power=0,exps=[],coefs=[]): self.origin = float(origin) self.power = float(power) # cgbf is made by list of pgbf self.pgbfs = [] # the coefficient of each pgbf self.coefs = array.array('d') # normalization constant of pgbf self.pnorms = array.array('d') # exponential of each pgbf self.pexps = array.array('d') for expn,coef in zip(exps,coefs): self.add_pgbf(expn,coef,False) if self.pgbfs: self.normalize() def __getitem__(self,item): return list(zip(self.coefs,self.pgbfs)).__getitem__(item) def __repr__(self): return "cgbf(%f,%d,%s,%s)"%(self.origin,self.power,list(self.pexps),list(self.coefs)) def __call__(self,*args,**kwargs): return sum(c*p(*args,**kwargs) for c,p in self) def grid(self,xs): return sum(c*p.grid(xs) for c,p in self) def add_pgbf(self,expn,coef,renormalize=True): self.pgbfs.append(pgbf(expn,self.origin,self.power)) self.coefs.append(coef) if renormalize: self.normalize() p = self.pgbfs[-1] self.pnorms.append(p.norm) self.pexps.append(p.expn) def normalize(self): Saa_sqrt = np.sqrt(S(self,self)) for i in range(len(self.coefs)): self.coefs[i] /= Saa_sqrt

UTF-8

Python

py

cgbf.py

dan9thsense/contest_submission

e74fe729920ba0ae9df0632d87b4e152785c6b04

5316f01200ab0ffa6988d311aed8218c60b5261e

/submission/test_submission/runDocker.py

5d9fcfeaf40164199bbabb65d6e6635ecaa6fbf2

no_license

https://github.com/dan9thsense/contest_submission

e5a0098871b825a4d123ee7763bd81195a996470

7f24e5d8257e7560bc5f3cb1ccad0f12d6594c8d

refs/heads/master

import importlib.util from animalai.envs.gym.environment import AnimalAIEnv from animalai.envs.arena_config import ArenaConfig MULTIPLE_CONFIGS = True NUM_EPISODES = 2 def main(): # Load the agent from the submission # this is the standard way that python 3.5+ versions import a file # and a class within that file, from a specific path location # agent.py was copied into the docker image in the folder /aaio # and agent.py has a class, Agent, that we use to interact with # https://stackoverflow.com/questions/67631/how-to-import-a-module-given-the-full-path print('Loading your agent') try: spec = importlib.util.spec_from_file_location('agent_module', '/aaio/agent.py') agent_module = importlib.util.module_from_spec(spec) spec.loader.exec_module(agent_module) submitted_agent = agent_module.Agent() except Exception as e: print('Your agent could not be loaded, make sure all the paths are absolute, error thrown:') raise e print('Agent successfully loaded') arena_config_in = ArenaConfig('/aaio/configs/1-Food.yaml') print('Resetting your agent') try: submitted_agent.reset(t=arena_config_in.arenas[0].t) except Exception as e: print('Your agent could not be reset:') raise e env = AnimalAIEnv( environment_filename='/aaio/test/env/AnimalAI', seed=0, retro=False, n_arenas=1, worker_id=1, docker_training=True, ) print('Running ', NUM_EPISODES, ' episodes') configs = [] configs.append('/aaio/configs/1-Food.yaml') if MULTIPLE_CONFIGS: configs.append('/aaio/configs/2-Preferences.yaml') configs.append('/aaio/configs/3-Obstacles.yaml') configs.append('/aaio/configs/4-Avoidance.yaml') configs.append('/aaio/configs/5-SpatialReasoning.yaml') configs.append('/aaio/configs/6-Generalization.yaml') configs.append('/aaio/configs/7-InternalMemory.yaml') configs.append('/aaio/configs/temporary_blackout.yaml') configs.append('/aaio/configs/permanent_blackout.yaml') configs.append('/aaio/configs/permanent_blackout_with_wall_and_bad_goal.yaml') configs.append('/aaio/configs/hot_zone.yaml') configs.append('/aaio/configs/movingFood.yaml') configs.append('/aaio/configs/forcedChoice.yaml') configs.append('/aaio/configs/objectManipulation.yaml') configs.append('/aaio/configs/allObjectsRandom.yaml') config_results = [] for config in configs: print('starting ', config) average_num_actions = 0 average_reward = 0 num_time_outs = 0 arena_config_in = ArenaConfig(config) for k in range(NUM_EPISODES): time_out = False num_actions = 0 episode_reward = 0 episode_results = [] env.reset(arenas_configurations=arena_config_in) print('Episode {} starting'.format(k)) try: obs, reward, done, info = env.step([0, 0]) for i in range(arena_config_in.arenas[0].t): action = submitted_agent.step(obs, reward, done, info) num_actions += 1 obs, reward, done, info = env.step(action) episode_reward += reward if done: if i == arena_config_in.arenas[0].t - 1: time_out = True submitted_agent.reset(arena_config_in.arenas[0].t) break except Exception as e: print('Episode {} failed'.format(k)) raise e print('Episode {0} completed, num actions {1}, reward {1}'.format(k, num_actions, episode_reward, time_out)) #episode_results.append([config, k, num_actions, episode_reward, time_out]) average_reward += episode_reward average_num_actions += num_actions if time_out: num_time_outs += 1 config_results.append([config, average_num_actions / NUM_EPISODES, average_reward / NUM_EPISODES, num_time_outs]) print("config results: config, avg number of actions, average reward, number of timeouts") for result in config_results: print(result) if __name__ == '__main__': main()

UTF-8

Python

py

runDocker.py

panuta/thaihealthplm

eb0ff8ba6b8956f667b1e2687b610338a2115249

58b5035b8de1d2e60917f27b66fe28c190610861

/homepage/urls.py

a6d2173fb40b37bc2a47184820883db3649a53d3

no_license

https://github.com/panuta/thaihealthplm

9babe9ad70028dea90d1ea240a06087c78b8d15a

4d62e2eed5ea9bad9c4ee78be8bb9b7cd8e00a04

refs/heads/master

from django.conf.urls.defaults import * urlpatterns = patterns('homepage.views', url(r'^home/$', 'view_dashboard', name='view_dashboard'), )

UTF-8

Python

py

urls.py

stevenzjj/niuyuan_platform

9cc6342b73ed85ead05cb03169dfd8a36c7ee3c1

92b9dd58e4fa5d1513f3a3ba19cfc7623450c987

/host_mgr/action_list.py

da8537a9ba95de1c4d0e82aa79f8e0b6d4ed6a55

no_license

https://github.com/stevenzjj/niuyuan_platform

58fc0aa179aa23ea2e1bdfefa74440ba72998536

ca89993db293e79d8f95444080a1dcd6db91e429

refs/heads/master

#!/usr/bin/env python # -*- coding:utf-8 -*- from host_mgr.plugins import cmd, state actions = { "cmd": cmd.CMD, "state": state.State, }

UTF-8

Python

py

action_list.py

cuevas1208/Tradebot

4026768ea47689def101f11c9cbbfade674d7413

5af641702c966f63d3443c0545c14eaaa4e20cde

/src/sklearn_main.py

5b1f5a5335424dc8f9939d47ad402be617529e46

permissive

https://github.com/cuevas1208/Tradebot

cea8d279b6a0bffd69bebde64484a8278c8d6518

f6499bc75d625414c9a474c774912cb502a153d8

refs/heads/master

# skelearn.py # Prepare dataSets for training # techniques learn on the bottom site were implemented # to build this ml module # referene https://pythonprogramming.net/machine-learning-stock-prices-python-programming-for-finance/ ################################################################################ import argparse import logging import os from collections import Counter import pandas as pd import numpy as np from sklearn import svm, neighbors from sklearn.ensemble import VotingClassifier, RandomForestClassifier from sklearn.externals import joblib from src.correlation_test import get_correlation from src.conf import PREDICTION_DAYS, BATCH_LEN, MODELS_PATH, STOCK_TO_PREDICT, LABEL_TO_PREDICT, \ PERCENTAGE_THRESHOLD from src.data_functions.data_load import get_dataframe logger = logging.getLogger() def process_data_for_labels(ticker_feature, df): """ process_data_for_labels # input days to analyze data # it would output the percentage increase/decrease of the stock in PREDICTION_DAYS # by shifting the columns to PREDICTION_DAYS :param ticker_feature: string name of the ticker :param df: dataset fragment :return: df with adjusted percentage change """ print('loading:', ticker_feature, df.shape) # delete all NAN array with rows deleted df.dropna(subset=[ticker_feature], inplace=True) logging.debug("df shape after eliminating NAN from labels", df.shape) # get future labels for classification, shift data df['{}_labels'.format(ticker_feature)] = \ (df[ticker_feature].shift(-PREDICTION_DAYS) - df[ticker_feature]) / df[ticker_feature] # return a list of labels with no NAN df.dropna(subset=['{}_labels'.format(ticker_feature)], inplace=True) logging.debug("df shape after eliminating NAN from labels", df.shape) logging.debug("labels with days difference", df['{}_labels'.format(ticker_feature)]) # transform labels in to 1, 0 and -1 ==> buy_hold_sell df['{}_labels'.format(ticker_feature)] = list(map(set_buy_sell_hold, df['{}_labels'.format(ticker_feature)])) logging.debug("labels after the one_hot", df['{}_labels'.format(ticker_feature)]) # visualize spread values = df['{}_labels'.format(ticker_feature)].values.tolist() str_values = [str(i) for i in values] print('Data spread:', Counter(str_values), "total labels: ", len(values)) # handle any invalid numbers df.fillna(0, inplace=True) df.replace([np.inf, -np.inf], np.nan, inplace=True) df.dropna(inplace=True) return df def set_buy_sell_hold(*args): """ str_vals is a list of our data labels -1 = decrees 0 = stayed same -1 = increased """ cols = [c for c in args] for col in cols: if col > PERCENTAGE_THRESHOLD: return 1 if col < -PERCENTAGE_THRESHOLD: return -1 return 0 def extract_features_method_1(df): # tickers are all the column_labels that would be for training excluding training_labels tickers = df.columns.values.tolist() # pct_change() normalize the value to be percentage change df_values = df[[ticker for ticker in tickers]].pct_change() df_values.replace([np.inf, -np.inf], 0, inplace=True) df_values.fillna(0, inplace=True) print("x features shape: ", df_values.shape) x = df_values.values return x, df def extract_features_method_2(df, ticker): # get correlation stock correlation_stock = get_correlation(df, ticker + LABEL_TO_PREDICT, top_samples=1, set_len=12).index def shift_data(corr, pct=False): if pct: df[corr] = df[corr].pct_change() x = df[corr].shift(0).values for i in range(1, BATCH_LEN): x = np.dstack((x, df[corr].shift(i).values)) return x # calculates the medan of low df['x_features'] = df[ticker + LABEL_TO_PREDICT] # df[ticker + '_Low'] + df[ticker + '_High'] / 2 # normalize the value to be percent change df['x_features'] = df['x_features'].pct_change() print('average percentage change {} in the last 20 days {}\n\n'.format(np.abs(df['x_features']).mean(), np.abs(df['x_features'][-20:]).mean())) # extract past feature data including today's data if known # Todo: currently row goes from new to old x = shift_data('x_features') for corr in correlation_stock: new_x = (shift_data(corr, pct=True)) x = np.concatenate([x, new_x], -1) x = x[0].tolist() df['training_features'] = x # handles invalid numbers # df.replace([np.inf, -np.inf], 0, inplace=True) # df.fillna(0, inplace=True) return df def get_training_dataset(ticker, df): # change values to percentage of change within the days intended to predict df = process_data_for_labels(ticker + LABEL_TO_PREDICT, df) # x, _ = extract_features_method_1(df) df = extract_features_method_2(df, ticker) # take the last 7 days as validation samples before shuffle # this is mainly for visualization sample_size = 15 valid = df[-sample_size:] y = valid[ticker + LABEL_TO_PREDICT + '_labels'].values x = valid['training_features'].tolist() x = np.asarray(x) dates = valid['Date'].tolist() real_x = valid[ticker + LABEL_TO_PREDICT].values valid_sample = {'x': x, 'y': y, 'dates': dates, 'p_dates': dates, "real_x": real_x} # shuffles dataset new_df = df[:-sample_size] new_df = new_df.sample(frac=1).reset_index(drop=True) # Todo: Balance data y = new_df[ticker + LABEL_TO_PREDICT + '_labels'].values values, count = np.unique(y, return_counts=True) limit = np.min(count) limit_value = values[np.argmin(count)] # load dataset y = new_df[ticker + LABEL_TO_PREDICT + '_labels'].values x = new_df['training_features'].tolist() x = np.asarray(x) dates = new_df['Date'].tolist() # clean data mask = ~np.isnan(x).any(axis=1) x = x[mask]; y = y[mask] mask = np.isfinite(x).any(axis=1) x = x[mask]; y = y[mask] print('input training labels shape:', y.shape, ' and features shape:', x.shape) return x, y, dates, valid_sample def train(x, y): logging.debug("X sample: \ {} ".format(len(x.shape))) logging.debug("y sample: \ {} ".format(len(y.shape))) # random shuffle and split test_size = int(len(y) * 0.2) x_train, x_test, y_train, y_test = x[test_size:], x[:test_size], y[test_size:], y[:test_size] # combine the predictions of several base estimators clf = VotingClassifier([('lsvc', svm.LinearSVC()), ('knn', neighbors.KNeighborsClassifier()), ('rfor', RandomForestClassifier())]) clf.fit(x_train, y_train) # test data prediction np.set_printoptions(precision=2) confidence = clf.score(x_test, y_test) print('accuracy:', confidence) return confidence, clf def forecast(ticker, df): # load dataset x, y, dates, valid_set = get_training_dataset(ticker, df) # load model if not os.path.exists(ticker): # train model confidence, clf = train(x, y) # save model if not os.path.exists(MODELS_PATH): os.makedirs(MODELS_PATH) joblib.dump(clf, MODELS_PATH + ticker + '.pkl') # run valid_set from src.visualization import matplot_graphs valid_set['y_pred'] = clf.predict(valid_set['x']) matplot_graphs.plot_histogram(valid_set, ticker, confidence, PREDICTION_DAYS) # last dataset sample clf = joblib.load(MODELS_PATH + ticker + '.pkl') # get forecast x = x[-1:] forecast_ = clf.predict(x) print('\n', ticker, ': Based in the last', BATCH_LEN, 'market days, the forecast is ', forecast_ * PERCENTAGE_THRESHOLD, '% in next', PREDICTION_DAYS, 'days\n') if __name__ == "__main__": import warnings, sys if not sys.warnoptions: warnings.simplefilter("ignore") # parser initial arguments # logging.basicConfig(filename='log.log', level=logging.INFO) parser = argparse.ArgumentParser(description='Optional app description') # run -v for debug mode parser.add_argument('-v', "--verbose", action='store_true', help='Type -v to do debugging') args = parser.parse_args() # set debug mode if args.verbose: logger.setLevel(logging.DEBUG) # forecast chosen ticker df = get_dataframe(STOCK_TO_PREDICT) forecast(STOCK_TO_PREDICT, df) # forecast all sp500 # sp500_list = getsp500() # for sp500_ticker in sp500_list: # df = get_dataframe(sp500_ticker) # forecast(sp500_ticker, df)

UTF-8

Python

py

sklearn_main.py

Sohoni-Agarwal/QA_CommunityForum

2943ca5d54b6be3988f153aa0ad8041bead4dd99

a5feac3c37c18ad4d8c1391fce1f4c02a512081e

/admins/urls.py

892233402212440ffe139b60de52c29061038c3c

no_license

https://github.com/Sohoni-Agarwal/QA_CommunityForum

76bcadea338dab35b0aafbe936dfc91507b5f8ab

f9482149ce0a91e8f24d34913f03fb9764d07f6c

refs/heads/master

HTML

from django.urls import path from QA_CommunityForum import views urlpatterns = [ # path('', views.index), # path('', views.HomePageView.as_view(), name='home') ]

UTF-8

Python

py

urls.py

crowdbotics-apps/web-23-dev-6461

ee493bfbfb98f18704c1df4170da1e101fa6a32d

bf72dbcc8cdeeab0c1570269fdaeb44987fd944e

/home/migrations/0003_auto_20200623_0752.py

6553287ab8d0c60eaa35282ae05ebee028038f12

no_license

https://github.com/crowdbotics-apps/web-23-dev-6461

8dffd49588ff0ea8538f1888b398391f90956a54

1d1b8e8c163873a4cbecacc73b921291389929ce

refs/heads/master

# Generated by Django 2.2.13 on 2020-06-23 07:52 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ("home", "0002_load_initial_data"), ] operations = [ migrations.AddField( model_name="customtext", name="ghfjhfgjhgfjhgfjh", field=models.BigIntegerField(blank=True, null=True), ), migrations.AddField( model_name="customtext", name="jhghfkjfkjgf", field=models.BigIntegerField(blank=True, null=True), ), ]

UTF-8

Python

py

0003_auto_20200623_0752.py

SagittariusA-Star/AST5220-Milestone-I

21950f0c931fbc7fbe6644791050c214bceeac4c

8668ef7e84aa9dd9f595c8959936a288de1ae0f2

/src/plot_recombination.py

2476f245f56bbf618c4b8abd45b413b01ace60c8

no_license

https://github.com/SagittariusA-Star/AST5220-Milestone-I

c38575f085b9b0c3eae02af0ab5e84e7d97feea3

3525cf59a40854747d695b658307b53f2ddb8089

refs/heads/master

import numpy as np import matplotlib.pyplot as plt import matplotlib from astropy import constants as const from astropy import units as u plt.style.use("bmh") fonts = { "font.family": "serif", "axes.labelsize": 18, "font.size": 12, "legend.fontsize": 18, "xtick.labelsize": 12, "ytick.labelsize": 12, } plt.rcParams.update(fonts) # Density parameters needed to plot background # color corresponding to domination era cosmo_data = np.loadtxt("cosmology.txt") OmegaB = cosmo_data[:, 3] OmegaCDM = cosmo_data[:, 4] OmegaLambda = cosmo_data[:, 5] OmegaR = cosmo_data[:, 6] Omega_sum = OmegaB + OmegaCDM + OmegaLambda + OmegaR Omega_m = OmegaCDM + OmegaB # Loading data from file recombo_data = np.loadtxt("recombination.txt") x = recombo_data[:, 0] Xe = recombo_data[:, 1] ne = recombo_data[:, 2] * u.m ** (- 3) tau = recombo_data[:, 3] dtaudx = recombo_data[:, 4] ddtaudxdx = recombo_data[:, 5] g_tilde = recombo_data[:, 6] dg_tildedx = recombo_data[:, 7] ddg_tildeddx = recombo_data[:, 8] Saha_Xe = recombo_data[:, 9] # Computing printout data g_integral = np.trapz(g_tilde, x = x) x_rec = x[np.argmin(np.abs(Xe - 0.5))] a_rec = np.exp(x_rec) z_rec = 1 / a_rec - 1 Saha_x_rec = x[np.argmin(np.abs(Saha_Xe - 0.5))] Saha_a_rec = np.exp(Saha_x_rec) Saha_z_rec = 1 / Saha_a_rec - 1 log_rel_error = np.log10(np.abs(g_integral - 1)) x_lss = x[np.where(g_tilde == g_tilde.max())][0] a_lss = np.exp(x_lss) z_lss = 1 / a_lss - 1 g_max = g_tilde.max() tau_transparent = tau[np.abs(tau - 1).argmin()] x_transparent = x[np.abs(tau - 1).argmin()] # Printout of interesting information print("----------------------------Some interesting quantities------------------------") print("Integral of g_tilde: {0}, log rel error: {1}".format(g_integral, log_rel_error)) print("Maximum of g_tilde: x = {0}, g_tilde = {1}".format(x_lss, g_max)) print("Optical depth: tau = {0} at x = {1}".format(tau_transparent, x_transparent)) print("Redshift at last scattering: z = {0}".format(z_lss)) print("Recombination (Xe = 0.5): x = {0}, z = {1}".format(x_rec, z_rec)) print("Recombination Saha (Xe = 0.5): x = {0}, z = {1}".format(Saha_x_rec, Saha_z_rec)) print("-------------------------------------------------------------------------------") # Generating plots fig = plt.figure(figsize=[1.5 * 7.1014, 1.5 * 7.1014 / 1.618]) # Plotting electron fraction ax10 = plt.subplot(221) ax10.scatter(x_rec, Xe[np.where(x == x_rec)], color = "r", label=r"$(x_{rec}, X_{e,rec})$", zorder = 3) ax10.plot(x, Xe, label=r"$X_e(x)$", zorder = 1) ax10.text(-10, Xe[np.where(x == x_rec)], r"$({0:.2f}, {1:.2f})$".format(x_rec, 0.5), color = "r") ax10.scatter(Saha_x_rec, Saha_Xe[np.where(x == Saha_x_rec)], color = "g", zorder = 4, label=r"$(x_{rec}, X_{e,rec}^{Saha})$") ax10.plot(x, Saha_Xe, label=r"$X_e^{Saha}(x)$", zorder = 2) ax10.text(-10, 0.5 * Saha_Xe[np.where(x == Saha_x_rec)], r"$({0:.2f}, {1:.2f})$".format(Saha_x_rec, 0.5), color = "g") ax10.legend(fontsize = 16) ax10.set_xlabel(r"$x = \log (a)$") ax10.set_ylabel(r"$X_e \approx n_e / n_H$") ax10.set_yscale("log") ax10.set_xlim(-12, 0) ax10.set_ylim(1.5e-4, 5) ax10.axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax10.axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax10.axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) # Plotting electron density ax11 = plt.subplot(222) ax11.plot(x, ne, label=r"$n_e(x)$") ax11.legend() ax11.set_xlabel(r"$x = \log (a)$") ax11.set_ylabel(r"$n_e [\mathrm{m^{-3}}]$") ax11.set_yscale("log") ax11.set_xlim(-12, 0) ax11.axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax11.axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax11.axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) # Plotting optical depth ax12 = plt.subplot(212) ax12.plot(x, tau, label=r"$\tau(x)$") ax12.plot(x, - dtaudx, label=r"$-\tau'(x)$", linestyle = "--") ax12.plot(x, ddtaudxdx, label=r"$\tau''(x)$", linestyle = "-.") ax12.scatter(x_transparent, tau_transparent, color = "r", label = r"$(x_{lss}, \tau_{lss})$") ax12.text(-8.2, 1, "({0:.2f}, 1)".format(x_transparent), color = "r") ax12.legend() ax12.set_xlabel(r"$x = \log (a)$") ax12.set_ylabel(r"$\tau(x)$") ax12.set_ylim(1e-8, 1e8) ax12.set_xlim(-12, 0) ax12.set_yscale("log") ax12.axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax12.axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax12.axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) fig.tight_layout() fig.savefig("../doc/Figures/Xe_ne_tau.pdf", dpi=1000) # Plotting visibility function, derivative and second derivative thereof fig1, ax1 = plt.subplots(2, 2 , figsize=[1.5 * 7.1014, 1.5 * 7.1014 / 1.618]) ax1[0, 0].scatter(x_lss, g_max, color = "r", label = r"$(x_{lss}, \tilde{g}_{lss})$") ax1[0, 0].plot(x, g_tilde, label=r"$\tilde{g}(x)$") ax1[0, 0].text(-10, g_max, r"$({0:.2f}, {1:.2f})$".format(x_lss, g_max), color = "r") ax1[0, 0].set_xlim(-12, 0) ax1[0, 0].legend() ax1[0, 0].set_ylabel(r"$\tilde{g}(x)$") ax1[0, 0].set_xlabel(r"$x = \log (a)$") ax1[0, 0].axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax1[0, 0].axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax1[0, 0].axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) ax1[0, 1].plot(x, dg_tildedx, label=r"$\tilde{g}'(x)$") ax1[0, 1].set_ylabel(r"$\frac{d\tilde{g}}{dx}(x)$") ax1[0, 1].set_xlabel(r"$x = \log (a)$") ax1[0, 1].set_xlim(-12, 0) ax1[0, 1].legend() ax1[0, 1].axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax1[0, 1].axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax1[0, 1].axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) ax1[1, 0].plot(x, ddg_tildeddx, label=r"$\tilde{g}''(x)$") ax1[1, 0].legend() ax1[1, 0].set_xlim(-12, 0) ax1[1, 0].set_ylabel(r"$\frac{d^2\tilde{g}}{dx^2}(x)$") ax1[1, 0].set_xlabel(r"$x = \log (a)$") ax1[1, 0].axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax1[1, 0].axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax1[1, 0].axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) # Peak normalized visibility function and its derivatives ax1[1, 1].plot(x, g_tilde / np.max(g_max), label=r"$\tilde{g}(x)$") ax1[1, 1].plot(x, dg_tildedx / np.max(np.max(dg_tildedx)), label=r"$\tilde{g}'(x)$") ax1[1, 1].plot(x, ddg_tildeddx / np.max(np.abs(ddg_tildeddx)), label=r"$\tilde{g}''(x)$") ax1[1, 1].legend(loc = 1) ax1[1, 1].set_xlim(-7.5, -5.7) ax1[1, 1].set_ylabel(r"Peak normalized") ax1[1, 1].set_xlabel(r"$x = \log (a)$") ax1[1, 1].axvspan( np.min(x), x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], alpha=0.3, color="orange", ) ax1[1, 1].axvspan( x[np.where(OmegaB + OmegaCDM >= OmegaLambda + OmegaR)][0], x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], alpha=0.3, color="cyan", ) ax1[1, 1].axvspan( x[np.where(OmegaLambda >= Omega_sum - OmegaLambda)][0], np.max(x), alpha=0.3, color="purple", ) fig1.tight_layout() fig1.savefig("../doc/Figures/g_tilde.pdf", dpi=1000) plt.show()

UTF-8

Python

py

plot_recombination.py

qimo00/timo

720953b131d21ca437a75bde9afed3d6f4fa08aa

86146192c0162428887102cdd15f43d338216ee9

/test1_login()def.py

ebdd3f0da43f3ad9e228dcf7b55c38f75490a767

no_license

https://github.com/qimo00/timo

46d894323a2a82c8170162f343d1c5d5ed1fa690

01f5a1e6ef304479fd806cc607cd99f3c2d8ba41

refs/heads/master

user_data={} def logIn(): while True: print('|---新建用户：N/n---|') print('|---登录账号：E/e---|') print('|---退出账号：Q/q---|') print('请输入命令代码：') command=input() if command=='N' or command=='n': newC() # continue elif command=='E' or command=='e': enterC() # continue elif command=='Q' or command =='q': break else: print('输入命令有误，请重新输入：\n') print('退出成功~') def newC(): while True: name = input('请输入用户名：') if name in user_data: print('该用户名已存在，请重新输入') continue else: code=input('请输入密码：') user_data[name]=code print('创建用户成功！') break return def enterC(): name=input('请输入用户名:') if name in user_data: code=input('请输入密码：') if code==user_data[name]: print("登录成功！") else: print('密码错误~') else: print('该用户不存在！') return logIn()

UTF-8

Python

py

test1_login()def.py

bartek412/IntermediatePythonCourse

0d6fc7afb19473bc50773413e61171b5c9cd428a

504cbe0df5cc4ff320b4f3168414b7168c04e392

/task49_args&kwargs.py

67ec37c1ac69ba4730237fd53dccc8d2b1d316fe

no_license

https://github.com/bartek412/IntermediatePythonCourse

5f93e4c86f3c883a719b8da0283b48e2a0053926

73a41a0017906c982f23eaa5a6d50cd44469ceef

refs/heads/master

def calculate_paint(efficency_ltr_per_m2, *args): return sum(args)*efficency_ltr_per_m2 print(calculate_paint(2, 10, 12, 28)) area = [18, 21, 32, 42] print(calculate_paint(2, *area)) def log_it(*args): with open(r'C:\Users\barte\Documents', 'a') as f: for string in args: f.write(string + ' ') f.write('\n') log_it('Starting processing forecasting') log_it('ERROR', 'Not enough data', 'invoices', '2020')

UTF-8

Python

py

task49_args&kwargs.py

biseshbhattarai/Transaction-Microservice

14ce7d77215848b80a8738629c73963aa760232d

d12a9ae0b4ca53f6ecc2e525e77aaefa908059c5

/shopapp/shoptrans/urls.py

e2bcbfef1d6fcba8dcf03f84c9aed39c0a15881b

permissive

https://github.com/biseshbhattarai/Transaction-Microservice

64a4dbb4a279a0fae7ec8a4a8760fad787c43b18

32226e339d53842d6178f50d5988880e7a7ae7c3

refs/heads/master

from django.urls import path from . import views from .views import CreateTransaction, ProductUpdateView, SingleDayApiView,ProductApiView, CapitalApiView,UserApiView ,CategoryApiView, ProductDetailView urlpatterns = [ path('',views.main, name="main"), path('<int:pk>/', views.transaction, name="product"), path('<int:pk>/update/', ProductUpdateView.as_view(), name="update"), path('add/', CreateTransaction.as_view(), name="add"), path('dashboard/', views.dashboard_view, name="dashboard"), path('products/', ProductApiView.as_view(), name="api-product"), path('product/<int:pk>/', ProductDetailView.as_view(), name="api-detail"), path('capital/', CapitalApiView.as_view(), name="api-capital"), path('category/', CategoryApiView.as_view(), name="api-category"), path('users/', UserApiView.as_view(), name="api-users"), path('single/',SingleDayApiView.as_view(), name="api-single" ) ]

UTF-8

Python

py

urls.py

TheURBN/turg

c179cb149a596217b8a4f8dad39dd063035df42e

b68691423cc1c937cd13994fcb2e641ca6d9cae1

/turg/logger.py

36e9000263318761401cceadc441b95e3756d49d

permissive

https://github.com/TheURBN/turg

54db64a35dc500364a6c20a56caffa0241ce006f

93e459ac3adc606a9f1b15acfe414fc8d3550c10

refs/heads/master