def __new__(self, operator, context, pipe, thickness): split = random_integer(1, 100) < operator.split rail = random_integer(1, 100) < operator.split if not split else False pipe_profile = create.curve(operator, context, pipe.name+'-profile') self.pipe(operator, context, pipe_profile, split, rail) self.set_dimensions(operator, pipe_profile, thickness) return pipe_profile
def rand_cells(self, x, y, l):
for a in range(x):
for b in range(y):
r = random_integer(0, 100)
s = random_integer(0, 100)
if r > s:
v = 1
else:
v = 0
l[str((a, b))] = cell(self.world, (a, b), v).channel
return l
def send(self, recipient, message):
# Send to IRC first
recipient.receive(self.mind, recipient, message)
message = message.get('text', '')
if message.startswith('\x01ACTION '):
message = message.replace('ACTION ', '', 1).replace('\x01', '_')
channel_id = None
if isinstance(recipient, Group):
server = self.mind.get_guild(self.server_id)
for chan in server.channels:
irc_chan_name = chan.name.replace(' ', '_')
if irc_chan_name == recipient.name:
channel_id = chan.id
url = 'https://discordapp.com/api/channels/{0}/messages'.format(channel_id)
nonce = random_integer(-2**63, 2**63 - 1)
payload = {
'content': unicode(message),
'nonce': nonce
}
self._sent_nonces.append(unicode(nonce))
return chord.http_post(url, self.credentials.token, payload)
def random_element(l):
"""
returns random element in list l
"""
if l:
index = random_integer(0, len(l) - 1)
return l[index]
return 'empty list'
def random_element(l):
"""
returns random element in list l
"""
print('in random_element', combined)
if l:
index = random_integer(0, len(l) - 1)
return l[index]
return 'empty list'
def __new__(self, ot, context, pipe, thickness):
split = random_integer(1, 100) <= ot.split
pipe_profile = create.curve(ot, context, pipe.name + '-profile')
self.pipe(ot, context, pipe_profile, split, thickness)
self.set_dimensions(ot, pipe_profile, thickness)
return pipe_profile
def __init__(self, pipe_profile):
spline1 = pipe_profile.data.splines.new('BEZIER')
spline1.use_cyclic_u = True
spline2 = pipe_profile.data.splines.new('BEZIER')
spline2.use_cyclic_u = True
type = ['type1', 'type2', 'type3']
getattr(self,
type[random_integer(0, 2)])(pipe_profile,
spline1, spline2)
def send_message(self, channel_id, content, *, guild_id=None, tts=False):
url = '{0.CHANNELS}/{1}/messages'.format(self, channel_id)
payload = {
'content': str(content),
'nonce': random_integer(-2**63, 2**63 - 1)
}
if tts:
payload['tts'] = True
return self.post(url, json=payload, bucket='messages:' + str(guild_id))
def send_message(self, channel_id, content, *, guild_id=None, tts=False):
url = '{0.CHANNELS}/{1}/messages'.format(self, channel_id)
payload = {
'content': str(content),
'nonce': random_integer(-2**63, 2**63 - 1)
}
if tts:
payload['tts'] = True
return self.post(url, json=payload, bucket='messages:' + str(guild_id))
def __init__(self, ot, context, pipe, index, thickness):
spline = pipe.data.splines.new('POLY')
is_straight_pipe = random_integer(1, 100) <= ot.straight
self.depth(ot, context, pipe, ot.depth * 0.5, index, thickness)
if is_straight_pipe:
self.straight(ot, pipe, spline, thickness)
else:
self.bent(ot, context, pipe, spline, thickness)
self.align_profile(ot, context, pipe)
def __init__(self, operator, context, pipe, index, thickness):
spline = pipe.data.splines.new('POLY')
is_straight_pipe = random_integer(1, 100) < operator.straight
self.depth(operator, context, pipe, operator.depth * 0.5, index, thickness)
if is_straight_pipe:
self.straight(operator, pipe, spline, thickness)
else:
self.bent(operator, context, pipe, spline, thickness)
self.align_profile(context, pipe)
def send_message(self, user=None, message=None, channel=None):
""" Todo """
self.logger.info("sending message to %s: %s", user, message)
cid = channel
if not cid:
for cid in self.channels:
if str(self.channels[cid]) == str(user):
channel = cid
self.logger.debug(cid)
if (channel):
self.post(
'channels/' + cid + '/messages',
json.dumps({
'content': message,
'nonce': random_integer(-2**63, 2**63 - 1)
}))
else:
logger.error("Unknown user %s", user)
def send_message(self,
channel_id,
content,
*,
guild_id=None,
tts=False,
embed=None):
r = Route('POST',
'/channels/{channel_id}/messages',
channel_id=channel_id)
payload = {'nonce': random_integer(-2**63, 2**63 - 1)}
if content:
payload['content'] = content
if tts:
payload['tts'] = True
if embed:
payload['embed'] = embed
return self.request(r, json=payload)
# modules ============================= print(__name__) import math print(math.sqrt(4)) import random print(random.randint(1, 10)) from random import randint print(randint(1, 10)) from random import randint as random_integer print(random_integer(1, 10)) import lab03_grading print(lab03_grading.number_grade_to_letter_grade(87)) from lab03_grading import number_grade_to_letter_grade print(number_grade_to_letter_grade(87)) # __name__ is a special variable you can access inside a module # if the user ran the module, the value of __name__ will be __main__ # if the user imported the module, the value of __name__ will be the name of the module # this allows you to only run certain code when the module itself is being run and not when it's imported # comparisons ============================= x = 1
def __init__(self, operator, context, pipe, spline, thickness):
pipe_corners = self.get_corners(operator, context, pipe,
spline, thickness)
is_beveled = random_integer(
1, 100) <= operator.bevel and operator.bevel_size > 0
if is_beveled:
for index, point in enumerate(pipe_corners):
if index == 0:
create.point(spline, point)
elif index != len(pipe_corners) - 1:
if point[2]:
length_x = abs(point[0] -
pipe_corners[index + 1][0])
length_y = abs(pipe_corners[index - 1][1] -
point[1])
if min((length_x,
length_y)) * (operator.bevel_size *
0.01) > thickness * 0.5:
offset_y = -min((length_x, length_y)) * (
operator.bevel_size * 0.01)
offset_x = offset_y if point[
3] else -offset_y
create.point(spline,
point,
offset_y=offset_y)
create.point(spline,
point,
offset_x=offset_x)
point[0] += offset_x
else:
create.point(spline, point)
else:
length_x = abs(pipe_corners[index - 1][0] -
point[0])
length_y = abs(point[1] -
pipe_corners[index + 1][1])
if min((length_x,
length_y)) * (operator.bevel_size *
0.01) > thickness * 0.5:
offset_y = min((length_x, length_y)) * (
operator.bevel_size * 0.01)
offset_x = offset_y if point[
3] else -offset_y
create.point(spline,
point,
offset_x=offset_x)
create.point(spline,
point,
offset_y=offset_y)
point[1] += offset_y
else:
create.point(spline, point)
else:
create.point(spline, point)
else:
for point in pipe_corners:
create.point(spline, point)
def __init__(self, operator, context, pipe, spline, thickness): pipe_corners = self.get_corners(operator, context, pipe, spline, thickness) is_beveled = random_integer(1, 100) < operator.bevel if is_beveled: for index, point in enumerate(pipe_corners): if index == 0: create.point(spline, point) elif index != len(pipe_corners) - 1: if point[2]: length_x = abs(point[0] - pipe_corners[index + 1][0]) length_y = abs(pipe_corners[index - 1][1] - point[1]) if min((length_x, length_y)) * 0.25 > thickness: offset_y = -min((length_x, length_y)) * 0.25 offset_x = offset_y if point[3] else -offset_y create.point(spline, point, offset_y=offset_y) create.point(spline, point, offset_x=offset_x) point[0] += offset_x else: create.point(spline, point) else: length_x = abs(pipe_corners[index - 1][0] - point[0]) length_y = abs(point[1] - pipe_corners[index + 1][1]) if min((length_x, length_y)) * 0.25 > thickness: offset_y = min((length_x, length_y)) * 0.25 offset_x = offset_y if point[3] else -offset_y create.point(spline, point, offset_x=offset_x) create.point(spline, point, offset_y=offset_y) point[1] += offset_y else: create.point(spline, point) else: create.point(spline, point) else: for point in pipe_corners: create.point(spline, point)
def __init__(self, pipe_profile, type=None):
type = ['single', 'double'][random_integer(
0, 1)] if not type else type
getattr(self, type)(pipe_profile)
from random import randint as random_integer
# random.randint(A, B) generates a random integer number N, A ? N ? B.
ny = int(input('Please, enter number of rows: '))
nx = int(input('Please, enter number of columns: '))
rand_min = int(input('Let us define the range of your random numbers. '
'Enter minimual possible number: '))
rand_max = int(input('Enter maximual possible number: '))
# Generation of random matrix
a = []
for i in range(0,ny):
row = []
for j in range(0,nx):
element_ij = random_integer(rand_min, rand_max)
row.append(element_ij)
a.append(row)
if nx and ny < 7:
print(str(a)) # Print matrix.
fate = int(input('Enter the specific integer number '
'and I delete all rows that contain it. Your choice: '))
# Identification 'fatal' rows which contain the specific number.
fatal_columns_indices = []
for i in range(0,ny):
row_susp = a[i]
print(str(row_susp))
for j in range(0,nx):
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Start Manager (shares plane between processes)
from multiprocessing import Process, Manager, Pipe, Array
recv, send = Pipe(False)
# Make up some things to simulate
from Physics import Particle
from random import randint as random_integer
# Some config width height settings
width = 1000
height = 1000
particle_amount = 5
random_plane = [Particle(X_position=random_integer(0, width), Y_position=random_integer(0, height), X_velocity=random_integer(-500, 500), Y_velocity=random_integer(-500, 500)) for count in range(particle_amount)]
logger.info('Created plane with %s particles', particle_amount)
# Start the display
import pygame
from pygame.locals import *
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode((width, height))
# Initialise the physics stuff
from Physics import World
Jacks_sweet_thread = World(random_plane, send)
from timeit import default_timer as current_time
from multiprocessing import Process, Pool
def random_number():
""" Generates a random number between 2 and 12 """
return random_integer(1, 6) + random_integer(1, 6)
print('Creating shared memory')
# Create particles in shared memory
from multiprocessing import RawArray
from numpy import frombuffer
particle_list_flat = RawArray('d', number_of_particles * number_of_axes * number_of_properties)
particle_list = frombuffer(particle_list_flat, dtype='d').reshape((number_of_particles, number_of_axes, number_of_properties))
print('Setting initial values')
# Set initial property values
from random import randint as random_integer
if placement is 'vortex':
for particle in particle_list:
poop = random_integer(0,height - 1)
for axis_index, axis in enumerate(axes):
# Randomise position
particle[axis_index][i['position']] = poop
particle[i['y']][i['velocity']] = -2 * (particle[i['y']][i['position']] - width/2)
particle[i['x']][i['velocity']] = 2* (particle[i['x']][i['position']] - height/2)
elif placement is 'normal':
for particle in particle_list:
# Set acceleration
particle[i['y']][i['acceleration']] = 100
for axis_index, axis in enumerate(axes):
# Randomise position
particle[axis_index][i['position']] = random_integer(0,axes_size[axis_index] - 1)
# Randomise velocity
particle[axis_index][i['velocity']] = random_integer(-1000000,1000000)/10000
print(f'- {toping}')
make_pizza(30, 'cheese')
make_pizza(40, 'cheese', 'ham', 'mushrooms')
#passing key-value arguments - ** double stars (kwargs)
def build_profile(first, last, **user_info):
user_info['first_name'] = first
user_info['last_name'] = last
return user_info
user_profile = build_profile('paul', 'pelar', location='cieszyn', age='22')
print(user_profile)
#empty
def build_profile(**user_info):
return user_info
user_profile = build_profile(location='cieszyn', age='22', first_name='paul')
print(user_profile)
#modules
from random import randint as random_integer #can change names of functions
print(random_integer(69, 70))
