Datasets:

ytzi

/

the-stack-dedup-python-filtered-docstrings

like 0

e52b2e1c1ea59fa64c3206672451d1ca75882b8f

py

Python

Contacts/urls.py

simonescob/Agendadj

badd90f3fce0950aa151840f7015c68632c7a203

Contacts/urls.py

simonescob/Agendadj

badd90f3fce0950aa151840f7015c68632c7a203

Contacts/urls.py

simonescob/Agendadj

badd90f3fce0950aa151840f7015c68632c7a203

from django.urls import path from . import views urlpatterns = [ path('', views.index, name="home"), path('all', views.index), path('create', views.create, name="create"), path('delete/<int:contact_id>', views.delete, name="delete"), path('edit/<int:contact_id>', views.edit, name="edit"), ]

from django.urls import path from . import views urlpatterns = [ path('', views.index, name="home"), path('all', views.index), path('create', views.create, name="create"), path('delete/<int:contact_id>', views.delete, name="delete"), path('edit/<int:contact_id>', views.edit, name="edit"), ]

92ad40269e21a10d36efc821460ad6ea637d560c

py

Python

glidepy.py

quantizimo/test

3d830dac676877db0a3a63ee0c482bc1b6871d6a

glidepy.py

quantizimo/test

3d830dac676877db0a3a63ee0c482bc1b6871d6a

glidepy.py

quantizimo/test

3d830dac676877db0a3a63ee0c482bc1b6871d6a

import numpy as np from scipy.optimize import fmin import math from scipy.optimize import minimize

import numpy as np from scipy.optimize import fmin import math from scipy.optimize import minimize class Glider: def __init__(self, speeds, sink_rates, weight_ref, weight=None): self._init_constants() # self.wm = 0 self.altitude = 0 self.flight_state = "on_ground" self.weight_ref = weight_ref self.weight = weight self.original_speeds = speeds self.original_sink_rates = sink_rates self._calc_scale_factor() self._scale_speeds() self._calc_polar_model() self.calc_stf_model() def _init_constants(self): self.kmh_to_knots = 0.539957 self.ms_to_knots = 1.94384 self.knots_to_kmh = 1.852 self.nm_to_feet = 6076.12 self.nm_to_sm = 1.15078 def _calc_scale_factor(self): if self.weight is None: self._scale_factor = 1.0 else: self._scale_factor = math.sqrt(self.weight / self.weight_ref) def _scale_speeds(self): self.speeds = self.kmh_to_knots * self._scale_factor * np.array(self.original_speeds) self.sink_rates = self.ms_to_knots * self._scale_factor * np.array(self.original_sink_rates) def _calc_polar_model(self): self._polar_model = np.polyfit(self.speeds, self.sink_rates, 3) def _glide_ratio2(self, speed): return speed/self.sink_rate(speed) def best_ld(self): res = minimize(self._glide_ratio2, 0, method="SLSQP") return -res.fun def best_ld_speed(self): res = minimize(self._glide_ratio2, 0, method="SLSQP") return res.x[0] def calc_stf_model(self): distance = 1 lower_limit = 0.0001 climb_range = np.arange(lower_limit, 10.5, 1) stf_values = [fmin(self.calc_total_time, 1, args=(x, distance), disp=False)[0] for x in climb_range] self._stf_model = np.polyfit(climb_range, stf_values, 4) def sink_rate(self, speed): return self.polar(speed) def polar(self, speed): return np.polyval(self._polar_model, speed) def glide_ratio(self, speed): return -speed/self.sink_rate(speed) def calc_avg_speed(self, speed, climb_rate, e=1): total_time = self.calc_total_time(speed, climb_rate, e) avg_speed = e / total_time return avg_speed def calc_total_time(self, speed, climb_rate, e=1): ws = np.polyval(self._polar_model, speed) total_time = e * (-(ws + 0) / (speed * climb_rate) + (1 / speed)) return total_time def speed_to_fly(self, climb_rate, explicit=False): if explicit: return fmin(self.calc_total_time, 1, args=[climb_rate], disp=False)[0] else: return np.polyval(self._stf_model, climb_rate) def altitude_lost(self, speed, distance): sink_rate = -(self.polar(speed)) altitude_lost = sink_rate * distance/speed return altitude_lost, altitude_lost * self.nm_to_feet def get_range(self, altitude, speed): sink_rate = self.polar(speed) glide_time = altitude/self.nm_to_feet/(-sink_rate) range1 = speed * glide_time return range1 def set_altitude(self, altitude): self.altitude = altitude self.flight_state = 'flying' def cruise(self, mc, distance): speed = self.speed_to_fly(mc) altitude_loss = self.altitude_lost(speed, distance)[1] if altitude_loss > self.altitude: self.altitude = 0 self.flight_state = "on_ground" else: self.altitude = self.altitude - altitude_loss cruise_time = distance/speed return cruise_time def climb(self, climb_step_size, climb_rate): self.altitude += climb_step_size climb_time = climb_step_size/(climb_rate * self.nm_to_feet) return climb_time class Thermals: def __init__(self, dt, distance_to_destination, distance_step): self.cum_dist = 0 self.thermals = np.array([]) while self.cum_dist <= distance_to_destination: d = np.random.exponential(dt, 1)[0] if d < distance_step: d += distance_step # make it at least a min distance of distant_step # print(d) self.thermals = np.append(self.thermals, d) self.cum_dist += d self.cum_sum = np.cumsum(self.thermals) def is_thermal(self, dist, distance_step): for d in self.cum_sum: if (d > dist) & (d < (dist + distance_step)): return d return 0

c30132e2c9779826c7032440043cdd50a86109e8

py

Python

src/dummy.py

ashesh705/master-of-coin

8ce253cd1c73005856c896a155ef25804d95d02f

src/dummy.py

ashesh705/master-of-coin

8ce253cd1c73005856c896a155ef25804d95d02f

src/dummy.py

ashesh705/master-of-coin

8ce253cd1c73005856c896a155ef25804d95d02f

""" Dummy source code to initialize repo""" from typing import Literal def dummy() -> Literal[True]: """Dummy function""" return True

""" Dummy source code to initialize repo""" from typing import Literal def dummy() -> Literal[True]: """Dummy function""" return True

202dc2c2ce0978019f7627c8b0b1ddd47cb141d2

py

Python

module.py

ShveczovaKS/8lab2k

1c58ec07c8a7fa5ed9807a7751315131f2e361f0

module.py

ShveczovaKS/8lab2k

1c58ec07c8a7fa5ed9807a7751315131f2e361f0

module.py

ShveczovaKS/8lab2k

1c58ec07c8a7fa5ed9807a7751315131f2e361f0

#!/usr/bin/env python3 # -*- coding: utf-8 -*-

#!/usr/bin/env python3 # -*- coding: utf-8 -*- def get_func(tag): def func(s): group = tag, s return group return func

df2da96dcd879b529489f9f2d167184ae6a3c44c

py

Python

ros2_and_turtlesim_deep_dive/launch/2_turtlesim_cmd_vel_publisher.launch.py

noshluk2/ROS2-Learners-Repository

2e8982a4f659c99ab90175253c28f1c10a60e31b

2021-11-27T18:18:12.000Z

2022-01-15T19:32:19.000Z

ros2_and_turtlesim_deep_dive/launch/2_turtlesim_cmd_vel_publisher.launch.py

noshluk2/ROS2-Learners-Repository

2e8982a4f659c99ab90175253c28f1c10a60e31b

ros2_and_turtlesim_deep_dive/launch/2_turtlesim_cmd_vel_publisher.launch.py

noshluk2/ROS2-Learners-Repository

2e8982a4f659c99ab90175253c28f1c10a60e31b

2021-09-02T10:49:46.000Z

2022-02-22T12:47:17.000Z

from launch import LaunchDescription from launch_ros.actions import Node

from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): return LaunchDescription([ Node( package='turtlesim', executable='turtlesim_node' ), Node( package='ros2_and_turtlesim_deep_dive', executable='ts_velocity_publisher', name='cmd_vel_publisher', output='screen' ), ])

0ba659f60c6cbb8e70fbe2ade949ed0726b3d12f

py

Python

crabageprediction/venv/Lib/site-packages/fontTools/misc/cython.py

13rianlucero/CrabAgePrediction

92bc7fbe1040f49e820473e33cc3902a5a7177c7

2015-01-01T00:15:34.000Z

2022-03-31T22:57:03.000Z

crabageprediction/venv/Lib/site-packages/fontTools/misc/cython.py

13rianlucero/CrabAgePrediction

92bc7fbe1040f49e820473e33cc3902a5a7177c7

2016-09-27T09:07:36.000Z

2022-03-31T23:04:51.000Z

crabageprediction/venv/Lib/site-packages/fontTools/misc/cython.py

13rianlucero/CrabAgePrediction

92bc7fbe1040f49e820473e33cc3902a5a7177c7

2015-01-01T08:41:17.000Z

2022-03-31T16:12:52.000Z

""" Exports a no-op 'cython' namespace similar to https://github.com/cython/cython/blob/master/Cython/Shadow.py This allows to optionally compile @cython decorated functions (when cython is available at built time), or run the same code as pure-python, without runtime dependency on cython module. We only define the symbols that we use. E.g. see fontTools.cu2qu """ from types import SimpleNamespace compiled = False for name in ("double", "complex", "int"): globals()[name] = None for name in ("cfunc", "inline"): globals()[name] = _empty_decorator locals = lambda **_: _empty_decorator returns = lambda _: _empty_decorator

""" Exports a no-op 'cython' namespace similar to https://github.com/cython/cython/blob/master/Cython/Shadow.py This allows to optionally compile @cython decorated functions (when cython is available at built time), or run the same code as pure-python, without runtime dependency on cython module. We only define the symbols that we use. E.g. see fontTools.cu2qu """ from types import SimpleNamespace def _empty_decorator(x): return x compiled = False for name in ("double", "complex", "int"): globals()[name] = None for name in ("cfunc", "inline"): globals()[name] = _empty_decorator locals = lambda **_: _empty_decorator returns = lambda _: _empty_decorator

ab9929ed3ea92aae5e1281a1b168bffd87818815

py

Python

appengine/swarming/server/acl.py

pombreda/swarming

c70f311f3db8f25752c793a0d7b36cf537d95580

appengine/swarming/server/acl.py

pombreda/swarming

c70f311f3db8f25752c793a0d7b36cf537d95580

appengine/swarming/server/acl.py

pombreda/swarming

c70f311f3db8f25752c793a0d7b36cf537d95580

2021-12-06T03:37:36.000Z

2021-12-06T03:37:36.000Z

# Copyright 2014 The Swarming Authors. All rights reserved. # Use of this source code is governed by the Apache v2.0 license that can be # found in the LICENSE file. """Defines access groups.""" from components import auth from components import utils # Names of groups. # See https://code.google.com/p/swarming/wiki/SwarmingAccessGroups for each # level. ADMINS_GROUP = 'swarming-admins' BOTS_GROUP = 'swarming-bots' PRIVILEGED_USERS_GROUP = 'swarming-privileged-users' USERS_GROUP = 'swarming-users' def is_bot_or_admin(): """Returns True if current user can execute user-side and bot-side calls.""" return is_bot() or is_admin() def get_user_type(): """Returns a string describing the current access control for the user.""" if is_admin(): return 'admin' if is_privileged_user(): return 'privileged user' if is_user(): return 'user' if is_bot(): return 'bot' return 'unknown user' def bootstrap_dev_server_acls(): """Adds localhost to IP whitelist and Swarming groups.""" assert utils.is_local_dev_server() if auth.is_replica(): return bots = auth.bootstrap_loopback_ips() auth.bootstrap_group(BOTS_GROUP, bots, 'Swarming bots') auth.bootstrap_group(USERS_GROUP, bots, 'Swarming users') # Add a swarming admin. smoke-test@example.com is used in # server_smoke_test.py admin = auth.Identity(auth.IDENTITY_USER, 'smoke-test@example.com') auth.bootstrap_group(ADMINS_GROUP, [admin], 'Swarming administrators') # Add an instance admin (for easier manual testing when running dev server). auth.bootstrap_group( auth.ADMIN_GROUP, [auth.Identity(auth.IDENTITY_USER, 'test@example.com')], 'Users that can manage groups')

# Copyright 2014 The Swarming Authors. All rights reserved. # Use of this source code is governed by the Apache v2.0 license that can be # found in the LICENSE file. """Defines access groups.""" from components import auth from components import utils # Names of groups. # See https://code.google.com/p/swarming/wiki/SwarmingAccessGroups for each # level. ADMINS_GROUP = 'swarming-admins' BOTS_GROUP = 'swarming-bots' PRIVILEGED_USERS_GROUP = 'swarming-privileged-users' USERS_GROUP = 'swarming-users' def is_admin(): return auth.is_group_member(ADMINS_GROUP) or auth.is_admin() def is_bot(): return auth.is_group_member(BOTS_GROUP) or is_admin() def is_privileged_user(): return auth.is_group_member(PRIVILEGED_USERS_GROUP) or is_admin() def is_user(): return auth.is_group_member(USERS_GROUP) or is_privileged_user() def is_bot_or_user(): return is_bot() or is_user() def is_bot_or_privileged_user(): return is_bot() or is_privileged_user() def is_bot_or_admin(): """Returns True if current user can execute user-side and bot-side calls.""" return is_bot() or is_admin() def get_user_type(): """Returns a string describing the current access control for the user.""" if is_admin(): return 'admin' if is_privileged_user(): return 'privileged user' if is_user(): return 'user' if is_bot(): return 'bot' return 'unknown user' def bootstrap_dev_server_acls(): """Adds localhost to IP whitelist and Swarming groups.""" assert utils.is_local_dev_server() if auth.is_replica(): return bots = auth.bootstrap_loopback_ips() auth.bootstrap_group(BOTS_GROUP, bots, 'Swarming bots') auth.bootstrap_group(USERS_GROUP, bots, 'Swarming users') # Add a swarming admin. smoke-test@example.com is used in # server_smoke_test.py admin = auth.Identity(auth.IDENTITY_USER, 'smoke-test@example.com') auth.bootstrap_group(ADMINS_GROUP, [admin], 'Swarming administrators') # Add an instance admin (for easier manual testing when running dev server). auth.bootstrap_group( auth.ADMIN_GROUP, [auth.Identity(auth.IDENTITY_USER, 'test@example.com')], 'Users that can manage groups')

f75d5caf71f40f210458b85e2a678429b8d45bdb

py

Python

suricata-4.1.4/suricata-update/suricata/update/commands/removesource.py

runtest007/dpdk_surcata_4.1.1

5abf91f483b418b5d9c2dd410b5c850d6ed95c5f

2019-06-17T07:05:07.000Z

2022-03-07T03:26:27.000Z

suricata-4.1.4/suricata-update/suricata/update/commands/removesource.py

clockdad/DPDK_SURICATA-4_1_1

974cc9eb54b0b1ab90eff12a95617e3e293b77d3

2019-07-18T02:32:10.000Z

2022-03-24T03:39:11.000Z

suricata-4.1.4/suricata-update/suricata/update/commands/removesource.py

clockdad/DPDK_SURICATA-4_1_1

974cc9eb54b0b1ab90eff12a95617e3e293b77d3

2019-06-18T03:31:56.000Z

2022-03-13T05:23:10.000Z

# Copyright (C) 2017 Open Information Security Foundation # # You can copy, redistribute or modify this Program under the terms of # the GNU General Public License version 2 as published by the Free # Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # version 2 along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. from __future__ import print_function import os import logging from suricata.update import config from suricata.update import sources logger = logging.getLogger()

# Copyright (C) 2017 Open Information Security Foundation # # You can copy, redistribute or modify this Program under the terms of # the GNU General Public License version 2 as published by the Free # Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # version 2 along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. from __future__ import print_function import os import logging from suricata.update import config from suricata.update import sources logger = logging.getLogger() def register(parser): parser.add_argument("name") parser.set_defaults(func=remove_source) def remove_source(): name = config.args().name enabled_source_filename = sources.get_enabled_source_filename(name) if os.path.exists(enabled_source_filename): logger.debug("Deleting file %s.", enabled_source_filename) os.remove(enabled_source_filename) logger.info("Source %s removed, previously enabled.", name) return 0 disabled_source_filename = sources.get_disabled_source_filename(name) if os.path.exists(disabled_source_filename): logger.debug("Deleting file %s.", disabled_source_filename) os.remove(disabled_source_filename) logger.info("Source %s removed, previously disabled.", name) return 0 logger.warning("Source %s does not exist.", name) return 1

3ca045d0b4c2187471f92b0e5fdbef4d90523a1c

py

Python

blogs/admin.py

AgnosticMe/phleeb

48f85048d2db5d16d243feee2f84a961682a0f4d

blogs/admin.py

AgnosticMe/phleeb

48f85048d2db5d16d243feee2f84a961682a0f4d

blogs/admin.py

AgnosticMe/phleeb

48f85048d2db5d16d243feee2f84a961682a0f4d

from django.contrib import admin from .models import Blog, Category, Tag, Comment # Register your models here. @admin.register(Blog) @admin.register(Category) @admin.register(Tag) @admin.register(Comment)

from django.contrib import admin from .models import Blog, Category, Tag, Comment # Register your models here. @admin.register(Blog) class AdminBlog(admin.ModelAdmin): list_display = ['title', 'publishing_date'] list_display_links = ['title', 'publishing_date'] list_filter = ['publishing_date', 'category', 'tag'] search_fields = ['title', 'content'] class Meta: model = Blog @admin.register(Category) class AdminCategory(admin.ModelAdmin): list_display = ['title'] search_fields = ['title'] class Meta: model = Category @admin.register(Tag) class AdminTag(admin.ModelAdmin): list_display = ['title'] search_fields = ['title'] class Meta: model = Tag @admin.register(Comment) class AdminComment(admin.ModelAdmin): search_fields = ['name', 'email', 'content', 'blog__title'] list_filter = ['publishing_date'] class Meta: model = Comment

7eab3c278fcfc42d13e8ea1b8a894c6d62712411

py

Python

zcode/inout/tests/test_inout_core.py

lzkelley/zcode

55a63693fe3ad744957d7ce2d74fb4c8e09ea8ba

2021-02-11T03:24:55.000Z

2021-02-11T03:24:55.000Z

zcode/inout/tests/test_inout_core.py

lzkelley/zcode

55a63693fe3ad744957d7ce2d74fb4c8e09ea8ba

zcode/inout/tests/test_inout_core.py

lzkelley/zcode

55a63693fe3ad744957d7ce2d74fb4c8e09ea8ba

"""Test methods for `inout_core.py`. Can be run with: $ nosetests zcode/inout/tests/test_inout_core.py """ from __future__ import absolute_import, division, print_function, unicode_literals import os import warnings import shutil from numpy.testing import run_module_suite import numpy as np from nose.tools import assert_true, assert_false, assert_equal # Run all methods as if with `nosetests ...` if __name__ == "__main__": run_module_suite()

"""Test methods for `inout_core.py`. Can be run with: $ nosetests zcode/inout/tests/test_inout_core.py """ from __future__ import absolute_import, division, print_function, unicode_literals import os import warnings import shutil from numpy.testing import run_module_suite import numpy as np from nose.tools import assert_true, assert_false, assert_equal class TestInoutCore(object): @classmethod def setup_class(cls): cls.fname_npz = '_test_inout_core_testfile.npz' cls.fname_npz_subdir = os.path.join('./subdir', cls.fname_npz) cls.test_dir_0 = '_test_inout_core_dir' cls.test_file_0 = '_test_filename.txt' cls._kill_test_files() @classmethod def teardown_class(cls): cls._kill_test_files() @classmethod def _kill_test_files(cls): # Remove created directories if os.path.exists(cls.test_dir_0): print("removing '{}'".format(cls.test_dir_0)) shutil.rmtree(cls.test_dir_0) # Remove created files if os.path.exists(cls.fname_npz_subdir): print("removing '{}'".format(cls.fname_npz_subdir)) os.remove(cls.fname_npz_subdir) tname = os.path.dirname(cls.fname_npz_subdir) print("Removing '{}'".format(tname)) os.rmdir(tname) if os.path.exists(cls.fname_npz): print("removing '{}'".format(cls.fname_npz)) os.remove(cls.fname_npz) if os.path.exists(cls.test_file_0): print("removing '{}'".format(cls.test_file_0)) os.remove(cls.test_file_0) return def test_dictToNPZ_npzToDict(self): fname = self.fname_npz fname_subdir = self.fname_npz_subdir from zcode.inout.inout_core import npzToDict, dictToNPZ # Create a test dictionary to save subdata = {'a': 'a', 'b': 'abc', 'c': np.arange(4)} data = {'one': np.array(1), 'two': np.array(2, dtype=np.uint64), 'three': subdata} # Try saving dictToNPZ(data, fname) assert_true(os.path.exists(fname)) # Try Loading loaded = npzToDict(fname) for key, item in data.items(): print("key = ", key) print("\t", type(loaded[key]), repr(loaded[key])) print("\t", type(item), repr(item)) # Look at internal dictionary separately if type(item) is not dict and type(loaded[key]) is not dict: assert_true(np.array_equal(loaded[key], item)) assert_equal(type(loaded[key]), type(item)) # Check internal dictionary subloaded = loaded['three'] print("Subloaded keys = ", subloaded.keys()) for key, item in subdata.items(): print("key = ", key) print("\t", subloaded[key]) print("\t", item) assert_true(np.array_equal(subloaded[key], item)) assert_equal(type(subloaded[key]), type(item)) # Make sure subdirectories are created if needed dictToNPZ(data, fname_subdir) assert_true(os.path.exists(fname_subdir)) def test_modify_exists_files(self): fdir = self.test_dir_0 fname = self.test_file_0 num_files = 4 max_files = 20 # This must be between [11, 100] from zcode.inout.inout_core import modify_exists, modify_filename # Create test directory if needed, store boolean whether to later remove it. if not os.path.exists(fdir): os.makedirs(fdir) # Create test filename fname = os.path.join(fdir, fname) # Make sure it doesnt already exist if os.path.exists(fname): raise RuntimeError("Test filename '{}' already exists.".format(fname)) # Create files that should *not* interfere with 'modify_exists' # 'modify_exists' should only look for 2-digit appended numbers fname_distract_1 = modify_filename(fname, append='_6') fname_distract_2 = modify_filename(fname, append='_123') print("Interference filenames = '{}', '{}'".format(fname_distract_1, fname_distract_2)) for ff in [fname_distract_1, fname_distract_2]: open(ff, 'a') # Test that filenames are appropriately modified # ---------------------------------------------- print("fname = '{}'".format(fname)) for ii in range(num_files): new_name = modify_exists(fname, max=max_files) print(ii, "new_name = ", new_name) assert_false(os.path.exists(new_name)) # Create file open(new_name, 'a') if ii == 0: intended_name = str(fname) else: intended_name = modify_filename(fname, append="_{:02d}".format(ii-1)) print("\tshould be = ", intended_name) assert_true(os.path.exists(intended_name)) if not os.path.exists(new_name): raise RuntimeError("New file should have been created '{}'.".format(new_name)) # Make sure filenames dont exceed maximum, and raises warning with warnings.catch_warnings(record=True) as ww: assert_equal(modify_exists(fname, max=num_files-1), None) assert_true(len(ww) > 0) def test_modify_exists_dirs(self): fdir = self.test_dir_0 num_files = 4 max_files = 20 # This must be between [11, 100] from zcode.inout.inout_core import modify_exists, modify_filename # Make sure directory doesn't initially exist if os.path.exists(fdir) and os.path.isdir(fdir): shutil.rmtree(fdir) ''' # Create files that should *not* interfere with 'modify_exists' # 'modify_exists' should only look for 2-digit appended numbers fname_distract_1 = modify_filename(fname, append='_6') fname_distract_2 = modify_filename(fname, append='_123') print("Interference filenames = '{}', '{}'".format(fname_distract_1, fname_distract_2)) for ff in [fname_distract_1, fname_distract_2]: open(ff, 'a') ''' # Test that filenames are appropriately modified # ---------------------------------------------- print("fname = '{}'".format(fdir)) created = [] for ii in range(num_files): new_name = modify_exists(fdir, max=max_files) print(ii, "new_name = ", new_name) assert_false(os.path.exists(new_name)) # Create directory os.makedirs(new_name) created.append(new_name) if ii == 0: intended_name = str(fdir) else: intended_name = modify_filename(fdir, append="_{:02d}".format(ii-1)) print("\tshould be = ", intended_name) assert_true(os.path.exists(intended_name)) if not os.path.exists(new_name): raise RuntimeError("New file should have been created '{}'.".format(new_name)) # Cleanup for fdir in created: shutil.rmtree(fdir) return # Run all methods as if with `nosetests ...` if __name__ == "__main__": run_module_suite()

fb8a1c89bff42274aadcbbd4e1333face551763d

py

Python

Lecture2/name.py

EusebioSimango/CS50s-Web-Programming-With-Python-And-Javascript

80df8834c1db8cc28b72d5393ff9aa340c069b57

Lecture2/name.py

EusebioSimango/CS50s-Web-Programming-With-Python-And-Javascript

80df8834c1db8cc28b72d5393ff9aa340c069b57

Lecture2/name.py

EusebioSimango/CS50s-Web-Programming-With-Python-And-Javascript

80df8834c1db8cc28b72d5393ff9aa340c069b57

name = input("Mame: ") print(f"Hello, {name}")

name = input("Mame: ") print(f"Hello, {name}")

f510ea13d343357dd5eae6dc2035a2c37e918c43

py

Python

tasksapi/models/validators.py

mwiens91/saltant

9e72175a896f5859ada304ad3ae4d84dfc3834db

2018-12-08T01:18:29.000Z

2018-12-14T23:18:42.000Z

tasksapi/models/validators.py

saltant-org/saltant

db498a1186fc74221f8214ad1819dd03bf4b08ac

2019-05-23T07:43:13.000Z

2021-06-10T20:46:53.000Z

tasksapi/models/validators.py

saltant-org/saltant

db498a1186fc74221f8214ad1819dd03bf4b08ac

2019-03-13T22:31:09.000Z

2019-05-03T00:18:30.000Z

"""Contains validators for task models.""" def task_instance_args_are_valid(instance, fill_missing_args=False): """Determines whether a task instance's arguments are valid. The arguments are valid if the instance's argument includes all of its task type's required arguments (but not necessarily the arguments for which a default value exists). Arg: instance: A task instance instance. (Yikes!) fill_missing_args: A boolean determining whether to fill in any missing arguments in the instance with default values. Returns: A tuple containing a boolean and a string, where the boolean signals whether the arguments are valid and the string explains why, in the case that the boolean is False (otherwise it's an empty string). """ # Validate an instance's args against its required args. task_type_required_args = instance.task_type.required_arguments task_type_default_vals = ( instance.task_type.required_arguments_default_values ) instance_arg_keys = instance.arguments.keys() for required_arg in task_type_required_args: # Check if the required argument is provided if required_arg not in instance_arg_keys: # Required argument not provided. Check if default argument # value exists. if required_arg not in task_type_default_vals: # No default exists return ( False, "required argument '%s' not provided!" % required_arg, ) # Fill in the default value if we're told to if fill_missing_args: instance.arguments[required_arg] = task_type_default_vals[ required_arg ] # Valid return (True, "") def task_type_args_are_valid(instance): """Determines whether a task type's argument fields are valid. The argument fields are valid if the argument keys in the required_arguments_default_values field are a subset of its required arguments. Arg: instance: A task type instance. Returns: A tuple containing a boolean and a string, where the boolean signals whether the arguments are valid and the string explains why, in the case that the boolean is False (otherwise it's an empty string). """ # Ensure that the default arguments form a subset of the required # arguments if not set(instance.required_arguments_default_values.keys()).issubset( set(instance.required_arguments) ): return (False, "default arguments not a subset of required arguments") # Valid return (True, "")

"""Contains validators for task models.""" def task_instance_args_are_valid(instance, fill_missing_args=False): """Determines whether a task instance's arguments are valid. The arguments are valid if the instance's argument includes all of its task type's required arguments (but not necessarily the arguments for which a default value exists). Arg: instance: A task instance instance. (Yikes!) fill_missing_args: A boolean determining whether to fill in any missing arguments in the instance with default values. Returns: A tuple containing a boolean and a string, where the boolean signals whether the arguments are valid and the string explains why, in the case that the boolean is False (otherwise it's an empty string). """ # Validate an instance's args against its required args. task_type_required_args = instance.task_type.required_arguments task_type_default_vals = ( instance.task_type.required_arguments_default_values ) instance_arg_keys = instance.arguments.keys() for required_arg in task_type_required_args: # Check if the required argument is provided if required_arg not in instance_arg_keys: # Required argument not provided. Check if default argument # value exists. if required_arg not in task_type_default_vals: # No default exists return ( False, "required argument '%s' not provided!" % required_arg, ) # Fill in the default value if we're told to if fill_missing_args: instance.arguments[required_arg] = task_type_default_vals[ required_arg ] # Valid return (True, "") def task_type_args_are_valid(instance): """Determines whether a task type's argument fields are valid. The argument fields are valid if the argument keys in the required_arguments_default_values field are a subset of its required arguments. Arg: instance: A task type instance. Returns: A tuple containing a boolean and a string, where the boolean signals whether the arguments are valid and the string explains why, in the case that the boolean is False (otherwise it's an empty string). """ # Ensure that the default arguments form a subset of the required # arguments if not set(instance.required_arguments_default_values.keys()).issubset( set(instance.required_arguments) ): return (False, "default arguments not a subset of required arguments") # Valid return (True, "")

b18e463d5d6fb71fac9aa5f7d292312fb8ee31b9

py

Python

semantic_segmentation/keras_metrics.py

Jason-Khan/ubdvss

76cabfa642af1f659920de32827ea6c3fe008588

2020-01-20T13:22:47.000Z

2021-11-12T07:35:36.000Z

semantic_segmentation/keras_metrics.py

Jason-Khan/ubdvss

76cabfa642af1f659920de32827ea6c3fe008588

2020-09-09T13:19:11.000Z

2020-11-15T10:52:23.000Z

semantic_segmentation/keras_metrics.py

Jason-Khan/ubdvss

76cabfa642af1f659920de32827ea6c3fe008588

2020-06-01T16:26:07.000Z

2022-03-08T02:00:45.000Z

#!/usr/bin/python # -*- coding: utf-8 -*- # Copyright (С) ABBYY (BIT Software), 1993 - 2019. All rights reserved. """ Различные метрики для keras подсчитываемые при обучении """ import functools import keras.backend as K import tensorflow as tf from semantic_segmentation.losses import get_losses @_metric_wrapper def confusion_matrix(true, pred, weights): """ Confusion matrix для бинарной классификации :param true: :param pred: :param weights: :return: tp, tn, fp, fn - confusion matrix """ equal = K.equal(true, pred) tp = tf.logical_and(equal, K.equal(true, 1)) tn = tf.logical_and(equal, K.equal(true, 0)) fp = tf.logical_and(tf.logical_not(equal), K.equal(pred, 1)) fn = tf.logical_and(tf.logical_not(equal), K.equal(pred, 0)) tp = calculate_sum(tp) tn = calculate_sum(tn) fp = calculate_sum(fp) fn = calculate_sum(fn) return tp, tn, fp, fn @_metric_wrapper def precision(true, pred, weights): """ Вычисляет precision c учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) return tp / K.maximum(1., tp + fp) @_metric_wrapper def recall(true, pred, weights): """ Вычисляет recall с учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) return tp / K.maximum(1., tp + fn) @_metric_wrapper def f1(true, pred, weights): """ Вычисляет f1-меру с учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) precision = tp / K.maximum(1., tp + fp) recall = tp / K.maximum(1., tp + fn) return tf.cond(K.not_equal(precision + recall, 0.), lambda: 2. * precision * recall / (precision + recall), lambda: 0.) def detection_pixel_acc(y_true, y_pred): """ Вычисляет попиксельную accuracy детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return _acc(detection_true, detection_pred) def detection_pixel_precision(y_true, y_pred): """ Вычисляет попиксельню точность (precision) детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return precision(detection_true, detection_pred) def detection_pixel_recall(y_true, y_pred): """ Вычисляет попиксельню полноту (recall) детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return recall(detection_true, detection_pred) def detection_pixel_f1(y_true, y_pred): """ Вычисляет попиксельню f1-меру детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return f1(detection_true, detection_pred) def classification_pixel_acc(y_true, y_pred): """ Вычисляет попиксельную accuracy классификации считается только по y_true > 0 т.е. там где есть какой-то объект :param y_true: :param y_pred: :return: """ mask = K.cast(y_true > 0, tf.float32) labels = K.cast((y_true - 1) * mask, tf.int64) class_p = tf.nn.softmax(y_pred[..., 1:], axis=-1) predictions = tf.argmax(class_p, axis=-1) return _acc(labels, predictions, weights=mask) def get_all_metrics(classification_mode=False): """ Возвращает список всех метрик :param classification_mode: :return: """ all_metrics = [ detection_pixel_acc, detection_pixel_precision, detection_pixel_recall, detection_pixel_f1 ] if classification_mode: all_metrics.append(classification_pixel_acc) all_metrics += get_losses(classification_mode) return all_metrics

#!/usr/bin/python # -*- coding: utf-8 -*- # Copyright (С) ABBYY (BIT Software), 1993 - 2019. All rights reserved. """ Различные метрики для keras подсчитываемые при обучении """ import functools import keras.backend as K import tensorflow as tf from semantic_segmentation.losses import get_losses def _squeeze_single_dims(*args): return [tf.squeeze(arg) for arg in args] def _metric_wrapper(metric_fn): @functools.wraps(metric_fn) def metric_fn_wrapped(true, pred, weights=None): if weights is None: weights = tf.ones_like(true, tf.float32) _true, _pred, _weights = _squeeze_single_dims(true, pred, weights) metric_value = metric_fn(_true, _pred, _weights) return metric_value return metric_fn_wrapped @_metric_wrapper def _acc(true, pred, weights): equal = K.cast(K.equal(true, pred), tf.float32) return K.sum(equal * weights) / K.maximum(1., K.sum(weights)) def confusion_matrix(true, pred, weights): """ Confusion matrix для бинарной классификации :param true: :param pred: :param weights: :return: tp, tn, fp, fn - confusion matrix """ equal = K.equal(true, pred) def calculate_sum(metric): m = K.cast(metric, tf.float32) return K.sum(m * weights) tp = tf.logical_and(equal, K.equal(true, 1)) tn = tf.logical_and(equal, K.equal(true, 0)) fp = tf.logical_and(tf.logical_not(equal), K.equal(pred, 1)) fn = tf.logical_and(tf.logical_not(equal), K.equal(pred, 0)) tp = calculate_sum(tp) tn = calculate_sum(tn) fp = calculate_sum(fp) fn = calculate_sum(fn) return tp, tn, fp, fn @_metric_wrapper def precision(true, pred, weights): """ Вычисляет precision c учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) return tp / K.maximum(1., tp + fp) @_metric_wrapper def recall(true, pred, weights): """ Вычисляет recall с учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) return tp / K.maximum(1., tp + fn) @_metric_wrapper def f1(true, pred, weights): """ Вычисляет f1-меру с учетом весов :param true: :param pred: :param weights: :return: """ tp, tn, fp, fn = confusion_matrix(true, pred, weights) precision = tp / K.maximum(1., tp + fp) recall = tp / K.maximum(1., tp + fn) return tf.cond(K.not_equal(precision + recall, 0.), lambda: 2. * precision * recall / (precision + recall), lambda: 0.) def _get_detection_labels(y_true, y_pred): detection_true = K.cast(K.greater(y_true, 0), tf.int32) detection_pred = K.cast(K.greater(y_pred[..., 0], 0), tf.int32) return detection_true, detection_pred def detection_pixel_acc(y_true, y_pred): """ Вычисляет попиксельную accuracy детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return _acc(detection_true, detection_pred) def detection_pixel_precision(y_true, y_pred): """ Вычисляет попиксельню точность (precision) детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return precision(detection_true, detection_pred) def detection_pixel_recall(y_true, y_pred): """ Вычисляет попиксельню полноту (recall) детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return recall(detection_true, detection_pred) def detection_pixel_f1(y_true, y_pred): """ Вычисляет попиксельню f1-меру детекции :param y_true: :param y_pred: :return: """ detection_true, detection_pred = _get_detection_labels(y_true, y_pred) return f1(detection_true, detection_pred) def classification_pixel_acc(y_true, y_pred): """ Вычисляет попиксельную accuracy классификации считается только по y_true > 0 т.е. там где есть какой-то объект :param y_true: :param y_pred: :return: """ mask = K.cast(y_true > 0, tf.float32) labels = K.cast((y_true - 1) * mask, tf.int64) class_p = tf.nn.softmax(y_pred[..., 1:], axis=-1) predictions = tf.argmax(class_p, axis=-1) return _acc(labels, predictions, weights=mask) def get_all_metrics(classification_mode=False): """ Возвращает список всех метрик :param classification_mode: :return: """ all_metrics = [ detection_pixel_acc, detection_pixel_precision, detection_pixel_recall, detection_pixel_f1 ] if classification_mode: all_metrics.append(classification_pixel_acc) all_metrics += get_losses(classification_mode) return all_metrics

a675dc6e47d5ff70decc3601d63c4681223ee3d8

py

Python

datazie/model/LinearModel.py

amozie/amozie

fb7c16ce537bc5567f9c87cfc22c564a4dffc4ef

datazie/model/LinearModel.py

amozie/amozie

fb7c16ce537bc5567f9c87cfc22c564a4dffc4ef

datazie/model/LinearModel.py

amozie/amozie

fb7c16ce537bc5567f9c87cfc22c564a4dffc4ef

# -*- coding: utf-8 -*- """ Created on %(date)s @author: %(username)s """ import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn import linear_model import statsmodels.api as sm from statsmodels.sandbox.regression.predstd import wls_prediction_std model_sm = 'sm' if __name__ == '__main__': x = np.linspace(0, 10, 21) y = 3*x + 2 y += np.random.randn(x.size) lm = LinearModel(y, x) lm.fit() lm.summary() print(lm.predict()) lm.plot()

# -*- coding: utf-8 -*- """ Created on %(date)s @author: %(username)s """ import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn import linear_model import statsmodels.api as sm from statsmodels.sandbox.regression.predstd import wls_prediction_std model_sm = 'sm' class ModelException(Exception): def __init__(self, message): super().__init__(self) self.message = message class LinearModel(): def __init__(self, y, x=None, model=model_sm, add_constant=None): self.model = model self.add_constant = add_constant self.__features = None if x is None: x = np.arange(y.size) self.x = self.__pretreat_params(x) self.y = y def __pretreat_params(self, x): if not isinstance(x, np.ndarray): x = np.array(x) if not self.__features: if 1 == x.ndim: self.__features = 1 elif 2 == x.ndim: self.__features = x.shape[1] else: raise ModelException('dimension of x is error') if 2 != x.ndim: x = x.reshape(-1, self.__features) if self.add_constant is None: if model_sm == self.model: x = self.__add_constant(x) elif self.add_constant: x = self.__add_constant(x) return x def __add_constant(self, x): # 样本数为1时，sm.add_constant存在bug，没有添加常数返回原数组 if 1 == x.shape[0]: return np.concatenate((np.ones((x.shape[0], 1)), x), axis=1) else: return sm.add_constant(x) def __fit_sm(self): self.res = sm.OLS(self.y, self.x).fit() def fit(self): if model_sm == self.model: self.__fit_sm() def predict(self, x=None, alpha=0.05): if x is not None: x = self.__pretreat_params(x) ret = [self.res.predict(x)] ret.extend(wls_prediction_std(self.res, exog=x, alpha=alpha)) return np.array(ret).T def summary(self): print(self.res.summary()) def plot(self): fig = plt.figure() fig.suptitle('LINEAR MODEL') ax = plt.subplot(111) y_prd = self.predict(alpha=0.1) ax.plot(self.x[:, 1], self.y, '*', label='sample') ax.plot(self.x[:, 1], y_prd[:, 0], label='predict') ax.plot(self.x[:, 1], y_prd[:, 2], 'r--', label='std') ax.plot(self.x[:, 1], y_prd[:, 3], 'r--', label='std') plt.show() if __name__ == '__main__': x = np.linspace(0, 10, 21) y = 3*x + 2 y += np.random.randn(x.size) lm = LinearModel(y, x) lm.fit() lm.summary() print(lm.predict()) lm.plot()

b67a3f691f33184cbbf6898ebf7144756349476d

py

Python

utilities.py

rc1035/directed-probe-matching

c724096672e778202d9e8ed197cdf7395ea1d211

2017-08-16T12:16:52.000Z

2022-02-26T05:09:39.000Z

utilities.py

d15c0/directed-probe-matching

c724096672e778202d9e8ed197cdf7395ea1d211

2019-07-10T12:00:00.000Z

2019-07-10T12:00:00.000Z

utilities.py

d15c0/directed-probe-matching

c724096672e778202d9e8ed197cdf7395ea1d211

2017-11-30T11:01:06.000Z

2019-11-03T23:39:40.000Z

#!/usr/bin/env python3.6 """Refactored utility functions.""" __author__ = "Richard Cosgrove" from collections import defaultdict import gzip from itertools import combinations from datetime import datetime, timedelta import json import os def export_compressed_json(dict_item, file_name): """Export gzip compressed JSON. (For Uni dataset compressed size is ~10% of uncompressed.) :param dict_item: Dictionary to dump as JSON. :param file_name: Name of file to be written e.g. dict.json.gz """ # Use lowest level of compression for fast speed. os.makedirs(os.path.dirname(file_name), exist_ok=True) with gzip.open(file_name, mode="wt", compresslevel=1) as f: json.dump(dict_item, f, separators=(',', ':')) def import_compressed_json(file_name): """Import gzip compressed JSON. :param file_name: Name of file to be read e.g. dict.json.gz :returns: JSON as a dictionary. """ with gzip.open(file_name, mode="rt") as f: return json.load(f) def match_tokens_with_same_ssid_set(token_to_probes): """Split into clusters that share the SAME set of SSIDs probed for. :param token_to_probes: Dictionary with token keys and probe values :returns: Dictionary with SSID set keys and token values """ ssid_set_to_tokens = defaultdict(set) token_to_ssid_set = {} for token, probes in token_to_probes.items(): ssid_set = set() for probe in probes: if probe["ssid"] == 0: # Ignore broadcast probes. continue ssid_set.add(probe["ssid"]) if len(ssid_set) < 2: # Ignore sets with cardinality less than X # due to high rate of false positives. continue # Cluster token with any tokens that share the same SSID set. ssid_set_to_tokens[frozenset(ssid_set)].add(token) token_to_ssid_set[token] = frozenset(ssid_set) # Sanity check: Assert that no token has been matched more than once. tokens = [t for tokens in list(ssid_set_to_tokens.values()) for t in tokens] assert(len(tokens) == len(set(tokens))) return (ssid_set_to_tokens, token_to_ssid_set) def validate_clusters(clusters, token_to_probes): """Validate the correctness of a clustering. :param clusters: An iterable of clusters, where each cluster is a list of tokens. :returns: Dictionary of binary classifier results """ token_to_mac = import_compressed_json("int/token_to_mac.json.gz") # Use a binary Classification true_positives, false_positives = 0, 0 num_of_clusters = 0 mac_to_timestamps = defaultdict(list) for cluster in clusters: num_of_clusters += 1 for pair in combinations(cluster, r=2): if token_to_mac[pair[0]] == token_to_mac[pair[1]]: true_positives += 1 mac = token_to_mac[pair[0]] t1_timestamps = [float(p["timestamp"]) for p in token_to_probes[pair[0]]] t2_timestamps = [float(p["timestamp"]) for p in token_to_probes[pair[1]]] mac_to_timestamps[mac] += t1_timestamps mac_to_timestamps[mac] += t2_timestamps else: false_positives += 1 greater_than = 0 lengths = [] for mac, timestamps in mac_to_timestamps.items(): length = timedelta(seconds=max(timestamps)) - timedelta(seconds=min(timestamps)) if length > timedelta(hours=12): greater_than += 1 lengths.append(length) import statistics mid = statistics.median(lengths) # Total number of valid pairs and invalid pairs have been # pre-computed in randomiseTokens.py ... # So we can easily calculate the negatives by subtracting the positives. actual_combos = import_compressed_json("int/valid_combinations.json.gz") true_negatives = actual_combos["invalid_pairs"] - false_positives false_negatives = actual_combos["valid_pairs"] - true_positives # Sanity checks assert(true_positives + false_positives + true_negatives + false_negatives == actual_combos["total_pairs"]) assert(true_positives + false_negatives == actual_combos["valid_pairs"]) assert(false_positives + true_negatives == actual_combos["invalid_pairs"]) true_positive_rate = (true_positives / (float(true_positives + false_negatives))) false_positive_rate = (false_positives / (float(false_positives + true_negatives))) accuracy = (true_positives + true_negatives) / float(actual_combos["total_pairs"]) return { "tp": true_positives, "fp": false_positives, "tn": true_negatives, "fn": false_negatives, "tpr": true_positive_rate, "fpr": false_positive_rate, "accuracy": accuracy, "clusters": num_of_clusters, "macs": greater_than, "median": mid }

#!/usr/bin/env python3.6 """Refactored utility functions.""" __author__ = "Richard Cosgrove" from collections import defaultdict import gzip from itertools import combinations from datetime import datetime, timedelta import json import os def export_compressed_json(dict_item, file_name): """Export gzip compressed JSON. (For Uni dataset compressed size is ~10% of uncompressed.) :param dict_item: Dictionary to dump as JSON. :param file_name: Name of file to be written e.g. dict.json.gz """ # Use lowest level of compression for fast speed. os.makedirs(os.path.dirname(file_name), exist_ok=True) with gzip.open(file_name, mode="wt", compresslevel=1) as f: json.dump(dict_item, f, separators=(',', ':')) def import_compressed_json(file_name): """Import gzip compressed JSON. :param file_name: Name of file to be read e.g. dict.json.gz :returns: JSON as a dictionary. """ with gzip.open(file_name, mode="rt") as f: return json.load(f) def match_tokens_with_same_ssid_set(token_to_probes): """Split into clusters that share the SAME set of SSIDs probed for. :param token_to_probes: Dictionary with token keys and probe values :returns: Dictionary with SSID set keys and token values """ ssid_set_to_tokens = defaultdict(set) token_to_ssid_set = {} for token, probes in token_to_probes.items(): ssid_set = set() for probe in probes: if probe["ssid"] == 0: # Ignore broadcast probes. continue ssid_set.add(probe["ssid"]) if len(ssid_set) < 2: # Ignore sets with cardinality less than X # due to high rate of false positives. continue # Cluster token with any tokens that share the same SSID set. ssid_set_to_tokens[frozenset(ssid_set)].add(token) token_to_ssid_set[token] = frozenset(ssid_set) # Sanity check: Assert that no token has been matched more than once. tokens = [t for tokens in list(ssid_set_to_tokens.values()) for t in tokens] assert(len(tokens) == len(set(tokens))) return (ssid_set_to_tokens, token_to_ssid_set) def validate_clusters(clusters, token_to_probes): """Validate the correctness of a clustering. :param clusters: An iterable of clusters, where each cluster is a list of tokens. :returns: Dictionary of binary classifier results """ token_to_mac = import_compressed_json("int/token_to_mac.json.gz") # Use a binary Classification true_positives, false_positives = 0, 0 num_of_clusters = 0 mac_to_timestamps = defaultdict(list) for cluster in clusters: num_of_clusters += 1 for pair in combinations(cluster, r=2): if token_to_mac[pair[0]] == token_to_mac[pair[1]]: true_positives += 1 mac = token_to_mac[pair[0]] t1_timestamps = [float(p["timestamp"]) for p in token_to_probes[pair[0]]] t2_timestamps = [float(p["timestamp"]) for p in token_to_probes[pair[1]]] mac_to_timestamps[mac] += t1_timestamps mac_to_timestamps[mac] += t2_timestamps else: false_positives += 1 greater_than = 0 lengths = [] for mac, timestamps in mac_to_timestamps.items(): length = timedelta(seconds=max(timestamps)) - timedelta(seconds=min(timestamps)) if length > timedelta(hours=12): greater_than += 1 lengths.append(length) import statistics mid = statistics.median(lengths) # Total number of valid pairs and invalid pairs have been # pre-computed in randomiseTokens.py ... # So we can easily calculate the negatives by subtracting the positives. actual_combos = import_compressed_json("int/valid_combinations.json.gz") true_negatives = actual_combos["invalid_pairs"] - false_positives false_negatives = actual_combos["valid_pairs"] - true_positives # Sanity checks assert(true_positives + false_positives + true_negatives + false_negatives == actual_combos["total_pairs"]) assert(true_positives + false_negatives == actual_combos["valid_pairs"]) assert(false_positives + true_negatives == actual_combos["invalid_pairs"]) true_positive_rate = (true_positives / (float(true_positives + false_negatives))) false_positive_rate = (false_positives / (float(false_positives + true_negatives))) accuracy = (true_positives + true_negatives) / float(actual_combos["total_pairs"]) return { "tp": true_positives, "fp": false_positives, "tn": true_negatives, "fn": false_negatives, "tpr": true_positive_rate, "fpr": false_positive_rate, "accuracy": accuracy, "clusters": num_of_clusters, "macs": greater_than, "median": mid }

0e899a0c6dc84c26eed43123ac191ce6e094f3ae

py

Python

nautobot/users/tests/test_models.py

psmware-ltd/nautobot

ac516287fb8edcc3482bd011839de837c6bbf0df

2021-02-24T01:40:40.000Z

2022-03-30T10:30:59.000Z

nautobot/users/tests/test_models.py

psmware-ltd/nautobot

ac516287fb8edcc3482bd011839de837c6bbf0df

2021-02-24T00:58:08.000Z

2022-03-31T23:38:23.000Z

nautobot/users/tests/test_models.py

psmware-ltd/nautobot

ac516287fb8edcc3482bd011839de837c6bbf0df

2021-02-24T02:45:16.000Z

2022-03-20T18:48:36.000Z

from django.contrib.auth import get_user_model from django.test import TestCase # Use the proper swappable User model User = get_user_model()

from django.contrib.auth import get_user_model from django.test import TestCase # Use the proper swappable User model User = get_user_model() class UserConfigTest(TestCase): def setUp(self): user = User.objects.create_user(username="testuser") user.config_data = { "a": True, "b": { "foo": 101, "bar": 102, }, "c": { "foo": { "x": 201, }, "bar": { "y": 202, }, "baz": { "z": 203, }, }, } user.save() self.user = user def test_get(self): # Retrieve root and nested values self.assertEqual(self.user.get_config("a"), True) self.assertEqual(self.user.get_config("b.foo"), 101) self.assertEqual(self.user.get_config("c.baz.z"), 203) # Invalid values should return None self.assertIsNone(self.user.get_config("invalid")) self.assertIsNone(self.user.get_config("a.invalid")) self.assertIsNone(self.user.get_config("b.foo.invalid")) self.assertIsNone(self.user.get_config("b.foo.x.invalid")) # Invalid values with a provided default should return the default self.assertEqual(self.user.get_config("invalid", "DEFAULT"), "DEFAULT") self.assertEqual(self.user.get_config("a.invalid", "DEFAULT"), "DEFAULT") self.assertEqual(self.user.get_config("b.foo.invalid", "DEFAULT"), "DEFAULT") self.assertEqual(self.user.get_config("b.foo.x.invalid", "DEFAULT"), "DEFAULT") def test_all(self): flattened_data = { "a": True, "b.foo": 101, "b.bar": 102, "c.foo.x": 201, "c.bar.y": 202, "c.baz.z": 203, } # Retrieve a flattened dictionary containing all config data self.assertEqual(self.user.all_config(), flattened_data) def test_set(self): # Overwrite existing values self.user.set_config("a", "abc") self.user.set_config("c.foo.x", "abc") self.assertEqual(self.user.config_data["a"], "abc") self.assertEqual(self.user.config_data["c"]["foo"]["x"], "abc") # Create new values self.user.set_config("d", "abc") self.user.set_config("b.baz", "abc") self.assertEqual(self.user.config_data["d"], "abc") self.assertEqual(self.user.config_data["b"]["baz"], "abc") # Set a value and commit to the database self.user.set_config("a", "def", commit=True) self.user.refresh_from_db() self.assertEqual(self.user.config_data["a"], "def") # Attempt to change a branch node to a leaf node with self.assertRaises(TypeError): self.user.set_config("b", 1) # Attempt to change a leaf node to a branch node with self.assertRaises(TypeError): self.user.set_config("a.x", 1) def test_clear(self): # Clear existing values self.user.clear_config("a") self.user.clear_config("b.foo") self.assertTrue("a" not in self.user.config_data) self.assertTrue("foo" not in self.user.config_data["b"]) self.assertEqual(self.user.config_data["b"]["bar"], 102) # Clear a non-existing value; should fail silently self.user.clear_config("invalid")

58ff00ab9dd53405c8606240357d386f8a7c8414

py

Python

lib/googlecloudsdk/api_lib/sql/instances.py

bopopescu/Google-Cloud-SDK-1

c4683bacb2f6192d8a816932e438a0493085469b

lib/googlecloudsdk/api_lib/sql/instances.py

bopopescu/Google-Cloud-SDK-1

c4683bacb2f6192d8a816932e438a0493085469b

lib/googlecloudsdk/api_lib/sql/instances.py

bopopescu/Google-Cloud-SDK-1

c4683bacb2f6192d8a816932e438a0493085469b

2020-07-24T20:13:29.000Z

2020-07-24T20:13:29.000Z

# Copyright 2016 Google Inc. 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. """Common utility functions for sql instances.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from apitools.base.py import list_pager from googlecloudsdk.api_lib.sql import api_util from googlecloudsdk.core import properties from googlecloudsdk.core.console import console_io _POSTGRES_DATABASE_VERSION_PREFIX = 'POSTGRES' class _BaseInstances(object): """Common utility functions for sql instances.""" @staticmethod def GetDatabaseInstances(limit=None, batch_size=None): """Gets SQL instances in a given project. Modifies current state of an individual instance to 'STOPPED' if activationPolicy is 'NEVER'. Args: limit: int, The maximum number of records to yield. None if all available records should be yielded. batch_size: int, The number of items to retrieve per request. Returns: List of yielded sql_messages.DatabaseInstance instances. """ client = api_util.SqlClient(api_util.API_VERSION_DEFAULT) sql_client = client.sql_client sql_messages = client.sql_messages project_id = properties.VALUES.core.project.Get(required=True) params = {} if limit is not None: params['limit'] = limit if batch_size is not None: params['batch_size'] = batch_size yielded = list_pager.YieldFromList( sql_client.instances, sql_messages.SqlInstancesListRequest(project=project_id), **params) return YieldInstancesWithAModifiedState() @staticmethod @staticmethod def IsPostgresDatabaseVersion(database_version): """Returns a boolean indicating if the database version is Postgres.""" return _POSTGRES_DATABASE_VERSION_PREFIX in database_version class InstancesV1Beta3(_BaseInstances): """Common utility functions for sql instances V1Beta3.""" @staticmethod @staticmethod class InstancesV1Beta4(_BaseInstances): """Common utility functions for sql instances V1Beta4.""" @staticmethod @staticmethod

# Copyright 2016 Google Inc. 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. """Common utility functions for sql instances.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from apitools.base.py import list_pager from googlecloudsdk.api_lib.sql import api_util from googlecloudsdk.core import properties from googlecloudsdk.core.console import console_io _POSTGRES_DATABASE_VERSION_PREFIX = 'POSTGRES' class _BaseInstances(object): """Common utility functions for sql instances.""" @staticmethod def GetDatabaseInstances(limit=None, batch_size=None): """Gets SQL instances in a given project. Modifies current state of an individual instance to 'STOPPED' if activationPolicy is 'NEVER'. Args: limit: int, The maximum number of records to yield. None if all available records should be yielded. batch_size: int, The number of items to retrieve per request. Returns: List of yielded sql_messages.DatabaseInstance instances. """ client = api_util.SqlClient(api_util.API_VERSION_DEFAULT) sql_client = client.sql_client sql_messages = client.sql_messages project_id = properties.VALUES.core.project.Get(required=True) params = {} if limit is not None: params['limit'] = limit if batch_size is not None: params['batch_size'] = batch_size yielded = list_pager.YieldFromList( sql_client.instances, sql_messages.SqlInstancesListRequest(project=project_id), **params) def YieldInstancesWithAModifiedState(): for result in yielded: # TODO(b/63139112): Investigate impact of instances without settings. if result.settings and result.settings.activationPolicy == 'NEVER': result.state = 'STOPPED' yield result return YieldInstancesWithAModifiedState() @staticmethod def PrintAndConfirmAuthorizedNetworksOverwrite(): console_io.PromptContinue( message='When adding a new IP address to authorized networks, ' 'make sure to also include any IP addresses that have already been ' 'authorized. Otherwise, they will be overwritten and de-authorized.', default=True, cancel_on_no=True) @staticmethod def IsPostgresDatabaseVersion(database_version): """Returns a boolean indicating if the database version is Postgres.""" return _POSTGRES_DATABASE_VERSION_PREFIX in database_version class InstancesV1Beta3(_BaseInstances): """Common utility functions for sql instances V1Beta3.""" @staticmethod def SetProjectAndInstanceFromRef(instance_resource, instance_ref): instance_resource.project = instance_ref.project instance_resource.instance = instance_ref.instance @staticmethod def AddBackupConfigToSettings(settings, backup_config): settings.backupConfiguration = [backup_config] class InstancesV1Beta4(_BaseInstances): """Common utility functions for sql instances V1Beta4.""" @staticmethod def SetProjectAndInstanceFromRef(instance_resource, instance_ref): instance_resource.project = instance_ref.project instance_resource.name = instance_ref.instance @staticmethod def AddBackupConfigToSettings(settings, backup_config): settings.backupConfiguration = backup_config

a6e3fb81075849bc5006590462c1692cddcd0b28

py

Python

catalog/general/catalog_logger.py

eoss-cloud/madxxx_catalog_api

ef37374a36129de4f0a6fe5dd46b5bc2e2f01d1d

catalog/general/catalog_logger.py

eoss-cloud/madxxx_catalog_api

ef37374a36129de4f0a6fe5dd46b5bc2e2f01d1d

catalog/general/catalog_logger.py

eoss-cloud/madxxx_catalog_api

ef37374a36129de4f0a6fe5dd46b5bc2e2f01d1d

#-*- coding: utf-8 -*- """ EOSS catalog system Custom logger Default configuration file within this directory is used to control logging behaviour; can be overwritten with LOGGING_CONF which points to local logging configuration """ __author__ = "Thilo Wehrmann, Steffen Gebhardt" __copyright__ = "Copyright 2016, EOSS GmbH" __credits__ = ["Thilo Wehrmann", "Steffen Gebhardt"] __license__ = "GPL" __version__ = "1.0.0" __maintainer__ = "Thilo Wehrmann" __email__ = "twehrmann@eoss.cloud" __status__ = "Production" import logging from logging.config import fileConfig import os from utilities import read_OS_var try: # Python 2.7+ from logging import NullHandler except ImportError: if read_OS_var('LOGGING_CONF', mandatory=False) == None: path = os.path.dirname(__file__) log_config_file = os.path.join(path, 'logging.ini') else: log_config_file = read_OS_var('LOGGING_CONF', mandatory=False) fileConfig(log_config_file) logger = logging.getLogger() logger.addHandler(NullHandler()) logging.getLogger(__name__).addHandler(NullHandler()) # Configure default logger to do nothing notificator = logging.getLogger('EOSS:notification') heartbeat_log = logging.getLogger('EOSS:heartbeat') tracer_log = logging.getLogger('EOSS:tracer') CALL = 41 START = 42 BEATING = 43 STOP = 44 STROKE = 45 HEALTH = 46 logging.addLevelName(CALL, 'CALL') logging.addLevelName(BEATING, 'BEATING') logging.addLevelName(BEATING, 'BEATING') logging.addLevelName(STROKE, 'STROKE') logging.addLevelName(HEALTH, 'HEALTH') logging.addLevelName(START, 'START BEAT') logging.addLevelName(STOP, 'STOP BEAT') # 3rd party logger configuration logging.getLogger('boto3.resources.action').setLevel(logging.WARNING) logging.getLogger('botocore.vendored.requests.packages.urllib3.connectionpool').setLevel(logging.WARNING)

#-*- coding: utf-8 -*- """ EOSS catalog system Custom logger Default configuration file within this directory is used to control logging behaviour; can be overwritten with LOGGING_CONF which points to local logging configuration """ __author__ = "Thilo Wehrmann, Steffen Gebhardt" __copyright__ = "Copyright 2016, EOSS GmbH" __credits__ = ["Thilo Wehrmann", "Steffen Gebhardt"] __license__ = "GPL" __version__ = "1.0.0" __maintainer__ = "Thilo Wehrmann" __email__ = "twehrmann@eoss.cloud" __status__ = "Production" import logging from logging.config import fileConfig import os from utilities import read_OS_var try: # Python 2.7+ from logging import NullHandler except ImportError: class NullHandler(logging.Handler): def emit(self, record): pass if read_OS_var('LOGGING_CONF', mandatory=False) == None: path = os.path.dirname(__file__) log_config_file = os.path.join(path, 'logging.ini') else: log_config_file = read_OS_var('LOGGING_CONF', mandatory=False) fileConfig(log_config_file) logger = logging.getLogger() logger.addHandler(NullHandler()) logging.getLogger(__name__).addHandler(NullHandler()) # Configure default logger to do nothing notificator = logging.getLogger('EOSS:notification') heartbeat_log = logging.getLogger('EOSS:heartbeat') tracer_log = logging.getLogger('EOSS:tracer') CALL = 41 START = 42 BEATING = 43 STOP = 44 STROKE = 45 HEALTH = 46 logging.addLevelName(CALL, 'CALL') logging.addLevelName(BEATING, 'BEATING') logging.addLevelName(BEATING, 'BEATING') logging.addLevelName(STROKE, 'STROKE') logging.addLevelName(HEALTH, 'HEALTH') logging.addLevelName(START, 'START BEAT') logging.addLevelName(STOP, 'STOP BEAT') # 3rd party logger configuration logging.getLogger('boto3.resources.action').setLevel(logging.WARNING) logging.getLogger('botocore.vendored.requests.packages.urllib3.connectionpool').setLevel(logging.WARNING)

25781249bb36750915e0251ce1e74e198d0fa28a

py

Python

deeplearning/ml4pl/models/batch.py

Zacharias030/ProGraML

cd99d2c5362acd0b24ee224492bb3e8c4d4736fb

deeplearning/ml4pl/models/batch.py

Zacharias030/ProGraML

cd99d2c5362acd0b24ee224492bb3e8c4d4736fb

2020-07-27T08:22:06.000Z

2020-07-30T17:34:35.000Z

deeplearning/ml4pl/models/batch.py

Zacharias030/ProGraML

cd99d2c5362acd0b24ee224492bb3e8c4d4736fb

2020-06-05T04:58:13.000Z

2020-06-05T04:58:13.000Z

# Copyright 2019 the ProGraML authors. # # Contact Chris Cummins <chrisc.101@gmail.com>. # # 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. """This file contains TODO: one line summary. TODO: Detailed explanation of the file. """ from typing import Any from typing import Iterable from typing import List from typing import NamedTuple from typing import Optional import numpy as np import sklearn.metrics from labm8.py import app FLAGS = app.FLAGS app.DEFINE_string( "batch_scores_averaging_method", "weighted", "Selects the averaging method to use when computing recall/precision/F1 " "scores. See <https://scikit-learn.org/stable/modules/generated/sklearn" ".metrics.f1_score.html>", ) class Data(NamedTuple): """The model data for a batch.""" graph_ids: List[int] data: Any # A flag used to mark that this batch is the end of an iterable sequences of # batches. end_of_batches: bool = False @property def EmptyBatch() -> Data: """Construct an empty batch.""" return Data(graph_ids=[], data=None) def EndOfBatches() -> Data: """Construct a 'end of batches' marker.""" return Data(graph_ids=[], data=None, end_of_batches=True) class BatchIterator(NamedTuple): """A batch iterator""" batches: Iterable[Data] # The total number of graphs in all of the batches. graph_count: int class Results(NamedTuple): """The results of running a batch through a model. Don't instantiate this tuple directly, use Results.Create(). """ targets: np.array predictions: np.array # The number of model iterations to compute the final results. This is used # by iterative models such as message passing networks. iteration_count: int # For iterative models, this indicates whether the state of the model at # iteration_count had converged on a solution. model_converged: bool # The learning rate and loss of models, if applicable. learning_rate: Optional[float] loss: Optional[float] # Batch-level average performance metrics. accuracy: float precision: float recall: float f1: float @property @property @property def target_count(self) -> int: """Get the number of targets in the batch. For graph-level classifiers, this will be equal to Data.graph_count, else it's equal to the batch node count. """ return self.targets.shape[1] def __eq__(self, rhs: "Results"): """Compare batch results.""" return self.accuracy == rhs.accuracy def __gt__(self, rhs: "Results"): """Compare batch results.""" return self.accuracy > rhs.accuracy @classmethod def Create( cls, targets: np.array, predictions: np.array, iteration_count: int = 1, model_converged: bool = True, learning_rate: Optional[float] = None, loss: Optional[float] = None, ): """Construct a results instance from 1-hot targets and predictions. This is the preferred means of construct a Results instance, which takes care of evaluating all of the metrics for you. The behavior of metrics calculation is dependent on the --batch_scores_averaging_method flag. Args: targets: An array of 1-hot target vectors with shape (y_count, y_dimensionality), dtype int32. predictions: An array of 1-hot prediction vectors with shape (y_count, y_dimensionality), dtype int32. iteration_count: For iterative models, the number of model iterations to compute the final result. model_converged: For iterative models, whether model converged. learning_rate: The model learning rate, if applicable. loss: The model loss, if applicable. Returns: A Results instance. """ if targets.shape != predictions.shape: raise TypeError( f"Expected model to produce targets with shape {targets.shape} but " f"instead received predictions with shape {predictions.shape}" ) y_dimensionality = targets.shape[1] if y_dimensionality < 2: raise TypeError( f"Expected label dimensionality > 1, received {y_dimensionality}" ) # Create dense arrays of shape (target_count). true_y = np.argmax(targets, axis=1) pred_y = np.argmax(predictions, axis=1) # NOTE(github.com/ChrisCummins/ProGraML/issues/22): This assumes that # labels use the values [0,...n). labels = np.arange(y_dimensionality, dtype=np.int64) return cls( targets=targets, predictions=predictions, iteration_count=iteration_count, model_converged=model_converged, learning_rate=learning_rate, loss=loss, accuracy=sklearn.metrics.accuracy_score(true_y, pred_y), precision=sklearn.metrics.precision_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), recall=sklearn.metrics.recall_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), f1=sklearn.metrics.f1_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), ) class RollingResults: """Maintain weighted rolling averages across batches.""" def Update( self, data: Data, results: Results, weight: Optional[float] = None ) -> None: """Update the rolling results with a new batch. Args: data: The batch data used to produce the results. results: The batch results to update the current state with. weight: A weight to assign to weighted sums. E.g. to weight results across all targets, use weight=results.target_count. To weight across targets, use weight=batch.target_count. To weight across graphs, use weight=batch.graph_count. By default, weight by target count. """ if weight is None: weight = results.target_count self.weight_sum += weight self.batch_count += 1 self.graph_count += data.graph_count self.target_count += results.target_count self.weighted_iteration_count_sum += results.iteration_count * weight self.weighted_model_converged_sum += ( weight if results.model_converged else 0 ) if results.has_learning_rate: self.has_learning_rate = True self.weighted_learning_rate_sum += results.learning_rate * weight if results.has_loss: self.has_loss = True self.weighted_loss_sum += results.loss * weight self.weighted_accuracy_sum += results.accuracy * weight self.weighted_precision_sum += results.precision * weight self.weighted_recall_sum += results.recall * weight self.weighted_f1_sum += results.f1 * weight @property @property @property @property @property @property @property @property

# Copyright 2019 the ProGraML authors. # # Contact Chris Cummins <chrisc.101@gmail.com>. # # 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. """This file contains TODO: one line summary. TODO: Detailed explanation of the file. """ from typing import Any from typing import Iterable from typing import List from typing import NamedTuple from typing import Optional import numpy as np import sklearn.metrics from labm8.py import app FLAGS = app.FLAGS app.DEFINE_string( "batch_scores_averaging_method", "weighted", "Selects the averaging method to use when computing recall/precision/F1 " "scores. See <https://scikit-learn.org/stable/modules/generated/sklearn" ".metrics.f1_score.html>", ) class Data(NamedTuple): """The model data for a batch.""" graph_ids: List[int] data: Any # A flag used to mark that this batch is the end of an iterable sequences of # batches. end_of_batches: bool = False @property def graph_count(self) -> int: return len(self.graph_ids) def EmptyBatch() -> Data: """Construct an empty batch.""" return Data(graph_ids=[], data=None) def EndOfBatches() -> Data: """Construct a 'end of batches' marker.""" return Data(graph_ids=[], data=None, end_of_batches=True) class BatchIterator(NamedTuple): """A batch iterator""" batches: Iterable[Data] # The total number of graphs in all of the batches. graph_count: int class Results(NamedTuple): """The results of running a batch through a model. Don't instantiate this tuple directly, use Results.Create(). """ targets: np.array predictions: np.array # The number of model iterations to compute the final results. This is used # by iterative models such as message passing networks. iteration_count: int # For iterative models, this indicates whether the state of the model at # iteration_count had converged on a solution. model_converged: bool # The learning rate and loss of models, if applicable. learning_rate: Optional[float] loss: Optional[float] # Batch-level average performance metrics. accuracy: float precision: float recall: float f1: float @property def has_learning_rate(self) -> bool: return self.learning_rate is not None @property def has_loss(self) -> bool: return self.loss is not None @property def target_count(self) -> int: """Get the number of targets in the batch. For graph-level classifiers, this will be equal to Data.graph_count, else it's equal to the batch node count. """ return self.targets.shape[1] def __repr__(self) -> str: return ( f"accuracy={self.accuracy:.2%}%, " f"precision={self.precision:.3f}, " f"recall={self.recall:.3f}, " f"f1={self.f1:.3f}" ) def __eq__(self, rhs: "Results"): """Compare batch results.""" return self.accuracy == rhs.accuracy def __gt__(self, rhs: "Results"): """Compare batch results.""" return self.accuracy > rhs.accuracy @classmethod def Create( cls, targets: np.array, predictions: np.array, iteration_count: int = 1, model_converged: bool = True, learning_rate: Optional[float] = None, loss: Optional[float] = None, ): """Construct a results instance from 1-hot targets and predictions. This is the preferred means of construct a Results instance, which takes care of evaluating all of the metrics for you. The behavior of metrics calculation is dependent on the --batch_scores_averaging_method flag. Args: targets: An array of 1-hot target vectors with shape (y_count, y_dimensionality), dtype int32. predictions: An array of 1-hot prediction vectors with shape (y_count, y_dimensionality), dtype int32. iteration_count: For iterative models, the number of model iterations to compute the final result. model_converged: For iterative models, whether model converged. learning_rate: The model learning rate, if applicable. loss: The model loss, if applicable. Returns: A Results instance. """ if targets.shape != predictions.shape: raise TypeError( f"Expected model to produce targets with shape {targets.shape} but " f"instead received predictions with shape {predictions.shape}" ) y_dimensionality = targets.shape[1] if y_dimensionality < 2: raise TypeError( f"Expected label dimensionality > 1, received {y_dimensionality}" ) # Create dense arrays of shape (target_count). true_y = np.argmax(targets, axis=1) pred_y = np.argmax(predictions, axis=1) # NOTE(github.com/ChrisCummins/ProGraML/issues/22): This assumes that # labels use the values [0,...n). labels = np.arange(y_dimensionality, dtype=np.int64) return cls( targets=targets, predictions=predictions, iteration_count=iteration_count, model_converged=model_converged, learning_rate=learning_rate, loss=loss, accuracy=sklearn.metrics.accuracy_score(true_y, pred_y), precision=sklearn.metrics.precision_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), recall=sklearn.metrics.recall_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), f1=sklearn.metrics.f1_score( true_y, pred_y, labels=labels, average=FLAGS.batch_scores_averaging_method, ), ) class RollingResults: """Maintain weighted rolling averages across batches.""" def __init__(self): self.weight_sum = 0 self.batch_count = 0 self.graph_count = 0 self.target_count = 0 self.weighted_iteration_count_sum = 0 self.weighted_model_converged_sum = 0 self.has_learning_rate = False self.weighted_learning_rate_sum = 0 self.has_loss = False self.weighted_loss_sum = 0 self.weighted_accuracy_sum = 0 self.weighted_precision_sum = 0 self.weighted_recall_sum = 0 self.weighted_f1_sum = 0 def Update( self, data: Data, results: Results, weight: Optional[float] = None ) -> None: """Update the rolling results with a new batch. Args: data: The batch data used to produce the results. results: The batch results to update the current state with. weight: A weight to assign to weighted sums. E.g. to weight results across all targets, use weight=results.target_count. To weight across targets, use weight=batch.target_count. To weight across graphs, use weight=batch.graph_count. By default, weight by target count. """ if weight is None: weight = results.target_count self.weight_sum += weight self.batch_count += 1 self.graph_count += data.graph_count self.target_count += results.target_count self.weighted_iteration_count_sum += results.iteration_count * weight self.weighted_model_converged_sum += ( weight if results.model_converged else 0 ) if results.has_learning_rate: self.has_learning_rate = True self.weighted_learning_rate_sum += results.learning_rate * weight if results.has_loss: self.has_loss = True self.weighted_loss_sum += results.loss * weight self.weighted_accuracy_sum += results.accuracy * weight self.weighted_precision_sum += results.precision * weight self.weighted_recall_sum += results.recall * weight self.weighted_f1_sum += results.f1 * weight @property def iteration_count(self) -> float: return self.weighted_iteration_count_sum / max(self.weight_sum, 1) @property def model_converged(self) -> float: return self.weighted_model_converged_sum / max(self.weight_sum, 1) @property def learning_rate(self) -> Optional[float]: if self.has_learning_rate: return self.weighted_learning_rate_sum / max(self.weight_sum, 1) @property def loss(self) -> Optional[float]: if self.has_loss: return self.weighted_loss_sum / max(self.weight_sum, 1) @property def accuracy(self) -> float: return self.weighted_accuracy_sum / max(self.weight_sum, 1) @property def precision(self) -> float: return self.weighted_precision_sum / max(self.weight_sum, 1) @property def recall(self) -> float: return self.weighted_recall_sum / max(self.weight_sum, 1) @property def f1(self) -> float: return self.weighted_f1_sum / max(self.weight_sum, 1)

bd43660e61d12126149a6be149f44586a149537b

py

Python

python/python-tutorial/10_packages/package_a/subpackage_a/a_module.py

wesleyegberto/dojos-languages

87170a722efac1247c713daa21cb3fcc39f5c5c1

python/python-tutorial/10_packages/package_a/subpackage_a/a_module.py

wesleyegberto/dojos-languages

87170a722efac1247c713daa21cb3fcc39f5c5c1

python/python-tutorial/10_packages/package_a/subpackage_a/a_module.py

wesleyegberto/dojos-languages

87170a722efac1247c713daa21cb3fcc39f5c5c1

# A module inside the package print("Module: ", __name__)

# A module inside the package print("Module: ", __name__) def do_stuff(): print("Doing stuff")

ea15f02ea347cde7a8bc22e6cd2d89594e3df3dd

py

Python

easy/1025-Divisor Game.py

Davidxswang/leetcode

d554b7f5228f14c646f726ddb91014a612673e06

2020-05-08T02:17:17.000Z

2020-05-17T04:55:56.000Z

easy/1025-Divisor Game.py

Davidxswang/leetcode

d554b7f5228f14c646f726ddb91014a612673e06

easy/1025-Divisor Game.py

Davidxswang/leetcode

d554b7f5228f14c646f726ddb91014a612673e06

""" https://leetcode.com/problems/divisor-game/ Alice and Bob take turns playing a game, with Alice starting first. Initially, there is a number N on the chalkboard. On each player's turn, that player makes a move consisting of: Choosing any x with 0 < x < N and N % x == 0. Replacing the number N on the chalkboard with N - x. Also, if a player cannot make a move, they lose the game. Return True if and only if Alice wins the game, assuming both players play optimally. Example 1: Input: 2 Output: true Explanation: Alice chooses 1, and Bob has no more moves. Example 2: Input: 3 Output: false Explanation: Alice chooses 1, Bob chooses 1, and Alice has no more moves. Note: 1 <= N <= 1000 """ # time complexity: O(nlogn), space complexity: O(n)

""" https://leetcode.com/problems/divisor-game/ Alice and Bob take turns playing a game, with Alice starting first. Initially, there is a number N on the chalkboard. On each player's turn, that player makes a move consisting of: Choosing any x with 0 < x < N and N % x == 0. Replacing the number N on the chalkboard with N - x. Also, if a player cannot make a move, they lose the game. Return True if and only if Alice wins the game, assuming both players play optimally. Example 1: Input: 2 Output: true Explanation: Alice chooses 1, and Bob has no more moves. Example 2: Input: 3 Output: false Explanation: Alice chooses 1, Bob chooses 1, and Alice has no more moves. Note: 1 <= N <= 1000 """ # time complexity: O(nlogn), space complexity: O(n) class Solution: def divisorGame(self, N: int) -> bool: flags = [False] * (N+1) import math for i in range(2, N+1): for j in range(1, int(math.sqrt(i))+2): if i % j == 0 and flags[i-j] == False: flags[i] = True break return flags[N]

56a51529edb0ee5b8e263f380f1c7725ffa73944

py

Python

evalml/automl/engine/sequential_engine.py

BlockchainClimateInstitute/price_microservice

11d1cff8965fe1befc997e9da3dc09efceed4579

evalml/automl/engine/sequential_engine.py

BlockchainClimateInstitute/price_microservice

11d1cff8965fe1befc997e9da3dc09efceed4579

evalml/automl/engine/sequential_engine.py

BlockchainClimateInstitute/price_microservice

11d1cff8965fe1befc997e9da3dc09efceed4579

import sys import traceback import numpy as np from evalml.automl.engine import EngineBase from evalml.exceptions import PipelineScoreError from evalml.model_family import ModelFamily from evalml.objectives.utils import get_objective from evalml.utils import get_logger logger = get_logger(__file__) class SequentialEngine(EngineBase): """The default engine for the AutoML search. Trains and scores pipelines locally, one after another.""" def evaluate_batch(self, pipelines): """Evaluate a batch of pipelines using the current dataset and AutoML state. Arguments: pipelines (list(PipelineBase)): A batch of pipelines to be fitted and evaluated. Returns: list (int): a list of the new pipeline IDs which were created by the AutoML search. """ if self.X_train is None or self.y_train is None: raise ValueError("Dataset has not been loaded into the engine.") new_pipeline_ids = [] index = 0 while self._should_continue_callback() and index < len(pipelines): pipeline = pipelines[index] self._pre_evaluation_callback(pipeline) X, y = self.X_train, self.y_train if pipeline.model_family == ModelFamily.ENSEMBLE: X, y = self.X_train.iloc[self.ensembling_indices], self.y_train.iloc[self.ensembling_indices] elif self.ensembling_indices is not None: training_indices = [i for i in range(len(self.X_train)) if i not in self.ensembling_indices] X = self.X_train.iloc[training_indices] y = self.y_train.iloc[training_indices] evaluation_result = EngineBase.train_and_score_pipeline(pipeline, self.automl, X, y) new_pipeline_ids.append(self._post_evaluation_callback(pipeline, evaluation_result)) index += 1 return new_pipeline_ids def train_batch(self, pipelines): """Train a batch of pipelines using the current dataset. Arguments: pipelines (list(PipelineBase)): A batch of pipelines to fit. Returns: dict[str, PipelineBase]: Dict of fitted pipelines keyed by pipeline name. """ super().train_batch(pipelines) fitted_pipelines = {} for pipeline in pipelines: try: fitted_pipeline = EngineBase.train_pipeline( pipeline, self.X_train, self.y_train, self.automl.optimize_thresholds, self.automl.objective ) fitted_pipelines[fitted_pipeline.name] = fitted_pipeline except Exception as e: logger.error(f'Train error for {pipeline.name}: {str(e)}') tb = traceback.format_tb(sys.exc_info()[2]) logger.error("Traceback:") logger.error("\n".join(tb)) return fitted_pipelines def score_batch(self, pipelines, X, y, objectives): """Score a batch of pipelines. Arguments: pipelines (list(PipelineBase)): A batch of fitted pipelines to score. X (ww.DataTable, pd.DataFrame): Features to score on. y (ww.DataTable, pd.DataFrame): Data to score on. objectives (list(ObjectiveBase), list(str)): Objectives to score on. Returns: dict: Dict containing scores for all objectives for all pipelines. Keyed by pipeline name. """ super().score_batch(pipelines, X, y, objectives) scores = {} objectives = [get_objective(o, return_instance=True) for o in objectives] for pipeline in pipelines: try: scores[pipeline.name] = pipeline.score(X, y, objectives) except Exception as e: logger.error(f"Score error for {pipeline.name}: {str(e)}") if isinstance(e, PipelineScoreError): nan_scores = {objective: np.nan for objective in e.exceptions} scores[pipeline.name] = {**nan_scores, **e.scored_successfully} else: # Traceback already included in the PipelineScoreError so we only # need to include it for all other errors tb = traceback.format_tb(sys.exc_info()[2]) logger.error("Traceback:") logger.error("\n".join(tb)) scores[pipeline.name] = {objective.name: np.nan for objective in objectives} return scores

import sys import traceback import numpy as np from evalml.automl.engine import EngineBase from evalml.exceptions import PipelineScoreError from evalml.model_family import ModelFamily from evalml.objectives.utils import get_objective from evalml.utils import get_logger logger = get_logger(__file__) class SequentialEngine(EngineBase): """The default engine for the AutoML search. Trains and scores pipelines locally, one after another.""" def evaluate_batch(self, pipelines): """Evaluate a batch of pipelines using the current dataset and AutoML state. Arguments: pipelines (list(PipelineBase)): A batch of pipelines to be fitted and evaluated. Returns: list (int): a list of the new pipeline IDs which were created by the AutoML search. """ if self.X_train is None or self.y_train is None: raise ValueError("Dataset has not been loaded into the engine.") new_pipeline_ids = [] index = 0 while self._should_continue_callback() and index < len(pipelines): pipeline = pipelines[index] self._pre_evaluation_callback(pipeline) X, y = self.X_train, self.y_train if pipeline.model_family == ModelFamily.ENSEMBLE: X, y = self.X_train.iloc[self.ensembling_indices], self.y_train.iloc[self.ensembling_indices] elif self.ensembling_indices is not None: training_indices = [i for i in range(len(self.X_train)) if i not in self.ensembling_indices] X = self.X_train.iloc[training_indices] y = self.y_train.iloc[training_indices] evaluation_result = EngineBase.train_and_score_pipeline(pipeline, self.automl, X, y) new_pipeline_ids.append(self._post_evaluation_callback(pipeline, evaluation_result)) index += 1 return new_pipeline_ids def train_batch(self, pipelines): """Train a batch of pipelines using the current dataset. Arguments: pipelines (list(PipelineBase)): A batch of pipelines to fit. Returns: dict[str, PipelineBase]: Dict of fitted pipelines keyed by pipeline name. """ super().train_batch(pipelines) fitted_pipelines = {} for pipeline in pipelines: try: fitted_pipeline = EngineBase.train_pipeline( pipeline, self.X_train, self.y_train, self.automl.optimize_thresholds, self.automl.objective ) fitted_pipelines[fitted_pipeline.name] = fitted_pipeline except Exception as e: logger.error(f'Train error for {pipeline.name}: {str(e)}') tb = traceback.format_tb(sys.exc_info()[2]) logger.error("Traceback:") logger.error("\n".join(tb)) return fitted_pipelines def score_batch(self, pipelines, X, y, objectives): """Score a batch of pipelines. Arguments: pipelines (list(PipelineBase)): A batch of fitted pipelines to score. X (ww.DataTable, pd.DataFrame): Features to score on. y (ww.DataTable, pd.DataFrame): Data to score on. objectives (list(ObjectiveBase), list(str)): Objectives to score on. Returns: dict: Dict containing scores for all objectives for all pipelines. Keyed by pipeline name. """ super().score_batch(pipelines, X, y, objectives) scores = {} objectives = [get_objective(o, return_instance=True) for o in objectives] for pipeline in pipelines: try: scores[pipeline.name] = pipeline.score(X, y, objectives) except Exception as e: logger.error(f"Score error for {pipeline.name}: {str(e)}") if isinstance(e, PipelineScoreError): nan_scores = {objective: np.nan for objective in e.exceptions} scores[pipeline.name] = {**nan_scores, **e.scored_successfully} else: # Traceback already included in the PipelineScoreError so we only # need to include it for all other errors tb = traceback.format_tb(sys.exc_info()[2]) logger.error("Traceback:") logger.error("\n".join(tb)) scores[pipeline.name] = {objective.name: np.nan for objective in objectives} return scores

ee2569e70a693fb7569365e25bd376b146aaf167

py

Python

source/read-file/app.py

aws-samples/aws-serverless-batch-architecture

1672d7623c2a0b6141bf83d019efe3c6c70efd00

2021-11-12T02:02:46.000Z

2022-03-01T23:28:48.000Z

source/read-file/app.py

aws-samples/aws-serverless-batch-architecture

1672d7623c2a0b6141bf83d019efe3c6c70efd00

2021-11-01T02:56:34.000Z

2022-01-17T00:19:53.000Z

source/read-file/app.py

aws-samples/aws-serverless-batch-architecture

1672d7623c2a0b6141bf83d019efe3c6c70efd00

2022-03-24T13:00:45.000Z

2022-03-24T13:00:45.000Z

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: MIT-0 import csv import s3fs import os s3 = s3fs.S3FileSystem(anon=False) header = [ 'uuid', 'country', 'itemType', 'salesChannel', 'orderPriority', 'orderDate', 'region', 'shipDate' ]

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # SPDX-License-Identifier: MIT-0 import csv import s3fs import os s3 = s3fs.S3FileSystem(anon=False) header = [ 'uuid', 'country', 'itemType', 'salesChannel', 'orderPriority', 'orderDate', 'region', 'shipDate' ] def lambda_handler(event, context): input_file = event['input']['FilePath'] output_data = [] skip_first = 0 with s3.open(input_file, 'r', newline='', encoding='utf-8-sig') as inFile: file_reader = csv.reader(inFile) for row in file_reader: if skip_first == 0: skip_first = skip_first + 1 continue new_object = {} for i in range(len(header)): new_object[header[i]] = row[i] output_data.append(new_object) return output_data

85f1aa282d6853f2f160254093d5add98f8f0f8b

py

Python

modules/differentialLine.py

inconvergent/differential-line-cuda

07927dff7c3178821776fccd5ad0aa196a3bb858

2016-05-22T17:40:02.000Z

2022-02-03T11:36:31.000Z

modules/differentialLine.py

inconvergent/differential-line-cuda

07927dff7c3178821776fccd5ad0aa196a3bb858

modules/differentialLine.py

inconvergent/differential-line-cuda

07927dff7c3178821776fccd5ad0aa196a3bb858

2017-03-17T05:13:16.000Z

2021-12-09T02:20:03.000Z

# -*- coding: utf-8 -*- from numpy import pi from numpy import zeros from numpy import sin from numpy import cos from numpy import sqrt from numpy.random import random from numpy import float32 as npfloat from numpy import int32 as npint TWOPI = pi*2 PI = pi

# -*- coding: utf-8 -*- from numpy import pi from numpy import zeros from numpy import sin from numpy import cos from numpy import sqrt from numpy.random import random from numpy import float32 as npfloat from numpy import int32 as npint TWOPI = pi*2 PI = pi class DifferentialLine(object): def __init__( self, size, stp, spring_stp, reject_stp, near_rad, far_rad, threads = 256, nmax = 1000000 ): self.itt = 0 self.threads = threads self.nmax = nmax self.size = size self.one = 1.0/size self.stp = stp self.spring_stp = spring_stp self.reject_stp = reject_stp self.near_rad = near_rad self.far_rad = far_rad self.__init() self.__cuda_init() def __init(self): self.num = 0 nz = int(1.0/(2*self.far_rad)) self.nz = nz self.nz2 = nz**2 nmax = self.nmax self.xy = zeros((nmax, 2), npfloat) self.dxy = zeros((nmax, 2), npfloat) self.tmp = zeros((nmax, 1), npfloat) self.link_len = zeros((nmax, 2), npfloat) self.link_curv = zeros((nmax, 2), npfloat) self.links = zeros((nmax, 2), npint) zone_map_size = self.nz2*64 self.zone_node = zeros(zone_map_size, npint) self.zone_num = zeros(self.nz2, npint) def __cuda_init(self): import pycuda.autoinit from .helpers import load_kernel self.cuda_agg_count = load_kernel( 'modules/cuda/agg_count.cu', 'agg_count', subs={'_THREADS_': self.threads} ) self.cuda_agg = load_kernel( 'modules/cuda/agg.cu', 'agg', subs={'_THREADS_': self.threads} ) self.cuda_step = load_kernel( 'modules/cuda/step.cu', 'step', subs={ '_THREADS_': self.threads } ) def init_circle(self, n, rad): from numpy import sort num = self.num links = self.links angles = random(n)*TWOPI angles = sort(angles) xx = 0.5 + cos(angles)*rad yy = 0.5 + sin(angles)*rad self.xy[num:num+n, 0] = xx self.xy[num:num+n, 1] = yy for i in range(num+1, num+n-1): links[i,0] = i-1 links[i,1] = i+1 links[num,1] = num+1 links[num,0] = num+n-1 links[(num+n-1),1] = num links[(num+n-1),0] = num+n-2 self.num = num+n def spawn_normal(self, limit, prob=0.01, t=None): links = self.links link_len = self.link_len xy = self.xy num = self.num mask = (random(num)<prob).nonzero()[0] if len(mask)<1: return for i in mask: b = links[i,1] l = link_len[i,1] if l>limit: newxy = (xy[b,:]+xy[i,:])*0.5 xy[num,:] = newxy links[i,1] = num links[num,0] = i links[num,1] = b links[b,0] = num num += 1 self.num = num def spawn_curl(self, limit, prob=0.01, t=None): links = self.links link_len = self.link_len xy = self.xy num = self.num curve = sqrt(self.link_curv[1:num,0]) for i, (r, t) in enumerate(zip(random(num), curve)): b = links[i,1] if r>t and link_len[i,1]>limit: newxy = (xy[b,:]+xy[i,:])*0.5 xy[num,:] = newxy links[i,1] = num links[num,0] = i links[num,1] = b links[b,0] = num num += 1 self.num = num def get_line(self): from numpy import array links = self.links curr = links[0,0] first = curr order = [first] while True: a = links[curr,0] b = links[curr,1] if a != curr: curr = a else: curr = b order.append(curr) if curr == first: order.append(a) break return array(order, npint) def step(self, t=None): import pycuda.driver as drv self.itt += 1 num = self.num xy = self.xy dxy = self.dxy tmp = self.tmp link_len = self.link_len link_curv = self.link_curv blocks = num//self.threads + 1 self.zone_num[:] = 0 self.cuda_agg_count( npint(num), npint(self.nz), drv.In(xy[:num,:]), drv.InOut(self.zone_num), block=(self.threads,1,1), grid=(blocks,1) ) zone_leap = self.zone_num[:].max() zone_map_size = self.nz2*zone_leap if zone_map_size>len(self.zone_node): print('resize, new zone leap: ', zone_map_size*2./self.nz2) self.zone_node = zeros(zone_map_size*2, npint) self.zone_num[:] = 0 self.cuda_agg( npint(num), npint(self.nz), npint(zone_leap), drv.In(xy[:num,:]), drv.InOut(self.zone_num), drv.InOut(self.zone_node), block=(self.threads,1,1), grid=(blocks,1) ) self.cuda_step( npint(num), npint(self.nz), npint(zone_leap), drv.In(xy[:num,:]), drv.Out(dxy[:num,:]), drv.Out(tmp[:num,:]), drv.Out(link_len[:num,:]), drv.Out(link_curv[:num,:]), drv.In(self.links[:num,:]), drv.In(self.zone_num), drv.In(self.zone_node), npfloat(self.stp), npfloat(self.reject_stp), npfloat(self.spring_stp), npfloat(self.near_rad), npfloat(self.far_rad), block=(self.threads,1,1), grid=(blocks,1) ) xy[:num,:] += dxy[:num,:]

9c9a724dc974172fe6713d50c40457af8df6ee64

py

Python

main.py

greenactionstudio/openleadr-python

03f2ceb3d9a8a2ffdffb67c99ec116187b9ee063

main.py

greenactionstudio/openleadr-python

03f2ceb3d9a8a2ffdffb67c99ec116187b9ee063

main.py

greenactionstudio/openleadr-python

03f2ceb3d9a8a2ffdffb67c99ec116187b9ee063

2021-11-03T02:36:32.000Z

2021-11-03T02:36:32.000Z

from logging import debug, exception from flask import Flask, request import os import asyncio import threading import ssl import aiohttp import nest_asyncio import json from openleadr.client import OpenADRClient from openleadr.utils import report_callback from openleadr.enums import MEASUREMENTS nest_asyncio.apply() client = OpenADRClient(ven_name='myven', vtn_url=os.environ.get('VTN_URL')) client.add_report(report_callback, client.ven_id, report_name = 'TELEMETRY_STATUS') client.add_report(report_callback, client.ven_id, report_name = 'TELEMETRY_USAGE', measurement= MEASUREMENTS.POWER_REAL) app = Flask(__name__) @app.route('/create_party_registration', methods=['POST', 'GET']) @app.route('/create_party_registration_while_registered', methods=['POST', 'GET']) @app.route('/query_registration', methods=['POST']) @app.route('/cancel_party_registration', methods=['POST']) @app.route('/register_reports') @app.route('/request_event', methods=['POST']) @app.route('/create_opt', methods =['POST']) @app.route('/cancel_opt', methods = ['POST']) if __name__ == "__main__": t1 = threading.Thread(target=app.run, kwargs={'host': '0.0.0.0', 'port': os.environ.get('PORT') }) t2 = threading.Thread(target=client_run) t1.start() t2.start() t2.join()

from logging import debug, exception from flask import Flask, request import os import asyncio import threading import ssl import aiohttp import nest_asyncio import json from openleadr.client import OpenADRClient from openleadr.utils import report_callback from openleadr.enums import MEASUREMENTS nest_asyncio.apply() client = OpenADRClient(ven_name='myven', vtn_url=os.environ.get('VTN_URL')) client.add_report(report_callback, client.ven_id, report_name = 'TELEMETRY_STATUS') client.add_report(report_callback, client.ven_id, report_name = 'TELEMETRY_USAGE', measurement= MEASUREMENTS.POWER_REAL) app = Flask(__name__) @app.route('/create_party_registration', methods=['POST', 'GET']) async def create_party_registration(): await client.create_party_registration(ven_id = client.ven_id, registration_id=client.registration_id) return {'status': 200, 'body': 'return from the create party registration'} @app.route('/create_party_registration_while_registered', methods=['POST', 'GET']) async def create_party_registration_while_registered(): await client.create_party_registration_while_registered() return {'status': 200, 'body': 'return from the create party registration'} @app.route('/query_registration', methods=['POST']) async def query_registration(): await client.query_registration() return {'status': 200, 'body': 'return from the query registration'} @app.route('/cancel_party_registration', methods=['POST']) async def cancel_party_registration(): await client.cancel_party_registration() return {'status': 200, 'body': 'return from the cancel registration'} @app.route('/register_reports') async def register_reports(): if client.reports: await client.register_reports(client.reports) return {'status': 200, 'body': 'The VEN has sent register report with metadata.'} @app.route('/request_event', methods=['POST']) async def request_event(): response_type, response_payload = await client.request_event() if response_type == 'oadrDistributeEvent': if 'events' in response_payload and len(response_payload['events']) > 0: await client._on_event(response_payload) return {'status': 200, 'body': 'return from the request event'} @app.route('/create_opt', methods =['POST']) async def create_opt(): return await client.create_opt(request.data) @app.route('/cancel_opt', methods = ['POST']) async def cancel_opt(): return await client.cancel_opt(request.data) def client_run(): loop = asyncio.new_event_loop() loop.create_task(client.run()) loop.run_forever() if __name__ == "__main__": t1 = threading.Thread(target=app.run, kwargs={'host': '0.0.0.0', 'port': os.environ.get('PORT') }) t2 = threading.Thread(target=client_run) t1.start() t2.start() t2.join()

0a7253e54a7ce0b7e58517111d748be3f97a40cb

py

Python

sound_lib/external/pybass_aac.py

ctoth/sound_lib

0e0544a1f4e5da5bc2e0ee99cd7c5bac9ba934c6

2020-09-03T15:35:03.000Z

2020-09-03T15:35:03.000Z

sound_lib/external/pybass_aac.py

ctoth/sound_lib

0e0544a1f4e5da5bc2e0ee99cd7c5bac9ba934c6

2020-09-25T05:47:44.000Z

2021-06-25T15:25:34.000Z

sound_lib/external/pybass_aac.py

ctoth/sound_lib

0e0544a1f4e5da5bc2e0ee99cd7c5bac9ba934c6

2020-01-05T16:24:20.000Z

2020-09-03T15:35:07.000Z

from __future__ import absolute_import # Copyright(c) Max Kolosov 2009 maxkolosov@inbox.ru # http://vosolok2008.narod.ru # BSD license __version__ = '0.1' __versionTime__ = '2009-11-15' __author__ = 'Max Kolosov <maxkolosov@inbox.ru>' __doc__ = ''' pybass_aac.py - is ctypes python module for BASS_AAC - extension to the BASS audio library that enables the playback of Advanced Audio Coding and MPEG-4 streams (http://www.maresweb.de). ''' import os, sys, ctypes from . import pybass from .paths import x86_path, x64_path import libloader bass_aac_module = libloader.load_library('bass_aac', x86_path=x86_path, x64_path=x64_path) func_type = libloader.get_functype() #Register the plugin with the Bass plugin system. pybass.BASS_PluginLoad(libloader.find_library_path('bass_aac', x86_path=x86_path, x64_path=x64_path), 0) QWORD = pybass.QWORD HSTREAM = pybass.HSTREAM DOWNLOADPROC = pybass.DOWNLOADPROC BASS_FILEPROCS = pybass.BASS_FILEPROCS # Additional BASS_SetConfig options BASS_CONFIG_MP4_VIDEO = 0x10700 # play the audio from MP4 videos # Additional tags available from BASS_StreamGetTags (for MP4 files) BASS_TAG_MP4 = 7 # MP4/iTunes metadata BASS_AAC_STEREO = 0x400000 # downmatrix to stereo # BASS_CHANNELINFO type BASS_CTYPE_STREAM_AAC = 0x10b00 # AAC BASS_CTYPE_STREAM_MP4 = 0x10b01 # MP4 #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateFile)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags); BASS_AAC_StreamCreateFile = func_type(HSTREAM, ctypes.c_byte, ctypes.c_void_p, QWORD, QWORD, ctypes.c_ulong)(('BASS_AAC_StreamCreateFile', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateURL)(const char *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user); BASS_AAC_StreamCreateURL = func_type(HSTREAM, ctypes.c_char_p, ctypes.c_ulong, ctypes.c_ulong, DOWNLOADPROC, ctypes.c_void_p)(('BASS_AAC_StreamCreateURL', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *procs, void *user); BASS_AAC_StreamCreateFileUser = func_type(HSTREAM, ctypes.c_ulong, ctypes.c_ulong, ctypes.POINTER(BASS_FILEPROCS), ctypes.c_void_p)(('BASS_AAC_StreamCreateFileUser', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_MP4_StreamCreateFile)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags); BASS_MP4_StreamCreateFile = func_type(HSTREAM, ctypes.c_byte, ctypes.c_void_p, QWORD, QWORD, ctypes.c_ulong)(('BASS_MP4_StreamCreateFile', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_MP4_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *procs, void *user); BASS_MP4_StreamCreateFileUser = func_type(HSTREAM, ctypes.c_ulong, ctypes.c_ulong, ctypes.POINTER(BASS_FILEPROCS), ctypes.c_void_p)(('BASS_MP4_StreamCreateFileUser', bass_aac_module))

from __future__ import absolute_import # Copyright(c) Max Kolosov 2009 maxkolosov@inbox.ru # http://vosolok2008.narod.ru # BSD license __version__ = '0.1' __versionTime__ = '2009-11-15' __author__ = 'Max Kolosov <maxkolosov@inbox.ru>' __doc__ = ''' pybass_aac.py - is ctypes python module for BASS_AAC - extension to the BASS audio library that enables the playback of Advanced Audio Coding and MPEG-4 streams (http://www.maresweb.de). ''' import os, sys, ctypes from . import pybass from .paths import x86_path, x64_path import libloader bass_aac_module = libloader.load_library('bass_aac', x86_path=x86_path, x64_path=x64_path) func_type = libloader.get_functype() #Register the plugin with the Bass plugin system. pybass.BASS_PluginLoad(libloader.find_library_path('bass_aac', x86_path=x86_path, x64_path=x64_path), 0) QWORD = pybass.QWORD HSTREAM = pybass.HSTREAM DOWNLOADPROC = pybass.DOWNLOADPROC BASS_FILEPROCS = pybass.BASS_FILEPROCS # Additional BASS_SetConfig options BASS_CONFIG_MP4_VIDEO = 0x10700 # play the audio from MP4 videos # Additional tags available from BASS_StreamGetTags (for MP4 files) BASS_TAG_MP4 = 7 # MP4/iTunes metadata BASS_AAC_STEREO = 0x400000 # downmatrix to stereo # BASS_CHANNELINFO type BASS_CTYPE_STREAM_AAC = 0x10b00 # AAC BASS_CTYPE_STREAM_MP4 = 0x10b01 # MP4 #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateFile)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags); BASS_AAC_StreamCreateFile = func_type(HSTREAM, ctypes.c_byte, ctypes.c_void_p, QWORD, QWORD, ctypes.c_ulong)(('BASS_AAC_StreamCreateFile', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateURL)(const char *url, DWORD offset, DWORD flags, DOWNLOADPROC *proc, void *user); BASS_AAC_StreamCreateURL = func_type(HSTREAM, ctypes.c_char_p, ctypes.c_ulong, ctypes.c_ulong, DOWNLOADPROC, ctypes.c_void_p)(('BASS_AAC_StreamCreateURL', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_AAC_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *procs, void *user); BASS_AAC_StreamCreateFileUser = func_type(HSTREAM, ctypes.c_ulong, ctypes.c_ulong, ctypes.POINTER(BASS_FILEPROCS), ctypes.c_void_p)(('BASS_AAC_StreamCreateFileUser', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_MP4_StreamCreateFile)(BOOL mem, const void *file, QWORD offset, QWORD length, DWORD flags); BASS_MP4_StreamCreateFile = func_type(HSTREAM, ctypes.c_byte, ctypes.c_void_p, QWORD, QWORD, ctypes.c_ulong)(('BASS_MP4_StreamCreateFile', bass_aac_module)) #HSTREAM BASSAACDEF(BASS_MP4_StreamCreateFileUser)(DWORD system, DWORD flags, const BASS_FILEPROCS *procs, void *user); BASS_MP4_StreamCreateFileUser = func_type(HSTREAM, ctypes.c_ulong, ctypes.c_ulong, ctypes.POINTER(BASS_FILEPROCS), ctypes.c_void_p)(('BASS_MP4_StreamCreateFileUser', bass_aac_module))

0a79e9ed00dd7cff3b0787278aa3e51a4698409f

py

Python

src/olympia/addons/views.py

tapaswenipathak/addons-server

b7085559a754248a8baade399d5a27f2c3e3ca7e

2019-08-17T21:17:50.000Z

2019-08-17T21:17:50.000Z

src/olympia/addons/views.py

tapaswenipathak/addons-server

b7085559a754248a8baade399d5a27f2c3e3ca7e

src/olympia/addons/views.py

tapaswenipathak/addons-server

b7085559a754248a8baade399d5a27f2c3e3ca7e

from collections import OrderedDict from django import http from django.db.models import Prefetch from django.db.transaction import non_atomic_requests from django.shortcuts import redirect from django.utils.cache import patch_cache_control from django.utils.decorators import method_decorator from django.views.decorators.cache import cache_page from elasticsearch_dsl import Q, query, Search from rest_framework import exceptions, serializers from rest_framework.decorators import action from rest_framework.generics import GenericAPIView, ListAPIView from rest_framework.mixins import ListModelMixin, RetrieveModelMixin from rest_framework.response import Response from rest_framework.settings import api_settings from rest_framework.viewsets import GenericViewSet import olympia.core.logger from olympia import amo from olympia.access import acl from olympia.amo.models import manual_order from olympia.amo.urlresolvers import get_outgoing_url from olympia.api.pagination import ESPageNumberPagination from olympia.api.permissions import ( AllowAddonAuthor, AllowReadOnlyIfPublic, AllowRelatedObjectPermissions, AllowReviewer, AllowReviewerUnlisted, AnyOf, GroupPermission) from olympia.constants.categories import CATEGORIES_BY_ID from olympia.search.filters import ( AddonAppQueryParam, AddonAppVersionQueryParam, AddonAuthorQueryParam, AddonCategoryQueryParam, AddonGuidQueryParam, AddonTypeQueryParam, AutoCompleteSortFilter, ReviewedContentFilter, SearchParameterFilter, SearchQueryFilter, SortingFilter) from olympia.translations.query import order_by_translation from olympia.versions.models import Version from .decorators import addon_view_factory from .indexers import AddonIndexer from .models import Addon, CompatOverride, ReplacementAddon from .serializers import ( AddonEulaPolicySerializer, AddonSerializer, AddonSerializerWithUnlistedData, CompatOverrideSerializer, ESAddonAutoCompleteSerializer, ESAddonSerializer, LanguageToolsSerializer, ReplacementAddonSerializer, StaticCategorySerializer, VersionSerializer) from .utils import ( get_addon_recommendations, get_addon_recommendations_invalid, get_creatured_ids, get_featured_ids, is_outcome_recommended) log = olympia.core.logger.getLogger('z.addons') addon_view = addon_view_factory(qs=Addon.objects.valid) addon_valid_disabled_pending_view = addon_view_factory( qs=Addon.objects.valid_and_disabled_and_pending) class BaseFilter(object): """ Filters help generate querysets for add-on listings. You have to define ``opts`` on the subclass as a sequence of (key, title) pairs. The key is used in GET parameters and the title can be used in the view. The chosen filter field is combined with the ``base`` queryset using the ``key`` found in request.GET. ``default`` should be a key in ``opts`` that's used if nothing good is found in request.GET. """ def options(self, request, key, default): """Get the (option, title) pair we want according to the request.""" if key in request.GET and (request.GET[key] in self.opts_dict or request.GET[key] in self.extras_dict): opt = request.GET[key] else: opt = default if opt in self.opts_dict: title = self.opts_dict[opt] else: title = self.extras_dict[opt] return opt, title def all(self): """Get a full mapping of {option: queryset}.""" return dict((field, self.filter(field)) for field in dict(self.opts)) def filter(self, field): """Get the queryset for the given field.""" return getattr(self, 'filter_{0}'.format(field))() DEFAULT_FIND_REPLACEMENT_PATH = '/collections/mozilla/featured-add-ons/' FIND_REPLACEMENT_SRC = 'find-replacement' class AddonChildMixin(object): """Mixin containing method to retrieve the parent add-on object.""" def get_addon_object(self, permission_classes=None, lookup='addon_pk'): """Return the parent Addon object using the URL parameter passed to the view. `permission_classes` can be use passed to change which permission classes the parent viewset will be used when loading the Addon object, otherwise AddonViewSet.permission_classes will be used.""" if hasattr(self, 'addon_object'): return self.addon_object if permission_classes is None: permission_classes = AddonViewSet.permission_classes self.addon_object = AddonViewSet( request=self.request, permission_classes=permission_classes, kwargs={'pk': self.kwargs[lookup]}).get_object() return self.addon_object class CompatOverrideView(ListAPIView): """This view is used by Firefox so it's performance-critical. Every firefox client requests the list of overrides approx. once per day. Firefox requests the overrides via a list of GUIDs which makes caching hard because the variation of possible GUID combinations prevent us to simply add some dumb-caching and requires us to resolve cache-misses. """ queryset = CompatOverride.objects.all() serializer_class = CompatOverrideSerializer @classmethod def as_view(cls, **initkwargs): """The API is read-only so we can turn off atomic requests.""" return non_atomic_requests( super(CompatOverrideView, cls).as_view(**initkwargs))

from collections import OrderedDict from django import http from django.db.models import Prefetch from django.db.transaction import non_atomic_requests from django.shortcuts import redirect from django.utils.cache import patch_cache_control from django.utils.decorators import method_decorator from django.views.decorators.cache import cache_page from elasticsearch_dsl import Q, query, Search from rest_framework import exceptions, serializers from rest_framework.decorators import action from rest_framework.generics import GenericAPIView, ListAPIView from rest_framework.mixins import ListModelMixin, RetrieveModelMixin from rest_framework.response import Response from rest_framework.settings import api_settings from rest_framework.viewsets import GenericViewSet import olympia.core.logger from olympia import amo from olympia.access import acl from olympia.amo.models import manual_order from olympia.amo.urlresolvers import get_outgoing_url from olympia.api.pagination import ESPageNumberPagination from olympia.api.permissions import ( AllowAddonAuthor, AllowReadOnlyIfPublic, AllowRelatedObjectPermissions, AllowReviewer, AllowReviewerUnlisted, AnyOf, GroupPermission) from olympia.constants.categories import CATEGORIES_BY_ID from olympia.search.filters import ( AddonAppQueryParam, AddonAppVersionQueryParam, AddonAuthorQueryParam, AddonCategoryQueryParam, AddonGuidQueryParam, AddonTypeQueryParam, AutoCompleteSortFilter, ReviewedContentFilter, SearchParameterFilter, SearchQueryFilter, SortingFilter) from olympia.translations.query import order_by_translation from olympia.versions.models import Version from .decorators import addon_view_factory from .indexers import AddonIndexer from .models import Addon, CompatOverride, ReplacementAddon from .serializers import ( AddonEulaPolicySerializer, AddonSerializer, AddonSerializerWithUnlistedData, CompatOverrideSerializer, ESAddonAutoCompleteSerializer, ESAddonSerializer, LanguageToolsSerializer, ReplacementAddonSerializer, StaticCategorySerializer, VersionSerializer) from .utils import ( get_addon_recommendations, get_addon_recommendations_invalid, get_creatured_ids, get_featured_ids, is_outcome_recommended) log = olympia.core.logger.getLogger('z.addons') addon_view = addon_view_factory(qs=Addon.objects.valid) addon_valid_disabled_pending_view = addon_view_factory( qs=Addon.objects.valid_and_disabled_and_pending) class BaseFilter(object): """ Filters help generate querysets for add-on listings. You have to define ``opts`` on the subclass as a sequence of (key, title) pairs. The key is used in GET parameters and the title can be used in the view. The chosen filter field is combined with the ``base`` queryset using the ``key`` found in request.GET. ``default`` should be a key in ``opts`` that's used if nothing good is found in request.GET. """ def __init__(self, request, base, key, default, model=Addon): self.opts_dict = dict(self.opts) self.extras_dict = dict(self.extras) if hasattr(self, 'extras') else {} self.request = request self.base_queryset = base self.key = key self.model = model self.field, self.title = self.options(self.request, key, default) self.qs = self.filter(self.field) def options(self, request, key, default): """Get the (option, title) pair we want according to the request.""" if key in request.GET and (request.GET[key] in self.opts_dict or request.GET[key] in self.extras_dict): opt = request.GET[key] else: opt = default if opt in self.opts_dict: title = self.opts_dict[opt] else: title = self.extras_dict[opt] return opt, title def all(self): """Get a full mapping of {option: queryset}.""" return dict((field, self.filter(field)) for field in dict(self.opts)) def filter(self, field): """Get the queryset for the given field.""" return getattr(self, 'filter_{0}'.format(field))() def filter_featured(self): ids = self.model.featured_random(self.request.APP, self.request.LANG) return manual_order(self.base_queryset, ids, 'addons.id') def filter_free(self): if self.model == Addon: return self.base_queryset.top_free(self.request.APP, listed=False) else: return self.base_queryset.top_free(listed=False) def filter_paid(self): if self.model == Addon: return self.base_queryset.top_paid(self.request.APP, listed=False) else: return self.base_queryset.top_paid(listed=False) def filter_popular(self): return self.base_queryset.order_by('-weekly_downloads') def filter_downloads(self): return self.filter_popular() def filter_users(self): return self.base_queryset.order_by('-average_daily_users') def filter_created(self): return self.base_queryset.order_by('-created') def filter_updated(self): return self.base_queryset.order_by('-last_updated') def filter_rating(self): return self.base_queryset.order_by('-bayesian_rating') def filter_hotness(self): return self.base_queryset.order_by('-hotness') def filter_name(self): return order_by_translation(self.base_queryset.all(), 'name') DEFAULT_FIND_REPLACEMENT_PATH = '/collections/mozilla/featured-add-ons/' FIND_REPLACEMENT_SRC = 'find-replacement' def find_replacement_addon(request): guid = request.GET.get('guid') if not guid: raise http.Http404 try: replacement = ReplacementAddon.objects.get(guid=guid) path = replacement.path except ReplacementAddon.DoesNotExist: path = DEFAULT_FIND_REPLACEMENT_PATH else: if replacement.has_external_url(): # It's an external URL: return redirect(get_outgoing_url(path)) replace_url = '%s%s?src=%s' % ( ('/' if not path.startswith('/') else ''), path, FIND_REPLACEMENT_SRC) return redirect(replace_url, permanent=False) class AddonViewSet(RetrieveModelMixin, GenericViewSet): permission_classes = [ AnyOf(AllowReadOnlyIfPublic, AllowAddonAuthor, AllowReviewer, AllowReviewerUnlisted), ] serializer_class = AddonSerializer serializer_class_with_unlisted_data = AddonSerializerWithUnlistedData lookup_value_regex = '[^/]+' # Allow '.' for email-like guids. def get_queryset(self): """Return queryset to be used for the view.""" # Special case: admins - and only admins - can see deleted add-ons. # This is handled outside a permission class because that condition # would pollute all other classes otherwise. if (self.request.user.is_authenticated and acl.action_allowed(self.request, amo.permissions.ADDONS_VIEW_DELETED)): return Addon.unfiltered.all() # Permission classes disallow access to non-public/unlisted add-ons # unless logged in as a reviewer/addon owner/admin, so we don't have to # filter the base queryset here. return Addon.objects.all() def get_serializer_class(self): # Override serializer to use serializer_class_with_unlisted_data if # we are allowed to access unlisted data. obj = getattr(self, 'instance') request = self.request if (acl.check_unlisted_addons_reviewer(request) or (obj and request.user.is_authenticated and obj.authors.filter(pk=request.user.pk).exists())): return self.serializer_class_with_unlisted_data return self.serializer_class def get_lookup_field(self, identifier): return Addon.get_lookup_field(identifier) def get_object(self): identifier = self.kwargs.get('pk') self.lookup_field = self.get_lookup_field(identifier) self.kwargs[self.lookup_field] = identifier self.instance = super(AddonViewSet, self).get_object() return self.instance def check_object_permissions(self, request, obj): """ Check if the request should be permitted for a given object. Raises an appropriate exception if the request is not permitted. Calls DRF implementation, but adds `is_disabled_by_developer` to the exception being thrown so that clients can tell the difference between a 401/403 returned because an add-on has been disabled by their developer or something else. """ try: super(AddonViewSet, self).check_object_permissions(request, obj) except exceptions.APIException as exc: exc.detail = { 'detail': exc.detail, 'is_disabled_by_developer': obj.disabled_by_user, 'is_disabled_by_mozilla': obj.status == amo.STATUS_DISABLED, } raise exc @action(detail=True) def eula_policy(self, request, pk=None): obj = self.get_object() serializer = AddonEulaPolicySerializer( obj, context=self.get_serializer_context()) return Response(serializer.data) class AddonChildMixin(object): """Mixin containing method to retrieve the parent add-on object.""" def get_addon_object(self, permission_classes=None, lookup='addon_pk'): """Return the parent Addon object using the URL parameter passed to the view. `permission_classes` can be use passed to change which permission classes the parent viewset will be used when loading the Addon object, otherwise AddonViewSet.permission_classes will be used.""" if hasattr(self, 'addon_object'): return self.addon_object if permission_classes is None: permission_classes = AddonViewSet.permission_classes self.addon_object = AddonViewSet( request=self.request, permission_classes=permission_classes, kwargs={'pk': self.kwargs[lookup]}).get_object() return self.addon_object class AddonVersionViewSet(AddonChildMixin, RetrieveModelMixin, ListModelMixin, GenericViewSet): # Permissions are always checked against the parent add-on in # get_addon_object() using AddonViewSet.permission_classes so we don't need # to set any here. Some extra permission classes are added dynamically # below in check_permissions() and check_object_permissions() depending on # what the client is requesting to see. permission_classes = [] serializer_class = VersionSerializer def check_permissions(self, request): requested = self.request.GET.get('filter') if self.action == 'list': if requested == 'all_with_deleted': # To see deleted versions, you need Addons:ViewDeleted. self.permission_classes = [ GroupPermission(amo.permissions.ADDONS_VIEW_DELETED)] elif requested == 'all_with_unlisted': # To see unlisted versions, you need to be add-on author or # unlisted reviewer. self.permission_classes = [AnyOf( AllowReviewerUnlisted, AllowAddonAuthor)] elif requested == 'all_without_unlisted': # To see all listed versions (not just public ones) you need to # be add-on author or reviewer. self.permission_classes = [AnyOf( AllowReviewer, AllowReviewerUnlisted, AllowAddonAuthor)] # When listing, we can't use AllowRelatedObjectPermissions() with # check_permissions(), because AllowAddonAuthor needs an author to # do the actual permission check. To work around that, we call # super + check_object_permission() ourselves, passing down the # addon object directly. return super(AddonVersionViewSet, self).check_object_permissions( request, self.get_addon_object()) super(AddonVersionViewSet, self).check_permissions(request) def check_object_permissions(self, request, obj): # If the instance is marked as deleted and the client is not allowed to # see deleted instances, we want to return a 404, behaving as if it # does not exist. if (obj.deleted and not GroupPermission(amo.permissions.ADDONS_VIEW_DELETED). has_object_permission(request, self, obj)): raise http.Http404 if obj.channel == amo.RELEASE_CHANNEL_UNLISTED: # If the instance is unlisted, only allow unlisted reviewers and # authors.. self.permission_classes = [ AllowRelatedObjectPermissions( 'addon', [AnyOf(AllowReviewerUnlisted, AllowAddonAuthor)]) ] elif not obj.is_public(): # If the instance is disabled, only allow reviewers and authors. self.permission_classes = [ AllowRelatedObjectPermissions( 'addon', [AnyOf(AllowReviewer, AllowAddonAuthor)]) ] super(AddonVersionViewSet, self).check_object_permissions(request, obj) def get_queryset(self): """Return the right base queryset depending on the situation.""" requested = self.request.GET.get('filter') valid_filters = ( 'all_with_deleted', 'all_with_unlisted', 'all_without_unlisted', ) if requested is not None: if self.action != 'list': raise serializers.ValidationError( 'The "filter" parameter is not valid in this context.') elif requested not in valid_filters: raise serializers.ValidationError( 'Invalid "filter" parameter specified.') # By default we restrict to valid, listed versions. Some filtering # options are available when listing, and in addition, when returning # a single instance, we don't filter at all. if requested == 'all_with_deleted' or self.action != 'list': queryset = Version.unfiltered.all() elif requested == 'all_with_unlisted': queryset = Version.objects.all() elif requested == 'all_without_unlisted': queryset = Version.objects.filter( channel=amo.RELEASE_CHANNEL_LISTED) else: # By default, we rely on queryset filtering to hide # non-public/unlisted versions. get_queryset() might override this # if we are asked to see non-valid, deleted and/or unlisted # versions explicitly. queryset = Version.objects.filter( files__status=amo.STATUS_APPROVED, channel=amo.RELEASE_CHANNEL_LISTED).distinct() # Filter with the add-on. return queryset.filter(addon=self.get_addon_object()) class AddonSearchView(ListAPIView): authentication_classes = [] filter_backends = [ ReviewedContentFilter, SearchQueryFilter, SearchParameterFilter, SortingFilter, ] pagination_class = ESPageNumberPagination permission_classes = [] serializer_class = ESAddonSerializer def get_queryset(self): qset = Search( using=amo.search.get_es(), index=AddonIndexer.get_index_alias(), doc_type=AddonIndexer.get_doctype_name()).extra( _source={'excludes': AddonIndexer.hidden_fields}).params( search_type='dfs_query_then_fetch') return qset @classmethod def as_view(cls, **kwargs): view = super(AddonSearchView, cls).as_view(**kwargs) return non_atomic_requests(view) class AddonAutoCompleteSearchView(AddonSearchView): pagination_class = None serializer_class = ESAddonAutoCompleteSerializer filter_backends = [ ReviewedContentFilter, SearchQueryFilter, SearchParameterFilter, AutoCompleteSortFilter, ] def get_queryset(self): # Minimal set of fields from ES that we need to build our results. # It's the opposite tactic used by the regular search endpoint, which # excludes a specific set of fields - because we know that autocomplete # only needs to return very few things. included_fields = ( 'icon_type', # Needed for icon_url. 'id', # Needed for... id 'is_recommended', 'modified', # Needed for icon_url. 'name_translations', # Needed for... name. 'default_locale', # Needed for translations to work. 'slug', # Needed for url. 'type', # Needed to attach the Persona for icon_url (sadly). ) qset = ( Search( using=amo.search.get_es(), index=AddonIndexer.get_index_alias(), doc_type=AddonIndexer.get_doctype_name()) .extra(_source={'includes': included_fields})) return qset def list(self, request, *args, **kwargs): # Ignore pagination (slice directly) but do wrap the data in a # 'results' property to mimic what the search API does. queryset = self.filter_queryset(self.get_queryset())[:10] serializer = self.get_serializer(queryset, many=True) return Response({'results': serializer.data}) class AddonFeaturedView(GenericAPIView): authentication_classes = [] permission_classes = [] serializer_class = AddonSerializer # We accept the 'page_size' parameter but we do not allow pagination for # this endpoint since the order is random. pagination_class = None def get(self, request, *args, **kwargs): queryset = self.filter_queryset(self.get_queryset()) serializer = self.get_serializer(queryset, many=True) # Simulate pagination-like results, without actual pagination. return Response({'results': serializer.data}) @classmethod def as_view(cls, **kwargs): view = super(AddonFeaturedView, cls).as_view(**kwargs) return non_atomic_requests(view) def get_queryset(self): return Addon.objects.valid() def filter_queryset(self, queryset): # We can pass the optional lang parameter to either get_creatured_ids() # or get_featured_ids() below to get locale-specific results in # addition to the generic ones. lang = self.request.GET.get('lang') if 'category' in self.request.GET: # If a category is passed then the app and type parameters are # mandatory because we need to find a category in the constants to # pass to get_creatured_ids(), and category slugs are not unique. # AddonCategoryQueryParam parses the request parameters for us to # determine the category. try: categories = AddonCategoryQueryParam(self.request).get_value() except ValueError: raise exceptions.ParseError( 'Invalid app, category and/or type parameter(s).') ids = [] for category in categories: ids.extend(get_creatured_ids(category, lang)) else: # If no category is passed, only the app parameter is mandatory, # because get_featured_ids() needs it to find the right collection # to pick addons from. It can optionally filter by type, so we # parse request for that as well. try: app = AddonAppQueryParam( self.request).get_object_from_reverse_dict() types = None if 'type' in self.request.GET: types = AddonTypeQueryParam(self.request).get_value() except ValueError: raise exceptions.ParseError( 'Invalid app, category and/or type parameter(s).') ids = get_featured_ids(app, lang=lang, types=types) # ids is going to be a random list of ids, we just slice it to get # the number of add-ons that was requested. We do it before calling # manual_order(), since it'll use the ids as part of a id__in filter. try: page_size = int( self.request.GET.get('page_size', api_settings.PAGE_SIZE)) except ValueError: raise exceptions.ParseError('Invalid page_size parameter') ids = ids[:page_size] return manual_order(queryset, ids, 'addons.id') class StaticCategoryView(ListAPIView): authentication_classes = [] pagination_class = None permission_classes = [] serializer_class = StaticCategorySerializer def get_queryset(self): return sorted(CATEGORIES_BY_ID.values(), key=lambda x: x.id) @classmethod def as_view(cls, **kwargs): view = super(StaticCategoryView, cls).as_view(**kwargs) return non_atomic_requests(view) def finalize_response(self, request, response, *args, **kwargs): response = super(StaticCategoryView, self).finalize_response( request, response, *args, **kwargs) patch_cache_control(response, max_age=60 * 60 * 6) return response class LanguageToolsView(ListAPIView): authentication_classes = [] pagination_class = None permission_classes = [] serializer_class = LanguageToolsSerializer @classmethod def as_view(cls, **initkwargs): """The API is read-only so we can turn off atomic requests.""" return non_atomic_requests( super(LanguageToolsView, cls).as_view(**initkwargs)) def get_query_params(self): """ Parse query parameters that this API supports: - app (mandatory) - type (optional) - appversion (optional, makes type mandatory) - author (optional) Can raise ParseError() in case a mandatory parameter is missing or a parameter is invalid. Returns a dict containing application (int), types (tuple or None), appversions (dict or None) and author (string or None). """ # app parameter is mandatory when calling this API. try: application = AddonAppQueryParam(self.request).get_value() except ValueError: raise exceptions.ParseError('Invalid or missing app parameter.') # appversion parameter is optional. if AddonAppVersionQueryParam.query_param in self.request.GET: try: value = AddonAppVersionQueryParam(self.request).get_values() appversions = { 'min': value[1], 'max': value[2] } except ValueError: raise exceptions.ParseError('Invalid appversion parameter.') else: appversions = None # type is optional, unless appversion is set. That's because the way # dicts and language packs have their compatibility info set in the # database differs, so to make things simpler for us we force clients # to filter by type if they want appversion filtering. if AddonTypeQueryParam.query_param in self.request.GET or appversions: try: addon_types = tuple( AddonTypeQueryParam(self.request).get_value()) except ValueError: raise exceptions.ParseError( 'Invalid or missing type parameter while appversion ' 'parameter is set.') else: addon_types = (amo.ADDON_LPAPP, amo.ADDON_DICT) # author is optional. It's a string representing the username(s) we're # filtering on. if AddonAuthorQueryParam.query_param in self.request.GET: author = AddonAuthorQueryParam(self.request).get_value() else: author = None return { 'application': application, 'types': addon_types, 'appversions': appversions, 'author': author, } def get_queryset(self): """ Return queryset to use for this view, depending on query parameters. """ # application, addon_types, appversions params = self.get_query_params() if params['types'] == (amo.ADDON_LPAPP,) and params['appversions']: qs = self.get_language_packs_queryset_with_appversions( params['application'], params['appversions']) else: # appversions filtering only makes sense for language packs only, # so it's ignored here. qs = self.get_queryset_base(params['application'], params['types']) if params['author']: qs = qs.filter( addonuser__user__username__in=params['author'], addonuser__listed=True).distinct() return qs def get_queryset_base(self, application, addon_types): """ Return base queryset to be used as the starting point in both get_queryset() and get_language_packs_queryset_with_appversions(). """ return ( Addon.objects.public() .filter(appsupport__app=application, type__in=addon_types, target_locale__isnull=False) .exclude(target_locale='') # Deactivate default transforms which fetch a ton of stuff we # don't need here like authors, previews or current version. # It would be nice to avoid translations entirely, because the # translations transformer is going to fetch a lot of translations # we don't need, but some language packs or dictionaries have # custom names, so we can't use a generic one for them... .only_translations() # Since we're fetching everything with no pagination, might as well # not order it. .order_by() ) def get_language_packs_queryset_with_appversions( self, application, appversions): """ Return queryset to use specifically when requesting language packs compatible with a given app + versions. application is an application id, and appversions is a dict with min and max keys pointing to application versions expressed as ints. """ # Base queryset. qs = self.get_queryset_base(application, (amo.ADDON_LPAPP,)) # Version queryset we'll prefetch once for all results. We need to # find the ones compatible with the app+appversion requested, and we # can avoid loading translations by removing transforms and then # re-applying the default one that takes care of the files and compat # info. versions_qs = ( Version.objects .latest_public_compatible_with(application, appversions) .no_transforms().transform(Version.transformer)) return ( qs.prefetch_related(Prefetch('versions', to_attr='compatible_versions', queryset=versions_qs)) .filter(versions__apps__application=application, versions__apps__min__version_int__lte=appversions['min'], versions__apps__max__version_int__gte=appversions['max'], versions__channel=amo.RELEASE_CHANNEL_LISTED, versions__files__status=amo.STATUS_APPROVED) .distinct() ) @method_decorator(cache_page(60 * 60 * 24)) def dispatch(self, *args, **kwargs): return super(LanguageToolsView, self).dispatch(*args, **kwargs) def list(self, request, *args, **kwargs): # Ignore pagination (return everything) but do wrap the data in a # 'results' property to mimic what the default implementation of list() # does in DRF. queryset = self.filter_queryset(self.get_queryset()) serializer = self.get_serializer(queryset, many=True) return Response({'results': serializer.data}) class ReplacementAddonView(ListAPIView): authentication_classes = [] queryset = ReplacementAddon.objects.all() serializer_class = ReplacementAddonSerializer class CompatOverrideView(ListAPIView): """This view is used by Firefox so it's performance-critical. Every firefox client requests the list of overrides approx. once per day. Firefox requests the overrides via a list of GUIDs which makes caching hard because the variation of possible GUID combinations prevent us to simply add some dumb-caching and requires us to resolve cache-misses. """ queryset = CompatOverride.objects.all() serializer_class = CompatOverrideSerializer @classmethod def as_view(cls, **initkwargs): """The API is read-only so we can turn off atomic requests.""" return non_atomic_requests( super(CompatOverrideView, cls).as_view(**initkwargs)) def get_guids(self): # Use the same Filter we use for AddonSearchView for consistency. guid_filter = AddonGuidQueryParam(self.request) return guid_filter.get_value() def filter_queryset(self, queryset): guids = self.get_guids() if not guids: raise exceptions.ParseError( 'Empty, or no, guid parameter provided.') # Evaluate the queryset and cast it into a list. # This will force Django to simply use len(queryset) instead of # calling .count() on it and avoids an additional COUNT query. # The amount of GUIDs we should get in real-life won't be paginated # most of the time so it's safe to simply evaluate the query. # The advantage here is that we are saving ourselves a `COUNT` query # and these are expensive. return list(queryset.filter(guid__in=guids).transform( CompatOverride.transformer).order_by('-pk')) class AddonRecommendationView(AddonSearchView): filter_backends = [ReviewedContentFilter] ab_outcome = None fallback_reason = None pagination_class = None def get_paginated_response(self, data): data = data[:4] # taar is only supposed to return 4 anyway. return Response(OrderedDict([ ('outcome', self.ab_outcome), ('fallback_reason', self.fallback_reason), ('page_size', 1), ('page_count', 1), ('count', len(data)), ('next', None), ('previous', None), ('results', data), ])) def filter_queryset(self, qs): qs = super(AddonRecommendationView, self).filter_queryset(qs) guid_param = self.request.GET.get('guid') taar_enable = self.request.GET.get('recommended', '').lower() == 'true' guids, self.ab_outcome, self.fallback_reason = ( get_addon_recommendations(guid_param, taar_enable)) results_qs = qs.query(query.Bool(must=[Q('terms', guid=guids)])) results_qs.execute() # To cache the results. if results_qs.count() != 4 and is_outcome_recommended(self.ab_outcome): guids, self.ab_outcome, self.fallback_reason = ( get_addon_recommendations_invalid()) return qs.query(query.Bool(must=[Q('terms', guid=guids)])) return results_qs def paginate_queryset(self, queryset): # We don't need pagination for the fixed number of results. return queryset

3840052143a4c80cb731fce500d7e4cb9f141b98

py

Python

scheduling/methods/k_means_NN_naive.py

CORE-Robotics-Lab/Personalized_Neural_Trees

3e8dd12fe4fc850be65c96c847eb143ef3bcdc2e

2021-05-22T19:25:01.000Z

2021-12-01T07:59:56.000Z

scheduling/methods/k_means_NN_naive.py

CORE-Robotics-Lab/Personalized_Neural_Trees

3e8dd12fe4fc850be65c96c847eb143ef3bcdc2e

scheduling/methods/k_means_NN_naive.py

CORE-Robotics-Lab/Personalized_Neural_Trees

3e8dd12fe4fc850be65c96c847eb143ef3bcdc2e

""" Created by Rohan Paleja on September 23, 2019 Nikolaidis et. al. benchmark """ import torch import torch.nn.functional as F # sys.path.insert(0, '/home/Anonymous/PycharmProjects/bayesian_prolo') import numpy as np import pickle from torch.autograd import Variable from utils.naive_utils import load_in_naive_data, find_which_schedule_this_belongs_to from utils.hri_utils import save_performance_results from sklearn.cluster import KMeans from scheduling.methods.train_autoencoder import Autoencoder, AutoEncoderTrain # sys.path.insert(0, '../') import itertools torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False torch.manual_seed(0) np.random.seed(0) from scheduling.methods.NN_naive import NNSmall # noinspection PyTypeChecker,PyArgumentList class NNTrain: """ class structure to train the NN for a certain amount of schedules. This class handles training the NN, evaluating the NN, and saving the results """ @staticmethod def cluster_matrices(matrices, num_schedules): """ clusters the matrix schedules :param matrices: :param num_schedules: :return: """ # vectorize each matrix vectorized_set = [] for i in matrices: vectorized = i.reshape(20 * 2048, 1) vectorized_set.append(vectorized) kmeans = KMeans(n_clusters=3, random_state=0) # random state makes it deterministic # Fitting the input data new_set = np.hstack(tuple(vectorized_set)).reshape(num_schedules, 20 * 2048) kmeans_model = kmeans.fit(np.asarray(new_set)) labels = kmeans_model.predict(np.asarray(new_set)) return kmeans_model, labels def train(self): """ Trains NN. Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled :return: """ epochs = 200000 * 3 for epoch in range(epochs): # sample a timestep before the cutoff for cross_validation rand_timestep_within_sched = np.random.randint(len(self.X_train_naive)) input_nn = self.X_train_naive[rand_timestep_within_sched] truth_nn = self.Y_train_naive[rand_timestep_within_sched] which_schedule = find_which_schedule_this_belongs_to(self.schedule_array_train_naive, rand_timestep_within_sched+self.sample_min) cluster_num = self.label[which_schedule] # iterate over pairwise comparisons if torch.cuda.is_available(): input_nn = Variable(torch.Tensor(np.asarray(input_nn).reshape(1, 242)).cuda()) # change to 5 to increase batch size truth = Variable(torch.Tensor(np.asarray(truth_nn).reshape(1)).cuda().long()) else: input_nn = Variable(torch.Tensor(np.asarray(input_nn).reshape(1, 242))) truth = Variable(torch.Tensor(np.asarray(truth_nn).reshape(1)).long()) self.optimizers[cluster_num].zero_grad() output = self.models[cluster_num].forward(input_nn) loss = F.cross_entropy(output, truth) loss.backward() # torch.nn.utils.clip_grad_norm_(self.model.parameters(), 0.5) self.optimizers[cluster_num].step() self.total_loss_array.append(loss.item()) if epoch % 500 == 499: print('loss at', epoch, ', total loss (average for each 100, averaged)', np.mean(self.total_loss_array[-100:])) # self.save_trained_nets(str(epoch)) @staticmethod def create_iterables(): """ adds all possible state combinations :return: """ iterables = [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]] states = [] for t in itertools.product(*iterables): states.append(t) return states def pass_in_embedding_out_state_ID(self, states, binary): """ pass in a binary embedding, and itll return the state id :param states :param binary: :return: """ binary_as_tuple = tuple(binary) index = states.index(binary_as_tuple) return index def evaluate_on_test_data(self): """ Evaluate performance of a trained network. This is tested on 20% of the data and will be stored in a text file. :return: """ # confusion_matrix = np.zeros((20,20)) autoencoder_class = AutoEncoderTrain(self.num_schedules) checkpoint = torch.load('/home/Anonymous/PycharmProjects/bayesian_prolo/scheduling_env/models/Autoencoder150.tar') autoencoder_class.model.load_state_dict(checkpoint['nn_state_dict']) states = self.create_iterables() prediction_accuracy = [0, 0] percentage_accuracy_top1 = [] percentage_accuracy_top3 = [] mean_input = [1.3277743, 0.32837677, 1.4974482, -1.3519306, -0.64621973, 0.10534518, -2.338118, -2.7345326, 1.7558736, -3.0746384, -3.485554] for i, schedule in enumerate(self.schedule_array_test_naive): current_schedule_matrix = np.zeros((2048, 20)) for count in range(schedule[0]-self.sample_test_min, schedule[1]-self.sample_test_min + 1): if current_schedule_matrix.sum() == 0: cluster_num = self.kmeans_model.predict(current_schedule_matrix.reshape(1, -1)) else: matrix = np.divide(current_schedule_matrix, current_schedule_matrix.sum()) cluster_num = self.kmeans_model.predict(matrix.reshape(1, -1)) net_input = self.X_test_naive[count] truth = self.Y_test_naive[count] if torch.cuda.is_available(): input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242)).cuda()) truth = Variable(torch.Tensor(np.asarray(truth).reshape(1)).cuda().long()) else: input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242))) truth = Variable(torch.Tensor(np.asarray(truth).reshape(1))) # forward output = self.models[int(cluster_num)].forward(input_nn) index = torch.argmax(output).item() # confusion_matrix[truth][index] += 1 # top 3 _, top_three = torch.topk(output, 3) if index == truth.item(): prediction_accuracy[0] += 1 if truth.item() in top_three.detach().cpu().tolist()[0]: prediction_accuracy[1] += 1 # update matrix embedding_copy = np.zeros((1, 11)) input_element = autoencoder_class.model.forward_only_encoding(input_nn) for z, each_element in enumerate(mean_input): if each_element > input_element[0][z].item(): embedding_copy[0][z] = 0 else: embedding_copy[0][z] = 1 index = self.pass_in_embedding_out_state_ID(states, embedding_copy[0]) action = truth.item() current_schedule_matrix[index][int(action)] += 1 print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20, ' top3: ', prediction_accuracy[1] / 20) print('schedule num:', i) percentage_accuracy_top1.append(prediction_accuracy[0] / 20) percentage_accuracy_top3.append(prediction_accuracy[1] / 20) prediction_accuracy = [0, 0] print(np.mean(percentage_accuracy_top1)) # save_performance_results(percentage_accuracy_top1, percentage_accuracy_top3, 'kmeans_to_NN_naive') return np.mean(percentage_accuracy_top1) def save_trained_nets(self, name): """ saves the model :return: """ torch.save({'nn1_state_dict': self.models[0].state_dict(), 'nn2_state_dict': self.models[1].state_dict(), 'nn3_state_dict': self.models[2].state_dict()}, '/home/Anonymous/PycharmProjects/bayesian_prolo/scheduling_env/models/k_means_NN_' + name + '.tar') def main(): """ entry point for file :return: """ res = [] for i in range(3): trainer = NNTrain() trainer.train() out = trainer.evaluate_on_test_data() res.append(out) print(np.mean(res)) print(np.std(res)) if __name__ == '__main__': main()

""" Created by Rohan Paleja on September 23, 2019 Nikolaidis et. al. benchmark """ import torch import torch.nn.functional as F # sys.path.insert(0, '/home/Anonymous/PycharmProjects/bayesian_prolo') import numpy as np import pickle from torch.autograd import Variable from utils.naive_utils import load_in_naive_data, find_which_schedule_this_belongs_to from utils.hri_utils import save_performance_results from sklearn.cluster import KMeans from scheduling.methods.train_autoencoder import Autoencoder, AutoEncoderTrain # sys.path.insert(0, '../') import itertools torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False torch.manual_seed(0) np.random.seed(0) from scheduling.methods.NN_naive import NNSmall # noinspection PyTypeChecker,PyArgumentList class NNTrain: """ class structure to train the NN for a certain amount of schedules. This class handles training the NN, evaluating the NN, and saving the results """ def __init__(self): self.num_schedules = 150 self.num_test_schedules = 100 self.total_loss_array = [] self.X_train_naive, self.Y_train_naive, self.schedule_array_train_naive, self.X_test_naive, self.Y_test_naive, self.schedule_array_test_naive = load_in_naive_data( 250,250) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model1 = NNSmall().to(device) model2 = NNSmall().to(device) model3 = NNSmall().to(device) self.models = [model1, model2, model3] opt1 = torch.optim.Adam(self.models[0].parameters(), lr=.001) opt2 = torch.optim.Adam(self.models[1].parameters(), lr=.001) opt3 = torch.optim.Adam(self.models[2].parameters(), lr=.001) self.optimizers = [opt1, opt2, opt3] self.when_to_save = 1000 schedule_matrix_load_directory = '/home/Anonymous/PycharmProjects/bayesian_prolo/scheduling_env/results/'+str(self.num_schedules) + 'matrixes.pkl' self.matrices = pickle.load(open(schedule_matrix_load_directory, "rb")) self.kmeans_model, self.label = self.cluster_matrices(self.matrices, self.num_schedules) self.X_train_naive, \ self.Y_train_naive, \ self.schedule_array_train_naive, = self.sample_data(150) self.X_test_naive, \ self.Y_test_naive, \ self.schedule_array_test_naive, = self.sample_test_data(100) self.num_test_schedules = 100 def sample_data(self, size): # return self.X_train_naive[0:size * 20 * 20], \ # self.Y_train_naive[0:size * 20 * 20], \ # self.schedule_array_train_naive[0:size], \ # self.start_of_each_set_twenty_train[0:size * 20] if size == 250: set_of_twenty = 0 else: set_of_twenty = np.random.randint(250-size) self.sample_min = set_of_twenty * 20 return self.X_train_naive[set_of_twenty*20:set_of_twenty*20 + size * 20], \ self.Y_train_naive[set_of_twenty*20:set_of_twenty*20 + size * 20], \ self.schedule_array_train_naive[set_of_twenty:set_of_twenty+size] def sample_test_data(self, size): # return self.X_train_naive[0:size * 20 * 20], \ # self.Y_train_naive[0:size * 20 * 20], \ # self.schedule_array_train_naive[0:size], \ # self.start_of_each_set_twenty_train[0:size * 20] if size == 250: set_of_twenty = 0 else: set_of_twenty = np.random.randint(250-size) self.sample_test_min = set_of_twenty * 20 return self.X_test_naive[set_of_twenty*20:set_of_twenty*20 + size * 20], \ self.Y_test_naive[set_of_twenty*20:set_of_twenty*20 + size * 20], \ self.schedule_array_test_naive[set_of_twenty:set_of_twenty+size] @staticmethod def cluster_matrices(matrices, num_schedules): """ clusters the matrix schedules :param matrices: :param num_schedules: :return: """ # vectorize each matrix vectorized_set = [] for i in matrices: vectorized = i.reshape(20 * 2048, 1) vectorized_set.append(vectorized) kmeans = KMeans(n_clusters=3, random_state=0) # random state makes it deterministic # Fitting the input data new_set = np.hstack(tuple(vectorized_set)).reshape(num_schedules, 20 * 2048) kmeans_model = kmeans.fit(np.asarray(new_set)) labels = kmeans_model.predict(np.asarray(new_set)) return kmeans_model, labels def train(self): """ Trains NN. Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled :return: """ epochs = 200000 * 3 for epoch in range(epochs): # sample a timestep before the cutoff for cross_validation rand_timestep_within_sched = np.random.randint(len(self.X_train_naive)) input_nn = self.X_train_naive[rand_timestep_within_sched] truth_nn = self.Y_train_naive[rand_timestep_within_sched] which_schedule = find_which_schedule_this_belongs_to(self.schedule_array_train_naive, rand_timestep_within_sched+self.sample_min) cluster_num = self.label[which_schedule] # iterate over pairwise comparisons if torch.cuda.is_available(): input_nn = Variable(torch.Tensor(np.asarray(input_nn).reshape(1, 242)).cuda()) # change to 5 to increase batch size truth = Variable(torch.Tensor(np.asarray(truth_nn).reshape(1)).cuda().long()) else: input_nn = Variable(torch.Tensor(np.asarray(input_nn).reshape(1, 242))) truth = Variable(torch.Tensor(np.asarray(truth_nn).reshape(1)).long()) self.optimizers[cluster_num].zero_grad() output = self.models[cluster_num].forward(input_nn) loss = F.cross_entropy(output, truth) loss.backward() # torch.nn.utils.clip_grad_norm_(self.model.parameters(), 0.5) self.optimizers[cluster_num].step() self.total_loss_array.append(loss.item()) if epoch % 500 == 499: print('loss at', epoch, ', total loss (average for each 100, averaged)', np.mean(self.total_loss_array[-100:])) # self.save_trained_nets(str(epoch)) @staticmethod def create_iterables(): """ adds all possible state combinations :return: """ iterables = [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]] states = [] for t in itertools.product(*iterables): states.append(t) return states def pass_in_embedding_out_state_ID(self, states, binary): """ pass in a binary embedding, and itll return the state id :param states :param binary: :return: """ binary_as_tuple = tuple(binary) index = states.index(binary_as_tuple) return index def evaluate_on_test_data(self): """ Evaluate performance of a trained network. This is tested on 20% of the data and will be stored in a text file. :return: """ # confusion_matrix = np.zeros((20,20)) autoencoder_class = AutoEncoderTrain(self.num_schedules) checkpoint = torch.load('/home/Anonymous/PycharmProjects/bayesian_prolo/scheduling_env/models/Autoencoder150.tar') autoencoder_class.model.load_state_dict(checkpoint['nn_state_dict']) states = self.create_iterables() prediction_accuracy = [0, 0] percentage_accuracy_top1 = [] percentage_accuracy_top3 = [] mean_input = [1.3277743, 0.32837677, 1.4974482, -1.3519306, -0.64621973, 0.10534518, -2.338118, -2.7345326, 1.7558736, -3.0746384, -3.485554] for i, schedule in enumerate(self.schedule_array_test_naive): current_schedule_matrix = np.zeros((2048, 20)) for count in range(schedule[0]-self.sample_test_min, schedule[1]-self.sample_test_min + 1): if current_schedule_matrix.sum() == 0: cluster_num = self.kmeans_model.predict(current_schedule_matrix.reshape(1, -1)) else: matrix = np.divide(current_schedule_matrix, current_schedule_matrix.sum()) cluster_num = self.kmeans_model.predict(matrix.reshape(1, -1)) net_input = self.X_test_naive[count] truth = self.Y_test_naive[count] if torch.cuda.is_available(): input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242)).cuda()) truth = Variable(torch.Tensor(np.asarray(truth).reshape(1)).cuda().long()) else: input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242))) truth = Variable(torch.Tensor(np.asarray(truth).reshape(1))) # forward output = self.models[int(cluster_num)].forward(input_nn) index = torch.argmax(output).item() # confusion_matrix[truth][index] += 1 # top 3 _, top_three = torch.topk(output, 3) if index == truth.item(): prediction_accuracy[0] += 1 if truth.item() in top_three.detach().cpu().tolist()[0]: prediction_accuracy[1] += 1 # update matrix embedding_copy = np.zeros((1, 11)) input_element = autoencoder_class.model.forward_only_encoding(input_nn) for z, each_element in enumerate(mean_input): if each_element > input_element[0][z].item(): embedding_copy[0][z] = 0 else: embedding_copy[0][z] = 1 index = self.pass_in_embedding_out_state_ID(states, embedding_copy[0]) action = truth.item() current_schedule_matrix[index][int(action)] += 1 print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20, ' top3: ', prediction_accuracy[1] / 20) print('schedule num:', i) percentage_accuracy_top1.append(prediction_accuracy[0] / 20) percentage_accuracy_top3.append(prediction_accuracy[1] / 20) prediction_accuracy = [0, 0] print(np.mean(percentage_accuracy_top1)) # save_performance_results(percentage_accuracy_top1, percentage_accuracy_top3, 'kmeans_to_NN_naive') return np.mean(percentage_accuracy_top1) def save_trained_nets(self, name): """ saves the model :return: """ torch.save({'nn1_state_dict': self.models[0].state_dict(), 'nn2_state_dict': self.models[1].state_dict(), 'nn3_state_dict': self.models[2].state_dict()}, '/home/Anonymous/PycharmProjects/bayesian_prolo/scheduling_env/models/k_means_NN_' + name + '.tar') def main(): """ entry point for file :return: """ res = [] for i in range(3): trainer = NNTrain() trainer.train() out = trainer.evaluate_on_test_data() res.append(out) print(np.mean(res)) print(np.std(res)) if __name__ == '__main__': main()

b388f68a9de50b2d68147365e456767b8e775cd2

py

Python

candy_collect.py

itiB/poke-scripts

e2da1356ee8000c7345682d4c07709481f2044f8

2020-02-08T13:55:46.000Z

2020-07-21T13:17:26.000Z

candy_collect.py

itiB/poke-scripts

e2da1356ee8000c7345682d4c07709481f2044f8

candy_collect.py

itiB/poke-scripts

e2da1356ee8000c7345682d4c07709481f2044f8

#!/usr/bin/env python3 import argparse import serial import time from time import sleep import datetime parser = argparse.ArgumentParser() parser.add_argument('port') args = parser.parse_args() sleep_time = 50 ser = serial.Serial(args.port, 9600) sleep(3) send('Button LCLICK', 0.1) try: while 1: candyCorrect() except KeyboardInterrupt: send('RELEASE') ser.close()

#!/usr/bin/env python3 import argparse import serial import time from time import sleep import datetime parser = argparse.ArgumentParser() parser.add_argument('port') args = parser.parse_args() sleep_time = 50 def send(msg, duration=0): print(msg) ser.write(f'{msg}\r\n'.encode('utf-8')) sleep(duration) ser.write(b'RELEASE\r\n') ser = serial.Serial(args.port, 9600) def candyCorrect(): send('LY MAX', 0.1) sleep(0.3) send('Button A', 0.1) sleep(1) send('Button B', 0.1) sleep(0.8) send('LY MIN', 0.1) sleep(0.5) send('Button A', 0.1) sleep(0.3) send('LY MAX', 0.1) sleep(0.2) send('Button A', 0.1) sleep(0.3) send('Button A', 0.1) sleep(0.3) send('Button A', 0.1) sleep(2.5) send('Button A', 0.1) sleep(1.0) send('Button A', 0.1) for i in range(0, sleep_time): sleep(1) if i % 10 == 0: print(f'あと {sleep_time - i}秒 スリープします') sleep(3) send('Button LCLICK', 0.1) try: while 1: candyCorrect() except KeyboardInterrupt: send('RELEASE') ser.close()

a4ef9bd877c250ea0e460a024503d8e819218c76

py

Python

utils_ic.py

kkkgabriel/50039Homework3

69d8f36f60868cac64bb1d1682eba34a548f3565

utils_ic.py

kkkgabriel/50039Homework3

69d8f36f60868cac64bb1d1682eba34a548f3565

utils_ic.py

kkkgabriel/50039Homework3

69d8f36f60868cac64bb1d1682eba34a548f3565

import json import torch from torchvision import datasets, transforms from PIL import Image # Define function to read cat names # Define function to read data # Define processing testing image function def process_image(image): ''' Scales, crops, and normalizes a PIL image for a PyTorch model, returns an Numpy array ''' # TODO: Process a PIL image for use in a PyTorch model # Resize and crop image im = Image.open(image) preprocess = transforms.Compose([transforms.Resize(255), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) im_tensor = preprocess(im) im_tensor.unsqueeze_(0) return im_tensor # Define prediction function def predict(image_path, model, topk, device, cat_to_name): ''' Predict the class (or classes) of an image using a trained deep learning model. ''' model.to(device) model.eval() # TODO: Implement the code to predict the class from an image file img = process_image(image_path) img = img.to(device) output = model.forward(img) ps = torch.exp(output) probs, idxs = ps.topk(topk) idx_to_class = dict((v,k) for k, v in model.classifier.class_to_idx.items()) classes = [v for k, v in idx_to_class.items() if k in idxs.to('cpu').numpy()] if cat_to_name: classes = [cat_to_name[str(i + 1)] for c, i in \ model.classifier.class_to_idx.items() if c in classes] print('Probabilities:', probs.data.cpu().numpy()[0].tolist()) print('Classes:', classes)

import json import torch from torchvision import datasets, transforms from PIL import Image # Define function to read cat names def read_jason(filename): with open(filename, 'r') as f: cat_to_name = json.load(f) return cat_to_name # Define function to read data def load_data(data_dir): train_dir = data_dir + '/train' valid_dir = data_dir + '/valid' test_dir = data_dir + '/test' # Define your transforms for the training, validation, and testing sets train_transforms = transforms.Compose([transforms.RandomRotation(30), transforms.Resize(255), transforms.CenterCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) test_valid_transforms = transforms.Compose([transforms.Resize(255), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) # Load the datasets with ImageFolder train_data = datasets.ImageFolder(train_dir, transform=train_transforms) test_data = datasets.ImageFolder(test_dir, transform=test_valid_transforms) valid_data = datasets.ImageFolder(valid_dir, transform=test_valid_transforms) # Using the image datasets and the trainforms, define the dataloaders trainloader = torch.utils.data.DataLoader(train_data, batch_size=16, shuffle=True) testloader = torch.utils.data.DataLoader(test_data, batch_size=32) validloader = torch.utils.data.DataLoader(valid_data, batch_size=32) return trainloader, testloader, validloader, train_data # Define processing testing image function def process_image(image): ''' Scales, crops, and normalizes a PIL image for a PyTorch model, returns an Numpy array ''' # TODO: Process a PIL image for use in a PyTorch model # Resize and crop image im = Image.open(image) preprocess = transforms.Compose([transforms.Resize(255), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]) im_tensor = preprocess(im) im_tensor.unsqueeze_(0) return im_tensor # Define prediction function def predict(image_path, model, topk, device, cat_to_name): ''' Predict the class (or classes) of an image using a trained deep learning model. ''' model.to(device) model.eval() # TODO: Implement the code to predict the class from an image file img = process_image(image_path) img = img.to(device) output = model.forward(img) ps = torch.exp(output) probs, idxs = ps.topk(topk) idx_to_class = dict((v,k) for k, v in model.classifier.class_to_idx.items()) classes = [v for k, v in idx_to_class.items() if k in idxs.to('cpu').numpy()] if cat_to_name: classes = [cat_to_name[str(i + 1)] for c, i in \ model.classifier.class_to_idx.items() if c in classes] print('Probabilities:', probs.data.cpu().numpy()[0].tolist()) print('Classes:', classes)

7c9ecc3b2e26c62f94ef6497972cb0e25e5a58f9

py

Python

tensorflow/python/tools/freeze_graph_test.py

yage99/tensorflow

c7fa71b32a3635eb25596ae80d007b41007769c4

2020-08-04T12:36:25.000Z

2022-03-25T04:23:40.000Z

tensorflow/python/tools/freeze_graph_test.py

sseung0703/tensorflow

be084bd7a4dd241eb781fc704f57bcacc5c9b6dd

2019-12-15T01:20:31.000Z

2022-02-10T02:06:28.000Z

tensorflow/python/tools/freeze_graph_test.py

sseung0703/tensorflow

be084bd7a4dd241eb781fc704f57bcacc5c9b6dd

2020-02-10T07:03:06.000Z

2022-01-12T11:19:20.000Z

# Copyright 2015 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. # ============================================================================== """Tests the graph freezing tool.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import re from absl.testing import parameterized from tensorflow.core.example import example_pb2 from tensorflow.core.framework import graph_pb2 from tensorflow.core.protobuf import saver_pb2 from tensorflow.python.client import session from tensorflow.python.framework import dtypes from tensorflow.python.framework import graph_io from tensorflow.python.framework import importer from tensorflow.python.framework import ops from tensorflow.python.framework import test_util from tensorflow.python.ops import array_ops from tensorflow.python.ops import math_ops from tensorflow.python.ops import nn from tensorflow.python.ops import parsing_ops from tensorflow.python.ops import partitioned_variables from tensorflow.python.ops import variable_scope from tensorflow.python.ops import variables from tensorflow.python.platform import test from tensorflow.python.saved_model import builder as saved_model_builder from tensorflow.python.saved_model import signature_constants from tensorflow.python.saved_model import signature_def_utils from tensorflow.python.saved_model import tag_constants from tensorflow.python.tools import freeze_graph from tensorflow.python.training import saver as saver_lib if __name__ == "__main__": test.main()

# Copyright 2015 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. # ============================================================================== """Tests the graph freezing tool.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import re from absl.testing import parameterized from tensorflow.core.example import example_pb2 from tensorflow.core.framework import graph_pb2 from tensorflow.core.protobuf import saver_pb2 from tensorflow.python.client import session from tensorflow.python.framework import dtypes from tensorflow.python.framework import graph_io from tensorflow.python.framework import importer from tensorflow.python.framework import ops from tensorflow.python.framework import test_util from tensorflow.python.ops import array_ops from tensorflow.python.ops import math_ops from tensorflow.python.ops import nn from tensorflow.python.ops import parsing_ops from tensorflow.python.ops import partitioned_variables from tensorflow.python.ops import variable_scope from tensorflow.python.ops import variables from tensorflow.python.platform import test from tensorflow.python.saved_model import builder as saved_model_builder from tensorflow.python.saved_model import signature_constants from tensorflow.python.saved_model import signature_def_utils from tensorflow.python.saved_model import tag_constants from tensorflow.python.tools import freeze_graph from tensorflow.python.training import saver as saver_lib class FreezeGraphTest(test_util.TensorFlowTestCase, parameterized.TestCase): def _testFreezeGraph(self, saver_write_version): checkpoint_prefix = os.path.join(self.get_temp_dir(), "saved_checkpoint") checkpoint_state_name = "checkpoint_state" input_graph_name = "input_graph.pb" output_graph_name = "output_graph.pb" # We'll create an input graph that has a single variable containing 1.0, # and that then multiplies it by 2. with ops.Graph().as_default(): variable_node = variables.VariableV1(1.0, name="variable_node") output_node = math_ops.multiply(variable_node, 2.0, name="output_node") sess = session.Session() init = variables.global_variables_initializer() sess.run(init) output = sess.run(output_node) self.assertNear(2.0, output, 0.00001) saver = saver_lib.Saver(write_version=saver_write_version) checkpoint_path = saver.save( sess, checkpoint_prefix, global_step=0, latest_filename=checkpoint_state_name) graph_io.write_graph(sess.graph, self.get_temp_dir(), input_graph_name) # We save out the graph to disk, and then call the const conversion # routine. input_graph_path = os.path.join(self.get_temp_dir(), input_graph_name) input_saver_def_path = "" input_binary = False output_node_names = "output_node" restore_op_name = "save/restore_all" filename_tensor_name = "save/Const:0" output_graph_path = os.path.join(self.get_temp_dir(), output_graph_name) clear_devices = False freeze_graph.freeze_graph( input_graph_path, input_saver_def_path, input_binary, checkpoint_path, output_node_names, restore_op_name, filename_tensor_name, output_graph_path, clear_devices, "", "", "", checkpoint_version=saver_write_version) # Now we make sure the variable is now a constant, and that the graph still # produces the expected result. with ops.Graph().as_default(): output_graph_def = graph_pb2.GraphDef() with open(output_graph_path, "rb") as f: output_graph_def.ParseFromString(f.read()) _ = importer.import_graph_def(output_graph_def, name="") self.assertEqual(4, len(output_graph_def.node)) for node in output_graph_def.node: self.assertNotEqual("VariableV2", node.op) self.assertNotEqual("Variable", node.op) with session.Session() as sess: output_node = sess.graph.get_tensor_by_name("output_node:0") output = sess.run(output_node) self.assertNear(2.0, output, 0.00001) def _createTFExampleString(self, feature_name, feature_value): """Create a serialized tensorflow example.""" example = example_pb2.Example() example.features.feature[feature_name].float_list.value.extend([ feature_value]) return example.SerializeToString() def _writeDummySavedModel(self, path, feature_name, tags): """Writes a classifier with two input features to the given path.""" with ops.Graph().as_default(): examples = array_ops.placeholder(dtypes.string, name="input_node") feature_configs = { feature_name: parsing_ops.FixedLenFeature(shape=[], dtype=dtypes.float32), } features = parsing_ops.parse_example(examples, feature_configs) feature = features[feature_name] variable_node = variables.VariableV1(1.0, name="variable_node") scores = math_ops.multiply(variable_node, feature, name="output_node") class_feature = array_ops.fill(array_ops.shape(feature), "class_%s" % feature_name) classes = array_ops.transpose(class_feature) with session.Session() as sess: sess.run(variables.global_variables_initializer()) signature = ( signature_def_utils.classification_signature_def( examples=examples, classes=classes, scores=scores,)) builder = saved_model_builder.SavedModelBuilder(path) builder.add_meta_graph_and_variables( sess, tags, signature_def_map={ signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature, }, ) builder.save(as_text=True) @test_util.run_v1_only("b/120545219") def testFreezeGraphV1(self): self._testFreezeGraph(saver_pb2.SaverDef.V1) @test_util.run_v1_only("b/120545219") def testFreezeGraphV2(self): self._testFreezeGraph(saver_pb2.SaverDef.V2) def testFreezeMetaGraph(self): tmp_dir = self.get_temp_dir() checkpoint_prefix = os.path.join(tmp_dir, "meta_graph_checkpoint") checkpoint_state_name = "checkpoint_state" output_graph_filename = os.path.join(tmp_dir, "output_graph.pb") with ops.Graph().as_default(): variable_node = variables.VariableV1(1.0, name="variable_node") output_node = math_ops.multiply(variable_node, 2.0, name="output_node") sess = session.Session() init = variables.global_variables_initializer() sess.run(init) output = sess.run(output_node) self.assertNear(2.0, output, 0.00001) saver = saver_lib.Saver() checkpoint_path = saver.save( sess, checkpoint_prefix, global_step=0, latest_filename=checkpoint_state_name) input_saver_def_path = "" input_binary = True output_node_names = "output_node" restore_op_name = "save/restore_all" filename_tensor_name = "save/Const:0" clear_devices = False input_meta_graph = checkpoint_path + ".meta" freeze_graph.freeze_graph( "", input_saver_def_path, input_binary, checkpoint_path, output_node_names, restore_op_name, filename_tensor_name, output_graph_filename, clear_devices, "", "", "", input_meta_graph) # Now we make sure the variable is now a constant, and that the graph still # produces the expected result. with ops.Graph().as_default(): output_graph_def = graph_pb2.GraphDef() with open(output_graph_filename, "rb") as f: output_graph_def.ParseFromString(f.read()) _ = importer.import_graph_def(output_graph_def, name="") self.assertEqual(4, len(output_graph_def.node)) for node in output_graph_def.node: self.assertNotEqual("VariableV2", node.op) self.assertNotEqual("Variable", node.op) with session.Session() as sess: output_node = sess.graph.get_tensor_by_name("output_node:0") output = sess.run(output_node) self.assertNear(2.0, output, 0.00001) @parameterized.named_parameters( ("empty_tags_set", "", []), ("default_tags_set", tag_constants.SERVING, [tag_constants.SERVING])) def testFreezeSavedModel(self, tags_string, tags_list): tmp_dir = self.get_temp_dir() saved_model_dir = os.path.join(tmp_dir, "saved_model_dir") feature_name = "feature" self._writeDummySavedModel(saved_model_dir, feature_name, tags_list) output_graph_filename = os.path.join(tmp_dir, "output_graph.pb") input_saved_model_dir = saved_model_dir output_node_names = "output_node" input_binary = False input_saver_def_path = False restore_op_name = None filename_tensor_name = None clear_devices = False input_meta_graph = False checkpoint_path = None input_graph_filename = None saved_model_tags = tags_string freeze_graph.freeze_graph(input_graph_filename, input_saver_def_path, input_binary, checkpoint_path, output_node_names, restore_op_name, filename_tensor_name, output_graph_filename, clear_devices, "", "", "", input_meta_graph, input_saved_model_dir, saved_model_tags) # Now we make sure the variable is now a constant, and that the graph still # produces the expected result. with ops.Graph().as_default(): output_graph_def = graph_pb2.GraphDef() with open(output_graph_filename, "rb") as f: output_graph_def.ParseFromString(f.read()) _ = importer.import_graph_def(output_graph_def, name="") if any(u"ParseExampleV2" in node.name for node in output_graph_def.node): expected_node_count = 10 else: expected_node_count = 8 self.assertEqual(expected_node_count, len(output_graph_def.node)) for node in output_graph_def.node: self.assertNotEqual("VariableV2", node.op) self.assertNotEqual("Variable", node.op) feature_value = 2.0 example = self._createTFExampleString(feature_name, feature_value) with session.Session() as sess: input_node = sess.graph.get_tensor_by_name("input_node:0") output_node = sess.graph.get_tensor_by_name("output_node:0") output = sess.run(output_node, feed_dict={input_node: [example]}) self.assertNear(feature_value, output, 0.00001) def testSinglePartitionedVariable(self): """Ensures partitioned variables fail cleanly with freeze graph.""" checkpoint_prefix = os.path.join(self.get_temp_dir(), "saved_checkpoint") checkpoint_state_name = "checkpoint_state" input_graph_name = "input_graph.pb" output_graph_name = "output_graph.pb" # Create a graph with partition variables. When weights are partitioned into # a single partition, the weights variable is followed by a identity -> # identity (an additional identity node). partitioner = partitioned_variables.fixed_size_partitioner(1) with ops.Graph().as_default(): with variable_scope.variable_scope("part", partitioner=partitioner): batch_size, height, width, depth = 5, 128, 128, 3 input1 = array_ops.zeros( (batch_size, height, width, depth), name="input1") input2 = array_ops.zeros( (batch_size, height, width, depth), name="input2") num_nodes = depth filter1 = variable_scope.get_variable("filter", [num_nodes, num_nodes]) filter2 = array_ops.reshape(filter1, [1, 1, num_nodes, num_nodes]) conv = nn.conv2d( input=input1, filter=filter2, strides=[1, 1, 1, 1], padding="SAME") node = math_ops.add(conv, input2, name="test/add") node = nn.relu6(node, name="test/relu6") # Save graph and checkpoints. sess = session.Session() sess.run(variables.global_variables_initializer()) saver = saver_lib.Saver() checkpoint_path = saver.save( sess, checkpoint_prefix, global_step=0, latest_filename=checkpoint_state_name) graph_io.write_graph(sess.graph, self.get_temp_dir(), input_graph_name) # Ensure this graph has partition variables. self.assertTrue([ tensor.name.split(":")[0] for op in sess.graph.get_operations() for tensor in op.values() if re.search(r"/part_\d+/", tensor.name) ]) # Test freezing graph doesn't make it crash. output_node_names = "save/restore_all" output_graph_path = os.path.join(self.get_temp_dir(), output_graph_name) with self.assertRaises(ValueError): freeze_graph.freeze_graph_with_def_protos( input_graph_def=sess.graph_def, input_saver_def=None, input_checkpoint=checkpoint_path, output_node_names=output_node_names, restore_op_name="save/restore_all", # default value filename_tensor_name="save/Const:0", # default value output_graph=output_graph_path, clear_devices=False, initializer_nodes="") if __name__ == "__main__": test.main()

5d3f7ba06d8f30ec1f43524b350975670db0b280

py

Python

tests/gmprocess/waveform_processing/adjust_highpass_ridder_test.py

usgs/groundmotion-processing-

ed188e2bb1dcd9b17433ef4677874eac654fdd16

tests/gmprocess/waveform_processing/adjust_highpass_ridder_test.py

usgs/groundmotion-processing-

ed188e2bb1dcd9b17433ef4677874eac654fdd16

tests/gmprocess/waveform_processing/adjust_highpass_ridder_test.py

usgs/groundmotion-processing-

ed188e2bb1dcd9b17433ef4677874eac654fdd16

#!/usr/bin/env python # -*- coding: utf-8 -*- import os import numpy as np from gmprocess.core.streamcollection import StreamCollection from gmprocess.io.read import read_data from gmprocess.utils.test_utils import read_data_dir from gmprocess.waveform_processing.adjust_highpass_ridder import ridder_fchp from gmprocess.utils.config import get_config if __name__ == "__main__": os.environ["CALLED_FROM_PYTEST"] = "True" test_auto_fchp()

#!/usr/bin/env python # -*- coding: utf-8 -*- import os import numpy as np from gmprocess.core.streamcollection import StreamCollection from gmprocess.io.read import read_data from gmprocess.utils.test_utils import read_data_dir from gmprocess.waveform_processing.adjust_highpass_ridder import ridder_fchp from gmprocess.utils.config import get_config def test_auto_fchp(): data_files, origin = read_data_dir("geonet", "us1000778i", "*.V1A") data_files.sort() streams = [] for f in data_files: streams += read_data(f) sc = StreamCollection(streams) output_fchp = [] config = get_config() config["integration"]["frequency"] = True for st in sc: for tr in st: tr.setParameter( "corner_frequencies", {"type": "constant", "highpass": 0.001, "lowpass": 20}, ) tmp_st = ridder_fchp(st, config=config) for tr in tmp_st: initial_corners = tr.getParameter("corner_frequencies") output_fchp.append(initial_corners["highpass"]) target_fchp = np.array( [ 0.021345158261480087, 0.022839239726168643, 0.02482398434993213, 0.01399481102242619, 0.026850167635921275, 0.004817661513765862, 0.008204101694236587, 0.006429246474225982, 0.004237087327289796, ] ) np.testing.assert_allclose(output_fchp, target_fchp, atol=1e-7) if __name__ == "__main__": os.environ["CALLED_FROM_PYTEST"] = "True" test_auto_fchp()

8314dc9023ae51350cf14c4fc6f29ae2621bb8d7

py

Python

supperfeed/importer.py

corydodt/SupperFeed

2980e3f6d287f56c6eade06cfe57870d9796c5ea

2015-10-28T23:53:29.000Z

2018-02-27T12:39:54.000Z

supperfeed/importer.py

corydodt/SupperFeed

2980e3f6d287f56c6eade06cfe57870d9796c5ea

supperfeed/importer.py

corydodt/SupperFeed

2980e3f6d287f56c6eade06cfe57870d9796c5ea

""" Import recipes from URLs to our database """ import re import json from txpx import background, EchoProcess from txpx.process import LineGlueProtocol from supperfeed.build import Recipe LineGlueProtocol.MAX_LENGTH=10000 class ImportProcess(EchoProcess): """ Import a recipe by loading the json data dumped by the downloader process """

""" Import recipes from URLs to our database """ import re import json from txpx import background, EchoProcess from txpx.process import LineGlueProtocol from supperfeed.build import Recipe LineGlueProtocol.MAX_LENGTH=10000 class ImportProcess(EchoProcess): """ Import a recipe by loading the json data dumped by the downloader process """ def __init__(self, *a, **kw): EchoProcess.__init__(self, *a, **kw) self.linebuf = [] def outLineReceived(self, line): if re.match(r'^/\*+/$', line): return self.finished() self.linebuf.append(line) def finished(self): data = json.loads('\n'.join(self.linebuf)) recipe = Recipe.fromLoadedData(data) recipe.save() self.linebuf[:] = [] def importRecipe(url): d = background(['recipeschema', url], proto=ImportProcess) d.addCallback(lambda ok: Recipe.objects(importedFrom=url).first()) return d

30f5d5f62a940e9c9c56d93b2735b45ae0a23f7e

py

Python

src/my_project/medium_problems/from1to50/group_people_give_group_size.py

ivan1016017/LeetCodeAlgorithmProblems

f617f30201fb1cd53e32de35084fdeb88ef36023

src/my_project/medium_problems/from1to50/group_people_give_group_size.py

ivan1016017/LeetCodeAlgorithmProblems

f617f30201fb1cd53e32de35084fdeb88ef36023

2021-09-22T12:26:14.000Z

2021-09-22T12:26:14.000Z

src/my_project/medium_problems/from1to50/group_people_give_group_size.py

ivan1016017/LeetCodeAlgorithmProblems

454284b76634cc34ed41f7fa30d857403cedf1bf

from typing import List solution = Solution() print(solution.groupThePeople(groupSizes = [3,3,3,3,3,1,3]))

from typing import List class Solution: def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]: final_groups=[] count_dict = {} for ind, val in enumerate(groupSizes): # print(count_dict) if val in count_dict.keys(): if len(count_dict[val]) < val: count_dict[val].append(ind) else: final_groups.append(count_dict[val]) count_dict[val] = [ind] else: count_dict[val] = [ind] for key in count_dict.keys(): final_groups.append(count_dict[key]) return final_groups solution = Solution() print(solution.groupThePeople(groupSizes = [3,3,3,3,3,1,3]))

dbd8f6bc8f256424cc38bdbd062b914922bea024

py

Python

tests/bidirectional_lut_test.py

pnarvor/nephelae_simulation

7b3f3a2c2aaa49324f8b09a6ab62819c280efa4c

tests/bidirectional_lut_test.py

pnarvor/nephelae_simulation

7b3f3a2c2aaa49324f8b09a6ab62819c280efa4c

tests/bidirectional_lut_test.py

pnarvor/nephelae_simulation

7b3f3a2c2aaa49324f8b09a6ab62819c280efa4c

#! /usr/bin/python3 import sys import os sys.path.append('../') import numpy as np import matplotlib.pyplot as plt import imageio import matplotlib.cm as cm import time from netCDF4 import MFDataset import mesonh_probe as cdf """ test file for periodiccontainer and netcdfinterface types - arguments : mesonh (netcdf) files to open """ mesonhfiles = sys.argv[slice(1,len(sys.argv))] atm = MFDataset(mesonhfiles) lut = cdf.BiDirectionalLUT(atm.variables['VLEV'][:,0,0]) lin = cdf.BiDirectionalLinear(atm.variables['S_N_direction'][:]) plot1, axes1 = plt.subplots(1,2) x = np.linspace(0,160,1000) axes1[0].plot(x, lut.to_output_space(np.linspace(0,160,1000))) x = np.linspace(0.005,3.95,1000) axes1[1].plot(x, lut.to_input_space(np.linspace(0.005,3.95,1000))) plot1, axes1 = plt.subplots(1,2) x = np.linspace(0,160,1000) axes1[0].plot(x, lin.to_output_space(np.linspace(0,700,1000))) x = np.linspace(0.005,3.95,1000) axes1[1].plot(x, lin.to_input_space(np.linspace(-1,5,1000))) plt.show(block=False)

#! /usr/bin/python3 import sys import os sys.path.append('../') import numpy as np import matplotlib.pyplot as plt import imageio import matplotlib.cm as cm import time from netCDF4 import MFDataset import mesonh_probe as cdf """ test file for periodiccontainer and netcdfinterface types - arguments : mesonh (netcdf) files to open """ mesonhfiles = sys.argv[slice(1,len(sys.argv))] atm = MFDataset(mesonhfiles) lut = cdf.BiDirectionalLUT(atm.variables['VLEV'][:,0,0]) lin = cdf.BiDirectionalLinear(atm.variables['S_N_direction'][:]) plot1, axes1 = plt.subplots(1,2) x = np.linspace(0,160,1000) axes1[0].plot(x, lut.to_output_space(np.linspace(0,160,1000))) x = np.linspace(0.005,3.95,1000) axes1[1].plot(x, lut.to_input_space(np.linspace(0.005,3.95,1000))) plot1, axes1 = plt.subplots(1,2) x = np.linspace(0,160,1000) axes1[0].plot(x, lin.to_output_space(np.linspace(0,700,1000))) x = np.linspace(0.005,3.95,1000) axes1[1].plot(x, lin.to_input_space(np.linspace(-1,5,1000))) plt.show(block=False)

754066c0276ad5f42837eccb52a06e7a374ef810

py

Python

tests/test_get_credits.py

freshsecurity/zerobounce-python-api-v2

7bd5c838db24cde6c5cbca5ca1590395e707b7cd

2018-11-01T08:37:43.000Z

2019-10-23T13:58:27.000Z

tests/test_get_credits.py

freshsecurity/zerobounce-python-api-v2

7bd5c838db24cde6c5cbca5ca1590395e707b7cd

2019-10-09T22:30:52.000Z

2022-01-14T15:13:32.000Z

tests/test_get_credits.py

freshsecurity/zerobounce-python-api-v2

7bd5c838db24cde6c5cbca5ca1590395e707b7cd

2018-07-18T10:55:07.000Z

2019-11-21T14:53:11.000Z

import responses @responses.activate

import responses @responses.activate def test_should_get_2375323_of_credit(zerobounce, zerobounce_response_getcredits): responses.add(responses.GET, 'https://api.zerobounce.net/v2/getcredits?api_key=123456', json=zerobounce_response_getcredits, status=200) assert zerobounce.get_credits() == 2375323

5c0bef4089d7fb266a9c29954e06a567e8ce9a6d

py

Python

constant/constant.py

ZxbMsl160918/covid19-vaccin

7ebf3fa1de45fdaec8108e79ff6e090400cde9eb

constant/constant.py

ZxbMsl160918/covid19-vaccin

7ebf3fa1de45fdaec8108e79ff6e090400cde9eb

constant/constant.py

ZxbMsl160918/covid19-vaccin

7ebf3fa1de45fdaec8108e79ff6e090400cde9eb

# 请求成功 RESPONSE_OK = 200 # 请求所需的URL地址 URLS = { # 主机地址 "hostUrl": "https://m.r.umiaohealth.com/", # 获取疫苗接种列表地址；POST "vaccinationAddress": "/InstitutionMedicineStock/GetBykeyword_InstitutionMedicineStock", # 获取某个社区医院的某一天可预约的时间段 "hospitalTimeRange": "/Reservation/GetByWorkDate_Rsv_TimeRange", # 执行疫苗预约请求 url；GET "secVaccination": "/Reservation/Reservation_Create", # 获取 childId "childId": "/Adult/Index", # 获取用户信息 "userMsg": "/Home/My" } # 区域名称 AREAS = [ "天河区", "白云区", "黄埔区", "荔湾区", "越秀区", "海珠区", "番禺区", "花都区", "南沙区", "增城区", "从化区" ] # 所有疫苗类型 VACCINE_TYPES = { "veroCell": 5601, # 新冠疫苗（Vero细胞） "adenovirusVector": 5602 # 新冠疫苗（腺病毒载体） # etc... } # 需要预约的疫苗类型 SEC_TYPE = VACCINE_TYPES["veroCell"]

# 请求成功 RESPONSE_OK = 200 # 请求所需的URL地址 URLS = { # 主机地址 "hostUrl": "https://m.r.umiaohealth.com/", # 获取疫苗接种列表地址；POST "vaccinationAddress": "/InstitutionMedicineStock/GetBykeyword_InstitutionMedicineStock", # 获取某个社区医院的某一天可预约的时间段 "hospitalTimeRange": "/Reservation/GetByWorkDate_Rsv_TimeRange", # 执行疫苗预约请求 url；GET "secVaccination": "/Reservation/Reservation_Create", # 获取 childId "childId": "/Adult/Index", # 获取用户信息 "userMsg": "/Home/My" } # 区域名称 AREAS = [ "天河区", "白云区", "黄埔区", "荔湾区", "越秀区", "海珠区", "番禺区", "花都区", "南沙区", "增城区", "从化区" ] # 所有疫苗类型 VACCINE_TYPES = { "veroCell": 5601, # 新冠疫苗（Vero细胞） "adenovirusVector": 5602 # 新冠疫苗（腺病毒载体） # etc... } # 需要预约的疫苗类型 SEC_TYPE = VACCINE_TYPES["veroCell"]

5ebd8f1c512b1380b449a67ec585f3905c6bceac

py

Python

personal_context_builder/gensim_hdp.py

InternetOfUs/personal-context-builder

89e7388d622bc0efbf708542566fdcdca667a4e5

personal_context_builder/gensim_hdp.py

InternetOfUs/personal-context-builder

89e7388d622bc0efbf708542566fdcdca667a4e5

personal_context_builder/gensim_hdp.py

InternetOfUs/personal-context-builder

89e7388d622bc0efbf708542566fdcdca667a4e5

#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2011 Radim Rehurek <radimrehurek@seznam.cz> # Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html """Scikit learn interface for :class:`~gensim.models.hdpmodel.HdpModel`. Follows scikit-learn API conventions to facilitate using gensim along with scikit-learn. Examples -------- .. sourcecode:: pycon >>> from gensim.test.utils import common_dictionary, common_corpus >>> from gensim.sklearn_api import HdpTransformer >>> >>> # Lets extract the distribution of each document in topics >>> model = HdpTransformer(id2word=common_dictionary) >>> distr = model.fit_transform(common_corpus) """ import numpy as np from gensim import matutils # type: ignore from gensim import models # type: ignore from scipy import sparse # type: ignore from sklearn.base import BaseEstimator, TransformerMixin # type: ignore from sklearn.exceptions import NotFittedError # type: ignore class HdpTransformer(TransformerMixin, BaseEstimator): """Base HDP module, wraps :class:`~gensim.models.hdpmodel.HdpModel`. The inner workings of this class heavily depends on `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. """ def __init__( self, id2word, max_chunks=None, max_time=None, chunksize=256, kappa=1.0, tau=64.0, K=15, T=150, alpha=1, gamma=1, eta=0.01, scale=1.0, var_converge=0.0001, outputdir=None, random_state=None, ): """ Parameters ---------- id2word : :class:`~gensim.corpora.dictionary.Dictionary`, optional Mapping between a words ID and the word itself in the vocabulary. max_chunks : int, optional Upper bound on how many chunks to process.It wraps around corpus beginning in another corpus pass, if there are not enough chunks in the corpus. max_time : int, optional Upper bound on time in seconds for which model will be trained. chunksize : int, optional Number of documents to be processed by the model in each mini-batch. kappa : float, optional Learning rate, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. tau : float, optional Slow down parameter, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. K : int, optional Second level truncation level, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. T : int, optional Top level truncation level, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. alpha : int, optional Second level concentration, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. gamma : int, optional First level concentration, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. eta : float, optional The topic Dirichlet, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. scale : float, optional Weights information from the mini-chunk of corpus to calculate rhot. var_converge : float, optional Lower bound on the right side of convergence. Used when updating variational parameters for a single document. outputdir : str, optional Path to a directory where topic and options information will be stored. random_state : int, optional Seed used to create a :class:`~np.random.RandomState`. Useful for obtaining reproducible results. """ self.gensim_model = None self.id2word = id2word self.max_chunks = max_chunks self.max_time = max_time self.chunksize = chunksize self.kappa = kappa self.tau = tau self.K = K self.T = T self.alpha = alpha self.gamma = gamma self.eta = eta self.scale = scale self.var_converge = var_converge self.outputdir = outputdir self.random_state = random_state def fit(self, X, y=None): """Fit the model according to the given training data. Parameters ---------- X : {iterable of list of (int, number), scipy.sparse matrix} A collection of documents in BOW format used for training the model. Returns ------- :class:`~gensim.sklearn_api.hdp.HdpTransformer` The trained model. """ if sparse.issparse(X): corpus = matutils.Sparse2Corpus(sparse=X, documents_columns=False) else: corpus = X self.gensim_model = models.HdpModel( corpus=corpus, id2word=self.id2word, max_chunks=self.max_chunks, max_time=self.max_time, chunksize=self.chunksize, kappa=self.kappa, tau=self.tau, K=self.K, T=self.T, alpha=self.alpha, gamma=self.gamma, eta=self.eta, scale=self.scale, var_converge=self.var_converge, outputdir=self.outputdir, random_state=self.random_state, ) return self def transform(self, docs): """Infer a matrix of topic distribution for the given document bow, where a_ij indicates (topic_i, topic_probability_j). Parameters ---------- docs : {iterable of list of (int, number), list of (int, number)} Document or sequence of documents in BOW format. Returns ------- numpy.ndarray of shape [`len(docs), num_topics`] Topic distribution for `docs`. """ if self.gensim_model is None: raise NotFittedError( "This model has not been fitted yet. Call 'fit' with appropriate arguments before using this method." ) # The input as array of array if isinstance(docs[0], tuple): docs = [docs] distribution, max_num_topics = [], 0 for doc in docs: topicd = self.gensim_model[doc] distribution.append(topicd) max_num_topics = max(max_num_topics, max(topic[0] for topic in topicd) + 1) # returning dense representation for compatibility with sklearn # but we should go back to sparse representation in the future distribution = [matutils.sparse2full(t, max_num_topics) for t in distribution] return np.reshape(np.array(distribution), (len(docs), max_num_topics)) def partial_fit(self, X): """Train model over a potentially incomplete set of documents. Uses the parameters set in the constructor. This method can be used in two ways: * On an unfitted model in which case the model is initialized and trained on `X`. * On an already fitted model in which case the model is **updated** by `X`. Parameters ---------- X : {iterable of list of (int, number), scipy.sparse matrix} A collection of documents in BOW format used for training the model. Returns ------- :class:`~gensim.sklearn_api.hdp.HdpTransformer` The trained model. """ if sparse.issparse(X): X = matutils.Sparse2Corpus(sparse=X, documents_columns=False) if self.gensim_model is None: self.gensim_model = models.HdpModel( id2word=self.id2word, max_chunks=self.max_chunks, max_time=self.max_time, chunksize=self.chunksize, kappa=self.kappa, tau=self.tau, K=self.K, T=self.T, alpha=self.alpha, gamma=self.gamma, eta=self.eta, scale=self.scale, var_converge=self.var_converge, outputdir=self.outputdir, random_state=self.random_state, ) self.gensim_model.update(corpus=X) return self

#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2011 Radim Rehurek <radimrehurek@seznam.cz> # Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html """Scikit learn interface for :class:`~gensim.models.hdpmodel.HdpModel`. Follows scikit-learn API conventions to facilitate using gensim along with scikit-learn. Examples -------- .. sourcecode:: pycon >>> from gensim.test.utils import common_dictionary, common_corpus >>> from gensim.sklearn_api import HdpTransformer >>> >>> # Lets extract the distribution of each document in topics >>> model = HdpTransformer(id2word=common_dictionary) >>> distr = model.fit_transform(common_corpus) """ import numpy as np from gensim import matutils # type: ignore from gensim import models # type: ignore from scipy import sparse # type: ignore from sklearn.base import BaseEstimator, TransformerMixin # type: ignore from sklearn.exceptions import NotFittedError # type: ignore class HdpTransformer(TransformerMixin, BaseEstimator): """Base HDP module, wraps :class:`~gensim.models.hdpmodel.HdpModel`. The inner workings of this class heavily depends on `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. """ def __init__( self, id2word, max_chunks=None, max_time=None, chunksize=256, kappa=1.0, tau=64.0, K=15, T=150, alpha=1, gamma=1, eta=0.01, scale=1.0, var_converge=0.0001, outputdir=None, random_state=None, ): """ Parameters ---------- id2word : :class:`~gensim.corpora.dictionary.Dictionary`, optional Mapping between a words ID and the word itself in the vocabulary. max_chunks : int, optional Upper bound on how many chunks to process.It wraps around corpus beginning in another corpus pass, if there are not enough chunks in the corpus. max_time : int, optional Upper bound on time in seconds for which model will be trained. chunksize : int, optional Number of documents to be processed by the model in each mini-batch. kappa : float, optional Learning rate, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. tau : float, optional Slow down parameter, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. K : int, optional Second level truncation level, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. T : int, optional Top level truncation level, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. alpha : int, optional Second level concentration, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. gamma : int, optional First level concentration, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. eta : float, optional The topic Dirichlet, see `Wang, Paisley, Blei: "Online Variational Inference for the Hierarchical Dirichlet Process, JMLR (2011)" <http://jmlr.csail.mit.edu/proceedings/papers/v15/wang11a/wang11a.pdf>`_. scale : float, optional Weights information from the mini-chunk of corpus to calculate rhot. var_converge : float, optional Lower bound on the right side of convergence. Used when updating variational parameters for a single document. outputdir : str, optional Path to a directory where topic and options information will be stored. random_state : int, optional Seed used to create a :class:`~np.random.RandomState`. Useful for obtaining reproducible results. """ self.gensim_model = None self.id2word = id2word self.max_chunks = max_chunks self.max_time = max_time self.chunksize = chunksize self.kappa = kappa self.tau = tau self.K = K self.T = T self.alpha = alpha self.gamma = gamma self.eta = eta self.scale = scale self.var_converge = var_converge self.outputdir = outputdir self.random_state = random_state def fit(self, X, y=None): """Fit the model according to the given training data. Parameters ---------- X : {iterable of list of (int, number), scipy.sparse matrix} A collection of documents in BOW format used for training the model. Returns ------- :class:`~gensim.sklearn_api.hdp.HdpTransformer` The trained model. """ if sparse.issparse(X): corpus = matutils.Sparse2Corpus(sparse=X, documents_columns=False) else: corpus = X self.gensim_model = models.HdpModel( corpus=corpus, id2word=self.id2word, max_chunks=self.max_chunks, max_time=self.max_time, chunksize=self.chunksize, kappa=self.kappa, tau=self.tau, K=self.K, T=self.T, alpha=self.alpha, gamma=self.gamma, eta=self.eta, scale=self.scale, var_converge=self.var_converge, outputdir=self.outputdir, random_state=self.random_state, ) return self def transform(self, docs): """Infer a matrix of topic distribution for the given document bow, where a_ij indicates (topic_i, topic_probability_j). Parameters ---------- docs : {iterable of list of (int, number), list of (int, number)} Document or sequence of documents in BOW format. Returns ------- numpy.ndarray of shape [`len(docs), num_topics`] Topic distribution for `docs`. """ if self.gensim_model is None: raise NotFittedError( "This model has not been fitted yet. Call 'fit' with appropriate arguments before using this method." ) # The input as array of array if isinstance(docs[0], tuple): docs = [docs] distribution, max_num_topics = [], 0 for doc in docs: topicd = self.gensim_model[doc] distribution.append(topicd) max_num_topics = max(max_num_topics, max(topic[0] for topic in topicd) + 1) # returning dense representation for compatibility with sklearn # but we should go back to sparse representation in the future distribution = [matutils.sparse2full(t, max_num_topics) for t in distribution] return np.reshape(np.array(distribution), (len(docs), max_num_topics)) def partial_fit(self, X): """Train model over a potentially incomplete set of documents. Uses the parameters set in the constructor. This method can be used in two ways: * On an unfitted model in which case the model is initialized and trained on `X`. * On an already fitted model in which case the model is **updated** by `X`. Parameters ---------- X : {iterable of list of (int, number), scipy.sparse matrix} A collection of documents in BOW format used for training the model. Returns ------- :class:`~gensim.sklearn_api.hdp.HdpTransformer` The trained model. """ if sparse.issparse(X): X = matutils.Sparse2Corpus(sparse=X, documents_columns=False) if self.gensim_model is None: self.gensim_model = models.HdpModel( id2word=self.id2word, max_chunks=self.max_chunks, max_time=self.max_time, chunksize=self.chunksize, kappa=self.kappa, tau=self.tau, K=self.K, T=self.T, alpha=self.alpha, gamma=self.gamma, eta=self.eta, scale=self.scale, var_converge=self.var_converge, outputdir=self.outputdir, random_state=self.random_state, ) self.gensim_model.update(corpus=X) return self

b582f1040cc1af3be284ad67fe9c371e838dde5d

py

Python

zaqar-8.0.0/zaqar/common/policies/claims.py

scottwedge/OpenStack-Stein

7077d1f602031dace92916f14e36b124f474de15

2015-01-02T09:35:23.000Z

2022-03-25T00:38:45.000Z

zaqar-8.0.0/zaqar/common/policies/claims.py

scottwedge/OpenStack-Stein

7077d1f602031dace92916f14e36b124f474de15

2019-08-14T06:46:03.000Z

2021-12-13T20:01:25.000Z

zaqar-8.0.0/zaqar/common/policies/claims.py

scottwedge/OpenStack-Stein

7077d1f602031dace92916f14e36b124f474de15

2015-01-28T03:01:28.000Z

2021-05-13T18:55:19.000Z

# 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. from oslo_policy import policy from zaqar.common.policies import base CLAIMS = 'claims:%s' rules = [ policy.DocumentedRuleDefault( name=CLAIMS % 'create', check_str=base.UNPROTECTED, description='Claims a set of messages from the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims', 'method': 'POST' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'get', check_str=base.UNPROTECTED, description='Queries the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'GET' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'delete', check_str=base.UNPROTECTED, description='Releases the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'DELETE' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'update', check_str=base.UNPROTECTED, description='Updates the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'PATCH' } ] ) ]

# 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. from oslo_policy import policy from zaqar.common.policies import base CLAIMS = 'claims:%s' rules = [ policy.DocumentedRuleDefault( name=CLAIMS % 'create', check_str=base.UNPROTECTED, description='Claims a set of messages from the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims', 'method': 'POST' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'get', check_str=base.UNPROTECTED, description='Queries the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'GET' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'delete', check_str=base.UNPROTECTED, description='Releases the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'DELETE' } ] ), policy.DocumentedRuleDefault( name=CLAIMS % 'update', check_str=base.UNPROTECTED, description='Updates the specified claim for the specified queue.', operations=[ { 'path': '/v2/queues/{queue_name}/claims/{claim_id}', 'method': 'PATCH' } ] ) ] def list_rules(): return rules

48f845ebbaca4afd27efda9fdf590cf268429691

py

Python

bot.py

boyuan12/MLH-Helper

efa98907b89bae2ef1f1c8b551075356b61ad741

bot.py

boyuan12/MLH-Helper

efa98907b89bae2ef1f1c8b551075356b61ad741

bot.py

boyuan12/MLH-Helper

efa98907b89bae2ef1f1c8b551075356b61ad741

import discord import discord.utils from discord.ext import commands import requests import random client = discord.Client() SECRET_KEY="secretkey" BASE_URL="http://0.0.0.0:1234" @client.event @client.event client.run("")

import discord import discord.utils from discord.ext import commands import requests import random client = discord.Client() SECRET_KEY="secretkey" BASE_URL="http://0.0.0.0:1234" @client.event async def on_ready(): print('We have logged in as {0.user}'.format(client)) @client.event async def on_message(message): id = client.user.id if str(id) in message.content: # get the question resp = str(message.content).split(f"<@!{str(id)}> ")[1] if resp == "checkin": await message.channel.send(f"Welcome! Please go ahead and go to {BASE_URL}/{message.author.id}. When you finished, please tag me and say finished, and I will send you more information!") elif resp == "attendees" and "mlh" in [y.name.lower() for y in message.author.roles]: curr = requests.get("https://mlh-events.now.sh/na-2020").json()[0]["name"] csv_file = requests.get(f"{BASE_URL}/api/generate/{curr}/{SECRET_KEY}").json()["url"] channel = await message.author.create_dm() await channel.send(f"Here's the file link to download: {csv_file}") elif resp == "attendees" and "mlh" not in [y.name.lower() for y in message.author.roles]: await message.channel.send(f"Oops, looks like you don't have permission to use this command!") elif resp == "finished": resp = requests.get(f"{BASE_URL}/api/current_hack/{message.author.id}").json() if resp["hack"] in [hack.name for hack in message.guild.roles] and resp["hack"] not in [y.name.lower() for y in message.author.roles]: role = discord.utils.get(message.guild.roles, name=resp["hack"]) user = message.author await user.add_roles(role) else: guild = message.guild await guild.create_role(name=resp["hack"], colour=discord.Colour(0x00FF00)) role = discord.utils.get(message.guild.roles, name=resp["hack"]) user = message.author await user.add_roles(role) await message.channel.send(resp["resp"]) client.run("")

f968e78a0a396c803ccb0a25d591d668dacf68bf

py

Python

django_pathfinder_statcrunch/urls.py

porowns/django-pathfinder-statcrunch

4a31dd014b6e1c27b3e70ae88ca5762841ce72db

django_pathfinder_statcrunch/urls.py

porowns/django-pathfinder-statcrunch

4a31dd014b6e1c27b3e70ae88ca5762841ce72db

django_pathfinder_statcrunch/urls.py

porowns/django-pathfinder-statcrunch

4a31dd014b6e1c27b3e70ae88ca5762841ce72db

from django.contrib.staticfiles.urls import staticfiles_urlpatterns from django.conf import settings from django.contrib import admin from django.urls import path, re_path from . import views # SSO urlpatterns = [ path('reports/', views.list_reports, name="django-pathfinder-statcrunch-list-reports"), path('reports/<int:pk>/', views.view_report, name="django-pathfinder-statcrunch-view-report"), path('reports/<int:pk>/refresh/', views.refresh_report, name="django-pathfinder-statcrunch-view-report-refresh"), ]

from django.contrib.staticfiles.urls import staticfiles_urlpatterns from django.conf import settings from django.contrib import admin from django.urls import path, re_path from . import views # SSO urlpatterns = [ path('reports/', views.list_reports, name="django-pathfinder-statcrunch-list-reports"), path('reports/<int:pk>/', views.view_report, name="django-pathfinder-statcrunch-view-report"), path('reports/<int:pk>/refresh/', views.refresh_report, name="django-pathfinder-statcrunch-view-report-refresh"), ]

0ed78fe0d10f673e40978db5dbae120f7d215015

py

Python

adventofcode/2021/1/2.py

jan25/code_sorted

f405fd0898f72eb3d5428f9e10aefb4a009d5089

2018-01-18T11:01:36.000Z

2021-12-20T18:14:48.000Z

adventofcode/2021/1/2.py

jan25/code_sorted

f405fd0898f72eb3d5428f9e10aefb4a009d5089

adventofcode/2021/1/2.py

jan25/code_sorted

f405fd0898f72eb3d5428f9e10aefb4a009d5089

import fileinput nums = list(map(int, fileinput.input())) print(sum(inc for inc in gen()))

import fileinput nums = list(map(int, fileinput.input())) def gen(): for i in range(1, len(nums) - 2): if sum(nums[i:i + 3]) > sum(nums[i - 1: i + 2]): yield 1 print(sum(inc for inc in gen()))

2f907545d59c9d2bffc0a13955bd9ba29dc05554

py

Python

openapi-server/python-flask/openapi_server/controllers/health_check_service_controller.py

michilu/proto-api

aca02aaa11064e87462ab34674c0c4974cf70372

openapi-server/python-flask/openapi_server/controllers/health_check_service_controller.py

michilu/proto-api

aca02aaa11064e87462ab34674c0c4974cf70372

2020-07-15T09:50:06.000Z

2020-07-15T09:50:06.000Z

openapi-server/python-flask/openapi_server/controllers/health_check_service_controller.py

michilu/proto-openapi

aca02aaa11064e87462ab34674c0c4974cf70372

import connexion import six from openapi_server.models.runtime_error import RuntimeError # noqa: E501 from openapi_server.models.v1_health_check_service_health_check_response import V1HealthCheckServiceHealthCheckResponse # noqa: E501 from openapi_server import util def health_check_service_health_check(): # noqa: E501 """health_check_service_health_check # noqa: E501 :rtype: V1HealthCheckServiceHealthCheckResponse """ return 'do some magic!'

import connexion import six from openapi_server.models.runtime_error import RuntimeError # noqa: E501 from openapi_server.models.v1_health_check_service_health_check_response import V1HealthCheckServiceHealthCheckResponse # noqa: E501 from openapi_server import util def health_check_service_health_check(): # noqa: E501 """health_check_service_health_check # noqa: E501 :rtype: V1HealthCheckServiceHealthCheckResponse """ return 'do some magic!'

4cb74abbf6f8f44cb294e4d005f81aad23521f19

py

Python

gfat/models/one_eight_two/model.py

paurosello/gfat

23bcb7bf328be8bd0c1aa99ff869d8e539563eba

gfat/models/one_eight_two/model.py

paurosello/gfat

23bcb7bf328be8bd0c1aa99ff869d8e539563eba

2021-03-25T21:40:00.000Z

2021-11-15T17:46:49.000Z

gfat/models/one_eight_two/model.py

paurosello/gfat

23bcb7bf328be8bd0c1aa99ff869d8e539563eba

class Model182: """Class to create Model 182 files""" declarant = None declared_registers = {}

class Model182: """Class to create Model 182 files""" declarant = None declared_registers = {} def __init__(self): return

887fea9a7f42da7c5675403aa05cab40094c6fb6

py

Python

src/model/synapses/tensor_backend/VoltageJump.py

Fassial/pku-intern

4463e7d5a5844c8002f7e3d01b4fadc3a20e2038

src/model/synapses/tensor_backend/VoltageJump.py

Fassial/pku-intern

4463e7d5a5844c8002f7e3d01b4fadc3a20e2038

src/model/synapses/tensor_backend/VoltageJump.py

Fassial/pku-intern

4463e7d5a5844c8002f7e3d01b4fadc3a20e2038

""" Created on 12:39, June. 4th, 2021 Author: fassial Filename: VoltageJump.py """ import brainpy as bp __all__ = [ "VoltageJump", ]

""" Created on 12:39, June. 4th, 2021 Author: fassial Filename: VoltageJump.py """ import brainpy as bp __all__ = [ "VoltageJump", ] class VoltageJump(bp.TwoEndConn): target_backend = "general" def __init__(self, pre, post, conn, weight = 1., delay = 0., **kwargs ): # init params self.weight = weight self.delay = delay # init connections self.conn = conn(pre.size, post.size) self.conn_mat = self.conn.requires("conn_mat") self.size = bp.ops.shape(self.conn_mat) # init vars self.w = bp.ops.ones(self.size) * self.weight self.Isyn = self.register_constant_delay("Isyn", size = self.size, delay_time = self.delay ) # init super super(VoltageJump, self).__init__(pre = pre, post = post, **kwargs) def update(self, _t): # set Isyn & post.V Isyn = self.w * bp.ops.unsqueeze(self.pre.spike, 1) * self.conn_mat self.post.V += bp.ops.sum(Isyn * (1. - self.post.refractory), axis = 0)

2356a07736148deea7e9a4b60909d1ff37a28c82

py

Python

clahe_and_augmentation/parseConfig.py

RandomeName745/DD2424---Project-Covid-19

2e1e647e841eeb00760daecb58effeba3ca237c4

clahe_and_augmentation/parseConfig.py

RandomeName745/DD2424---Project-Covid-19

2e1e647e841eeb00760daecb58effeba3ca237c4

clahe_and_augmentation/parseConfig.py

RandomeName745/DD2424---Project-Covid-19

2e1e647e841eeb00760daecb58effeba3ca237c4

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun May 10 10:31:44 2020 @author: alex """ import argparse from clodsa.utils.conf import Conf

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sun May 10 10:31:44 2020 @author: alex """ import argparse from clodsa.utils.conf import Conf def parseConfig(configfile): ap = argparse.ArgumentParser() ap.add_argument("-c", "--conf", required=True, help="path to configuration file") args = vars(ap.parse_args(args=["-c",configfile])) config = {} conf = Conf(args["conf"]) config["problem"] = conf["problem"] config["annotationMode"] = conf["annotation_mode"] config["outputMode"] = conf["output_mode"] config["generationMode"] = conf["generation_mode"] config["inputPath"] = conf["input_path"] # parameters = conf["parameters"] config["outputPath"] = conf["output_path"] config["augmentationTechniques"] = conf["augmentation_techniques"] return config

d6844ad5af8ac8dd3731b4be397175e5d6c05d9f

py

Python

clientui/vstrm_server.py

cbk914/BlackMamba

826d5e2994368006cad09acaaa7c6bfa047891b5

2021-02-09T09:42:57.000Z

2022-03-26T09:28:03.000Z

clientui/vstrm_server.py

cbk914/BlackMamba

826d5e2994368006cad09acaaa7c6bfa047891b5

2021-02-12T16:46:51.000Z

2021-12-20T21:12:14.000Z

clientui/vstrm_server.py

cbk914/BlackMamba

826d5e2994368006cad09acaaa7c6bfa047891b5

2021-02-09T12:16:50.000Z

2022-02-25T04:19:18.000Z

#################################################################################### # BLACKMAMBA BY: LOSEYS (https://github.com/loseys) # # QT GUI INTERFACE BY: WANDERSON M.PIMENTA (https://github.com/Wanderson-Magalhaes) # ORIGINAL QT GUI: https://github.com/Wanderson-Magalhaes/Simple_PySide_Base #################################################################################### """ Video streaming server. """ import sys import socket from os import environ environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1' import pygame from zlib import decompress from cryptography.fernet import Fernet try: SERVER_IP = sys.argv[1] PORT_VIDEO = sys.argv[2] except: SERVER_IP = 0 PORT_VIDEO = 0 if __name__ == "__main__": start_stream()

#################################################################################### # BLACKMAMBA BY: LOSEYS (https://github.com/loseys) # # QT GUI INTERFACE BY: WANDERSON M.PIMENTA (https://github.com/Wanderson-Magalhaes) # ORIGINAL QT GUI: https://github.com/Wanderson-Magalhaes/Simple_PySide_Base #################################################################################### """ Video streaming server. """ import sys import socket from os import environ environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1' import pygame from zlib import decompress from cryptography.fernet import Fernet try: SERVER_IP = sys.argv[1] PORT_VIDEO = sys.argv[2] except: SERVER_IP = 0 PORT_VIDEO = 0 def crypt(msg, key): command = str(msg) command = bytes(command, encoding='utf8') cipher_suite = Fernet(key) encoded_text = cipher_suite.encrypt(command) return encoded_text def decrypt(msg, key): cipher_suite = Fernet(key) decoded_text_f = cipher_suite.decrypt(msg) return decoded_text_f def recvall(conn, length): try: buf = b'' while len(buf) < length: data = conn.recv(length - len(buf)) if not data: return data buf += data return buf except: pass def start_stream(host=str(SERVER_IP), port=int(PORT_VIDEO)): sock = socket.socket() sock.bind((host, port)) print("Listening ....") sock.settimeout(15.0) sock.listen(5) try: conn, addr = sock.accept() except: print('socket.timeout: timed out') return print("Accepted ....", addr) client_resolution = (conn.recv(50).decode()) client_resolution = str(client_resolution).split(',') CLIENT_WIDTH = int(client_resolution[0]) CLIENT_HEIGHT = int(client_resolution[1]) with open('bin/profile/vstream_size.txt', 'r') as f: scsize = f.read() f.close() try: scsize = scsize.split(':') SERVER_WIDTH = int(scsize[0]) SERVER_HEIGHT = int( scsize[1]) except: SERVER_WIDTH = 1000 SERVER_HEIGHT = 600 pygame.init() pygame.display.set_caption('BlackMamba') programIcon = pygame.image.load('icons/others/icon_3.png') pygame.display.set_icon(programIcon) screen = pygame.display.set_mode((SERVER_WIDTH, SERVER_HEIGHT)) clock = pygame.time.Clock() watching = True try: while watching: for event in pygame.event.get(): if event.type == pygame.QUIT: watching = False break # Retreive the size of the pixels length, the pixels length and pixels try: size_len = int.from_bytes(conn.recv(1), byteorder='big') size = int.from_bytes(conn.recv(size_len), byteorder='big') pixels = decompress(recvall(conn, size)) # Create the Surface from raw pixels img = pygame.image.fromstring(pixels, (CLIENT_WIDTH, CLIENT_HEIGHT), 'RGB') # resize the client image to match the server's screen dimensions scaled_img = pygame.transform.scale(img, (SERVER_WIDTH, SERVER_HEIGHT)) # Display the picture screen.blit(scaled_img, (0, 0)) pygame.display.flip() #clock.tick(60) clock.tick(120) except: break finally: pygame.quit() sock.close() if __name__ == "__main__": start_stream()

9b17df01413810c9aafe1a9d4b06d58e9e2eff88

py

Python

src/api/domain/schedule/ScheduleCronJob/ScheduleCronJobRequest.py

PythonDataIntegrator/pythondataintegrator

6167778c36c2295e36199ac0d4d256a4a0c28d7a

2020-12-19T15:06:13.000Z

2022-01-12T19:52:17.000Z

src/api/domain/schedule/ScheduleCronJob/ScheduleCronJobRequest.py

PythonDataIntegrator/pythondataintegrator

6167778c36c2295e36199ac0d4d256a4a0c28d7a

2021-01-06T22:05:22.000Z

2022-03-10T10:30:30.000Z

src/api/domain/schedule/ScheduleCronJob/ScheduleCronJobRequest.py

PythonDataIntegrator/pythondataintegrator

6167778c36c2295e36199ac0d4d256a4a0c28d7a

2020-12-18T23:10:09.000Z

2021-04-02T13:03:12.000Z

from datetime import datetime from infrastructure.cqrs.decorators.requestclass import requestclass @requestclass

from datetime import datetime from infrastructure.cqrs.decorators.requestclass import requestclass @requestclass class ScheduleCronJobRequest: OperationName: str = None Cron: str = None StartDate: datetime = None EndDate: datetime = None

58f8d59cc2c4eb8e7df9a61a133e9fc628033ad5

py

Python

Unit3SC_0205/northwind.py

TemsyChen/DS-Unit-3-Sprint-2-SQL-and-Databases

cba1e0f5476f5e7a13e10ad450474a565d302b33

Unit3SC_0205/northwind.py

TemsyChen/DS-Unit-3-Sprint-2-SQL-and-Databases

cba1e0f5476f5e7a13e10ad450474a565d302b33

Unit3SC_0205/northwind.py

TemsyChen/DS-Unit-3-Sprint-2-SQL-and-Databases

cba1e0f5476f5e7a13e10ad450474a565d302b33

import sqlite3 # Connect to the sqlite3 file connection = sqlite3.connect("northwind_small.sqlite3") cursor = connection.cursor() # Queries # `expensive_items`: What are the ten most expensive items (per unit price) in the database? price_query = f""" SELECT UnitPrice, ProductName FROM product ORDER BY UnitPrice DESC LIMIT 10;""" expensive_items = cursor.execute(price_query).fetchall() print("Expensive items:", expensive_items) # Expensive items: [(263.5, 'Côte de Blaye'), (123.79, 'Thüringer Rostbratwurst'), # (97, 'Mishi Kobe Niku'), (81, "Sir Rodney's Marmalade"), (62.5, 'Carnarvon Tigers'), # (55, 'Raclette Courdavault'), (53, 'Manjimup Dried Apples'), (49.3, 'Tarte au sucre'), # (46, 'Ipoh Coffee'), (45.6, 'Rössle Sauerkraut')] # `avg_hire_age`: What is the average age of an employee at the time of their hiring? # ONLY RAN THIS THE FIRST TIME, then commented it out # add_age_column = f""" # ALTER TABLE Employee # ADD age INT AS (hiredate - birthdate) # """ # cursor.execute(add_age_column) avghire_query = f"""SELECT AVG(age) from employee""" avg_hire_age = cursor.execute(avghire_query).fetchone()[0] print("Average hire age:", avg_hire_age) # Average hire age: 37.22222222222222 # (*Stretch*) `avg_age_by_city`: How does the average age of employee at hire vary by city? avg_by_city_query = f"""SELECT AVG(age), city FROM employee GROUP BY city """ avg_age_by_city = cursor.execute(avg_by_city_query).fetchall() print("Average age by city:", avg_age_by_city) # Average age by city: [(29.0, 'Kirkland'), (32.5, 'London'), # (56.0, 'Redmond'), (40.0, 'Seattle'), (40.0, 'Tacoma')] # - `ten_most_expensive`: What are the ten most expensive items (per unit price) in the database # *and* their suppliers? # COMMENTING OUT AFTER RUNNING ONCE # suppliers_prices_table = f"""CREATE TABLE suppliers_prices AS # SELECT Product.ProductName, Product.UnitPrice, Supplier.CompanyName # FROM Product # LEFT JOIN Supplier ON Product.SupplierId = Supplier.Id # """ # cursor.execute(suppliers_prices_table) # insertion_query = f"""SELECT Product.ProductName, Product.UnitPrice, Supplier.CompanyName # FROM Product # LEFT JOIN Supplier ON Product.SupplierId = Supplier.Id""" # cursor.execute(insertion_query) price_supplier_query = f"""SELECT unitprice, companyname FROM suppliers_prices ORDER BY unitprice DESC LIMIT 10; """ price_supplier_topten = cursor.execute(price_supplier_query).fetchall() print("Top most expensive items and their suppliers:", price_supplier_topten) # Top most expensive items and their suppliers: [(263.5, 'Aux # joyeux ecclésiastiques'), (123.79, 'Plutzer Lebensmittelgroßmärkte AG'), # (97, 'Tokyo Traders'), (81, 'Specialty Biscuits, Ltd.'), # (62.5, 'Pavlova, Ltd.'), (55, 'Gai pâturage'), (53, "G'day, Mate"), # (49.3, "Forêts d'érables"), (46, 'Leka Trading'), (45.6, 'Plutzer Lebensmittelgroßmärkte AG')] # - `largest_category`: What is the largest category (by number of unique products in it)? largest_category_query = f"""SELECT CategoryId, COUNT(DISTINCT ProductName) FROM Product GROUP BY CategoryId ORDER BY COUNT(DISTINCT ProductName) DESC""" largest_category = cursor.execute(largest_category_query).fetchone()[0] print("Largest category:", largest_category) # Largest category: 3 # - (*Stretch*) `most_territories`: Who's the employee with the most territories? # Use `TerritoryId` (not name, region, or other fields) as the unique # identifier for territories. # COMMENT OUT AFTER RUNNING ONCE # employee_territory_table = f"""CREATE TABLE employee_territory AS # SELECT Employee.FirstName, Employee.LastName, # EmployeeTerritory.EmployeeId, EmployeeTerritory.TerritoryId # FROM Employee # JOIN EmployeeTerritory ON Employee.Id = EmployeeTerritory.EmployeeId;""" # cursor.execute(employee_territory_table) territory_query = f"""SELECT COUNT(DISTINCT TerritoryId), FirstName, LastName, EmployeeId from employee_territory GROUP BY EmployeeId ORDER BY COUNT(DISTINCT TerritoryId) DESC""" employee_territory = cursor.execute(territory_query).fetchone() print("Which employee has the most territory?", employee_territory) # Which employee has the most territory? (10, 'Robert', 'King', 7) connection.commit() connection.close()

import sqlite3 # Connect to the sqlite3 file connection = sqlite3.connect("northwind_small.sqlite3") cursor = connection.cursor() # Queries # `expensive_items`: What are the ten most expensive items (per unit price) in the database? price_query = f""" SELECT UnitPrice, ProductName FROM product ORDER BY UnitPrice DESC LIMIT 10;""" expensive_items = cursor.execute(price_query).fetchall() print("Expensive items:", expensive_items) # Expensive items: [(263.5, 'Côte de Blaye'), (123.79, 'Thüringer Rostbratwurst'), # (97, 'Mishi Kobe Niku'), (81, "Sir Rodney's Marmalade"), (62.5, 'Carnarvon Tigers'), # (55, 'Raclette Courdavault'), (53, 'Manjimup Dried Apples'), (49.3, 'Tarte au sucre'), # (46, 'Ipoh Coffee'), (45.6, 'Rössle Sauerkraut')] # `avg_hire_age`: What is the average age of an employee at the time of their hiring? # ONLY RAN THIS THE FIRST TIME, then commented it out # add_age_column = f""" # ALTER TABLE Employee # ADD age INT AS (hiredate - birthdate) # """ # cursor.execute(add_age_column) avghire_query = f"""SELECT AVG(age) from employee""" avg_hire_age = cursor.execute(avghire_query).fetchone()[0] print("Average hire age:", avg_hire_age) # Average hire age: 37.22222222222222 # (*Stretch*) `avg_age_by_city`: How does the average age of employee at hire vary by city? avg_by_city_query = f"""SELECT AVG(age), city FROM employee GROUP BY city """ avg_age_by_city = cursor.execute(avg_by_city_query).fetchall() print("Average age by city:", avg_age_by_city) # Average age by city: [(29.0, 'Kirkland'), (32.5, 'London'), # (56.0, 'Redmond'), (40.0, 'Seattle'), (40.0, 'Tacoma')] # - `ten_most_expensive`: What are the ten most expensive items (per unit price) in the database # *and* their suppliers? # COMMENTING OUT AFTER RUNNING ONCE # suppliers_prices_table = f"""CREATE TABLE suppliers_prices AS # SELECT Product.ProductName, Product.UnitPrice, Supplier.CompanyName # FROM Product # LEFT JOIN Supplier ON Product.SupplierId = Supplier.Id # """ # cursor.execute(suppliers_prices_table) # insertion_query = f"""SELECT Product.ProductName, Product.UnitPrice, Supplier.CompanyName # FROM Product # LEFT JOIN Supplier ON Product.SupplierId = Supplier.Id""" # cursor.execute(insertion_query) price_supplier_query = f"""SELECT unitprice, companyname FROM suppliers_prices ORDER BY unitprice DESC LIMIT 10; """ price_supplier_topten = cursor.execute(price_supplier_query).fetchall() print("Top most expensive items and their suppliers:", price_supplier_topten) # Top most expensive items and their suppliers: [(263.5, 'Aux # joyeux ecclésiastiques'), (123.79, 'Plutzer Lebensmittelgroßmärkte AG'), # (97, 'Tokyo Traders'), (81, 'Specialty Biscuits, Ltd.'), # (62.5, 'Pavlova, Ltd.'), (55, 'Gai pâturage'), (53, "G'day, Mate"), # (49.3, "Forêts d'érables"), (46, 'Leka Trading'), (45.6, 'Plutzer Lebensmittelgroßmärkte AG')] # - `largest_category`: What is the largest category (by number of unique products in it)? largest_category_query = f"""SELECT CategoryId, COUNT(DISTINCT ProductName) FROM Product GROUP BY CategoryId ORDER BY COUNT(DISTINCT ProductName) DESC""" largest_category = cursor.execute(largest_category_query).fetchone()[0] print("Largest category:", largest_category) # Largest category: 3 # - (*Stretch*) `most_territories`: Who's the employee with the most territories? # Use `TerritoryId` (not name, region, or other fields) as the unique # identifier for territories. # COMMENT OUT AFTER RUNNING ONCE # employee_territory_table = f"""CREATE TABLE employee_territory AS # SELECT Employee.FirstName, Employee.LastName, # EmployeeTerritory.EmployeeId, EmployeeTerritory.TerritoryId # FROM Employee # JOIN EmployeeTerritory ON Employee.Id = EmployeeTerritory.EmployeeId;""" # cursor.execute(employee_territory_table) territory_query = f"""SELECT COUNT(DISTINCT TerritoryId), FirstName, LastName, EmployeeId from employee_territory GROUP BY EmployeeId ORDER BY COUNT(DISTINCT TerritoryId) DESC""" employee_territory = cursor.execute(territory_query).fetchone() print("Which employee has the most territory?", employee_territory) # Which employee has the most territory? (10, 'Robert', 'King', 7) connection.commit() connection.close()

1c787236266f19826db1b1ea01fce5c806ce4267

py

Python

lib/model/complete_net.py

chensjtu/poxture

f6abea1216c987f0e4c628b250054d764eaecf2e

lib/model/complete_net.py

chensjtu/poxture

f6abea1216c987f0e4c628b250054d764eaecf2e

lib/model/complete_net.py

chensjtu/poxture

f6abea1216c987f0e4c628b250054d764eaecf2e

import torch import torch.nn as nn import torch.nn.functional as F import functools from .SurfaceClassifier import conv1_1, period_loss # from .DepthNormalizer import DepthNormalizer from ..net_util import * # from iPERCore.models.networks.criterions import VGGLoss from lib.model.Models import NestedUNet import numpy as np class ResnetBlock(nn.Module): """Define a Resnet block""" def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias, last=False): """Initialize the Resnet block A resnet block is a conv block with skip connections We construct a conv block with build_conv_block function, and implement skip connections in <forward> function. Original Resnet paper: https://arxiv.org/pdf/1512.03385.pdf """ super(ResnetBlock, self).__init__() self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias, last) def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias, last=False): """Construct a convolutional block. Parameters: dim (int) -- the number of channels in the conv layer. padding_type (str) -- the name of padding layer: reflect | replicate | zero norm_layer -- normalization layer use_dropout (bool) -- if use dropout layers. use_bias (bool) -- if the conv layer uses bias or not Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU)) """ conv_block = [] p = 0 if padding_type == 'reflect': conv_block += [nn.ReflectionPad2d(1)] elif padding_type == 'replicate': conv_block += [nn.ReplicationPad2d(1)] elif padding_type == 'zero': p = 1 else: raise NotImplementedError('padding [%s] is not implemented' % padding_type) conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim), nn.ReLU(True)] if use_dropout: conv_block += [nn.Dropout(0.5)] p = 0 if padding_type == 'reflect': conv_block += [nn.ReflectionPad2d(1)] elif padding_type == 'replicate': conv_block += [nn.ReplicationPad2d(1)] elif padding_type == 'zero': p = 1 else: raise NotImplementedError('padding [%s] is not implemented' % padding_type) if last: conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias)] else: conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim)] return nn.Sequential(*conv_block) def forward(self, x): """Forward function (with skip connections)""" out = x + self.conv_block(x) # add skip connections return out class ResnetFilter(nn.Module): """Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations. We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style) """ def __init__(self, opt, input_nc=3, output_nc=256, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'): """Construct a Resnet-based generator Parameters: input_nc (int) -- the number of channels in input images output_nc (int) -- the number of channels in output images ngf (int) -- the number of filters in the last conv layer norm_layer -- normalization layer use_dropout (bool) -- if use dropout layers n_blocks (int) -- the number of ResNet blocks padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero """ assert (n_blocks >= 0) super(ResnetFilter, self).__init__() if type(norm_layer) == functools.partial: use_bias = norm_layer.func == nn.InstanceNorm2d else: use_bias = norm_layer == nn.InstanceNorm2d model = [nn.ReflectionPad2d(3), nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias), norm_layer(ngf), nn.ReLU(True)] n_downsampling = 2 for i in range(n_downsampling): # add downsampling layers mult = 2 ** i model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias), norm_layer(ngf * mult * 2), nn.ReLU(True)] mult = 2 ** n_downsampling for i in range(n_blocks): # add ResNet blocks if i == n_blocks - 1: model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias, last=True)] else: model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)] if opt.use_tanh: model += [nn.Tanh()] self.model = nn.Sequential(*model) def forward(self, input): """Standard forward""" return self.model(input)

import torch import torch.nn as nn import torch.nn.functional as F import functools from .SurfaceClassifier import conv1_1, period_loss # from .DepthNormalizer import DepthNormalizer from ..net_util import * # from iPERCore.models.networks.criterions import VGGLoss from lib.model.Models import NestedUNet import numpy as np class Pint_Model(nn.Module): def __init__(self, opt): super(Pint_Model, self).__init__() self.period_loss = period_loss() self.feat_uv_error = nn.SmoothL1Loss() # A feature with B uvmap self.opt = opt self.NUnet = NestedUNet(in_ch=3, out_ch=3) norm_type = get_norm_layer(norm_type=opt.norm_color) self.image_filter = ResnetFilter(opt, norm_layer=norm_type) # self.conv = conv1_1(input_layers=256, output_layers=16) init_net(self) def filter(self, images): ''' Filter the input images store all intermediate features. :param images: [B, C, H, W] input images ''' self.im_feat = self.image_filter(images) def forward(self, uv_A, uv_B, part_uv_B, index): ''' this function is made for pint total train. ''' complete_feat = self.NUnet(uv_A) complete_feat_B = self.NUnet(uv_B) # im_feat = self.image_filter(uv_A) # B C H W for 512 uv_B, B 256 128 128 # complete_feat = self.conv(im_feat) # B 16 128 128 -> b 16 512 512 [0:3] loss # im_feat_B = self.image_filter(uv_B) # complete_feat_B = self.conv(im_feat_B) # A_feat = F.interpolate(complete_feat[:,0:3,:,:], scale_factor=4, mode='bilinear', align_corners=True) # in this param, A_feat means complete feature. # part_uv_B.requires_grad=True # to make uvb as one leaf # A_feat = complete_feat[:,0:3,:,:] # part_uv_B = F.interpolate(part_uv_B, scale_factor=0.25, mode='bilinear', align_corners=True) A_vis_feat = complete_feat[index==1] B_vis_uv = part_uv_B[index==1] loss1 = self.feat_uv_error(A_vis_feat, B_vis_uv.detach()) # loss2 = self.vgg_loss(complete_feat[:,:3], complete_feat_B[:,:3].detach()) # loss2 = self.period_loss(complete_feat, complete_feat_B.detach()) loss2=0 return complete_feat, complete_feat_B, loss1, loss2 # def pint_forward(self, uv_A, uv_B): # ''' # this function is made for pint total train. # ''' # im_feat = self.image_filter(uv_A) # B C H W for 512 uv_B, B 256 128 128 # self.complete_feat = self.conv(im_feat) # B 16 128 128 -> b 16 512 512 [0:3] loss # im_feat_B = self.image_filter(uv_B.squeeze(1)) # complete_feat_B = self.conv(im_feat_B) # A_feat = F.interpolate(self.complete_feat[:,0:3,:,:], scale_factor=4, mode='bilinear', align_corners=True) # in this param, A_feat means complete feature. # uv_B_feat = uv_B.squeeze(1).expand_as(A_feat) # uv_B_feat.requires_grad=True # to make uvb as one leaf # A_vis_feat = A_feat[uv_B_feat != 0.0] # B_vis_uv = uv_B_feat[uv_B_feat != 0.0] # loss_content = self.feat_uv_error(A_vis_feat, B_vis_uv) * 100 # loss_content1 = self.feat_uv_error(A_feat, uv_A)*100 # # loss_feat = self.error_term(self.complete_feat, complete_feat_B) # return A_feat, A_vis_feat, B_vis_uv, self.complete_feat, complete_feat_B, loss_content+loss_content1 class ResnetBlock(nn.Module): """Define a Resnet block""" def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias, last=False): """Initialize the Resnet block A resnet block is a conv block with skip connections We construct a conv block with build_conv_block function, and implement skip connections in <forward> function. Original Resnet paper: https://arxiv.org/pdf/1512.03385.pdf """ super(ResnetBlock, self).__init__() self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias, last) def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias, last=False): """Construct a convolutional block. Parameters: dim (int) -- the number of channels in the conv layer. padding_type (str) -- the name of padding layer: reflect | replicate | zero norm_layer -- normalization layer use_dropout (bool) -- if use dropout layers. use_bias (bool) -- if the conv layer uses bias or not Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU)) """ conv_block = [] p = 0 if padding_type == 'reflect': conv_block += [nn.ReflectionPad2d(1)] elif padding_type == 'replicate': conv_block += [nn.ReplicationPad2d(1)] elif padding_type == 'zero': p = 1 else: raise NotImplementedError('padding [%s] is not implemented' % padding_type) conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim), nn.ReLU(True)] if use_dropout: conv_block += [nn.Dropout(0.5)] p = 0 if padding_type == 'reflect': conv_block += [nn.ReflectionPad2d(1)] elif padding_type == 'replicate': conv_block += [nn.ReplicationPad2d(1)] elif padding_type == 'zero': p = 1 else: raise NotImplementedError('padding [%s] is not implemented' % padding_type) if last: conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias)] else: conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), norm_layer(dim)] return nn.Sequential(*conv_block) def forward(self, x): """Forward function (with skip connections)""" out = x + self.conv_block(x) # add skip connections return out class ResnetFilter(nn.Module): """Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations. We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style) """ def __init__(self, opt, input_nc=3, output_nc=256, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'): """Construct a Resnet-based generator Parameters: input_nc (int) -- the number of channels in input images output_nc (int) -- the number of channels in output images ngf (int) -- the number of filters in the last conv layer norm_layer -- normalization layer use_dropout (bool) -- if use dropout layers n_blocks (int) -- the number of ResNet blocks padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero """ assert (n_blocks >= 0) super(ResnetFilter, self).__init__() if type(norm_layer) == functools.partial: use_bias = norm_layer.func == nn.InstanceNorm2d else: use_bias = norm_layer == nn.InstanceNorm2d model = [nn.ReflectionPad2d(3), nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias), norm_layer(ngf), nn.ReLU(True)] n_downsampling = 2 for i in range(n_downsampling): # add downsampling layers mult = 2 ** i model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias), norm_layer(ngf * mult * 2), nn.ReLU(True)] mult = 2 ** n_downsampling for i in range(n_blocks): # add ResNet blocks if i == n_blocks - 1: model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias, last=True)] else: model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)] if opt.use_tanh: model += [nn.Tanh()] self.model = nn.Sequential(*model) def forward(self, input): """Standard forward""" return self.model(input)

91b66cd5922aac62b6769b7d844bbbf6732242a0

py

Python

ActiveCell_RealMorphology_Burst_Inh_cluster.py

EilamLeleo/burst

538dbf6845f4de5519c0392368d611d1e54608e1

ActiveCell_RealMorphology_Burst_Inh_cluster.py

EilamLeleo/burst

538dbf6845f4de5519c0392368d611d1e54608e1

ActiveCell_RealMorphology_Burst_Inh_cluster.py

EilamLeleo/burst

538dbf6845f4de5519c0392368d611d1e54608e1

#!/usr/lib/python-exec/python2.7/python import os import sys os.chdir('C:/Users/Leleo/Documents/Active Cell Real Morphology/') from neuron import h from neuron import gui #%% import numpy as np import time import math import cPickle as pickle #%% sk = False if sk==True: from sklearn import decomposition from sklearn import cluster from sklearn import linear_model from sklearn import ensemble from sklearn import cross_validation #%% h.load_file('nrngui.hoc') h.load_file("import3d.hoc") cvode = h.CVode() cvode.active(0) morphologyFilename = "morphologies/cell1.asc" #morphologyFilename = "morphologies/cell2.asc" #morphologyFilename = "morphologies/cell3.asc" #biophysicalModelFilename = "L5PCbiophys1.hoc" #biophysicalModelFilename = "L5PCbiophys2.hoc" #biophysicalModelFilename = "L5PCbiophys3.hoc" #biophysicalModelFilename = "L5PCbiophys4.hoc" #biophysicalModelFilename = "L5PCbiophys5.hoc" biophysicalModelFilename = "L5PCbiophys5b.hoc" #biophysicalModelTemplateFilename = "L5PCtemplate.hoc" biophysicalModelTemplateFilename = "L5PCtemplate_2.hoc" #%% h.load_file(biophysicalModelFilename) h.load_file(biophysicalModelTemplateFilename) L5PC = h.L5PCtemplate(morphologyFilename) h.celsius = 34 #%% set dendritic VDCC g=0 #secs = h.allsec VDCC_g = 1 if VDCC_g==0: for sec in h.allsec(): if hasattr(sec, 'gCa_HVAbar_Ca_HVA'): sec.gCa_HVAbar_Ca_HVA = 0 #%% helper functions #%% create length-weighted random section list #%% add some random NMDA synapses and plot a somatic trace just to see all things are alive and kicking #%% run simulation on some parameter pair, plot the space L5PC = h.L5PCtemplate(morphologyFilename) name = 'inh_secdt_meds62_exc60dt0sd0num15' #saveDir = '/ems/elsc-labs/segev-i/eilam.goldenberg/Documents/coincidence/wgh1/'+name+'/' saveDir = 'C:/Users/Leleo/Documents/coincidence/wgh1/'+name+'/' if not os.path.exists(saveDir): os.makedirs(saveDir) try: randomSeed = int(sys.argv[1]) print 'random seed selected by user - %d' %(randomSeed) except: randomSeed = np.random.randint(100000) print 'randomly chose seed - %d' %(randomSeed) np.random.seed(randomSeed) #ind = 1 #a = np.linspace(-50,-25,num=6),np.linspace(-20,20,num=21),np.linspace(25,100,num=16) ApicalBasalInterval = [0]#np.linspace(-10,10,num=11) #[x for xs in a for x in xs] numBasal = 50 #35 #np.linspace(0,200,num=81) numApical = 30 #np.linspace(0,20,num=11)#50,num=21)# numInh = 20 #0 #numOblique = 40-numApical #totalSyn = [20,50,100,200,400,600,800]#[80,120,150,180]#np.linspace(0,200,num=5)#41) partApical = 2 #[5,10,20,50,100,200,500]#[i for i in np.linspace(10,100,num=10)]+[200,300,400,500]#np.logspace(0,7,num=29,base=2) medSegment = [0,36,60,63]#[36]+[i for i in np.linspace(60,65,num=6)]#37,44,num=8)] ##40#60 # #secInh = [60[0.5],60[1],61[0],62[0],63[0],64[0],67[0]] #optimal planned inh at prox junc #secInh = [60[1],61[0],63[1]] #encapsulating inh for partApi=20 #random.choice(secInh) treeTime = 0 #0.1*np.logspace(3,10,num=22,base=2) numExperiments = 20 spks = [[0 for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] frqs = [[0 for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] #trc = [[[] for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] i = 0 j = 0 start = time.time() for ApiBasInd in ApicalBasalInterval:#treeT in treeTime:# print "Running for interval: %s [ms]" % (int(ApiBasInd))#treeTime: %.2f [ms]" % (treeT)# #for numB in numBasal:#totalS in totalSyn:# # print "Running for %s basal synapses" % (int(numB)) # for partApi in partApical: for medS in medSegment: # for numA in numApical:#np.linspace(0,totalS,num=41):# print "Running for inhibition in sec: %s" % (int(medS)) #partApi=%s" % (float(partApi)) # # numA = int(totalS*0.4) spks[j][i],frqs[j][i] = runSim(L5PC,ApiBasInd,treeTime,numBasal,numInh,numApical,medS,partApical,numExperiments) j = j+1 j = 0 i = i+1 pickle.dump(spks,open(saveDir+name+'_spks'+str(randomSeed)+".npy","wb"),protocol=2) pickle.dump(frqs,open(saveDir+name+'_frqs'+str(randomSeed)+".npy","wb"),protocol=2) print "Saved as ", saveDir+name+'_spks'+str(randomSeed)+".npy" print "Total running time was: ", (time.time()-start)/3600, "hours" #saveDir = '/ems/elsc-labs/segev-i/eilam.goldenberg/Documents/concidence/' #pickle.dump(spks1,open(saveDir+'dt_treet_30tot_hires_spks',"wb"),protocol=2) #pickle.dump(frqs1,open(saveDir+'dt_treet_30tot_hires_frqs',"wb"),protocol=2)

#!/usr/lib/python-exec/python2.7/python import os import sys os.chdir('C:/Users/Leleo/Documents/Active Cell Real Morphology/') from neuron import h from neuron import gui #%% import numpy as np import time import math import cPickle as pickle #%% sk = False if sk==True: from sklearn import decomposition from sklearn import cluster from sklearn import linear_model from sklearn import ensemble from sklearn import cross_validation #%% h.load_file('nrngui.hoc') h.load_file("import3d.hoc") cvode = h.CVode() cvode.active(0) morphologyFilename = "morphologies/cell1.asc" #morphologyFilename = "morphologies/cell2.asc" #morphologyFilename = "morphologies/cell3.asc" #biophysicalModelFilename = "L5PCbiophys1.hoc" #biophysicalModelFilename = "L5PCbiophys2.hoc" #biophysicalModelFilename = "L5PCbiophys3.hoc" #biophysicalModelFilename = "L5PCbiophys4.hoc" #biophysicalModelFilename = "L5PCbiophys5.hoc" biophysicalModelFilename = "L5PCbiophys5b.hoc" #biophysicalModelTemplateFilename = "L5PCtemplate.hoc" biophysicalModelTemplateFilename = "L5PCtemplate_2.hoc" #%% h.load_file(biophysicalModelFilename) h.load_file(biophysicalModelTemplateFilename) L5PC = h.L5PCtemplate(morphologyFilename) h.celsius = 34 #%% set dendritic VDCC g=0 #secs = h.allsec VDCC_g = 1 if VDCC_g==0: for sec in h.allsec(): if hasattr(sec, 'gCa_HVAbar_Ca_HVA'): sec.gCa_HVAbar_Ca_HVA = 0 #%% helper functions def Add_NMDA_SingleSynapticEventToSegment(segment, activationTime, synapseWeight, exc_inh): # synapse = h.ProbAMPANMDA2(segment) # synapse = h.ProbAMPANMDA_EMS(segLoc,sec=section) if exc_inh==0: # inhibitory synapse = h.ProbGABAAB_EMS(segment) #GABAA/B synapse.tau_r_GABAA = 0.2 synapse.tau_d_GABAA = 8 synapse.tau_r_GABAB = 3.5 synapse.tau_d_GABAB = 260.9 # synapse.gmax = .001 synapse.e_GABAA = -80 synapse.e_GABAB = -97 synapse.GABAB_ratio = 0.0 # synapse.Use = 1 # synapse.u0 = 0 # synapse.Dep = 0 # synapse.Fac = 0 else: # excitatory synapse = h.ProbAMPANMDA2(segment) synapse.gmax = .0004 # synapse = h.ProbAMPANMDA_EMS(segLoc,sec=section) synapse.Use = 1.0 synapse.Dep = 0 synapse.Fac = 0 netStimulation = h.NetStim() netStimulation.number = 1 netStimulation.start = activationTime netConnection = h.NetCon(netStimulation,synapse) netConnection.delay = 0 netConnection.weight[0] = synapseWeight return netStimulation,netConnection,synapse #%% create length-weighted random section list def randSecWeight(obj,medSeg,part,num): allLen = [] for i in range(len(obj)): allLen.append(obj[i].L) randSecList = [0 for i in range(num)] h.distance(sec=obj[medSeg]) # define distance measure from medSeg # draw from cumulative length a seg for syn x = np.sum(allLen[:medSeg])+(np.random.rand(num)-0.5)*np.sum(allLen)/part j=0 farbug=0 while j<num: # redraw boundary crossers if x[j]<0 or x[j]>np.sum(allLen): x[j] = np.sum(allLen[:medSeg])+(np.random.rand()-0.5)*np.sum(allLen)/part continue # find sec for i in range(len(obj)): if x[j]<np.sum(allLen[:i+1]): randSecList[j]=i break # check that sec is sufficiently close to medseg if h.distance(obj[randSecList[j]](1))>sum(allLen)/part and farbug<5:#obj[medSeg].L+obj[randSecList[j]].L:# x[j] = np.sum(allLen[:medSeg])+(np.random.rand()-0.5)*np.sum(allLen)/part farbug+=1 continue j+=1 farbug=0 return randSecList #%% add some random NMDA synapses and plot a somatic trace just to see all things are alive and kicking def runSim(cell,ApiBasInt,treeT,numBas,numApi,partApi,medSeg,inSec,numExp): simulationTime = 400 silentTimeAtStart = 100 delayTime = 200 silentTimeAtEnd = 100 origNumSamplesPerMS = 40 #20 # was 20!!! totalSimDuration = simulationTime + silentTimeAtStart + silentTimeAtEnd listOfSomaTraces = [] spikes = [] numSpikes = 0 numSpikesPerExp = [0]*numExp freq = [0]*numExp for experiment in range(numExp): startTime = time.time() listOfRandBasalSectionInds = randSecWeight(cell.dend,44,1,int(numBas))#np.random.randint(0,len(cell.dend),int(numBas)) listOfRandApicalSectionInds = randSecWeight(cell.apic,62,20,20)#int(numApi)) #medSeg + np.random.randint(-distance,distance,int(numApi)) if partApi>15: listOfRandInhSectionInds = randSecWeight(cell.apic,medSeg,partApi,numApi) else: listOfRandInhSectionInds = randSecWeight(cell.apic,medSeg,partApi,numApi) # listOfRandApicalSectionInds = randSecWeight(cell.apic,np.random.randint(37,78),partApi,10)#int(numApi)) # listOfRandObliqueSectionInds = np.random.randint(0,len(cell.apic)/partApi,0)#int(40-numApi)) #obliques listOfBasalSections = [cell.dend[x] for x in listOfRandBasalSectionInds] listOfApicalSections = [cell.apic[x] for x in listOfRandApicalSectionInds] listOfInhSections = [cell.apic[x] for x in listOfRandInhSectionInds] # listOfObliqueSections = [cell.apic[x] for x in listOfRandObliqueSectionInds] # listOfSections = listOfApicalSections + listOfBasalSections listOfRandBasalLocationsInSection = np.random.rand(len(listOfRandBasalSectionInds)) listOfRandApicalLocationsInSection = np.random.rand(len(listOfRandApicalSectionInds)) # listOfRandInhLocationsInSection = float(inSec)/4 + 0.25*np.random.rand(len(listOfRandInhSectionInds)) if partApi>30: listOfRandInhLocationsInSection = [1]*numApi #min(1,float(7440)/partApi/cell.apic[medSeg].L)*np.random.rand(len(listOfRandInhSectionInds)) else: listOfRandInhLocationsInSection = np.random.rand(len(listOfRandInhSectionInds)) # listOfRandObliqueLocationsInSection = np.random.rand(len(listOfRandObliqueSectionInds)) # listOfSegLocs = list(listOfRandApicalLocationsInSection) + list(listOfRandBasalLocationsInSection) listOfEvents = [] for k, section in enumerate(listOfApicalSections): eventTime = silentTimeAtStart + 100*np.random.normal(0,1) listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandApicalLocationsInSection[k]), eventTime, 1, 1)) for k, section in enumerate(listOfBasalSections): eventTime = silentTimeAtStart + 100*np.random.normal(0,1) #simulationTime/2*np.random.rand(1)[0] listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandBasalLocationsInSection[k]), eventTime, 1, 1)) for k, section in enumerate(listOfInhSections): eventTime = silentTimeAtStart + 100*np.random.normal(0,1) #simulationTime/2*np.random.rand(1)[0] listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandInhLocationsInSection[k]), eventTime, 1, 0)) for k, section in enumerate(listOfApicalSections): eventTime = silentTimeAtStart + delayTime + treeT*np.random.normal(0,1) #gauss(0.5,0.2) listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandApicalLocationsInSection[k]), eventTime, 1, 1)) for k, section in enumerate(listOfBasalSections): eventTime = silentTimeAtStart + delayTime + treeT*np.random.normal(0,1) #simulationTime/2*np.random.rand(1)[0] listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandBasalLocationsInSection[k]), eventTime, 1, 1)) for k, section in enumerate(listOfInhSections): eventTime = silentTimeAtStart + delayTime + ApiBasInt + treeT*np.random.normal(0,1) #simulationTime/2*np.random.rand(1)[0] listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandInhLocationsInSection[k]), eventTime, 1, 0)) #add obliques # for k, section in enumerate(listOfObliqueSections): # eventTime = silentTimeAtStart + delayTime + treeT*np.random.normal(1,0.2) #simulationTime/2*np.random.rand(1)[0] # listOfEvents.append(Add_NMDA_SingleSynapticEventToSegment(section(listOfRandObliqueLocationsInSection[k]), eventTime, 2)) ##%% run the simulation h.dt = 0.025 recTime = h.Vector() recTime.record(h._ref_t) recVoltage = h.Vector() recVoltage.record(cell.soma[0](0.5)._ref_v) cvode.cache_efficient(1) h.finitialize(-76) stopTime = totalSimDuration neuron.run(stopTime) # plot the trace origRecordingTime = np.array(recTime.to_python()) # ugly workaround to recTime.as_numpy() origSomaVoltage = np.array(recVoltage.to_python()) # ugly workaround to recVoltage.as_numpy() recordingTime = np.arange(0,totalSimDuration,1.0/origNumSamplesPerMS) somaVoltage = np.interp(recordingTime, origRecordingTime, origSomaVoltage) listOfSomaTraces.append(somaVoltage) origSpikes = [] tempSpikes = 0 k = (silentTimeAtStart+delayTime-50)*origNumSamplesPerMS #int(np.min([0,ApiBasInt])) while k < (totalSimDuration-silentTimeAtEnd)*origNumSamplesPerMS: if somaVoltage[k]>-10: tempTime = float(k)/origNumSamplesPerMS if tempSpikes>0 and tempTime-origSpikes[-1]>20: break origSpikes.append(tempTime) # numSpikesPerExp[experiment] = tempSpikes + 1 numSpikes = numSpikes + 1 tempSpikes += 1 # numSpikesPerExp[experiment] k = k+origNumSamplesPerMS*3 else: k = k+5 # was 1 before # spikes = [] spikes.append(origSpikes) if tempSpikes>1: freq[experiment] = tempSpikes/(origSpikes[-1]-origSpikes[-tempSpikes]) # plt.figure() # plt.plot(recordingTime, somaVoltage) # plt.xlabel('Time [ms]'); plt.ylabel('Voltage [mV]') # plt.axis(xmin=0, xmax=stopTime, ymin=min(somaVoltage)-5, ymax=max(somaVoltage)+5) #listOfEvents = [] if (experiment+1)%10==0 or (time.time()-startTime)/60>5 or numExp<5: print "Dt %s treeTime %s exp. # %s took %.3f minutes" % (ApiBasInt,treeT,experiment+1, (time.time()-startTime)/60) print "Mean no. of spikes: %s" % (float(numSpikes)/numExp) return float(numSpikes)/numExp,np.mean(freq)#, listOfSomaTraces, recordingTime #%% run simulation on some parameter pair, plot the space L5PC = h.L5PCtemplate(morphologyFilename) name = 'inh_secdt_meds62_exc60dt0sd0num15' #saveDir = '/ems/elsc-labs/segev-i/eilam.goldenberg/Documents/coincidence/wgh1/'+name+'/' saveDir = 'C:/Users/Leleo/Documents/coincidence/wgh1/'+name+'/' if not os.path.exists(saveDir): os.makedirs(saveDir) try: randomSeed = int(sys.argv[1]) print 'random seed selected by user - %d' %(randomSeed) except: randomSeed = np.random.randint(100000) print 'randomly chose seed - %d' %(randomSeed) np.random.seed(randomSeed) #ind = 1 #a = np.linspace(-50,-25,num=6),np.linspace(-20,20,num=21),np.linspace(25,100,num=16) ApicalBasalInterval = [0]#np.linspace(-10,10,num=11) #[x for xs in a for x in xs] numBasal = 50 #35 #np.linspace(0,200,num=81) numApical = 30 #np.linspace(0,20,num=11)#50,num=21)# numInh = 20 #0 #numOblique = 40-numApical #totalSyn = [20,50,100,200,400,600,800]#[80,120,150,180]#np.linspace(0,200,num=5)#41) partApical = 2 #[5,10,20,50,100,200,500]#[i for i in np.linspace(10,100,num=10)]+[200,300,400,500]#np.logspace(0,7,num=29,base=2) medSegment = [0,36,60,63]#[36]+[i for i in np.linspace(60,65,num=6)]#37,44,num=8)] ##40#60 # #secInh = [60[0.5],60[1],61[0],62[0],63[0],64[0],67[0]] #optimal planned inh at prox junc #secInh = [60[1],61[0],63[1]] #encapsulating inh for partApi=20 #random.choice(secInh) treeTime = 0 #0.1*np.logspace(3,10,num=22,base=2) numExperiments = 20 spks = [[0 for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] frqs = [[0 for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] #trc = [[[] for i in range(len(ApicalBasalInterval))] for j in range(len(medSegment))]#*4)] i = 0 j = 0 start = time.time() for ApiBasInd in ApicalBasalInterval:#treeT in treeTime:# print "Running for interval: %s [ms]" % (int(ApiBasInd))#treeTime: %.2f [ms]" % (treeT)# #for numB in numBasal:#totalS in totalSyn:# # print "Running for %s basal synapses" % (int(numB)) # for partApi in partApical: for medS in medSegment: # for numA in numApical:#np.linspace(0,totalS,num=41):# print "Running for inhibition in sec: %s" % (int(medS)) #partApi=%s" % (float(partApi)) # # numA = int(totalS*0.4) spks[j][i],frqs[j][i] = runSim(L5PC,ApiBasInd,treeTime,numBasal,numInh,numApical,medS,partApical,numExperiments) j = j+1 j = 0 i = i+1 pickle.dump(spks,open(saveDir+name+'_spks'+str(randomSeed)+".npy","wb"),protocol=2) pickle.dump(frqs,open(saveDir+name+'_frqs'+str(randomSeed)+".npy","wb"),protocol=2) print "Saved as ", saveDir+name+'_spks'+str(randomSeed)+".npy" print "Total running time was: ", (time.time()-start)/3600, "hours" #saveDir = '/ems/elsc-labs/segev-i/eilam.goldenberg/Documents/concidence/' #pickle.dump(spks1,open(saveDir+'dt_treet_30tot_hires_spks',"wb"),protocol=2) #pickle.dump(frqs1,open(saveDir+'dt_treet_30tot_hires_frqs',"wb"),protocol=2)

ec42f79f6e9bebd0d6cc7d934779f60d52434f4f

py

Python

sharesansar/driver.py

prajwal-stha/web-scrapers

bfcc5a065e859c69f1a9a2065c9c857b22af42c0

sharesansar/driver.py

prajwal-stha/web-scrapers

bfcc5a065e859c69f1a9a2065c9c857b22af42c0

sharesansar/driver.py

prajwal-stha/web-scrapers

bfcc5a065e859c69f1a9a2065c9c857b22af42c0

from selenium import webdriver import time from datetime import date from selenium.webdriver.common.keys import Keys from scrape_table_all import scrape_table from return_dates import return_dates # Open the link PATH = "/Users/prajwalshrestha/Desktop/PythonApp/thesis/web-scrapers/sharesansar/chromedriver" browser = webdriver.Chrome(PATH) browser.maximize_window() browser.get("https://www.sharesansar.com/today-share-price") # Select the type of data to scrape searchBar = browser.find_element_by_id('sector') browser.implicitly_wait(20) # Select Commercial Bank searchBar.send_keys('Commercial Bank') sdate = date(2020, 3, 23) edate = date(2021, 5, 13) dates = return_dates(sdate, edate) for day in dates: # Enter the date date_box = browser.find_elements_by_id('fromdate') date_box[0].clear() date_box[0].send_keys(day) # Click Search searchBar = browser.find_element_by_id('btn_todayshareprice_submit') searchBar.click() time.sleep(3) # Needed for this sites searchBar.send_keys(Keys.ENTER) # Wait for data to show up longer wait time ensures data has loaded before scraping begins time.sleep(8) # Scrape the table html = browser.page_source scrape_table(data=html, date=day) browser.close()

from selenium import webdriver import time from datetime import date from selenium.webdriver.common.keys import Keys from scrape_table_all import scrape_table from return_dates import return_dates # Open the link PATH = "/Users/prajwalshrestha/Desktop/PythonApp/thesis/web-scrapers/sharesansar/chromedriver" browser = webdriver.Chrome(PATH) browser.maximize_window() browser.get("https://www.sharesansar.com/today-share-price") # Select the type of data to scrape searchBar = browser.find_element_by_id('sector') browser.implicitly_wait(20) # Select Commercial Bank searchBar.send_keys('Commercial Bank') sdate = date(2020, 3, 23) edate = date(2021, 5, 13) dates = return_dates(sdate, edate) for day in dates: # Enter the date date_box = browser.find_elements_by_id('fromdate') date_box[0].clear() date_box[0].send_keys(day) # Click Search searchBar = browser.find_element_by_id('btn_todayshareprice_submit') searchBar.click() time.sleep(3) # Needed for this sites searchBar.send_keys(Keys.ENTER) # Wait for data to show up longer wait time ensures data has loaded before scraping begins time.sleep(8) # Scrape the table html = browser.page_source scrape_table(data=html, date=day) browser.close()

d08252eba99ccd39e5902637266d30dc619c8ac2

py

Python

tests/view_tests/test_group_routes.py

Kalafut-organization/elephant_vending_machine_backend

f8b94adda2b2e9c824a3983749061a549ad1d0ec

tests/view_tests/test_group_routes.py

Kalafut-organization/elephant_vending_machine_backend

f8b94adda2b2e9c824a3983749061a549ad1d0ec

2020-03-23T21:36:07.000Z

2022-02-16T17:09:18.000Z

tests/view_tests/test_group_routes.py

Kalafut-organization/elephants_cse5911

3d2c72173070666e8b7503af6efe891e6507936d

2020-04-14T00:48:58.000Z

2022-02-23T18:39:44.000Z

import pytest import subprocess from io import BytesIO import json from werkzeug.wrappers import Response from elephant_vending_machine import elephant_vending_machine from subprocess import CompletedProcess, CalledProcessError @pytest.fixture

import pytest import subprocess from io import BytesIO import json from werkzeug.wrappers import Response from elephant_vending_machine import elephant_vending_machine from subprocess import CompletedProcess, CalledProcessError def raise_(ex): raise ex @pytest.fixture def client(): elephant_vending_machine.APP.config['TESTING'] = True with elephant_vending_machine.APP.test_client() as client: yield client subprocess.call(["rmdir","elephant_vending_machine/static/img/test"]) subprocess.call(["rmdir","elephant_vending_machine/static/img/test2"]) def test_post_group_route_no_name(client): response = client.post('/groups') assert response.status_code == 400 assert b'Error with request: No name field in body of request.' in response.data def test_post_group_route_empty_name(client): data = {'name': ''} response = client.post('/groups', data=data) assert response.status_code == 400 assert json.loads(response.data)['message'] == 'Error with request: Group name must not be empty.' def test_post_group_route_duplicate(client): subprocess.call(["mkdir", "elephant_vending_machine/static/img/test"]) data = {'name': 'test'} response = client.post('/groups', data=data) assert response.status_code == 400 assert json.loads(response.data)['message'] == 'Error with request: Group already exists.' def test_post_group_route_copying_exception(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: raise_(CalledProcessError(1, ['ssh']))) data = {'name': 'test'} response = client.post('/groups', data=data) assert response.status_code == 500 assert json.loads(response.data)['message'] == 'Error: Failed to create group on hosts.' def test_post_group_route_happy_path(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: CompletedProcess(['some_command'], returncode=0)) data = {'name': 'test'} response = client.post('/groups', data=data) assert response.status_code == 201 assert b'Success: Group created.' def test_delete_group_route_not_exist(client): response = client.delete('/groups/test') assert response.status_code == 400 assert b"Group test does not exist and so couldn't be deleted." in response.data def test_delete_group_route_os_error(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: CompletedProcess(['some_command'], returncode=0)) monkeypatch.setattr('shutil.rmtree', lambda path: raise_(OSError)) subprocess.call(["mkdir", "elephant_vending_machine/static/img/test"]) response = client.delete('/groups/test') assert response.status_code == 400 assert b'An error has occurred and the group could not be deleted' in response.data def test_delete_group_happy_path(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: CompletedProcess(['some_command'], returncode=0)) subprocess.call(["mkdir", "elephant_vending_machine/static/img/test"]) response = client.delete('/groups/test') assert response.status_code == 200 assert b'Group test was successfully deleted.' in response.data def test_delete_fixations_group(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: CompletedProcess(['some_command'], returncode=0)) response = client.delete('/groups/Fixations') assert response.status_code == 400 assert b'The fixations group cannot be deleted' in response.data def test_delete_group_no_connection(monkeypatch, client): monkeypatch.setattr('subprocess.run', lambda command, check, shell: raise_(CalledProcessError(1, ['ssh']))) subprocess.call(["mkdir", "elephant_vending_machine/static/img/test"]) response = client.delete('/groups/test') assert response.status_code == 500 assert json.loads(response.data)['message'] == ['Error: Failed to delete file from hosts. ', \ 'Group not deleted, please try again'] def test_get_group_route(client): subprocess.call(["mkdir", "elephant_vending_machine/static/img/test"]) subprocess.call(["mkdir", "elephant_vending_machine/static/img/test2"]) response = client.get('/groups') response_json_files = json.loads(response.data)['names'] min_elements_expected = ["test","test2"] assert all(elem in response_json_files for elem in min_elements_expected) assert response.status_code == 200

b8886f82232200a3b8d715152e899cad7d68af4a

py

Python

ots/main/urls.py

rashikbuksh/Optimal-Transportation-System

18c6d5341c6d3ecbb1c8fcfba8e46ca2ba493882

2021-12-01T15:56:42.000Z

2021-12-23T15:49:48.000Z

ots/main/urls.py

rashikbuksh/Optimal-Transportation-System

18c6d5341c6d3ecbb1c8fcfba8e46ca2ba493882

ots/main/urls.py

rashikbuksh/Optimal-Transportation-System

18c6d5341c6d3ecbb1c8fcfba8e46ca2ba493882

2021-09-24T19:49:28.000Z

2021-12-22T10:25:38.000Z

from django.conf.urls import url from django.urls import path from . import views app_name = 'articles' urlpatterns = [ url(r'^$', views.homepage, name="list"), url(r'^about/$', views.about, name="about"), url(r'^contact/$', views.contact, name="contact"), url(r'^bolaka/$', views.bolaka, name="bolaka"), url(r'^offers_page/$', views.offers, name="offers_page"), url(r'^bolakareview/$', views.bolakareview, name="bolakareview"), url(r'^ticket/$', views.ticket, name="ticket"), path('deletebalaka/<str:pk>/$', views.deletebalaka, name="deletebalaka"), url(r'^ticket_page/$', views.ticket_page, name="ticket_page"), # Air url(r'^Air_Biman_Bangladesh/$', views.Air_Biman_Bangladesh, name="Air_Biman_Bangladesh"), url(r'^Air_Novoair/$', views.Air_Novoair, name="Air_Novoair"), url(r'^Air_US_Bangla/$', views.Air_US_Bangla, name="Air_US_Bangla"), # Bus url(r'^Bus_Akash/$', views.Bus_Akash, name="Bus_Akash"), url(r'^Bus_Alif/$', views.Bus_Alif, name="Bus_Alif"), url(r'^Bus_Anabil/$', views.Bus_Anabil, name="Bus_Anabil"), url(r'^Bus_BRTC/$', views.Bus_BRTC, name="Bus_BRTC"), url(r'^Bus_Green_Dhaka/$', views.Bus_Green_Dhaka, name="Bus_Green_Dhaka"), url(r'^Bus_Raida/$', views.Bus_Raida, name="Bus_Raida"), url(r'^Bus_Skyline/$', views.Bus_Skyline, name="Bus_Skyline"), url(r'^Bus_Supravat/$', views.Bus_Supravat, name="Bus_Supravat"), url(r'^Bus_VIP/$', views.Bus_VIP, name="Bus_VIP"), # Train url(r'^Train_Chitra_Express/$', views.Train_Chitra_Express, name="Train_Chitra_Express"), url(r'^Train_Ekota_Express/$', views.Train_Ekota_Express, name="Train_Ekota_Express"), url(r'^Train_Mahanagar_Godhuli/$', views.Train_Mahanagar_Godhuli, name="Train_Mahanagar_Godhuli"), url(r'^Train_Suborno_Express/$', views.Train_Suborno_Express, name="Train_Suborno_Express"), url(r'^Train_Tista_Express/$', views.Train_Tista_Express, name="Train_Tista_Express"), url(r'^(?P<slug>[\w-]+)/$', views.homepage, name="list"), ]

from django.conf.urls import url from django.urls import path from . import views app_name = 'articles' urlpatterns = [ url(r'^$', views.homepage, name="list"), url(r'^about/$', views.about, name="about"), url(r'^contact/$', views.contact, name="contact"), url(r'^bolaka/$', views.bolaka, name="bolaka"), url(r'^offers_page/$', views.offers, name="offers_page"), url(r'^bolakareview/$', views.bolakareview, name="bolakareview"), url(r'^ticket/$', views.ticket, name="ticket"), path('deletebalaka/<str:pk>/$', views.deletebalaka, name="deletebalaka"), url(r'^ticket_page/$', views.ticket_page, name="ticket_page"), # Air url(r'^Air_Biman_Bangladesh/$', views.Air_Biman_Bangladesh, name="Air_Biman_Bangladesh"), url(r'^Air_Novoair/$', views.Air_Novoair, name="Air_Novoair"), url(r'^Air_US_Bangla/$', views.Air_US_Bangla, name="Air_US_Bangla"), # Bus url(r'^Bus_Akash/$', views.Bus_Akash, name="Bus_Akash"), url(r'^Bus_Alif/$', views.Bus_Alif, name="Bus_Alif"), url(r'^Bus_Anabil/$', views.Bus_Anabil, name="Bus_Anabil"), url(r'^Bus_BRTC/$', views.Bus_BRTC, name="Bus_BRTC"), url(r'^Bus_Green_Dhaka/$', views.Bus_Green_Dhaka, name="Bus_Green_Dhaka"), url(r'^Bus_Raida/$', views.Bus_Raida, name="Bus_Raida"), url(r'^Bus_Skyline/$', views.Bus_Skyline, name="Bus_Skyline"), url(r'^Bus_Supravat/$', views.Bus_Supravat, name="Bus_Supravat"), url(r'^Bus_VIP/$', views.Bus_VIP, name="Bus_VIP"), # Train url(r'^Train_Chitra_Express/$', views.Train_Chitra_Express, name="Train_Chitra_Express"), url(r'^Train_Ekota_Express/$', views.Train_Ekota_Express, name="Train_Ekota_Express"), url(r'^Train_Mahanagar_Godhuli/$', views.Train_Mahanagar_Godhuli, name="Train_Mahanagar_Godhuli"), url(r'^Train_Suborno_Express/$', views.Train_Suborno_Express, name="Train_Suborno_Express"), url(r'^Train_Tista_Express/$', views.Train_Tista_Express, name="Train_Tista_Express"), url(r'^(?P<slug>[\w-]+)/$', views.homepage, name="list"), ]

b81f72c1a629494935d113e4876d1627760656f2

py

Python

bana/OpenMayaFX/__init__.py

christophercrouzet/bana

8087df05ba9844b4d78d3c4699948ca61cf7621d

2017-01-11T15:57:46.000Z

2020-09-23T06:18:30.000Z

bana/OpenMayaFX/__init__.py

christophercrouzet/bana

8087df05ba9844b4d78d3c4699948ca61cf7621d

bana/OpenMayaFX/__init__.py

christophercrouzet/bana

8087df05ba9844b4d78d3c4699948ca61cf7621d

2017-03-06T23:52:08.000Z

2020-09-23T06:19:03.000Z

"""Extensions for the ``maya.OpenMayaFX`` module."""

"""Extensions for the ``maya.OpenMayaFX`` module."""

8b0fe30871875ffa461d0b5d638a14149f7fd68f

py

Python

apps/metadata/users/models.py

DiegoCorrea/ouvidoMusical

e8bdb993e2c6ef2fe4a78e844bc60be2738a5ba5

2021-10-06T19:35:48.000Z

2021-10-06T19:35:48.000Z

apps/metadata/users/models.py

DiegoCorrea/ouvido_musical-Back

e8bdb993e2c6ef2fe4a78e844bc60be2738a5ba5

apps/metadata/users/models.py

DiegoCorrea/ouvido_musical-Back

e8bdb993e2c6ef2fe4a78e844bc60be2738a5ba5

# -*- coding: utf-8 -*- from __future__ import unicode_literals import uuid from django.db import models

# -*- coding: utf-8 -*- from __future__ import unicode_literals import uuid from django.db import models class User(models.Model): id = models.CharField( max_length=255, unique=True, db_index=True, primary_key=True, default=uuid.uuid1().hex ) def as_json(self): return dict( user_id=self.id )

13ba18ae2cb6655e5d831659bbe1a04a83ddcd4a

py

Python

running_modes/constructors/running_mode.py

lilleswing/Reinvent-1

ac4e3e6fa6379c6f4af883478dfd1b3407933ada

2020-04-04T02:01:15.000Z

2022-03-30T21:56:56.000Z

running_modes/constructors/running_mode.py

lilleswing/Reinvent-1

ac4e3e6fa6379c6f4af883478dfd1b3407933ada

2020-04-05T15:19:56.000Z

2022-03-09T12:58:21.000Z

running_modes/constructors/running_mode.py

lilleswing/Reinvent-1

ac4e3e6fa6379c6f4af883478dfd1b3407933ada

2020-04-05T19:25:43.000Z

2022-02-22T12:04:39.000Z

from running_modes.configurations import GeneralConfigurationEnvelope from running_modes.constructors.base_running_mode import BaseRunningMode from running_modes.constructors.create_model_mode_constructor import CreateModelModeConstructor from running_modes.constructors.curriculum_learning_mode_constructor import CurriculumLearningModeConstructor from running_modes.constructors.reinforcement_learning_mode_constructor import ReinforcementLearningModeConstructor from running_modes.constructors.sampling_mode_constructor import SamplingModeConstructor from running_modes.constructors.scoring_mode_constructor import ScoringModeConstructor from running_modes.constructors.transfer_learning_mode_constructor import TransferLearningModeConstructor from running_modes.constructors.validation_mode_constructor import ValidationModeConstructor from running_modes.enums.running_mode_enum import RunningModeEnum

from running_modes.configurations import GeneralConfigurationEnvelope from running_modes.constructors.base_running_mode import BaseRunningMode from running_modes.constructors.create_model_mode_constructor import CreateModelModeConstructor from running_modes.constructors.curriculum_learning_mode_constructor import CurriculumLearningModeConstructor from running_modes.constructors.reinforcement_learning_mode_constructor import ReinforcementLearningModeConstructor from running_modes.constructors.sampling_mode_constructor import SamplingModeConstructor from running_modes.constructors.scoring_mode_constructor import ScoringModeConstructor from running_modes.constructors.transfer_learning_mode_constructor import TransferLearningModeConstructor from running_modes.constructors.validation_mode_constructor import ValidationModeConstructor from running_modes.enums.running_mode_enum import RunningModeEnum class RunningMode: def __new__(cls, configuration: GeneralConfigurationEnvelope) -> BaseRunningMode: running_mode_enum = RunningModeEnum() _configuration = configuration if configuration.run_type == running_mode_enum.REINFORCEMENT_LEARNING: return ReinforcementLearningModeConstructor(configuration) if configuration.run_type == running_mode_enum.CURRICULUM_LEARNING: return CurriculumLearningModeConstructor(configuration) if configuration.run_type == running_mode_enum.TRANSFER_LEARNING: return TransferLearningModeConstructor(configuration) if configuration.run_type == running_mode_enum.SCORING: return ScoringModeConstructor(configuration) if configuration.run_type == running_mode_enum.SAMPLING: return SamplingModeConstructor(configuration) if configuration.run_type == running_mode_enum.CREATE_MODEL: return CreateModelModeConstructor(configuration) if configuration.run_type == running_mode_enum.VALIDATION: return ValidationModeConstructor(configuration) # if configuration.run_type == running_mode_enum.AUTOMATED_CURRICULUM_LEARNING: # return AutomatedCurriculumLearningModeConstructor(configuration) else: raise TypeError(f"Requested run type: '{configuration.run_type}' is not implemented.")

1477ad88726678c8460cc5fe89ba40da27efa1cb

py

Python

ansible/collections/ansible_collections/nhsd/apigee/plugins/filter/filters.py

uk-gov-mirror/nhsdigital.api-management-utils

4ee5489f7ce7595c371e2f4e83fc0c753308905a

ansible/collections/ansible_collections/nhsd/apigee/plugins/filter/filters.py

uk-gov-mirror/nhsdigital.api-management-utils

4ee5489f7ce7595c371e2f4e83fc0c753308905a

2020-05-27T15:00:31.000Z

2021-09-13T11:38:58.000Z

ansible/collections/ansible_collections/nhsd/apigee/plugins/filter/filters.py

uk-gov-mirror/nhsdigital.api-management-utils

4ee5489f7ce7595c371e2f4e83fc0c753308905a

2021-04-11T07:31:36.000Z

2022-01-24T11:23:18.000Z

from ansible_collections.nhsd.apigee.plugins.module_utils import constants def org_from_env(environment) -> str: """Get nhsd apigee organization name from environment name.""" for org, envs in constants.APIGEE_ORG_TO_ENV.items(): if environment in envs: return org valid_envs = [] for v in constants.APIGEE_ORG_TO_ENV.values(): valid_envs = valid_envs + v raise ValueError(f"Unknown environment {environment}, valid environments are {valid_envs}")

from ansible_collections.nhsd.apigee.plugins.module_utils import constants def org_from_env(environment) -> str: """Get nhsd apigee organization name from environment name.""" for org, envs in constants.APIGEE_ORG_TO_ENV.items(): if environment in envs: return org valid_envs = [] for v in constants.APIGEE_ORG_TO_ENV.values(): valid_envs = valid_envs + v raise ValueError(f"Unknown environment {environment}, valid environments are {valid_envs}") class FilterModule: @staticmethod def filters(): return { 'org_from_env': org_from_env }

9821d58fd217247d13910323dd73ffca785b11ca

py

Python

IPython/deathrow/astyle.py

dchichkov/ipython

8096bb8640ee7e7c5ebdf3f428fe69cd390e1cd4

2019-03-20T07:38:35.000Z

2021-06-18T09:42:46.000Z

IPython/deathrow/astyle.py

dchichkov/ipython

8096bb8640ee7e7c5ebdf3f428fe69cd390e1cd4

2015-04-01T13:14:57.000Z

2015-05-26T16:01:37.000Z

IPython/deathrow/astyle.py

dchichkov/ipython

8096bb8640ee7e7c5ebdf3f428fe69cd390e1cd4

2019-06-29T03:13:02.000Z

2020-04-23T04:47:11.000Z

""" ``astyle`` provides classes for adding style (foreground and background color; bold; blink; etc.) to terminal and curses output. """ import sys, os try: import curses except ImportError: curses = None COLOR_BLACK = 0 COLOR_RED = 1 COLOR_GREEN = 2 COLOR_YELLOW = 3 COLOR_BLUE = 4 COLOR_MAGENTA = 5 COLOR_CYAN = 6 COLOR_WHITE = 7 A_BLINK = 1<<0 # Blinking text A_BOLD = 1<<1 # Extra bright or bold text A_DIM = 1<<2 # Half bright text A_REVERSE = 1<<3 # Reverse-video text A_STANDOUT = 1<<4 # The best highlighting mode available A_UNDERLINE = 1<<5 # Underlined text class Style(object): """ Store foreground color, background color and attribute (bold, underlined etc.). """ __slots__ = ("fg", "bg", "attrs") COLORNAMES = { "black": COLOR_BLACK, "red": COLOR_RED, "green": COLOR_GREEN, "yellow": COLOR_YELLOW, "blue": COLOR_BLUE, "magenta": COLOR_MAGENTA, "cyan": COLOR_CYAN, "white": COLOR_WHITE, } ATTRNAMES = { "blink": A_BLINK, "bold": A_BOLD, "dim": A_DIM, "reverse": A_REVERSE, "standout": A_STANDOUT, "underline": A_UNDERLINE, } def __init__(self, fg, bg, attrs=0): """ Create a ``Style`` object with ``fg`` as the foreground color, ``bg`` as the background color and ``attrs`` as the attributes. Examples: >>> Style(COLOR_RED, COLOR_BLACK) <Style fg=red bg=black attrs=0> >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE) <Style fg=yellow bg=blue attrs=bold|underline> """ self.fg = fg self.bg = bg self.attrs = attrs def fromstr(cls, value): """ Create a ``Style`` object from a string. The format looks like this: ``"red:black:bold|blink"``. """ # defaults fg = COLOR_WHITE bg = COLOR_BLACK attrs = 0 parts = value.split(":") if len(parts) > 0: fg = cls.COLORNAMES[parts[0].lower()] if len(parts) > 1: bg = cls.COLORNAMES[parts[1].lower()] if len(parts) > 2: for strattr in parts[2].split("|"): attrs |= cls.ATTRNAMES[strattr.lower()] return cls(fg, bg, attrs) fromstr = classmethod(fromstr) def fromenv(cls, name, default): """ Create a ``Style`` from an environment variable named ``name`` (using ``default`` if the environment variable doesn't exist). """ return cls.fromstr(os.environ.get(name, default)) fromenv = classmethod(fromenv) def switchstyle(s1, s2): """ Return the ANSI escape sequence needed to switch from style ``s1`` to style ``s2``. """ attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE) a1 = s1.attrs & attrmask a2 = s2.attrs & attrmask args = [] if s1 != s2: # do we have to get rid of the bold/underline/blink bit? # (can only be done by a reset) # use reset when our target color is the default color # (this is shorter than 37;40) if (a1 & ~a2 or s2==style_default): args.append("0") s1 = style_default a1 = 0 # now we know that old and new color have the same boldness, # or the new color is bold and the old isn't, # i.e. we only might have to switch bold on, not off if not (a1 & A_BOLD) and (a2 & A_BOLD): args.append("1") # Fix underline if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE): args.append("4") # Fix blink if not (a1 & A_BLINK) and (a2 & A_BLINK): args.append("5") # Fix reverse if not (a1 & A_REVERSE) and (a2 & A_REVERSE): args.append("7") # Fix foreground color if s1.fg != s2.fg: args.append("3%d" % s2.fg) # Finally fix the background color if s1.bg != s2.bg: args.append("4%d" % s2.bg) if args: return "\033[%sm" % ";".join(args) return "" class Text(list): """ A colored string. A ``Text`` object is a sequence, the sequence items will be ``(style, string)`` tuples. """ def format(self, styled=True): """ This generator yields the strings that will make up the final colorized string. """ if styled: oldstyle = style_default for (style, string) in self: if not isinstance(style, (int, long)): switch = switchstyle(oldstyle, style) if switch: yield switch if string: yield string oldstyle = style switch = switchstyle(oldstyle, style_default) if switch: yield switch else: for (style, string) in self: if not isinstance(style, (int, long)): yield string def string(self, styled=True): """ Return the resulting string (with escape sequences, if ``styled`` is true). """ return "".join(self.format(styled)) def __str__(self): """ Return ``self`` as a string (without ANSI escape sequences). """ return self.string(False) def write(self, stream, styled=True): """ Write ``self`` to the output stream ``stream`` (with escape sequences, if ``styled`` is true). """ for part in self.format(styled): stream.write(part) try: import ipipe except ImportError: pass else: ipipe.xrepr.when_type(Text)(xrepr_astyle_text) def streamstyle(stream, styled=None): """ If ``styled`` is ``None``, return whether ``stream`` refers to a terminal. If this can't be determined (either because ``stream`` doesn't refer to a real OS file, or because you're on Windows) return ``False``. If ``styled`` is not ``None`` ``styled`` will be returned unchanged. """ if styled is None: try: styled = os.isatty(stream.fileno()) except (KeyboardInterrupt, SystemExit): raise except Exception: styled = False return styled def write(stream, styled, *texts): """ Write ``texts`` to ``stream``. """ text = Text(*texts) text.write(stream, streamstyle(stream, styled)) def writeln(stream, styled, *texts): """ Write ``texts`` to ``stream`` and finish with a line feed. """ write(stream, styled, *texts) stream.write("\n") class Stream(object): """ Stream wrapper that adds color output. """ class stdout(object): """ Stream wrapper for ``sys.stdout`` that adds color output. """ stdout = stdout() class stderr(object): """ Stream wrapper for ``sys.stderr`` that adds color output. """ stderr = stderr() if curses is not None: # This is probably just range(8) COLOR2CURSES = [ COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE, ] A2CURSES = { A_BLINK: curses.A_BLINK, A_BOLD: curses.A_BOLD, A_DIM: curses.A_DIM, A_REVERSE: curses.A_REVERSE, A_STANDOUT: curses.A_STANDOUT, A_UNDERLINE: curses.A_UNDERLINE, } # default style style_default = Style.fromstr("white:black") # Styles for datatypes style_type_none = Style.fromstr("magenta:black") style_type_bool = Style.fromstr("magenta:black") style_type_number = Style.fromstr("yellow:black") style_type_datetime = Style.fromstr("magenta:black") style_type_type = Style.fromstr("cyan:black") # Style for URLs and file/directory names style_url = Style.fromstr("green:black") style_dir = Style.fromstr("cyan:black") style_file = Style.fromstr("green:black") # Style for ellipsis (when an output has been shortened style_ellisis = Style.fromstr("red:black") # Style for displaying exceptions style_error = Style.fromstr("red:black") # Style for displaying non-existing attributes style_nodata = Style.fromstr("red:black")

""" ``astyle`` provides classes for adding style (foreground and background color; bold; blink; etc.) to terminal and curses output. """ import sys, os try: import curses except ImportError: curses = None COLOR_BLACK = 0 COLOR_RED = 1 COLOR_GREEN = 2 COLOR_YELLOW = 3 COLOR_BLUE = 4 COLOR_MAGENTA = 5 COLOR_CYAN = 6 COLOR_WHITE = 7 A_BLINK = 1<<0 # Blinking text A_BOLD = 1<<1 # Extra bright or bold text A_DIM = 1<<2 # Half bright text A_REVERSE = 1<<3 # Reverse-video text A_STANDOUT = 1<<4 # The best highlighting mode available A_UNDERLINE = 1<<5 # Underlined text class Style(object): """ Store foreground color, background color and attribute (bold, underlined etc.). """ __slots__ = ("fg", "bg", "attrs") COLORNAMES = { "black": COLOR_BLACK, "red": COLOR_RED, "green": COLOR_GREEN, "yellow": COLOR_YELLOW, "blue": COLOR_BLUE, "magenta": COLOR_MAGENTA, "cyan": COLOR_CYAN, "white": COLOR_WHITE, } ATTRNAMES = { "blink": A_BLINK, "bold": A_BOLD, "dim": A_DIM, "reverse": A_REVERSE, "standout": A_STANDOUT, "underline": A_UNDERLINE, } def __init__(self, fg, bg, attrs=0): """ Create a ``Style`` object with ``fg`` as the foreground color, ``bg`` as the background color and ``attrs`` as the attributes. Examples: >>> Style(COLOR_RED, COLOR_BLACK) <Style fg=red bg=black attrs=0> >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE) <Style fg=yellow bg=blue attrs=bold|underline> """ self.fg = fg self.bg = bg self.attrs = attrs def __call__(self, *args): text = Text() for arg in args: if isinstance(arg, Text): text.extend(arg) else: text.append((self, arg)) return text def __eq__(self, other): return self.fg == other.fg and self.bg == other.bg and self.attrs == other.attrs def __neq__(self, other): return self.fg != other.fg or self.bg != other.bg or self.attrs != other.attrs def __repr__(self): color2name = ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white") attrs2name = ("blink", "bold", "dim", "reverse", "standout", "underline") return "<%s fg=%s bg=%s attrs=%s>" % ( self.__class__.__name__, color2name[self.fg], color2name[self.bg], "|".join([attrs2name[b] for b in xrange(6) if self.attrs&(1<<b)]) or 0) def fromstr(cls, value): """ Create a ``Style`` object from a string. The format looks like this: ``"red:black:bold|blink"``. """ # defaults fg = COLOR_WHITE bg = COLOR_BLACK attrs = 0 parts = value.split(":") if len(parts) > 0: fg = cls.COLORNAMES[parts[0].lower()] if len(parts) > 1: bg = cls.COLORNAMES[parts[1].lower()] if len(parts) > 2: for strattr in parts[2].split("|"): attrs |= cls.ATTRNAMES[strattr.lower()] return cls(fg, bg, attrs) fromstr = classmethod(fromstr) def fromenv(cls, name, default): """ Create a ``Style`` from an environment variable named ``name`` (using ``default`` if the environment variable doesn't exist). """ return cls.fromstr(os.environ.get(name, default)) fromenv = classmethod(fromenv) def switchstyle(s1, s2): """ Return the ANSI escape sequence needed to switch from style ``s1`` to style ``s2``. """ attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE) a1 = s1.attrs & attrmask a2 = s2.attrs & attrmask args = [] if s1 != s2: # do we have to get rid of the bold/underline/blink bit? # (can only be done by a reset) # use reset when our target color is the default color # (this is shorter than 37;40) if (a1 & ~a2 or s2==style_default): args.append("0") s1 = style_default a1 = 0 # now we know that old and new color have the same boldness, # or the new color is bold and the old isn't, # i.e. we only might have to switch bold on, not off if not (a1 & A_BOLD) and (a2 & A_BOLD): args.append("1") # Fix underline if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE): args.append("4") # Fix blink if not (a1 & A_BLINK) and (a2 & A_BLINK): args.append("5") # Fix reverse if not (a1 & A_REVERSE) and (a2 & A_REVERSE): args.append("7") # Fix foreground color if s1.fg != s2.fg: args.append("3%d" % s2.fg) # Finally fix the background color if s1.bg != s2.bg: args.append("4%d" % s2.bg) if args: return "\033[%sm" % ";".join(args) return "" class Text(list): """ A colored string. A ``Text`` object is a sequence, the sequence items will be ``(style, string)`` tuples. """ def __init__(self, *args): list.__init__(self) self.append(*args) def __repr__(self): return "%s.%s(%s)" % ( self.__class__.__module__, self.__class__.__name__, list.__repr__(self)[1:-1]) def append(self, *args): for arg in args: if isinstance(arg, Text): self.extend(arg) elif isinstance(arg, tuple): # must be (style, string) list.append(self, arg) elif isinstance(arg, unicode): list.append(self, (style_default, arg)) else: list.append(self, (style_default, str(arg))) def insert(self, index, *args): self[index:index] = Text(*args) def __add__(self, other): new = Text() new.append(self) new.append(other) return new def __iadd__(self, other): self.append(other) return self def format(self, styled=True): """ This generator yields the strings that will make up the final colorized string. """ if styled: oldstyle = style_default for (style, string) in self: if not isinstance(style, (int, long)): switch = switchstyle(oldstyle, style) if switch: yield switch if string: yield string oldstyle = style switch = switchstyle(oldstyle, style_default) if switch: yield switch else: for (style, string) in self: if not isinstance(style, (int, long)): yield string def string(self, styled=True): """ Return the resulting string (with escape sequences, if ``styled`` is true). """ return "".join(self.format(styled)) def __str__(self): """ Return ``self`` as a string (without ANSI escape sequences). """ return self.string(False) def write(self, stream, styled=True): """ Write ``self`` to the output stream ``stream`` (with escape sequences, if ``styled`` is true). """ for part in self.format(styled): stream.write(part) try: import ipipe except ImportError: pass else: def xrepr_astyle_text(self, mode="default"): yield (-1, True) for info in self: yield info ipipe.xrepr.when_type(Text)(xrepr_astyle_text) def streamstyle(stream, styled=None): """ If ``styled`` is ``None``, return whether ``stream`` refers to a terminal. If this can't be determined (either because ``stream`` doesn't refer to a real OS file, or because you're on Windows) return ``False``. If ``styled`` is not ``None`` ``styled`` will be returned unchanged. """ if styled is None: try: styled = os.isatty(stream.fileno()) except (KeyboardInterrupt, SystemExit): raise except Exception: styled = False return styled def write(stream, styled, *texts): """ Write ``texts`` to ``stream``. """ text = Text(*texts) text.write(stream, streamstyle(stream, styled)) def writeln(stream, styled, *texts): """ Write ``texts`` to ``stream`` and finish with a line feed. """ write(stream, styled, *texts) stream.write("\n") class Stream(object): """ Stream wrapper that adds color output. """ def __init__(self, stream, styled=None): self.stream = stream self.styled = streamstyle(stream, styled) def write(self, *texts): write(self.stream, self.styled, *texts) def writeln(self, *texts): writeln(self.stream, self.styled, *texts) def __getattr__(self, name): return getattr(self.stream, name) class stdout(object): """ Stream wrapper for ``sys.stdout`` that adds color output. """ def write(self, *texts): write(sys.stdout, None, *texts) def writeln(self, *texts): writeln(sys.stdout, None, *texts) def __getattr__(self, name): return getattr(sys.stdout, name) stdout = stdout() class stderr(object): """ Stream wrapper for ``sys.stderr`` that adds color output. """ def write(self, *texts): write(sys.stderr, None, *texts) def writeln(self, *texts): writeln(sys.stderr, None, *texts) def __getattr__(self, name): return getattr(sys.stdout, name) stderr = stderr() if curses is not None: # This is probably just range(8) COLOR2CURSES = [ COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE, ] A2CURSES = { A_BLINK: curses.A_BLINK, A_BOLD: curses.A_BOLD, A_DIM: curses.A_DIM, A_REVERSE: curses.A_REVERSE, A_STANDOUT: curses.A_STANDOUT, A_UNDERLINE: curses.A_UNDERLINE, } # default style style_default = Style.fromstr("white:black") # Styles for datatypes style_type_none = Style.fromstr("magenta:black") style_type_bool = Style.fromstr("magenta:black") style_type_number = Style.fromstr("yellow:black") style_type_datetime = Style.fromstr("magenta:black") style_type_type = Style.fromstr("cyan:black") # Style for URLs and file/directory names style_url = Style.fromstr("green:black") style_dir = Style.fromstr("cyan:black") style_file = Style.fromstr("green:black") # Style for ellipsis (when an output has been shortened style_ellisis = Style.fromstr("red:black") # Style for displaying exceptions style_error = Style.fromstr("red:black") # Style for displaying non-existing attributes style_nodata = Style.fromstr("red:black")

0ba81da5ce04ec487462a1396a9e594fbd6ac8ba

py

Python

0000_examples/gelsight/tst.py

Photon26/wrs-main_0614

c0d0e38deac9785e9c382305f65f3ac5f221787d

0000_examples/gelsight/tst.py

Photon26/wrs-main_0614

c0d0e38deac9785e9c382305f65f3ac5f221787d

0000_examples/gelsight/tst.py

Photon26/wrs-main_0614

c0d0e38deac9785e9c382305f65f3ac5f221787d

import pickle import robot_sim.robots.ur3_dual.ur3_dual as ur3d import rbt_con.force_control as ur3dx # import robot_con.ur.ur3_dual_x as ur3dx import visualization.panda.world as wd import modeling.geometric_model as gm import motion.optimization_based.incremental_nik as inik import numpy as np import modeling.collision_model as cm import cv2 import img_to_depth as itd import time import motion.probabilistic.rrt_connect as rrtc ur_dual_x = ur3dx.UR3DualX(lft_robot_ip='10.2.0.50', rgt_robot_ip='10.2.0.51', pc_ip='10.2.0.100') base = wd.World(cam_pos=[2,1,3], lookat_pos=[0,0,1.1]) gm.gen_frame().attach_to(base) robot_s = ur3d.UR3Dual() jnt = ur_dual_x.get_jnt_values("lft_arm") robot_s.fk(component_name="lft_arm",jnt_values= np.array(jnt)) robot_meshmodel = robot_s.gen_meshmodel(toggle_tcpcs=True) robot_meshmodel.attach_to(base) base.run()

import pickle import robot_sim.robots.ur3_dual.ur3_dual as ur3d import rbt_con.force_control as ur3dx # import robot_con.ur.ur3_dual_x as ur3dx import visualization.panda.world as wd import modeling.geometric_model as gm import motion.optimization_based.incremental_nik as inik import numpy as np import modeling.collision_model as cm import cv2 import img_to_depth as itd import time import motion.probabilistic.rrt_connect as rrtc ur_dual_x = ur3dx.UR3DualX(lft_robot_ip='10.2.0.50', rgt_robot_ip='10.2.0.51', pc_ip='10.2.0.100') base = wd.World(cam_pos=[2,1,3], lookat_pos=[0,0,1.1]) gm.gen_frame().attach_to(base) robot_s = ur3d.UR3Dual() jnt = ur_dual_x.get_jnt_values("lft_arm") robot_s.fk(component_name="lft_arm",jnt_values= np.array(jnt)) robot_meshmodel = robot_s.gen_meshmodel(toggle_tcpcs=True) robot_meshmodel.attach_to(base) base.run()

3fd17c06364dbbcfbf61a1c852f8a863c6286b83

py

Python

galaxy_model/spiral_arms/three_kpc.py

K-Monty/galaxy-model

9515d7c87c31e68338466d2044d8e9c679bf8648

galaxy_model/spiral_arms/three_kpc.py

K-Monty/galaxy-model

9515d7c87c31e68338466d2044d8e9c679bf8648

galaxy_model/spiral_arms/three_kpc.py

K-Monty/galaxy-model

9515d7c87c31e68338466d2044d8e9c679bf8648

""" This module use SpiralArm superclass, with some modifications, to create 3-kpc arm. """ from shapely.geometry.polygon import Polygon from descartes import PolygonPatch from .spiral_parameters import Three_Kpc from . import spiral_property as spiral_eq from .spiral_arm_superclass import SpiralArm

""" This module use SpiralArm superclass, with some modifications, to create 3-kpc arm. """ from shapely.geometry.polygon import Polygon from descartes import PolygonPatch from .spiral_parameters import Three_Kpc from . import spiral_property as spiral_eq from .spiral_arm_superclass import SpiralArm class ThreeKpcArm(SpiralArm): def __init__(self): self.params = Three_Kpc self._color = 'yellow' self.tuning_window = 3 self._spine_r_kpc, self.x_spine, self.y_spine, self._B_spine, \ self._width_kpc = \ self.spine_radii_coords_b_range_and_width_with_smoothing() self._poly_coords_inner, self._poly_coords_outer = self._poly_coords() self._polygon_near = Polygon(self._poly_coords_inner) self._polygon_far = Polygon(self._poly_coords_outer) self.polypatch_near = PolygonPatch(self._polygon_near, color=self._color, alpha=0.2) self.polypatch_far = PolygonPatch(self._polygon_far, color=self._color, alpha=0.2) def __repr__(self): return "ThreeKpc" def _radii_factory(self, B): return self._spine_radius_at_B_and_psi( B, self.params['B-kink'], self.params['psi'], self.params['R-kink']) def _width_factory(self, B, r): return spiral_eq.CylinderSize.width_kpc( self.params['w-kink'], r, self.params['R-kink']) + 0.1 def spine_radii_coords_b_range_and_width_with_smoothing(self): r_spine_near = [] x_spine_near = [] y_spine_near = [] width_kpc_near = [] B_list_near = [x for x in range(self.params['B-begin-near'], self.params['B-end-near'])] r_spine_far = [] x_spine_far = [] y_spine_far = [] width_kpc_far = [] B_list_far = [x for x in range(self.params['B-begin-far'], self.params['B-end-far'])] for B_near in B_list_near: r_near = self._radii_factory(B_near) w_near = self._width_factory(B_near, r_near) r_spine_near.append(r_near) width_kpc_near.append(w_near) for B_far in B_list_far: r_far = self._radii_factory(B_far) w_far = self._width_factory(B_far, r_far) r_spine_far.append(r_far) width_kpc_far.append(w_far) for B_near, r_near in zip(B_list_near, r_spine_near): cartesian_coords = spiral_eq.polar_to_cartesian(r_near, B_near) x_spine_near.append(cartesian_coords[0]) y_spine_near.append(cartesian_coords[1]) for B_far, r_far in zip(B_list_far, r_spine_far): cartesian_coords = spiral_eq.polar_to_cartesian(r_far, B_far) x_spine_far.append(cartesian_coords[0]) y_spine_far.append(cartesian_coords[1]) r_spine = [r_spine_near, r_spine_far] x_spine = [x_spine_near, x_spine_far] y_spine = [y_spine_near, y_spine_far] B_list = [B_list_near, B_list_far] width_kpc = [width_kpc_near, width_kpc_far] return (r_spine, x_spine, y_spine, B_list, width_kpc) def _poly_coords(self): x_border_inner_near, y_border_inner_near, x_border_outer_near, \ y_border_outer_near = \ self._border_coords(self.x_spine[0], self.y_spine[0], self._B_spine[0], self._width_kpc[0]) x_border_inner_far, y_border_inner_far, x_border_outer_far, \ y_border_outer_far = \ self._border_coords(self.x_spine[1], self.y_spine[1], self._B_spine[1], self._width_kpc[1]) x_poly_edge_coords_near = x_border_inner_near \ + x_border_outer_near[::-1] y_poly_edge_coords_near = y_border_inner_near \ + y_border_outer_near[::-1] poly_edge_coords_near = [xy for xy in zip(x_poly_edge_coords_near, y_poly_edge_coords_near)] x_poly_edge_coords_far = x_border_inner_far + x_border_outer_far[::-1] y_poly_edge_coords_far = y_border_inner_far + y_border_outer_far[::-1] poly_edge_coords_far = [xy for xy in zip(x_poly_edge_coords_far, y_poly_edge_coords_far)] return poly_edge_coords_near, poly_edge_coords_far

dbeff05f1c61b09708b8a95665c71d6764ac49fd

py

Python

rbi/rbi_budgets_scraper.py

cbgaindia/scrappers

f8aab1d0f0a52007d8f0ab94e7ea38047e6e46a9

rbi/rbi_budgets_scraper.py

cbgaindia/scrappers

f8aab1d0f0a52007d8f0ab94e7ea38047e6e46a9

rbi/rbi_budgets_scraper.py

cbgaindia/scrappers

f8aab1d0f0a52007d8f0ab94e7ea38047e6e46a9

'Code for scrapping RBI Data' from datetime import date from lxml import etree import logging from logging.config import fileConfig from scrappers.scrapping_utils import ScrappingUtils fileConfig('scrappers/logging_config.ini') logger = logging.getLogger() OUT_FOLDER = "rbi" if __name__ == '__main__': obj = RBIBudgetScraper() for year in range(2002,2015): year = str(year) url1 = "https://www.rbi.org.in/scripts/AnnualPublications.aspx?head=Handbook%20of%20Statistics%20on%20Indian%20Economy" url2 = "https://rbi.org.in/Scripts/AnnualPublications.aspx?head=State+Finances+%3a+A+Study+of+Budgets" obj.fetch_docs_for_year(url1, year) obj.fetch_docs_for_year(url2, year)

'Code for scrapping RBI Data' from datetime import date from lxml import etree import logging from logging.config import fileConfig from scrappers.scrapping_utils import ScrappingUtils fileConfig('scrappers/logging_config.ini') logger = logging.getLogger() OUT_FOLDER = "rbi" class RBIBudgetScraper(ScrappingUtils): def fetch_docs_for_year(self, url, year=None): '''Fetches all documents for a budget year ''' if not year: current_year = date.today().year year = "%s" % (current_year) page_dom = self.get_page_dom(url) title = self.get_text_from_element(page_dom, xpath="//h2[@class='page_title']/text()") download_dir = "%s/%s/%s" % (OUT_FOLDER, year, title) file_dir = download_dir for node in page_dom.xpath("//table[@class='tablebg']/tr"): node_title = self.get_text_from_element(node, xpath="./td[@class='tableheader']//text()") if node_title: file_dir = "%s/%s" % (download_dir, node_title) continue node_title = self.get_text_from_element(node, xpath="./td[@style]//text()") file_path = "%s/%s" % (file_dir, node_title) file_link = node.xpath("./td[2]/a[@target]/@href") if file_link: self.fetch_and_save_file(file_link[0].replace('http://', 'https://'), file_path + ".xls") file_link = node.xpath("./td[3]/a[@target]/@href") if file_link: self.fetch_and_save_file(file_link[0].replace('http://', 'https://'), file_path + ".pdf") if __name__ == '__main__': obj = RBIBudgetScraper() for year in range(2002,2015): year = str(year) url1 = "https://www.rbi.org.in/scripts/AnnualPublications.aspx?head=Handbook%20of%20Statistics%20on%20Indian%20Economy" url2 = "https://rbi.org.in/Scripts/AnnualPublications.aspx?head=State+Finances+%3a+A+Study+of+Budgets" obj.fetch_docs_for_year(url1, year) obj.fetch_docs_for_year(url2, year)

30b7600879ed7470a3a4e7671d503041ddaee708

py

Python

0x11-python-network_1/2-post_email.py

Nahi-Terefe/alx-higher_level_programming

c67a78a6f79e853918963971f8352979e7691541

0x11-python-network_1/2-post_email.py

Nahi-Terefe/alx-higher_level_programming

c67a78a6f79e853918963971f8352979e7691541

0x11-python-network_1/2-post_email.py

Nahi-Terefe/alx-higher_level_programming

c67a78a6f79e853918963971f8352979e7691541

#!/usr/bin/python3 """ post email """ import urllib.request import urllib.parse import sys if __name__ == "__main__": value = {'email': sys.argv[2]} data = urllib.parse.urlencode(value) data = data.encode('utf-8') req = urllib.request.Request(sys.argv[1], data) with urllib.request.urlopen(req) as response: res = response.read().decode(encoding='UTF-8') print(res)

#!/usr/bin/python3 """ post email """ import urllib.request import urllib.parse import sys if __name__ == "__main__": value = {'email': sys.argv[2]} data = urllib.parse.urlencode(value) data = data.encode('utf-8') req = urllib.request.Request(sys.argv[1], data) with urllib.request.urlopen(req) as response: res = response.read().decode(encoding='UTF-8') print(res)

98dd68e4820e061630336d4d9dc6896eb5df6fb1

py

Python

modules/selection.py

psp-codes/reduced-decoy-ensemble

096926d8d44a6d7bdbf9c49dd52fb83ff86e8b3f

2020-04-22T04:16:03.000Z

2020-08-19T13:50:20.000Z

modules/selection.py

psp-codes/reduced-decoy-ensemble

096926d8d44a6d7bdbf9c49dd52fb83ff86e8b3f

modules/selection.py

psp-codes/reduced-decoy-ensemble

096926d8d44a6d7bdbf9c49dd52fb83ff86e8b3f

2020-08-19T13:50:26.000Z

2020-08-19T13:50:26.000Z

# selection.py # since: 10/2018 # Developed by: Shehu Lab """Module for selecting next generation from current generation. This module provides methods to select next generation from current generation. Available Functions: - truncation: Selects next generation via elitism truncation selection. """ def truncation(parent_population, child_population, parents_scores, children_scores, elitism_rate): """Selects next generation using elitism truncation selection. This function implements truncation selection while ensuring elitism to select a specific number of members for the next generation. Args: parent_population: A list containing members of parent population. child_population: A list containing members of offspring population. parents_scores: A list containing scores of each member of the parent population. The format is: [member 1 score, member 2 score, ....] The order of members has to be consistent with parent_population argument. children_scores: A list containing scores of each member of the offspring population. The format is: [member 1 score, member 2 score, ....] The order of members has to be consistent with child_population argument. elitism_rate: A float indicating the elitism percentage. Returns: A list of members for the next generation of population. """ population_size = len(parent_population) population_indices = list(range(population_size)) sorted_parents_indices = [x for _, x in sorted(zip( parents_scores, population_indices ))] sorted_parents_scores = sorted(parents_scores) # Slice parent population using elitism rate slice_index = int(population_size * elitism_rate) selected_parents_indices = sorted_parents_indices[:slice_index] selected_parents = [parent_population[i] for i in selected_parents_indices] combined_population = selected_parents + child_population combined_scores = sorted_parents_scores[:slice_index] + children_scores combined_population_indices = list(range(len(combined_population))) sorted_population_indices = [x for _, x in sorted(zip( combined_scores, combined_population_indices ))] selected_population_indices = sorted_population_indices[:population_size] # Truncate and return return [combined_population[i] for i in selected_population_indices]

# selection.py # since: 10/2018 # Developed by: Shehu Lab """Module for selecting next generation from current generation. This module provides methods to select next generation from current generation. Available Functions: - truncation: Selects next generation via elitism truncation selection. """ def truncation(parent_population, child_population, parents_scores, children_scores, elitism_rate): """Selects next generation using elitism truncation selection. This function implements truncation selection while ensuring elitism to select a specific number of members for the next generation. Args: parent_population: A list containing members of parent population. child_population: A list containing members of offspring population. parents_scores: A list containing scores of each member of the parent population. The format is: [member 1 score, member 2 score, ....] The order of members has to be consistent with parent_population argument. children_scores: A list containing scores of each member of the offspring population. The format is: [member 1 score, member 2 score, ....] The order of members has to be consistent with child_population argument. elitism_rate: A float indicating the elitism percentage. Returns: A list of members for the next generation of population. """ population_size = len(parent_population) population_indices = list(range(population_size)) sorted_parents_indices = [x for _, x in sorted(zip( parents_scores, population_indices ))] sorted_parents_scores = sorted(parents_scores) # Slice parent population using elitism rate slice_index = int(population_size * elitism_rate) selected_parents_indices = sorted_parents_indices[:slice_index] selected_parents = [parent_population[i] for i in selected_parents_indices] combined_population = selected_parents + child_population combined_scores = sorted_parents_scores[:slice_index] + children_scores combined_population_indices = list(range(len(combined_population))) sorted_population_indices = [x for _, x in sorted(zip( combined_scores, combined_population_indices ))] selected_population_indices = sorted_population_indices[:population_size] # Truncate and return return [combined_population[i] for i in selected_population_indices]

3f46e12fb5d861255b9732050d691bdff492592b

py

Python

Desafios/desafio030.py

VanessaCML/python

56133b9000ba89154f37038e11a3c2d1aa6d1094

Desafios/desafio030.py

VanessaCML/python

56133b9000ba89154f37038e11a3c2d1aa6d1094

Desafios/desafio030.py

VanessaCML/python

56133b9000ba89154f37038e11a3c2d1aa6d1094

n = int(input('Digite um número: ')) if n % 2 == 0: print(f'O número {n} é par.') else: print(f'O número {n} é ímpar.')