def load_line(self, line):
"""
data_id|group_name
"""
try:
parts = line.split(' -> ')
manufactured_component_str = parts[0].strip()
manufactured_component_str_parts = manufactured_component_str.split('|')
manufactured_type_id = int(manufactured_component_str_parts[0])
manufactured_type_name = manufactured_component_str_parts[1]
manufactured_group_id = int(manufactured_component_str_parts[2])
manufactured_component = Component(manufactured_type_name, manufactured_type_id, group_id=manufactured_group_id)
component_parts = parts[1].strip().split(' ')
for component_str in component_parts:
component_str_parts = component_str.split('|')
component_type_id = int(component_str_parts[0])
component_amount = float(component_str_parts[1])
manufactured_component.components[component_type_id] = Component("", component_type_id, component_amount)
self.data[manufactured_type_id] = manufactured_component
except Exception, e:
print "Load line failed on '" + line + "': " + str(e)
def __init__(self, *args, **kwds):
Component.__init__(self, *args, **kwds)
self.log("Active_tag", "initializing component", self.data.level)
# Set up data structures
self.tags = {}
self.scan_tags()
self.generated = False
def __init__(self, *args, **kwds):
Component.__init__(self, *args, **kwds)
self.siteroot = "http://masenf.com"
self.rsstitle = "masenf.com > blog"
self.rssfile = "output/feed.rss"
self.rsspath = "/feed.rss"
self.NUM_POSTS = 20
self.PREVIEW_CHARS = 256
self.output_rss(self.rssfile)
def __init__(self, *args, **kwds):
Component.__init__(self, *args, **kwds)
# add predefined rewrites
self.rewrites = { '/?' : ('/home.html',''),
'blog/?' : ('/blog.html','[R]'),
'blog/tag/([\ a-zA-Z]+)' : ('/blog/tag/$1.html','[R]'),
'blog/archive/([0-9]{4})-([0-9]{2})/?' : ('/blog/archive/$1-$2.html','[R]'),
'blog/rss2/?' : ('/feed.rss','[R]') }
self.index_permalinks()
self.write_htaccess()
def __init__ (self, locations):
operations.Operation.__init__ (self)
Component.__init__ (self, None)
self.savePlaylist = SavePlaylistRegistry (self)
self.locations = locations
self.__preferences = RecordingPreferences (locations)
self.__running_ops = []
self._music_file_patterns = {}
self._playlist_file_patterns = {}
self._music_file_filters = None
self._playlist_file_filters = None
self.register_music_file_pattern ("MPEG Audio Stream, Layer III", "*.mp3")
self.register_music_file_pattern ("Ogg Vorbis Codec Compressed WAV File", "*.ogg")
self.register_music_file_pattern ("Free Lossless Audio Codec", "*.flac")
self.register_music_file_pattern ("PCM Wave audio", "*.wav")
def __init__ (self, locations):
operations.Operation.__init__ (self)
Component.__init__ (self, None)
self.savePlaylist = SavePlaylistRegistry (self)
self.locations = locations
self.__preferences = RecordingPreferences (locations)
self.__running_ops = []
self._music_file_patterns = {}
self._playlist_file_patterns = {}
self._music_file_filters = None
self._playlist_file_filters = None
self.register_music_file_pattern ("MPEG Audio Stream, Layer III", "*.mp3")
self.register_music_file_pattern ("Ogg Vorbis Codec Compressed WAV File", "*.ogg")
self.register_music_file_pattern ("Free Lossless Audio Codec", "*.flac")
self.register_music_file_pattern ("PCM Wave audio", "*.wav")
def do_create(self, arg):
"""\nCreate a new component.
create [name=<string>] [version=<string>] [category=<string>]
name = new component name. Default = New Component.
version = component version. Default = 1.0.
category = component category. Default = User Component.
"""
args = CREATION_ARGS.parse(arg)
if args:
comp = Component()
comp.name = args.name
comp.version = args.version
comp.category = args.category
self.write("New component created.\n")
settings.active_component = comp
else:
self.stdout.write("*** Arguments extraction error, creation canceled.\n")
def dfs(self, start_node: Node, a_component: Component) -> None:
self.set_discovered(start_node)
# if protein, get a peptide list, if peptide get a protein list
neighbour_list = self.node_dict.get(start_node)
# for all neighbouring white node that is not deleted, explore them
for current_neighbour in neighbour_list:
if self.is_white(current_neighbour) \
and (current_neighbour.get_first_id()
not in self.node_to_delete):
self.dfs(current_neighbour, a_component)
self.set_explored(start_node)
# after the nodes are blacken,
# add the protein or peptide into the a_component
# with its neighbours
if isinstance(start_node, Protein):
a_component.add_protein(start_node, neighbour_list)
elif isinstance(start_node, Peptide):
a_component.add_peptide(start_node, neighbour_list)
def separate(protein_peptide_graph: Graph) -> List[Component]:
# for all white peptide nodes, explore them
component_list = []
for node in protein_peptide_graph.node_dict.keys():
# if it is white and not deleted
if protein_peptide_graph.is_white(node) and \
node.get_first_id() not in protein_peptide_graph.node_to_delete:
a_component = Component()
protein_peptide_graph.dfs(node, a_component)
component_list.append(a_component)
print("separated")
return component_list
def connected_components_segmentation(intermediate_global_mask):
"""
:param intermediate_global_mask: black and white image
:return: components
"""
_, labeled_img = cv2.connectedComponentsWithAlgorithm(
intermediate_global_mask, 8, cv2.CV_32S, cv2.CCL_GRANA)
labels = np.unique(labeled_img)
labels = labels[labels != 0]
components = []
for label in labels:
mask = np.zeros_like(labeled_img, dtype=np.uint8)
mask[labeled_img == label] = 255
# Compute the convex hull
if get_opencv_major_version(cv2.__version__) in ['2', '3']:
mask, contours, _ = cv2.findContours(mask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
else:
contours, _ = cv2.findContours(mask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
hull = []
for cnt in contours:
hull.append(cv2.convexHull(cnt, False))
hull_mask = np.zeros((mask.shape[0], mask.shape[1]), dtype=np.uint8)
for i in range(len(contours)):
hull_mask = cv2.drawContours(hull_mask, hull, i, 255, -1, 8)
single_component, flag = draw_border_for_picture_parts(hull_mask)
_, connected_component, stats, _ = cv2.connectedComponentsWithStatsWithAlgorithm(
single_component, 8, cv2.CV_32S, cv2.CCL_GRANA)
valid_labels = np.argwhere(
stats[:, cv2.CC_STAT_AREA] >= LABEL_AREA_THRESHOLD)
if valid_labels[0] == 0:
valid_labels = valid_labels[1:]
for valid_label in valid_labels:
component = Component(valid_label, connected_component,
stats[valid_label], flag)
components.append(component)
components.sort(key=lambda x: x.area, reverse=True)
return components
def __init__(self, board, network, scheduler):
self.board = board
self.scheduler = scheduler
self.parts_initialized = False
self.mac = network.mac
self.data = {}
self.mine = None
self.version = "0.8.0"
self.listeners = []
self.read_cache()
# if (type(self.mine) is dict and "parts" in self.mine):
# ct.print_heading("initializing from cache")
# Part.init_parts(board, scheduler, self.mine["parts"])
Component.setup_services(board, scheduler)
if (type(self.mine) is dict and "components" in self.mine):
ct.print_heading("initializing from cache")
Component.netlist_from_config(self.mine["components"])
Component.print_netlist()
MQTT.subscribe(config_topic_base + self.mac + "/config", self.on_mqtt)
def __init__(self, *args, **kwds):
Component.__init__(self, *args, **kwds)
self.PREVIEW_CHARS = 512
self.TEMPLATE = "post-short.tmpl.html"
self.NUM_POSTS = 10
import os
import sys
sys.path.append("../")
from components import addComponent, Component
# Add components in order of dependency.
addComponent(
Component(name="jsoncpp",
srcDir=os.environ["SOURCE_DIR"] + "/../3rd_party/jsoncpp"))
addComponent(Component(name="Logger", runTestsCmd="./LoggerTest"))
addComponent(Component(name="misc", runTestsCmd="./misctest"))
addComponent(
Component(name="GlobalConfiguration",
runTestsCmd="./GlobalConfigurationTest"))
addComponent(
Component(name="ParkingDatabase", runTestsCmd="./ParkingDatabaseTest"))
addComponent(Component(name="CloudService", runTestsCmd="./CloudServiceTest"))
addComponent(Component(name="PriceProvider",
runTestsCmd="./PriceProviderTest"))
addComponent(Component(name="VerifyParking",
runTestsCmd="./VerifyParkingTest"))
addComponent(Component(name="BLEService", runTestsCmd="./BLEServiceTest"))
def load_game(self):
back = "./Dominion/card_back.png"
path = lambda name: f"./Dominion/{name}.png"
for i in range(60):
component = Component(65, 95, front=path("copper"), back=back)
component.order = i
self.public_components.append(component)
for i in range(40):
component = Component(190, 95, front=path("silver"), back=back)
component.order = i
self.public_components.append(component)
for i in range(30):
component = Component(315, 95, front=path("gold"), back=back)
component.order = i
self.public_components.append(component)
for i in range(8):
component = Component(65, 280, front=path("estate"), back=back)
component.order = i
self.public_components.append(component)
for i in range(8):
component = Component(190, 280, front=path("duchy"), back=back)
component.order = i
self.public_components.append(component)
for i in range(8):
component = Component(315, 280, front=path("province"), back=back)
component.order = i
self.public_components.append(component)
for i in range(10):
component = Component(65, 465, front=path("curse"), back=back)
component.order = i
self.public_components.append(component)
component = Component(315, 465, front=path("trash"), back=back)
component.order = 0
self.public_components.append(component)
import sys
import os
sys.path.append("../")
from components import addComponent, Component
addComponent(
Component(name="sqlite3",
srcDir=os.environ["SOURCE_DIR"] + "/../3rd_party/sqlite3/src"))
from common_components import *
# Intel Edison specific components here:
import urllib.parse
import json
from auth import *
from modules import *
warnings.filterwarnings("ignore")
def urlencode(str):
return urllib.parse.quote(str)
def urldecode(str):
return urllib.parse.unquote(str)
if __name__=='__main__':
autho = tweepy.OAuthHandler(user[0], user[1])
autho.set_access_token(user[2], user[3])
api = tweepy.API(autho)
co = Component(api)
lines = sys.argv[0]
lines = urldecode(lines)
lines = lines.encode('utf-8').decode()
tweets = co.search(query=lines,count=10)
an= co.analysis(tweets)
print(json.dumps(an))
def urlencode(str):
return urllib.parse.quote(str)
def urldecode(str):
return urllib.parse.unquote(str)
if __name__ == '__main__':
autho = tweepy.OAuthHandler(user[0], user[1])
autho.set_access_token(user[2], user[3])
api = tweepy.API(autho)
co_api = Component(api)
query = sys.argv[1]
query = urldecode(query)
query = query.encode('utf-8').decode()
if len(sys.argv) == 2:
"guest"
tweets = co_api.search(query)
elif len(sys.argv) == 3:
"client"
since_id = sys.argv[2]
tweets = update_tweets(query, co_api, since_id)
an = co_api.analysis(tweets)
def __init__ (self, application):
gtk.Window.__init__ (self, gtk.WINDOW_TOPLEVEL)
operations.Operation.__init__ (self)
Component.__init__ (self, application)
self.__application = application
self.__masterer = AudioMastering ()
# Variable related to this being an Operation
self.__running = False
self.connect ("show", self.__on_show)
# We listen for GtkMusicList events
self.music_list_widget.listeners.append (self)
glade_file = os.path.join (constants.data_dir, "serpentine.glade")
g = gtk.glade.XML (glade_file, "main_window_container")
# Send glade to setup subcomponents
for c in self._components:
if hasattr (c, "_setup_glade"):
c._setup_glade (g)
self.add (g.get_widget ("main_window_container"))
self.set_title ("Serpentine")
self.set_default_size (450, 350)
self.set_icon_name ("gnome-dev-cdrom-audio")
# record button
# setup record button
self.__write_to_disc = MapProxy (dict(
button = g.get_widget ("write_to_disc"),
menu = g.get_widget ("write_to_disc_mni")
))
self.__write_to_disc.set_sensitive (False)
self.__write_to_disc["button"].connect ("clicked", self.__on_write_files)
self.__write_to_disc["menu"].connect ("activate", self.__on_write_files)
# masterer widget
box = self.get_child()
self.music_list_widget.show()
box.add (self.music_list_widget)
# preferences
g.get_widget ("preferences_mni").connect ("activate", self.__on_preferences)
# setup remove buttons
self.remove = MapProxy ({"menu": g.get_widget ("remove_mni"),
"button": g.get_widget ("remove")})
self.remove["menu"].connect ("activate", self.__on_remove_file)
self.remove["button"].connect ("clicked", self.__on_remove_file)
self.remove.set_sensitive (False)
# setup clear buttons
self.clear = MapProxy ({"menu": g.get_widget ("clear_mni"),
"button": g.get_widget ("clear")})
self.clear["button"].connect ("clicked", self.clear_files)
self.clear["menu"].connect ("activate", self.clear_files)
self.clear.set_sensitive (False)
# setup quit menu item
g.get_widget ("quit_mni").connect ("activate", self.stop)
self.connect("delete-event", self.stop)
# About dialog
g.get_widget ("about_mni").connect ("activate", self.__on_about)
# update buttons
self.on_contents_changed()
if self.__application.preferences.drive is None:
gtkutil.dialog_warn (
_("No recording drive found"),
_("No recording drive found on your system, therefore some of "
"Serpentine's functionalities will be disabled."),
parent = self
)
g.get_widget ("preferences_mni").set_sensitive (False)
self.__write_to_disc.set_sensitive (False)
# Load internal XSPF playlist
self.__load_playlist()
def get_context():
"""Return the dictionnary containing the context of the exercise."""
with open(sys.argv[1], "r") as f:
context = json.load(f)
Component.sync_context(context)
return context
def _insert_entry_from_page_text(self, data_id, data_text):
soup = BeautifulSoup(data_text)
type_name = soup.find_all('h1')[0].string.encode('utf8')
if 'Sorry' in [v.string for v in soup.find_all('h2')] or 'Error' in [v.string for v in soup.find_all('h1')]:
# The item with this typeid does not exist!
manufactured_component = Component(type_name, data_id)
manufactured_component.components = {-1: Component("None", -1)}
self.data[data_id] = manufactured_component
return False
group_id = -1
# Let's try to decipher the group
forms = soup.find_all('form')
for form in forms:
form_anchors = form.find_all('a')
for anchor in form_anchors:
if anchor.string == 'Browse Market Group':
group_url = anchor.get('href')
group_id = get_group_id_from_url(group_url)
self.groups.add_data(group_id)
volume = 9999999999
# Let's try to decipher the volume
forms = soup.find_all('form')
for form in forms:
if form.get('name') == 'type_add':
dds = form.find_all('dd')
mm_string = str(dds[1])
mm_string = mm_string.replace('<dd>', '')
mm_string = mm_string[0:mm_string.index('<sup>') - 1]
volume = float(mm_string)
# form_anchors = form.find_all('a')
# for anchor in form_anchors:
# if anchor.string == 'Browse Market Group':
# group_url = anchor.get('href')
# group_id = get_group_id_from_url(group_url)
# self.groups.add_data(group_id)
manufactured_component = Component(type_name, data_id, 1, group_id=group_id, volume=volume)
for_unit_count = 1
manufacturing_specified = False
reprocessing_specified = False
for div in soup.find_all('div'):
for c in div.contents:
if c.name == 'h4' and c.string == 'Manufacturing':
# This should happen only once if there is a manufacturing bit
manufacturing_specified = True
for_unit_count = self._get_for_unit_count(div)
manufactured_component.components = self._get_components(div, for_unit_count)
if c.name == 'h4' and c.string == 'Reprocessing':
# This should happen only once if there is a reprocessing bit
reprocessing_specified = True
for_unit_count = self._get_for_unit_count(div)
manufactured_component.reprocessing = self._get_components(div, for_unit_count)
if not manufacturing_specified:
manufactured_component.components = {-1: Component("Empty", -1)}
if not reprocessing_specified:
manufactured_component.reprocessing = {-1: Component("Empty", -1)}
self.data[data_id] = manufactured_component
return True
def __init__(self, application):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
operations.Operation.__init__(self)
Component.__init__(self, application)
self.__application = application
self.__masterer = AudioMastering()
# Variable related to this being an Operation
self.__running = False
self.connect("show", self.__on_show)
# We listen for GtkMusicList events
self.music_list_widget.listeners.append(self)
glade_file = os.path.join(constants.data_dir, "serpentine.glade")
g = gtk.glade.XML(glade_file, "main_window_container")
# Send glade to setup subcomponents
for c in self._components:
if hasattr(c, "_setup_glade"):
c._setup_glade(g)
self.add(g.get_widget("main_window_container"))
self.set_title("Serpentine")
self.set_default_size(450, 350)
self.set_icon_name("gnome-dev-cdrom-audio")
# record button
# setup record button
self.__write_to_disc = MapProxy(
dict(button=g.get_widget("write_to_disc"),
menu=g.get_widget("write_to_disc_mni")))
self.__write_to_disc.set_sensitive(False)
self.__write_to_disc["button"].connect("clicked",
self.__on_write_files)
self.__write_to_disc["menu"].connect("activate", self.__on_write_files)
# masterer widget
box = self.get_child()
self.music_list_widget.show()
box.add(self.music_list_widget)
# preferences
g.get_widget("preferences_mni").connect("activate",
self.__on_preferences)
# setup remove buttons
self.remove = MapProxy({
"menu": g.get_widget("remove_mni"),
"button": g.get_widget("remove")
})
self.remove["menu"].connect("activate", self.__on_remove_file)
self.remove["button"].connect("clicked", self.__on_remove_file)
self.remove.set_sensitive(False)
# setup clear buttons
self.clear = MapProxy({
"menu": g.get_widget("clear_mni"),
"button": g.get_widget("clear")
})
self.clear["button"].connect("clicked", self.clear_files)
self.clear["menu"].connect("activate", self.clear_files)
self.clear.set_sensitive(False)
# setup quit menu item
g.get_widget("quit_mni").connect("activate", self.stop)
self.connect("delete-event", self.stop)
# About dialog
g.get_widget("about_mni").connect("activate", self.__on_about)
# update buttons
self.on_contents_changed()
if self.__application.preferences.drive is None:
gtkutil.dialog_warn(
_("No recording drive found"),
_("No recording drive found on your system, therefore some of "
"Serpentine's functionalities will be disabled."), self)
g.get_widget("preferences_mni").set_sensitive(False)
self.__write_to_disc.set_sensitive(False)
# Load internal XSPF playlist
self.__load_playlist()
# Components
#
#########
if __name__ == '__main__':
from components import DefraggingArrayComponent as Component
import numpy as np
#TODO tests should include: when there is nothing in the first class,
# when there is nothing in the last class. When there is nothing
# in one or many in between classes. When the allocation scheme has repeat
# entries. When the allocation scheme is not contiguous. component
# dimensions of (1,),(n,),(n,m) and when incorrect dimensions are added.
# also, when components have complex data types (structs)
d1 = Component('component_1', (1, ), np.int32)
d2 = Component('component_2', (2, ), np.int32)
d3 = Component('component_3', (3, ), np.int32)
allocation_scheme = (
(1, 1, 1),
(1, 0, 1),
(1, 0, 0),
)
allocator = GlobalAllocator([d1, d2, d3], allocation_scheme)
to_add = []
to_add.append({
'component_1': 1,
'component_3': (1, 2, 3),
'component_2': ((1, 10), (2, 20)),
@author: khalid
"""
from modules import *
import scrap
import statuslookup as sl
from components import Component
from auth import *
if __name__ == '__main__':
'''handle maxtweet'''
autho = tweepy.OAuthHandler(user[0], user[1])
autho.set_access_token(user[2], user[3])
api = tweepy.API(autho)
user_com = Component(api)
num_tweets=1000
search= sys.argv[1]
if sys.argv[2] ==1:
userName= 1
elif sys.argv[2] ==2:
query = 1
else:
print('error')
#language= 'ar'
start= '2019-{}-{}'
intervals = [(start.format(f'{i%12:02}','01'),start.format(f'{(i+1)%12:02}','01'))for i in range(1,8)]
import sys
import os
sys.path.append("../")
from components import addComponent, Component
addComponent(
Component(name="sqlite3",
srcDir=os.environ["SOURCE_DIR"] + "/../3rd_party/sqlite3/src"))
addComponent(
Component(name="openssl",
srcDir=os.environ["SOURCE_DIR"] + "/../3rd_party/openssl"))
addComponent(
Component(name="curl",
srcDir=os.environ["SOURCE_DIR"] + "/../3rd_party/curl"))
exec('from common_components import *')
# Raspberry Pi specific components here:
