Datasets:

Reset23

/

the-stack-v2-processed

like 0

6b59d53ff5dca12c2cf49ecda84be12a1c60a12c

a3644ed207867df4d78a04af39ac3e26f86f9012

/ibvp/language/symbolic/util.py

cf587104d319938fea973aba507443ccc906a896

permissive

ibvp/ibvp

006887be85a37ac4da51664d5fec9244c446cacd

c758b150cbd822bd17444499bea29c53b0606327

refs/heads/master

UTF-8

Python

py

from __future__ import division from __future__ import absolute_import from six.moves import range __copyright__ = "Copyright (C) 2010-2013 Andreas Kloeckner" __license__ = """ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import numpy as np def pretty(expr): from ibvp.language.symbolic.mappers import PrettyStringifyMapper stringify_mapper = PrettyStringifyMapper() from pymbolic.mapper.stringifier import PREC_NONE result = stringify_mapper(expr, PREC_NONE) splitter = "="*75 + "\n" cse_strs = stringify_mapper.get_cse_strings() if cse_strs: result = "\n".join(cse_strs)+"\n"+splitter+result return result def join_fields(*args): from pytools.obj_array import make_obj_array, log_shape from pymbolic.geometric_algebra import MultiVector, bit_count res_list = [] for arg in args: if isinstance(arg, list): res_list.extend(arg) elif isinstance(arg, MultiVector): for grade in arg.all_grades(): for bits in range(2**arg.space.dimensions): if bit_count(bits) == grade: res_list.append(arg.data.get(bits, 0)) elif isinstance(arg, np.ndarray): if log_shape(arg) == (): res_list.append(arg) else: res_list.extend(arg.flat) else: res_list.append(arg) return make_obj_array(res_list)

inform@tiker.net

06683c64c9c082713d0b286d60bf3d006bef3569

6fcfb638fa725b6d21083ec54e3609fc1b287d9e

/python/NicolasHug_Surprise/Surprise-master/examples/grid_search_usage.py

f915af8c2eff0478eb4c7a991024a2a4e4aa1ff3

no_license

LiuFang816/SALSTM_py_data

6db258e51858aeff14af38898fef715b46980ac1

d494b3041069d377d6a7a9c296a14334f2fa5acc

refs/heads/master

Python

UTF-8

Python

py

""" This module describes how to manually train and test an algorithm without using the evaluate() function. """ from __future__ import (absolute_import, division, print_function, unicode_literals) from surprise import GridSearch from surprise import SVD from surprise import Dataset param_grid = {'n_epochs': [5, 10], 'lr_all': [0.002, 0.005], 'reg_all': [0.4, 0.6]} grid_search = GridSearch(SVD, param_grid, measures=['RMSE', 'FCP']) # Prepare Data data = Dataset.load_builtin('ml-100k') data.split(n_folds=3) grid_search.evaluate(data) # best RMSE score print(grid_search.best_score['RMSE']) # >>> 0.96117566386 # combination of parameters that gave the best RMSE score print(grid_search.best_params['RMSE']) # >>> {'reg_all': 0.4, 'lr_all': 0.005, 'n_epochs': 10} # best FCP score print(grid_search.best_score['FCP']) # >>> 0.702279736531 # combination of parameters that gave the best FCP score print(grid_search.best_params['FCP']) # >>> {'reg_all': 0.6, 'lr_all': 0.005, 'n_epochs': 10} import pandas as pd # noqa results_df = pd.DataFrame.from_dict(grid_search.cv_results) print(results_df)

659338505@qq.com

e854ed4a3386c854b4fb23ef278a885098c04eaf

2b49bf0b7b9a62eb665cb0da9a86d7c65433f8a2

/Additional/206.Reverse Linked List.py

06f7ef7c083a993eeb7cd52a2f6ada4422dd50d7

no_license

samuel871211/My-python-code

f7472fff671437d6181b91d36a77e24eb04678c6

3120cfb6ccaeade969dd0ea0ff335b4a5789ba74

refs/heads/master

UTF-8

Python

py

class ListNode: def __init__(self, x): self.val = x self.next = None class Solution: def reverseList(self, head: ListNode) -> ListNode: a = [] while head != None: a.append(head.val) head = head.next if len(a) == 0: return None else: a.reverse() newhead = ListNode(a[0]) cur = newhead for i in range(1,len(a)): cur.next = ListNode(a[i]) cur = cur.next return newhead

noreply@github.com

904ddc6a110c928eecd9ed053afa3bf80f4931a3

de24f83a5e3768a2638ebcf13cbe717e75740168

/moodledata/vpl_data/25/usersdata/98/11884/submittedfiles/av1_3.py

e38e0f0784c64456ff7dcadb762460593411b8a4

no_license

rafaelperazzo/programacao-web

95643423a35c44613b0f64bed05bd34780fe2436

170dd5440afb9ee68a973f3de13a99aa4c735d79

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- from __future__ import division import math a=int(input('Digite o valor de a: ')) b=int(input('Digite o valor de b: ')) i=1 cont=0 c=0 while True: if a%i==0 and b%i==0: cont=cont+1 c=i i=i+1 if i==a or i==b: break

rafael.mota@ufca.edu.br

e50e19db7754f252118d5e3c69541abe67d0fdab

de24f83a5e3768a2638ebcf13cbe717e75740168

/moodledata/vpl_data/42/usersdata/69/21660/submittedfiles/jain.py

34c02d431af79001b4eb9414ce0115cad59ff0fc

no_license

rafaelperazzo/programacao-web

95643423a35c44613b0f64bed05bd34780fe2436

170dd5440afb9ee68a973f3de13a99aa4c735d79

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- from __future__ import division import funcoes ''' ENTRADA TESTE f = 0.2 dH = 5 L = 3250 Q = 0.005 g = 9.81 v = 0.000001 e = 0.00006 k = 10 A saida para esta entrada é aproximadamente: 0.1247 (D) e 0.0224 (f) ''' f = 0.2 dH = input('Digite a perda de carga: ') L = input('Digite o comprimento da tubulação: ') Q = input('Digite a vazão: ') g = input('Digite a gravidade: ') v = input('Digite a viscosidade cinemática: ') e = input('Digite a rugosidade absoluta: ') k = 10 #comece aqui import math def diametro(fn,L,Q,dH): Diam=((8*fn*L*Q*Q)/(math.pi*math.pi*dH*g))**(1/5) return Diam def Reynalds(Q,D,v): R=4*Q/(math.pi*D*v) return R def atrito(Rey,E,D): s=(E/(3.7*D))+(5.74/(Rey**0.9)) t=(2500/Rey)**6 f=(((64/Rey)**8)+9.5*((math.log(s)-t)**(-16)))**0.125 return f for i in range(0,k,1): D=diametro(fn,L,Q,dH) Rey=Reynalds(Q,D,v) fn=atrito(Rey,e,D) if 0.000001<=(e/D)<=0.01 and 5000<=Rey<=100000000: if fn==f: break else: f=fn print('%.10f'%f) print('%.10f'%D)

rafael.mota@ufca.edu.br

d84e02f5f2815a7f82b35a8daa0cb83b201fc09c

6e1508ebdaf63b3afee10926bdf74ce9478f3508

/kadanesalgorithm.py

4ebc51ef1200e349f04a36b701abf97ccdb58046

no_license

dopeprogr4mmer/DSA

5f2741a924bec9b6add7b4d92d207ec553576439

18f4bd93b264acfd4cfd91b9aa318bdf502d0339

refs/heads/main

UTF-8

Python

py

<<<<<<< HEAD <<<<<<< HEAD import sys ======= >>>>>>> d86366dc91ea42926b2be1e049e46fb03f518c05 ======= >>>>>>> d86366dc91ea42926b2be1e049e46fb03f518c05 def maxSubArraySum(a,size): max_so_far = 0 max_ending_here = 0 for i in range(size): <<<<<<< HEAD <<<<<<< HEAD #max_ending_here += a[i] if max_ending_here + a[i]<a[i]: max_ending_here = a[i] else: max_ending_here+=a[i] if(max_so_far<max_ending_here): max_so_far = max_ending_here print(max_so_far) return max_so_far def max_SubArray_Sum(a,size): #Kadane algo ##Your code here output_arr = [0]*size output_arr[0]=a[0] max_sum = a[0] for i in range(1,size): output_arr[i] = max(a[i], output_arr[i-1]+a[i]) #print(output_arr) max_sum = max(max_sum, output_arr[i]) print(output_arr, max_sum) return max_sum maxSubArraySum([2,3,-6,3,3,-6,1,-5], 5) ======= ======= >>>>>>> d86366dc91ea42926b2be1e049e46fb03f518c05 max_ending_here += a[i] if max_ending_here<0: max_ending_here = 0 elif(max_so_far<max_ending_here): max_so_far = max_ending_here <<<<<<< HEAD return max_so_far >>>>>>> d86366dc91ea42926b2be1e049e46fb03f518c05 ======= return max_so_far >>>>>>> d86366dc91ea42926b2be1e049e46fb03f518c05

noreply@github.com

c4de4f95686f6d39c4a347e4462b601fbc2bd6d2

ca7aa979e7059467e158830b76673f5b77a0f5a3

/Python_codes/p03828/s176803120.py

3c09dd5cfe45d562d5aee2961335ac10dec7d7b7

no_license

Aasthaengg/IBMdataset

7abb6cbcc4fb03ef5ca68ac64ba460c4a64f8901

f33f1c5c3b16d0ea8d1f5a7d479ad288bb3f48d8

refs/heads/main

UTF-8

Python

py

from collections import Counter MOD = 10 ** 9 + 7 def factorize(n): """ Simple factorize :param n: number to factorize :return: list of factors time complexity : O(n√n) space complexity : O(n) """ factors = [] for i in range(2, n+1): while n % i == 0: n = n // i factors.append(i) return factors def main(): N = int(input()) factors = [] for i in range(1, N+1): factors += factorize(i) factor_counts = list(Counter(factors).values()) ans = 1 for v in factor_counts: ans = ans * (v+1) % MOD print(ans) main()

66529651+Aastha2104@users.noreply.github.com

f970d26407f174a743bcb989cdae5fd18f1cf862

969ae96c883fa8aee938a03af40be54dad60f0ca

/query_scripts/intersect_base.py

13528a869bc3f58b6e98c732106540b26f4a338d

no_license

fuxmanlab/altered_TFBS

1cd695c734cbbfd23b72c683ff9a531306144337

2cc4a3c95836b3f980764619597b37cd967091dc

refs/heads/master

UTF-8

Python

py

# Base class for loading, saving, and querying the .bed and .vcf # files import useful import tempfile import os import glob import shutil class IntersectBase(object): ''' Base class for intersecting .bed and .vcf files with the alterome datafiles using Spark-SQL.''' def __init__(self, filename, hadoop=False): if not hadoop: if not os.path.exists(filename): raise OSError("File not found: %s" % filename) self.filename = filename # The loaded dataframe from the file self.df = None #The result of the query self.intersect_df = None # Are we on hadoop? self.hadoop = hadoop def to_df(self, spark): ''' Convert the file to a Spark DataFrame, stored internally in self.df. The df is registered as a Spark SQL temp table. ''' pass def intersection_query(self,spark): ''' Intersection query for the .bed and .vcf files with the alterome in the tfbs_df and tf_info_df dataframes. Stores the result internally in self.intersect_df. ''' pass def write_df(self, output_csv, npartitions=None): ''' Write in parallel to a set of output CSV files and them consolidate them into 1.''' tmp_name = self.df_to_csv(output_csv, npartitions) if not self.hadoop: self.consolidate_csv(tmp_name,output_csv) @useful.timeit def df_to_csv(self,output_csv, npartitions=None): # Repartition if asked if npartitions: self.intersect_df.repartition(npartitions) # Get a unique temporary filename using the process id if not self.hadoop: tmp_name = str(os.getpid())+'_tmp' tmp_path = os.path.join(os.environ['TMPDIR'],tmp_name+'.csv') if os.path.exists(tmp_path): shutil.rmtree(tmp_path) self.intersect_df.write.option('header','true').csv(tmp_path) return tmp_path else: self.intersect_df.write.option('header','true').csv(output_csv) @useful.timeit def consolidate_csv(self, input_dir,output_csv, delete_input=True): print("Consolidating parallel CSV files.") if os.path.exists(output_csv): os.unlink(output_csv) # Then write a loop to read them in one-by-one and append to the requested output_csv csv_files = glob.glob(os.path.join(input_dir,'*.csv')) shutil.copyfile(csv_files.pop(0),output_csv) # Now open the output file for appending and add all the # others to it. with open(output_csv, 'ab') as outfile: for fname in csv_files : with open(fname, 'rb') as infile: # Throw away the header line infile.readline() # Block copy rest of file from input to output without parsing shutil.copyfileobj(infile, outfile) # Finally delete the whole temp directory if requested. if delete_input: shutil.rmtree(input_dir)

noreply@github.com

403fac664e7532d39cf7a726cf9165c6b7e21555

fa461310d67a51dc0f473e54bd02c90c12c7f7dc

/Query understanding/demo1.py

a9f1754dc771f5deedea583220bd1d8b0d3f305b

no_license

yangeryang/Ads-ranking-

624cf215eda0837e0df738a7ec96d2811d053916

216c10fa49c52e0fbb913ef2a7d53cd92700d576

refs/heads/master

UTF-8

Python

py

import sys from pyspark import SparkContext if __name__ == "__main__": file = sys.argv[1] #raw train file sc = SparkContext(appName="demo1") data_uc = sc.textFile(file).map(lambda line: line.upper()) data_filt = data_uc.filter(lambda line: line.startswith("T")) #data_uc... data_filt.saveAsTextFile("demo_T_output6") sc.stop()

noreply@github.com

76a29edd0e8bbc220e530784749c7239e7e13007

650772c1de39412ed293bdd9f28518d3e50b2ef0

/transformations/color_demo.py

4f726733b2310e4fb9232d6f0ae9d75b6b914973

no_license

tuftsceeo/Onshape-PLUS-Team

2ecb62d40ba5349cad3ebd39368b771d95d88649

40bcd952ca7b84660615d8812c0e3ec3ce0211e6

refs/heads/master

UTF-8

Python

py

############################################################################### # Project name: Color Demo # File name: color_demo.py # Author: Therese (Teo) Patrosio @imnotartsy # Date: 7/21/20 # Description: Connects spike bluetooth to onshape api for 7/23 demo # History: # Last modified by Teo 7/24/20 # (C) Tufts Center for Engineering Education and Outreach (CEEO) ############################################################################### import serial #pip3 install pyserial import utils.transform_utils as transform import utils.onshape_utils as onshape import argparse from datetime import datetime ### Connect to Serial ser = serial.Serial('/dev/tty.LEGOHubOwen-SerialPortP') # serial.Serial(port_args.port) # ### Gets Spike starter message for i in range(0,2): line = ser.readline() print(line.decode(), end="") ### Catch case for if spike goes into data spewing mode (untested) (WIP) # Cancels any Data Sending ser.write('\x03'.encode()) ser.write('\x03'.encode()) ser.write('\x03'.encode()) ser.write('\x03'.encode()) ### Message to send to serial ## This program gets the gesture of the spike message = """ import hub,utime\r\n from spike.control import wait_for_seconds\r\n def setMotor(large, small):\r\n\b\b hub.port.C.motor.run_to_position(large, 50)\r\n\b hub.port.D.motor.run_to_position(small, 50)\r\n\b \r\n\r\n\r\n\r\n """ print(message) ser.write('\x03'.encode()) ser.write(message.encode()) last = 0 assembly = onshape.getAssemblyInfo(False) # print(assembly["MvFKyhclA9pW5axe3"]["fullPath"]) ### Read Data and call API for i in range(0,1000): line = ser.readline() ## Prints serial line print(line.decode(), end="") try: curr = int(line.decode()) except: print("position not updated") curr = last ## If state changes, call a transform if(abs(curr - last) > 5): ## Sets transformation args = [0, 0, 0, 0, 0, 1, curr] ## Transforms set up (get matrix and part id from assembly info) M = transform.getTranslationMatrix(args, False) partsToTransform = [assembly["MvFKyhclA9pW5axe3"]["fullPath"]] # selects motor axle state = onshape.postTransform(M, False, partsToTransform, False) print("\tTransformation status:", state, datetime.now()) last = curr ser.close()

noreply@github.com

736a6dd319cdb36e01d57e42fdf371c5db550c22

6fcfb638fa725b6d21083ec54e3609fc1b287d9e

/python/ghwatson_faststyle/faststyle-master/losses.py

7a4cc6b60cea27257d8a4820a88ca8fb5d7f1574

no_license

LiuFang816/SALSTM_py_data

6db258e51858aeff14af38898fef715b46980ac1

d494b3041069d377d6a7a9c296a14334f2fa5acc

refs/heads/master

Python

UTF-8

Python

py

""" This file contains the different loss functions. File author: Grant Watson Date: Feb 2017 """ import tensorflow as tf import numpy as np def content_loss(content_layers, target_content_layers, content_weights): """Defines the content loss function. :param content_layers List of tensors for layers derived from training graph. :param target_content_layers List of placeholders to be filled with content layer data. :param content_weights List of floats to be used as weights for content layers. """ assert(len(target_content_layers) == len(content_layers)) num_content_layers = len(target_content_layers) # Content loss content_losses = [] for i in xrange(num_content_layers): content_layer = content_layers[i] target_content_layer = target_content_layers[i] content_weight = content_weights[i] loss = tf.reduce_sum(tf.squared_difference(content_layer, target_content_layer)) loss = content_weight * loss _, h, w, c = content_layer.get_shape().as_list() num_elements = h * w * c loss = loss / tf.cast(num_elements, tf.float32) content_losses.append(loss) content_loss = tf.add_n(content_losses, name='content_loss') return content_loss def style_loss(grams, target_grams, style_weights): """Defines the style loss function. :param grams List of tensors for Gram matrices derived from training graph. :param target_grams List of numpy arrays for Gram matrices precomputed from style image. :param style_weights List of floats to be used as weights for style layers. """ assert(len(grams) == len(target_grams)) num_style_layers = len(target_grams) # Style loss style_losses = [] for i in xrange(num_style_layers): gram, target_gram = grams[i], target_grams[i] style_weight = style_weights[i] _, c1, c2 = gram.get_shape().as_list() size = c1*c2 loss = tf.reduce_sum(tf.square(gram - tf.constant(target_gram))) loss = style_weight * loss / size style_losses.append(loss) style_loss = tf.add_n(style_losses, name='style_loss') return style_loss def tv_loss(X): """Creates 2d TV loss using X as the input tensor. Acts on different colour channels individually, and uses convolution as a means of calculating the differences. :param X: 4D Tensor """ # These filters for the convolution will take the differences across the # spatial dimensions. Constructing these on paper has to be done carefully, # but can be easily understood when one realizes that the sub-3x3 arrays # should have no mixing terms as the RGB channels should not interact # within this convolution. Thus, the 2 3x3 subarrays are identity and # -1*identity. The filters should look like: # v_filter = [ [(3x3)], [(3x3)] ] # h_filter = [ [(3x3), (3x3)] ] ident = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) v_array = np.array([[ident], [-1*ident]]) h_array = np.array([[ident, -1*ident]]) v_filter = tf.constant(v_array, tf.float32) h_filter = tf.constant(h_array, tf.float32) vdiff = tf.nn.conv2d(X, v_filter, strides=[1, 1, 1, 1], padding='VALID') hdiff = tf.nn.conv2d(X, h_filter, strides=[1, 1, 1, 1], padding='VALID') loss = tf.reduce_sum(tf.square(hdiff)) + tf.reduce_sum(tf.square(vdiff)) return loss

659338505@qq.com

40a5badf20a8815924f3d9ea4e245dba81149a88

ca7aa979e7059467e158830b76673f5b77a0f5a3

/Python_codes/p03588/s910432178.py

314d7a583d1067ee67cd31e93342774353c07a3a

no_license

Aasthaengg/IBMdataset

7abb6cbcc4fb03ef5ca68ac64ba460c4a64f8901

f33f1c5c3b16d0ea8d1f5a7d479ad288bb3f48d8

refs/heads/main

UTF-8

Python

py

import sys def solve(): readline = sys.stdin.buffer.readline mod = 10 ** 9 + 7 n = int(readline()) ab = [list(map(int, readline().split())) for _ in range(n)] ab.sort() print((ab[-1][0] - ab[0][0] + 1) + (ab[0][0] - 1) + (ab[-1][1])) if __name__ == '__main__': solve()

66529651+Aastha2104@users.noreply.github.com

702e397972e162ab5ddf2af196684a76f393bd61

71673d845952b50986d1c21dc5bbbcab2a2a2651

/introduction_to_lxml.py

0783fcf78d6a6982eff93f7b0558518976c20d60

no_license

afcarl/introductionToWebScraping

77a44bfb7655e44231bed216d37b015e3cf52a5c

d1039aeee87365f2807dd198e53bd1bb6224a550

refs/heads/master

UTF-8

Python

py

import requests import lxml.html base_url = "https://www.google.com" def scrape(url,base_url,depth): if depth == 0: return True r = requests.get(url) html = lxml.html.fromstring(r.text) links = html.xpath("//a/@href") for ind,link in enumerate(links): if "http" in link: print link else: print base_url+link links[ind] = base_url+link for link in links: scrape(link,base_url,depth-1) scrape(base_url,base_url,5)

ericschles@gmail.com

611ca1b0710e080956b3f0259d5042c17ada5814

bad62c2b0dfad33197db55b44efeec0bab405634

/sdk/signalr/azure-mgmt-signalr/azure/mgmt/signalr/aio/operations/_usages_operations.py

aa1860efef37dbf2413c285639f2957501b5bfdb

permissive

test-repo-billy/azure-sdk-for-python

20c5a2486456e02456de17515704cb064ff19833

cece86a8548cb5f575e5419864d631673be0a244

refs/heads/master

MIT

Python

UTF-8

Python

py

# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import functools from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar import warnings from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.rest import HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.mgmt.core.exceptions import ARMErrorFormat from ... import models as _models from ..._vendor import _convert_request from ...operations._usages_operations import build_list_request T = TypeVar('T') ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] class UsagesOperations: """UsagesOperations async operations. You should not instantiate this class directly. Instead, you should create a Client instance that instantiates it for you and attaches it as an attribute. :ivar models: Alias to model classes used in this operation group. :type models: ~azure.mgmt.signalr.models :param client: Client for service requests. :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An object model deserializer. """ models = _models def __init__(self, client, config, serializer, deserializer) -> None: self._client = client self._serialize = serializer self._deserialize = deserializer self._config = config @distributed_trace def list( self, location: str, **kwargs: Any ) -> AsyncIterable["_models.SignalRUsageList"]: """List resource usage quotas by location. :param location: the location like "eastus". :type location: str :keyword callable cls: A custom type or function that will be passed the direct response :return: An iterator like instance of either SignalRUsageList or the result of cls(response) :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.signalr.models.SignalRUsageList] :raises: ~azure.core.exceptions.HttpResponseError """ cls = kwargs.pop('cls', None) # type: ClsType["_models.SignalRUsageList"] error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {})) def prepare_request(next_link=None): if not next_link: request = build_list_request( location=location, subscription_id=self._config.subscription_id, template_url=self.list.metadata['url'], ) request = _convert_request(request) request.url = self._client.format_url(request.url) else: request = build_list_request( location=location, subscription_id=self._config.subscription_id, template_url=next_link, ) request = _convert_request(request) request.url = self._client.format_url(request.url) request.method = "GET" return request async def extract_data(pipeline_response): deserialized = self._deserialize("SignalRUsageList", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) return deserialized.next_link or None, AsyncList(list_of_elem) async def get_next(next_link=None): request = prepare_request(next_link) pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat) return pipeline_response return AsyncItemPaged( get_next, extract_data ) list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.SignalRService/locations/{location}/usages'} # type: ignore

noreply@github.com

df4017d719a457eb43a5aa6c9d289e9e674a9b84

e61802befd592a18d535999277e3d4767042a441

/problem_11.py

8c4304f4ad7e6f7973982931f25f9f46d2d2458a

no_license

subenakhatun/pythonbasic

5962804d4aaee18c9bc5e8f1d178ae846efabd85

36066df0a9355c6d451e80e06fba2fb712759f3d

refs/heads/master

UTF-8

Python

py

str = 'subena' print(len(str))

noreply@github.com

45158fd73f856d10753fdab1158bbd52cbc902c4

d94b6845aeeb412aac6850b70e22628bc84d1d6d

/es_maml/policies.py

f901bf44a33836629722349dd7c0953bd0a94da7

permissive

ishine/google-research

541aea114a68ced68736340e037fc0f8257d1ea2

c1ae273841592fce4c993bf35cdd0a6424e73da4

refs/heads/master

Apache-2.0

Jupyter Notebook

UTF-8

Python

py

# coding=utf-8 # Copyright 2023 The Google Research Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Contains policies used in MAML.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import abc import numpy as np import tensorflow.compat.v1 as tf import tensorflow_probability as tfp class Policy(object): r"""Abstract class for different policies \Pi: S -> A. Class is responsible for creating different policies and provides an interface for computing actions recommended by policies in different input states. In particular, this class provides an interface that accepts compressed vectorized form of the policy and decompresses it. Standard procedure for improving the parameters of the policy with an interface given by the class: policy = policies.ParticularClassThatInheritsFromBaseClass(...) vectorized_network = policy.get_initial() while(...): new_vectorized_network = SomeTransformationOf(vectorized_network) policy.update(new_vectorized_network) and SomeTransformationOf is a single step of some optimization procedure such as gradient descent that sees the policy in the vectorized form. """ __metaclass__ = abc.ABCMeta @abc.abstractmethod def update(self, vectorized_parameters): """Updates the policy using new parameters from <vectorized_parameters>. Updates the parameters of the policy using new parameters encoded by <vectorized_parameters>. The size of the vector <vectorized_parameters> should be the number of all biases and weights of the neural network. We use the convention where parameters encoding matrices of connections of the neural network come in <vectorized_parameters> before parameters encoding biases and furthermore the order in <vectorized_parameters> of parameters encoding weights for different matrices/biases-vectors is inherited from the order of these matrices/biases-vectors in the decompressed neural network. Details regarding compression depend on different neural network architectures used (such as: structured and unstructured) and are given in the implementations of that abstract method in specific classes that inherit from Policy. Args: vectorized_parameters: parameters of the neural network in the vectorized form. Returns: """ raise NotImplementedError('Abstract method') @abc.abstractmethod def get_action(self, state): """Returns the action proposed by a policy in a given state. Returns an action proposed by the policy in <state>. Args: state: input state Returns: Action proposed by the policy represented by an object of the class in a given state. """ raise NotImplementedError('Abstract method') @abc.abstractmethod def get_initial(self): """Returns the default parameters of the policy in the vectorized form. Initial parameters of the policy are output in the vectorized form. Args: Returns: Numpy array encoding in the vectorized form initial parameters of the policy. """ raise NotImplementedError('Abstract method') @abc.abstractmethod def get_total_num_parameters(self): """Outputs total number of parameters of the policy. Args: Returns: Total number of parameters used by the policy. """ raise NotImplementedError('Abstract method') class BasicTFPolicy(Policy): """Basic Policy implemented in Tensorflow.""" def __init__(self, state_dimensionality, action_dimensionality, hidden_layers, scope): self.state_dimensionality = state_dimensionality self.action_dimensionality = action_dimensionality self.input_ph = tf.placeholder( dtype=tf.float32, shape=[None, self.state_dimensionality]) self.output_ph = tf.placeholder( dtype=tf.float32, shape=[None, self.action_dimensionality]) with tf.variable_scope(scope, reuse=tf.AUTO_REUSE): self.out = self.input_ph for i, layer_size in enumerate(hidden_layers): self.out = tf.layers.dense( self.out, layer_size, activation=tf.nn.relu, name='h' + str(i)) self.main_out = tf.layers.dense( self.out, self.action_dimensionality, name='main_out') self.secondary_out = tf.layers.dense( self.out, self.action_dimensionality, name='secondary_out') self.action = tfp.distributions.Normal( loc=self.main_out, scale=self.secondary_out).sample() self.loss = tf.losses.mean_squared_error(self.main_out, self.output_ph) self.obj_tensor = -1.0 * self.loss self.tf_params = tf.trainable_variables(scope) self.shapes = [v.shape.as_list() for v in self.tf_params] self.sizes = [int(np.prod(s)) for s in self.shapes] self.total_nb_parameters = sum(self.sizes) self.assign_ph_dict = { v: tf.placeholder(dtype=tf.float32, shape=v.shape.as_list()) for v in self.tf_params } self.assign_ops = [] for v in self.tf_params: self.assign_ops.append(v.assign(self.assign_ph_dict[v])) with tf.control_dependencies(self.assign_ops): # This is needed to input Numpy Params into network temporarily self.action = tf.identity(self.action) self.sess = tf.Session() self.sess.run(tf.global_variables_initializer()) self.np_params = np.concatenate([ self.sess.run(tf.reshape(tf_param, [-1])) for tf_param in self.tf_params ]) def update(self, flattened_weights): self.np_params = flattened_weights def get_action(self, state): ph_dict = {} for ind, v in enumerate(self.tf_params): numpy_flat_val = self.np_params[sum(self.sizes[:ind] ):sum(self.sizes[:ind + 1])] numpy_reshaped = np.reshape(numpy_flat_val, self.shapes[ind]) v_ph = self.assign_ph_dict[v] ph_dict[v_ph] = numpy_reshaped ph_dict[self.input_ph] = state.reshape(-1, self.state_dimensionality) action_numpy = self.sess.run(self.action, feed_dict=ph_dict) return action_numpy.flatten() def get_initial(self): return self.np_params def get_total_num_parameters(self): return self.total_nb_parameters class DeterministicNumpyPolicy(Policy): """Deterministic Policy implemented in Numpy.""" def __init__(self, state_dimensionality, action_dimensionality, hidden_layers, init_sd=None): self.state_dimensionality = state_dimensionality self.action_dimensionality = action_dimensionality self.layers = hidden_layers + [action_dimensionality] self.layers.insert(0, state_dimensionality) self.weights = [] self.biases = [] self.weight_positions = [] self.bias_positions = [] self.init_params = [] flat_pos = 0 for dims in zip(self.layers[:-1], self.layers[1:]): in_size = dims[0] out_size = dims[1] if init_sd is None: init_sd = np.sqrt(2.0 / (in_size)) init_weights = init_sd * np.random.normal(0, 1, size=(out_size * in_size)) self.init_params.extend(init_weights.tolist()) self.weights.append(np.reshape(init_weights, (out_size, in_size))) self.weight_positions.append(flat_pos) flat_pos += out_size * in_size init_biases = np.zeros(out_size) self.init_params.extend(init_biases.tolist()) self.biases.append(init_biases) self.bias_positions.append(flat_pos) flat_pos += out_size self.weight_positions.append(flat_pos) def update(self, flat_weights): for i, dims in enumerate(zip(self.layers[:-1], self.layers[1:])): in_size = dims[0] out_size = dims[1] start_pos = self.weight_positions[i] end_pos = start_pos + (out_size * in_size) self.weights[i] = np.reshape( np.array(flat_weights[start_pos:end_pos]), (out_size, in_size)) start_pos = self.bias_positions[i] end_pos = start_pos + out_size self.biases[i] = np.reshape( np.array(flat_weights[start_pos:end_pos]), (out_size)) def get_action(self, state): neuron_values = np.reshape(np.array(state), (self.state_dimensionality)) for i in range(len(self.weights)): neuron_values = np.matmul(self.weights[i], neuron_values) neuron_values += self.biases[i] if i < len(self.weights) - 1: np.maximum(neuron_values, 0, neuron_values) np.tanh(neuron_values, neuron_values) # this is sometimes not needed return neuron_values def get_initial(self): return np.array(self.init_params) def get_total_num_parameters(self): return self.weight_positions[-1]

copybara-worker@google.com

3b8746a1cdd4600634297132c55f8cb3205475c4

d8349b7c3ca5289ea4627719699ae88b536fa24e

/uhr.py

bb9d4cef9887219b82c8773ba0814e754bdfe453

no_license

Mighty-Yth/Affinity

8277ae59785f5663b1458e579f9f49e7719b4871

a4f92421f014c0b296596234b0727bb2b0f526f1

refs/heads/master

UTF-8

Python

py

import discord from discord.ext import commands class Uhr: def __init__(self, identity,user,EXP): self.identity = identity self.user= user self.EXP = EXP def __str__(self): return self.identity + ':' + self.user+':' + str(self.EXP) def deposit(self,amount): if amount >= 0: self.EXP += amount def remove(self,amount): if amount >= 0 and amount<= self.EXP: self.EXP -= amount

noreply@github.com

c92b4463310cabc5b593f28b34d7d29802149be3

8f4e9d24de3dfbd2efae58877ab0043a7da57831

/Learn_PhythonEx/ex6.py

a9b2054e8db34cbb6de3068fbfe0bc208451d780

no_license

dersonnex/Python_learning

1cbcfe428a4765adabdca65d275b63c37acb0ea8

7827962c5f208b36c6511a20d220cba609494853

refs/heads/master

UTF-8

Python

py

x= "There are %d types of people." % 10 # defines veriable X binary = "binary" # defines veriable binary do_not = "don't" # defines veriable do_not y = "Those who know %s and those who %s." % (binary, do_not) # defines veriable y print x print y print "I said: %r." % x #I said :there are 10 types of people. print "I also said: '%s'." % y hilarious = False joke_evaluation = "Isn't that joke so fanny?! %r" print joke_evaluation % hilarious w = "This is the left side of ..." e = "a string with a right side." print w + e

noreply@github.com

ca80285ee2929ac20cf43ad7fff92fb60b9efdea

f81c8e4d702d5c88af92c691d35b6f9c0d2f4390

/backend/dark_waterfall_26026/wsgi.py

e5039146e98431c055564aea9a661c25a52173fd

no_license

crowdbotics-apps/dark-waterfall-26026

bdfd44240dae3c1ad20ed8b7a8da701308db5958

95f9eda959b6d21778ff59db2c5c9a585d6a670c

refs/heads/master

UTF-8

Python

py

""" WSGI config for dark_waterfall_26026 project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dark_waterfall_26026.settings') application = get_wsgi_application()

team@crowdbotics.com

ae7a1e257d3423cfd604b1e6c27ffe19ee1012f5

6b3e8b4291c67195ad51e356ba46602a15d5fe38

/rastervision2/examples/utils.py

d521e74560b2de4494f0d0ff4344208ee3e221b0

permissive

csaybar/raster-vision

4f5bb1125d4fb3ae5c455db603d8fb749221dd74

617ca15f64e3b8a391432306a743f7d0dfff352f

refs/heads/master

NOASSERTION

UTF-8

Python

py

import csv from io import StringIO import tempfile import os import rasterio from shapely.strtree import STRtree from shapely.geometry import shape, mapping import shapely from rastervision.core import Box from rastervision.data import RasterioCRSTransformer, GeoJSONVectorSource from rastervision.utils.files import (file_to_str, file_exists, get_local_path, upload_or_copy, make_dir, json_to_file) from rastervision.filesystem import S3FileSystem def str_to_bool(x): if type(x) == str: if x.lower() == 'true': return True elif x.lower() == 'false': return False else: raise ValueError('{} is expected to be true or false'.format(x)) return x def get_scene_info(csv_uri): csv_str = file_to_str(csv_uri) reader = csv.reader(StringIO(csv_str), delimiter=',') return list(reader) def crop_image(image_uri, window, crop_uri): im_dataset = rasterio.open(image_uri) rasterio_window = window.rasterio_format() im = im_dataset.read(window=rasterio_window) with tempfile.TemporaryDirectory() as tmp_dir: crop_path = get_local_path(crop_uri, tmp_dir) make_dir(crop_path, use_dirname=True) meta = im_dataset.meta meta['width'], meta['height'] = window.get_width(), window.get_height() meta['transform'] = rasterio.windows.transform( rasterio_window, im_dataset.transform) with rasterio.open(crop_path, 'w', **meta) as dst: dst.colorinterp = im_dataset.colorinterp dst.write(im) upload_or_copy(crop_path, crop_uri) def save_image_crop(image_uri, image_crop_uri, label_uri=None, label_crop_uri=None, size=600, min_features=10, vector_labels=True): """Save a crop of an image to use for testing. If label_uri is set, the crop needs to cover >= min_features. Args: image_uri: URI of original image image_crop_uri: URI of cropped image to save label_uri: optional URI of label file label_crop_uri: optional URI of cropped labels to save size: height and width of crop Raises: ValueError if cannot find a crop satisfying min_features constraint. """ if not file_exists(image_crop_uri): print('Saving test crop to {}...'.format(image_crop_uri)) old_environ = os.environ.copy() try: request_payer = S3FileSystem.get_request_payer() if request_payer == 'requester': os.environ['AWS_REQUEST_PAYER'] = request_payer im_dataset = rasterio.open(image_uri) h, w = im_dataset.height, im_dataset.width extent = Box(0, 0, h, w) windows = extent.get_windows(size, size) if label_uri and vector_labels: crs_transformer = RasterioCRSTransformer.from_dataset( im_dataset) vs = GeoJSONVectorSource(label_uri, crs_transformer) geojson = vs.get_geojson() geoms = [] for f in geojson['features']: g = shape(f['geometry']) geoms.append(g) tree = STRtree(geoms) def p2m(x, y, z=None): return crs_transformer.pixel_to_map((x, y)) for w in windows: use_window = True if label_uri and vector_labels: w_polys = tree.query(w.to_shapely()) use_window = len(w_polys) >= min_features if use_window and label_crop_uri is not None: print('Saving test crop labels to {}...'.format( label_crop_uri)) label_crop_features = [ mapping(shapely.ops.transform(p2m, wp)) for wp in w_polys ] label_crop_json = { 'type': 'FeatureCollection', 'features': [{ 'geometry': f } for f in label_crop_features] } json_to_file(label_crop_json, label_crop_uri) if use_window: crop_image(image_uri, w, image_crop_uri) if not vector_labels and label_uri and label_crop_uri: crop_image(label_uri, w, label_crop_uri) break if not use_window: raise ValueError('Could not find a good crop.') finally: os.environ.clear() os.environ.update(old_environ)

lewfish@gmail.com

811fd686f5129b674ddd6d46c77719477b3fb263

b2eb8af13e5532fc5c613bbd68af97fa5938b758

/beginner level/count digits.py

084171349b4c07bb3c473b3a1c85a5dcdc51e228

no_license

rahasudha2910/python-programming

81964ffd61c6a814e22543a9315b05eca028fd59

f3cfbb9a3d368cd17fbd59c6ce4affa83fe36585

refs/heads/master

UTF-8

Python

py

count=0 number=int(input()) while(number>0): number=number/10 count=count+1 print("numer of digits:",count)

noreply@github.com

c2835b1f8a3632284eca779d2dc1f17bfaf30295

6d501ea43b1a52bf4af44ae5677eba8b928ffec3

/directory/signals.py

e1d22e0a309d7321f2db634715374ef5fabc6e4f

no_license

mozilla/hive-django

78d5e7bf687e2311a41d2b6d555b9671c4270b4d

bf95dce0af0148ecacde2256d235788fd79c7d5e

refs/heads/master

Python

UTF-8

Python

py

from django.dispatch import receiver from django.contrib.sites.models import Site from django.db.models.signals import post_save from django.contrib.auth.signals import user_logged_in from django.contrib import messages from registration.signals import user_activated from .models import City, User, Organization, Membership, is_user_vouched_for @receiver(post_save, sender=City) def clear_site_cache_when_city_changes(**kwargs): # It's possible that the site may be associated with a different # city now, so clear the site cache. Site.objects.clear_cache() @receiver(post_save, sender=User) def create_membership_for_user(sender, raw, instance, **kwargs): if raw: return if not len(Membership.objects.filter(user=instance)): membership = Membership(user=instance) membership.save() @receiver(user_activated) def auto_register_user_with_organization(sender, user, request, **kwargs): if user.membership.organization: return orgs = Organization.objects.possible_affiliations_for(user) if orgs.count() != 1: return org = orgs[0] user.membership.organization = org user.membership.save() @receiver(user_logged_in) def tell_user_to_update_their_profile(sender, user, request, **kwargs): if not is_user_vouched_for(user): return if not user.membership.bio: messages.info(request, 'You don\'t have a bio! You should write one ' 'so community members can learn more about you. ' 'Just visit your user profile by accessing the ' 'user menu at the top-right corner of this page.', fail_silently=True)

varmaa@gmail.com

f264cbe12ec190255d0fe7fb1219395eaff22bc8

743c3b0cd875fe294fc15b96de678c93ecd8ab27

/foruser/myuser/urls.py

838fc3a9e5c5fdfd03f5f634b2ec6fe3d8967638

no_license

yudian03/LOGIN

f3cc760ee25a34ce7b939de5475fc7f7097b59a3

3db6278bc15be6244187d9744f3bdf562c7d409f

refs/heads/master

UTF-8

Python

py

from django.urls import path from . import views urlpatterns = [ path('register/',views.register), path('login/',views.login), path('home/',views.home), path('logout/',views.logout) ]

noreply@github.com

a955aa2adcf7d72b65e3af9165bf022c5a057ec0

9d29b302cca89a4ad816f99f1d3c708862dd4c0b

/client.py

73c58c8f77fdac730b4bde122ffd76801a4ac751

no_license

Manoj-M-97/Flight-Booking-System

a28c57c770ea06cc4c8704dbddc2740ec3d86fcd

649d74c63d73a24a3fd97406008903f806ffa34b

refs/heads/master

UTF-8

Python

py

# Python program to implement client side of chat room. import socket import select import sys server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if len(sys.argv) != 3: print "Correct usage: script, IP address, port number" exit() IP_address = str(sys.argv[1]) Port = int(sys.argv[2]) server.connect((IP_address, Port)) cl="CLOSE" while True: # maintains a list of possible input streams sockets_list = [sys.stdin, server] """ There are two possible input situations. Either the user wants to give manual input to send to other people, or the server is sending a message to be printed on the screen. Select returns from sockets_list, the stream that is reader for input. So for example, if the server wants to send a message, then the if condition will hold true below.If the user wants to send a message, the else condition will evaluate as true""" read_sockets,write_socket, error_socket = select.select(sockets_list,[],[]) for socks in read_sockets: if socks == server: message = socks.recv(2048) if (message.endswith(cl)): print "Connection Terminated" exit() print message else: message = sys.stdin.readline() server.send(message) sys.stdout.flush() server.close()

noreply@github.com

c3b2ccf3279e3d6c131b50d1a8a089fc8ee00b32

5a52ccea88f90dd4f1acc2819997fce0dd5ffb7d

/alipay/aop/api/domain/BizListDataInfo.py

5f874dfae528b4b6592ad1306c025ec59eb0239e

permissive

alipay/alipay-sdk-python-all

8bd20882852ffeb70a6e929038bf88ff1d1eff1c

1fad300587c9e7e099747305ba9077d4cd7afde9

refs/heads/master

Apache-2.0

Python

UTF-8

Python

py

#!/usr/bin/env python # -*- coding: utf-8 -*- import json from alipay.aop.api.constant.ParamConstants import * class BizListDataInfo(object): def __init__(self): self._code = None self._name = None @property def code(self): return self._code @code.setter def code(self, value): self._code = value @property def name(self): return self._name @name.setter def name(self, value): self._name = value def to_alipay_dict(self): params = dict() if self.code: if hasattr(self.code, 'to_alipay_dict'): params['code'] = self.code.to_alipay_dict() else: params['code'] = self.code if self.name: if hasattr(self.name, 'to_alipay_dict'): params['name'] = self.name.to_alipay_dict() else: params['name'] = self.name return params @staticmethod def from_alipay_dict(d): if not d: return None o = BizListDataInfo() if 'code' in d: o.code = d['code'] if 'name' in d: o.name = d['name'] return o

liuqun.lq@alibaba-inc.com

bd171b67cb9363e6bad907a04d5ab5e0bc909104

c16d80fa4837ca849056dc1e66191825037969ed

/gptneo_piqa.py

d804ccdcc15115883cf1b8dceb7408a4520b8371

no_license

vivekvkashyap/gpt2-commonsens

c289819e440b52dfb7390c614494cd85437cd1c3

f5d884bcf27c2bd2cb3cf8fa55f6151d12e17b9d

refs/heads/main

UTF-8

Python

py

import jax print(jax.local_device_count()) import jax.numpy as jnp import flax import flax.linen as nn from flax.training.common_utils import get_metrics,onehot,shard,shard_prng_key from flax.training import train_state from flax.metrics.tensorboard import SummaryWriter from flax.training import checkpoints from datasets import load_dataset,load_metric from transformers import GPT2Tokenizer from tqdm import tqdm import logging import optax import math from pathlib import Path from typing import Callable from itertools import chain from flax.metrics import tensorboard from datasets import load_dataset,load_metric from transformers import GPTNeoConfig,GPT2Tokenizer from model_file import FlaxGPTNeoForMultipleChoice logger = logging.getLogger() logger.setLevel(logging.INFO) tokenizer=GPT2Tokenizer.from_pretrained('EleutherAI/gpt-neo-1.3B',pad_token='<|endoftext|>') dataset=load_dataset('piqa') num_choices=2 def preprocess(example): example['first_sentence']=[example['goal']]*num_choices example['second_sentence']=[example[f'sol{i}'] for i in [1,2]] return example train_dataset=dataset['train'].map(preprocess) validation_dataset=dataset['validation'].map(preprocess) test_dataset=dataset['test'].map(preprocess) len_train_dataset=16113 len_validation_dataset=1838 len_test_dataset=3084 train_dataset=train_dataset.select(range(len_train_dataset)) test_dataset=test_dataset.select(range(len_test_dataset)) validation_dataset=validation_dataset.select(range(len_validation_dataset)) remove_col=train_dataset.column_names def tokenize(examples): tokenized_examples=tokenizer(examples['first_sentence'],examples['second_sentence'],padding='max_length',truncation=True,max_length=256,return_tensors='jax') tokenized_examples['labels']=int(examples['label']) return tokenized_examples train_dataset=train_dataset.map(tokenize) validation_dataset=validation_dataset.map(tokenize) train_dataset=train_dataset.remove_columns(remove_col) validation_dataset=validation_dataset.remove_columns(remove_col) test_dataset=test_dataset.remove_columns(remove_col) per_device_batch_size=4 seed=0 num_train_epochs=3 learning_rate=2e-5 model = FlaxGPTNeoForMultipleChoice.from_pretrained('EleutherAI/gpt-neo-1.3B',input_shape=(1,num_choices,1)) total_batch_size = per_device_batch_size * jax.local_device_count() print('The overall batch size (both for training and eval) is', total_batch_size) num_train_steps = len(train_dataset) // total_batch_size * num_train_epochs num_validation_steps=len(validation_dataset)//total_batch_size*num_train_epochs learning_rate_function = optax.linear_schedule(init_value=learning_rate, end_value=0, transition_steps=num_train_steps) class TrainState(train_state.TrainState): logits_function:Callable=flax.struct.field(pytree_node=False) loss_function:Callable=flax.struct.field(pytree_node=False) def adamw(weight_decay): return optax.adafactor(learning_rate=learning_rate_function) decay_path=lambda p:not any(x in p for x in ['bias','LayerNorm.weight']) def traverse(function): def mask(data): flat=flax.traverse_util.flatten_dict(data) return flax.traverse_util.unflatten_dict({k:function(k,v) for k,v in flat.items()}) return mask gradient_transformation=optax.chain( optax.masked(adamw(0.0),mask=traverse(lambda path,_:decay_path(path))), optax.masked(adamw(0.01),mask=traverse(lambda path,_:not decay_path(path)))) def loss_function(logits,labels): logits=flax.linen.log_softmax(logits) xentropy=optax.softmax_cross_entropy(logits,onehot(labels,num_classes=num_choices)) return jnp.mean(xentropy) def eval_function(logits): return logits.argmax(-1) state=TrainState.create(apply_fn=model.__call__, params=model.params, tx=gradient_transformation, logits_function=eval_function, loss_function=loss_function) def train_step(state,batch,dropout_rng): targets=batch.pop("labels") dropout_rng,new_dropout_rng=jax.random.split(dropout_rng) def loss_function(params): logits=state.apply_fn(**batch,params=params,dropout_rng=dropout_rng,train=True)[0] loss=state.loss_function(logits,targets) return loss grad_function=jax.value_and_grad(loss_function) loss,grad=grad_function(state.params) grad=jax.lax.pmean(grad,"batch") new_state=state.apply_gradients(grads=grad) #Added. logits=new_state.apply_fn(**batch,params=new_state.params,dropout_rng=dropout_rng,train=True)[0] accuracy=jnp.equal(jnp.argmax(logits,axis=-1),targets) metrics=jax.lax.pmean({"loss":loss,"learning_rate":learning_rate_function(state.step),'accuracy':accuracy},axis_name="batch") return new_state,metrics,new_dropout_rng parallel_train_step = jax.pmap(train_step, axis_name="batch", donate_argnums=(0,)) def eval_step(state, batch): targets=batch.pop('labels') logits = state.apply_fn(**batch, params=state.params, train=False) loss=state.loss_function(logits,targets) predictions=state.logits_function(logits) eval_accuracy=jnp.equal(predictions,targets) #eval_acc=jnp.equal(predictions,targets) metrics=jax.lax.pmean({"loss":loss,'accuracy':eval_accuracy},axis_name="batch") #return state.logits_function(logits) #(8,4) return targets,predictions,metrics parallel_eval_step = jax.pmap(eval_step, axis_name="batch") def glue_train_data_loader(rng,dataset,batch_size): steps_per_epoch=len_train_dataset//batch_size perms=jax.random.permutation(rng,len_train_dataset) perms=perms[:steps_per_epoch*batch_size] perms=perms.reshape((steps_per_epoch,batch_size)) for perm in perms: batch=dataset[perm] #print(jnp.array(batch['label'])) batch={k:jnp.array(v) for k,v in batch.items()} batch=shard(batch) yield batch rng=jax.random.PRNGKey(seed) dropout_rngs=jax.random.split(rng,jax.local_device_count()) def glue_eval_data_loader(dataset, batch_size): for i in range(len_validation_dataset // batch_size): batch = dataset[i * batch_size : (i + 1) * batch_size] batch = {k: jnp.array(v) for k, v in batch.items()} batch = shard(batch) yield batch state = flax.jax_utils.replicate(state) actual_task = "mnli" metric = load_metric('glue', "mnli") actual_taskmetric = load_metric('glue', actual_task) workdir='./piqa_tensorboard' summary_writer = tensorboard.SummaryWriter(workdir) logger.info(f"***** Running training *****") logger.info(f" Num examples = {len_train_dataset}") logger.info(f" Num Epochs = {num_train_epochs}") logger.info(f" Instantaneous batch size per device = {per_device_batch_size}") logger.info(f" Total train batch size = {total_batch_size}") logger.info(f" Total optimization steps = {num_train_steps}") for i, epoch in enumerate(tqdm(range(1, num_train_epochs+1), desc=f"Epoch ...", position=0, leave=True)): rng, input_rng = jax.random.split(rng) train_acc_metrics=[] train_loss_metrics=[] eval_acc_metrics=[] eval_loss_metrics=[] # train with tqdm(total=len_train_dataset // total_batch_size, desc="Training...", leave=False) as progress_bar_train: for idx,batch in enumerate(glue_train_data_loader(input_rng, train_dataset, total_batch_size)): state, train_metric, dropout_rngs = parallel_train_step(state, batch, dropout_rngs) train_acc_metrics.append(jax.device_get(train_metric['accuracy']).mean().item()) train_loss_metrics.append(flax.jax_utils.unreplicate(train_metric)['loss'].item()) if idx%5==0: summary_writer.scalar('train_loss',flax.jax_utils.unreplicate(train_metric)['loss'].item(),idx) summary_writer.scalar('train_accuracy', jax.device_get(train_metric['accuracy']).mean().item(),idx) if idx%20==0: logger.info(f"train_step_loss{idx}: {flax.jax_utils.unreplicate(train_metric)['loss'].item()} train_step_acc{idx}: {jax.device_get(train_metric['accuracy']).mean().item()} ") progress_bar_train.update(1) # evaluate with tqdm(total=len_validation_dataset // total_batch_size, desc="Evaluating...", leave=False) as progress_bar_eval: for idx,batch in enumerate(glue_eval_data_loader(validation_dataset, total_batch_size)): labels,predictions,eval_metric=parallel_eval_step(state, batch) eval_acc_metrics.append(jax.device_get(eval_metric['accuracy']).mean().item()) eval_loss_metrics.append(flax.jax_utils.unreplicate(eval_metric)['loss'].item()) progress_bar_eval.update(1) if idx%5==0: logger.info(f"eval_step_loss {idx} : {flax.jax_utils.unreplicate(eval_metric)['loss'].item()} eval_step_acc {idx} : {jax.device_get(eval_metric['accuracy']).mean().item()}") summary_writer.scalar('eval_loss : ', flax.jax_utils.unreplicate(eval_metric)['loss'].item(),idx) summary_writer.scalar('eval_accuracy : ', jax.device_get(eval_metric['accuracy']).mean().item(),idx) logger.info(f"---------------------Epoch {epoch} done-----------------") logger.info(f"Train loss: {jax.device_get(jnp.array(train_loss_metrics)).mean().item()} Train accuracy: {jax.device_get(jnp.array(train_acc_metrics)).mean().item()}") logger.info(f"Eval loss: {jax.device_get(jnp.array(eval_loss_metrics)).mean().item()} Eval accuracy: {jax.device_get(jnp.array(eval_acc_metrics)).mean().item()}") if jax.process_index() == 0: params = jax.device_get(jax.tree_map(lambda x: x[0], state.params)) model.save_pretrained( './', params=params, push_to_hub=True, commit_message=f"Piqa:Saving weights of epoch {epoch} at step {idx}",) summary_writer.flush()

noreply@github.com

4716976f68bf061fef859306dd4192440aa5d090

94312b972c9ea96404535d26a297c72e75f84d22

/Weather_WebCrawl.py

350443ebd66136fe19578ad51278528825577cdc

no_license

1LuvCode/My_Slut_TJ

2e8092d78857497a45a22d4af2270dc4c51cdada

d7f39542cccb51b46d4d53d6489ef3b82079bc4d

refs/heads/main

UTF-8

Python

py

import requests from bs4 import BeautifulSoup def Crawling_Weather(Finallocation): url = 'https://search.naver.com/search.naver?where=nexearch&sm=top_hty&fbm=1&ie=utf8&query=' + Finallocation hdr = {'User-Agent': ( 'mozilla/5.0 (windows nt 10.0; win64; x64) applewebkit/537.36 (khtml, like gecko) chrome/78.0.3904.70 safari/537.36')} req = requests.get(url, headers=hdr) html = req.text soup = BeautifulSoup(html, 'html.parser') LocationInfo = "" NowTemp = "" CheckDust = [] # 오류 체크 ErrorCheck = soup.find('span', {'class': 'btn_select'}) if 'None' in str(ErrorCheck): print("Error! 지역 검색 오류!") return None else: # 지역 정보 for i in soup.select('span[class=btn_select]'): LocationInfo = i.text # 현재 온도 NowTemp = soup.find('span', {'class': 'todaytemp'}).text + soup.find('span', {'class': 'tempmark'}).text[2:] # 날씨 캐스트 WeatherCast = soup.find('p', {'class': 'cast_txt'}).text # 오늘 오전온도, 오후온도, 체감온도 TodayMorningTemp = soup.find('span', {'class': 'min'}).text TodayAfternoonTemp = soup.find('span', {'class': 'max'}).text TodayFeelTemp = soup.find('span', {'class': 'sensible'}).text[5:] # 자외선 지수 TodayUV = soup.find('span', {'class': 'indicator'}).text[4:-2] + " " + soup.find('span', {'class': 'indicator'}).text[-2:] # 미세먼지, 초미세먼지, 오존 지수 CheckDust1 = soup.find('div', {'class': 'sub_info'}) CheckDust2 = CheckDust1.find('div', {'class': 'detail_box'}) for i in CheckDust2.select('dd'): CheckDust.append(i.text) FineDust = CheckDust[0][:-2] + " " + CheckDust[0][-2:] UltraFineDust = CheckDust[1][:-2] + " " + CheckDust[1][-2:] Ozon = CheckDust[2][:-2] + " " + CheckDust[2][-2:] # 내일 오전, 오후 온도 및 상태 체크 tomorrowArea = soup.find('div', {'class': 'tomorrow_area'}) tomorrowCheck = tomorrowArea.find_all('div', {'class': 'main_info morning_box'}) # 내일 오전온도 tomorrowMoring1 = tomorrowCheck[0].find('span', {'class': 'todaytemp'}).text tomorrowMoring2 = tomorrowCheck[0].find('span', {'class': 'tempmark'}).text[2:] tomorrowMoring = tomorrowMoring1 + tomorrowMoring2 # 내일 오전상태 tomorrowMState1 = tomorrowCheck[0].find('div', {'class': 'info_data'}) tomorrowMState2 = tomorrowMState1.find('ul', {'class': 'info_list'}) tomorrowMState3 = tomorrowMState2.find('p', {'class': 'cast_txt'}).text tomorrowMState4 = tomorrowMState2.find('div', {'class': 'detail_box'}) tomorrowMState5 = tomorrowMState4.find('span').text.strip() tomorrowMState = tomorrowMState3 + " " + tomorrowMState5 # 내일 오후온도 tomorrowAfter1 = tomorrowCheck[1].find('p', {'class': 'info_temperature'}) tomorrowAfter2 = tomorrowAfter1.find('span', {'class': 'todaytemp'}).text tomorrowAfter3 = tomorrowAfter1.find('span', {'class': 'tempmark'}).text[2:] tomorrowAfter = tomorrowAfter2 + tomorrowAfter3 # 내일 오후상태 tomorrowAState1 = tomorrowCheck[1].find('div', {'class': 'info_data'}) tomorrowAState2 = tomorrowAState1.find('ul', {'class': 'info_list'}) tomorrowAState3 = tomorrowAState2.find('p', {'class': 'cast_txt'}).text tomorrowAState4 = tomorrowAState2.find('div', {'class': 'detail_box'}) tomorrowAState5 = tomorrowAState4.find('span').text.strip() tomorrowAState = tomorrowAState3 + " " + tomorrowAState5 Weather_info_dict = { '지역':LocationInfo, '현재온도':NowTemp, '체감온도':TodayFeelTemp, '오전온도':TodayMorningTemp, '오후온도':TodayAfternoonTemp, '현재상태':WeatherCast, '현재자외선지수':TodayUV, '현재미세먼지농도':FineDust, '현재초미세먼지농도':UltraFineDust, '현재오존지수':Ozon, '내일오전온도':tomorrowMoring, '내일오전상태':tomorrowMState, '내일오후온도':tomorrowAfter, '내일오후상태':tomorrowAState } return Weather_info_dict # print("=========================================") # print(LocationInfo + " 날씨 정보입니다.") # print("=========================================") # print("현재온도: " + NowTemp) # print("체감온도: " + TodayFeelTemp) # print("오전/오후 온도: " + TodayMorningTemp + "/" + TodayAfternoonTemp) # print("현재 상태: " + WeatherCast) # print("현재 자외선 지수: " + TodayUV) # print("현재 미세먼지 농도: " + FineDust) # print("현재 초미세먼지 농도: " + UltraFineDust) # print("현재 오존 지수: " + Ozon) # print("=========================================") # print(LocationInfo + " 내일 날씨 정보입니다.") # print("=========================================") # print("내일 오전 온도: " + tomorrowMoring) # print("내일 오전 상태: " + tomorrowMState) # print("내일 오후 온도: " + tomorrowAfter) # print("내일 오후 상태: " + tomorrowAState)

noreply@github.com

707062ffa62600fed5892717cfc5efb6677b3277

9743d5fd24822f79c156ad112229e25adb9ed6f6

/xai/brain/wordbase/nouns/_plough.py

8524ffbb0f26cf406e78e16dbed5ed7ccee77fc1

permissive

cash2one/xai

de7adad1758f50dd6786bf0111e71a903f039b64

e76f12c9f4dcf3ac1c7c08b0cc8844c0b0a104b6

refs/heads/master

UTF-8

Python

py

#calss header class _PLOUGH(): def __init__(self,): self.name = "PLOUGH" self.definitions = [u'a large farming tool with blades that digs the soil in fields so that seeds can be planted', u'If land is under the plough, crops are grown on it: '] self.parents = [] self.childen = [] self.properties = [] self.jsondata = {} self.specie = 'nouns' def run(self, obj1 = [], obj2 = []): return self.jsondata

xingwang1991@gmail.com

8aa66e9bfbe8bd636da164d691be14c9753a0cf6

2e318c8fdbb8e8826937ffbf1eede7034a47960a

/GazeGAN_using_CSC/train_old1.py

3a4c6f4bdfa7d3250a264ab2b5f775c39e7fdeb4

no_license

chenkeshuai/Sal-CFS-GAN

e06efbe5e49360c8f5634704c487483795c10d31

8ae0fb77efff503190bcc8b6333c1d21ea1bfbce

refs/heads/master

UTF-8

Python

py

### Copyright (C) 2017 NVIDIA Corporation. All rights reserved. ### Licensed under the CC BY-NC-SA 4.0 license (https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode). import time from collections import OrderedDict from options.train_options import TrainOptions from data.data_loader import CreateDataLoader from models.models import create_model import util.util as util from util.visualizer import Visualizer import os import numpy as np import torch from torch.autograd import Variable opt = TrainOptions().parse() iter_path = os.path.join(opt.checkpoints_dir, opt.name, 'iter.txt') if opt.continue_train: try: start_epoch, epoch_iter = np.loadtxt(iter_path , delimiter=',', dtype=int) except: start_epoch, epoch_iter = 1, 0 print('Resuming from epoch %d at iteration %d' % (start_epoch, epoch_iter)) else: start_epoch, epoch_iter = 1, 0 if opt.debug: opt.display_freq = 1 opt.print_freq = 1 opt.niter = 1 opt.niter_decay = 0 opt.max_dataset_size = 10 data_loader = CreateDataLoader(opt) dataset = data_loader.load_data() dataset_size = len(data_loader) print('#training images = %d' % dataset_size) model = create_model(opt) visualizer = Visualizer(opt) total_steps = (start_epoch-1) * dataset_size + epoch_iter display_delta = total_steps % opt.display_freq print_delta = total_steps % opt.print_freq save_delta = total_steps % opt.save_latest_freq My_Limit = 600 # just for debugging phase, to control the total training steps for saving time for epoch in range(start_epoch, opt.niter + opt.niter_decay + 1): epoch_start_time = time.time() if epoch != start_epoch: epoch_iter = epoch_iter % dataset_size for i, data in enumerate(dataset, start=epoch_iter): if(i > My_Limit): break iter_start_time = time.time() total_steps += opt.batchSize epoch_iter += opt.batchSize # whether to collect output images save_fake = total_steps % opt.display_freq == display_delta ############## Forward Pass ###################### losses, generated = model(Variable(data['label']), Variable(data['inst']), Variable(data['image']), Variable(data['feat']), infer=save_fake) # sum per device losses losses = [ torch.mean(x) if not isinstance(x, int) else x for x in losses ] loss_dict = dict(zip(model.module.loss_names, losses)) print("loss dict is :", loss_dict) # calculate final loss scalar # loss_D = (loss_dict['D_fake'] + loss_dict['D_real']) * 0.5 # loss_G = loss_dict['G_GAN'] + loss_dict.get('G_GAN_Feat',0) + loss_dict.get('G_VGG',0) loss_D = (loss_dict['D_fake'] + loss_dict['D_real']) * 0.5 loss_G = loss_dict['G_GAN'] + loss_dict.get('G_GAN_Feat',0) + loss_dict.get('G_VGG',0) + loss_dict.get('Loss_CC',0) print("CC loss is :", loss_dict.get('Loss_CC',0)) ############### Backward Pass #################### # update generator weights model.module.optimizer_G.zero_grad() loss_G.backward() model.module.optimizer_G.step() # update discriminator weights model.module.optimizer_D.zero_grad() loss_D.backward() model.module.optimizer_D.step() #call(["nvidia-smi", "--format=csv", "--query-gpu=memory.used,memory.free"]) ############## Display results and errors ########## ### print out errors if total_steps % opt.print_freq == print_delta: errors = {k: v.data[0] if not isinstance(v, int) else v for k, v in loss_dict.items()} t = (time.time() - iter_start_time) / opt.batchSize visualizer.print_current_errors(epoch, epoch_iter, errors, t) visualizer.plot_current_errors(errors, total_steps) ### display output images if save_fake: visuals = OrderedDict([('input_label', util.tensor2label(data['label'][0], opt.label_nc)), ('synthesized_image', util.tensor2im(generated.data[0])), ('real_image', util.tensor2im(data['image'][0]))]) visualizer.display_current_results(visuals, epoch, total_steps) ### save latest model if total_steps % opt.save_latest_freq == save_delta: print('saving the latest model (epoch %d, total_steps %d)' % (epoch, total_steps)) model.module.save('latest') np.savetxt(iter_path, (epoch, epoch_iter), delimiter=',', fmt='%d') if epoch_iter >= dataset_size: break # end of epoch iter_end_time = time.time() print('End of epoch %d / %d \t Time Taken: %d sec' % (epoch, opt.niter + opt.niter_decay, time.time() - epoch_start_time)) ''' ### save model for this epoch if epoch % opt.save_epoch_freq == 0: print('saving the model at the end of epoch %d, iters %d' % (epoch, total_steps)) model.module.save('latest') model.module.save(epoch) np.savetxt(iter_path, (epoch+1, 0), delimiter=',', fmt='%d') ''' ### instead of only training the local enhancer, train the entire network after certain iterations if (opt.niter_fix_global != 0) and (epoch == opt.niter_fix_global): model.module.update_fixed_params() ### linearly decay learning rate after certain iterations if epoch > opt.niter: model.module.update_learning_rate()

noreply@github.com

effa795ba011f8dc2f6b6da9ac6642b41478c955

ac2567d2be46412f10a47aba6b062347fb831ec9

/twitterTest.py

d48b78dc469f066c5c8a5c8ce76e0454cb493cd7

no_license

rhymg/TwitterScraping

e9e8d4098ba4d28cdb0d17f76de98a81c08432aa

769effdbdf83a170c13d2cac51ca5df7956e2dab

refs/heads/master

UTF-8

Python

py

import GetOldTweets3 as got; word = 'fuck'; f = open("usernameTest.txt", "a"); tweetCriteria = got.manager.TweetCriteria().setQuerySearch(word).setMaxTweets(10); tweets = got.manager.TweetManager.getTweets(tweetCriteria); for tweet in tweets: print(tweet.text + ' BY: ' + tweet.username + '\n'); if word in tweet.text.lower(): print('This has ' + word + ' in it.\n'); f.write(tweet.username + '\n'); else: print('This does not have ' + word + ' in it.\n'); f.close();

noreply@github.com

11e480051d1e2e4b524f910449fa7a03d3d0f592

b3db0cb0849fc3c981077cc5dc071c6eac6fd1ed

/C.1.14.py

f9372e61feee0ec164fad2d51aa25739dd93f3b8

no_license

Andi-Abdi/Tugas-Struktur-Data

bcfcfd3cf4ac28ce966b30d07041d775b33db778

49162ad9c5869161df01bc1a0f8697c2d7d1623a

refs/heads/main

UTF-8

Python

py

def odd_product_pair(data): data = set(data) for y in data: for x in data: if y == x : continue if y*x % 2 == 1: return True return False print(odd_product_pair([5,7,9,14,16]))

noreply@github.com

275aa3e362920aae1e2af84fe0380f36fa448f39

55c250525bd7198ac905b1f2f86d16a44f73e03a

/Python/pygame/pygameweb/pygameweb/db.py

57c70ca70133b811d4447037d0df7cd54b72e632

permissive

NateWeiler/Resources

213d18ba86f7cc9d845741b8571b9e2c2c6be916

bd4a8a82a3e83a381c97d19e5df42cbababfc66c

refs/heads/master

UTF-8

Python

py

version https://git-lfs.github.com/spec/v1 oid sha256:95c026dc0e7051336cd999158979e81f159d4470489660469d0e0175c66400da size 1274

nateweiler84@gmail.com

ec81f69f8b35b27ca38c0fabe125ba6ef4bc3a1d

1975ee674b36084366b1bbe2c091d8f0f8795dc0

/demo/class_views.py

49ac0086b684256a0215318d23d4992296ad6f5e

no_license

srikanthpragada/PYTHON_03_JULY_2018_WEBDEMO

f193213788deadcab7ac7b183328269ba1334488

56e076ad30703117cafc56d6d95449c6ec8eebb2

refs/heads/master

UTF-8

Python

py

from django.views.generic import TemplateView, ListView from django.shortcuts import render from .forms import LoginForm from .models import Course class ClassView1(TemplateView): template_name = 'class_view1.html' class LoginView(TemplateView): template_name = 'login.html' def get(self, request): form = LoginForm() return render(request, self.template_name, {'form': form}) def post(self, request): form = LoginForm(request.POST) if form.is_valid(): print(form.cleaned_data['username'], form.cleaned_data['password']) return render(request, self.template_name, {'form': form}) # Generic View - ListView demo class ListCourseView(ListView): model = Course template_name = "courses.html" # default is demo/course_list.html context_object_name = 'courses' # default is object_list

srikanthpragada@gmail.com

946eaac05979a4f663b7fefeba08d4f1dd8efb16

d21c924fc23b812aaedeb2cfa3dfb108535a507f

/tw2/jqplugins/fg/defaults.py

310f64fb53f192fa733e55b3ba04ea7270501562

no_license

toscawidgets/tw2.jqplugins.fg

eba3a90949c59dd7c6b3740ab09faa9b5d824a6d

8317f3bec82364b95e86aa3655c7f787b25d715f

refs/heads/master

UTF-8

Python

py

#jQuery.ui _fg_dirname_ = 'jquery/fg/%(subdir)s'

ralph.bean@gmail.com

79848a0117879783d1f2f0c37b6a8586c18147c6

85a9ffeccb64f6159adbd164ff98edf4ac315e33

/pysnmp/IPV6-TCP-MIB.py

ae7c821868888b0850cd5394fcb2bb61fbdbaeb3

permissive

agustinhenze/mibs.snmplabs.com

5d7d5d4da84424c5f5a1ed2752f5043ae00019fb

1fc5c07860542b89212f4c8ab807057d9a9206c7

refs/heads/master

Apache-2.0

UTF-8

Python

py

# # PySNMP MIB module IPV6-TCP-MIB (http://snmplabs.com/pysmi) # ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/IPV6-TCP-MIB # Produced by pysmi-0.3.4 at Mon Apr 29 19:45:44 2019 # On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4 # Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15) # ObjectIdentifier, OctetString, Integer = mibBuilder.importSymbols("ASN1", "ObjectIdentifier", "OctetString", "Integer") NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues") ConstraintsIntersection, SingleValueConstraint, ConstraintsUnion, ValueRangeConstraint, ValueSizeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "ConstraintsIntersection", "SingleValueConstraint", "ConstraintsUnion", "ValueRangeConstraint", "ValueSizeConstraint") Ipv6Address, Ipv6IfIndexOrZero = mibBuilder.importSymbols("IPV6-TC", "Ipv6Address", "Ipv6IfIndexOrZero") ModuleCompliance, ObjectGroup, NotificationGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "ObjectGroup", "NotificationGroup") MibScalar, MibTable, MibTableRow, MibTableColumn, experimental, ObjectIdentity, Gauge32, Counter64, Counter32, Bits, NotificationType, IpAddress, ModuleIdentity, Integer32, iso, TimeTicks, Unsigned32, mib_2, MibIdentifier = mibBuilder.importSymbols("SNMPv2-SMI", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "experimental", "ObjectIdentity", "Gauge32", "Counter64", "Counter32", "Bits", "NotificationType", "IpAddress", "ModuleIdentity", "Integer32", "iso", "TimeTicks", "Unsigned32", "mib-2", "MibIdentifier") DisplayString, TextualConvention = mibBuilder.importSymbols("SNMPv2-TC", "DisplayString", "TextualConvention") ipv6TcpMIB = ModuleIdentity((1, 3, 6, 1, 3, 86)) ipv6TcpMIB.setRevisions(('2017-02-22 00:00', '1998-01-29 00:00',)) if mibBuilder.loadTexts: ipv6TcpMIB.setLastUpdated('201702220000Z') if mibBuilder.loadTexts: ipv6TcpMIB.setOrganization('IETF IPv6 MIB Working Group') tcp = MibIdentifier((1, 3, 6, 1, 2, 1, 6)) ipv6TcpConnTable = MibTable((1, 3, 6, 1, 2, 1, 6, 16), ) if mibBuilder.loadTexts: ipv6TcpConnTable.setStatus('obsolete') ipv6TcpConnEntry = MibTableRow((1, 3, 6, 1, 2, 1, 6, 16, 1), ).setIndexNames((0, "IPV6-TCP-MIB", "ipv6TcpConnLocalAddress"), (0, "IPV6-TCP-MIB", "ipv6TcpConnLocalPort"), (0, "IPV6-TCP-MIB", "ipv6TcpConnRemAddress"), (0, "IPV6-TCP-MIB", "ipv6TcpConnRemPort"), (0, "IPV6-TCP-MIB", "ipv6TcpConnIfIndex")) if mibBuilder.loadTexts: ipv6TcpConnEntry.setStatus('obsolete') ipv6TcpConnLocalAddress = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 1), Ipv6Address()) if mibBuilder.loadTexts: ipv6TcpConnLocalAddress.setStatus('obsolete') ipv6TcpConnLocalPort = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))) if mibBuilder.loadTexts: ipv6TcpConnLocalPort.setStatus('obsolete') ipv6TcpConnRemAddress = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 3), Ipv6Address()) if mibBuilder.loadTexts: ipv6TcpConnRemAddress.setStatus('obsolete') ipv6TcpConnRemPort = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 4), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))) if mibBuilder.loadTexts: ipv6TcpConnRemPort.setStatus('obsolete') ipv6TcpConnIfIndex = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 5), Ipv6IfIndexOrZero()) if mibBuilder.loadTexts: ipv6TcpConnIfIndex.setStatus('obsolete') ipv6TcpConnState = MibTableColumn((1, 3, 6, 1, 2, 1, 6, 16, 1, 6), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))).clone(namedValues=NamedValues(("closed", 1), ("listen", 2), ("synSent", 3), ("synReceived", 4), ("established", 5), ("finWait1", 6), ("finWait2", 7), ("closeWait", 8), ("lastAck", 9), ("closing", 10), ("timeWait", 11), ("deleteTCB", 12)))).setMaxAccess("readwrite") if mibBuilder.loadTexts: ipv6TcpConnState.setStatus('obsolete') ipv6TcpConformance = MibIdentifier((1, 3, 6, 1, 3, 86, 2)) ipv6TcpCompliances = MibIdentifier((1, 3, 6, 1, 3, 86, 2, 1)) ipv6TcpGroups = MibIdentifier((1, 3, 6, 1, 3, 86, 2, 2)) ipv6TcpCompliance = ModuleCompliance((1, 3, 6, 1, 3, 86, 2, 1, 1)).setObjects(("IPV6-TCP-MIB", "ipv6TcpGroup")) if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0): ipv6TcpCompliance = ipv6TcpCompliance.setStatus('obsolete') ipv6TcpGroup = ObjectGroup((1, 3, 6, 1, 3, 86, 2, 2, 1)).setObjects(("IPV6-TCP-MIB", "ipv6TcpConnState")) if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0): ipv6TcpGroup = ipv6TcpGroup.setStatus('obsolete') mibBuilder.exportSymbols("IPV6-TCP-MIB", ipv6TcpConnTable=ipv6TcpConnTable, ipv6TcpConnEntry=ipv6TcpConnEntry, ipv6TcpMIB=ipv6TcpMIB, ipv6TcpGroups=ipv6TcpGroups, ipv6TcpConnIfIndex=ipv6TcpConnIfIndex, tcp=tcp, ipv6TcpConnRemPort=ipv6TcpConnRemPort, ipv6TcpConformance=ipv6TcpConformance, PYSNMP_MODULE_ID=ipv6TcpMIB, ipv6TcpConnState=ipv6TcpConnState, ipv6TcpConnRemAddress=ipv6TcpConnRemAddress, ipv6TcpConnLocalPort=ipv6TcpConnLocalPort, ipv6TcpCompliances=ipv6TcpCompliances, ipv6TcpConnLocalAddress=ipv6TcpConnLocalAddress, ipv6TcpCompliance=ipv6TcpCompliance, ipv6TcpGroup=ipv6TcpGroup)

dcwangmit01@gmail.com

480127fceb33213f368de855a806d8bd709a0909

2136c75df909b40c2667679b2ba4740d8b50a299

/test.py

86957845b7c17d62c3ce76575f6a1f07d42c824f

no_license

jianglikun/preMLI

19e91935266539afa15cb86a3e62608840c775d1

54b48fba7adf7fb232ac1a2cec883c596d49d3a3

refs/heads/main

UTF-8

Python

py

import os os.environ["CUDA_VISIBLE_DEVICES"]="4" from model import get_model from model import get_model_max from model import get_model_C_mul from model import get_model_C_sub import tensorflow as tf import numpy as np from sklearn.metrics import roc_auc_score,average_precision_score, f1_score from sklearn.metrics import accuracy_score,recall_score def stat(y_label,y_pred): # print('y_label=',y_label) # print('y_pred=',y_pred) threshold = 0.5 auc = roc_auc_score(y_label, y_pred) aupr = average_precision_score(y_label, y_pred) for i in range(len(y_pred)): if y_pred[i][0] >= threshold: y_pred[i][0] = 1 if y_pred[i][0] < threshold: y_pred[i][0] = 0 TP = 0 TN = 0 FP = 0 FN = 0 for i in range(len(y_pred)): if y_pred[i][0] == 0 and y_label[i] == 0: TN = TN + 1 if y_pred[i][0] == 1 and y_label[i] == 1: TP = TP + 1 if y_pred[i][0] == 0 and y_label[i] == 1: FN = FN + 1 if y_pred[i][0] == 1 and y_label[i] == 0: FP = FP + 1 specificity = TN/(TN+FP) recall = recall_score(y_label,y_pred) acc = accuracy_score(y_label,y_pred) f1 = f1_score(y_label, y_pred) acc = round(acc, 4) auc = round(auc,4) aupr = round(aupr, 4) f1 = round(f1,4) return acc,auc,aupr,f1,recall,specificity ########################## datatype = 2021 kmer = 3 ########################## for m in range(100): model=None model=get_model() model.load_weights('./model/3mer2021/Solanum lycopersicumModel%s.h5'%m) if datatype == 2020: names = ['Arabidopsis lyrata','Solanum lycopersicum'] elif datatype == 2021: names = ['aly','mtr','stu','bdi'] for name in names: Data_dir='/home/yxy/Project/002/processData/3mer/' if datatype == 2020: test=np.load(Data_dir+'5mer%s_test.npz'%name) elif datatype == 2021: test=np.load(Data_dir+'%s%stest2021.npz'%(name,kmer)) X_mi_tes,X_lnc_tes,y_tes=test['X_mi_tes'],test['X_lnc_tes'],test['y_tes'] print("****************Testing %s specific model on %s cell line****************"%(m,name)) y_pred = model.predict([X_mi_tes,X_lnc_tes]) auc = roc_auc_score(y_tes, y_pred) aupr = average_precision_score(y_tes, y_pred) f1 = f1_score(y_tes, np.round(y_pred.reshape(-1))) print("AUC : ", auc) print("AUPR : ", aupr) print("f1_score", f1) acc,auc,aupr,f1,recall,specificity = stat(y_tes, y_pred) print("ACC : ", acc,"auc : ", auc,"aupr ：" , aupr,"f1 : ", f1,"recall : ",recall,"specificity : ",specificity)

noreply@github.com

31068cd2c89faea0c9efdff5214f7c0d9abac707

9743d5fd24822f79c156ad112229e25adb9ed6f6

/xai/brain/wordbase/otherforms/_suffered.py

f5ba9fb4722605fcd51182e2e5bcc1348faf8603

permissive

cash2one/xai

de7adad1758f50dd6786bf0111e71a903f039b64

e76f12c9f4dcf3ac1c7c08b0cc8844c0b0a104b6

refs/heads/master

UTF-8

Python

py

#calss header class _SUFFERED(): def __init__(self,): self.name = "SUFFERED" self.definitions = suffer self.parents = [] self.childen = [] self.properties = [] self.jsondata = {} self.basic = ['suffer']

xingwang1991@gmail.com

351ef3112a8105eea8a02b98a6ff6303a19eee43

d2c4934325f5ddd567963e7bd2bdc0673f92bc40

/tests/artificial/transf_Integration/trend_LinearTrend/cycle_30/ar_/test_artificial_128_Integration_LinearTrend_30__100.py

7a5e907e035774475c35332c1022bd9fc95546df

permissive

jmabry/pyaf

797acdd585842474ff4ae1d9db5606877252d9b8

afbc15a851a2445a7824bf255af612dc429265af

refs/heads/master

BSD-3-Clause

Python

UTF-8

Python

py

import pyaf.Bench.TS_datasets as tsds import pyaf.tests.artificial.process_artificial_dataset as art art.process_dataset(N = 128 , FREQ = 'D', seed = 0, trendtype = "LinearTrend", cycle_length = 30, transform = "Integration", sigma = 0.0, exog_count = 100, ar_order = 0);

antoine.carme@laposte.net

42f0deaf250627b10751156d712d786cdc96ee26

6bf1b595a7f4d3cbf0995455869d438a7d0e0624

/lingvo/tasks/milan/score_functions.py

9c4ce867b372dfed657bec15a96096952923b006

permissive

huaxz1986/lingvo

889abc82b1bab6f37ba861c41eb480b7e89362c0

b83984577610423e3b1c6b04ca248cd23f2842f7

refs/heads/master

Apache-2.0

UTF-8

Python

py

# Lint as: python3 # Copyright 2021 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Implementation of combination functions for dual-encoder models.""" from lingvo import compat as tf from lingvo.core import base_layer class DotProductScoreFunction(base_layer.BaseLayer): """Performs dot product combination between two encoded vectors.""" @classmethod def Params(cls): p = super().Params() p.name = 'dot_product_score_function' return p def FProp(self, theta, x, y): """Computes pair-wise dot product similarity. Args: theta: NestedMap of variables belonging to this layer and its children. x: batch of encoded representations from modality x. A float32 Tensor of shape [x_batch_size, encoded_dim] y: batch of encoded representations from modality y. A float32 Tensor of shape [y_batch_size, encoded_dim] Returns: Pairwise dot products. A float32 Tensor with shape `[x_batch_size, y_batch_size]`. """ return tf.matmul(x, y, transpose_b=True)

copybara-worker@google.com

8158442771c431dd35672a9edc586edd0fe33d1d

e23a4f57ce5474d468258e5e63b9e23fb6011188

/125_algorithms/_exercises/templates/_algorithms_challenges/leetcode/leetCode/BreadthFirstSearch/103_BinaryTreeZigzagLevelOrderTraversal.py

4445a0088162de197a6843a1be5b63a07388215c

no_license

syurskyi/Python_Topics

52851ecce000cb751a3b986408efe32f0b4c0835

be331826b490b73f0a176e6abed86ef68ff2dd2b

refs/heads/master

Python

UTF-8

Python

py

#! /usr/bin/env python # -*- coding: utf-8 -*- # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None c.. Solution o.. ___ zigzagLevelOrder root __ n.. root: r_ [] left2right = 1 # 1. scan the level from left to right. -1 reverse. ans, stack, temp # list, [root], [] _____ stack: temp = [node.val ___ node __ stack] stack = [child ___ node __ stack ___ child __ (node.left, node.right) __ child] ans += [temp[::left2right]] # Pythonic way left2right *= -1 r_ ans """ [] [1] [1,2,3] [0,1,2,3,4,5,6,null,null,7,null,8,9,null,10] """

sergejyurskyj@yahoo.com

18418bc2a39d5aeb5d6d8aaa063f549811e5c5cf

9c7f47b2f31ea4ae55e33c706efe524eb62ff177

/HT_11/HT_11_1.py

3fdafbfbc8e4ba14a7b22a1f6076c98a1208a2cc

no_license

Kantarian/GITHUB

05b6d5425b345667a4188ced23da76ed337b910a

fa047cbb2beb9bf372b22596bea8aaef80423872

refs/heads/main

UTF-8

Python

py

#1. Створити клас Calc, який буде мати атребут last_result та 4 методи. Методи повинні виконувати математичні операції з 2-ма числами, а саме додавання, віднімання, # множення, ділення. # - Якщо під час створення екземпляру класу звернутися до атребута last_result він повинен повернути пусте значення # - Якщо використати один з методів - last_result повенен повернути результат виконання попереднього методу. # - Додати документування в клас (можете почитати цю статтю: https://realpython.com/documenting-python-code/ ) class Calc(): def __init__(self,a,b,last_result = None): self.a=a self.b=b self.last_result = last_result def add(self): self.last_result = self.a+self.b return self.last_result def mul(self): self.last_result = self.a*self.b return self.last_result def div(self): self.last_result = self.a/self.b return self.last_result def sub(self): self.last_result = self.a-self.b return self.last_result a=int(input("Enter first number: ")) b=int(input("Enter second number: ")) obj=Calc(a,b) choice=1 while choice!=0: print("0. Exit") print("1. Add") print("2. Subtraction") print("3. Multiplication") print("4. Division") print("5. Last result") choice=int(input("Enter choice: ")) if choice==1: print("Result: ",obj.add()) elif choice==2: print("Result: ",obj.sub()) elif choice==3: print("Result: ",obj.mul()) elif choice==4: print("Result: ",round(obj.div(),2)) elif choice==5: print("Last Result: ",round(obj.last_result)) elif choice==0: print("Exiting!") else: print("Invalid choice!!")

noreply@github.com

da74b5b74654f0fbd6447f906cfa0864252ad0ea

43e788ee824ce1f6611d42690688136e5840af0e

/Video.py

5727fe4166addad073efc4954296de4a11e5ee5a

no_license

Karthik8396/lrn_opencv2

3b9c9d824bee26c5d3c5c8ab54fb12e5a9bf145e

1d475f5b285cca187ff449f0036dcfe3dd5db136

refs/heads/master

UTF-8

Python

py

import cv2 import numpy cap=cv2.VideoCapture(0) #first webcam fourcc =cv2.VideoWriter_fourcc(*'XVID') # for saving the video and fourcc is codec out=cv2.VideoWriter('output.avi',fourcc,20.0,(640,480)) # adding codec and size of video cv2.VideoWriter() while True : ret,frame = cap.read() gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) cv2.imshow('frame',frame) cv2.imshow('gray',gray) out.write(frame) if cv2.waitKey(1) & 0xFF == ord('q'): #waitkey return 32 bit value(32 ones) 0xFF is 11111111(8 bit value),logical and makes it true and if executes break #ord is for getting key value cap.release() out.release() cv2.destroyAllWindows()

noreply@github.com

8031b06595673b677e41319deb604caa3164a455

5ca39c2f45bdef4f93e57b17a357a2565fe1cf02

/contactbook.py

05a5715d3a06a40a21e502278f0cf56788ca7c36

no_license

Ajit1999/ContactBook-API

de6f51d0e1fcf49b5c8b8bfacf4b7750b64b9356

df64583db98eb3421f07177f3c7dbb771c218ac4

refs/heads/main

UTF-8

Python

py

from flask import Flask from flask_pymongo import PyMongo from bson.json_util import dumps from bson.objectid import ObjectId from flask import jsonify, request app = Flask(__name__) app.secret_key = "secretkey" app.config['MONGO_URI'] = "mongodb://localhost:27017/User" mongo = PyMongo(app) @app.route('/add',methods=['POST']) def add_user(): _json = request.json _name = _json['name'] _address = _json['address'] _contactno = _json['contact'] _email = _json['email'] if _name and _address and _contactno and _email and request.method == 'POST': id = mongo.db.user.insert({'name':_name,'address':_address,'contact':_contactno,'email':_email}) resp = jsonify("Contact added sucessfully") resp.status_code = 200 return resp else: return not_found() @app.route('/users') def users(): users = mongo.db.user.find() resp = dumps(users) return resp @app.route('/user/<id>') def user(id): user = mongo.db.user.find_one({'_id':ObjectId(id)}) resp = dumps(user) return resp @app.route('/delete/<id>',methods=['DELETE']) def delete_user(id): delete_user = mongo.db.user.delete_one({'_id': ObjectId(id)}) resp = jsonify("Contact deleted successfully") resp.status_code = 200 return resp @app.route('/update/<id>', methods =['PUT']) def update(id): _id = id _json = request.json _name = _json['name'] _address = _json['address'] _contactno = _json['contact'] _email = _json['email'] if _name and _address and _contactno and _email and _id and request.method == 'PUT': mongo.db.user.update({'_id':ObjectId(_id['$oid']) if '$oid' in _id else ObjectId(_id)}, {'$set': {'name':_name,'address':_address,'contact':_contactno,'email':_email,}}) resp = jsonify("Contact updated Successfully") resp.status_code = 200 return resp else: return not_found() @app.errorhandler(404) def not_found(error=None): message = { 'status': 404, 'message':'Not Found' + request.url } resp = jsonify(message) resp.status_code = 404 return resp if __name__ =="__main__": app.run(debug = True)

noreply@github.com

f031555a692495a482d208cf6100105e71ac4dbc

79b38e6dad187bed26039f77611cc3feb7d75c1a

/issegm1/solve_ST.py

70e0b3b0d45f420e221a8fc3e8d48bb954d43064

no_license

engrjavediqbal/MLSL

aa362c04a47b2bc921331bbb47dd4fe15bdb4bbe

94ac81096fd6ba2c85352807dc93f6a6b6cc472d

refs/heads/master

UTF-8

Python

py

from __future__ import print_function from sklearn.datasets import fetch_mldata import logging import copy from datetime import datetime import argparse import cPickle import os import os.path as osp import re import sys import math import time from functools import partial from PIL import Image from multiprocessing import Pool from sklearn.metrics import log_loss import numpy as np import mxnet as mx import scipy.io from util1 import mxutil from util1 import transformer as ts from util1 import util from util1.lr_scheduler import FixedScheduler, LinearScheduler, PolyScheduler from data1 import FileIter, make_divisible #from data_src import FileIter, make_divisible, parse_split_file def parse_split_file_tgt(dataset_tgt, split_tgt, data_root=''): split_filename = 'issegm1/data_list/{}/{}.lst'.format(dataset_tgt, split_tgt) image_list = [] label_gt_list = [] image_data_list = [] with open(split_filename) as f: for item in f.readlines(): fields = item.strip().split('\t') image_list.append(os.path.join(data_root, fields[0])) image_data_list.append(fields[0]) label_gt_list.append(os.path.join(data_root, fields[1])) return image_list, label_gt_list,image_data_list def parse_model_label(args): assert args.model is not None fields = [_.strip() for _ in osp.basename(args.model).split('_')] # parse fields i = 0 num_fields = len(fields) # database dataset = fields[i] if args.dataset is None else args.dataset dataset_tgt = args.dataset_tgt i += 1 ######################## network structure assert fields[i].startswith('rn') net_type = re.compile('rn[a-z]*').findall(fields[i])[0] net_name = fields[i][len(net_type):].strip('-') i += 1 # number of classes assert fields[i].startswith('cls') classes = int(fields[i][len('cls'):]) i += 1 ######################## feature resolution #feat_stride = 32 feat_stride = 8 if i < num_fields and fields[i].startswith('s'): feat_stride = int(fields[i][len('s'):]) i += 1 # learning rate lr_params = { 'type': 'fixed', 'base': 0.1, 'args': None, } if args.base_lr is not None: lr_params['base'] = args.base_lr if args.lr_type in ('linear',): lr_params['type'] = args.lr_type elif args.lr_type in ('poly',): lr_params['type'] = args.lr_type elif args.lr_type == 'step': lr_params['args'] = {'step': [int(_) for _ in args.lr_steps.split(',')], 'factor': 0.1} model_specs = { # model 'lr_params': lr_params, 'net_type': net_type, 'net_name': net_name, 'classes': classes, 'feat_stride': feat_stride, # data 'dataset': dataset, 'dataset_tgt': dataset_tgt } return model_specs def parse_args(): parser = argparse.ArgumentParser(description='Tune FCRNs from ResNets.') parser.add_argument('--dataset', default=None, help='The source dataset to use, e.g. cityscapes, voc.') parser.add_argument('--dataset-tgt', dest='dataset_tgt', default=None, help='The target dataset to use, e.g. cityscapes, GM.') parser.add_argument('--split', dest='split', default='train', help='The split to use, e.g. train, trainval.') parser.add_argument('--split-tgt', dest='split_tgt', default='val', help='The split to use in target domain e.g. train, trainval.') parser.add_argument('--data-root', dest='data_root', help='The root data dir. for source domain', default=None, type=str) parser.add_argument('--data-root-tgt', dest='data_root_tgt', help='The root data dir. for target domain', default=None, type=str) parser.add_argument('--output', default=None, help='The output dir.') parser.add_argument('--model', default=None, help='The unique label of this model.') parser.add_argument('--batch-images', dest='batch_images', help='The number of images per batch.', default=None, type=int) parser.add_argument('--crop-size', dest='crop_size', help='The size of network input during training.', default=None, type=int) parser.add_argument('--origin-size', dest='origin_size', help='The size of images to crop from in source domain', default=2048, type=int) parser.add_argument('--origin-size-tgt', dest='origin_size_tgt', help='The size of images to crop from in target domain', default=2048, type=int) parser.add_argument('--scale-rate-range', dest='scale_rate_range', help='The range of rescaling', default='0.7,1.3', type=str) parser.add_argument('--weights', default=None, help='The path of a pretrained model.') parser.add_argument('--gpus', default='0', help='The devices to use, e.g. 0,1,2,3') # parser.add_argument('--lr-type', dest='lr_type', help='The learning rate scheduler, e.g., fixed(default)/step/linear', default=None, type=str) parser.add_argument('--base-lr', dest='base_lr', help='The lr to start from.', default=None, type=float) parser.add_argument('--lr-steps', dest='lr_steps', help='The steps when to reduce lr.', default=None, type=str) parser.add_argument('--weight-decay', dest='weight_decay', help='The weight decay in sgd.', default=0.0005, type=float) # parser.add_argument('--from-epoch', dest='from_epoch', help='The epoch to start from.', default=None, type=int) parser.add_argument('--stop-epoch', dest='stop_epoch', help='The index of epoch to stop.', default=None, type=int) parser.add_argument('--to-epoch', dest='to_epoch', help='The number of epochs to run.', default=None, type=int) # how many rounds to generate pseudo labels parser.add_argument('--idx-round', dest='idx_round', help='The current number of rounds to generate pseudo labels', default=0, type=int) # initial portion of selected pseudo labels in target domain parser.add_argument('--init-tgt-port', dest='init_tgt_port', help='The initial portion of pixels selected in target dataset, both by global and class-wise threshold', default=0.3, type=float) parser.add_argument('--init-src-port', dest='init_src_port', help='The initial portion of images selected in source dataset', default=0.3, type=float) parser.add_argument('--seed-int', dest='seed_int', help='The random seed', default=0, type=int) parser.add_argument('--mine-port', dest='mine_port', help='The portion of data being mined', default=0.5, type=float) # parser.add_argument('--mine-id-number', dest='mine_id_number', help='Thresholding value for deciding mine id', default=3, type=int) parser.add_argument('--mine-thresh', dest='mine_thresh', help='The threshold to determine the mine id', default=0.001, type=float) parser.add_argument('--mine-id-address', dest='mine_id_address', help='The address of mine id', default=None, type=str) # parser.add_argument('--phase', help='Phase of this call, e.g., train/val.', default='train', type=str) parser.add_argument('--with-prior', dest='with_prior', help='with prior', default='True', type=str) # for testing parser.add_argument('--test-scales', dest='test_scales', help='Lengths of the longer side to resize an image into, e.g., 224,256.', default=None, type=str) parser.add_argument('--test-flipping', dest='test_flipping', help='If average predictions of original and flipped images.', default=False, action='store_true') parser.add_argument('--test-steps', dest='test_steps', help='The number of steps to take, for predictions at a higher resolution.', default=1, type=int) # parser.add_argument('--kvstore', dest='kvstore', help='The type of kvstore, e.g., local/device.', default='local', type=str) parser.add_argument('--prefetch-threads', dest='prefetch_threads', help='The number of threads to fetch data.', default=1, type=int) parser.add_argument('--prefetcher', dest='prefetcher', help='The type of prefetercher, e.g., process/thread.', default='thread', type=str) parser.add_argument('--cache-images', dest='cache_images', help='If cache images, e.g., 0/1', default=None, type=int) parser.add_argument('--log-file', dest='log_file', default=None, type=str) parser.add_argument('--check-start', dest='check_start', help='The first epoch to snapshot.', default=1, type=int) parser.add_argument('--check-step', dest='check_step', help='The steps between adjacent snapshots.', default=4, type=int) parser.add_argument('--debug', help='True means logging debug info.', default=False, action='store_true') parser.add_argument('--backward-do-mirror', dest='backward_do_mirror', help='True means less gpu memory usage.', default=False, action='store_true') parser.add_argument('--no-cudnn', dest='no_mxnet_cudnn_autotune_default', help='True means deploy cudnn.', default=False, action='store_true') parser.add_argument('--kc-policy', dest='kc_policy', help='The kc determination policy, currently only "global" and "cb" (class-balanced)', default='cb', type=str) if len(sys.argv) == 1: parser.print_help() sys.exit(1) args = parser.parse_args() if args.debug: os.environ['MXNET_ENGINE_TYPE'] = 'NaiveEngine' if args.backward_do_mirror: os.environ['MXNET_BACKWARD_DO_MIRROR'] = '1' if args.no_mxnet_cudnn_autotune_default: os.environ['MXNET_CUDNN_AUTOTUNE_DEFAULT'] = '0' if args.output is None: if args.phase == 'val': args.output = osp.dirname(args.weights) else: args.output = 'output' if args.weights is not None: if args.model is None: assert '_ep-' in args.weights parts = osp.basename(args.weights).split('_ep-') args.model = '_'.join(parts[:-1]) if args.phase == 'train': if args.from_epoch is None: assert '_ep-' in args.weights parts = os.path.basename(args.weights).split('_ep-') assert len(parts) == 2 from_model = parts[0] if from_model == args.model: parts = os.path.splitext(os.path.basename(args.weights))[0].split('-') args.from_epoch = int(parts[-1]) if args.model is None: raise NotImplementedError('Missing argument: args.model') if args.from_epoch is None: args.from_epoch = 0 if args.log_file is None: if args.phase == 'train': args.log_file = '{}.log'.format(args.model) elif args.phase == 'val': suffix = '' if args.split_tgt != 'val': suffix = '_{}'.format(args.split_tgt) args.log_file = '{}{}.log'.format(osp.splitext(osp.basename(args.weights))[0], suffix) else: raise NotImplementedError('Unknown phase: {}'.format(args.phase)) model_specs = parse_model_label(args) if args.data_root is None: args.data_root = osp.join('data', model_specs['dataset']) return args, model_specs def get_dataset_specs_tgt(args, model_specs): dataset = args.dataset dataset_tgt = args.dataset_tgt meta = {} mine_id = None mine_id_priority = None mine_port = args.mine_port mine_th = args.mine_thresh cmap_path = 'data/shared/cmap.pkl' cache_images = args.phase == 'train' mx_workspace = 1650 sys.path.insert(0, 'data/cityscapesscripts/helpers') if args.phase == 'train': mine_id = np.load(args.mine_id_address + '/mine_id.npy') mine_id_priority = np.load(args.mine_id_address + '/mine_id_priority.npy') mine_th = np.zeros(len(mine_id)) # trainId starts from 0 if dataset == 'gta' and dataset_tgt == 'cityscapes': from labels import id2label, trainId2label # label_2_id_tgt = 255 * np.ones((256,)) for l in id2label: if l in (-1, 255): continue label_2_id_tgt[l] = id2label[l].trainId id_2_label_tgt = np.array([trainId2label[_].id for _ in trainId2label if _ not in (-1, 255)]) valid_labels_tgt = sorted(set(id_2_label_tgt.ravel())) id_2_label_src = id_2_label_tgt label_2_id_src = label_2_id_tgt valid_labels_src = valid_labels_tgt # cmap = np.zeros((256, 3), dtype=np.uint8) for i in id2label.keys(): cmap[i] = id2label[i].color # ident_size = True # #max_shape_src = np.array((1052, 1914)) max_shape_src = np.array((1024, 2048)) max_shape_tgt = np.array((1024, 2048)) # if args.split in ('train+', 'trainval+'): cache_images = False # if args.phase in ('val',): mx_workspace = 8192 elif dataset == 'synthia' and dataset_tgt == 'cityscapes': from labels_cityscapes_synthia import id2label as id2label_tgt from labels_cityscapes_synthia import trainId2label as trainId2label_tgt from labels_synthia import id2label as id2label_src label_2_id_src = 255 * np.ones((256,)) for l in id2label_src: if l in (-1, 255): continue label_2_id_src[l] = id2label_src[l].trainId label_2_id_tgt = 255 * np.ones((256,)) for l in id2label_tgt: if l in (-1, 255): continue label_2_id_tgt[l] = id2label_tgt[l].trainId id_2_label_tgt = np.array([trainId2label_tgt[_].id for _ in trainId2label_tgt if _ not in (-1, 255)]) valid_labels_tgt = sorted(set(id_2_label_tgt.ravel())) id_2_label_src = None valid_labels_src = None # cmap = np.zeros((256, 3), dtype=np.uint8) for i in id2label_tgt.keys(): cmap[i] = id2label_tgt[i].color # ident_size = True # max_shape_src = np.array((760, 1280)) max_shape_tgt = np.array((1024, 2048)) # if args.split in ('train+', 'trainval+'): cache_images = False # if args.phase in ('val',): mx_workspace = 8192 else: raise NotImplementedError('Unknow dataset: {}'.format(args.dataset)) if cmap is None and cmap_path is not None: if osp.isfile(cmap_path): with open(cmap_path) as f: cmap = cPickle.load(f) meta['gpus'] = args.gpus meta['mine_port'] = mine_port meta['mine_id'] = mine_id meta['mine_id_priority'] = mine_id_priority meta['mine_th'] = mine_th meta['label_2_id_tgt'] = label_2_id_tgt meta['id_2_label_tgt'] = id_2_label_tgt meta['valid_labels_tgt'] = valid_labels_tgt meta['label_2_id_src'] = label_2_id_src meta['id_2_label_src'] = id_2_label_src meta['valid_labels_src'] = valid_labels_src meta['cmap'] = cmap meta['ident_size'] = ident_size meta['max_shape_src'] = meta.get('max_shape_src', max_shape_src) meta['max_shape_tgt'] = meta.get('max_shape_tgt', max_shape_tgt) meta['cache_images'] = args.cache_images if args.cache_images is not None else cache_images meta['mx_workspace'] = mx_workspace return meta '''def _get_metric(): def _eval_func(label, pred): # global sxloss gt_label = label.ravel() valid_flag = gt_label != 255 labels = gt_label[valid_flag].astype(int) n,c,h,w = pred.shape valid_inds = np.where(valid_flag)[0] probmap = np.rollaxis(pred.astype(np.float32),1).reshape((c, -1)) valid_probmap = probmap[labels, valid_inds] log_valid_probmap = -np.log(valid_probmap+1e-32) sum_metric = log_valid_probmap.sum() num_inst = valid_flag.sum() return (sum_metric, num_inst + (num_inst == 0)) return mx.metric.CustomMetric(_eval_func, 'loss')''' class Multi_Accuracy(mx.metric.EvalMetric): """Calculate accuracies of multi label""" def __init__(self, num=None): self.num = num super(Multi_Accuracy, self).__init__('multi-accuracy') def reset(self): """Resets the internal evaluation result to initial state.""" self.num_inst = 0 if self.num is None else [0] * self.num self.sum_metric = 0.0 if self.num is None else [0.0] * self.num def update(self, labels, preds): mx.metric.check_label_shapes(labels, preds) if self.num is not None: assert len(labels) == self.num for i in range(len(labels)): #print ('I am here in accuracy') #pred_label = mx.nd.argmax_channel(preds[i]).asnumpy().astype('int32') pred_label = preds[i].asnumpy().astype('float') label = labels[i].asnumpy().astype('int32') mx.metric.check_label_shapes(label, pred_label) if self.num is None: #self.sum_metric += (pred_label.flat == label.flat).sum() #self.num_inst += len(pred_label.flat) outEval = _eval_func(label, pred_label) self.sum_metric = outEval[0] self.num_inst = outEval[1] else: if i==0: outEval = _eval_func(label, pred_label) self.sum_metric[i] = outEval[0] self.num_inst[i] = outEval[1] else: #self.sum_metric[i] = (pred_label.flat == label.flat).sum() #print(label.shape, pred_label.shape, label, pred_label) #self.sum_metric[i] = log_loss(label.flat, pred_label.flat) self.sum_metric[i] = cross_entropy(label.flatten(), pred_label.flatten()) self.num_inst[i] = len(pred_label.flat) #print self.sum_metric[i], self.num_inst[i] def get(self): """Gets the current evaluation result. Returns ------- names : list of str Name of the metrics. values : list of float Value of the evaluations. """ if self.num is None: return super(Multi_Accuracy, self).get() else: return zip(*(('%s-task%d'%(self.name, i), float('nan') if self.num_inst[i] == 0 else self.sum_metric[i] / self.num_inst[i]) for i in range(self.num))) def get_name_value(self): """Returns zipped name and value pairs. Returns ------- list of tuples A (name, value) tuple list. """ if self.num is None: return super(Multi_Accuracy, self).get_name_value() name, value = self.get() return list(zip(name, value)) def _eval_func(label, pred): # global sxloss gt_label = label.ravel() valid_flag = gt_label != 255 labels = gt_label[valid_flag].astype(int) n,c,h,w = pred.shape valid_inds = np.where(valid_flag)[0] probmap = np.rollaxis(pred.astype(np.float32),1).reshape((c, -1)) valid_probmap = probmap[labels, valid_inds] log_valid_probmap = -np.log(valid_probmap+1e-32) sum_metric = log_valid_probmap.sum() num_inst = valid_flag.sum() return (sum_metric, num_inst + (num_inst == 0)) def cross_entropy(targets, predictions): N = predictions.shape[0] lo = np.log(predictions+ 1e-6) #print predictions,lo ce = -np.sum(targets*lo)/N return ce def _get_scalemeanstd(): if model_specs['net_type'] in ('rna',): return (1.0 / 255, np.array([0.485, 0.456, 0.406]).reshape((1, 1, 3)), np.array([0.229, 0.224, 0.225]).reshape((1, 1, 3))) return None, None, None def _get_transformer_image(): scale, mean_, std_ = _get_scalemeanstd() transformers = [] if scale > 0: transformers.append(ts.ColorScale(np.single(scale))) transformers.append(ts.ColorNormalize(mean_, std_)) return transformers def _get_module(args, margs, dargs, net=None): if net is None: # the following lines show how to create symbols for our networks if model_specs['net_type'] == 'rna': from util1.symbol.symbol import cfg as symcfg symcfg['lr_type'] = 'alex' symcfg['workspace'] = dargs.mx_workspace symcfg['bn_use_global_stats'] = True if model_specs['net_name'] == 'a1': from util1.symbol.resnet_v2 import fcrna_model_a1, fcrna_model_a1_1 #net = fcrna_model_a1(margs.classes, margs.feat_stride, bootstrapping=False) net = fcrna_model_a1_1(margs.classes, margs.feat_stride, bootstrapping=False) if net is None: raise NotImplementedError('Unknown network: {}'.format(vars(margs))) contexts = [mx.gpu(int(_)) for _ in args.gpus.split(',')] #mod = mx.mod.Module(net, context=contexts) mod = mx.mod.Module(net, context=contexts, label_names=['softmax_label', 'sigmoid_label']) return mod def _make_dirs(path): if not osp.isdir(path): os.makedirs(path) def facc(label, pred): pred = pred.argmax(1).ravel() label = label.ravel() return (pred == label).mean() def fentropy(label, pred): pred_source = pred[:, 1, :, :].ravel() label = label.ravel() return -(label * np.log(pred_source + 1e-12) + (1. - label) * np.log(1. - pred_source + 1e-12)).mean() def _interp_preds_as_impl(num_classes, im_size, pred_stride, imh, imw, pred): imh0, imw0 = im_size pred = pred.astype(np.single, copy=False) input_h, input_w = pred.shape[0] * pred_stride, pred.shape[1] * pred_stride assert pred_stride >= 1. this_interp_pred = np.array(Image.fromarray(pred).resize((input_w, input_h), Image.CUBIC)) if imh0 == imh: interp_pred = this_interp_pred[:imh, :imw] else: interp_method = util.get_interp_method(imh, imw, imh0, imw0) interp_pred = np.array(Image.fromarray(this_interp_pred[:imh, :imw]).resize((imw0, imh0), interp_method)) return interp_pred def interp_preds_as(im_size, net_preds, pred_stride, imh, imw, threads=4): num_classes = net_preds.shape[0] worker = partial(_interp_preds_as_impl, num_classes, im_size, pred_stride, imh, imw) if threads == 1: ret = [worker(_) for _ in net_preds] else: pool = Pool(threads) ret = pool.map(worker, net_preds) pool.close() return np.array(ret) class ScoreUpdater(object): def __init__(self, valid_labels, c_num, x_num, logger=None, label=None, info=None): self._valid_labels = valid_labels self._confs = np.zeros((c_num, c_num, x_num)) self._pixels = np.zeros((c_num, x_num)) self._logger = logger self._label = label self._info = info @property def info(self): return self._info def reset(self): self._start = time.time() self._computed = np.zeros((self._pixels.shape[1],)) self._confs[:] = 0 self._pixels[:] = 0 @staticmethod def calc_updates(valid_labels, pred_label, label): num_classes = len(valid_labels) pred_flags = [set(np.where((pred_label == _).ravel())[0]) for _ in valid_labels] class_flags = [set(np.where((label == _).ravel())[0]) for _ in valid_labels] conf = [len(class_flags[j].intersection(pred_flags[k])) for j in xrange(num_classes) for k in xrange(num_classes)] pixel = [len(class_flags[j]) for j in xrange(num_classes)] return np.single(conf).reshape((num_classes, num_classes)), np.single(pixel) def do_updates(self, conf, pixel, i, computed=True): if computed: self._computed[i] = 1 self._confs[:, :, i] = conf self._pixels[:, i] = pixel def update(self, pred_label, label, i, computed=True): conf, pixel = ScoreUpdater.calc_updates(self._valid_labels, pred_label, label) self.do_updates(conf, pixel, i, computed) self.scores(i) def scores(self, i=None, logger=None): confs = self._confs pixels = self._pixels num_classes = pixels.shape[0] x_num = pixels.shape[1] class_pixels = pixels.sum(1) class_pixels += class_pixels == 0 scores = confs[xrange(num_classes), xrange(num_classes), :].sum(1) acc = scores.sum() / pixels.sum() cls_accs = scores / class_pixels class_preds = confs.sum(0).sum(1) ious = scores / (class_pixels + class_preds - scores) logger = self._logger if logger is None else logger if logger is not None: if i is not None: speed = 1. * self._computed.sum() / (time.time() - self._start) logger.info('Done {}/{} with speed: {:.2f}/s'.format(i + 1, x_num, speed)) name = '' if self._label is None else '{}, '.format(self._label) logger.info('{}pixel acc: {:.2f}%, mean acc: {:.2f}%, mean iou: {:.2f}%'. \ format(name, acc * 100, cls_accs.mean() * 100, ious.mean() * 100)) with util.np_print_options(formatter={'float': '{:5.2f}'.format}): logger.info('\n{}'.format(cls_accs * 100)) logger.info('\n{}'.format(ious * 100)) return acc, cls_accs, ious def overall_scores(self, logger=None): acc, cls_accs, ious = self.scores(None, logger) return acc, cls_accs.mean(), ious.mean() def _train_impl(args, model_specs, logger): if len(args.output) > 0: _make_dirs(args.output) # dataiter dataset_specs_tgt = get_dataset_specs_tgt(args, model_specs) scale, mean_, _ = _get_scalemeanstd() if scale > 0: mean_ /= scale margs = argparse.Namespace(**model_specs) dargs = argparse.Namespace(**dataset_specs_tgt) # number of list_lines split_filename = 'issegm1/data_list/{}/{}.lst'.format(margs.dataset, args.split) num_source = 0 with open(split_filename) as f: for item in f.readlines(): num_source = num_source + 1 # batches_per_epoch = num_source // args.batch_images # optimizer assert args.to_epoch is not None if args.stop_epoch is not None: assert args.stop_epoch > args.from_epoch and args.stop_epoch <= args.to_epoch else: args.stop_epoch = args.to_epoch from_iter = args.from_epoch * batches_per_epoch to_iter = args.to_epoch * batches_per_epoch lr_params = model_specs['lr_params'] base_lr = lr_params['base'] if lr_params['type'] == 'fixed': scheduler = FixedScheduler() elif lr_params['type'] == 'step': left_step = [] for step in lr_params['args']['step']: if from_iter > step: base_lr *= lr_params['args']['factor'] continue left_step.append(step - from_iter) model_specs['lr_params']['step'] = left_step scheduler = mx.lr_scheduler.MultiFactorScheduler(**lr_params['args']) elif lr_params['type'] == 'linear': scheduler = LinearScheduler(updates=to_iter + 1, frequency=50, stop_lr=min(base_lr / 100., 1e-6), offset=from_iter) elif lr_params['type'] == 'poly': scheduler = PolyScheduler(updates=to_iter + 1, frequency=50, stop_lr=min(base_lr / 100., 1e-8), power=0.9, offset=from_iter) initializer = mx.init.Xavier(rnd_type='gaussian', factor_type='in', magnitude=2) optimizer_params = { 'learning_rate': base_lr, 'momentum': 0.9, 'wd': args.weight_decay, 'lr_scheduler': scheduler, 'rescale_grad': 1.0 / len(args.gpus.split(',')), } data_src_port = args.init_src_port data_src_num = int(num_source * data_src_port) mod = _get_module(args, margs, dargs) addr_weights = args.weights # first weights should be xxxx_ep-0000.params! addr_output = args.output # initializer net_args = None net_auxs = None ### if addr_weights is not None: net_args, net_auxs = mxutil.load_params_from_file(addr_weights) print ('feat_stride', margs.feat_stride) ####################################### training model to_model = osp.join(addr_output, str(args.idx_round), '{}_ep'.format(args.model)) dataiter = FileIter(dataset=margs.dataset, split=args.split, data_root=args.data_root, num_sel_source=data_src_num, num_source=num_source, seed_int=args.seed_int, dataset_tgt=args.dataset_tgt, split_tgt=args.split_tgt, data_root_tgt=args.data_root_tgt, sampler='random', batch_images=args.batch_images, meta=dataset_specs_tgt, rgb_mean=mean_, feat_stride=margs.feat_stride, label_stride=margs.feat_stride, origin_size=args.origin_size, origin_size_tgt=args.origin_size_tgt, crop_size=args.crop_size, scale_rate_range=[float(_) for _ in args.scale_rate_range.split(',')], transformer=None, transformer_image=ts.Compose(_get_transformer_image()), prefetch_threads=args.prefetch_threads, prefetcher_type=args.prefetcher, ) dataiter.reset() #ad = dataiter.next() #label_shapes = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in label_shapes] #print (ad) mod.fit( dataiter, eval_metric=Multi_Accuracy(2), #eval_metric=_get_metric(), batch_end_callback=mx.callback.log_train_metric(10, auto_reset=False), epoch_end_callback=mx.callback.do_checkpoint(to_model), kvstore=args.kvstore, optimizer='sgd', optimizer_params=optimizer_params, initializer=initializer, arg_params=net_args, aux_params=net_auxs, allow_missing=args.from_epoch == 0, begin_epoch=args.from_epoch, num_epoch=args.stop_epoch, ) # @profile # MST: def _val_impl(args, model_specs, logger): if len(args.output) > 0: _make_dirs(args.output) # dataiter dataset_specs_tgt = get_dataset_specs_tgt(args, model_specs) scale, mean_, _ = _get_scalemeanstd() if scale > 0: mean_ /= scale #print (model_specs) margs = argparse.Namespace(**model_specs) dargs = argparse.Namespace(**dataset_specs_tgt) mod = _get_module(args, margs, dargs) addr_weights = args.weights # first weights should be xxxx_ep-0000.params! addr_output = args.output # current round index cround = args.idx_round net_args = None net_auxs = None ### if addr_weights is not None: net_args, net_auxs = mxutil.load_params_from_file(addr_weights) ###### save_dir = osp.join(args.output, str(cround), 'results') save_dir_self_train = osp.join(args.output, str(cround), 'self_train') # pseudo labels save_dir_pseudo_labelIds = osp.join(save_dir_self_train, 'pseudo_labelIds') save_dir_pseudo_color = osp.join(save_dir_self_train, 'pseudo_color') # without sp save_dir_nplabelIds = osp.join(save_dir, 'nplabelIds') save_dir_npcolor = osp.join(save_dir, 'npcolor') # probability map save_dir_probmap = osp.join(args.output, 'probmap') save_dir_stats = osp.join(args.output, 'stats') _make_dirs(save_dir) _make_dirs(save_dir_pseudo_labelIds) _make_dirs(save_dir_pseudo_color) _make_dirs(save_dir_nplabelIds) _make_dirs(save_dir_npcolor) _make_dirs(save_dir_probmap) _make_dirs(save_dir_stats) if args.with_prior == 'True': # with sp save_dir_splabelIds = osp.join(save_dir_self_train, 'splabelIds') save_dir_spcolor = osp.join(save_dir_self_train, 'spcolor') _make_dirs(save_dir_splabelIds) _make_dirs(save_dir_spcolor) if args.kc_policy == 'cb': # reweighted prediction map save_dir_rwlabelIds = osp.join(save_dir_self_train, 'rwlabelIds') save_dir_rwcolor = osp.join(save_dir_self_train, 'rwcolor') _make_dirs(save_dir_rwlabelIds) _make_dirs(save_dir_rwcolor) ###### dataset_tgt = model_specs['dataset_tgt'] image_list_tgt, label_gt_list_tgt,image_tgt_list = parse_split_file_tgt(margs.dataset_tgt, args.split_tgt) has_gt = args.split_tgt in ('train', 'val',) crop_sizes = sorted([int(_) for _ in args.test_scales.split(',')])[::-1] crop_size = crop_sizes[0] assert len(crop_sizes) == 1, 'multi-scale testing not implemented' label_stride = margs.feat_stride x_num = len(image_list_tgt) do_forward = True # for all images that has the same resolution if do_forward: batch = None transformers = [ts.Scale(crop_size, Image.CUBIC, False)] transformers += _get_transformer_image() transformer = ts.Compose(transformers) scorer_np = ScoreUpdater(dargs.valid_labels_tgt, margs.classes, x_num, logger) scorer_np.reset() # with prior if args.with_prior == 'True': scorer = ScoreUpdater(dargs.valid_labels_tgt, margs.classes, x_num, logger) scorer.reset() done_count = 0 # for multi-scale testing num_classes = margs.classes init_tgt_port = float(args.init_tgt_port) # class-wise cls_exist_array = np.zeros([1, num_classes], dtype=int) cls_thresh = np.zeros([num_classes]) # confidence thresholds for all classes cls_size = np.zeros([num_classes]) # number of predictions in each class array_pixel = 0.0 # prior if args.with_prior == 'True': in_path_prior = 'spatial_prior/{}/prior_array.mat'.format(args.dataset) sprior = scipy.io.loadmat(in_path_prior) prior_array = sprior["prior_array"].astype(np.float32) #prior_array = np.maximum(prior_array,0) ############################ network forward for i in xrange(x_num): start = time.time() ############################ network forward on single image (from official ResNet-38 implementation) sample_name = osp.splitext(osp.basename(image_list_tgt[i]))[0] im_path = osp.join(args.data_root_tgt, image_list_tgt[i]) rim = np.array(Image.open(im_path).convert('RGB'), np.uint8) if do_forward: im = transformer(rim) imh, imw = im.shape[:2] # init if batch is None: if dargs.ident_size: input_h = make_divisible(imh, margs.feat_stride) input_w = make_divisible(imw, margs.feat_stride) else: input_h = input_w = make_divisible(crop_size, margs.feat_stride) label_h, label_w = input_h / label_stride, input_w / label_stride test_steps = args.test_steps pred_stride = label_stride / test_steps pred_h, pred_w = label_h * test_steps, label_w * test_steps input_data = np.zeros((1, 3, input_h, input_w), np.single) input_label = 255 * np.ones((1, label_h * label_w), np.single) #dataiter_tgt = mx.io.NDArrayIter(input_data, input_label) input_label2 = np.ones((1, 19), np.single) label = {'softmax_label':input_label, 'sigmoid_label':input_label2} dataiter_tgt = mx.io.NDArrayIter(input_data, label) batch = dataiter_tgt.next() mod.bind(dataiter_tgt.provide_data, dataiter_tgt.provide_label, for_training=False, force_rebind=True) if not mod.params_initialized: mod.init_params(arg_params=net_args, aux_params=net_auxs) nim = np.zeros((3, imh + label_stride, imw + label_stride), np.single) sy = sx = label_stride // 2 nim[:, sy:sy + imh, sx:sx + imw] = im.transpose(2, 0, 1) net_preds = np.zeros((margs.classes, pred_h, pred_w), np.single) sy = sx = pred_stride // 2 + np.arange(test_steps) * pred_stride for ix in xrange(test_steps): for iy in xrange(test_steps): input_data = np.zeros((1, 3, input_h, input_w), np.single) input_data[0, :, :imh, :imw] = nim[:, sy[iy]:sy[iy] + imh, sx[ix]:sx[ix] + imw] batch.data[0] = mx.nd.array(input_data) mod.forward(batch, is_train=False) this_call_preds = mod.get_outputs()[0].asnumpy()[0] if args.test_flipping: batch.data[0] = mx.nd.array(input_data[:, :, :, ::-1]) mod.forward(batch, is_train=False) # average the original and flipped image prediction this_call_preds = 0.5 * ( this_call_preds + mod.get_outputs()[0].asnumpy()[0][:, :, ::-1]) net_preds[:, iy:iy + pred_h:test_steps, ix:ix + pred_w:test_steps] = this_call_preds interp_preds_np = interp_preds_as(rim.shape[:2], net_preds, pred_stride, imh, imw) ########################### #save predicted labels and confidence score vectors in target domains # no prior prediction with trainIDs pred_label_np = interp_preds_np.argmax(0) # no prior prediction with labelIDs if dargs.id_2_label_tgt is not None: pred_label_np = dargs.id_2_label_tgt[pred_label_np] # no prior color prediction im_to_save_np = Image.fromarray(pred_label_np.astype(np.uint8)) im_to_save_npcolor = im_to_save_np.copy() if dargs.cmap is not None: im_to_save_npcolor.putpalette(dargs.cmap.ravel()) # save no prior prediction with labelIDs and colors out_path_np = osp.join(save_dir_nplabelIds, '{}.png'.format(sample_name)) out_path_npcolor = osp.join(save_dir_npcolor, '{}.png'.format(sample_name)) im_to_save_np.save(out_path_np) im_to_save_npcolor.save(out_path_npcolor) # with prior if args.with_prior == 'True': probmap = np.multiply(prior_array,interp_preds_np).astype(np.float32) elif args.with_prior == 'False': probmap = interp_preds_np.copy().astype(np.float32) pred_label = probmap.argmax(0) probmap_max = np.amax(probmap, axis=0) ############################ save confidence scores of target domain as class-wise vectors for idx_cls in np.arange(0, num_classes): idx_temp = pred_label == idx_cls sname = 'array_cls' + str(idx_cls) if not (sname in locals()): exec ("%s = np.float32(0)" % sname) if idx_temp.any(): cls_exist_array[0, idx_cls] = 1 probmap_max_cls_temp = probmap_max[idx_temp].astype(np.float32) len_cls = probmap_max_cls_temp.size # downsampling by rate 4 probmap_cls = probmap_max_cls_temp[0:len_cls:4] exec ("%s = np.append(%s,probmap_cls)" % (sname, sname)) ############################ save prediction # save prediction probablity map out_path_probmap = osp.join(save_dir_probmap, '{}.npy'.format(sample_name)) np.save(out_path_probmap, probmap.astype(np.float32)) # save predictions with spatial priors, if sp exist. if args.with_prior == 'True': if dargs.id_2_label_tgt is not None: pred_label = dargs.id_2_label_tgt[pred_label] im_to_save_sp = Image.fromarray(pred_label.astype(np.uint8)) im_to_save_spcolor = im_to_save_sp.copy() if dargs.cmap is not None: # save color seg map im_to_save_spcolor.putpalette(dargs.cmap.ravel()) out_path_sp = osp.join(save_dir_splabelIds, '{}.png'.format(sample_name)) out_path_spcolor = osp.join(save_dir_spcolor, '{}.png'.format(sample_name)) im_to_save_sp.save(out_path_sp) im_to_save_spcolor.save(out_path_spcolor) # log information done_count += 1 if not has_gt: logger.info( 'Done {}/{} with speed: {:.2f}/s'.format(i + 1, x_num, 1. * done_count / (time.time() - start))) continue if args.split_tgt in ('train', 'val'): # evaluate with ground truth label_path = osp.join(args.data_root_tgt, label_gt_list_tgt[i]) label = np.array(Image.open(label_path), np.uint8) if args.with_prior == 'True': scorer.update(pred_label, label, i) scorer_np.update(pred_label_np, label, i) # save target training list fout = 'issegm1/data_list/{}/{}_training_gpu{}.lst'.format(args.dataset_tgt,args.split_tgt,args.gpus) fo = open(fout, "w") for idx_image in range(x_num): sample_name = osp.splitext(osp.basename(image_list_tgt[idx_image]))[0] fo.write(image_tgt_list[idx_image] + '\t' + osp.join(save_dir_pseudo_labelIds, '{}.png'.format(sample_name)) + '\n') fo.close() ############################ kc generation start_sort = time.time() # threshold for each class if args.kc_policy == 'global': for idx_cls in np.arange(0,num_classes): tname = 'array_cls' + str(idx_cls) exec ("array_pixel = np.append(array_pixel,%s)" % tname) # reverse=False for ascending losses and reverse=True for descending confidence array_pixel = sorted(array_pixel, reverse = True) len_cls = len(array_pixel) len_thresh = int(math.floor(len_cls * init_tgt_port)) cls_size[:] = len_cls cls_thresh[:] = array_pixel[len_thresh-1].copy() array_pixel = 0.0 if args.kc_policy == 'cb': for idx_cls in np.arange(0, num_classes): tname = 'array_cls' + str(idx_cls) if cls_exist_array[0, idx_cls] == 1: exec("%s = sorted(%s,reverse=True)" % (tname, tname)) # reverse=False for ascending losses and reverse=True for descending confidence exec("len_cls = len(%s)" % tname) cls_size[idx_cls] = len_cls len_thresh = int(math.floor(len_cls * init_tgt_port)) if len_thresh != 0: exec("cls_thresh[idx_cls] = %s[len_thresh-1].copy()" % tname) exec("%s = %d" % (tname, 0.0)) # threshold for mine_id with priority mine_id_priority = np.nonzero(cls_size / np.sum(cls_size) < args.mine_thresh)[0] # chosen mine_id mine_id_all = np.argsort(cls_size / np.sum(cls_size)) mine_id = mine_id_all[:args.mine_id_number] print(mine_id) np.save(save_dir_stats + '/mine_id.npy', mine_id) np.save(save_dir_stats + '/mine_id_priority.npy', mine_id_priority) np.save(save_dir_stats + '/cls_thresh.npy', cls_thresh) np.save(save_dir_stats + '/cls_size.npy', cls_size) logger.info('Kc determination done in %.2f s.', time.time() - start_sort) ############################ pseudo-label generation for i in xrange(x_num): sample_name = osp.splitext(osp.basename(image_list_tgt[i]))[0] sample_pseudo_label_name = osp.join(save_dir_pseudo_labelIds, '{}.png'.format(sample_name)) sample_pseudocolor_label_name = osp.join(save_dir_pseudo_color, '{}.png'.format(sample_name)) out_path_probmap = osp.join(save_dir_probmap, '{}.npy'.format(sample_name)) probmap = np.load(out_path_probmap) rw_probmap = np.zeros(probmap.shape, np.single) cls_thresh[cls_thresh == 0] = 1.0 # cls_thresh = 0 means there is no prediction in this class ############# pseudo-label assignment for idx_cls in np.arange(0, num_classes): cls_thresh_temp = cls_thresh[idx_cls] cls_probmap = probmap[idx_cls,:,:] cls_rw_probmap = np.true_divide(cls_probmap,cls_thresh_temp) rw_probmap[idx_cls,:,:] = cls_rw_probmap.copy() rw_probmap_max = np.amax(rw_probmap, axis=0) pseudo_label = np.argmax(rw_probmap,axis=0) ############# pseudo-label selection idx_unconfid = rw_probmap_max < 1 idx_confid = rw_probmap_max >= 1 # pseudo-labels with labelID pseudo_label = pseudo_label.astype(np.uint8) pseudo_label_labelID = dargs.id_2_label_tgt[pseudo_label] rw_pred_label = pseudo_label_labelID.copy() # ignore label assignment, compatible with labelIDs pseudo_label_labelID[idx_unconfid] = 0 ############# save pseudo-label im_to_save_pseudo = Image.fromarray(pseudo_label_labelID.astype(np.uint8)) im_to_save_pseudocol = im_to_save_pseudo.copy() if dargs.cmap is not None: # save segmentation prediction with color im_to_save_pseudocol.putpalette(dargs.cmap.ravel()) out_path_pseudo = osp.join(save_dir_pseudo_labelIds, '{}.png'.format(sample_name)) out_path_colpseudo = osp.join(save_dir_pseudo_color, '{}.png'.format(sample_name)) im_to_save_pseudo.save(out_path_pseudo) im_to_save_pseudocol.save(out_path_colpseudo) ############# save reweighted pseudo-label in cbst if args.kc_policy == 'cb': im_to_save_rw = Image.fromarray(rw_pred_label.astype(np.uint8)) im_to_save_rwcolor = im_to_save_rw.copy() if dargs.cmap is not None: im_to_save_rwcolor.putpalette(dargs.cmap.ravel()) out_path_rw = osp.join(save_dir_rwlabelIds, '{}.png'.format(sample_name)) out_path_rwcolor = osp.join(save_dir_rwcolor, '{}.png'.format(sample_name)) # save no prior prediction with labelIDs and colors im_to_save_rw.save(out_path_rw) im_to_save_rwcolor.save(out_path_rwcolor) ## remove probmap folder import shutil shutil.rmtree(save_dir_probmap) ## if __name__ == "__main__": util.cfg['choose_interpolation_method'] = True args, model_specs = parse_args() if len(args.output) > 0: _make_dirs(args.output) logger = util.set_logger(args.output, args.log_file, args.debug) logger.info('start with arguments %s', args) logger.info('and model specs %s', model_specs) if args.phase == 'train': _train_impl(args, model_specs, logger) elif args.phase == 'val': _val_impl(args, model_specs, logger) else: raise NotImplementedError('Unknown phase: {}'.format(args.phase))

noreply@github.com

a33b2f9f3cd62ddd7189114556f08b0144aad7c6

b08d42933ac06045905d7c005ca9c114ed3aecc0

/src/coefSubset/evaluate/ranks/tenth/rank_2p49_Q.py

c80b9b7c96acce81b347d895d8286c78c576e7d8

no_license

TanemuraKiyoto/PPI-native-detection-via-LR

d148d53f5eb60a4dda5318b371a3048e3f662725

897e7188b0da94e87126a4acc0c9a6ff44a64574

refs/heads/master

UTF-8

Python

py

# 9 July 2019 # Kiyoto Aramis Tanemura # Several metrics are used to assess the performance of the trained RF model, notably native ranking. This script returns a ranking of the native protein-protein complex among a decoy set. For convenience, I will define as a function and will call in a general performance assessment script. # Modified 11 July 2019 by Kiyoto Aramis Tanemura. To parallelize the process, I will replace the for loop for the testFileList to a multiprocessing pool. # Modified 9 September 2019 by Kiyoto Aramis Tanemura. I will use the function to perform the calculation on one CSV file only. Thus instead of a function to import in other scripts, they will be individual jobs parallelized as individual jobs in the queue. import os import pandas as pd import numpy as np import pickle os.chdir('/mnt/scratch/tanemur1/') # Read the model and trainFile testFile = '2p49.csv' identifier = 'Q' thresholdCoef = 0.1 testFilePath = '/mnt/scratch/tanemur1/CASF-PPI/nonb_descriptors/complete/' modelPath = '/mnt/home/tanemur1/6May2019/2019-11-11/results/coefSubset/tenth/' outputPath = '/mnt/home/tanemur1/6May2019/2019-11-11/results/coefSubset/evaluate/tenth/ranks/' pdbID = testFile[:4] with open(modelPath + 'model' + identifier + '.pkl', 'rb') as f: clf = pickle.load(f) result = pd.DataFrame() scoreList = [] df1 = pd.read_csv(testFilePath + testFile) dropList = ['Unnamed: 0', 'Unnamed: 0.1', 'ref'] df1 = df1.drop(dropList, axis = 1) df1 = df1.set_index('Pair_name') df1 = pd.DataFrame(df1.values.T, columns = df1.index, index = df1.columns) df1.fillna(0.0, inplace = True) df1 = df1.reindex(sorted(df1.columns), axis = 1) # Drop features with coefficients below threshold coefs = pd.read_csv('/mnt/home/tanemur1/6May2019/2019-11-11/results/medianCoefs.csv', index_col = 0, header = None, names = ['coefficients']) coefs = coefs[np.abs(coefs['coefficients']) < thresholdCoef] dropList = list(coefs.index) del coefs df1.drop(dropList, axis = 1, inplace = True) with open(modelPath + 'standardScaler' + identifier + '.pkl', 'rb') as g: scaler = pickle.load(g) for i in range(len(df1)): # subtract from one row each row of the dataframe, then remove the trivial row[[i]] - row[[i]]. Also some input files have 'class' column. This is erroneous and is removed. df2 = pd.DataFrame(df1.iloc[[i]].values - df1.values, index = df1.index, columns = df1.columns) df2 = df2.drop(df1.iloc[[i]].index[0], axis = 0) # Standardize inut DF using the standard scaler used for training data. df2 = scaler.transform(df2) # Predict class of each comparison descriptor and sum the classes to obtain score. Higher score corresponds to more native-like complex predictions = clf.predict(df2) score = sum(predictions) scoreList.append(score) # Make a new DataFrame to store the score and corresponding descriptorID. Add rank as column. Note: lower rank corresponds to more native-like complex result = pd.DataFrame(data = {'score': scoreList}, index = df1.index.tolist()).sort_values(by = 'score', ascending = False) result['rank'] = range(1, len(result) + 1) with open(outputPath + pdbID + identifier + '.csv', 'w') as h: result.to_csv(h)

tanemur1@msu.edu

3095ad9d0178728b8363be5fa150c0ea43e6ecea

9c902c6bc6ea2cce71195acd5baa8f44ab928eb6

/pythonapp/imgtxt/admin.py

0124dec01736c26d6587dbe332000f3719f39cdc

no_license

mogilivishal/Verzeo-OCR-Project

a383b56014e13dfef598a191012fc51dc9579624

8b34a6c8b323e0b55c7902f2c4f873a1e4ce04e7

refs/heads/master

UTF-8

Python

py

from django.contrib import admin from .models import Document admin.site.register(Document)

noreply@github.com

7f9a2d07182faa806f9337f02a6a0ce4035514fd

0676f6e4d3510a0305d29aa0b1fe740d538d3b63

/Python/SImplifyPline/CleanUpPolyline.py

1ce7d7116eb272886ed20d4186ae8a3b571c98fb

no_license

pgolay/PG_Scripts

f70ffe7e5ca07acd6f4caedc9a9aec566542da7c

796704a7daa6ac222a40bb02afdb599f74a6b0d4

refs/heads/master

Python

UTF-8

Python

py

import Rhino import scriptcontext as sc """ Cleans up by collapsing tiny segments in a polyline. """ def CleanUpPolyline(): while True: tol = sc.doc.ModelAbsoluteTolerance if sc.sticky.has_key("PLineSimplifyTol"): tol = sc.sticky["PLineSimplifyTol"] go = Rhino.Input.Custom.GetObject() go.AcceptNumber(True, False) go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve opDblTol = Rhino.Input.Custom.OptionDouble(tol) go.AddOptionDouble("SegmentTolerance",opDblTol) result = go.Get() if( go.CommandResult() != Rhino.Commands.Result.Success ): return if result == Rhino.Input.GetResult.Object: if type(go.Object(0).Geometry()) == Rhino.Geometry.PolylineCurve: curve = go.Object(0).Geometry() rc, pLine = curve.TryGetPolyline() pLineId = go.Object(0).ObjectId else: sc.doc.Objects.UnselectAll() sc.doc.Views.Redraw() print "Sorry, that was not a polyline." continue break elif result == Rhino.Input.GetResult.Option: tol = opDblTol.CurrentValue sc.sticky["PLineSimplifyTol"] = tol continue elif result == Rhino.Input.GetResult.Number: tol = go.Number() sc.sticky["PLineSimplifyTol"] = tol continue break count = pLine.CollapseShortSegments(tol) if count !=0: sc.doc.Objects.Replace(pLineId, pLine) sc.doc.Views.Redraw() print str(count) + " short segments were collapsed." else: print "No short segments were collapsed." pass if __name__ == "__main__": CleanUpPolyline()

noreply@github.com

ede12f3384950d410a2e5b5c0bb5ba2b28076ac9

6c67e2ae195521910fd3d8180fc5a70b9f60db81

/controllers/utils/rtsq_library/rtsq_level.py

bbe95532b2799521638fa5f25075270c273de949

permissive

zeroday0619/Real-Time-Delivery-Query-API

be8b7f0cd74e6c8651fc034064f51e6ec20bac17

fc2f973c205fe453f77ae27dcd99ce3c2e84528d

refs/heads/master

UTF-8

Python

py

def level(resp): """ Args: resp: level: string Returns: [level 1: 배송준비중, 2: 집화완료, 3: 배송중, 4: 지점 도착, 5: 배송출발, 6:배송 완료] """ if resp['level'] == 1: return { "code": 1, "level": "배송 준비중" } elif resp['level'] == 2: return { "code": 2, "level": "집화 완료" } elif resp['level'] == 3: return { "code": 3, "level": "배송중" } elif resp['level'] == 4: return { "code": 4, "level": "지점 도착" } elif resp['level'] == 5: return { "code": 5, "level": "배송 출발" } elif resp['level'] == 6: return { "code": 6, "level": "배송 완료" } else: return { "code": 0, "level": "Internal System Error" }

noreply@github.com

ee3452616d5ab280c04845cc2164cbdf6db586d2

9032e88ca0c90a15b96d2142d2629484cdf469b6

/py_controls/MemoryManager.py

fd1bc79f0d91f58ce62c4bd3349152244c888609

permissive

CyberCrunch/DU_AI_Gov

856db1db4e67e37ac8c8f05fc096a9bbc50027a8

a9fcf3b603c39bf0704df172a6745620d1d3c06b

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- """ Created on Fri Dec 30 15:52:43 2016 @author: robin """ import json from enum import Enum #testing possible enums for readability...(not implemeted) class NrH(Enum): #human data formtat for Json name = 0 human = 1 job = 2 status = 3 position = 4 money = 5 class NrL(Enum): #location data formtat for Json name = 0 location = 1 planet = 2 structure = 3 longitude = 4 latitude = 5 resource = 6 reward = 7 class SpH(Enum): #human string formtat for registration name = 0 job = 1 class SpL(Enum): #location string formtat for registration name = 0 planet = 1 structure = 2 longitude = 3 latitude = 4 def regHuman(msg): splitStr = msg.split() if(len(splitStr) != 2): return "Invalid Parameters, please use Format: !reg YourName YourJob" with open('memoryDB.json', 'r+') as json_file: json_data = json.load(json_file) json_data[splitStr[SpH.name.value]] = ['Human', splitStr[SpH.job.value],"idle", "unknownPos", 0] json_file.seek(0, 0) json_file.write(json.dumps(json_data, indent=4)) json_file.truncate() return ("New human registered: " +msg) def regLocation(msg): splitStr = msg.split() if(len(splitStr) != 5): return ("Invalid Parameters, please use Format: !geodata name planet type longitude latitude") with open('memoryDB.json', 'r+') as json_file: json_data = json.load(json_file) json_data[splitStr[SpL.name.value]] = ['Location', splitStr[SpL.planet.value], splitStr[SpL.structure.value], splitStr[SpL.longitude.value], splitStr[SpL.latitude.value], "default", 0] json_file.seek(0, 0) json_file.write(json.dumps(json_data, indent=4)) json_file.truncate() return ("New location registered: " +msg) def getDatabase(): with open('memoryDB.json', 'r') as json_file: json_data = json.load(json_file) return(json.dumps(json_data, indent=4, sort_keys=True))

noreply@github.com

6e1066a32d3b678c93a683c91c32ca9925549774

72d010d00355fc977a291c29eb18aeb385b8a9b0

/MPK261/__init__.py

1878e1129184af07da8510e9e370e01adae46916

no_license

maratbakirov/AbletonLive10_MIDIRemoteScripts

bf0749c5c4cce8e83b23f14f671e52752702539d

ed1174d9959b20ed05fb099f0461bbc006bfbb79

refs/heads/master

UTF-8

Python

py

# Embedded file name: /Users/versonator/Jenkins/live/output/mac_64_static/Release/python-bundle/MIDI Remote Scripts/MPK261/__init__.py # Compiled at: 2018-04-23 20:27:04 from __future__ import absolute_import, print_function, unicode_literals from .MPK261 import MPK261 from _Framework.Capabilities import controller_id, inport, outport, CONTROLLER_ID_KEY, PORTS_KEY, NOTES_CC, SCRIPT, REMOTE def get_capabilities(): return {CONTROLLER_ID_KEY: controller_id(vendor_id=2536, product_ids=[ 37], model_name='MPK261'), PORTS_KEY: [ inport(props=[NOTES_CC, SCRIPT, REMOTE]), outport(props=[SCRIPT, REMOTE])]} def create_instance(c_instance): return MPK261(c_instance)

julien@julienbayle.net

130a1da7648c1cb9b3d0bdc2b94793d83b2e1729

999a7707806f941d334170e9909a268d102929b2

/yelpCNN.py

3057ac376eecfe679a7625817028c878379593e2

no_license

wanaaaa/yelpCNN1D

7e089ab4ca60e3cf478a6d5b0a5a3b3e80253ba4

2f1f1ad9b8101d7a52f2f3c4d01d92e3f197b19b

refs/heads/main

UTF-8

Python

py

# https://chriskhanhtran.github.io/posts/cnn-sentence-classification/ from functionClass import * from gensim.models import Word2Vec import torch import torch.optim as optim device = 'cuda' rateReviewTrainList, rateReviewTestList, maxListCount = dataRead() xyDataLoader = DataLoaderFun(rateReviewTrainList, maxListCount, batchSize=2500) textCNNmodel = trainFun(xyDataLoader, maxListCount, epochs=20) # textCNNmodel = TextCnn(maxListCount).cuda(device=device) textCNNmodel = TextCnn(maxListCount).cpu() textCNNmodel.load_state_dict(torch.load('traindTextCNNmodel.model')) textCNNmodel.eval() # ================================================ # ================================================ # ================================================ xyTestDataLoader = DataLoaderFun(rateReviewTestList, maxListCount, batchSize=1) for epoch in range(1): # print("num of epochs->", epoch) for step, batch in enumerate(xyTestDataLoader): x_test, y_test = tuple(t.to('cpu') for t in batch) y_pridict = textCNNmodel(x_test) print("y_pridict->", y_pridict, 'y_test->', y_test) # break torch.cuda.empty_cache()

noreply@github.com

2be33a204326b77eed20224274574b433213be6a

73501b9e3623c3a9338306dbe52d1d89700f3d91

/upload_this_on_arduino/pyduino.py

2e4bf4eb623b2c987b4a395798e2605767cf5739

no_license

rouanro/PS

72af2d8f5f3d1c628b8ad599c244235781b04c61

a474d5ac9d23d50388c1811ddf256efa408b33d6

refs/heads/master

UTF-8

Python

py

""" A library to interface Arduino through serial connection """ import serial import smtplib from email.message import EmailMessage class Arduino(): """ Models an Arduino connection """ def __init__(self, serial_port='/dev/ttyACM0', baud_rate=9600, read_timeout=5): """ Initializes the serial connection to the Arduino board """ self.conn = serial.Serial(serial_port, baud_rate) self.conn.timeout = read_timeout # Timeout for readline() def set_pin_mode(self, pin_number, mode): """ Performs a pinMode() operation on pin_number Internally sends b'M{mode}{pin_number} where mode could be: - I for INPUT - O for OUTPUT - P for INPUT_PULLUP MO13 """ # command = (''.join(('M',mode,str(pin_number)))).encode() #print 'set_pin_mode =',command,(''.join(('M',mode,str(pin_number)))) # self.conn.write(command) def digital_read(self, pin_number): """ Performs a digital read on pin_number and returns the value (1 or 0) Internally sends b'RD{pin_number}' over the serial connection """ command = (''.join(('RD', str(pin_number)))).encode() #self.conn.write(command) line_received = self.conn.readline().decode().strip() header, value = line_received.split(':') # e.g. D13:1 if header == ('D'+ str(pin_number)): # If header matches return int(value) def digital_write(self, pin_number, digital_value): """ Writes the digital_value on pin_number Internally sends b'WD{pin_number}:{digital_value}' over the serial connection """ command = (''.join(('WD', str(pin_number), ':', str(digital_value)))).encode() #self.conn.write(command) def analog_read(self, pin_number): """ Performs an analog read on pin_number and returns the value (0 to 1023) Internally sends b'RA{pin_number}' over the serial connection """ command = (''.join(('RA', str(pin_number)))).encode() self.conn.write(command) print(command) line_received = self.conn.readline().decode().strip() #header, value = line_received.split(':') # e.g. A4:1 if line_received[0:2] == ("A0"): value = line_received[3:] # If header matches return int(value) if line_received[0:2] == ("A4"): value = line_received[3:] return value # me == the sender's email address # you == the recipient's email address # msg = EmailMessage() # msg['Subject'] = 'Teeeeeeeeeeest' # msg['From'] = 'benimagh@yahoo.com' # msg['To'] = 'beniaminmaghis@gmail.com' # Send the message via our own SMTP server. # s = smtplib.SMTP('localhost') # s.send_message(msg) # s.quit() def analog_write(self, pin_number, analog_value): """ Writes the analog value (0 to 255) on pin_number Internally sends b'WA{pin_number}:{analog_value}' over the serial connection """ command = (''.join(('WA', str(pin_number), ':', str(analog_value)))).encode() #self.conn.write(command) def send_message(self, message): command = message.encode() self.conn.write(command) def send_email(self, user, pwd, recipient, subject, body): FROM = user TO = recipient if isinstance(recipient, list) else [recipient] SUBJECT = subject TEXT = body # Prepare actual message message = """From: %s\nTo: %s\nSubject: %s\n\n%s """ % (FROM, ", ".join(TO), SUBJECT, TEXT) try: server = smtplib.SMTP("smtp.gmail.com", 587) server.ehlo() server.starttls() server.login(user, pwd) server.sendmail(FROM, TO, message) server.close() print('successfully sent the mail') except: print("failed to send mail") def close(self): """ To ensure we are properly closing our connection to the Arduino device. """ self.conn.close() print ('Connection to Arduino closed')

noreply@github.com

530f4767b7bb69cd945bd97def72737f1ad66039

7da328d5365788bec00b62e3c3de8b5133fba092

/impala/tests/test_impala.py

8c58516171a9ff74ed847675759c70ca285b5840

permissive

attilajeges/impyla

f7520677e426f42e60ecf9199d8dacd38eae1b99

35297fd573bd8d8984f89eec91f12dbb1837549a

refs/heads/master

Apache-2.0

UTF-8

Python

py

# Copyright 2019 Cloudera Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest from pytest import yield_fixture BIGGER_TABLE_NUM_ROWS = 100 @yield_fixture(scope='module') def bigger_table(cur): table_name = 'tmp_bigger_table' ddl = """CREATE TABLE {0} (s string) STORED AS PARQUET""".format(table_name) cur.execute(ddl) dml = """INSERT INTO {0} VALUES {1}""".format(table_name, ",".join(["('row{0}')".format(i) for i in xrange(BIGGER_TABLE_NUM_ROWS)])) # Disable codegen and expr rewrites so query runs faster. cur.execute("set disable_codegen=1") cur.execute("set enable_expr_rewrites=0") cur.execute(dml) try: yield table_name finally: cur.execute("DROP TABLE {0}".format(table_name)) def test_has_more_rows(cur, bigger_table): """Test that impyla correctly handles empty row batches returned with the hasMoreRows flag.""" # Set the fetch timeout very low and add sleeps so that Impala will return # empty batches. Run on a single node with a single thread to make as predictable # as possible. cur.execute("set fetch_rows_timeout_ms=1") cur.execute("set num_nodes=1") cur.execute("set mt_dop=1") cur.execute("""select * from {0} where s != cast(sleep(2) as string)""".format(bigger_table)) expected_rows = [("row{0}".format(i),) for i in xrange(BIGGER_TABLE_NUM_ROWS)] assert sorted(cur.fetchall()) == sorted(expected_rows)

noreply@github.com

bb452e72141b555c7dd30f34a66fc3fe30f86fbd

220a2a22f7ecbb960e6a09b1153ec5094aef15f5

/Log-Parsers/Recognition_Long_Talks/general_classes.py

a374a5df875af86c516cbe3be40426c999673ee0

no_license

jrweis01/Rubidium

89b27b8376891b42eb6b8bf952f70d92dd81768c

6050241aa19401bd5196939aadfc4a095f771d0a

refs/heads/master

UTF-8

Python

py

from templates_data import * import openpyxl import os import sys import shutil import datetime class Utils(object): def fetch_files_from_folder(self, pathToFolder): _pathToFiles = [] _fileNames = [] for dirPath, dirNames, fileNames in os.walk(pathToFolder): selected_path = [os.path.join(dirPath, item) for item in fileNames] _pathToFiles.extend(selected_path) selectedFile = [item for item in fileNames] _fileNames.extend(selectedFile) # Try to remove empty entries if none of the required files are in directory try: _pathToFiles.remove('') _imageFiles.remove('') except ValueError: pass # Warn if nothing was found in the given path if selectedFile == []: print 'No files with given parameters were found in:\n', dirPath, '\n' print len(_fileNames), 'files were found is searched folder(s)' return _pathToFiles, _fileNames def get_excel_worksheet(self): pass @staticmethod def insertion_sort(items): for i in range(1, len(items)): j = i while j > 0 and items[j] > items[j - 1]: items[j - 1], items[j] = items[j], items[j - 1] j = j - 1 return items def sort_order_dict(self,order_dict): for key in order_dict: items = order_dict[key] items = self.insertion_sort(items) def sorting_headers(self,sorting_dict,order_dict): sorted_list = [] for m in order_dict["noise_file_name"]: for i in order_dict["trig_to_ASR_delay"]: for j in order_dict["signal_dB"]: for k in order_dict["noise_dB"]: for key in sorting_dict: if (sorting_dict[key]["noise_file_name"] == str(m) and sorting_dict[key]["trig_to_ASR_delay"] == str(int(i)) and sorting_dict[key]["signal_dB"] == str(int(j)) and sorting_dict[key]["noise_dB"] == str(int(k))): sorted_list.append(key) return sorted_list def clear_dict_values(self,dict): for key in dict: dict[key].clear() def get_folder_location_path(self,folder): program_path = os.path.dirname(sys.argv[0]) template_path = program_path + '\\' + folder return template_path class ExcelHandler(object): def __init__(self, workbook_name): self.wb_name = workbook_name self.wb_name_with_dt = self._creat_new_excel_from_template_with_name_and_datetime(workbook_name) self.wb = openpyxl.load_workbook(str(self.wb_name_with_dt)) self.template_info = {} self.template_indexes = {'TRIG_ONLY': 4, 'MP_mTRIG_sASR': 4 ,'LJ_sTRIG_mASR' : 4} self.sheet_MP = None self.sheet_trig_only = None self.sheet_LJ_sTRIG_mASR = None def run_log_printing_LJ_sTRIG_mASR(self,log_dict): ''' for 'LJ_sTRIG_mASR' SHEET TEMPLATE''' asr_section = log_dict['asr_results_dict'] trig_section = log_dict['trig_results_dict_format'] if self.sheet_LJ_sTRIG_mASR is None: self.sheet_LJ_sTRIG_mASR = self._open_sheet('LJ_sTRIG_mASR') ROW = self.template_indexes['LJ_sTRIG_mASR'] ''' printing header section''' self._write_line_to_excel_sheet(self.sheet_LJ_sTRIG_mASR, ROW, 1, log_dict,EXCEL_LJ_sTRIG_mASR_TEMPLATE_HEADER_SECTION) ''' printing trig section''' self._write_line_to_excel_sheet(self.sheet_LJ_sTRIG_mASR,ROW,27,trig_section,EXCEL_LJ_sTRIG_mASR_TEMPLATE_TRIG_SECTION) ''' printing asr section''' cmd_template_order = ['volume_down' , 'volume_up' , 'next_song', 'pause' , 'resume', 'what_distance_have_i_done'] cmd_template_dict = {'volume_down': 'empty1.wav' , 'volume_up' : 'empty2.wav' , 'next_song' : 'empty3.wav', 'pause' : 'empty4.wav', 'resume' : 'empty5.wav' , 'what_distance_have_i_done' : 'empty6.wav'} for command in cmd_template_order: curr_key = cmd_template_dict[command] if curr_key in asr_section.keys(): curr_cmd_dict = asr_section[curr_key] self._write_line_to_excel_sheet(self.sheet_LJ_sTRIG_mASR, ROW, 10, curr_cmd_dict, EXCEL_LJ_sTRIG_mASR_TEMPLATE_ASR_SECTION) else: pass ROW += 1 self.template_indexes['LJ_sTRIG_mASR']+=6 def run_log_printing_TRIG_ONLY(self,log_dict,exl_tab_name): ''' for 'TRIG_ONLY' SHEET TEMPLATE''' if self.sheet_trig_only is None: self.sheet_trig_only = self._open_sheet(exl_tab_name) ROW = self.template_indexes[exl_tab_name] self._write_line_to_excel_sheet(self.sheet_trig_only,ROW,1,log_dict,EXCEL_TRIG_TEMPLATE_TUPLE) self.template_indexes[exl_tab_name] += 1 def run_log_printing_TRIG_ASR_MP(self,log_dict): ''' for 'MP_mTrig_sASR' SHEET TEMPLATE''' if self.sheet_MP is None: self.sheet_MP = self._open_sheet("MP_mTRIG_sASR") ROW = self.template_indexes["MP_mTRIG_sASR"] self._write_line_to_excel_sheet(self.sheet_MP,ROW,1,log_dict,EXCEL_MP_CMD_TEMPLATE) self.template_indexes['MP_mTRIG_sASR']+=1 def get_new_wb_name(self): return self.wb_name_with_dt def _creat_new_excel_from_template_with_name_and_datetime(self,project_name): program_path = os.path.dirname(sys.argv[0]) template_path = program_path + '\\template\exl.xlsx' shutil.copy2(str(template_path), str(program_path)) date_time = datetime.datetime.strftime(datetime.datetime.now(), '_%Y-%m-%d__%H_%M_%S') exl_file_name = str(project_name) + str(date_time) + ".xlsx" os.rename("exl.xlsx", str(exl_file_name)) return str(exl_file_name) def _write_line_to_excel_sheet(self,sheet,row,column,val_dict,template_list): row = str(row) start_col = column for i, key in enumerate(template_list): col = self._num_to_excel_alphabeit_colms(i+start_col) try: # sheet[col + row] = str(val_dict[key]) sheet[col + row] = val_dict[key] except : print key def _open_sheet(self,sheet_name): sheet = self.wb.get_sheet_by_name(sheet_name) return sheet def _num_to_excel_alphabeit_colms(self,index_num): cal1 = index_num % 27 cal2 = index_num // 26 new = index_num - cal2 * 26 if new == 0: new = 26 cal2 -= 1 if cal2: mychar = chr(cal2 + 64) + chr(new + 64) else: mychar = chr(index_num + 64) return mychar def save_workbook(self): self.wb.save(str(self.wb_name_with_dt))

noreply@github.com

c45e6ce9c846d77c6611d7c5fa1d641c22336a01

4b8c81f54cc52e096ad9ae751f00e88254aab0ca

/20-01-21 while홀.py

631fadc6b7eb53e75d2df8df8fc563a8e1db0e4e

no_license

dlatpdbs/python

50305cfcc92bb6c9bae409ec31ebd9e4aa868075

2f740941fe1ef172d40cb10a63c1ed19c5925e68

refs/heads/main

UTF-8

Python

py

q=1 while q <=100: print(q) q=q+2

noreply@github.com

9abb3baada0faed6fe83d3c15b41aa7c7958cb80

2f98aa7e5bfc2fc5ef25e4d5cfa1d7802e3a7fae

/python/python_27357.py

1163c19de3fb005d7b6fa68a6a453f6f2e63147f

no_license

AK-1121/code_extraction

cc812b6832b112e3ffcc2bb7eb4237fd85c88c01

5297a4a3aab3bb37efa24a89636935da04a1f8b6

refs/heads/master

UTF-8

Python

py

# pyplot.savefig with empty export plt.show()

ubuntu@ip-172-31-7-228.us-west-2.compute.internal

c7a6bbfb9e4f4606a0720e7f9c0efa56e7d90f30

b22588340d7925b614a735bbbde1b351ad657ffc

/athena/DataQuality/DataQualityConfigurations/python/TCTDisplay.py

6fa11e45427f043ea1f2b19da409200372d1fc14

no_license

rushioda/PIXELVALID_athena

90befe12042c1249cbb3655dde1428bb9b9a42ce

22df23187ef85e9c3120122c8375ea0e7d8ea440

refs/heads/master

UTF-8

Python

py

# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration from DataQualityUtils.DQWebDisplayConfig import DQWebDisplayConfig dqconfig = DQWebDisplayConfig() dqconfig.config = "TCT" dqconfig.hcfg = "/afs/cern.ch/user/a/atlasdqm/dqmdisk/tier0/han_config/Collisions/collisions_run.1.41.hcfg" dqconfig.hcfg_min10 = "/afs/cern.ch/user/a/atlasdqm/dqmdisk/tier0/han_config/Collisions/collisions_minutes10.1.9.hcfg" dqconfig.hcfg_min30 = "/afs/cern.ch/user/a/atlasdqm/dqmdisk/tier0/han_config/Collisions/collisions_minutes30.1.5.hcfg" dqconfig.hanResultsDir = "/afs/cern.ch/atlas/offline/external/FullChainTest/tier0/dqm/han_results" dqconfig.htmlDir = "/afs/cern.ch/atlas/offline/external/FullChainTest/tier0/dqm/www" dqconfig.htmlWeb = "http://atlas-project-fullchaintest.web.cern.ch/atlas-project-FullChainTest/tier0/dqm/www" dqconfig.runlist = "runlist_TCT.xml" dqconfig.indexFile = "results_TCT.html" dqconfig.lockFile = "DQWebDisplay_TCT.lock" dqconfig.dbConnection = "sqlite://;schema=MyCOOL_histo.db;dbname=OFLP200" dqconfig.dqmfOfl = "/GLOBAL/DETSTATUS/DQMFOFL" dqconfig.dbConnectionHisto = "sqlite://;schema=MyCOOL_histo.db;dbname=OFLP200" dqconfig.dqmfOflHisto = "/GLOBAL/DETSTATUS/DQMFOFLH" dqconfig.dbTagName = "DetStatusDQMFOFL-TCT"

rushioda@lxplus754.cern.ch

1533905896294b79dff04e1b69b2cda7c0496874

fa1dc1d0d2a169326c97dab863e15403bbd6bdbd

/CS486-686_A2Q2ANN.py

c52223b2857731732b02c8b7a75ccd93868316f2

permissive

mojivalipour/nnscratch

f07b893f7ac9792f5c9bb8e8ca5c664e392b6786

5e0b7f100d1057fab2c166df5696163634acd726

refs/heads/master

UTF-8

Python

py

#!/usr/bin/env python # coding: utf-8 # Design and Programming by Lead TA: Mojtaba Valipour @ Data Analytics Lab - UWaterloo.ca # COURSE: CS 486/686 - Artificial Intelligence - University of Waterloo - Spring 2020 - Alice Gao # Please let me know if you find any bugs in the code: m5valipo@uwaterloo.ca # The code will be available at https://github.com/mojivalipour/nnscratch # Version: 0.9.0 # Implement a neural network from scratch ''' Sources: - http://neuralnetworksanddeeplearning.com/chap2.html ''' print('Life is easy, you just need to do your best to find your place!') # Libraries import numpy as np import matplotlib.pyplot as plt from tqdm import tqdm from sklearn import datasets from sklearn.manifold import TSNE # visualization for data with more than two features from os import path import pandas as pd import csv import copy import random # Helper functions def fixSeed(seed=1010): np.random.seed(seed) random.seed(seed) # The hyper-parameters for the neural network nSamples = None # use None if you want to use full sample size # frogsSmall is the same dataset in Q1 that you have to use for comparision dataset = '2moons' # 2moons/frogsSmall/frogs noise = 0.05 # Noise in artificial datasets visNumSamples = 500 # number of samples to visualize # for regression, we use mean squared error. # for classification, we use cross entropy. # for now only mse is supported! lossFunction = 'mse' gdMethod = 'batch' # batch gradient descent method batchSize = 64 # only for minibatch gradient descent numEpochs = 200 # number of epochs learningRate = [0.5,0.05,0.005] # learning rates # for now only relu and sigmoid is supported lastActivationFunc = 'sigmoid' # relu/sigmoid/softmax # last layer activation function, this one is important # because we need to use it for classification later crossValidationFlag = True # if you like to run cross validation, set this flag to True kFold = 3 # k-fold cross validation, at least need to be 2 seed = 6565 # Do not change the seed for Assignment fixSeed(seed=seed) # fix the seed of random generator to make sure comparision is possible # Some Useful Notes for those students who are interested to know more: ''' - Neural networks are prone to overfitting. Increasing the number of parameters could lead to models that have complexity bigger than data. - Regularization, Normalization and Dropout are popular solutions to overfitting! - In a neural network, we usually use the softmax function as last layer activation for multi-class classification and sigmoid for single class classification. - For regression problems, we usually use Relu as last layer activation function and MSE as the loss function that we want to minimize. - Cross-entropy is the most useful loss function for multi-class classification. - Sometimes we need to use multiple neurons in the output layer, which means that we consider a neuron for each class. In this case, we need to use one-hot vectors to encode the labels. - Weight initialization is important! Gradient descent is not robust to weight initialization! Xavier initialization is the most popular method to initialize weights in neural networks. ''' # Load data colorBox = ['#377eb8','#FA0000','#344AA7', '#1EFA39','#00FBFF','#C500FF','#000000','#FFB600'] if dataset == '2moons': nSamples = 1000 if nSamples is None else nSamples X,y = datasets.make_moons(n_samples=nSamples, noise=noise, random_state=seed) numSamples, numFeatures, numClasses = X.shape[0], X.shape[1], 2 # shuffle X,y idxList = list(range(nSamples)) random.shuffle(idxList) # inplace X, y = X[idxList,:], y[idxList] elif dataset == 'frogsSmall' or dataset == 'frogs': if dataset == 'frogs': # original dataset name = 'Frogs_MFCCs.csv' else: # a small subset of frogs original dataset, same as A2Q1 name = 'frogs-small.csv' # check if we already have the file in the directory if not path.isfile(name): # otherwise ask user to upload it print("Please put this {} file in the current directory using choose files ...".format(name)) # just load the csv file X = pd.read_csv(name, sep=',') X["Family"] = X["Family"].astype('category') X["FamilyCat"] = X["Family"].cat.codes # added to the last column X, y = X.iloc[:,0:22].to_numpy(), X.iloc[:,-1].to_numpy() nSamples = X.shape[0] if nSamples is None else nSamples X, y = X[:nSamples,:], y[:nSamples] # filter number of samples numSamples, numFeatures, numClasses = X.shape[0], X.shape[1], len(np.unique(y)) print('#INFO: N (Number of Samples): {}, D (Number of Features): {}, C (Number of Classes): {}'.format(numSamples, numFeatures, numClasses)) plt.figure() # if y min is not zero, make it zero y = y - y.min() assert y.min() == 0 # sample required sample for visualization indices = list(range(numSamples)) selectedIndices = np.random.choice(indices, visNumSamples) colors = [colorBox[y[idx]] for idx in selectedIndices] if numFeatures == 2: XR = X[selectedIndices, :] else: # use tsne to reduce dimensionality for visualization XR = TSNE(n_components=2).fit_transform(X[selectedIndices,:]) plt.scatter(XR[:, 0], XR[:, 1], s=10, color=colors) plt.savefig('dataset.png') if len(y.shape) < 2: y = np.expand_dims(y,-1) # shape of y should be N x 1 # Define the network structure # # 2-Layer Network # config = { # # Layer Name: [Number of Nodes (in and out), Bias, Activation Function] # 'Hidden Layer 0': [[numFeatures, 30], True, 'relu'], # w1 # 'Fully Connected': [[30, 1], True, lastActivationFunc] # w2 # } # overfit network example config = { # Layer Name: [Number of Nodes (in and out), Bias, Activation Function] 'Hidden Layer 0': [[numFeatures, 1000], True, 'sigmoid'], # w1 'Fully Connected': [[1000, 1], True, lastActivationFunc] # w2 } # 3-Layer Network # config = { # # Layer Name: [Number of Nodes (in and out), Bias, Activation Function] # 'Hidden Layer 0': [[numFeatures, 3], True, 'sigmoid'], # w1 # 'Hidden Layer 1': [[3, 5], True, 'sigmoid'], # w2 # 'Fully Connected': [[5, 1], True, lastActivationFunc] # w2 # } # 4-layer Network # config = { # # Layer Name: [Number of Nodes (in and out), Bias, Activation Function] # 'Hidden Layer 0': [[numFeatures, 100], True, 'relu'], # w1 # 'Hidden Layer 1': [[100, 50], True, 'relu'], # w2 # 'Hidden Layer 2': [[50, 5], True, 'relu'], # w3 # 'Fully Connected': [[5, 1], True, lastActivationFunc] # w4 # } # Fully Connected Neural Network Class class neuralNetwork(): # initializing network def __init__(self, config=None, numClass=2, learningRate=0.005, numEpochs=10, batchSize= 64, lossFunction='mse'): self.config = config self.configKeyList = list(self.config.keys()) self.lossFunction = lossFunction self.numLayers = len(self.config) self.layers = {} self.layerShapes = {} self.learningRate = learningRate self.numEpochs = numEpochs self.loss = [] self.lossT = [] self.acc = [] self.accT = [] self.batchSize = batchSize self.numClass = numClass self.initWeights() # random init def initWeights(self): self.loss = [] self.lossT = [] self.acc = [] self.accT = [] if self.config != None: for key in config: # w is parameters, b is bias, a is activation function self.layers[key] = {'W':np.random.randn(self.config[key][0][0], self.config[key][0][1])/np.sqrt(self.config[key][0][1]), 'b':np.random.randn(self.config[key][0][1], ) if self.config[key][1]==True else [], 'a':self.config[key][2]} # keep track of shape only for better understanding self.layerShapes[key] = {'IS':self.config[key][0][0],'OS':self.config[key][0][1], 'NP':np.prod(self.layers[key]['W'].shape)+len(self.layers[key]['b'])} else: raise '#Err: Make sure you set a configuration correctly!' # activation functions def relu(self, X): return np.maximum(0, X) def sigmoid(self, X): #TODO: fix the overflow problem in Numpy exp function return 1./(1. + np.exp(-X)) def activationFunc(self, X, type='sigmoid'): if type == 'sigmoid': return self.sigmoid(X) elif type == 'relu': return self.relu(X) elif type == 'None': return X # do nothing else: raise '#Err: Not implemented activation function!' # objective/loss/cost functions def mse(self, y, yPred): # mean square error return np.mean(np.power(y-yPred,2)) def lossFunc(self, y, yPred, type='mse'): if type == 'mse': return self.mse(y, yPred) else: raise '#Err: Not implemented objective function!' # back-propagation learning # forward pass def forward(self, X): # apply a(W.T x X + b) for each layer for key in config: #print(X.shape, self.layers[key]['W'].shape) # save input of each layer for backward pass self.layers[key]['i'] = X z = np.dot(X, self.layers[key]['W']) z = z + self.layers[key]['b'] if len(self.layers[key]['b'])!=0 else z # save middle calculation for backward pass self.layers[key]['z'] = z X = self.activationFunc(z, type=self.layers[key]['a']) # save middle calculation for backward pass self.layers[key]['o'] = X return X # yPred # backward pass def backward(self, y, yPred): # derivative of sigmoid def sigmoidPrime(x): return self.sigmoid(x) * (1-self.sigmoid(x)) # derivative of relu def reluPrime(x): return np.where(x <= 0, 0, 1) def identity(x): return x #TODO: It's not necessary to use double for, # it is possible to implement faster and more efficient version # for each parameter (weights and bias) in each layer for idx, key in enumerate(config): # calculate derivatives if self.layers[key]['a'] == 'sigmoid': fPrime = sigmoidPrime elif self.layers[key]['a'] == 'relu': fPrime = reluPrime elif self.layers[key]['a'] == 'softmax': fPrime = softmaxPrime else: # None fPrime = identity deWRTdyPred = -(y-yPred) if self.lossFunction == 'mse' else 1 # de/dyPred # print('de/dy') # dyPred/dyPredBeforeActivation # in case of sigmoid g(x) x (1-g(x)) dyPredWRTdyPredPre = fPrime(self.layers[self.configKeyList[-1]]['o']) # print('dy/dz') # element wise multiplication/ hadamard product delta = np.multiply(deWRTdyPred, dyPredWRTdyPredPre) for idxW in range(len(config),idx,-1): # reverse if idxW-1 == idx: # calculating the derivative for the last one is different # because it is respected to that specific weight #print('\nWeights of layer',idx) deltaB = delta dxWRTdW = self.layers[key]['i'].T # dxWRTdW delta = np.dot(dxWRTdW,delta) #print('dz/dw') else: # this loop is depended to the number of layers in the configuration # print('\nWeights of layer',idxW-1) # the weights of current layer # how fast the cost is changing as a function of the output activation dxWRTdh = self.layers[self.configKeyList[idxW-1]]['W'].T # dxPreWRTdx-1 # print('dz/da') # print('output of layer',idxW-1-1) # the output of previous layer # how fast the activation function is changing dhWRTdhPre = fPrime(self.layers[self.configKeyList[idxW-1-1]]['o']) # dx-1WRTdx-1Pre # print('da/dz') delta = np.dot(delta, dxWRTdh) * dhWRTdhPre # sanity check: Numerical Gradient Checking # f'(x) = lim (f(x+deltax)-f(x))/deltax when deltax -> 0 # update parameters # W = W - Gamma * dL/dW self.layers[key]['djWRTdw'] = delta self.layers[key]['W'] = self.layers[key]['W'] - self.learningRate/y.shape[0] * delta # b = b - Gamma * dL/db self.layers[key]['djWRTdb'] = deltaB if len(self.layers[key]['b'])!=0: self.layers[key]['b'] = self.layers[key]['b'] - self.learningRate/y.shape[0] * np.sum(deltaB, axis=0) # Utility Functions def summary(self, space=20): print('{: <{}} | {: <{}} | {: <{}} | {: <{}}'.format("Layer Name", space, "Input Shape", space, "Output Shape", space, "Number of Parameters",space)) for key in config: print('{: <{}} | {: <{}} | {: <{}} | {: <{}}'.format(key, space, self.layerShapes[key]['IS'], space, self.layerShapes[key]['OS'], space, self.layerShapes[key]['NP'], space)) def fit(self, X, y, XT=None, yT=None, method='batch', batchSize=None, numEpochs=None, learningRate=None, initialState=None): if numEpochs is None: # overwrite numEpochs = self.numEpochs if learningRate is not None: self.learningRate = learningRate if batchSize is not None: self.batchSize = batchSize # if initialState is not None: # # use the given initial parameters (weights and bias) # self.layers = initialState if method == 'batch': # this is infact mini-batch gradient descent, just for consistency in course material # same as batched gradient descent in class to make it easier for you pBar = tqdm(range(numEpochs)) for edx in pBar: for idx in range(0, X.shape[0], self.batchSize): start = idx end = start + self.batchSize end = end if end < X.shape[0] else X.shape[0] #TODO: Support variable batchsize if end-start != self.batchSize: continue x_, y_ = X[start:end, :], y[start:end, :] yPred = self.forward(x_) loss = self.lossFunc(y_, yPred, type=self.lossFunction) self.backward(y_, yPred) yPred,yPredOrig = self.predict(X) loss = self.lossFunc(y, yPredOrig, type=self.lossFunction) self.loss.append(loss) acc = self.accuracy(y, yPred) self.acc.append(acc) if XT is not None: yPred, yPredOrig = self.predict(XT) loss = self.lossFunc(yT, yPredOrig, type=self.lossFunction) self.lossT.append(loss) acc = self.accuracy(yT, yPred) self.accT.append(acc) else: raise '#Err: {} Gradient Descent Method is Not implemented!'.format(method) def predict(self, X): yPred = self.forward(X) yPredOrigin = copy.deepcopy(yPred) # last layer activation function, class prediction should be single # and the output is between zero and one if self.config[self.configKeyList[-1]][-1] == 'sigmoid': yPred[yPred < 0.5] = 0 yPred[yPred >= 0.5] = 1 # multi-class problem elif self.config[self.configKeyList[-1]][-1] == 'softmax': raise '#Err: Prediction is not supported for softmax yet!' # single/multi class problem, single node and it can be anything greater than 0 elif self.config[self.configKeyList[-1]][-1] == 'relu': yPred = np.round(yPred) yPred = np.clip(yPred, 0, self.numClass-1) # sanity check return yPred, yPredOrigin def error(self, y, yPred): return self.lossFunc(y, yPred, type=self.lossFunction) def accuracy(self, y, yPred): return 100*np.sum(y==yPred)/y.shape[0] def plotLoss(self, loss=None, ax=None): if loss is None: loss = self.loss if ax is None: plt.plot(loss) plt.xlabel("Epochs") plt.ylabel("Loss") plt.title("Loss Per Epoch") plt.show() else: ax.plot(loss) ax.set_xlabel("Epochs") ax.set_ylabel("Loss") ax.set_title("Loss Per Epoch") def crossValidationIndices(self, index, k=5): # index is a list of indexes cvList = [] for idx in range(k): # iterate over k-folds interval = int(len(index)/k) start = idx * interval end = start + interval testIndexes = list(range(start,end)) trainIndexes = list(range(0,start)) + list(range(end,len(index))) cvList.append((trainIndexes, testIndexes)) return cvList if crossValidationFlag: if len(learningRate) == 1: fig, ax = plt.subplots(3,len(learningRate),figsize=(8,15)) else: fig, ax = plt.subplots(3,len(learningRate),figsize=(30,3*(len(learningRate)+2))) else: fig, ax = plt.subplots(1,1+len(learningRate),figsize=(30,1+len(learningRate))) for ldx, lr in enumerate(learningRate): nn = neuralNetwork(config=config, numClass=numClasses, numEpochs=numEpochs, learningRate=lr, lossFunction=lossFunction) # Initialize the network and the weights nn.initWeights() if crossValidationFlag: indexes = list(range(X.shape[0])) cvIndices = nn.crossValidationIndices(indexes, k=kFold) accList = [] accTList = [] lossList = [] lossTList = [] for k in range(kFold): nn.initWeights() XTrain, yTrain = X[cvIndices[k][0],:], y[cvIndices[k][0],:] XTest, yTest = X[cvIndices[k][1],:], y[cvIndices[k][1],:] # Train the network nn.fit(XTrain, yTrain, XTest, yTest, method=gdMethod, batchSize=batchSize, numEpochs=numEpochs, learningRate=lr) accList.append(nn.acc) accTList.append(nn.accT) lossList.append(nn.loss) lossTList.append(nn.lossT) acc = np.mean(accList, axis=0) accT = np.mean(accTList, axis=0) loss = np.mean(lossList, axis=0) lossT = np.mean(lossTList, axis=0) # print the network structure nn.summary() yPred, yPredOrig = nn.predict(X) print('#INFO: Mean squared error is {}'.format(nn.error(y,yPred))) colors = [colorBox[int(yPred[idx])] for idx in selectedIndices] if len(learningRate) == 1: ax[2].scatter(XR[:, 0], XR[:, 1], s=10, color=colors) ax[2].set_xlabel("X1") ax[2].set_ylabel("X2") ax[2].set_title("Data, LR: {}".format(lr)) ax[0].plot(acc) ax[0].plot(accT) ax[0].legend(['Train','Test']) ax[0].set_xlabel("Epochs") ax[0].set_ylabel("Accuracy") ax[0].set_title("Accuracy Per Epoch"+", LR: {}".format(lr)) ax[1].plot(loss) ax[1].plot(lossT) ax[1].legend(['Train','Test']) ax[1].set_xlabel("Epochs") ax[1].set_ylabel("Loss") ax[1].set_title("Loss Per Epoch"+", LR: {}".format(lr)) else: ax[2,ldx].scatter(XR[:, 0], XR[:, 1], s=10, color=colors) ax[2,ldx].set_xlabel("X1") ax[2,ldx].set_ylabel("X2") ax[2,ldx].set_title("Data, LR: {}".format(lr)) ax[0,ldx].plot(acc) ax[0,ldx].plot(accT) ax[0,ldx].legend(['Train','Test']) ax[0,ldx].set_xlabel("Epochs") ax[0,ldx].set_ylabel("Accuracy") ax[0,ldx].set_title("Accuracy Per Epoch"+", LR: {}".format(lr)) ax[1,ldx].plot(loss) ax[1,ldx].plot(lossT) ax[1,ldx].legend(['Train','Test']) ax[1,ldx].set_xlabel("Epochs") ax[1,ldx].set_ylabel("Loss") ax[1,ldx].set_title("Loss Per Epoch"+", LR: {}".format(lr)) else: # Perform a single run for visualization. nn.fit(X, y, method=gdMethod, batchSize=batchSize, numEpochs=numEpochs, learningRate=lr) # print the network structure nn.summary() yPred, yPredOrig = nn.predict(X) print('#INFO: Mean squared error is {}'.format(nn.error(y,yPred))) colors = [colorBox[int(yPred[idx])] for idx in selectedIndices] ax[ldx+1].scatter(XR[:, 0], XR[:, 1], s=10, color=colors) ax[ldx+1].set_xlabel("X1") ax[ldx+1].set_ylabel("X2") ax[ldx+1].set_title("LR: {}".format(lr)) # Plot the mean squared error with respect to the nu nn.plotLoss(ax=ax[0]) # train accuracy acc = nn.accuracy(y.squeeze(-1),yPred.squeeze(-1)) print('#INFO: Train Accuracy is {}'.format(acc)) if not crossValidationFlag: ax[0].legend(["LR: "+str(lr) for lr in learningRate]) # please feel free to save subplots for a better report fig.savefig('results.png')

noreply@github.com

3b91d9f42ee1ecda8632567b35ac5caa51d497c7

35053a371d85c2d45a4f52239d8a70b38194ef48

/Count of Matches in Tournament.py

96c8b115113e1096f964d3dcc4f40e3f4b7f16a1

no_license

Kuehar/LeetCode

51d169c81a2e572ea854399fc78e1130220388f9

4555c20455f181f9dd7b3aba2a8779dea795edfb

refs/heads/master

UTF-8

Python

py

class Solution: def numberOfMatches(self, n: int) -> int: return n-1 # O(1) Solution. # Always this answer is n-1. Sum of matches are always equals to sum of loser. # Runtime: 28 ms, faster than 82.44% of Python3 online submissions for Count of Matches in Tournament. # Memory Usage: 14.3 MB, less than 40.04% of Python3 online submissions for Count of Matches in Tournament.

noreply@github.com

c37ff8cfcff227220d098069e2f3040dce7f56e8

9145d24e2517d7f3cea6e89158806b95919449b8

/doc/conf.py

37c50aca46644bd4ce262e466fa2696daa55957c

permissive

pombredanne/coveragepy

b6de846694156581ee0b9a3348f4cfd48719855f

2364947d7814a065cf2c05d930eda94203b20f1c

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 # For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt # # coverage.py documentation build configuration file, created by # sphinx-quickstart on Wed May 13 22:18:33 2009. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.append(os.path.abspath('.')) # on_rtd is whether we are on readthedocs.org on_rtd = os.environ.get('READTHEDOCS', None) == 'True' # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.ifconfig', 'sphinxcontrib.spelling', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # General information about the project. project = u'Coverage.py' copyright = u'2009\N{EN DASH}2017, Ned Batchelder' # CHANGEME # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '4.3.4' # CHANGEME # The full version, including alpha/beta/rc tags. release = '4.3.4' # CHANGEME # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = ['_build'] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. #html_theme = 'default' if not on_rtd: # only import and set the theme if we're building docs locally import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # otherwise, readthedocs.org uses their theme by default, so no need to specify it # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} #html_style = "neds.css" #html_add_permalinks = "" # Add any paths that contain custom themes here, relative to this directory. html_theme_path = ['_templates'] # The name for this set of Sphinx documents. If None, it defaults to # "<project> v<release> documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_use_modindex = False # If false, no index is generated. html_use_index = False # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, an OpenSearch description file will be output, and all pages will # contain a <link> tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '.htm' # Output file base name for HTML help builder. htmlhelp_basename = 'coveragepydoc' # -- Spelling --- spelling_word_list_filename = 'dict.txt' spelling_show_suggestions = False # When auto-doc'ing a class, write the class' docstring and the __init__ docstring # into the class docs. autoclass_content = "class" prerelease = bool(max(release).isalpha()) def setup(app): app.add_stylesheet('coverage.css') app.add_config_value('prerelease', False, 'env') app.info("** Prerelease = %r" % prerelease)

ned@nedbatchelder.com

875a564377d75822b6c87a33792ad8d32b40b7b6

a6e4a6f0a73d24a6ba957277899adbd9b84bd594

/sdk/python/pulumi_azure_native/datacatalog/outputs.py

26d9e4bddb4ce2d56c83f67f19a73cd325ca56ef

permissive

MisinformedDNA/pulumi-azure-native

9cbd75306e9c8f92abc25be3f73c113cb93865e9

de974fd984f7e98649951dbe80b4fc0603d03356

refs/heads/master

UTF-8

Python

py

# coding=utf-8 # *** WARNING: this file was generated by the Pulumi SDK Generator. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union from .. import _utilities, _tables from ._enums import * __all__ = [ 'PrincipalsResponse', ] @pulumi.output_type class PrincipalsResponse(dict): """ User principals. """ def __init__(__self__, *, object_id: Optional[str] = None, upn: Optional[str] = None): """ User principals. :param str object_id: Object Id for the user :param str upn: UPN of the user. """ if object_id is not None: pulumi.set(__self__, "object_id", object_id) if upn is not None: pulumi.set(__self__, "upn", upn) @property @pulumi.getter(name="objectId") def object_id(self) -> Optional[str]: """ Object Id for the user """ return pulumi.get(self, "object_id") @property @pulumi.getter def upn(self) -> Optional[str]: """ UPN of the user. """ return pulumi.get(self, "upn") def _translate_property(self, prop): return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop

noreply@github.com

69e2f645ab6431a303076a1506514f479e530747

9fc5dd13e0595bd5796cd7ec109e3b7c290e2692

/wikipedia-scape.py

a54f56c6c75b06d0d4069f56a187c27ded4d5b68

no_license

ronandoolan2/python-webscraping

812d5190dfe5f24029b4737438c80e8d40716971

4dc83a331415c3e55f06b1a8d0de47710db5ccd0

refs/heads/master

UTF-8

Python

py

from bs4 import BeautifulSoup import urllib2 import re wiki = "http://en.wikipedia.org/wiki/Mad_Max:_Fury_Road" header = {'User-Agent': 'Mozilla/5.0'} #Needed to prevent 403 error on Wikipedia req = urllib2.Request(wiki,headers=header) page = urllib2.urlopen(req) soup = BeautifulSoup(page) rnd = "" pick = "" NFL = "" player = "" pos = "" college = "" conf = "" notes = "" table = soup.find("table", { "class" : "wikitable sortable" }) print table #output = open('output.csv','w') for row in table.findAll("tr"): cells = row.findAll("href") for cell in cells: # search-term = re.search(r'director',cell) # if search-term: # print search-term #print "---" print cell.text print cells.text #print "---"

noreply@github.com

6ac793e3b8df59989fc5a148e4385b6fe3b6ed70

dbab24ee5055dad1a57bb212ae30da994022eab5

/Python/Chapter 6 - tehtävä 3.py

4703757b6f12df00e86114119c5ffd8b7220709e

no_license

MikBom/mikbom-github.io

e8ab24080a6c6383f4ad973a817e10ab84375e4f

3dc7312798473a7620529d24fa771d5b09bafbbc

refs/heads/main

UTF-8

Python

py

vari = input("Valitse kohde (1-3):") if vari == "1": print("Haukion Kala Oy") elif vari == "2": print("Metallipaja VasaraAika") elif vari == "3": print("Balin palapelitehdas")

noreply@github.com

1aeaca94f2d4d9feb9733db3c8cad22d7ff94e80

cf5b2850dc9794eb0fc11826da4fd3ea6c22e9b1

/examples/conditional_format.py

868eec6890126a075a32371064be80ab9628e826

permissive

glasah/XlsxWriter

bcf74b43b9c114e45e1a3dd679b5ab49ee20a0ec

1e8aaeb03000dc2f294ccb89b33806ac40dabc13

refs/heads/main

UTF-8

Python

py

############################################################################### # # Example of how to add conditional formatting to an XlsxWriter file. # # Conditional formatting allows you to apply a format to a cell or a # range of cells based on certain criteria. # # SPDX-License-Identifier: BSD-2-Clause # Copyright 2013-2021, John McNamara, jmcnamara@cpan.org # import xlsxwriter workbook = xlsxwriter.Workbook('conditional_format.xlsx') worksheet1 = workbook.add_worksheet() worksheet2 = workbook.add_worksheet() worksheet3 = workbook.add_worksheet() worksheet4 = workbook.add_worksheet() worksheet5 = workbook.add_worksheet() worksheet6 = workbook.add_worksheet() worksheet7 = workbook.add_worksheet() worksheet8 = workbook.add_worksheet() worksheet9 = workbook.add_worksheet() # Add a format. Light red fill with dark red text. format1 = workbook.add_format({'bg_color': '#FFC7CE', 'font_color': '#9C0006'}) # Add a format. Green fill with dark green text. format2 = workbook.add_format({'bg_color': '#C6EFCE', 'font_color': '#006100'}) # Some sample data to run the conditional formatting against. data = [ [34, 72, 38, 30, 75, 48, 75, 66, 84, 86], [6, 24, 1, 84, 54, 62, 60, 3, 26, 59], [28, 79, 97, 13, 85, 93, 93, 22, 5, 14], [27, 71, 40, 17, 18, 79, 90, 93, 29, 47], [88, 25, 33, 23, 67, 1, 59, 79, 47, 36], [24, 100, 20, 88, 29, 33, 38, 54, 54, 88], [6, 57, 88, 28, 10, 26, 37, 7, 41, 48], [52, 78, 1, 96, 26, 45, 47, 33, 96, 36], [60, 54, 81, 66, 81, 90, 80, 93, 12, 55], [70, 5, 46, 14, 71, 19, 66, 36, 41, 21], ] ############################################################################### # # Example 1. # caption = ('Cells with values >= 50 are in light red. ' 'Values < 50 are in light green.') # Write the data. worksheet1.write('A1', caption) for row, row_data in enumerate(data): worksheet1.write_row(row + 2, 1, row_data) # Write a conditional format over a range. worksheet1.conditional_format('B3:K12', {'type': 'cell', 'criteria': '>=', 'value': 50, 'format': format1}) # Write another conditional format over the same range. worksheet1.conditional_format('B3:K12', {'type': 'cell', 'criteria': '<', 'value': 50, 'format': format2}) ############################################################################### # # Example 2. # caption = ('Values between 30 and 70 are in light red. ' 'Values outside that range are in light green.') worksheet2.write('A1', caption) for row, row_data in enumerate(data): worksheet2.write_row(row + 2, 1, row_data) worksheet2.conditional_format('B3:K12', {'type': 'cell', 'criteria': 'between', 'minimum': 30, 'maximum': 70, 'format': format1}) worksheet2.conditional_format('B3:K12', {'type': 'cell', 'criteria': 'not between', 'minimum': 30, 'maximum': 70, 'format': format2}) ############################################################################### # # Example 3. # caption = ('Duplicate values are in light red. ' 'Unique values are in light green.') worksheet3.write('A1', caption) for row, row_data in enumerate(data): worksheet3.write_row(row + 2, 1, row_data) worksheet3.conditional_format('B3:K12', {'type': 'duplicate', 'format': format1}) worksheet3.conditional_format('B3:K12', {'type': 'unique', 'format': format2}) ############################################################################### # # Example 4. # caption = ('Above average values are in light red. ' 'Below average values are in light green.') worksheet4.write('A1', caption) for row, row_data in enumerate(data): worksheet4.write_row(row + 2, 1, row_data) worksheet4.conditional_format('B3:K12', {'type': 'average', 'criteria': 'above', 'format': format1}) worksheet4.conditional_format('B3:K12', {'type': 'average', 'criteria': 'below', 'format': format2}) ############################################################################### # # Example 5. # caption = ('Top 10 values are in light red. ' 'Bottom 10 values are in light green.') worksheet5.write('A1', caption) for row, row_data in enumerate(data): worksheet5.write_row(row + 2, 1, row_data) worksheet5.conditional_format('B3:K12', {'type': 'top', 'value': '10', 'format': format1}) worksheet5.conditional_format('B3:K12', {'type': 'bottom', 'value': '10', 'format': format2}) ############################################################################### # # Example 6. # caption = ('Cells with values >= 50 are in light red. ' 'Values < 50 are in light green. Non-contiguous ranges.') # Write the data. worksheet6.write('A1', caption) for row, row_data in enumerate(data): worksheet6.write_row(row + 2, 1, row_data) # Write a conditional format over a range. worksheet6.conditional_format('B3:K6', {'type': 'cell', 'criteria': '>=', 'value': 50, 'format': format1, 'multi_range': 'B3:K6 B9:K12'}) # Write another conditional format over the same range. worksheet6.conditional_format('B3:K6', {'type': 'cell', 'criteria': '<', 'value': 50, 'format': format2, 'multi_range': 'B3:K6 B9:K12'}) ############################################################################### # # Example 7. # caption = 'Examples of color scales with default and user colors.' data = range(1, 13) worksheet7.write('A1', caption) worksheet7.write('B2', "2 Color Scale") worksheet7.write('D2', "2 Color Scale + user colors") worksheet7.write('G2', "3 Color Scale") worksheet7.write('I2', "3 Color Scale + user colors") for row, row_data in enumerate(data): worksheet7.write(row + 2, 1, row_data) worksheet7.write(row + 2, 3, row_data) worksheet7.write(row + 2, 6, row_data) worksheet7.write(row + 2, 8, row_data) worksheet7.conditional_format('B3:B14', {'type': '2_color_scale'}) worksheet7.conditional_format('D3:D14', {'type': '2_color_scale', 'min_color': "#FF0000", 'max_color': "#00FF00"}) worksheet7.conditional_format('G3:G14', {'type': '3_color_scale'}) worksheet7.conditional_format('I3:I14', {'type': '3_color_scale', 'min_color': "#C5D9F1", 'mid_color': "#8DB4E3", 'max_color': "#538ED5"}) ############################################################################### # # Example 8. # caption = 'Examples of data bars.' worksheet8.write('A1', caption) worksheet8.write('B2', "Default data bars") worksheet8.write('D2', "Bars only") worksheet8.write('F2', "With user color") worksheet8.write('H2', "Solid bars") worksheet8.write('J2', "Right to left") worksheet8.write('L2', "Excel 2010 style") worksheet8.write('N2', "Negative same as positive") data = range(1, 13) for row, row_data in enumerate(data): worksheet8.write(row + 2, 1, row_data) worksheet8.write(row + 2, 3, row_data) worksheet8.write(row + 2, 5, row_data) worksheet8.write(row + 2, 7, row_data) worksheet8.write(row + 2, 9, row_data) data = [-1, -2, -3, -2, -1, 0, 1, 2, 3, 2, 1, 0] for row, row_data in enumerate(data): worksheet8.write(row + 2, 11, row_data) worksheet8.write(row + 2, 13, row_data) worksheet8.conditional_format('B3:B14', {'type': 'data_bar'}) worksheet8.conditional_format('D3:D14', {'type': 'data_bar', 'bar_only': True}) worksheet8.conditional_format('F3:F14', {'type': 'data_bar', 'bar_color': '#63C384'}) worksheet8.conditional_format('H3:H14', {'type': 'data_bar', 'bar_solid': True}) worksheet8.conditional_format('J3:J14', {'type': 'data_bar', 'bar_direction': 'right'}) worksheet8.conditional_format('L3:L14', {'type': 'data_bar', 'data_bar_2010': True}) worksheet8.conditional_format('N3:N14', {'type': 'data_bar', 'bar_negative_color_same': True, 'bar_negative_border_color_same': True}) ############################################################################### # # Example 9. # caption = 'Examples of conditional formats with icon sets.' data = [ [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], ] worksheet9.write('A1', caption) for row, row_data in enumerate(data): worksheet9.write_row(row + 2, 1, row_data) worksheet9.conditional_format('B3:D3', {'type': 'icon_set', 'icon_style': '3_traffic_lights'}) worksheet9.conditional_format('B4:D4', {'type': 'icon_set', 'icon_style': '3_traffic_lights', 'reverse_icons': True}) worksheet9.conditional_format('B5:D5', {'type': 'icon_set', 'icon_style': '3_traffic_lights', 'icons_only': True}) worksheet9.conditional_format('B6:D6', {'type': 'icon_set', 'icon_style': '3_arrows'}) worksheet9.conditional_format('B7:E7', {'type': 'icon_set', 'icon_style': '4_arrows'}) worksheet9.conditional_format('B8:F8', {'type': 'icon_set', 'icon_style': '5_arrows'}) worksheet9.conditional_format('B9:F9', {'type': 'icon_set', 'icon_style': '5_ratings'}) workbook.close()

jmcnamara@cpan.org

96f12a1ab1eb7f33d8ce8497a6de454ae5054716

12fe05ebba89ea0f11d6f5d2fd8f047ee6369ff6

/minmax3.py

c6f28978343f73c011e14f3c2fb0c7170c66fa0b

no_license

daniilvarlamov/domzad

d467c4b9f51a1a640b0b001216849131c2463500

69e1b4c6fa27dc4d17499cfc6817c97d90f8391a

refs/heads/main

UTF-8

Python

py

N = int(input("Введите количество прямоугольников") for i in range (N): a = int(input("Введите стороны прямоугольника") b = int(input()) P = 2*(a+b) if (i=1): Max = P if (P>Max): Max = P print(Max)

noreply@github.com

d35605db5bdf283207a2c171638328c4c8b53252

4e30d990963870478ed248567e432795f519e1cc

/tests/api/v3_1_1/test_nbar_app.py

13a1bcd9798917799871178339c1315dd3a03d61

permissive

CiscoISE/ciscoisesdk

84074a57bf1042a735e3fc6eb7876555150d2b51

f468c54998ec1ad85435ea28988922f0573bfee8

refs/heads/main

MIT

Python

UTF-8

Python

py

# -*- coding: utf-8 -*- """IdentityServicesEngineAPI nbar_app API fixtures and tests. Copyright (c) 2021 Cisco and/or its affiliates. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import pytest from fastjsonschema.exceptions import JsonSchemaException from ciscoisesdk.exceptions import MalformedRequest from ciscoisesdk.exceptions import ciscoisesdkException from tests.environment import IDENTITY_SERVICES_ENGINE_VERSION pytestmark = pytest.mark.skipif(IDENTITY_SERVICES_ENGINE_VERSION != '3.1.1', reason='version does not match') def is_valid_get_nbar_apps(json_schema_validate, obj): if not obj: return False assert hasattr(obj, 'headers') assert hasattr(obj, 'content') assert hasattr(obj, 'text') assert hasattr(obj, 'response') assert hasattr(obj, 'status_code') json_schema_validate('jsd_1e8a476ad8455fdebad0d8973c810495_v3_1_1').validate(obj.response) return True def get_nbar_apps(api): endpoint_result = api.nbar_app.get_nbar_apps( filter='value1,value2', filter_type='string', page=0, size=0, sort='string', sort_by='string' ) return endpoint_result @pytest.mark.nbar_app def test_get_nbar_apps(api, validator): try: assert is_valid_get_nbar_apps( validator, get_nbar_apps(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest)): print("ERROR: {error}".format(error=original_e)) raise original_e def get_nbar_apps_default(api): endpoint_result = api.nbar_app.get_nbar_apps( filter=None, filter_type=None, page=None, size=None, sort=None, sort_by=None ) return endpoint_result @pytest.mark.nbar_app def test_get_nbar_apps_default(api, validator): try: assert is_valid_get_nbar_apps( validator, get_nbar_apps_default(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest, TypeError)): raise original_e def is_valid_create_nbar_app(json_schema_validate, obj): if not obj: return False assert hasattr(obj, 'headers') assert hasattr(obj, 'content') assert hasattr(obj, 'text') assert hasattr(obj, 'response') assert hasattr(obj, 'status_code') json_schema_validate('jsd_ccc30178afce5e51a65e96cd95ca1773_v3_1_1').validate(obj.response) return True def create_nbar_app(api): endpoint_result = api.nbar_app.create_nbar_app( active_validation=False, description='string', id='string', name='string', network_identities=[{'ports': 'string', 'protocol': 'string'}], payload=None ) return endpoint_result @pytest.mark.nbar_app def test_create_nbar_app(api, validator): try: assert is_valid_create_nbar_app( validator, create_nbar_app(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest)): print("ERROR: {error}".format(error=original_e)) raise original_e def create_nbar_app_default(api): endpoint_result = api.nbar_app.create_nbar_app( active_validation=False, description=None, id=None, name=None, network_identities=None, payload=None ) return endpoint_result @pytest.mark.nbar_app def test_create_nbar_app_default(api, validator): try: assert is_valid_create_nbar_app( validator, create_nbar_app_default(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest, TypeError)): raise original_e def is_valid_get_nbar_app_by_id(json_schema_validate, obj): if not obj: return False assert hasattr(obj, 'headers') assert hasattr(obj, 'content') assert hasattr(obj, 'text') assert hasattr(obj, 'response') assert hasattr(obj, 'status_code') json_schema_validate('jsd_61e99726f3745554a07ee102f74fe3bd_v3_1_1').validate(obj.response) return True def get_nbar_app_by_id(api): endpoint_result = api.nbar_app.get_nbar_app_by_id( id='string' ) return endpoint_result @pytest.mark.nbar_app def test_get_nbar_app_by_id(api, validator): try: assert is_valid_get_nbar_app_by_id( validator, get_nbar_app_by_id(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest)): print("ERROR: {error}".format(error=original_e)) raise original_e def get_nbar_app_by_id_default(api): endpoint_result = api.nbar_app.get_nbar_app_by_id( id='string' ) return endpoint_result @pytest.mark.nbar_app def test_get_nbar_app_by_id_default(api, validator): try: assert is_valid_get_nbar_app_by_id( validator, get_nbar_app_by_id_default(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest, TypeError)): raise original_e def is_valid_update_nbar_app_by_id(json_schema_validate, obj): if not obj: return False assert hasattr(obj, 'headers') assert hasattr(obj, 'content') assert hasattr(obj, 'text') assert hasattr(obj, 'response') assert hasattr(obj, 'status_code') json_schema_validate('jsd_b55622f1671359919573b261ba16ea71_v3_1_1').validate(obj.response) return True def update_nbar_app_by_id(api): endpoint_result = api.nbar_app.update_nbar_app_by_id( active_validation=False, description='string', id='string', name='string', network_identities=[{'ports': 'string', 'protocol': 'string'}], payload=None ) return endpoint_result @pytest.mark.nbar_app def test_update_nbar_app_by_id(api, validator): try: assert is_valid_update_nbar_app_by_id( validator, update_nbar_app_by_id(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest)): print("ERROR: {error}".format(error=original_e)) raise original_e def update_nbar_app_by_id_default(api): endpoint_result = api.nbar_app.update_nbar_app_by_id( active_validation=False, id='string', description=None, name=None, network_identities=None, payload=None ) return endpoint_result @pytest.mark.nbar_app def test_update_nbar_app_by_id_default(api, validator): try: assert is_valid_update_nbar_app_by_id( validator, update_nbar_app_by_id_default(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest, TypeError)): raise original_e def is_valid_delete_nbar_app_by_id(json_schema_validate, obj): if not obj: return False assert hasattr(obj, 'headers') assert hasattr(obj, 'content') assert hasattr(obj, 'text') assert hasattr(obj, 'response') assert hasattr(obj, 'status_code') json_schema_validate('jsd_44d289d5685350f5b00f130db0a45142_v3_1_1').validate(obj.response) return True def delete_nbar_app_by_id(api): endpoint_result = api.nbar_app.delete_nbar_app_by_id( id='string' ) return endpoint_result @pytest.mark.nbar_app def test_delete_nbar_app_by_id(api, validator): try: assert is_valid_delete_nbar_app_by_id( validator, delete_nbar_app_by_id(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest)): print("ERROR: {error}".format(error=original_e)) raise original_e def delete_nbar_app_by_id_default(api): endpoint_result = api.nbar_app.delete_nbar_app_by_id( id='string' ) return endpoint_result @pytest.mark.nbar_app def test_delete_nbar_app_by_id_default(api, validator): try: assert is_valid_delete_nbar_app_by_id( validator, delete_nbar_app_by_id_default(api) ) except Exception as original_e: with pytest.raises((JsonSchemaException, MalformedRequest, TypeError)): raise original_e

wastorga@altus.co.cr

8cb3d749f4466525d40f270c8a048fd83397d6b0

e25e7f0d944d302c2fd13b7517d97c5e0b5558ec

/FixTree_TBCNN/pycparser/c_parser.py

9a9d09657ad6d9acb7465f692d2e3c1c7d25ba04

no_license

NizhenJenny/FixTree

06702a0d529d861e34b045aac286434b0ce3d86f

be30a2cdeb6cc0aa13f29d2cd4d4ce325f00f2a0

refs/heads/master

UTF-8

Python

py

#------------------------------------------------------------------------------ # pycparser: c_parser.py # # CParser class: Parser and AST builder for the C language # # Copyright (C) 2008-2015, Eli Bendersky # License: BSD #------------------------------------------------------------------------------ import re from .ply import yacc from . import c_ast from .c_lexer import CLexer from .plyparser import PLYParser, Coord, ParseError from .ast_transforms import fix_switch_cases class CParser(PLYParser): def __init__( self, lex_optimize=True, lextab='pycparser.lextab', yacc_optimize=True, yacctab='pycparser.yacctab', yacc_debug=False, taboutputdir=''): """ Create a new CParser. Some arguments for controlling the debug/optimization level of the parser are provided. The defaults are tuned for release/performance mode. The simple rules for using them are: *) When tweaking CParser/CLexer, set these to False *) When releasing a stable parser, set to True lex_optimize: Set to False when you're modifying the lexer. Otherwise, changes in the lexer won't be used, if some lextab.py file exists. When releasing with a stable lexer, set to True to save the re-generation of the lexer table on each run. lextab: Points to the lex table that's used for optimized mode. Only if you're modifying the lexer and want some tests to avoid re-generating the table, make this point to a local lex table file (that's been earlier generated with lex_optimize=True) yacc_optimize: Set to False when you're modifying the parser. Otherwise, changes in the parser won't be used, if some parsetab.py file exists. When releasing with a stable parser, set to True to save the re-generation of the parser table on each run. yacctab: Points to the yacc table that's used for optimized mode. Only if you're modifying the parser, make this point to a local yacc table file yacc_debug: Generate a parser.out file that explains how yacc built the parsing table from the grammar. taboutputdir: Set this parameter to control the location of generated lextab and yacctab files. """ self.clex = CLexer( error_func=self._lex_error_func, on_lbrace_func=self._lex_on_lbrace_func, on_rbrace_func=self._lex_on_rbrace_func, type_lookup_func=self._lex_type_lookup_func) self.clex.build( optimize=lex_optimize, lextab=lextab, outputdir=taboutputdir) self.tokens = self.clex.tokens rules_with_opt = [ 'abstract_declarator', 'assignment_expression', 'declaration_list', 'declaration_specifiers', 'designation', 'expression', 'identifier_list', 'init_declarator_list', 'initializer_list', 'parameter_type_list', 'specifier_qualifier_list', 'block_item_list', 'type_qualifier_list', 'struct_declarator_list' ] for rule in rules_with_opt: self._create_opt_rule(rule) self.cparser = yacc.yacc( module=self, start='translation_unit_or_empty', debug=yacc_debug, optimize=yacc_optimize, tabmodule=yacctab, outputdir=taboutputdir) # Stack of scopes for keeping track of symbols. _scope_stack[-1] is # the current (topmost) scope. Each scope is a dictionary that # specifies whether a name is a type. If _scope_stack[n][name] is # True, 'name' is currently a type in the scope. If it's False, # 'name' is used in the scope but not as a type (for instance, if we # saw: int name; # If 'name' is not a key in _scope_stack[n] then 'name' was not defined # in this scope at all. self._scope_stack = [dict()] # Keeps track of the last token given to yacc (the lookahead token) self._last_yielded_token = None def parse(self, text, filename='', debuglevel=0): """ Parses C code and returns an AST. text: A string containing the C source code filename: Name of the file being parsed (for meaningful error messages) debuglevel: Debug level to yacc """ self.clex.filename = filename self.clex.reset_lineno() self._scope_stack = [dict()] self._last_yielded_token = None return self.cparser.parse( input=text, lexer=self.clex, debug=debuglevel) ######################-- PRIVATE --###################### def _push_scope(self): self._scope_stack.append(dict()) def _pop_scope(self): assert len(self._scope_stack) > 1 self._scope_stack.pop() def _add_typedef_name(self, name, coord): """ Add a new typedef name (ie a TYPEID) to the current scope """ if not self._scope_stack[-1].get(name, True): self._parse_error( "Typedef %r previously declared as non-typedef " "in this scope" % name, coord) self._scope_stack[-1][name] = True def _add_identifier(self, name, coord): """ Add a new object, function, or enum member name (ie an ID) to the current scope """ if self._scope_stack[-1].get(name, False): self._parse_error( "Non-typedef %r previously declared as typedef " "in this scope" % name, coord) self._scope_stack[-1][name] = False def _is_type_in_scope(self, name): """ Is *name* a typedef-name in the current scope? """ for scope in reversed(self._scope_stack): # If name is an identifier in this scope it shadows typedefs in # higher scopes. in_scope = scope.get(name) if in_scope is not None: return in_scope return False def _lex_error_func(self, msg, line, column): self._parse_error(msg, self._coord(line, column)) def _lex_on_lbrace_func(self): self._push_scope() def _lex_on_rbrace_func(self): self._pop_scope() def _lex_type_lookup_func(self, name): """ Looks up types that were previously defined with typedef. Passed to the lexer for recognizing identifiers that are types. """ is_type = self._is_type_in_scope(name) return is_type def _get_yacc_lookahead_token(self): """ We need access to yacc's lookahead token in certain cases. This is the last token yacc requested from the lexer, so we ask the lexer. """ return self.clex.last_token # To understand what's going on here, read sections A.8.5 and # A.8.6 of K&R2 very carefully. # # A C type consists of a basic type declaration, with a list # of modifiers. For example: # # int *c[5]; # # The basic declaration here is 'int c', and the pointer and # the array are the modifiers. # # Basic declarations are represented by TypeDecl (from module c_ast) and the # modifiers are FuncDecl, PtrDecl and ArrayDecl. # # The standard states that whenever a new modifier is parsed, it should be # added to the end of the list of modifiers. For example: # # K&R2 A.8.6.2: Array Declarators # # In a declaration T D where D has the form # D1 [constant-expression-opt] # and the type of the identifier in the declaration T D1 is # "type-modifier T", the type of the # identifier of D is "type-modifier array of T" # # This is what this method does. The declarator it receives # can be a list of declarators ending with TypeDecl. It # tacks the modifier to the end of this list, just before # the TypeDecl. # # Additionally, the modifier may be a list itself. This is # useful for pointers, that can come as a chain from the rule # p_pointer. In this case, the whole modifier list is spliced # into the new location. def _type_modify_decl(self, decl, modifier): """ Tacks a type modifier on a declarator, and returns the modified declarator. Note: the declarator and modifier may be modified """ #~ print '****' #~ decl.show(offset=3) #~ modifier.show(offset=3) #~ print '****' modifier_head = modifier modifier_tail = modifier # The modifier may be a nested list. Reach its tail. # while modifier_tail.type: modifier_tail = modifier_tail.type # If the decl is a basic type, just tack the modifier onto # it # if isinstance(decl, c_ast.TypeDecl): modifier_tail.type = decl return modifier else: # Otherwise, the decl is a list of modifiers. Reach # its tail and splice the modifier onto the tail, # pointing to the underlying basic type. # decl_tail = decl while not isinstance(decl_tail.type, c_ast.TypeDecl): decl_tail = decl_tail.type modifier_tail.type = decl_tail.type decl_tail.type = modifier_head return decl # Due to the order in which declarators are constructed, # they have to be fixed in order to look like a normal AST. # # When a declaration arrives from syntax construction, it has # these problems: # * The innermost TypeDecl has no type (because the basic # type is only known at the uppermost declaration level) # * The declaration has no variable name, since that is saved # in the innermost TypeDecl # * The typename of the declaration is a list of type # specifiers, and not a node. Here, basic identifier types # should be separated from more complex types like enums # and structs. # # This method fixes these problems. # def _fix_decl_name_type(self, decl, typename): """ Fixes a declaration. Modifies decl. """ # Reach the underlying basic type # type = decl while not isinstance(type, c_ast.TypeDecl): type = type.type decl.name = type.declname type.quals = decl.quals # The typename is a list of types. If any type in this # list isn't an IdentifierType, it must be the only # type in the list (it's illegal to declare "int enum ..") # If all the types are basic, they're collected in the # IdentifierType holder. # for tn in typename: if not isinstance(tn, c_ast.IdentifierType): if len(typename) > 1: self._parse_error( "Invalid multiple types specified", tn.coord) else: type.type = tn return decl if not typename: # Functions default to returning int # if not isinstance(decl.type, c_ast.FuncDecl): self._parse_error( "Missing type in declaration", decl.coord) type.type = c_ast.IdentifierType( ['int'], coord=decl.coord) else: # At this point, we know that typename is a list of IdentifierType # nodes. Concatenate all the names into a single list. # type.type = c_ast.IdentifierType( [name for id in typename for name in id.names], coord=typename[0].coord) return decl def _add_declaration_specifier(self, declspec, newspec, kind): """ Declaration specifiers are represented by a dictionary with the entries: * qual: a list of type qualifiers * storage: a list of storage type qualifiers * type: a list of type specifiers * function: a list of function specifiers This method is given a declaration specifier, and a new specifier of a given kind. Returns the declaration specifier, with the new specifier incorporated. """ spec = declspec or dict(qual=[], storage=[], type=[], function=[]) spec[kind].insert(0, newspec) return spec def _build_declarations(self, spec, decls, typedef_namespace=False): """ Builds a list of declarations all sharing the given specifiers. If typedef_namespace is true, each declared name is added to the "typedef namespace", which also includes objects, functions, and enum constants. """ is_typedef = 'typedef' in spec['storage'] declarations = [] # Bit-fields are allowed to be unnamed. # if decls[0].get('bitsize') is not None: pass # When redeclaring typedef names as identifiers in inner scopes, a # problem can occur where the identifier gets grouped into # spec['type'], leaving decl as None. This can only occur for the # first declarator. # elif decls[0]['decl'] is None: if len(spec['type']) < 2 or len(spec['type'][-1].names) != 1 or \ not self._is_type_in_scope(spec['type'][-1].names[0]): coord = '?' for t in spec['type']: if hasattr(t, 'coord'): coord = t.coord break self._parse_error('Invalid declaration', coord) # Make this look as if it came from "direct_declarator:ID" decls[0]['decl'] = c_ast.TypeDecl( declname=spec['type'][-1].names[0], type=None, quals=None, coord=spec['type'][-1].coord) # Remove the "new" type's name from the end of spec['type'] del spec['type'][-1] # A similar problem can occur where the declaration ends up looking # like an abstract declarator. Give it a name if this is the case. # elif not isinstance(decls[0]['decl'], (c_ast.Struct, c_ast.Union, c_ast.IdentifierType)): decls_0_tail = decls[0]['decl'] while not isinstance(decls_0_tail, c_ast.TypeDecl): decls_0_tail = decls_0_tail.type if decls_0_tail.declname is None: decls_0_tail.declname = spec['type'][-1].names[0] del spec['type'][-1] for decl in decls: assert decl['decl'] is not None if is_typedef: declaration = c_ast.Typedef( name=None, quals=spec['qual'], storage=spec['storage'], type=decl['decl'], coord=decl['decl'].coord) else: declaration = c_ast.Decl( name=None, quals=spec['qual'], storage=spec['storage'], funcspec=spec['function'], type=decl['decl'], init=decl.get('init'), bitsize=decl.get('bitsize'), coord=decl['decl'].coord) if isinstance(declaration.type, (c_ast.Struct, c_ast.Union, c_ast.IdentifierType)): fixed_decl = declaration else: fixed_decl = self._fix_decl_name_type(declaration, spec['type']) # Add the type name defined by typedef to a # symbol table (for usage in the lexer) # if typedef_namespace: if is_typedef: self._add_typedef_name(fixed_decl.name, fixed_decl.coord) else: self._add_identifier(fixed_decl.name, fixed_decl.coord) declarations.append(fixed_decl) return declarations def _build_function_definition(self, spec, decl, param_decls, body): """ Builds a function definition. """ assert 'typedef' not in spec['storage'] declaration = self._build_declarations( spec=spec, decls=[dict(decl=decl, init=None)], typedef_namespace=True)[0] return c_ast.FuncDef( decl=declaration, param_decls=param_decls, body=body, coord=decl.coord) def _select_struct_union_class(self, token): """ Given a token (either STRUCT or UNION), selects the appropriate AST class. """ if token == 'struct': return c_ast.Struct else: return c_ast.Union ## ## Precedence and associativity of operators ## precedence = ( ('left', 'LOR'), ('left', 'LAND'), ('left', 'OR'), ('left', 'XOR'), ('left', 'AND'), ('left', 'EQ', 'NE'), ('left', 'GT', 'GE', 'LT', 'LE'), ('left', 'RSHIFT', 'LSHIFT'), ('left', 'PLUS', 'MINUS'), ('left', 'TIMES', 'DIVIDE', 'MOD') ) ## ## Grammar productions ## Implementation of the BNF defined in K&R2 A.13 ## # Wrapper around a translation unit, to allow for empty input. # Not strictly part of the C99 Grammar, but useful in practice. # def p_translation_unit_or_empty(self, p): """ translation_unit_or_empty : translation_unit | empty """ if p[1] is None: p[0] = c_ast.FileAST([]) else: p[0] = c_ast.FileAST(p[1]) def p_translation_unit_1(self, p): """ translation_unit : external_declaration """ # Note: external_declaration is already a list # p[0] = p[1] def p_translation_unit_2(self, p): """ translation_unit : translation_unit external_declaration """ if p[2] is not None: p[1].extend(p[2]) p[0] = p[1] # Declarations always come as lists (because they can be # several in one line), so we wrap the function definition # into a list as well, to make the return value of # external_declaration homogenous. # def p_external_declaration_1(self, p): """ external_declaration : function_definition """ p[0] = [p[1]] def p_external_declaration_2(self, p): """ external_declaration : declaration """ p[0] = p[1] def p_external_declaration_3(self, p): """ external_declaration : pp_directive """ p[0] = p[1] def p_external_declaration_4(self, p): """ external_declaration : SEMI """ p[0] = None def p_pp_directive(self, p): """ pp_directive : PPHASH """ self._parse_error('Directives not supported yet', self._coord(p.lineno(1))) # In function definitions, the declarator can be followed by # a declaration list, for old "K&R style" function definitios. # def p_function_definition_1(self, p): """ function_definition : declarator declaration_list_opt compound_statement """ # no declaration specifiers - 'int' becomes the default type spec = dict( qual=[], storage=[], type=[c_ast.IdentifierType(['int'], coord=self._coord(p.lineno(1)))], function=[]) p[0] = self._build_function_definition( spec=spec, decl=p[1], param_decls=p[2], body=p[3]) def p_function_definition_2(self, p): """ function_definition : declaration_specifiers declarator declaration_list_opt compound_statement """ spec = p[1] p[0] = self._build_function_definition( spec=spec, decl=p[2], param_decls=p[3], body=p[4]) def p_statement(self, p): """ statement : labeled_statement | expression_statement | compound_statement | selection_statement | iteration_statement | jump_statement """ p[0] = p[1] # In C, declarations can come several in a line: # int x, *px, romulo = 5; # # However, for the AST, we will split them to separate Decl # nodes. # # This rule splits its declarations and always returns a list # of Decl nodes, even if it's one element long. # def p_decl_body(self, p): """ decl_body : declaration_specifiers init_declarator_list_opt """ spec = p[1] # p[2] (init_declarator_list_opt) is either a list or None # if p[2] is None: # By the standard, you must have at least one declarator unless # declaring a structure tag, a union tag, or the members of an # enumeration. # ty = spec['type'] s_u_or_e = (c_ast.Struct, c_ast.Union, c_ast.Enum) if len(ty) == 1 and isinstance(ty[0], s_u_or_e): decls = [c_ast.Decl( name=None, quals=spec['qual'], storage=spec['storage'], funcspec=spec['function'], type=ty[0], init=None, bitsize=None, coord=ty[0].coord)] # However, this case can also occur on redeclared identifiers in # an inner scope. The trouble is that the redeclared type's name # gets grouped into declaration_specifiers; _build_declarations # compensates for this. # else: decls = self._build_declarations( spec=spec, decls=[dict(decl=None, init=None)], typedef_namespace=True) else: decls = self._build_declarations( spec=spec, decls=p[2], typedef_namespace=True) p[0] = decls # The declaration has been split to a decl_body sub-rule and # SEMI, because having them in a single rule created a problem # for defining typedefs. # # If a typedef line was directly followed by a line using the # type defined with the typedef, the type would not be # recognized. This is because to reduce the declaration rule, # the parser's lookahead asked for the token after SEMI, which # was the type from the next line, and the lexer had no chance # to see the updated type symbol table. # # Splitting solves this problem, because after seeing SEMI, # the parser reduces decl_body, which actually adds the new # type into the table to be seen by the lexer before the next # line is reached. def p_declaration(self, p): """ declaration : decl_body SEMI """ p[0] = p[1] # Since each declaration is a list of declarations, this # rule will combine all the declarations and return a single # list # def p_declaration_list(self, p): """ declaration_list : declaration | declaration_list declaration """ p[0] = p[1] if len(p) == 2 else p[1] + p[2] def p_declaration_specifiers_1(self, p): """ declaration_specifiers : type_qualifier declaration_specifiers_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'qual') def p_declaration_specifiers_2(self, p): """ declaration_specifiers : type_specifier declaration_specifiers_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'type') def p_declaration_specifiers_3(self, p): """ declaration_specifiers : storage_class_specifier declaration_specifiers_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'storage') def p_declaration_specifiers_4(self, p): """ declaration_specifiers : function_specifier declaration_specifiers_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'function') def p_storage_class_specifier(self, p): """ storage_class_specifier : AUTO | REGISTER | STATIC | EXTERN | TYPEDEF """ p[0] = p[1] def p_function_specifier(self, p): """ function_specifier : INLINE """ p[0] = p[1] def p_type_specifier_1(self, p): """ type_specifier : VOID | _BOOL | CHAR | SHORT | INT | LONG | FLOAT | DOUBLE | _COMPLEX | SIGNED | UNSIGNED """ p[0] = c_ast.IdentifierType([p[1]], coord=self._coord(p.lineno(1))) def p_type_specifier_2(self, p): """ type_specifier : typedef_name | enum_specifier | struct_or_union_specifier """ p[0] = p[1] def p_type_qualifier(self, p): """ type_qualifier : CONST | RESTRICT | VOLATILE """ p[0] = p[1] def p_init_declarator_list_1(self, p): """ init_declarator_list : init_declarator | init_declarator_list COMMA init_declarator """ p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]] # If the code is declaring a variable that was declared a typedef in an # outer scope, yacc will think the name is part of declaration_specifiers, # not init_declarator, and will then get confused by EQUALS. Pass None # up in place of declarator, and handle this at a higher level. # def p_init_declarator_list_2(self, p): """ init_declarator_list : EQUALS initializer """ p[0] = [dict(decl=None, init=p[2])] # Similarly, if the code contains duplicate typedefs of, for example, # array types, the array portion will appear as an abstract declarator. # def p_init_declarator_list_3(self, p): """ init_declarator_list : abstract_declarator """ p[0] = [dict(decl=p[1], init=None)] # Returns a {decl=<declarator> : init=<initializer>} dictionary # If there's no initializer, uses None # def p_init_declarator(self, p): """ init_declarator : declarator | declarator EQUALS initializer """ p[0] = dict(decl=p[1], init=(p[3] if len(p) > 2 else None)) def p_specifier_qualifier_list_1(self, p): """ specifier_qualifier_list : type_qualifier specifier_qualifier_list_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'qual') def p_specifier_qualifier_list_2(self, p): """ specifier_qualifier_list : type_specifier specifier_qualifier_list_opt """ p[0] = self._add_declaration_specifier(p[2], p[1], 'type') # TYPEID is allowed here (and in other struct/enum related tag names), because # struct/enum tags reside in their own namespace and can be named the same as types # def p_struct_or_union_specifier_1(self, p): """ struct_or_union_specifier : struct_or_union ID | struct_or_union TYPEID """ klass = self._select_struct_union_class(p[1]) p[0] = klass( name=p[2], decls=None, coord=self._coord(p.lineno(2))) def p_struct_or_union_specifier_2(self, p): """ struct_or_union_specifier : struct_or_union brace_open struct_declaration_list brace_close """ klass = self._select_struct_union_class(p[1]) p[0] = klass( name=None, decls=p[3], coord=self._coord(p.lineno(2))) def p_struct_or_union_specifier_3(self, p): """ struct_or_union_specifier : struct_or_union ID brace_open struct_declaration_list brace_close | struct_or_union TYPEID brace_open struct_declaration_list brace_close """ klass = self._select_struct_union_class(p[1]) p[0] = klass( name=p[2], decls=p[4], coord=self._coord(p.lineno(2))) def p_struct_or_union(self, p): """ struct_or_union : STRUCT | UNION """ p[0] = p[1] # Combine all declarations into a single list # def p_struct_declaration_list(self, p): """ struct_declaration_list : struct_declaration | struct_declaration_list struct_declaration """ p[0] = p[1] if len(p) == 2 else p[1] + p[2] def p_struct_declaration_1(self, p): """ struct_declaration : specifier_qualifier_list struct_declarator_list_opt SEMI """ spec = p[1] assert 'typedef' not in spec['storage'] if p[2] is not None: decls = self._build_declarations( spec=spec, decls=p[2]) elif len(spec['type']) == 1: # Anonymous struct/union, gcc extension, C1x feature. # Although the standard only allows structs/unions here, I see no # reason to disallow other types since some compilers have typedefs # here, and pycparser isn't about rejecting all invalid code. # node = spec['type'][0] if isinstance(node, c_ast.Node): decl_type = node else: decl_type = c_ast.IdentifierType(node) decls = self._build_declarations( spec=spec, decls=[dict(decl=decl_type)]) else: # Structure/union members can have the same names as typedefs. # The trouble is that the member's name gets grouped into # specifier_qualifier_list; _build_declarations compensates. # decls = self._build_declarations( spec=spec, decls=[dict(decl=None, init=None)]) p[0] = decls def p_struct_declaration_2(self, p): """ struct_declaration : specifier_qualifier_list abstract_declarator SEMI """ # "Abstract declarator?!", you ask? Structure members can have the # same names as typedefs. The trouble is that the member's name gets # grouped into specifier_qualifier_list, leaving any remainder to # appear as an abstract declarator, as in: # typedef int Foo; # struct { Foo Foo[3]; }; # p[0] = self._build_declarations( spec=p[1], decls=[dict(decl=p[2], init=None)]) def p_struct_declarator_list(self, p): """ struct_declarator_list : struct_declarator | struct_declarator_list COMMA struct_declarator """ p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]] # struct_declarator passes up a dict with the keys: decl (for # the underlying declarator) and bitsize (for the bitsize) # def p_struct_declarator_1(self, p): """ struct_declarator : declarator """ p[0] = {'decl': p[1], 'bitsize': None} def p_struct_declarator_2(self, p): """ struct_declarator : declarator COLON constant_expression | COLON constant_expression """ if len(p) > 3: p[0] = {'decl': p[1], 'bitsize': p[3]} else: p[0] = {'decl': c_ast.TypeDecl(None, None, None), 'bitsize': p[2]} def p_enum_specifier_1(self, p): """ enum_specifier : ENUM ID | ENUM TYPEID """ p[0] = c_ast.Enum(p[2], None, self._coord(p.lineno(1))) def p_enum_specifier_2(self, p): """ enum_specifier : ENUM brace_open enumerator_list brace_close """ p[0] = c_ast.Enum(None, p[3], self._coord(p.lineno(1))) def p_enum_specifier_3(self, p): """ enum_specifier : ENUM ID brace_open enumerator_list brace_close | ENUM TYPEID brace_open enumerator_list brace_close """ p[0] = c_ast.Enum(p[2], p[4], self._coord(p.lineno(1))) def p_enumerator_list(self, p): """ enumerator_list : enumerator | enumerator_list COMMA | enumerator_list COMMA enumerator """ if len(p) == 2: p[0] = c_ast.EnumeratorList([p[1]], p[1].coord) elif len(p) == 3: p[0] = p[1] else: p[1].enumerators.append(p[3]) p[0] = p[1] def p_enumerator(self, p): """ enumerator : ID | ID EQUALS constant_expression """ if len(p) == 2: enumerator = c_ast.Enumerator( p[1], None, self._coord(p.lineno(1))) else: enumerator = c_ast.Enumerator( p[1], p[3], self._coord(p.lineno(1))) self._add_identifier(enumerator.name, enumerator.coord) p[0] = enumerator def p_declarator_1(self, p): """ declarator : direct_declarator """ p[0] = p[1] def p_declarator_2(self, p): """ declarator : pointer direct_declarator """ p[0] = self._type_modify_decl(p[2], p[1]) # Since it's impossible for a type to be specified after a pointer, assume # it's intended to be the name for this declaration. _add_identifier will # raise an error if this TYPEID can't be redeclared. # def p_declarator_3(self, p): """ declarator : pointer TYPEID """ decl = c_ast.TypeDecl( declname=p[2], type=None, quals=None, coord=self._coord(p.lineno(2))) p[0] = self._type_modify_decl(decl, p[1]) def p_direct_declarator_1(self, p): """ direct_declarator : ID """ p[0] = c_ast.TypeDecl( declname=p[1], type=None, quals=None, coord=self._coord(p.lineno(1))) def p_direct_declarator_2(self, p): """ direct_declarator : LPAREN declarator RPAREN """ p[0] = p[2] def p_direct_declarator_3(self, p): """ direct_declarator : direct_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET """ quals = (p[3] if len(p) > 5 else []) or [] # Accept dimension qualifiers # Per C99 6.7.5.3 p7 arr = c_ast.ArrayDecl( type=None, dim=p[4] if len(p) > 5 else p[3], dim_quals=quals, coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=arr) def p_direct_declarator_4(self, p): """ direct_declarator : direct_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET | direct_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET """ # Using slice notation for PLY objects doesn't work in Python 3 for the # version of PLY embedded with pycparser; see PLY Google Code issue 30. # Work around that here by listing the two elements separately. listed_quals = [item if isinstance(item, list) else [item] for item in [p[3],p[4]]] dim_quals = [qual for sublist in listed_quals for qual in sublist if qual is not None] arr = c_ast.ArrayDecl( type=None, dim=p[5], dim_quals=dim_quals, coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=arr) # Special for VLAs # def p_direct_declarator_5(self, p): """ direct_declarator : direct_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET """ arr = c_ast.ArrayDecl( type=None, dim=c_ast.ID(p[4], self._coord(p.lineno(4))), dim_quals=p[3] if p[3] != None else [], coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=arr) def p_direct_declarator_6(self, p): """ direct_declarator : direct_declarator LPAREN parameter_type_list RPAREN | direct_declarator LPAREN identifier_list_opt RPAREN """ func = c_ast.FuncDecl( args=p[3], type=None, coord=p[1].coord) # To see why _get_yacc_lookahead_token is needed, consider: # typedef char TT; # void foo(int TT) { TT = 10; } # Outside the function, TT is a typedef, but inside (starting and # ending with the braces) it's a parameter. The trouble begins with # yacc's lookahead token. We don't know if we're declaring or # defining a function until we see LBRACE, but if we wait for yacc to # trigger a rule on that token, then TT will have already been read # and incorrectly interpreted as TYPEID. We need to add the # parameters to the scope the moment the lexer sees LBRACE. # if self._get_yacc_lookahead_token().type == "LBRACE": if func.args is not None: for param in func.args.params: if isinstance(param, c_ast.EllipsisParam): break self._add_identifier(param.name, param.coord) p[0] = self._type_modify_decl(decl=p[1], modifier=func) def p_pointer(self, p): """ pointer : TIMES type_qualifier_list_opt | TIMES type_qualifier_list_opt pointer """ coord = self._coord(p.lineno(1)) # Pointer decls nest from inside out. This is important when different # levels have different qualifiers. For example: # # char * const * p; # # Means "pointer to const pointer to char" # # While: # # char ** const p; # # Means "const pointer to pointer to char" # # So when we construct PtrDecl nestings, the leftmost pointer goes in # as the most nested type. nested_type = c_ast.PtrDecl(quals=p[2] or [], type=None, coord=coord) if len(p) > 3: tail_type = p[3] while tail_type.type is not None: tail_type = tail_type.type tail_type.type = nested_type p[0] = p[3] else: p[0] = nested_type def p_type_qualifier_list(self, p): """ type_qualifier_list : type_qualifier | type_qualifier_list type_qualifier """ p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]] def p_parameter_type_list(self, p): """ parameter_type_list : parameter_list | parameter_list COMMA ELLIPSIS """ if len(p) > 2: p[1].params.append(c_ast.EllipsisParam(self._coord(p.lineno(3)))) p[0] = p[1] def p_parameter_list(self, p): """ parameter_list : parameter_declaration | parameter_list COMMA parameter_declaration """ if len(p) == 2: # single parameter p[0] = c_ast.ParamList([p[1]], p[1].coord) else: p[1].params.append(p[3]) p[0] = p[1] def p_parameter_declaration_1(self, p): """ parameter_declaration : declaration_specifiers declarator """ spec = p[1] if not spec['type']: spec['type'] = [c_ast.IdentifierType(['int'], coord=self._coord(p.lineno(1)))] p[0] = self._build_declarations( spec=spec, decls=[dict(decl=p[2])])[0] def p_parameter_declaration_2(self, p): """ parameter_declaration : declaration_specifiers abstract_declarator_opt """ spec = p[1] if not spec['type']: spec['type'] = [c_ast.IdentifierType(['int'], coord=self._coord(p.lineno(1)))] # Parameters can have the same names as typedefs. The trouble is that # the parameter's name gets grouped into declaration_specifiers, making # it look like an old-style declaration; compensate. # if len(spec['type']) > 1 and len(spec['type'][-1].names) == 1 and \ self._is_type_in_scope(spec['type'][-1].names[0]): decl = self._build_declarations( spec=spec, decls=[dict(decl=p[2], init=None)])[0] # This truly is an old-style parameter declaration # else: decl = c_ast.Typename( name='', quals=spec['qual'], type=p[2] or c_ast.TypeDecl(None, None, None), coord=self._coord(p.lineno(2))) typename = spec['type'] decl = self._fix_decl_name_type(decl, typename) p[0] = decl def p_identifier_list(self, p): """ identifier_list : identifier | identifier_list COMMA identifier """ if len(p) == 2: # single parameter p[0] = c_ast.ParamList([p[1]], p[1].coord) else: p[1].params.append(p[3]) p[0] = p[1] def p_initializer_1(self, p): """ initializer : assignment_expression """ p[0] = p[1] def p_initializer_2(self, p): """ initializer : brace_open initializer_list_opt brace_close | brace_open initializer_list COMMA brace_close """ if p[2] is None: p[0] = c_ast.InitList([], self._coord(p.lineno(1))) else: p[0] = p[2] def p_initializer_list(self, p): """ initializer_list : designation_opt initializer | initializer_list COMMA designation_opt initializer """ if len(p) == 3: # single initializer init = p[2] if p[1] is None else c_ast.NamedInitializer(p[1], p[2]) p[0] = c_ast.InitList([init], p[2].coord) else: init = p[4] if p[3] is None else c_ast.NamedInitializer(p[3], p[4]) p[1].exprs.append(init) p[0] = p[1] def p_designation(self, p): """ designation : designator_list EQUALS """ p[0] = p[1] # Designators are represented as a list of nodes, in the order in which # they're written in the code. # def p_designator_list(self, p): """ designator_list : designator | designator_list designator """ p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]] def p_designator(self, p): """ designator : LBRACKET constant_expression RBRACKET | PERIOD identifier """ p[0] = p[2] def p_type_name(self, p): """ type_name : specifier_qualifier_list abstract_declarator_opt """ #~ print '==========' #~ print p[1] #~ print p[2] #~ print p[2].children() #~ print '==========' typename = c_ast.Typename( name='', quals=p[1]['qual'], type=p[2] or c_ast.TypeDecl(None, None, None), coord=self._coord(p.lineno(2))) p[0] = self._fix_decl_name_type(typename, p[1]['type']) def p_abstract_declarator_1(self, p): """ abstract_declarator : pointer """ dummytype = c_ast.TypeDecl(None, None, None) p[0] = self._type_modify_decl( decl=dummytype, modifier=p[1]) def p_abstract_declarator_2(self, p): """ abstract_declarator : pointer direct_abstract_declarator """ p[0] = self._type_modify_decl(p[2], p[1]) def p_abstract_declarator_3(self, p): """ abstract_declarator : direct_abstract_declarator """ p[0] = p[1] # Creating and using direct_abstract_declarator_opt here # instead of listing both direct_abstract_declarator and the # lack of it in the beginning of _1 and _2 caused two # shift/reduce errors. # def p_direct_abstract_declarator_1(self, p): """ direct_abstract_declarator : LPAREN abstract_declarator RPAREN """ p[0] = p[2] def p_direct_abstract_declarator_2(self, p): """ direct_abstract_declarator : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET """ arr = c_ast.ArrayDecl( type=None, dim=p[3], dim_quals=[], coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=arr) def p_direct_abstract_declarator_3(self, p): """ direct_abstract_declarator : LBRACKET assignment_expression_opt RBRACKET """ p[0] = c_ast.ArrayDecl( type=c_ast.TypeDecl(None, None, None), dim=p[2], dim_quals=[], coord=self._coord(p.lineno(1))) def p_direct_abstract_declarator_4(self, p): """ direct_abstract_declarator : direct_abstract_declarator LBRACKET TIMES RBRACKET """ arr = c_ast.ArrayDecl( type=None, dim=c_ast.ID(p[3], self._coord(p.lineno(3))), dim_quals=[], coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=arr) def p_direct_abstract_declarator_5(self, p): """ direct_abstract_declarator : LBRACKET TIMES RBRACKET """ p[0] = c_ast.ArrayDecl( type=c_ast.TypeDecl(None, None, None), dim=c_ast.ID(p[3], self._coord(p.lineno(3))), dim_quals=[], coord=self._coord(p.lineno(1))) def p_direct_abstract_declarator_6(self, p): """ direct_abstract_declarator : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN """ func = c_ast.FuncDecl( args=p[3], type=None, coord=p[1].coord) p[0] = self._type_modify_decl(decl=p[1], modifier=func) def p_direct_abstract_declarator_7(self, p): """ direct_abstract_declarator : LPAREN parameter_type_list_opt RPAREN """ p[0] = c_ast.FuncDecl( args=p[2], type=c_ast.TypeDecl(None, None, None), coord=self._coord(p.lineno(1))) # declaration is a list, statement isn't. To make it consistent, block_item # will always be a list # def p_block_item(self, p): """ block_item : declaration | statement """ p[0] = p[1] if isinstance(p[1], list) else [p[1]] # Since we made block_item a list, this just combines lists # def p_block_item_list(self, p): """ block_item_list : block_item | block_item_list block_item """ # Empty block items (plain ';') produce [None], so ignore them p[0] = p[1] if (len(p) == 2 or p[2] == [None]) else p[1] + p[2] def p_compound_statement_1(self, p): """ compound_statement : brace_open block_item_list_opt brace_close """ p[0] = c_ast.Compound( block_items=p[2], coord=self._coord(p.lineno(1))) def p_labeled_statement_1(self, p): """ labeled_statement : ID COLON statement """ p[0] = c_ast.Label(p[1], p[3], self._coord(p.lineno(1))) def p_labeled_statement_2(self, p): """ labeled_statement : CASE constant_expression COLON statement """ p[0] = c_ast.Case(p[2], [p[4]], self._coord(p.lineno(1))) def p_labeled_statement_3(self, p): """ labeled_statement : DEFAULT COLON statement """ p[0] = c_ast.Default([p[3]], self._coord(p.lineno(1))) def p_selection_statement_1(self, p): """ selection_statement : IF LPAREN expression RPAREN statement """ p[0] = c_ast.If(p[3], p[5], None, self._coord(p.lineno(1))) def p_selection_statement_2(self, p): """ selection_statement : IF LPAREN expression RPAREN statement ELSE statement """ p[0] = c_ast.If(p[3], p[5], p[7], self._coord(p.lineno(1))) def p_selection_statement_3(self, p): """ selection_statement : SWITCH LPAREN expression RPAREN statement """ p[0] = fix_switch_cases( c_ast.Switch(p[3], p[5], self._coord(p.lineno(1)))) def p_iteration_statement_1(self, p): """ iteration_statement : WHILE LPAREN expression RPAREN statement """ p[0] = c_ast.While(p[3], p[5], self._coord(p.lineno(1))) def p_iteration_statement_2(self, p): """ iteration_statement : DO statement WHILE LPAREN expression RPAREN SEMI """ p[0] = c_ast.DoWhile(p[5], p[2], self._coord(p.lineno(1))) def p_iteration_statement_3(self, p): """ iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN statement """ p[0] = c_ast.For(p[3], p[5], p[7], p[9], self._coord(p.lineno(1))) def p_iteration_statement_4(self, p): """ iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN statement """ p[0] = c_ast.For(c_ast.DeclList(p[3], self._coord(p.lineno(1))), p[4], p[6], p[8], self._coord(p.lineno(1))) def p_jump_statement_1(self, p): """ jump_statement : GOTO ID SEMI """ p[0] = c_ast.Goto(p[2], self._coord(p.lineno(1))) def p_jump_statement_2(self, p): """ jump_statement : BREAK SEMI """ p[0] = c_ast.Break(self._coord(p.lineno(1))) def p_jump_statement_3(self, p): """ jump_statement : CONTINUE SEMI """ p[0] = c_ast.Continue(self._coord(p.lineno(1))) def p_jump_statement_4(self, p): """ jump_statement : RETURN expression SEMI | RETURN SEMI """ p[0] = c_ast.Return(p[2] if len(p) == 4 else None, self._coord(p.lineno(1))) def p_expression_statement(self, p): """ expression_statement : expression_opt SEMI """ if p[1] is None: p[0] = c_ast.EmptyStatement(self._coord(p.lineno(1))) else: p[0] = p[1] def p_expression(self, p): """ expression : assignment_expression | expression COMMA assignment_expression """ if len(p) == 2: p[0] = p[1] else: if not isinstance(p[1], c_ast.ExprList): p[1] = c_ast.ExprList([p[1]], p[1].coord) p[1].exprs.append(p[3]) p[0] = p[1] def p_typedef_name(self, p): """ typedef_name : TYPEID """ p[0] = c_ast.IdentifierType([p[1]], coord=self._coord(p.lineno(1))) def p_assignment_expression(self, p): """ assignment_expression : conditional_expression | unary_expression assignment_operator assignment_expression """ if len(p) == 2: p[0] = p[1] else: p[0] = c_ast.Assignment(p[2], p[1], p[3], p[1].coord) # K&R2 defines these as many separate rules, to encode # precedence and associativity. Why work hard ? I'll just use # the built in precedence/associativity specification feature # of PLY. (see precedence declaration above) # def p_assignment_operator(self, p): """ assignment_operator : EQUALS | XOREQUAL | TIMESEQUAL | DIVEQUAL | MODEQUAL | PLUSEQUAL | MINUSEQUAL | LSHIFTEQUAL | RSHIFTEQUAL | ANDEQUAL | OREQUAL """ p[0] = p[1] def p_constant_expression(self, p): """ constant_expression : conditional_expression """ p[0] = p[1] def p_conditional_expression(self, p): """ conditional_expression : binary_expression | binary_expression CONDOP expression COLON conditional_expression """ if len(p) == 2: p[0] = p[1] else: p[0] = c_ast.TernaryOp(p[1], p[3], p[5], p[1].coord) def p_binary_expression(self, p): """ binary_expression : cast_expression | binary_expression TIMES binary_expression | binary_expression DIVIDE binary_expression | binary_expression MOD binary_expression | binary_expression PLUS binary_expression | binary_expression MINUS binary_expression | binary_expression RSHIFT binary_expression | binary_expression LSHIFT binary_expression | binary_expression LT binary_expression | binary_expression LE binary_expression | binary_expression GE binary_expression | binary_expression GT binary_expression | binary_expression EQ binary_expression | binary_expression NE binary_expression | binary_expression AND binary_expression | binary_expression OR binary_expression | binary_expression XOR binary_expression | binary_expression LAND binary_expression | binary_expression LOR binary_expression """ if len(p) == 2: p[0] = p[1] else: p[0] = c_ast.BinaryOp(p[2], p[1], p[3], p[1].coord) def p_cast_expression_1(self, p): """ cast_expression : unary_expression """ p[0] = p[1] def p_cast_expression_2(self, p): """ cast_expression : LPAREN type_name RPAREN cast_expression """ p[0] = c_ast.Cast(p[2], p[4], self._coord(p.lineno(1))) def p_unary_expression_1(self, p): """ unary_expression : postfix_expression """ p[0] = p[1] def p_unary_expression_2(self, p): """ unary_expression : PLUSPLUS unary_expression | MINUSMINUS unary_expression | unary_operator cast_expression """ p[0] = c_ast.UnaryOp(p[1], p[2], p[2].coord) def p_unary_expression_3(self, p): """ unary_expression : SIZEOF unary_expression | SIZEOF LPAREN type_name RPAREN """ p[0] = c_ast.UnaryOp( p[1], p[2] if len(p) == 3 else p[3], self._coord(p.lineno(1))) def p_unary_operator(self, p): """ unary_operator : AND | TIMES | PLUS | MINUS | NOT | LNOT """ p[0] = p[1] def p_postfix_expression_1(self, p): """ postfix_expression : primary_expression """ p[0] = p[1] def p_postfix_expression_2(self, p): """ postfix_expression : postfix_expression LBRACKET expression RBRACKET """ p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord) def p_postfix_expression_3(self, p): """ postfix_expression : postfix_expression LPAREN argument_expression_list RPAREN | postfix_expression LPAREN RPAREN """ p[0] = c_ast.FuncCall(p[1], p[3] if len(p) == 5 else None, p[1].coord) def p_postfix_expression_4(self, p): """ postfix_expression : postfix_expression PERIOD ID | postfix_expression PERIOD TYPEID | postfix_expression ARROW ID | postfix_expression ARROW TYPEID """ field = c_ast.ID(p[3], self._coord(p.lineno(3))) p[0] = c_ast.StructRef(p[1], p[2], field, p[1].coord) def p_postfix_expression_5(self, p): """ postfix_expression : postfix_expression PLUSPLUS | postfix_expression MINUSMINUS """ p[0] = c_ast.UnaryOp('p' + p[2], p[1], p[1].coord) def p_postfix_expression_6(self, p): """ postfix_expression : LPAREN type_name RPAREN brace_open initializer_list brace_close | LPAREN type_name RPAREN brace_open initializer_list COMMA brace_close """ p[0] = c_ast.CompoundLiteral(p[2], p[5]) def p_primary_expression_1(self, p): """ primary_expression : identifier """ p[0] = p[1] def p_primary_expression_2(self, p): """ primary_expression : constant """ p[0] = p[1] def p_primary_expression_3(self, p): """ primary_expression : unified_string_literal | unified_wstring_literal """ p[0] = p[1] def p_primary_expression_4(self, p): """ primary_expression : LPAREN expression RPAREN """ p[0] = p[2] def p_primary_expression_5(self, p): """ primary_expression : OFFSETOF LPAREN type_name COMMA identifier RPAREN """ coord = self._coord(p.lineno(1)) p[0] = c_ast.FuncCall(c_ast.ID(p[1], coord), c_ast.ExprList([p[3], p[5]], coord), coord) def p_argument_expression_list(self, p): """ argument_expression_list : assignment_expression | argument_expression_list COMMA assignment_expression """ if len(p) == 2: # single expr p[0] = c_ast.ExprList([p[1]], p[1].coord) else: p[1].exprs.append(p[3]) p[0] = p[1] def p_identifier(self, p): """ identifier : ID """ p[0] = c_ast.ID(p[1], self._coord(p.lineno(1))) def p_constant_1(self, p): """ constant : INT_CONST_DEC | INT_CONST_OCT | INT_CONST_HEX | INT_CONST_BIN """ p[0] = c_ast.Constant( 'int', p[1], self._coord(p.lineno(1))) def p_constant_2(self, p): """ constant : FLOAT_CONST | HEX_FLOAT_CONST """ p[0] = c_ast.Constant( 'float', p[1], self._coord(p.lineno(1))) def p_constant_3(self, p): """ constant : CHAR_CONST | WCHAR_CONST """ p[0] = c_ast.Constant( 'char', p[1], self._coord(p.lineno(1))) # The "unified" string and wstring literal rules are for supporting # concatenation of adjacent string literals. # I.e. "hello " "world" is seen by the C compiler as a single string literal # with the value "hello world" # def p_unified_string_literal(self, p): """ unified_string_literal : STRING_LITERAL | unified_string_literal STRING_LITERAL """ if len(p) == 2: # single literal p[0] = c_ast.Constant( 'string', p[1], self._coord(p.lineno(1))) else: p[1].value = p[1].value[:-1] + p[2][1:] p[0] = p[1] def p_unified_wstring_literal(self, p): """ unified_wstring_literal : WSTRING_LITERAL | unified_wstring_literal WSTRING_LITERAL """ if len(p) == 2: # single literal p[0] = c_ast.Constant( 'string', p[1], self._coord(p.lineno(1))) else: p[1].value = p[1].value.rstrip()[:-1] + p[2][2:] p[0] = p[1] def p_brace_open(self, p): """ brace_open : LBRACE """ p[0] = p[1] def p_brace_close(self, p): """ brace_close : RBRACE """ p[0] = p[1] def p_empty(self, p): 'empty : ' p[0] = None def p_error(self, p): # If error recovery is added here in the future, make sure # _get_yacc_lookahead_token still works! # if p: self._parse_error( 'before: %s' % p.value, self._coord(lineno=p.lineno, column=self.clex.find_tok_column(p))) else: self._parse_error('At end of input', '') #------------------------------------------------------------------------------ if __name__ == "__main__": import pprint import time, sys #t1 = time.time() #parser = CParser(lex_optimize=True, yacc_debug=True, yacc_optimize=False) #sys.write(time.time() - t1) #buf = ''' #int (*k)(int); #''' ## set debuglevel to 2 for debugging #t = parser.parse(buf, 'x.c', debuglevel=0) #t.show(showcoord=True)

noreply@github.com

08a65bb7db851c3827f50ea795ce9e58ad45c818

7eebbfaee45fdc57c4fc6ba32c87c35be1e62b14

/airbyte-integrations/connectors/source-facebook-pages/source_facebook_pages/streams.py

717fb1c76800fc295cff19b40b475069c0e2914a

permissive

Velocity-Engineering/airbyte

b6e1fcead5b9fd7c74d50b9f27118654604dc8e0

802a8184cdd11c1eb905a54ed07c8732b0c0b807

refs/heads/master

MIT

Java

UTF-8

Python

py

# # Copyright (c) 2021 Airbyte, Inc., all rights reserved. # from abc import ABC from typing import Any, Iterable, Mapping, MutableMapping, Optional import requests from airbyte_cdk.sources.streams.http import HttpStream from source_facebook_pages.metrics import PAGE_FIELDS, PAGE_METRICS, POST_FIELDS, POST_METRICS class FacebookPagesStream(HttpStream, ABC): url_base = "https://graph.facebook.com/v11.0/" primary_key = "id" data_field = "data" def __init__( self, access_token: str = None, page_id: str = None, **kwargs, ): super().__init__(**kwargs) self._access_token = access_token self._page_id = page_id @property def path_param(self): return self.name[:-1] def next_page_token(self, response: requests.Response) -> Optional[Mapping[str, Any]]: data = response.json() if not data.get("data") or not data.get("paging"): return {} return { "limit": 100, "after": data.get("paging", {}).get("cursors", {}).get("after"), } def request_params( self, stream_state: Mapping[str, Any], stream_slice: Mapping[str, any] = None, next_page_token: Mapping[str, Any] = None, ) -> MutableMapping[str, Any]: next_page_token = next_page_token or {} params = {"access_token": self._access_token, **next_page_token} return params def parse_response(self, response: requests.Response, **kwargs) -> Iterable[Mapping]: if not self.data_field: yield response.json() records = response.json().get(self.data_field, []) for record in records: yield record class Page(FacebookPagesStream): """ API docs: https://developers.facebook.com/docs/graph-api/reference/page/, """ data_field = "" def path(self, **kwargs) -> str: return self._page_id def next_page_token(self, response: requests.Response) -> Optional[Mapping[str, Any]]: return None def request_params(self, **kwargs) -> MutableMapping[str, Any]: params = super().request_params(**kwargs) # we have to define which fields will return from Facebook API # because FB API doesn't provide opportunity to get fields dynamically without delays # so in PAGE_FIELDS we define fields that user can get from API params["fields"] = PAGE_FIELDS return params class Post(FacebookPagesStream): """ https://developers.facebook.com/docs/graph-api/reference/v11.0/page/feed, """ def path(self, **kwargs) -> str: return f"{self._page_id}/posts" def request_params(self, **kwargs) -> MutableMapping[str, Any]: params = super().request_params(**kwargs) params["fields"] = POST_FIELDS return params class PageInsights(FacebookPagesStream): """ API docs: https://developers.facebook.com/docs/graph-api/reference/page/insights/, """ def path(self, **kwargs) -> str: return f"{self._page_id}/insights" def next_page_token(self, response: requests.Response) -> Optional[Mapping[str, Any]]: return None def request_params( self, stream_state: Mapping[str, Any], stream_slice: Mapping[str, any] = None, next_page_token: Mapping[str, Any] = None, ) -> MutableMapping[str, Any]: params = super().request_params(stream_state, stream_slice, next_page_token) params["metric"] = ",".join(PAGE_METRICS) return params class PostInsights(FacebookPagesStream): """ API docs: https://developers.facebook.com/docs/graph-api/reference/post/insights/, """ def path(self, **kwargs) -> str: return f"{self._page_id}/posts" def request_params( self, stream_state: Mapping[str, Any], stream_slice: Mapping[str, any] = None, next_page_token: Mapping[str, Any] = None, ) -> MutableMapping[str, Any]: params = super().request_params(stream_state, stream_slice, next_page_token) params["fields"] = f'insights.metric({",".join(POST_METRICS)})' return params def parse_response(self, response: requests.Response, **kwargs) -> Iterable[Mapping]: # unique case so we override this method records = response.json().get(self.data_field) or [] for insights in records: if insights.get("insights"): data = insights.get("insights").get("data") for insight in data: yield insight else: yield insights

noreply@github.com

3d1e771da9ec0f32bfd297a1b19794e9054adce4

1825283527f5a479204708feeaf55f4ab6d1290b

/leetcode/python/45/sol.py

3db6f97188dd189aef4c4caf07b43524d9f7f299

no_license

frankieliu/problems

b82c61d3328ffcc1da2cbc95712563355f5d44b5

911c6622448a4be041834bcab25051dd0f9209b2

refs/heads/master