filename
stringlengths
13
19
text
stringlengths
134
1.04M
the-stack_106_29164
from tkinter import * window = Tk() window.geometry("400x300+20+10") window.title('The Grid Manager') class MyWindow: def __init__(self,window): self.lbl1 = Entry(window,bd=3,justify="center") self.lbl1.grid(row=0,column=0,padx=2) self.lbl1.insert(0,"Standard Calculator") self.lbl2 = Entry(window,bd=3,justify="center") self.lbl2.grid(row=1,column=0,padx=2) self.lbl2.insert(0,"Input 1st Number :") self.txtfld2 = Entry(window,bd=3) self.txtfld2.grid(row=1,column=1) self.lbl3 = Entry(window,bd=3,justify="center") self.lbl3.grid(row=2,column=0,padx=2) self.lbl3.insert(0,"Input 2nd Number :") self.txtfld3=Entry(window,bd=3) self.txtfld3.grid(row=2,column=1,padx=2) self.lbl4 = Entry(window,bd=3,justify="center") self.lbl4.grid(row=3,column=0,padx=2) self.lbl4.insert(0,"Select Operators :") self.btn1=Button(window,text="Addition(+)",command=self.add) self.btn1.grid(row=4,column=0,padx=2) self.btn2 = Button(window,text="Subtraction(-)") self.btn2.grid(row=4,column=1,padx=2) self.btn2.bind('<Button-1>',self.subtract) self.btn3=Button(window,text="Multiply(*)", command=self.multiply) self.btn3.grid(row=5,column=0,padx=2) self.btn4=Button(window,text="Division(/)") self.btn4.grid(row=5,column=1,padx=2) self.btn4.bind('<Button-1>',self.division) self.lbl5=Entry(window,bd=3,justify="center") self.lbl5.grid(row=7,column=0,padx=2) self.lbl5.insert(0,"Result :") self.txtfld4=Entry(window,bd=4) self.txtfld4.grid(row=7,column=1,padx=2) def add(self): self.txtfld4.delete(0,'end') num1=int(self.txtfld2.get()) num2=int(self.txtfld3.get()) answer = num1+num2 self.txtfld4.insert(END,answer) def subtract(self,event): self.txtfld4.delete(0,'end') num1=int(self.txtfld2.get()) num2=int(self.txtfld3.get()) answer = num1-num2 self.txtfld4.insert(END,answer) def multiply(self): self.txtfld4.delete(0,'end') num1=int(self.txtfld2.get()) num2=int(self.txtfld3.get()) answer = num1*num2 self.txtfld4.insert(END,answer) def division(self,event): self.txtfld4.delete(0,'end') num1=int(self.txtfld2.get()) num2=int(self.txtfld3.get()) answer = num1/num2 self.txtfld4.insert(END,str(answer)) mywin = MyWindow(window) window.mainloop()
the-stack_106_29165
from uuid import uuid4 from django.db import models class BaseModelMixin(models.Model): """ Abstract Model class creation and modification datetimes ['site', 'created', 'updated'] """ slug = models.SlugField( max_length=100, unique=True, db_index=True, default=uuid4, editable=False ) created = models.DateTimeField( ("creation date and time"), editable=False, auto_now_add=True,) updated = models.DateTimeField( ("update date and time"), auto_now=True, editable=False ) class Meta: abstract = True
the-stack_106_29166
# # 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. # coding: utf-8 """ KServe Python SDK for KServe # noqa: E501 The version of the OpenAPI document: v0.1 Generated by: https://openapi-generator.tech """ from __future__ import absolute_import import unittest import datetime import kserve from kserve.models.v1beta1_explainer_extension_spec import V1beta1ExplainerExtensionSpec # noqa: E501 from kserve.rest import ApiException class TestV1beta1ExplainerExtensionSpec(unittest.TestCase): """V1beta1ExplainerExtensionSpec unit test stubs""" def setUp(self): pass def tearDown(self): pass def make_instance(self, include_optional): """Test V1beta1ExplainerExtensionSpec include_option is a boolean, when False only required params are included, when True both required and optional params are included """ # model = kserve.models.v1beta1_explainer_extension_spec.V1beta1ExplainerExtensionSpec() # noqa: E501 if include_optional : return V1beta1ExplainerExtensionSpec( args = [ '0' ], command = [ '0' ], config = { 'key' : '0' }, env = [ None ], env_from = [ None ], image = '0', image_pull_policy = '0', lifecycle = None, liveness_probe = None, name = '0', ports = [ None ], readiness_probe = None, resources = None, runtime_version = '0', security_context = None, startup_probe = None, stdin = True, stdin_once = True, storage_uri = '0', termination_message_path = '0', termination_message_policy = '0', tty = True, volume_devices = [ None ], volume_mounts = [ None ], working_dir = '0' ) else : return V1beta1ExplainerExtensionSpec( ) def testV1beta1ExplainerExtensionSpec(self): """Test V1beta1ExplainerExtensionSpec""" inst_req_only = self.make_instance(include_optional=False) inst_req_and_optional = self.make_instance(include_optional=True) if __name__ == '__main__': unittest.main()
the-stack_106_29169
# Natural Language Toolkit: Table widget # # Copyright (C) 2001-2015 NLTK Project # Author: Edward Loper <[email protected]> # URL: <http://nltk.org/> # For license information, see LICENSE.TXT """ Tkinter widgets for displaying multi-column listboxes and tables. """ from __future__ import division import nltk.compat import operator from tkinter import (Frame, Label, Listbox, Scrollbar, Tk) ###################################################################### # Multi-Column Listbox ###################################################################### class MultiListbox(Frame): """ A multi-column listbox, where the current selection applies to an entire row. Based on the MultiListbox Tkinter widget recipe from the Python Cookbook (http://code.activestate.com/recipes/52266/) For the most part, ``MultiListbox`` methods delegate to its contained listboxes. For any methods that do not have docstrings, see ``Tkinter.Listbox`` for a description of what that method does. """ #///////////////////////////////////////////////////////////////// # Configuration #///////////////////////////////////////////////////////////////// #: Default configuration values for the frame. FRAME_CONFIG = dict(background='#888', takefocus=True, highlightthickness=1) #: Default configurations for the column labels. LABEL_CONFIG = dict(borderwidth=1, relief='raised', font='helvetica -16 bold', background='#444', foreground='white') #: Default configuration for the column listboxes. LISTBOX_CONFIG = dict(borderwidth=1, selectborderwidth=0, highlightthickness=0, exportselection=False, selectbackground='#888', activestyle='none', takefocus=False) #///////////////////////////////////////////////////////////////// # Constructor #///////////////////////////////////////////////////////////////// def __init__(self, master, columns, column_weights=None, cnf={}, **kw): """ Construct a new multi-column listbox widget. :param master: The widget that should contain the new multi-column listbox. :param columns: Specifies what columns should be included in the new multi-column listbox. If ``columns`` is an integer, the it is the number of columns to include. If it is a list, then its length indicates the number of columns to include; and each element of the list will be used as a label for the corresponding column. :param cnf, kw: Configuration parameters for this widget. Use ``label_*`` to configure all labels; and ``listbox_*`` to configure all listboxes. E.g.: >>> mlb = MultiListbox(master, 5, label_foreground='red') """ # If columns was specified as an int, convert it to a list. if isinstance(columns, int): columns = list(range(columns)) include_labels = False else: include_labels = True if len(columns) == 0: raise ValueError("Expected at least one column") # Instance variables self._column_names = tuple(columns) self._listboxes = [] self._labels = [] # Pick a default value for column_weights, if none was specified. if column_weights is None: column_weights = [1] * len(columns) elif len(column_weights) != len(columns): raise ValueError('Expected one column_weight for each column') self._column_weights = column_weights # Configure our widgets. Frame.__init__(self, master, **self.FRAME_CONFIG) self.grid_rowconfigure(1, weight=1) for i, label in enumerate(self._column_names): self.grid_columnconfigure(i, weight=column_weights[i]) # Create a label for the column if include_labels: l = Label(self, text=label, **self.LABEL_CONFIG) self._labels.append(l) l.grid(column=i, row=0, sticky='news', padx=0, pady=0) l.column_index = i # Create a listbox for the column lb = Listbox(self, **self.LISTBOX_CONFIG) self._listboxes.append(lb) lb.grid(column=i, row=1, sticky='news', padx=0, pady=0) lb.column_index = i # Clicking or dragging selects: lb.bind('<Button-1>', self._select) lb.bind('<B1-Motion>', self._select) # Scroll whell scrolls: lb.bind('<Button-4>', lambda e: self._scroll(-1)) lb.bind('<Button-5>', lambda e: self._scroll(+1)) lb.bind('<MouseWheel>', lambda e: self._scroll(e.delta)) # Button 2 can be used to scan: lb.bind('<Button-2>', lambda e: self.scan_mark(e.x, e.y)) lb.bind('<B2-Motion>', lambda e: self.scan_dragto(e.x, e.y)) # Dragging outside the window has no effect (diable # the default listbox behavior, which scrolls): lb.bind('<B1-Leave>', lambda e: 'break') # Columns can be resized by dragging them: l.bind('<Button-1>', self._resize_column) # Columns can be resized by dragging them. (This binding is # used if they click on the grid between columns:) self.bind('<Button-1>', self._resize_column) # Set up key bindings for the widget: self.bind('<Up>', lambda e: self.select(delta=-1)) self.bind('<Down>', lambda e: self.select(delta=1)) self.bind('<Prior>', lambda e: self.select(delta=-self._pagesize())) self.bind('<Next>', lambda e: self.select(delta=self._pagesize())) # Configuration customizations self.configure(cnf, **kw) #///////////////////////////////////////////////////////////////// # Column Resizing #///////////////////////////////////////////////////////////////// def _resize_column(self, event): """ Callback used to resize a column of the table. Return ``True`` if the column is actually getting resized (if the user clicked on the far left or far right 5 pixels of a label); and ``False`` otherwies. """ # If we're already waiting for a button release, then ignore # the new button press. if event.widget.bind('<ButtonRelease>'): return False # Decide which column (if any) to resize. self._resize_column_index = None if event.widget is self: for i, lb in enumerate(self._listboxes): if abs(event.x-(lb.winfo_x()+lb.winfo_width())) < 10: self._resize_column_index = i elif event.x > (event.widget.winfo_width()-5): self._resize_column_index = event.widget.column_index elif event.x < 5 and event.widget.column_index != 0: self._resize_column_index = event.widget.column_index-1 # Bind callbacks that are used to resize it. if self._resize_column_index is not None: event.widget.bind('<Motion>', self._resize_column_motion_cb) event.widget.bind('<ButtonRelease-%d>' % event.num, self._resize_column_buttonrelease_cb) return True else: return False def _resize_column_motion_cb(self, event): lb = self._listboxes[self._resize_column_index] charwidth = lb.winfo_width() / lb['width'] x1 = event.x + event.widget.winfo_x() x2 = lb.winfo_x() + lb.winfo_width() lb['width'] = max(3, lb['width'] + (x1-x2) // charwidth) def _resize_column_buttonrelease_cb(self, event): event.widget.unbind('<ButtonRelease-%d>' % event.num) event.widget.unbind('<Motion>') #///////////////////////////////////////////////////////////////// # Properties #///////////////////////////////////////////////////////////////// @property def column_names(self): """ A tuple containing the names of the columns used by this multi-column listbox. """ return self._column_names @property def column_labels(self): """ A tuple containing the ``Tkinter.Label`` widgets used to display the label of each column. If this multi-column listbox was created without labels, then this will be an empty tuple. These widgets will all be augmented with a ``column_index`` attribute, which can be used to determine which column they correspond to. This can be convenient, e.g., when defining callbacks for bound events. """ return tuple(self._labels) @property def listboxes(self): """ A tuple containing the ``Tkinter.Listbox`` widgets used to display individual columns. These widgets will all be augmented with a ``column_index`` attribute, which can be used to determine which column they correspond to. This can be convenient, e.g., when defining callbacks for bound events. """ return tuple(self._listboxes) #///////////////////////////////////////////////////////////////// # Mouse & Keyboard Callback Functions #///////////////////////////////////////////////////////////////// def _select(self, e): i = e.widget.nearest(e.y) self.selection_clear(0, 'end') self.selection_set(i) self.activate(i) self.focus() def _scroll(self, delta): for lb in self._listboxes: lb.yview_scroll(delta, 'unit') return 'break' def _pagesize(self): """:return: The number of rows that makes up one page""" return int(self.index('@0,1000000')) - int(self.index('@0,0')) #///////////////////////////////////////////////////////////////// # Row selection #///////////////////////////////////////////////////////////////// def select(self, index=None, delta=None, see=True): """ Set the selected row. If ``index`` is specified, then select row ``index``. Otherwise, if ``delta`` is specified, then move the current selection by ``delta`` (negative numbers for up, positive numbers for down). This will not move the selection past the top or the bottom of the list. :param see: If true, then call ``self.see()`` with the newly selected index, to ensure that it is visible. """ if (index is not None) and (delta is not None): raise ValueError('specify index or delta, but not both') # If delta was given, then calculate index. if delta is not None: if len(self.curselection()) == 0: index = -1 + delta else: index = int(self.curselection()[0]) + delta # Clear all selected rows. self.selection_clear(0, 'end') # Select the specified index if index is not None: index = min(max(index, 0), self.size()-1) #self.activate(index) self.selection_set(index) if see: self.see(index) #///////////////////////////////////////////////////////////////// # Configuration #///////////////////////////////////////////////////////////////// def configure(self, cnf={}, **kw): """ Configure this widget. Use ``label_*`` to configure all labels; and ``listbox_*`` to configure all listboxes. E.g.: >>> mlb = MultiListbox(master, 5) >>> mlb.configure(label_foreground='red') >>> mlb.configure(listbox_foreground='red') """ cnf = dict(list(cnf.items()) + list(kw.items())) for (key, val) in list(cnf.items()): if key.startswith('label_') or key.startswith('label-'): for label in self._labels: label.configure({key[6:]: val}) elif key.startswith('listbox_') or key.startswith('listbox-'): for listbox in self._listboxes: listbox.configure({key[8:]: val}) else: Frame.configure(self, {key:val}) def __setitem__(self, key, val): """ Configure this widget. This is equivalent to ``self.configure({key,val``)}. See ``configure()``. """ self.configure({key:val}) def rowconfigure(self, row_index, cnf={}, **kw): """ Configure all table cells in the given row. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. """ for lb in self._listboxes: lb.itemconfigure(row_index, cnf, **kw) def columnconfigure(self, col_index, cnf={}, **kw): """ Configure all table cells in the given column. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. """ lb = self._listboxes[col_index] cnf = dict(list(cnf.items()) + list(kw.items())) for (key, val) in list(cnf.items()): if key in ('background', 'bg', 'foreground', 'fg', 'selectbackground', 'selectforeground'): for i in range(lb.size()): lb.itemconfigure(i, {key:val}) else: lb.configure({key:val}) def itemconfigure(self, row_index, col_index, cnf=None, **kw): """ Configure the table cell at the given row and column. Valid keyword arguments are: ``background``, ``bg``, ``foreground``, ``fg``, ``selectbackground``, ``selectforeground``. """ lb = self._listboxes[col_index] return lb.itemconfigure(row_index, cnf, **kw) #///////////////////////////////////////////////////////////////// # Value Access #///////////////////////////////////////////////////////////////// def insert(self, index, *rows): """ Insert the given row or rows into the table, at the given index. Each row value should be a tuple of cell values, one for each column in the row. Index may be an integer or any of the special strings (such as ``'end'``) accepted by ``Tkinter.Listbox``. """ for elt in rows: if len(elt) != len(self._column_names): raise ValueError('rows should be tuples whose length ' 'is equal to the number of columns') for (lb,elts) in zip(self._listboxes, list(zip(*rows))): lb.insert(index, *elts) def get(self, first, last=None): """ Return the value(s) of the specified row(s). If ``last`` is not specified, then return a single row value; otherwise, return a list of row values. Each row value is a tuple of cell values, one for each column in the row. """ values = [lb.get(first, last) for lb in self._listboxes] if last: return [tuple(row) for row in zip(*values)] else: return tuple(values) def bbox(self, row, col): """ Return the bounding box for the given table cell, relative to this widget's top-left corner. The bounding box is a tuple of integers ``(left, top, width, height)``. """ dx, dy, _, _ = self.grid_bbox(row=0, column=col) x, y, w, h = self._listboxes[col].bbox(row) return int(x)+int(dx), int(y)+int(dy), int(w), int(h) #///////////////////////////////////////////////////////////////// # Hide/Show Columns #///////////////////////////////////////////////////////////////// def hide_column(self, col_index): """ Hide the given column. The column's state is still maintained: its values will still be returned by ``get()``, and you must supply its values when calling ``insert()``. It is safe to call this on a column that is already hidden. :see: ``show_column()`` """ if self._labels: self._labels[col_index].grid_forget() self.listboxes[col_index].grid_forget() self.grid_columnconfigure(col_index, weight=0) def show_column(self, col_index): """ Display a column that has been hidden using ``hide_column()``. It is safe to call this on a column that is not hidden. """ weight = self._column_weights[col_index] if self._labels: self._labels[col_index].grid(column=col_index, row=0, sticky='news', padx=0, pady=0) self._listboxes[col_index].grid(column=col_index, row=1, sticky='news', padx=0, pady=0) self.grid_columnconfigure(col_index, weight=weight) #///////////////////////////////////////////////////////////////// # Binding Methods #///////////////////////////////////////////////////////////////// def bind_to_labels(self, sequence=None, func=None, add=None): """ Add a binding to each ``Tkinter.Label`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). """ return [label.bind(sequence, func, add) for label in self.column_labels] def bind_to_listboxes(self, sequence=None, func=None, add=None): """ Add a binding to each ``Tkinter.Listbox`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). """ for listbox in self.listboxes: listbox.bind(sequence, func, add) def bind_to_columns(self, sequence=None, func=None, add=None): """ Add a binding to each ``Tkinter.Label`` and ``Tkinter.Listbox`` widget in this mult-column listbox that will call ``func`` in response to the event sequence. :return: A list of the identifiers of replaced binding functions (if any), allowing for their deletion (to prevent a memory leak). """ return (self.bind_to_labels(sequence, func, add) + self.bind_to_listboxes(sequence, func, add)) #///////////////////////////////////////////////////////////////// # Simple Delegation #///////////////////////////////////////////////////////////////// # These methods delegate to the first listbox: def curselection(self, *args, **kwargs): return self._listboxes[0].curselection(*args, **kwargs) def selection_includes(self, *args, **kwargs): return self._listboxes[0].selection_includes(*args, **kwargs) def itemcget(self, *args, **kwargs): return self._listboxes[0].itemcget(*args, **kwargs) def size(self, *args, **kwargs): return self._listboxes[0].size(*args, **kwargs) def index(self, *args, **kwargs): return self._listboxes[0].index(*args, **kwargs) def nearest(self, *args, **kwargs): return self._listboxes[0].nearest(*args, **kwargs) # These methods delegate to each listbox (and return None): def activate(self, *args, **kwargs): for lb in self._listboxes: lb.activate(*args, **kwargs) def delete(self, *args, **kwargs): for lb in self._listboxes: lb.delete(*args, **kwargs) def scan_mark(self, *args, **kwargs): for lb in self._listboxes: lb.scan_mark(*args, **kwargs) def scan_dragto(self, *args, **kwargs): for lb in self._listboxes: lb.scan_dragto(*args, **kwargs) def see(self, *args, **kwargs): for lb in self._listboxes: lb.see(*args, **kwargs) def selection_anchor(self, *args, **kwargs): for lb in self._listboxes: lb.selection_anchor(*args, **kwargs) def selection_clear(self, *args, **kwargs): for lb in self._listboxes: lb.selection_clear(*args, **kwargs) def selection_set(self, *args, **kwargs): for lb in self._listboxes: lb.selection_set(*args, **kwargs) def yview(self, *args, **kwargs): for lb in self._listboxes: v = lb.yview(*args, **kwargs) return v # if called with no arguments def yview_moveto(self, *args, **kwargs): for lb in self._listboxes: lb.yview_moveto(*args, **kwargs) def yview_scroll(self, *args, **kwargs): for lb in self._listboxes: lb.yview_scroll(*args, **kwargs) #///////////////////////////////////////////////////////////////// # Aliases #///////////////////////////////////////////////////////////////// itemconfig = itemconfigure rowconfig = rowconfigure columnconfig = columnconfigure select_anchor = selection_anchor select_clear = selection_clear select_includes = selection_includes select_set = selection_set #///////////////////////////////////////////////////////////////// # These listbox methods are not defined for multi-listbox #///////////////////////////////////////////////////////////////// # def xview(self, *what): pass # def xview_moveto(self, fraction): pass # def xview_scroll(self, number, what): pass ###################################################################### # Table ###################################################################### class Table(object): """ A display widget for a table of values, based on a ``MultiListbox`` widget. For many purposes, ``Table`` can be treated as a list-of-lists. E.g., table[i] is a list of the values for row i; and table.append(row) adds a new row with the given lits of values. Individual cells can be accessed using table[i,j], which refers to the j-th column of the i-th row. This can be used to both read and write values from the table. E.g.: >>> table[i,j] = 'hello' The column (j) can be given either as an index number, or as a column name. E.g., the following prints the value in the 3rd row for the 'First Name' column: >>> print(table[3, 'First Name']) John You can configure the colors for individual rows, columns, or cells using ``rowconfig()``, ``columnconfig()``, and ``itemconfig()``. The color configuration for each row will be preserved if the table is modified; however, when new rows are added, any color configurations that have been made for *columns* will not be applied to the new row. Note: Although ``Table`` acts like a widget in some ways (e.g., it defines ``grid()``, ``pack()``, and ``bind()``), it is not itself a widget; it just contains one. This is because widgets need to define ``__getitem__()``, ``__setitem__()``, and ``__nonzero__()`` in a way that's incompatible with the fact that ``Table`` behaves as a list-of-lists. :ivar _mlb: The multi-column listbox used to display this table's data. :ivar _rows: A list-of-lists used to hold the cell values of this table. Each element of _rows is a row value, i.e., a list of cell values, one for each column in the row. """ def __init__(self, master, column_names, rows=None, column_weights=None, scrollbar=True, click_to_sort=True, reprfunc=None, cnf={}, **kw): """ Construct a new Table widget. :type master: Tkinter.Widget :param master: The widget that should contain the new table. :type column_names: list(str) :param column_names: A list of names for the columns; these names will be used to create labels for each column; and can be used as an index when reading or writing cell values from the table. :type rows: list(list) :param rows: A list of row values used to initialze the table. Each row value should be a tuple of cell values, one for each column in the row. :type scrollbar: bool :param scrollbar: If true, then create a scrollbar for the new table widget. :type click_to_sort: bool :param click_to_sort: If true, then create bindings that will sort the table's rows by a given column's values if the user clicks on that colum's label. :type reprfunc: function :param reprfunc: If specified, then use this function to convert each table cell value to a string suitable for display. ``reprfunc`` has the following signature: reprfunc(row_index, col_index, cell_value) -> str (Note that the column is specified by index, not by name.) :param cnf, kw: Configuration parameters for this widget's contained ``MultiListbox``. See ``MultiListbox.__init__()`` for details. """ self._num_columns = len(column_names) self._reprfunc = reprfunc self._frame = Frame(master) self._column_name_to_index = dict((c,i) for (i,c) in enumerate(column_names)) # Make a copy of the rows & check that it's valid. if rows is None: self._rows = [] else: self._rows = [[v for v in row] for row in rows] for row in self._rows: self._checkrow(row) # Create our multi-list box. self._mlb = MultiListbox(self._frame, column_names, column_weights, cnf, **kw) self._mlb.pack(side='left', expand=True, fill='both') # Optional scrollbar if scrollbar: sb = Scrollbar(self._frame, orient='vertical', command=self._mlb.yview) self._mlb.listboxes[0]['yscrollcommand'] = sb.set #for listbox in self._mlb.listboxes: # listbox['yscrollcommand'] = sb.set sb.pack(side='right', fill='y') self._scrollbar = sb # Set up sorting self._sortkey = None if click_to_sort: for i, l in enumerate(self._mlb.column_labels): l.bind('<Button-1>', self._sort) # Fill in our multi-list box. self._fill_table() #///////////////////////////////////////////////////////////////// #{ Widget-like Methods #///////////////////////////////////////////////////////////////// # These all just delegate to either our frame or our MLB. def pack(self, *args, **kwargs): """Position this table's main frame widget in its parent widget. See ``Tkinter.Frame.pack()`` for more info.""" self._frame.pack(*args, **kwargs) def grid(self, *args, **kwargs): """Position this table's main frame widget in its parent widget. See ``Tkinter.Frame.grid()`` for more info.""" self._frame.grid(*args, **kwargs) def focus(self): """Direct (keyboard) input foxus to this widget.""" self._mlb.focus() def bind(self, sequence=None, func=None, add=None): """Add a binding to this table's main frame that will call ``func`` in response to the event sequence.""" self._mlb.bind(sequence, func, add) def rowconfigure(self, row_index, cnf={}, **kw): """:see: ``MultiListbox.rowconfigure()``""" self._mlb.rowconfigure(row_index, cnf, **kw) def columnconfigure(self, col_index, cnf={}, **kw): """:see: ``MultiListbox.columnconfigure()``""" col_index = self.column_index(col_index) self._mlb.columnconfigure(col_index, cnf, **kw) def itemconfigure(self, row_index, col_index, cnf=None, **kw): """:see: ``MultiListbox.itemconfigure()``""" col_index = self.column_index(col_index) return self._mlb.itemconfigure(row_index, col_index, cnf, **kw) def bind_to_labels(self, sequence=None, func=None, add=None): """:see: ``MultiListbox.bind_to_labels()``""" return self._mlb.bind_to_labels(sequence, func, add) def bind_to_listboxes(self, sequence=None, func=None, add=None): """:see: ``MultiListbox.bind_to_listboxes()``""" return self._mlb.bind_to_listboxes(sequence, func, add) def bind_to_columns(self, sequence=None, func=None, add=None): """:see: ``MultiListbox.bind_to_columns()``""" return self._mlb.bind_to_columns(sequence, func, add) rowconfig = rowconfigure columnconfig = columnconfigure itemconfig = itemconfigure #///////////////////////////////////////////////////////////////// #{ Table as list-of-lists #///////////////////////////////////////////////////////////////// def insert(self, row_index, rowvalue): """ Insert a new row into the table, so that its row index will be ``row_index``. If the table contains any rows whose row index is greater than or equal to ``row_index``, then they will be shifted down. :param rowvalue: A tuple of cell values, one for each column in the new row. """ self._checkrow(rowvalue) self._rows.insert(row_index, rowvalue) if self._reprfunc is not None: rowvalue = [self._reprfunc(row_index,j,v) for (j,v) in enumerate(rowvalue)] self._mlb.insert(row_index, rowvalue) if self._DEBUG: self._check_table_vs_mlb() def extend(self, rowvalues): """ Add new rows at the end of the table. :param rowvalues: A list of row values used to initialze the table. Each row value should be a tuple of cell values, one for each column in the row. """ for rowvalue in rowvalues: self.append(rowvalue) if self._DEBUG: self._check_table_vs_mlb() def append(self, rowvalue): """ Add a new row to the end of the table. :param rowvalue: A tuple of cell values, one for each column in the new row. """ self.insert(len(self._rows), rowvalue) if self._DEBUG: self._check_table_vs_mlb() def clear(self): """ Delete all rows in this table. """ self._rows = [] self._mlb.delete(0, 'end') if self._DEBUG: self._check_table_vs_mlb() def __getitem__(self, index): """ Return the value of a row or a cell in this table. If ``index`` is an integer, then the row value for the ``index``th row. This row value consists of a tuple of cell values, one for each column in the row. If ``index`` is a tuple of two integers, ``(i,j)``, then return the value of the cell in the ``i``th row and the ``j``th column. """ if isinstance(index, slice): raise ValueError('Slicing not supported') elif isinstance(index, tuple) and len(index)==2: return self._rows[index[0]][self.column_index(index[1])] else: return tuple(self._rows[index]) def __setitem__(self, index, val): """ Replace the value of a row or a cell in this table with ``val``. If ``index`` is an integer, then ``val`` should be a row value (i.e., a tuple of cell values, one for each column). In this case, the values of the ``index``th row of the table will be replaced with the values in ``val``. If ``index`` is a tuple of integers, ``(i,j)``, then replace the value of the cell in the ``i``th row and ``j``th column with ``val``. """ if isinstance(index, slice): raise ValueError('Slicing not supported') # table[i,j] = val elif isinstance(index, tuple) and len(index)==2: i, j = index[0], self.column_index(index[1]) config_cookie = self._save_config_info([i]) self._rows[i][j] = val if self._reprfunc is not None: val = self._reprfunc(i, j, val) self._mlb.listboxes[j].insert(i, val) self._mlb.listboxes[j].delete(i+1) self._restore_config_info(config_cookie) # table[i] = val else: config_cookie = self._save_config_info([index]) self._checkrow(val) self._rows[index] = list(val) if self._reprfunc is not None: val = [self._reprfunc(index,j,v) for (j,v) in enumerate(val)] self._mlb.insert(index, val) self._mlb.delete(index+1) self._restore_config_info(config_cookie) def __delitem__(self, row_index): """ Delete the ``row_index``th row from this table. """ if isinstance(index, slice): raise ValueError('Slicing not supported') if isinstance(row_index, tuple) and len(row_index)==2: raise ValueError('Cannot delete a single cell!') del self._rows[row_index] self._mlb.delete(row_index) if self._DEBUG: self._check_table_vs_mlb() def __len__(self): """ :return: the number of rows in this table. """ return len(self._rows) def _checkrow(self, rowvalue): """ Helper function: check that a given row value has the correct number of elements; and if not, raise an exception. """ if len(rowvalue) != self._num_columns: raise ValueError('Row %r has %d columns; expected %d' % (rowvalue, len(rowvalue), self._num_columns)) #///////////////////////////////////////////////////////////////// # Columns #///////////////////////////////////////////////////////////////// @property def column_names(self): """A list of the names of the columns in this table.""" return self._mlb.column_names def column_index(self, i): """ If ``i`` is a valid column index integer, then return it as is. Otherwise, check if ``i`` is used as the name for any column; if so, return that column's index. Otherwise, raise a ``KeyError`` exception. """ if isinstance(i, int) and 0 <= i < self._num_columns: return i else: # This raises a key error if the column is not found. return self._column_name_to_index[i] def hide_column(self, column_index): """:see: ``MultiListbox.hide_column()``""" self._mlb.hide_column(self.column_index(column_index)) def show_column(self, column_index): """:see: ``MultiListbox.show_column()``""" self._mlb.show_column(self.column_index(column_index)) #///////////////////////////////////////////////////////////////// # Selection #///////////////////////////////////////////////////////////////// def selected_row(self): """ Return the index of the currently selected row, or None if no row is selected. To get the row value itself, use ``table[table.selected_row()]``. """ sel = self._mlb.curselection() if sel: return int(sel[0]) else: return None def select(self, index=None, delta=None, see=True): """:see: ``MultiListbox.select()``""" self._mlb.select(index, delta, see) #///////////////////////////////////////////////////////////////// # Sorting #///////////////////////////////////////////////////////////////// def sort_by(self, column_index, order='toggle'): """ Sort the rows in this table, using the specified column's values as a sort key. :param column_index: Specifies which column to sort, using either a column index (int) or a column's label name (str). :param order: Specifies whether to sort the values in ascending or descending order: - ``'ascending'``: Sort from least to greatest. - ``'descending'``: Sort from greatest to least. - ``'toggle'``: If the most recent call to ``sort_by()`` sorted the table by the same column (``column_index``), then reverse the rows; otherwise sort in ascending order. """ if order not in ('ascending', 'descending', 'toggle'): raise ValueError('sort_by(): order should be "ascending", ' '"descending", or "toggle".') column_index = self.column_index(column_index) config_cookie = self._save_config_info(index_by_id=True) # Sort the rows. if order == 'toggle' and column_index == self._sortkey: self._rows.reverse() else: self._rows.sort(key=operator.itemgetter(column_index), reverse=(order=='descending')) self._sortkey = column_index # Redraw the table. self._fill_table() self._restore_config_info(config_cookie, index_by_id=True, see=True) if self._DEBUG: self._check_table_vs_mlb() def _sort(self, event): """Event handler for clicking on a column label -- sort by that column.""" column_index = event.widget.column_index # If they click on the far-left of far-right of a column's # label, then resize rather than sorting. if self._mlb._resize_column(event): return 'continue' # Otherwise, sort. else: self.sort_by(column_index) return 'continue' #///////////////////////////////////////////////////////////////// #{ Table Drawing Helpers #///////////////////////////////////////////////////////////////// def _fill_table(self, save_config=True): """ Re-draw the table from scratch, by clearing out the table's multi-column listbox; and then filling it in with values from ``self._rows``. Note that any cell-, row-, or column-specific color configuration that has been done will be lost. The selection will also be lost -- i.e., no row will be selected after this call completes. """ self._mlb.delete(0, 'end') for i, row in enumerate(self._rows): if self._reprfunc is not None: row = [self._reprfunc(i,j,v) for (j,v) in enumerate(row)] self._mlb.insert('end', row) def _get_itemconfig(self, r, c): return dict( (k, self._mlb.itemconfig(r, c, k)[-1]) for k in ('foreground', 'selectforeground', 'background', 'selectbackground') ) def _save_config_info(self, row_indices=None, index_by_id=False): """ Return a 'cookie' containing information about which row is selected, and what color configurations have been applied. this information can the be re-applied to the table (after making modifications) using ``_restore_config_info()``. Color configuration information will be saved for any rows in ``row_indices``, or in the entire table, if ``row_indices=None``. If ``index_by_id=True``, the the cookie will associate rows with their configuration information based on the rows' python id. This is useful when performing operations that re-arrange the rows (e.g. ``sort``). If ``index_by_id=False``, then it is assumed that all rows will be in the same order when ``_restore_config_info()`` is called. """ # Default value for row_indices is all rows. if row_indices is None: row_indices = list(range(len(self._rows))) # Look up our current selection. selection = self.selected_row() if index_by_id and selection is not None: selection = id(self._rows[selection]) # Look up the color configuration info for each row. if index_by_id: config = dict((id(self._rows[r]), [self._get_itemconfig(r, c) for c in range(self._num_columns)]) for r in row_indices) else: config = dict((r, [self._get_itemconfig(r, c) for c in range(self._num_columns)]) for r in row_indices) return selection, config def _restore_config_info(self, cookie, index_by_id=False, see=False): """ Restore selection & color configuration information that was saved using ``_save_config_info``. """ selection, config = cookie # Clear the selection. if selection is None: self._mlb.selection_clear(0, 'end') # Restore selection & color config if index_by_id: for r, row in enumerate(self._rows): if id(row) in config: for c in range(self._num_columns): self._mlb.itemconfigure(r, c, config[id(row)][c]) if id(row) == selection: self._mlb.select(r, see=see) else: if selection is not None: self._mlb.select(selection, see=see) for r in config: for c in range(self._num_columns): self._mlb.itemconfigure(r, c, config[r][c]) #///////////////////////////////////////////////////////////////// # Debugging (Invariant Checker) #///////////////////////////////////////////////////////////////// _DEBUG = False """If true, then run ``_check_table_vs_mlb()`` after any operation that modifies the table.""" def _check_table_vs_mlb(self): """ Verify that the contents of the table's ``_rows`` variable match the contents of its multi-listbox (``_mlb``). This is just included for debugging purposes, to make sure that the list-modifying operations are working correctly. """ for col in self._mlb.listboxes: assert len(self) == col.size() for row in self: assert len(row) == self._num_columns assert self._num_columns == len(self._mlb.column_names) #assert self._column_names == self._mlb.column_names for i, row in enumerate(self): for j, cell in enumerate(row): if self._reprfunc is not None: cell = self._reprfunc(i, j, cell) assert self._mlb.get(i)[j] == cell ###################################################################### # Demo/Test Function ###################################################################### # update this to use new WordNet API def demo(): root = Tk() root.bind('<Control-q>', lambda e: root.destroy()) table = Table(root, 'Word Synset Hypernym Hyponym'.split(), column_weights=[0, 1, 1, 1], reprfunc=(lambda i,j,s: ' %s' % s)) table.pack(expand=True, fill='both') from nltk.corpus import wordnet from nltk.corpus import brown for word, pos in sorted(set(brown.tagged_words()[:500])): if pos[0] != 'N': continue word = word.lower() for synset in wordnet.synsets(word): hyper = (synset.hypernyms()+[''])[0] hypo = (synset.hyponyms()+[''])[0] table.append([word, getattr(synset, 'definition', '*none*'), getattr(hyper, 'definition', '*none*'), getattr(hypo, 'definition', '*none*')]) table.columnconfig('Word', background='#afa') table.columnconfig('Synset', background='#efe') table.columnconfig('Hypernym', background='#fee') table.columnconfig('Hyponym', background='#ffe') for row in range(len(table)): for column in ('Hypernym', 'Hyponym'): if table[row, column] == '*none*': table.itemconfig(row, column, foreground='#666', selectforeground='#666') root.mainloop() if __name__ == '__main__': demo()
the-stack_106_29170
import torch import torch.nn as nn import torch.nn.functional as F import math import torch.utils.model_zoo as model_zoo import torch __all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152'] model_urls = { 'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth', 'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth', 'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth', 'resnet101': 'https://download.pytorch.org/models/resnet101-5d3mb4d8f.pth', 'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth', } class BasicBlock(nn.Module): expansion = 1 def __init__(self, in_planes, planes, stride=1): super(BasicBlock, self).__init__() self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.shortcut = nn.Sequential() if stride != 1 or in_planes != self.expansion*planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(self.expansion*planes) ) def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) out = F.relu(out) return out class Bottleneck(nn.Module): expansion = 4 def __init__(self, in_planes, planes, stride=1): super(Bottleneck, self).__init__() self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False) self.bn3 = nn.BatchNorm2d(self.expansion*planes) self.shortcut = nn.Sequential() if stride != 1 or in_planes != self.expansion*planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(self.expansion*planes) ) def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = F.relu(self.bn2(self.conv2(out))) out = self.bn3(self.conv3(out)) out += self.shortcut(x) out = F.relu(out) return out class ResNet(nn.Module): def __init__(self, block, num_blocks, num_classes=3): super(ResNet, self).__init__() self.in_planes = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) self.linear = nn.Linear(512*block.expansion, num_classes) def _make_layer(self, block, planes, num_blocks, stride): strides = [stride] + [1]*(num_blocks-1) layers = [] for stride in strides: layers.append(block(self.in_planes, planes, stride)) self.in_planes = planes * block.expansion return nn.Sequential(*layers) def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = self.layer1(out) out = self.layer2(out) out = self.layer3(out) out = self.layer4(out) out = F.avg_pool2d(out, 4) out = out.view(out.size(0), -1) out = self.linear(out) return out def resnet18(pretrained=False, **kwargs): model = ResNet(BasicBlock, [2,2,2,2], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet18'])) return model def resnet34(pretrained=False, **kwargs): model = ResNet(BasicBlock, [3,4,6,3], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet34'])) return model def resnet50(pretrained=False, **kwargs): model = ResNet(Bottleneck, [3,4,6,3], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet50'])) return model def resnet101(pretrained=False, **kwargs): model = ResNet(Bottleneck, [3,4,23,3], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet101'])) return model def resnet152(pretrained=False, **kwargs): model = ResNet(Bottleneck, [3,8,36,3], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet152'])) return model
the-stack_106_29172
# Copyright 2018 The Cirq Developers # # 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 # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest import sympy import cirq def test_product_duplicate_keys(): with pytest.raises(ValueError): _ = cirq.Linspace('a', 0, 9, 10) * cirq.Linspace('a', 0, 10, 11) def test_zip_duplicate_keys(): with pytest.raises(ValueError): _ = cirq.Linspace('a', 0, 9, 10) * cirq.Linspace('a', 0, 10, 11) def test_linspace(): sweep = cirq.Linspace('a', 0.34, 9.16, 7) assert len(sweep) == 7 params = list(sweep.param_tuples()) assert len(params) == 7 assert params[0] == (('a', 0.34),) assert params[-1] == (('a', 9.16),) def test_linspace_one_point(): sweep = cirq.Linspace('a', 0.34, 9.16, 1) assert len(sweep) == 1 params = list(sweep.param_tuples()) assert len(params) == 1 assert params[0] == (('a', 0.34),) def test_linspace_sympy_symbol(): a = sympy.Symbol('a') sweep = cirq.Linspace(a, 0.34, 9.16, 7) assert len(sweep) == 7 params = list(sweep.param_tuples()) assert len(params) == 7 assert params[0] == (('a', 0.34),) assert params[-1] == (('a', 9.16),) def test_points(): sweep = cirq.Points('a', [1, 2, 3, 4]) assert len(sweep) == 4 params = list(sweep) assert len(params) == 4 def test_zip(): sweep = cirq.Points('a', [1, 2, 3]) + cirq.Points('b', [4, 5, 6, 7]) assert len(sweep) == 3 assert _values(sweep, 'a') == [1, 2, 3] assert _values(sweep, 'b') == [4, 5, 6] def test_product(): sweep = cirq.Points('a', [1, 2, 3]) * cirq.Points('b', [4, 5, 6, 7]) assert len(sweep) == 12 assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3] assert _values(sweep, 'b') == [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7] def _values(sweep, key): p = sympy.Symbol(key) return [resolver.value_of(p) for resolver in sweep] def test_equality(): et = cirq.testing.EqualsTester() et.add_equality_group(cirq.UnitSweep, cirq.UnitSweep) # Simple sweeps with the same key are equal to themselves, but different # from each other even if they happen to contain the same points. et.make_equality_group(lambda: cirq.Linspace('a', 0, 10, 11)) et.make_equality_group(lambda: cirq.Linspace('b', 0, 10, 11)) et.make_equality_group(lambda: cirq.Points('a', list(range(11)))) et.make_equality_group(lambda: cirq.Points('b', list(range(11)))) # Product and Zip sweeps can also be equated. et.make_equality_group( lambda: cirq.Linspace('a', 0, 5, 6) * cirq.Linspace('b', 10, 15, 6)) et.make_equality_group( lambda: cirq.Linspace('a', 0, 5, 6) + cirq.Linspace('b', 10, 15, 6)) et.make_equality_group( lambda: cirq.Points('a', [1, 2]) * (cirq.Linspace('b', 0, 5, 6) + cirq.Linspace('c', 10, 15, 6))) def test_repr(): assert repr(cirq.study.sweeps.Product(cirq.UnitSweep)) == \ 'cirq.study.sweeps.Product(cirq.UnitSweep)' assert repr(cirq.study.sweeps.Zip(cirq.UnitSweep)) == \ 'cirq.study.sweeps.Zip(cirq.UnitSweep)'
the-stack_106_29173
import json # https://docs.python.org/3/library/csv.html # https://django-extensions.readthedocs.io/en/latest/runscript.html import os from index.models import Game_Model, Image_Model def run(): fileNumber = 7 while fileNumber <= 7: with open(f'res/data_{fileNumber}.json', "r") as f: data = json.load(f) for i in data: # print("-------------------------------------------------------------------------") id, cover, genres, name, platforms, developers = None, None, None, None, None, None if 'id' in i: id = i['id'] if 'cover' in i: cover = i['cover'] if 'genres' in i: genres = i["genres"] if 'name' in i: name = i['name'] if 'platforms' in i: platforms = i['platforms'] if 'involved_companies' in i: developers = i['involved_companies'] print("Game Uploaded: ", name, "- Platforms:", platforms) img, created = Image_Model.objects.get_or_create(img_id=id,img_url=cover) game = Game_Model(game_id=int(id), game_title=name,genres={"genres":genres},developers={"developers":developers},platforms ={"platforms":platforms}, img_id=img) game.save() fileNumber+=1
the-stack_106_29175
# -*- coding: utf-8 -*- import lxml.etree import six import zeit.content.article.article import zeit.wochenmarkt.interfaces import zeit.wochenmarkt.testing import zope.component class TestRecipeCategoriesWhitelist( zeit.wochenmarkt.testing.FunctionalTestCase): def test_category_should_be_found_through_xml(self): categories = zope.component.getUtility( zeit.wochenmarkt.interfaces.IRecipeCategoriesWhitelist)._load() pizza = dict(categories.items()).get('pizza') assert 'Pizza' == pizza.name def test_category_should_be_found_by_id(self): bowl = zope.component.getUtility( zeit.wochenmarkt.interfaces.IRecipeCategoriesWhitelist).get('bowl') assert 'Bowl' == bowl.name def test_autocomplete_should_be_available_for_categrories(self): result = zope.component.getUtility( zeit.wochenmarkt.interfaces.IRecipeCategoriesWhitelist).search('B') assert 2 == len(result) names = [] for item in result: names.append(item.name) assert u'Barbecue' in names class TestRecipeCategories( zeit.wochenmarkt.testing.FunctionalTestCase, zeit.wochenmarkt.testing.RecipeCategoriesHelper): def get_content(self): from zeit.wochenmarkt.categories import RecipeCategories from lxml import objectify class Content(object): categories = RecipeCategories() xml = objectify.fromstring('<article><head/></article>') return Content() def test_set_should_add_new_categories(self): categories = self.setup_categories('summer', 'pizza') summer = categories['summer'] pizza = categories['pizza'] content = self.get_content() content.categories = [summer, pizza] result = content.categories self.assertEqual(['summer', 'pizza'], [x.code for x in result]) def test_set_should_add_duplicate_values_only_once(self): categories = self.setup_categories('summer') summer = categories['summer'] content = self.get_content() content.categories = [summer, summer] result = content.categories self.assertEqual(['summer'], [x.code for x in result]) def test_set_should_write_categories_to_xml_head(self): categories = self.setup_categories('summer') summer = categories['summer'] content = self.get_content() content.categories = [summer] self.assertEllipsis( '<recipe_categories...><category code="summer"/>...', lxml.etree.tostring( content.xml.head.recipe_categories, encoding=six.text_type)) def test_removing_all_categories_should_leave_no_trace(self): categories = self.setup_categories('summer') summer = categories['summer'] content = self.get_content() content.categories = [summer] self.assertEqual(1, len(content.xml.xpath('//recipe_categories'))) content.categories = [] self.assertEqual(0, len(content.xml.xpath('//recipe_categories'))) def test_unavailable_categories_should_just_be_skipped(self): categories = self.setup_categories('servomotoren', 'pizza') servomotoren = categories['servomotoren'] pizza = categories['pizza'] content = self.get_content() content.categories = [servomotoren, pizza] result = content.categories self.assertEqual(['pizza'], [x.code for x in result])
the-stack_106_29179
import os import time import random import ujson as json from typing import List, Set from collections import OrderedDict from nltk.tokenize import word_tokenize from multiprocessing import Manager stop_words = set(corpus.stopwords.words('english')) random.seed(22) base_url = 'https://en.wikipedia.org/?curid={}' class DisjointSet: def __init__(self, n, comp): self.parent = [i for i in range(n)] self.rank = [0 for _ in range(n)] self.comp = comp self.n = n def run(self): for i in range(self.n): for j in range(i + 1, self.n): if self.comp(i, j): self.union(i, j) def find(self, x): if self.parent[x] != x: self.parent[x] = self.find(self.parent[x]) return self.parent[x] def union(self, x, y): xroot = self.find(x) yroot = self.find(y) if xroot == yroot: return if self.rank[xroot] < self.rank[yroot]: self.parent[xroot] = yroot elif self.rank[xroot] > self.rank[yroot]: self.parent[yroot] = xroot else: self.parent[yroot] = xroot self.rank[xroot] += 1 def acronym(phrase: str, stopwords: Set[str], ner=None): cap = lambda x: x[0].upper() + x[1:] def with_dot(l): s = set() for x in l: s.update({x, x + '.'}) return s time_name = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december', 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'] if phrase.lower() in time_name: abbr = with_dot([cap(phrase[:3])]) if phrase.lower() == 'september': abbr.update(with_dot(['Sept'])) elif phrase.lower() == 'tuesday': abbr.update(with_dot(['Tu', 'Tues'])) elif phrase.lower() == 'thursday': abbr.update(with_dot(['Thur', 'Thurs', 'Th'])) return abbr abbr = {phrase} words = word_tokenize(phrase) stand_form = [] for w in words: if w in stopwords: stand_form.append(w.lower()) else: stand_form.append(cap(w.lower())) abbr.add(' '.join(stand_form)) words = [w for w in words if w not in stopwords] # if len(words) == 1 or ner == 'PERSON': # return abbr # first_cap_letters = [w[0].upper() for w in words] # abbr.add('.'.join(first_cap_letters)) # abbr.add(''.join(first_cap_letters)) # abbr.add('.'.join(first_cap_letters)+'.') return abbr # ------------------- parsing and linking section ------------------- def link(sents): mentions = [] for i_s, s in enumerate(sents): if s['text'] != '.': for i_m, m in enumerate(s['mentions']): mentions.append(Mention(m['start'], m['end'], s['text'], m['ner'], m['text'], i_s, i_m)) abbr = acronym(m['text'], stop_words, ner=m['ner']) mentions[-1].alias = abbr def get_entities(mention: Mention): mset = mention.alias for m in mset: ment_info = share_src.ment_ent_dict.get(m) if ment_info: mention.total_num += ment_info['total'] for eid, freq_name in ment_info['entities'].items(): eid = int(eid) freq = freq_name['freq'] name = freq_name['name'] if eid in mention.candidates: mention.candidates[eid].freq = max(mention.candidates[eid].freq, freq) else: mention.candidates[eid] = Entity(eid, name, freq) true_ent = share_src.redirects.get(m, None) if true_ent: eid, name = int(true_ent['id']), true_ent['name'] if eid in mention.candidates: mention.candidates[eid].freq = 1.0 else: mention.candidates[eid] = Entity(eid, name, 1.0) cands = mention.candidates.items() cands = sorted(cands, key=lambda x: x[1].freq, reverse=True) mention.candidates = [c[1] for c in cands] # only for names def coref(mentions: List[Mention]): mention_person = [] for m in mentions: if m.ner == 'PERSON': mention_person.append(m) elif len(m.candidates) > 0: highest_candidate: Entity = m.candidates[0] if highest_candidate.name in share_src.persons: mention_person.append(m) # mention_person = sorted(mention_person,lambda x:len(x.text)) mention_num = len(mention_person) def is_same_person(i1, i2): if i1 == i2: return True m1, m2 = mention_person[i1].text, mention_person[i2].text return str_contain(m1, m2) or str_contain(m2, m1) dset = DisjointSet(mention_num, is_same_person) dset.run() # candidate implement person_cand = {} for k in set(dset.parent): person_cand[k] = {} for i_m, m in enumerate(mention_person): label = dset.parent[i_m] for ent in m.candidates: eid = ent.id if eid in person_cand[label]: person_cand[label][eid].update(ent) else: person_cand[label][eid] = ent for i_m, m in enumerate(mention_person): label = dset.parent[i_m] tmp = person_cand[label].items() tmp = sorted(tmp, key=lambda x: x[1].freq, reverse=True) m.candidates = [t[1] for t in tmp] for m in mentions: get_entities(m) coref(mentions) for m in mentions: if m.candidates is None or len(m.candidates) <= 0: continue sent_id, ment_id = m.sent_id, m.ment_id ment = sents[sent_id]['mentions'][ment_id] cands = [m.candidates[0]] # maybe more than one candidates have frequency = 1 if abs(cands[0].freq - 1.0) < 1e-4: for i in range(1, len(m.candidates)): if abs(m.candidates[i].freq - 1.0) < 1e-4: if m.candidates[i].id not in share_src.disambiguation_id2name: cands.append(m.candidates[i]) else: pass else: break if cands[0].id in share_src.disambiguation_id2name: if len(cands) == 1: continue else: cands = cands[1:] rand_int = random.randrange(len(cands)) ment['link'] = base_url.format(cands[rand_int].id) ment['entity'] = cands[rand_int].name def write_big_dict(fn, dic, limit=20): with open(fn, 'w') as fw: item = {} for k, v in dic.items(): item[k] = v if len(item) == limit: fw.write(json.dumps(item) + '\n') item = {} if item != {}: fw.write(json.dumps(item)) def read_big_dict(fn): dic = {} for i_line, line in enumerate(open(fn)): line = line.strip() for k, v in json.loads(line).items(): item = {'total': v['total'], 'entities': OrderedDict()} # v = {'total':10,'entities':{51:{'freq':,'name':}} for eid, ent in v['entities'].items(): item['entities'][int(eid)] = ent dic[k] = v return dic def write_ment_ent_dict(sources: List[str], stopwords): ment_ent_dict = {} def read_src(fn: str): for i_l, line in enumerate(open(fn).readlines()): line = line.strip() items = line.split('\t') mention = items[0] if items[1].isdigit(): total_num = int(items[1]) else: continue if total_num >= 1: ment_info = ment_ent_dict.get(mention, None) if ment_info is None: ment_ent_dict[mention] = {'total': total_num, 'entities': {}} ment_info = ment_ent_dict[mention] else: ment_info['total'] += total_num ent_num = len(items[2:]) for ent in items[2:]: ent_items = ent.split(',') if not ent_items[1].isdigit() or (ent_items[1].isdigit() and len(ent_items) == 2): eid = int(ent_items[0]) name = ','.join(ent_items[1:]) num = total_num / ent_num else: if ent_items[0].isdigit() and ent_items[1].isdigit(): eid, num = int(ent_items[0]), int(ent_items[1]) else: print('line:{} does not have right ents'.format(line)) name = ','.join(ent_items[2:]) if eid in ment_info['entities']: prev_freq = ment_info['entities'][eid]['freq'] ment_info['entities'][eid]['freq'] = min((1.0, prev_freq + num / total_num)) else: ment_info['entities'][eid] = {'freq': num / total_num, 'name': name} for src in sources: read_src(src) for ment, item in ment_ent_dict.items(): ents = list(item['entities'].items()) ents = sorted(ents, key=lambda x: x[1]['freq'], reverse=True) ordered_ents = OrderedDict() for eid, ent in ents: ordered_ents[eid] = ent item['entities'] = ordered_ents start = time.time() write_big_dict('/home/hkeaa/ment_ent.dict', ment_ent_dict) print('write dict cost {:.2f}s'.format(time.time() - start)) class Mention: def __init__(self, start, end, ctx, ner, text, sent_id, ment_id, link=None): self.start = start self.end = end self.ctx = ctx self.ner = ner self.text = text self.link = link self.total_num = 0 self.alias = None self.sent_id = sent_id self.ment_id = ment_id self.candidates = {} def __str__(self): return '{}_{}'.format(self.text, self.ner) def __repr__(self): return '{}_{}'.format(self.text, self.ner) class Entity: # wiki id, name, freq def __init__(self, wid, name, freq): self.id = wid self.name = name self.freq = freq def __str__(self): return '{}_{}'.format(self.name, self.id) def __repr__(self): return '{}_{}'.format(self.name, self.id) def __hash__(self): return self.id def __eq__(self, other): return self.id == other.id def update(self, other): self.freq = (self.freq + other.freq) / 2 def read_dict_from_dir(path): dic = {} for fn in os.listdir(path): if fn.endswith('.dict'): tmp = read_big_dict(os.path.join(path, fn)) dic = {**dic, **tmp} print('\tread {} done'.format(fn)) # TODO remove break to read full dictionary # break return dic def str_contain(m: str, n: str): if m == n: return True start = m.find(n) if start == -1: return False end = start + len(n) - 1 # print(m, n, start, end) if (start == 0 or m[start - 1] == ' ') and (end == len(m) - 1 or m[end + 1] == ' '): return True return False class LinkSharedSource: def __init__(self, disam_fn, redirect_fn, ment_ent_fn, person_fn): # self.manager = manager # process_safe = lambda x: self.manager.dict(x) # disambiguation dict : id -- name self.disambiguation_id2name, self.disambiguation_name2id = self.__measure_speed(disam_fn, self.__read_disambiguation, 'disambiguation') # self.disambiguation_id2name = process_safe(self.disambiguation_id2name) # self.disambiguation_name2id = process_safe(self.disambiguation_name2id) # redirect dict: alias -- {id, name} self.redirects = self.__measure_speed(redirect_fn, self.__read_redirects, 'redirect') # ment_ent dict: mention -- {total:int,alias:List[str],entities:{id:{freq:float,name:str}} # self.ment_ent_dict = process_safe(self.__measure_speed(ment_ent_fn,read_big_dict,'mention-entity dictionary')) start = time.time() self.ment_ent_dict = read_dict_from_dir(ment_ent_fn) print('read mention-entity dictionary cost {:.02}s'.format(time.time() - start)) self.persons = self.__measure_speed(person_fn, self.__read_person, 'person names') def __measure_speed(self, fn, func, name): start = time.time() item = func(fn) print('read {} cost {:.2f}s'.format(name, time.time() - start)) return item @staticmethod def __read_person(fn): persons = [] for line in open(fn): persons.append(line.strip()) # persons[line.strip()] = None # persons.add(line.strip()) return persons @staticmethod def __read_disambiguation(fn): disam_id2nme = {} disam_nme2id = {} for line in open(fn): line = line.strip() wid, name = line.split('\t') disam_id2nme[int(wid)] = name disam_nme2id[name] = int(wid) return disam_id2nme, disam_nme2id @staticmethod def __read_redirects(fn): redirects = {} for line in open(fn): alias, name, id = line.strip().split('\t') redirects[alias] = {'name': name, 'id': id} return redirects def main(): conll_root = '/home/data/corpora/nytimes/nyt_preprocess/conll' parsed_root = '/home/data/corpora/nytimes/nyt_preprocess/parsed' disam_fn = '/home/hkeaa/data/nel/basic_data/wiki_disambiguation_pages.txt' name_id_fn = '/home/hkeaa/data/nel/basic_data/wiki_name_id_map.txt' redirect_fn = '/home/hkeaa/data/nel/basic_data/wiki_redirects.txt' ment_ent_fn = '/home/hkeaa/ment_ent.dict' person_fn = '/home/hkeaa/data/nel/basic_data/p_e_m_data/persons.txt' share_src = LinkSharedSource(disam_fn, redirect_fn, ment_ent_fn, person_fn) # task = Task({'fn':os.path.j)}) # link(task,share_src) # pem_dir = '/home/hkeaa/data/nel/generated' # crosswiki_wikipedia = os.path.join(pem_dir,'crosswikis_wikipedia_p_e_m.txt') # yago = os.path.join(pem_dir,'yago_p_e_m.txt') # write_ment_ent_dict([crosswiki_wikipedia],set(corpus.stopwords.words('english'))) if __name__ == '__main__': main()
the-stack_106_29180
import errno import os import gevent.socket import six from geventhttpclient import __version__ from geventhttpclient.connectionpool import ConnectionPool from geventhttpclient.header import Headers from geventhttpclient.response import HTTPConnectionClosed from geventhttpclient.response import HTTPSocketPoolResponse from geventhttpclient.url import URL CRLF = "\r\n" WHITESPACE = " " FIELD_VALUE_SEP = ": " HOST_PORT_SEP = ":" SLASH = "/" PROTO_HTTP = "http" PROTO_HTTPS = "https" HEADER_HOST = "Host" HEADER_CONTENT_LENGTH = "Content-Length" METHOD_GET = "GET" METHOD_HEAD = "HEAD" METHOD_POST = "POST" METHOD_PUT = "PUT" METHOD_DELETE = "DELETE" METHOD_PATCH = "PATCH" METHOD_OPTIONS = "OPTIONS" METHOD_TRACE = "TRACE" def _get_body_length(body): """ Get len of string or file :param body: :return: :rtype: int """ try: return len(body) except TypeError: try: return os.fstat(body.fileno()).st_size except (AttributeError, OSError): return None class HTTPClient(object): HTTP_11 = 'HTTP/1.1' HTTP_10 = 'HTTP/1.0' BLOCK_SIZE = 1024 * 4 # 4KB DEFAULT_HEADERS = Headers({ 'User-Agent': 'python/gevent-http-client-' + __version__ }) @classmethod def from_url(cls, url, **kw): if not isinstance(url, URL): url = URL(url) enable_ssl = url.scheme == PROTO_HTTPS if not enable_ssl: kw.pop('ssl_options', None) return cls(url.host, port=url.port, ssl=enable_ssl, **kw) def __init__(self, host, port=None, headers=None, block_size=BLOCK_SIZE, connection_timeout=ConnectionPool.DEFAULT_CONNECTION_TIMEOUT, network_timeout=ConnectionPool.DEFAULT_NETWORK_TIMEOUT, disable_ipv6=False, concurrency=1, ssl=False, ssl_options=None, ssl_context_factory=None, insecure=False, proxy_host=None, proxy_port=None, version=HTTP_11, headers_type=Headers): if headers is None: headers = {} self.host = host self.port = port connection_host = self.host connection_port = self.port if proxy_host is not None: assert proxy_port is not None, \ 'you have to provide proxy_port if you set proxy_host' self.use_proxy = True connection_host = proxy_host connection_port = proxy_port else: self.use_proxy = False if ssl: ssl_options = ssl_options.copy() if ssl_options else {} if ssl_options is not None: if ssl_context_factory is not None: requested_hostname = headers.get('host', self.host) ssl_options.setdefault('server_hostname', requested_hostname) self.ssl = True if not self.port: self.port = 443 if not connection_port: connection_port = self.port # Import SSL as late as possible, fail hard with Import Error from geventhttpclient.connectionpool import SSLConnectionPool self._connection_pool = SSLConnectionPool( connection_host, connection_port, self.host, self.port, size=concurrency, ssl_options=ssl_options, ssl_context_factory=ssl_context_factory, insecure=insecure, network_timeout=network_timeout, connection_timeout=connection_timeout, disable_ipv6=disable_ipv6, use_proxy=self.use_proxy ) else: self.ssl = False if not self.port: self.port = 80 if not connection_port: connection_port = self.port self._connection_pool = ConnectionPool( connection_host, connection_port, self.host, self.port, size=concurrency, network_timeout=network_timeout, connection_timeout=connection_timeout, disable_ipv6=disable_ipv6, use_proxy=self.use_proxy ) self.version = version self.headers_type = headers_type self.default_headers = headers_type() self.default_headers.update(self.DEFAULT_HEADERS) self.default_headers.update(headers) self.block_size = block_size self._base_url_string = str(self.get_base_url()) def get_base_url(self): url = URL() url.host = self.host url.port = self.port url.scheme = self.ssl and PROTO_HTTPS or PROTO_HTTP return url def close(self): self._connection_pool.close() # Like urllib2, try to treat the body as a file if we can't determine the # file length with `len()` def _build_request(self, method, request_uri, body="", headers=None): """ :param method: :type method: basestring :param request_uri: :type request_uri: basestring :param body: :type body: basestring or file :param headers: :type headers: dict :return: :rtype: basestring """ if headers is None: headers = {} header_fields = self.headers_type() header_fields.update(self.default_headers) header_fields.update(headers) if self.version == self.HTTP_11 and HEADER_HOST not in header_fields: host_port = self.host if self.port not in (80, 443): host_port += HOST_PORT_SEP + str(self.port) header_fields[HEADER_HOST] = host_port if body and HEADER_CONTENT_LENGTH not in header_fields: body_length = _get_body_length(body) if body_length: header_fields[HEADER_CONTENT_LENGTH] = body_length request_url = request_uri if self.use_proxy: base_url = self._base_url_string if request_uri.startswith(SLASH): base_url = base_url[:-1] request_url = base_url + request_url elif not request_url.startswith((SLASH, PROTO_HTTP)): request_url = SLASH + request_url elif request_url.startswith(PROTO_HTTP): if request_url.startswith(self._base_url_string): request_url = request_url[len(self._base_url_string) - 1:] else: raise ValueError("Invalid host in URL") request = method + WHITESPACE + request_url + WHITESPACE + self.version + CRLF for field, value in header_fields.items(): request += field + FIELD_VALUE_SEP + str(value) + CRLF request += CRLF return request def request(self, method, request_uri, body=b"", headers=None): """ :param method: :param request_uri: :param body: byte or file :param headers: :return: """ if isinstance(body, six.text_type): body = body.encode('utf-8') request = self._build_request( method.upper(), request_uri, body=body, headers=headers) attempts_left = self._connection_pool.size + 1 while 1: sock = self._connection_pool.get_socket() try: _request = request.encode() if body: if isinstance(body, six.binary_type): sock.sendall(_request + body) else: sock.sendall(_request) # TODO: Support non file-like iterables, e.g. `(u"string1", u"string2")`. if six.PY3: sock.sendfile(body) else: while True: chunk = body.read(65536) if not chunk: break sock.sendall(chunk) else: sock.sendall(_request) except gevent.socket.error as e: self._connection_pool.release_socket(sock) if (e.errno == errno.ECONNRESET or e.errno == errno.EPIPE) and attempts_left > 0: attempts_left -= 1 continue raise e try: response = HTTPSocketPoolResponse(sock, self._connection_pool, block_size=self.block_size, method=method.upper(), headers_type=self.headers_type) except HTTPConnectionClosed as e: # connection is released by the response itself if attempts_left > 0: attempts_left -= 1 continue raise e else: response._sent_request = request return response def get(self, request_uri, headers={}): return self.request(METHOD_GET, request_uri, headers=headers) def head(self, request_uri, headers=None): return self.request(METHOD_HEAD, request_uri, headers=headers) def post(self, request_uri, body=u'', headers=None): return self.request(METHOD_POST, request_uri, body=body, headers=headers) def put(self, request_uri, body=u'', headers=None): return self.request(METHOD_PUT, request_uri, body=body, headers=headers) def delete(self, request_uri, body=u'', headers=None): return self.request(METHOD_DELETE, request_uri, body=body, headers=headers) def patch(self, request_uri, body=u'', headers=None): return self.request(METHOD_PATCH, request_uri, body=body, headers=headers) def trace(self, request_uri, body=u'', headers=None): return self.request(METHOD_TRACE, request_uri, body=body, headers=headers) def options(self, request_uri, headers=None): return self.request(METHOD_OPTIONS, request_uri, headers=headers) class HTTPClientPool(object): """ Factory for maintaining a bunch of clients, one per host:port """ # TODO: Add some housekeeping and cleanup logic def __init__(self, **kwargs): self.clients = dict() self.client_args = kwargs def get_client(self, url): if not isinstance(url, URL): url = URL(url) client_key = url.host, url.port try: return self.clients[client_key] except KeyError: client = HTTPClient.from_url(url, **self.client_args) self.clients[client_key] = client return client def close(self): for client in self.clients.values(): client.close()
the-stack_106_29182
# # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # """End-to-end test for the streaming wordcount example. Important: End-to-end test infrastructure for streaming pipeine in Python SDK is in development and is not yet available for use. Currently, this test blocks until the job is manually terminated. """ import datetime import logging import random import unittest import uuid from hamcrest.core.core.allof import all_of from nose.plugins.attrib import attr from apache_beam.examples import streaming_wordcount from apache_beam.io.gcp.tests.pubsub_matcher import PubSubMessageMatcher from apache_beam.runners.runner import PipelineState from apache_beam.testing import test_utils from apache_beam.testing.pipeline_verifiers import PipelineStateMatcher from apache_beam.testing.test_pipeline import TestPipeline INPUT_TOPIC = 'wc_topic_input' OUTPUT_TOPIC = 'wc_topic_output' INPUT_SUB = 'wc_subscription_input' OUTPUT_SUB = 'wc_subscription_output' DEFAULT_INPUT_NUMBERS = 500 class StreamingWordCountIT(unittest.TestCase): def setUp(self): self.test_pipeline = TestPipeline(is_integration_test=True) self.project = self.test_pipeline.get_option('project') self.uuid = str(uuid.uuid4()) # Set up PubSub environment. from google.cloud import pubsub self.pubsub_client = pubsub.Client(project=self.project) self.input_topic = self.pubsub_client.topic(INPUT_TOPIC + self.uuid) self.output_topic = self.pubsub_client.topic(OUTPUT_TOPIC + self.uuid) self.input_sub = self.input_topic.subscription(INPUT_SUB + self.uuid) self.output_sub = self.output_topic.subscription(OUTPUT_SUB + self.uuid) self.input_topic.create() self.output_topic.create() test_utils.wait_for_topics_created([self.input_topic, self.output_topic]) self.input_sub.create() self.output_sub.create() def _generate_identifier(self): seed = random.randint(0, 999) current_time = datetime.datetime.now().strftime('%m%d%H%M%S') return '%s%d' % (current_time, seed) def _inject_numbers(self, topic, num_messages): """Inject numbers as test data to PubSub.""" logging.debug('Injecting %d numbers to topic %s', num_messages, topic.full_name) for n in range(num_messages): topic.publish(str(n)) def _cleanup_pubsub(self): test_utils.cleanup_subscriptions([self.input_sub, self.output_sub]) test_utils.cleanup_topics([self.input_topic, self.output_topic]) def tearDown(self): self._cleanup_pubsub() @attr('IT') def test_streaming_wordcount_it(self): # Build expected dataset. expected_msg = [('%d: 1' % num) for num in range(DEFAULT_INPUT_NUMBERS)] # Set extra options to the pipeline for test purpose state_verifier = PipelineStateMatcher(PipelineState.RUNNING) pubsub_msg_verifier = PubSubMessageMatcher(self.project, OUTPUT_SUB + self.uuid, expected_msg, timeout=400) extra_opts = {'input_subscription': self.input_sub.full_name, 'output_topic': self.output_topic.full_name, 'on_success_matcher': all_of(state_verifier, pubsub_msg_verifier)} # Generate input data and inject to PubSub. test_utils.wait_for_subscriptions_created([self.input_sub]) self._inject_numbers(self.input_topic, DEFAULT_INPUT_NUMBERS) # Get pipeline options from command argument: --test-pipeline-options, # and start pipeline job by calling pipeline main function. streaming_wordcount.run( self.test_pipeline.get_full_options_as_args(**extra_opts)) if __name__ == '__main__': logging.getLogger().setLevel(logging.DEBUG) unittest.main()
the-stack_106_29183
from typing import Union class Vehicle: def __init__(self, type: str, model: str, price: int) -> None: self.type: str = type self.model: str = model self.price: int = price self.owner: Union[str, None] = None def buy(self, money: int, owner: str) -> str: if self.owner == None and self.price <= money: self.owner = owner return f'Successfully bought a {self.type}. Change: {money - self.price:.2f}' elif self.owner != None: return 'Car already sold' elif self.price > money: return 'Sorry, not enough money' def sell(self) -> Union[str, None]: if self.owner == None: return 'Vehicle has no owner' else: self.owner = None def __repr__(self) -> str: if self.owner == None: return f'{self.model} {self.type} is on sale: {self.price}' else: return f'{self.model} {self.type} is owned by: {self.owner}' # vehicle_type = "car" # model = "BMW" # price = 30000 # vehicle = Vehicle(vehicle_type, # model, price) # print(vehicle.buy(15000, "Peter")) # print(vehicle.buy(35000, "George")) # print(vehicle) # vehicle.sell() # print(vehicle)
the-stack_106_29184
# encoding = utf-8 import os import pdb import time import numpy as np import torch from torch import optim from torch.autograd import Variable from dataloader.dataloaders import train_dataloader, val_dataloader from network import get_model from eval import evaluate from options import opt from scheduler import schedulers from utils import init_log, seed_everything, load_meta, save_meta from mscv.summary import create_summary_writer, write_meters_loss, write_image from mscv.image import tensor2im # from utils.send_sms import send_notification import misc_utils as utils import random import albumentations as A from albumentations.pytorch.transforms import ToTensorV2 # 初始化 with torch.no_grad(): # 设置随机种子 if opt.seed is not None: seed_everything(opt.seed) # 初始化路径 save_root = os.path.join(opt.checkpoint_dir, opt.tag) log_root = os.path.join(opt.log_dir, opt.tag) utils.try_make_dir(save_root) utils.try_make_dir(log_root) # dataloader train_dataloader = train_dataloader val_dataloader = val_dataloader # 初始化日志 logger = init_log(training=True) # 初始化训练的meta信息 meta = load_meta(new=True) save_meta(meta) # 初始化模型 Model = get_model(opt.model) model = Model(opt, logger) # 暂时还不支持多GPU # if len(opt.gpu_ids): # model = torch.nn.DataParallel(model, device_ids=opt.gpu_ids) model = model.to(device=opt.device) if opt.load: load_epoch = model.load(opt.load) start_epoch = load_epoch + 1 if opt.resume else 1 else: start_epoch = 1 model.train() # 开始训练 print('Start training...') start_step = (start_epoch - 1) * len(train_dataloader) global_step = start_step total_steps = opt.epochs * len(train_dataloader) start = time.time() # 定义scheduler scheduler = model.scheduler # tensorboard日志 writer = create_summary_writer(log_root) start_time = time.time() # 在日志记录transforms logger.info('train_trasforms: ' +str(train_dataloader.dataset.transforms)) logger.info('===========================================') if val_dataloader is not None: logger.info('val_trasforms: ' +str(val_dataloader.dataset.transforms)) logger.info('===========================================') # 在日志记录scheduler if opt.scheduler in schedulers: logger.info('scheduler: (Lambda scheduler)\n' + str(schedulers[opt.scheduler])) logger.info('===========================================') # 训练循环 try: eval_result = '' for epoch in range(start_epoch, opt.epochs + 1): for iteration, sample in enumerate(train_dataloader): global_step += 1 # 计算剩余时间 rate = (global_step - start_step) / (time.time() - start) remaining = (total_steps - global_step) / rate # --debug模式下只训练10个batch if opt.debug and iteration > 10: break sample['global_step'] = global_step # 更新网络参数 updated = model.update(sample) predicted = updated.get('predicted') pre_msg = 'Epoch:%d' % epoch # 显示进度条 msg = f'lr:{round(scheduler.get_lr()[0], 6) : .6f} (loss) {str(model.avg_meters)} ETA: {utils.format_time(remaining)}' utils.progress_bar(iteration, len(train_dataloader), pre_msg, msg) # print(pre_msg, msg) if global_step % 1000 == 0: # 每1000个step将loss写到tensorboard write_meters_loss(writer, 'train', model.avg_meters, global_step) # 记录训练日志 logger.info(f'Train epoch: {epoch}, lr: {round(scheduler.get_lr()[0], 6) : .6f}, (loss) ' + str(model.avg_meters)) if epoch % opt.save_freq == 0 or epoch == opt.epochs: # 最后一个epoch要保存一下 model.save(epoch) # 训练时验证 if not opt.no_eval and epoch % opt.eval_freq == 0: model.eval() evaluate(model, val_dataloader, epoch, writer, logger, data_name='val') model.train() if scheduler is not None: scheduler.step() # 保存结束信息 if opt.tag != 'cache': with open('run_log.txt', 'a') as f: f.writelines(' Accuracy:' + eval_result + '\n') meta = load_meta() meta[-1]['finishtime'] = utils.get_time_stamp() save_meta(meta) except Exception as e: # if not opt.debug: # debug模式不会发短信 12是短信模板字数限制 # send_notification([opt.tag[:12], str(e)[:12]], template='error') if opt.tag != 'cache': with open('run_log.txt', 'a') as f: f.writelines(' Error: ' + str(e)[:120] + '\n') meta = load_meta() meta[-1]['finishtime'] = utils.get_time_stamp() save_meta(meta) # print(e) raise Exception('Error') # 再引起一个异常,这样才能打印之前的trace back信息 except: # 其他异常,如键盘中断等 meta = load_meta() meta[-1]['finishtime'] = utils.get_time_stamp() save_meta(meta)
the-stack_106_29186
# Copyright 2017 Presys Instrumentos e Sistemas Ltda. # 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. __author__ = "Renato José da Silva" __credits__ = ["Renato José da Silva, Ricardo Lopes de Goes"] __version__ = "1.0.0" __maintainer__ = "Renato José da Silva" __email__ = "[email protected]" from http.client import HTTPConnection from base64 import b64encode import os ipConfigFile = 'ip_address_config.txt' port = 5000 url = '/pconserver/pages/setpconmode.cgi?type={}' method = 'GET' print('Select the desired mode:') print('1 - Control') print('2 - Measure') print('3 - Vent') print('4 - Reset') option = input('') mode = "" if option == '1': mode = 'CONTROL' elif option == '2': mode = 'MEASURE' elif option == '3': mode = "VENT" elif option == '4': mode = "RESETPRESSON" print("Mode: " + mode) username = 'admin' password = 'xvmaster' currentDirectory = os.path.dirname(__file__) fullPath = os.path.join(currentDirectory, ipConfigFile) file = open(fullPath) ipValue = file.read() connection = HTTPConnection(ipValue, port=port) authKey = b64encode((username+":"+password).encode('utf-8')).decode('utf-8') headers = {"Authorization":"Basic " + authKey} connection.request(method, url.format(mode), headers=headers) response = connection.getresponse() print("http://" + ipValue + ":" + str(port) + url.format(mode)) print(response.read().decode())
the-stack_106_29187
# from https://github.com/amdegroot/ssd.pytorch import torch from torchvision import transforms import cv2 import numpy as np import types from numpy import random from PIL import Image from torchvision.transforms import functional as F from torchvision.transforms import Normalize as TorchNormalize def intersect(box_a, box_b): max_xy = np.minimum(box_a[:, 2:], box_b[2:]) min_xy = np.maximum(box_a[:, :2], box_b[:2]) inter = np.clip((max_xy - min_xy), a_min=0, a_max=np.inf) return inter[:, 0] * inter[:, 1] def jaccard_numpy(box_a, box_b): """Compute the jaccard overlap of two sets of boxes. The jaccard overlap is simply the intersection over union of two boxes. E.g.: A ∩ B / A ∪ B = A ∩ B / (area(A) + area(B) - A ∩ B) Args: box_a: Multiple bounding boxes, Shape: [num_boxes,4] box_b: Single bounding box, Shape: [4] Return: jaccard overlap: Shape: [box_a.shape[0], box_a.shape[1]] """ inter = intersect(box_a, box_b) area_a = ((box_a[:, 2] - box_a[:, 0]) * (box_a[:, 3] - box_a[:, 1])) # [A,B] area_b = ((box_b[2] - box_b[0]) * (box_b[3] - box_b[1])) # [A,B] union = area_a + area_b - inter return inter / union # [A,B] class Compose(object): """Composes several augmentations together. Args: transforms (List[Transform]): list of transforms to compose. Example: >>> augmentations.Compose([ >>> transforms.CenterCrop(10), >>> transforms.ToTensor(), >>> ]) """ def __init__(self, transforms): self.transforms = transforms def __call__(self, img, boxes=None, labels=None): for t in self.transforms: img, boxes, labels = t(img, boxes, labels) return img, boxes, labels class Lambda(object): """Applies a lambda as a transform.""" def __init__(self, lambd): assert isinstance(lambd, types.LambdaType) self.lambd = lambd def __call__(self, img, boxes=None, labels=None): return self.lambd(img, boxes, labels) class ConvertFromInts(object): def __call__(self, image, boxes=None, labels=None): return image.astype(np.float32), boxes, labels class SubtractMeans(object): def __init__(self, mean): self.mean = np.array(mean, dtype=np.float32) def __call__(self, image, boxes=None, labels=None): image = image.astype(np.float32) image -= self.mean return image.astype(np.float32), boxes, labels class ToAbsoluteCoords(object): def __call__(self, image, boxes=None, labels=None): height, width, channels = image.shape boxes[:, 0] *= width boxes[:, 2] *= width boxes[:, 1] *= height boxes[:, 3] *= height return image, boxes, labels class ToPercentCoords(object): def __call__(self, image, boxes=None, labels=None): height, width, channels = image.shape boxes[:, 0] /= width boxes[:, 2] /= width boxes[:, 1] /= height boxes[:, 3] /= height return image, boxes, labels class Normalize(object): def __init__(self, mean=0, std=1): self.mean = mean self.std = std def __call__(self, image, boxes=None, labels=None): image = image-self.mean image = image/self.std return image, boxes, labels class Resize(object): def __init__(self, size=300): self.size = size def __call__(self, image, boxes=None, labels=None): image = cv2.resize(image, (self.size, self.size)) return image, boxes, labels class RandomSaturation(object): def __init__(self, lower=0.5, upper=1.5): self.lower = lower self.upper = upper assert self.upper >= self.lower, "contrast upper must be >= lower." assert self.lower >= 0, "contrast lower must be non-negative." def __call__(self, image, boxes=None, labels=None): if random.randint(2): image[:, :, 1] *= random.uniform(self.lower, self.upper) return image, boxes, labels class RandomHue(object): def __init__(self, delta=18.0): assert delta >= 0.0 and delta <= 360.0 self.delta = delta def __call__(self, image, boxes=None, labels=None): if random.randint(2): image[:, :, 0] += random.uniform(-self.delta, self.delta) image[:, :, 0][image[:, :, 0] > 360.0] -= 360.0 image[:, :, 0][image[:, :, 0] < 0.0] += 360.0 return image, boxes, labels class RandomLightingNoise(object): def __init__(self): self.perms = ((0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)) def __call__(self, image, boxes=None, labels=None): if random.randint(2): swap = self.perms[random.randint(len(self.perms))] shuffle = SwapChannels(swap) # shuffle channels image = shuffle(image) return image, boxes, labels class ConvertColor(object): def __init__(self, current, transform): self.transform = transform self.current = current def __call__(self, image, boxes=None, labels=None): if self.current == 'BGR' and self.transform == 'HSV': image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) elif self.current == 'RGB' and self.transform == 'HSV': image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV) elif self.current == 'BGR' and self.transform == 'RGB': image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) elif self.current == 'HSV' and self.transform == 'BGR': image = cv2.cvtColor(image, cv2.COLOR_HSV2BGR) elif self.current == 'HSV' and self.transform == "RGB": image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB) else: raise NotImplementedError return image, boxes, labels class RandomContrast(object): def __init__(self, lower=0.5, upper=1.5): self.lower = lower self.upper = upper assert self.upper >= self.lower, "contrast upper must be >= lower." assert self.lower >= 0, "contrast lower must be non-negative." # expects float image def __call__(self, image, boxes=None, labels=None): if random.randint(2): alpha = random.uniform(self.lower, self.upper) image *= alpha return image, boxes, labels class RandomBrightness(object): def __init__(self, delta=32): assert delta >= 0.0 assert delta <= 255.0 self.delta = delta def __call__(self, image, boxes=None, labels=None): if random.randint(2): delta = random.uniform(-self.delta, self.delta) image += delta return image, boxes, labels class ToCV2Image(object): def __call__(self, tensor, boxes=None, labels=None): return tensor.cpu().numpy().astype(np.float32).transpose((1, 2, 0)), boxes, labels class ToTensor(object): def __call__(self, cvimage, boxes=None, labels=None): return torch.from_numpy(cvimage.astype(np.float32)).permute(2, 0, 1), boxes, labels class RandomSampleCrop(object): """Crop Arguments: img (Image): the image being input during training boxes (Tensor): the original bounding boxes in pt form labels (Tensor): the class labels for each bbox mode (float tuple): the min and max jaccard overlaps Return: (img, boxes, classes) img (Image): the cropped image boxes (Tensor): the adjusted bounding boxes in pt form labels (Tensor): the class labels for each bbox """ def __init__(self): self.sample_options = ( # using entire original input image None, # sample a patch s.t. MIN jaccard w/ obj in .1,.3,.4,.7,.9 (0.1, None), (0.3, None), (0.7, None), (0.9, None), # randomly sample a patch (None, None), ) def __call__(self, image, boxes=None, labels=None): # guard against no boxes if boxes is not None and boxes.shape[0] == 0: return image, boxes, labels height, width, _ = image.shape while True: # randomly choose a mode mode = random.choice(self.sample_options) if mode is None: return image, boxes, labels min_iou, max_iou = mode if min_iou is None: min_iou = float('-inf') if max_iou is None: max_iou = float('inf') # max trails (50) for _ in range(50): current_image = image w = random.uniform(0.3 * width, width) h = random.uniform(0.3 * height, height) # aspect ratio constraint b/t .5 & 2 if h / w < 0.5 or h / w > 2: continue left = random.uniform(width - w) top = random.uniform(height - h) # convert to integer rect x1,y1,x2,y2 rect = np.array([int(left), int(top), int(left + w), int(top + h)]) # calculate IoU (jaccard overlap) b/t the cropped and gt boxes overlap = jaccard_numpy(boxes, rect) # is min and max overlap constraint satisfied? if not try again # check that at least 1 gtbox has IoU acceptable considering the constraints if overlap.max() < min_iou or overlap.min() > max_iou: continue # cut the crop from the image current_image = current_image[rect[1]:rect[3], rect[0]:rect[2], :] # keep overlap with gt box IF center in sampled patch centers = (boxes[:, :2] + boxes[:, 2:]) / 2.0 # mask in all gt boxes that above and to the left of centers m1 = (rect[0] < centers[:, 0]) * (rect[1] < centers[:, 1]) # mask in all gt boxes that under and to the right of centers m2 = (rect[2] > centers[:, 0]) * (rect[3] > centers[:, 1]) # mask in that both m1 and m2 are true mask = m1 * m2 # have any valid boxes? try again if not if not mask.any(): continue # take only matching gt boxes current_boxes = boxes[mask, :].copy() # take only matching gt labels current_labels = labels[mask] # should we use the box left and top corner or the crop's current_boxes[:, :2] = np.maximum(current_boxes[:, :2], rect[:2]) # adjust to crop (by substracting crop's left,top) current_boxes[:, :2] -= rect[:2] current_boxes[:, 2:] = np.minimum(current_boxes[:, 2:], rect[2:]) # adjust to crop (by substracting crop's left,top) current_boxes[:, 2:] -= rect[:2] return current_image, current_boxes, current_labels class Expand(object): def __init__(self, mean): self.mean = mean def __call__(self, image, boxes, labels): if random.randint(2): return image, boxes, labels height, width, depth = image.shape ratio = random.uniform(1, 4) left = random.uniform(0, width * ratio - width) top = random.uniform(0, height * ratio - height) expand_image = np.zeros( (int(height * ratio), int(width * ratio), depth), dtype=image.dtype) expand_image[:, :, :] = self.mean expand_image[int(top):int(top + height), int(left):int(left + width)] = image image = expand_image boxes = boxes.copy() boxes[:, :2] += (int(left), int(top)) boxes[:, 2:] += (int(left), int(top)) return image, boxes, labels class RandomMirror(object): def __call__(self, image, boxes, classes): _, width, _ = image.shape if random.randint(2): image = image[:, ::-1] boxes = boxes.copy() boxes[:, 0::2] = width - boxes[:, 2::-2] return image, boxes, classes class SwapChannels(object): """Transforms a tensorized image by swapping the channels in the order specified in the swap tuple. Args: swaps (int triple): final order of channels eg: (2, 1, 0) """ def __init__(self, swaps): self.swaps = swaps def __call__(self, image): """ Args: image (Tensor): image tensor to be transformed Return: a tensor with channels swapped according to swap """ # if torch.is_tensor(image): # image = image.data.cpu().numpy() # else: # image = np.array(image) image = image[:, :, self.swaps] return image class PhotometricDistort(object): def __init__(self): self.pd = [ RandomContrast(), # RGB ConvertColor(current="RGB", transform='HSV'), # HSV RandomSaturation(), # HSV RandomHue(), # HSV ConvertColor(current='HSV', transform='RGB'), # RGB RandomContrast() # RGB ] self.rand_brightness = RandomBrightness() self.rand_light_noise = RandomLightingNoise() def __call__(self, image, boxes, labels): im = image.copy() im, boxes, labels = self.rand_brightness(im, boxes, labels) if random.randint(2): distort = Compose(self.pd[:-1]) else: distort = Compose(self.pd[1:]) im, boxes, labels = distort(im, boxes, labels) return self.rand_light_noise(im, boxes, labels) class Lambda(object): """Apply a user-defined lambda as a transform. Args: lambd (function): Lambda/function to be used for transform. """ def __init__(self, lambd): assert isinstance(lambd, types.LambdaType) self.lambd = lambd def __call__(self, img, bboxes=None, labels=None): return self.lambd(img), bboxes, labels def __repr__(self): return self.__class__.__name__ + '()' class SSDColorJitter(object): """Randomly change the brightness, contrast and saturation of an image. Args: brightness (float): How much to jitter brightness. brightness_factor is chosen uniformly from [max(0, 1 - brightness), 1 + brightness]. contrast (float): How much to jitter contrast. contrast_factor is chosen uniformly from [max(0, 1 - contrast), 1 + contrast]. saturation (float): How much to jitter saturation. saturation_factor is chosen uniformly from [max(0, 1 - saturation), 1 + saturation]. hue(float): How much to jitter hue. hue_factor is chosen uniformly from [-hue, hue]. Should be >=0 and <= 0.5. """ def __init__(self, brightness=0, contrast=0, saturation=0, hue=0): self.brightness = brightness self.contrast = contrast self.saturation = saturation self.hue = hue @staticmethod def get_params(brightness, contrast, saturation, hue): """Get a randomized transform to be applied on image. Arguments are same as that of __init__. Returns: Transform which randomly adjusts brightness, contrast and saturation in a random order. """ transforms = [] if brightness > 0: brightness_factor = random.uniform(max(0, 1 - brightness), 1 + brightness) transforms.append(Lambda(lambda img: F.adjust_brightness(img, brightness_factor))) if contrast > 0: contrast_factor = random.uniform(max(0, 1 - contrast), 1 + contrast) transforms.append(Lambda(lambda img: F.adjust_contrast(img, contrast_factor))) if saturation > 0: saturation_factor = random.uniform(max(0, 1 - saturation), 1 + saturation) transforms.append(Lambda(lambda img: F.adjust_saturation(img, saturation_factor))) if hue > 0: hue_factor = random.uniform(-hue, hue) transforms.append(Lambda(lambda img: F.adjust_hue(img, hue_factor))) random.shuffle(transforms) transform = Compose(transforms) return transform def __call__(self, img, bboxes=None, bboxes_labels=None): """ Args: img (PIL Image): Input image. Returns: PIL Image: Color jittered image. """ transform = self.get_params(self.brightness, self.contrast, self.saturation, self.hue) PILimg = Image.fromarray(img.astype(np.uint8)) transformed, _, _ = transform(PILimg) array = np.array(transformed.convert("RGB")) # execute at the end a randomlighting noise as per original paper last_trans = RandomLightingNoise() image, _, _ = last_trans(array.astype(np.float32)) return image, bboxes, bboxes_labels def __repr__(self): format_string = self.__class__.__name__ + '(' format_string += 'brightness={0}'.format(self.brightness) format_string += ', contrast={0}'.format(self.contrast) format_string += ', saturation={0}'.format(self.saturation) format_string += ', hue={0})'.format(self.hue) return format_string class ToNormalDomain(object): def __call__(self, image, bboxes=None, labels=None): image = image / 255 return image, bboxes, labels class ToPixelDomain(object): def __call__(self, image, bboxes=None, labels=None): image = image * 255 return image, bboxes, labels class DeNormalize(object): def __init__(self, mean, std, reshape=False): """ if reshape: self.mean = torch.Tensor(mean) self.std = torch.Tensor(std) else: """ self.mean = np.array(mean, dtype=np.float32) self.std = np.array(std, dtype=np.float32) self.reshape = reshape def __call__(self, tensor): if self.reshape: tensor, _, _ = (ToCV2Image())(tensor) tensor = tensor*self.std tensor = tensor+self.mean if self.reshape: tensor, _, _ = (ToTensor())(tensor) return tensor
the-stack_106_29188
from bs4 import BeautifulSoup import numpy as np import requests import re import time import random class TradeList(object): """ A web scraper to extract sales attributes from autotrader.co.uk Specify the make, model, postcode and search radius for the vehicle Part of a larger machine learning sales analytics project. """ def __init__(self, make, car_model, postcode, radius): self.make = make self.car_model = car_model self.postcode = postcode self.radius = radius self.url_format = "http://www.autotrader.co.uk/search/used/cars/{make}/{car_model}/" \ "postcode/{postcode}/radius/{radius}/searchcontext/default/sort/" \ "priceasc/onesearchad/new%2Cnearlynew%2Cused/page/{page_num}" self.soup = None self.print_intro() def print_intro(self): print('=' * 8) print('Autotrader Scraping Tool - Luke Woods 2016') print('Vehicle: {}, {}. Searching... {} miles around {}.' .format(self.make, self.car_model, self.radius, self.postcode)) def get_url(self, page_num=1): """Creates and returns the URL""" return self.url_format.format(make=self.make, car_model=self.car_model, postcode=self.postcode, radius=self.radius, page_num=page_num) def load_page(self, page_num=1): """Runs BeautifulSoup module on the results page.""" r = requests.get(self.get_url(page_num)) self.soup = BeautifulSoup(r.text, "html.parser") def get_num_pages(self): """Returns the number of pages of results.""" page_res = self.soup.html.body.findAll('li', {'class': 'paginationMini__count'}) page_text = ''.join([i.text for i in page_res]) page_nums = (page_text.split(' ')[-1]) return page_nums def get_prices(self): """Returns the car prices in a numpy array""" price_range = self.soup.html.body.findAll('div', {'class': 'search-result__price'}) prices = np.zeros(12) k = 0 for i in price_range: # convert string into integer prices[k] = int(re.sub('[^\d\.]', '', i.text[1:])) k += 1 # remove first and last entries (ads) prices = prices[1:-1] print("Prices extracted ✓") return prices def get_attributes(self): """Returns car attributes""" attributes = self.soup.html.body.findAll('ul', {'class': 'search-result__attributes'}) summary = [] category = [] for k in range(1, 11): car_attr = '' c = 0 for counter, item in enumerate(attributes[k].findAll('li')): if attributes[k].find(class_='js-tooltip') and counter == 0: c = 1 continue else: car_attr += item.text + ' ' category.append(c) summary.append(car_attr) return summary, category def get_url_ids(self): """Return unique url ID.""" links = self.soup.html.body.findAll('a', {'class': 'gui-test-search-result-link'}) url_id = [''] * 10 k = 0 for link in links: url_id[k] = str(re.findall('\d+', link.get('href'))[0]) k += 1 return url_id def get_urls(self): """Return the url.""" links = self.soup.html.body.findAll('a', {'class': 'gui-test-search-result-link'}) url = [''] * 10 k = 0 for link in links: url[k] = link.get('href') k += 1 return url def run(self, listings, pages=3, start_page=1, delay=1): """Loops over search results and returns an array of vehicle attributes""" price_array = np.array([]) attr_array = np.array([], dtype=object) url_id_array = np.array([]) url_array = np.array([]) category_array = np.array([]) print('='*8) print('BEGIN LOOP') ts = time.time() for page_num in range(start_page, start_page + pages): listings.load_page(page_num) print(listings.get_url(page_num)) if page_num == start_page: print(" → of {} total pages".format(listings.get_num_pages())) print('') print("Processing page {} of {}...".format(page_num, pages)) try: # Append attributes into array price_array = np.append(price_array, listings.get_prices()) attr_array = np.append(attr_array, listings.get_attributes()[0]) category_array = np.append(category_array, listings.get_attributes()[1]) url_id_array = np.append(url_id_array, listings.get_url_ids()) url_array = np.append(url_array, listings.get_urls()) except Exception as e: print('An error occurred on page {}: {}'.format(page_num, e)) print(len(price_array), len(attr_array), len(url_id_array), len(url_array)) # Sleep delay random_sleep = delay + delay*(random.randint(0, 1000) / 1000) print('({:0.4} s delay)'.format(random_sleep)) time.sleep(random_sleep) print('') print('Time taken: {:0.2} s'.format(time.time() - ts)) return price_array, attr_array, url_id_array, url_array, category_array
the-stack_106_29189
# qubit number=4 # total number=40 import cirq import qiskit from qiskit.providers.aer import QasmSimulator from qiskit.test.mock import FakeVigo from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister from qiskit import BasicAer, execute, transpile from pprint import pprint from qiskit.test.mock import FakeVigo from math import log2 import numpy as np import networkx as nx def bitwise_xor(s: str, t: str) -> str: length = len(s) res = [] for i in range(length): res.append(str(int(s[i]) ^ int(t[i]))) return ''.join(res[::-1]) def bitwise_dot(s: str, t: str) -> str: length = len(s) res = 0 for i in range(length): res += int(s[i]) * int(t[i]) return str(res % 2) def build_oracle(n: int, f) -> QuantumCircuit: # implement the oracle O_f # NOTE: use multi_control_toffoli_gate ('noancilla' mode) # https://qiskit.org/documentation/_modules/qiskit/aqua/circuits/gates/multi_control_toffoli_gate.html # https://quantumcomputing.stackexchange.com/questions/3943/how-do-you-implement-the-toffoli-gate-using-only-single-qubit-and-cnot-gates # https://quantumcomputing.stackexchange.com/questions/2177/how-can-i-implement-an-n-bit-toffoli-gate controls = QuantumRegister(n, "ofc") target = QuantumRegister(1, "oft") oracle = QuantumCircuit(controls, target, name="Of") for i in range(2 ** n): rep = np.binary_repr(i, n) if f(rep) == "1": for j in range(n): if rep[j] == "0": oracle.x(controls[j]) oracle.mct(controls, target[0], None, mode='noancilla') for j in range(n): if rep[j] == "0": oracle.x(controls[j]) # oracle.barrier() return oracle def make_circuit(n:int,f) -> QuantumCircuit: # circuit begin input_qubit = QuantumRegister(n,"qc") classical = ClassicalRegister(n, "qm") prog = QuantumCircuit(input_qubit, classical) prog.cx(input_qubit[0],input_qubit[3]) # number=13 prog.h(input_qubit[3]) # number=23 prog.cz(input_qubit[0],input_qubit[3]) # number=24 prog.y(input_qubit[1]) # number=37 prog.h(input_qubit[3]) # number=25 prog.x(input_qubit[3]) # number=18 prog.cx(input_qubit[0],input_qubit[3]) # number=19 prog.cx(input_qubit[0],input_qubit[3]) # number=15 prog.h(input_qubit[1]) # number=2 prog.h(input_qubit[2]) # number=3 prog.h(input_qubit[3]) # number=4 prog.y(input_qubit[3]) # number=12 prog.h(input_qubit[0]) # number=5 oracle = build_oracle(n-1, f) prog.append(oracle.to_gate(),[input_qubit[i] for i in range(n-1)]+[input_qubit[n-1]]) prog.h(input_qubit[1]) # number=6 prog.h(input_qubit[2]) # number=7 prog.h(input_qubit[3]) # number=32 prog.cx(input_qubit[3],input_qubit[0]) # number=20 prog.cx(input_qubit[3],input_qubit[0]) # number=26 prog.z(input_qubit[3]) # number=27 prog.h(input_qubit[0]) # number=29 prog.cz(input_qubit[3],input_qubit[0]) # number=30 prog.h(input_qubit[0]) # number=31 prog.h(input_qubit[0]) # number=33 prog.cz(input_qubit[3],input_qubit[0]) # number=34 prog.h(input_qubit[0]) # number=35 prog.h(input_qubit[2]) # number=36 prog.h(input_qubit[3]) # number=8 prog.h(input_qubit[0]) # number=9 prog.y(input_qubit[2]) # number=10 prog.y(input_qubit[2]) # number=11 prog.y(input_qubit[1]) # number=38 prog.y(input_qubit[1]) # number=39 # circuit end for i in range(n): prog.measure(input_qubit[i], classical[i]) return prog if __name__ == '__main__': a = "111" b = "0" f = lambda rep: bitwise_xor(bitwise_dot(a, rep), b) prog = make_circuit(4,f) backend = FakeVigo() sample_shot =8000 info = execute(prog, backend=backend, shots=sample_shot).result().get_counts() backend = FakeVigo() circuit1 = transpile(prog,backend,optimization_level=2) writefile = open("../data/startQiskit_noisy2807.csv","w") print(info,file=writefile) print("results end", file=writefile) print(circuit1.__len__(),file=writefile) print(circuit1,file=writefile) writefile.close()
the-stack_106_29190
''' ___ _ ___ __ _______ /\/\ _ __ / _ \ | __ _ _ _ ___ _ __ / __\ / / \_ _ / / \| '__/ /_)/ |/ _` | | | |/ _ \ '__|____ / / / / / / / /\/\ \ | / ___/| | (_| | |_| | __/ | |_____/ /___/ /___/\/ /_ \/ \/_| \/ |_|\__,_|\__, |\___|_| \____/\____/\____/ |___/ ''' ############################################################################## # (c) Akshat Chauhan ,2021 # # This is the command line interface for MrPlayer # # this can play any Mp3 file # # MrPlayer can be downloaded from https://AkshatChauhan18.github.io/MrPlayer # ############################################################################## import argparse import pygame from rich import console from rich.syntax import Syntax from prompt_toolkit.application import Application from prompt_toolkit.application.current import get_app from prompt_toolkit.key_binding import KeyBindings from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous from prompt_toolkit.layout import HSplit, Layout, VSplit from prompt_toolkit.styles import Style from prompt_toolkit.widgets import Box, Button, Frame, Label, TextArea import lyricsgenius import os import os.path import shutil pygame.mixer.init() console = console.Console() dest_f = f"{os.path.expanduser('~')}\\Music\\MrPlayer-songs" def player(args): if args.playsong: pygame.mixer.music.load(args.playsong.strip()) pygame.mixer.music.play() def play_clicked(): pygame.mixer.music.unpause() def pause_clicked(): pygame.mixer.music.pause() def exit_clicked(): pygame.mixer.music.stop() get_app().exit() def rewind(): pygame.mixer.music.rewind() # All the widgets for the UI. play_btn = Button("Play", handler=play_clicked) pause_btn = Button("Pause", handler=pause_clicked) rewind_btn = Button("Rewind", handler=rewind) exit_btn = Button("Exit", handler=exit_clicked) text_area = TextArea(focusable=False, height=10, width=70) text_area.text = ''' ___ _ ___ __ _______ /\/\ _ __ / _ \ | __ _ _ _ ___ _ __ / __\ / / \_ _ / / \| '__/ /_)/ |/ _` | | | |/ _ \ '__|____ / / / / / / / /\/\ \ | / ___/| | (_| | |_| | __/ | |_____/ /___/ /___/\/ /_ \/ \/_| \/ |_|\__,_|\__, |\___|_| \____/\____/\____/ |___/ ''' copy_right_label = Label(text='Copyright (c)\n2021,\nAkshat Chauhan') song_name = Label(text=f"Now playing {args.playsong}") # Combine all the widgets in a UI. # The `Box` object ensures that padding will be inserted around the containing # widget. It adapts automatically, unless an explicit `padding` amount is given. root_container = Box( HSplit( [ Label(text="Press `Tab` to move down and `Shift+Tab` to move up"), VSplit( [ Box( body=HSplit( [play_btn, pause_btn, rewind_btn, exit_btn, copy_right_label], padding=1), padding=1, style="class:left-pane", ), Box( HSplit( [ Box( body=Frame( text_area ) ), Box( body=Frame(song_name) ) ]) , padding=1, style="class:right-pane"), ] ) ] ), ) layout = Layout(container=root_container, focused_element=pause_btn) # Key bindings. kb = KeyBindings() kb.add("tab")(focus_next) kb.add("s-tab")(focus_previous) # Styling. style = Style( [ ("left-pane", "bg:#888800 #000000"), ("right-pane", "bg:#00aa00 #000000"), ("button", "#000000"), ("button-arrow", "#000000"), ("button focused", "bg:#ff0000"), ("text-area focused", "bg:#ff0000"), ] ) # Build a main application object. application = Application( layout=layout, key_bindings=kb, style=style, full_screen=True) application.run() if args.getlyrics: song=None try: api_key = open( f"{os.path.expanduser('~')}\\.MrPlayer\\api_key.txt").read() genius = lyricsgenius.Genius(api_key) if args.singer: song = genius.search_song(args.getlyrics.strip(), args.singer.strip()) else: song = genius.search_song(args.getlyrics.strip(),'') lyrics = song.lyrics console.rule(f'[bold red]{args.getlyrics}') console.print(lyrics) except: console.print_exception() if args.version: console.print('[green]v1.1.0') if args.sourcecode: console.rule('[bold red]Code') code_file = Syntax.from_path(f"{os.path.expanduser('~')}\\.MrPlayer\\mpc.py",line_numbers=True) # this file will be created by installer console.print(code_file) if args.addtrack: try: file = str(args.addtrack) if file.endswith('.mp3'): if args.movetrack: console.print('[cyan]Moving track ...') shutil.move(f'{file}', dest_f) console.print('[green]Done') else: console.print('[cyan]Coping track ...') shutil.copy(f'{file}', dest_f) console.print('[green]Done') else: console.print('[red]Sorry not a ".mp3" file !') except Exception as e: console.print(f'[red]{e}') if args.addfolder: files = os.listdir(args.addfolder) try: if args.movetrack: for track in files: if track.endswith('.mp3'): console.print(f'[cyan]Moving track [yellow]{track} ...') shutil.move(f'{args.addfolder}\\{track}', dest_f) console.print('[green]Done') else: for track in files: if track.endswith('.mp3'): console.print(f'[cyan]Coping track [yellow]{track} ...') shutil.copy(f'{args.addfolder}\\{track}', dest_f) console.print('[green]Done') except Exception as e: console.print(f'[red]{e}') if __name__ == '__main__': parse = argparse.ArgumentParser() parse.add_argument('-ps', '--playsong', help='This command is for playing mp3') parse.add_argument('-gl', '--getlyrics', help='This command gets lyrics') parse.add_argument('-si', '--singer', help='This command is used with --gl command to enter singer') parse.add_argument('-v', '--version', help='This command shows current version',action='store_true') parse.add_argument('-sc', '--sourcecode', help='This command shows the source code.',action='store_true') parse.add_argument('-at ', '--addtrack', help='This command is used add sound track to MrPlayer folder.') parse.add_argument('-af', '--addfolder', help='This command is used to add all sound tracks of the specified folder to the MrPlayer folder') parse.add_argument('-m', '--movetrack', help= 'This command is used with "-at" & "-af" to move sound track instead of copying sound track', action='store_true') args = parse.parse_args() player(args)
the-stack_106_29191
""" LIF (Leaky integrate-and-fire) Neuron model Copyright(c) HiroshiARAKI """ import numpy as np import matplotlib.pyplot as plt from .neuron import Neuron from ..tools import kernel class LIF(Neuron): """ LIF: leaky integrate-and-fire model """ def __init__(self, time: int, dt: float = 1.0, rest=-65, th=-40, ref=3, tc_decay=100, k='single', tau: tuple = (20, ), **kwargs): """ Initialize Neuron parameters :param time: experimental time :param dt: time step :param rest: resting potential :param th: threshold :param ref: refractory period :param tc_decay: time constance :param k: kernel {'single', 'double'} :param tau: exponential decays as tuple(tau_1 ,tau_2) or float """ super().__init__(time, dt) if k not in ['single', 'double']: print('The kernel is selected "single".') k = 'single' self.rest = kwargs.get('rest', rest) self.th = kwargs.get('th', th) self.ref = kwargs.get('ref', ref) self.tc_decay = kwargs.get('tc_decay', tc_decay) self.monitor = {} self.kernel = kernel[kwargs.get('k', k)] # default: single exp filter self.tau = tau if type(tau) is tuple else (tau, ) def calc_v(self, data): """ Calculate Membrane Voltage :param data: tuple(spikes[], weight[]) :return: """ spikes = np.array(data[0]) weights = np.array(data[1]) data = [ spikes[i] * weights[i] for i in range(weights.size) ] time = int(self.time / self.dt) data = np.sum(data, 0) data = np.convolve(data, self.kernel(np.arange(0, self.time, self.dt), self.tau) )[0:time] # initialize f_last = 0 # last firing time vpeak = 20 # the peak of membrane voltage spikes = np.zeros(time) v = self.rest # set to resting voltage v_monitor = [] # monitor voltage # Core of LIF for t in range(time): dv = ((self.dt * t) > (f_last + self.ref)) * (-v + self.rest) / self.tc_decay + data[t] v = v + self.dt * dv # calc voltage f_last = f_last + (self.dt * t - f_last) * (v >= self.th) # if fires, memory the firing time v = v + (vpeak - v) * (v >= self.th) # set to peak v_monitor.append(v) spikes[t] = (v >= self.th) * 1 # set to spike v = v + (self.rest - v) * (v >= self.th) # return to resting voltage self.monitor['s'] = spikes self.monitor['v'] = v_monitor self.monitor['f'] = np.arange(0, self.time, self.dt)[v >= self.th], # real firing times return v_monitor, spikes, self.monitor['f'] def plot_v(self, save=False, filename='lif.png', **kwargs): """ plot membrane potential :param save: :param filename: :param kwargs: :return: """ x = np.arange(0, self.time, self.dt) plt.title('LIF Neuron model Simulation') plt.plot(x, self.monitor['v']) plt.ylabel('V [mV]') plt.xlabel('time [ms]') if not save: plt.show() else: plt.savefig(filename, dpi=kwargs.get('dpi', 150)) plt.close() class IF(LIF): """ IF: integrate-and-fire model """ def __init__(self, time: int, dt: float = 1.0, rest=-65, th=-40, ref=3, k='single', tau: tuple = (20, ), **kwargs): """ Initialize Neuron parameters :param time: :param dt: :param rest: :param th: :param ref: :param k: :param tau: :param kwargs: """ super().__init__(time=time, dt=dt, rest=rest, th=th, ref=ref, k=k, tau=tau, **kwargs) def calc_v(self, data): """ Calculate Membrane Voltage :param data: tuple(spikes[], weight[]) :return membrane voltage, output spikes, firing times: """ spikes = np.array(data[0]) weights = np.array(data[1]) peak = 20 # the peak of membrane voltage f_last = -100 # last firing time t_ref = int(self.ref / self.dt) # refractory period [x dt ms] v = np.zeros(int(self.time / self.dt)) + self.rest # all membrane voltage set to resting vol. input_spikes = np.array([ spikes[i] * weights[i] for i in range(weights.size) ]) input_spikes = np.sum(input_spikes, 0) for t, s in enumerate(input_spikes): if s: # if fires, # and be not in refractory period, calculate voltage v[t:] += (t > (f_last + t_ref)) * s * self.kernel(np.arange(0, v[t:].size, 1) * self.dt, self.tau) if v[t] >= self.th: v[t] = peak v[t+1:] = self.rest # return to resting voltage f_last = t # memory the firing time self.monitor = { 'v': v, 's': [v >= self.th], # boolean spike trains 'f': np.arange(0, self.time, self.dt)[v >= self.th], # real firing times } return v, self.monitor['s'], self.monitor['f']
the-stack_106_29195
from kit.dependency_file import * class probability: def set_exp_pr(self,pop,pressure): self.pop = pop; sigma = 0; for x in (pop): sigma += (math.exp(-pressure * x['evaluation'])); for x in pop: x['pr'] = (math.exp(-pressure * x['evaluation'])) / sigma; return pop;
the-stack_106_29196
#!/usr/bin/env python3 # Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. from typing import List, Optional, Dict, Any, Tuple import torch import torch.distributed as dist from torch.distributed._sharding_spec import ShardMetadata from torchrec.distributed.dist_data import ( PooledEmbeddingsReduceScatter, SequenceEmbeddingAllToAll, ) from torchrec.distributed.embedding_lookup import ( GroupedPooledEmbeddingsLookup, GroupedEmbeddingsLookup, ) from torchrec.distributed.embedding_sharding import ( group_tables, SparseFeaturesAllToAll, BasePooledEmbeddingDist, BaseSparseFeaturesDist, EmbeddingSharding, BaseSequenceEmbeddingDist, SequenceShardingContext, BaseEmbeddingLookup, bucketize_kjt_before_all2all, ) from torchrec.distributed.embedding_types import ( SparseFeaturesList, ShardedEmbeddingTable, GroupedEmbeddingConfig, SparseFeatures, EmbeddingComputeKernel, BaseGroupedFeatureProcessor, ) from torchrec.distributed.types import ( ShardedTensorMetadata, Awaitable, ParameterSharding, ) from torchrec.modules.embedding_configs import EmbeddingTableConfig class RwSparseFeaturesDist(BaseSparseFeaturesDist[SparseFeatures]): def __init__( self, # pyre-fixme[11]: Annotation `ProcessGroup` is not defined as a type. pg: dist.ProcessGroup, num_id_list_features: int, num_id_score_list_features: int, id_list_feature_hash_sizes: List[int], id_score_list_feature_hash_sizes: List[int], device: Optional[torch.device] = None, is_sequence: bool = False, has_feature_processor: bool = False, ) -> None: super().__init__() self._world_size: int = pg.size() self._num_id_list_features = num_id_list_features self._num_id_score_list_features = num_id_score_list_features id_list_feature_block_sizes = [ (hash_size + self._world_size - 1) // self._world_size for hash_size in id_list_feature_hash_sizes ] id_score_list_feature_block_sizes = [ (hash_size + self._world_size - 1) // self._world_size for hash_size in id_score_list_feature_hash_sizes ] self.register_buffer( "_id_list_feature_block_sizes_tensor", torch.tensor( id_list_feature_block_sizes, device=device, dtype=torch.int32, ), ) self.register_buffer( "_id_score_list_feature_block_sizes_tensor", torch.tensor( id_score_list_feature_block_sizes, device=device, dtype=torch.int32, ), ) self._dist = SparseFeaturesAllToAll( pg, self._world_size * [self._num_id_list_features], self._world_size * [self._num_id_score_list_features], device, ) self._is_sequence = is_sequence self._has_feature_processor = has_feature_processor self.unbucketize_permute_tensor: Optional[torch.Tensor] = None def forward( self, sparse_features: SparseFeatures, ) -> Awaitable[Awaitable[SparseFeatures]]: if self._num_id_list_features > 0: assert sparse_features.id_list_features is not None ( id_list_features, self.unbucketize_permute_tensor, ) = bucketize_kjt_before_all2all( sparse_features.id_list_features, num_buckets=self._world_size, block_sizes=self._id_list_feature_block_sizes_tensor, output_permute=self._is_sequence, bucketize_pos=self._has_feature_processor, ) else: id_list_features = None if self._num_id_score_list_features > 0: assert sparse_features.id_score_list_features is not None id_score_list_features, _ = bucketize_kjt_before_all2all( sparse_features.id_score_list_features, num_buckets=self._world_size, block_sizes=self._id_score_list_feature_block_sizes_tensor, output_permute=False, bucketize_pos=False, ) else: id_score_list_features = None bucketized_sparse_features = SparseFeatures( id_list_features=id_list_features, id_score_list_features=id_score_list_features, ) return self._dist(bucketized_sparse_features) class RwPooledEmbeddingDist(BasePooledEmbeddingDist[torch.Tensor]): def __init__( self, pg: dist.ProcessGroup, ) -> None: super().__init__() self._dist = PooledEmbeddingsReduceScatter(pg) def forward(self, local_embs: torch.Tensor) -> Awaitable[torch.Tensor]: return self._dist(local_embs) class RwSequenceEmbeddingDist(BaseSequenceEmbeddingDist): def __init__( self, pg: dist.ProcessGroup, num_features: int, device: Optional[torch.device] = None, ) -> None: super().__init__() self._dist = SequenceEmbeddingAllToAll(pg, [num_features] * pg.size(), device) def forward( self, sharding_ctx: SequenceShardingContext, local_embs: torch.Tensor ) -> Awaitable[torch.Tensor]: return self._dist( local_embs, lengths=sharding_ctx.lengths_after_input_dist, input_splits=sharding_ctx.input_splits, output_splits=sharding_ctx.output_splits, unbucketize_permute_tensor=sharding_ctx.unbucketize_permute_tensor, ) class RwEmbeddingSharding( EmbeddingSharding[ SparseFeatures, torch.Tensor, SparseFeaturesList, List[torch.Tensor] ] ): """ Shards embedding bags row-wise, i.e.. a given embedding table is evenly distributed by rows and table slices are placed on all ranks. """ def __init__( self, embedding_configs: List[ Tuple[EmbeddingTableConfig, ParameterSharding, torch.Tensor] ], pg: dist.ProcessGroup, device: Optional[torch.device] = None, is_sequence: bool = False, ) -> None: super().__init__() # pyre-fixme[4]: Attribute must be annotated. self._pg = pg if device is None: device = torch.device("cpu") self._device = device self._is_sequence = is_sequence sharded_tables_per_rank = self._shard(embedding_configs) self._grouped_embedding_configs_per_rank: List[ List[GroupedEmbeddingConfig] ] = [] self._score_grouped_embedding_configs_per_rank: List[ List[GroupedEmbeddingConfig] ] = [] ( self._grouped_embedding_configs_per_rank, self._score_grouped_embedding_configs_per_rank, ) = group_tables(sharded_tables_per_rank) self._grouped_embedding_configs: List[ GroupedEmbeddingConfig ] = self._grouped_embedding_configs_per_rank[dist.get_rank(pg)] self._score_grouped_embedding_configs: List[ GroupedEmbeddingConfig ] = self._score_grouped_embedding_configs_per_rank[dist.get_rank(pg)] self._has_feature_processor: bool = False for group_config in self._grouped_embedding_configs: if group_config.has_feature_processor: self._has_feature_processor = True def _shard( self, embedding_configs: List[ Tuple[EmbeddingTableConfig, ParameterSharding, torch.Tensor] ], ) -> List[List[ShardedEmbeddingTable]]: world_size = self._pg.size() tables_per_rank: List[List[ShardedEmbeddingTable]] = [ [] for i in range(world_size) ] for config in embedding_configs: # pyre-fixme [16] shards = config[1].sharding_spec.shards # construct the global sharded_tensor_metadata global_metadata = ShardedTensorMetadata( shards_metadata=shards, size=torch.Size([config[0].num_embeddings, config[0].embedding_dim]), ) for rank in range(world_size): tables_per_rank[rank].append( ShardedEmbeddingTable( num_embeddings=config[0].num_embeddings, embedding_dim=config[0].embedding_dim, name=config[0].name, embedding_names=config[0].embedding_names, data_type=config[0].data_type, feature_names=config[0].feature_names, pooling=config[0].pooling, is_weighted=config[0].is_weighted, has_feature_processor=config[0].has_feature_processor, local_rows=shards[rank].shard_sizes[0], local_cols=config[0].embedding_dim, compute_kernel=EmbeddingComputeKernel(config[1].compute_kernel), local_metadata=shards[rank], global_metadata=global_metadata, weight_init_max=config[0].weight_init_max, weight_init_min=config[0].weight_init_min, ) ) return tables_per_rank def create_train_input_dist(self) -> BaseSparseFeaturesDist[SparseFeatures]: num_id_list_features = self._get_id_list_features_num() num_id_score_list_features = self._get_id_score_list_features_num() id_list_feature_hash_sizes = self._get_id_list_features_hash_sizes() id_score_list_feature_hash_sizes = self._get_id_score_list_features_hash_sizes() return RwSparseFeaturesDist( pg=self._pg, num_id_list_features=num_id_list_features, num_id_score_list_features=num_id_score_list_features, id_list_feature_hash_sizes=id_list_feature_hash_sizes, id_score_list_feature_hash_sizes=id_score_list_feature_hash_sizes, device=self._device, is_sequence=self._is_sequence, has_feature_processor=self._has_feature_processor, ) def create_train_lookup( self, fused_params: Optional[Dict[str, Any]], feature_processor: Optional[BaseGroupedFeatureProcessor] = None, ) -> BaseEmbeddingLookup: if self._is_sequence: return GroupedEmbeddingsLookup( grouped_configs=self._grouped_embedding_configs, fused_params=fused_params, pg=self._pg, device=self._device, ) else: return GroupedPooledEmbeddingsLookup( grouped_configs=self._grouped_embedding_configs, grouped_score_configs=self._score_grouped_embedding_configs, fused_params=fused_params, pg=self._pg, device=self._device, feature_processor=feature_processor, ) def create_train_pooled_output_dist( self, device: Optional[torch.device] = None, ) -> RwPooledEmbeddingDist: return RwPooledEmbeddingDist(self._pg) def create_train_sequence_output_dist(self) -> RwSequenceEmbeddingDist: return RwSequenceEmbeddingDist( self._pg, self._get_id_list_features_num(), self._device, ) def embedding_dims(self) -> List[int]: embedding_dims = [] for grouped_config in self._grouped_embedding_configs: embedding_dims.extend(grouped_config.embedding_dims()) for grouped_config in self._score_grouped_embedding_configs: embedding_dims.extend(grouped_config.embedding_dims()) return embedding_dims def embedding_names(self) -> List[str]: embedding_names = [] for grouped_config in self._grouped_embedding_configs: embedding_names.extend(grouped_config.embedding_names()) for grouped_config in self._score_grouped_embedding_configs: embedding_names.extend(grouped_config.embedding_names()) return embedding_names def embedding_shard_metadata(self) -> List[Optional[ShardMetadata]]: embedding_shard_metadata = [] for grouped_config in self._grouped_embedding_configs: embedding_shard_metadata.extend(grouped_config.embedding_shard_metadata()) for grouped_config in self._score_grouped_embedding_configs: embedding_shard_metadata.extend(grouped_config.embedding_shard_metadata()) return embedding_shard_metadata def id_list_feature_names(self) -> List[str]: id_list_feature_names = [] for grouped_config in self._grouped_embedding_configs: id_list_feature_names.extend(grouped_config.feature_names()) return id_list_feature_names def id_score_list_feature_names(self) -> List[str]: id_score_list_feature_names = [] for grouped_config in self._score_grouped_embedding_configs: id_score_list_feature_names.extend(grouped_config.feature_names()) return id_score_list_feature_names def _get_id_list_features_num(self) -> int: return sum( group_config.num_features() for group_config in self._grouped_embedding_configs ) def _get_id_score_list_features_num(self) -> int: return sum( group_config.num_features() for group_config in self._score_grouped_embedding_configs ) def _get_id_list_features_hash_sizes(self) -> List[int]: id_list_feature_hash_sizes: List[int] = [] for group_config in self._grouped_embedding_configs: id_list_feature_hash_sizes.extend(group_config.feature_hash_sizes()) return id_list_feature_hash_sizes def _get_id_score_list_features_hash_sizes(self) -> List[int]: id_score_list_feature_hash_sizes: List[int] = [] for group_config in self._score_grouped_embedding_configs: id_score_list_feature_hash_sizes.extend(group_config.feature_hash_sizes()) return id_score_list_feature_hash_sizes
the-stack_106_29199
#!/usr/bin/env python3 # Copyright (c) 2014-2020 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test behavior of headers messages to announce blocks. Setup: - Two nodes: - node0 is the node-under-test. We create two p2p connections to it. The first p2p connection is a control and should only ever receive inv's. The second p2p connection tests the headers sending logic. - node1 is used to create reorgs. test_null_locators ================== Sends two getheaders requests with null locator values. First request's hashstop value refers to validated block, while second request's hashstop value refers to a block which hasn't been validated. Verifies only the first request returns headers. test_nonnull_locators ===================== Part 1: No headers announcements before "sendheaders" a. node mines a block [expect: inv] send getdata for the block [expect: block] b. node mines another block [expect: inv] send getheaders and getdata [expect: headers, then block] c. node mines another block [expect: inv] peer mines a block, announces with header [expect: getdata] d. node mines another block [expect: inv] Part 2: After "sendheaders", headers announcements should generally work. a. peer sends sendheaders [expect: no response] peer sends getheaders with current tip [expect: no response] b. node mines a block [expect: tip header] c. for N in 1, ..., 10: * for announce-type in {inv, header} - peer mines N blocks, announces with announce-type [ expect: getheaders/getdata or getdata, deliver block(s) ] - node mines a block [ expect: 1 header ] Part 3: Headers announcements stop after large reorg and resume after getheaders or inv from peer. - For response-type in {inv, getheaders} * node mines a 7 block reorg [ expect: headers announcement of 8 blocks ] * node mines an 8-block reorg [ expect: inv at tip ] * peer responds with getblocks/getdata [expect: inv, blocks ] * node mines another block [ expect: inv at tip, peer sends getdata, expect: block ] * node mines another block at tip [ expect: inv ] * peer responds with getheaders with an old hashstop more than 8 blocks back [expect: headers] * peer requests block [ expect: block ] * node mines another block at tip [ expect: inv, peer sends getdata, expect: block ] * peer sends response-type [expect headers if getheaders, getheaders/getdata if mining new block] * node mines 1 block [expect: 1 header, peer responds with getdata] Part 4: Test direct fetch behavior a. Announce 2 old block headers. Expect: no getdata requests. b. Announce 3 new blocks via 1 headers message. Expect: one getdata request for all 3 blocks. (Send blocks.) c. Announce 1 header that forks off the last two blocks. Expect: no response. d. Announce 1 more header that builds on that fork. Expect: one getdata request for two blocks. e. Announce 16 more headers that build on that fork. Expect: getdata request for 14 more blocks. f. Announce 1 more header that builds on that fork. Expect: no response. Part 5: Test handling of headers that don't connect. a. Repeat 10 times: 1. Announce a header that doesn't connect. Expect: getheaders message 2. Send headers chain. Expect: getdata for the missing blocks, tip update. b. Then send 9 more headers that don't connect. Expect: getheaders message each time. c. Announce a header that does connect. Expect: no response. d. Announce 49 headers that don't connect. Expect: getheaders message each time. e. Announce one more that doesn't connect. Expect: disconnect. """ from test_framework.blocktools import create_block, create_coinbase from test_framework.messages import CInv from test_framework.p2p import ( CBlockHeader, NODE_WITNESS, P2PInterface, p2p_lock, MSG_BLOCK, msg_block, msg_getblocks, msg_getdata, msg_getheaders, msg_headers, msg_inv, msg_sendheaders, ) from test_framework.test_framework import BitcoinTestFramework from test_framework.util import ( assert_equal, ) DIRECT_FETCH_RESPONSE_TIME = 0.05 class BaseNode(P2PInterface): def __init__(self): super().__init__() self.block_announced = False self.last_blockhash_announced = None self.recent_headers_announced = [] def send_get_data(self, block_hashes): """Request data for a list of block hashes.""" msg = msg_getdata() for x in block_hashes: msg.inv.append(CInv(MSG_BLOCK, x)) self.send_message(msg) def send_get_headers(self, locator, hashstop): msg = msg_getheaders() msg.locator.vHave = locator msg.hashstop = hashstop self.send_message(msg) def send_block_inv(self, blockhash): msg = msg_inv() msg.inv = [CInv(MSG_BLOCK, blockhash)] self.send_message(msg) def send_header_for_blocks(self, new_blocks): headers_message = msg_headers() headers_message.headers = [CBlockHeader(b) for b in new_blocks] self.send_message(headers_message) def send_getblocks(self, locator): getblocks_message = msg_getblocks() getblocks_message.locator.vHave = locator self.send_message(getblocks_message) def wait_for_block_announcement(self, block_hash, timeout=60): test_function = lambda: self.last_blockhash_announced == block_hash self.wait_until(test_function, timeout=timeout) def on_inv(self, message): self.block_announced = True self.last_blockhash_announced = message.inv[-1].hash def on_headers(self, message): if len(message.headers): self.block_announced = True for x in message.headers: x.calc_sha256() # append because headers may be announced over multiple messages. self.recent_headers_announced.append(x.sha256) self.last_blockhash_announced = message.headers[-1].sha256 def clear_block_announcements(self): with p2p_lock: self.block_announced = False self.last_message.pop("inv", None) self.last_message.pop("headers", None) self.recent_headers_announced = [] def check_last_headers_announcement(self, headers): """Test whether the last headers announcements received are right. Headers may be announced across more than one message.""" test_function = lambda: (len(self.recent_headers_announced) >= len(headers)) self.wait_until(test_function) with p2p_lock: assert_equal(self.recent_headers_announced, headers) self.block_announced = False self.last_message.pop("headers", None) self.recent_headers_announced = [] def check_last_inv_announcement(self, inv): """Test whether the last announcement received had the right inv. inv should be a list of block hashes.""" test_function = lambda: self.block_announced self.wait_until(test_function) with p2p_lock: compare_inv = [] if "inv" in self.last_message: compare_inv = [x.hash for x in self.last_message["inv"].inv] assert_equal(compare_inv, inv) self.block_announced = False self.last_message.pop("inv", None) class SendHeadersTest(BitcoinTestFramework): def set_test_params(self): self.setup_clean_chain = True self.num_nodes = 2 def mine_blocks(self, count): """Mine count blocks and return the new tip.""" # Clear out block announcements from each p2p listener [x.clear_block_announcements() for x in self.nodes[0].p2ps] self.nodes[0].generatetoaddress(count, self.nodes[0].get_deterministic_priv_key().address) return int(self.nodes[0].getbestblockhash(), 16) def mine_reorg(self, length): """Mine a reorg that invalidates length blocks (replacing them with # length+1 blocks). Note: we clear the state of our p2p connections after the to-be-reorged-out blocks are mined, so that we don't break later tests. return the list of block hashes newly mined.""" # make sure all invalidated blocks are node0's self.nodes[0].generatetoaddress(length, self.nodes[0].get_deterministic_priv_key().address) self.sync_blocks(self.nodes, wait=0.1) for x in self.nodes[0].p2ps: x.wait_for_block_announcement(int(self.nodes[0].getbestblockhash(), 16)) x.clear_block_announcements() tip_height = self.nodes[1].getblockcount() hash_to_invalidate = self.nodes[1].getblockhash(tip_height - (length - 1)) self.nodes[1].invalidateblock(hash_to_invalidate) all_hashes = self.nodes[1].generatetoaddress(length + 1, self.nodes[1].get_deterministic_priv_key().address) # Must be longer than the orig chain self.sync_blocks(self.nodes, wait=0.1) return [int(x, 16) for x in all_hashes] def run_test(self): # Setup the p2p connections inv_node = self.nodes[0].add_p2p_connection(BaseNode()) # Make sure NODE_NETWORK is not set for test_node, so no block download # will occur outside of direct fetching test_node = self.nodes[0].add_p2p_connection(BaseNode(), services=NODE_WITNESS) self.test_null_locators(test_node, inv_node) self.test_nonnull_locators(test_node, inv_node) def test_null_locators(self, test_node, inv_node): tip = self.nodes[0].getblockheader(self.nodes[0].generatetoaddress(1, self.nodes[0].get_deterministic_priv_key().address)[0]) tip_hash = int(tip["hash"], 16) inv_node.check_last_inv_announcement(inv=[tip_hash]) test_node.check_last_inv_announcement(inv=[tip_hash]) self.log.info("Verify getheaders with null locator and valid hashstop returns headers.") test_node.clear_block_announcements() test_node.send_get_headers(locator=[], hashstop=tip_hash) test_node.check_last_headers_announcement(headers=[tip_hash]) self.log.info("Verify getheaders with null locator and invalid hashstop does not return headers.") block = create_block(int(tip["hash"], 16), create_coinbase(tip["height"] + 1), tip["mediantime"] + 1) block.solve() test_node.send_header_for_blocks([block]) test_node.clear_block_announcements() test_node.send_get_headers(locator=[], hashstop=int(block.hash, 16)) test_node.sync_with_ping() assert_equal(test_node.block_announced, False) inv_node.clear_block_announcements() test_node.send_message(msg_block(block)) inv_node.check_last_inv_announcement(inv=[int(block.hash, 16)]) def test_nonnull_locators(self, test_node, inv_node): tip = int(self.nodes[0].getbestblockhash(), 16) # PART 1 # 1. Mine a block; expect inv announcements each time self.log.info("Part 1: headers don't start before sendheaders message...") for i in range(4): self.log.debug("Part 1.{}: starting...".format(i)) old_tip = tip tip = self.mine_blocks(1) inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_inv_announcement(inv=[tip]) # Try a few different responses; none should affect next announcement if i == 0: # first request the block test_node.send_get_data([tip]) test_node.wait_for_block(tip) elif i == 1: # next try requesting header and block test_node.send_get_headers(locator=[old_tip], hashstop=tip) test_node.send_get_data([tip]) test_node.wait_for_block(tip) test_node.clear_block_announcements() # since we requested headers... elif i == 2: # this time announce own block via headers inv_node.clear_block_announcements() height = self.nodes[0].getblockcount() last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time'] block_time = last_time + 1 new_block = create_block(tip, create_coinbase(height + 1), block_time) new_block.solve() test_node.send_header_for_blocks([new_block]) test_node.wait_for_getdata([new_block.sha256]) test_node.send_and_ping(msg_block(new_block)) # make sure this block is processed inv_node.wait_until(lambda: inv_node.block_announced) inv_node.clear_block_announcements() test_node.clear_block_announcements() self.log.info("Part 1: success!") self.log.info("Part 2: announce blocks with headers after sendheaders message...") # PART 2 # 2. Send a sendheaders message and test that headers announcements # commence and keep working. test_node.send_message(msg_sendheaders()) prev_tip = int(self.nodes[0].getbestblockhash(), 16) test_node.send_get_headers(locator=[prev_tip], hashstop=0) test_node.sync_with_ping() # Now that we've synced headers, headers announcements should work tip = self.mine_blocks(1) inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_headers_announcement(headers=[tip]) height = self.nodes[0].getblockcount() + 1 block_time += 10 # Advance far enough ahead for i in range(10): self.log.debug("Part 2.{}: starting...".format(i)) # Mine i blocks, and alternate announcing either via # inv (of tip) or via headers. After each, new blocks # mined by the node should successfully be announced # with block header, even though the blocks are never requested for j in range(2): self.log.debug("Part 2.{}.{}: starting...".format(i, j)) blocks = [] for _ in range(i + 1): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 if j == 0: # Announce via inv test_node.send_block_inv(tip) test_node.wait_for_getheaders() # Should have received a getheaders now test_node.send_header_for_blocks(blocks) # Test that duplicate inv's won't result in duplicate # getdata requests, or duplicate headers announcements [inv_node.send_block_inv(x.sha256) for x in blocks] test_node.wait_for_getdata([x.sha256 for x in blocks]) inv_node.sync_with_ping() else: # Announce via headers test_node.send_header_for_blocks(blocks) test_node.wait_for_getdata([x.sha256 for x in blocks]) # Test that duplicate headers won't result in duplicate # getdata requests (the check is further down) inv_node.send_header_for_blocks(blocks) inv_node.sync_with_ping() [test_node.send_message(msg_block(x)) for x in blocks] test_node.sync_with_ping() inv_node.sync_with_ping() # This block should not be announced to the inv node (since it also # broadcast it) assert "inv" not in inv_node.last_message assert "headers" not in inv_node.last_message tip = self.mine_blocks(1) inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_headers_announcement(headers=[tip]) height += 1 block_time += 1 self.log.info("Part 2: success!") self.log.info("Part 3: headers announcements can stop after large reorg, and resume after headers/inv from peer...") # PART 3. Headers announcements can stop after large reorg, and resume after # getheaders or inv from peer. for j in range(2): self.log.debug("Part 3.{}: starting...".format(j)) # First try mining a reorg that can propagate with header announcement new_block_hashes = self.mine_reorg(length=7) tip = new_block_hashes[-1] inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_headers_announcement(headers=new_block_hashes) block_time += 8 # Mine a too-large reorg, which should be announced with a single inv new_block_hashes = self.mine_reorg(length=8) tip = new_block_hashes[-1] inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_inv_announcement(inv=[tip]) block_time += 9 fork_point = self.nodes[0].getblock("%064x" % new_block_hashes[0])["previousblockhash"] fork_point = int(fork_point, 16) # Use getblocks/getdata test_node.send_getblocks(locator=[fork_point]) test_node.check_last_inv_announcement(inv=new_block_hashes) test_node.send_get_data(new_block_hashes) test_node.wait_for_block(new_block_hashes[-1]) for i in range(3): self.log.debug("Part 3.{}.{}: starting...".format(j, i)) # Mine another block, still should get only an inv tip = self.mine_blocks(1) inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_inv_announcement(inv=[tip]) if i == 0: # Just get the data -- shouldn't cause headers announcements to resume test_node.send_get_data([tip]) test_node.wait_for_block(tip) elif i == 1: # Send a getheaders message that shouldn't trigger headers announcements # to resume (best header sent will be too old) test_node.send_get_headers(locator=[fork_point], hashstop=new_block_hashes[1]) test_node.send_get_data([tip]) test_node.wait_for_block(tip) elif i == 2: # This time, try sending either a getheaders to trigger resumption # of headers announcements, or mine a new block and inv it, also # triggering resumption of headers announcements. test_node.send_get_data([tip]) test_node.wait_for_block(tip) if j == 0: test_node.send_get_headers(locator=[tip], hashstop=0) test_node.sync_with_ping() else: test_node.send_block_inv(tip) test_node.sync_with_ping() # New blocks should now be announced with header tip = self.mine_blocks(1) inv_node.check_last_inv_announcement(inv=[tip]) test_node.check_last_headers_announcement(headers=[tip]) self.log.info("Part 3: success!") self.log.info("Part 4: Testing direct fetch behavior...") tip = self.mine_blocks(1) height = self.nodes[0].getblockcount() + 1 last_time = self.nodes[0].getblock(self.nodes[0].getbestblockhash())['time'] block_time = last_time + 1 # Create 2 blocks. Send the blocks, then send the headers. blocks = [] for _ in range(2): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 inv_node.send_message(msg_block(blocks[-1])) inv_node.sync_with_ping() # Make sure blocks are processed test_node.last_message.pop("getdata", None) test_node.send_header_for_blocks(blocks) test_node.sync_with_ping() # should not have received any getdata messages with p2p_lock: assert "getdata" not in test_node.last_message # This time, direct fetch should work blocks = [] for _ in range(3): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 test_node.send_header_for_blocks(blocks) test_node.sync_with_ping() test_node.wait_for_getdata([x.sha256 for x in blocks], timeout=DIRECT_FETCH_RESPONSE_TIME) [test_node.send_message(msg_block(x)) for x in blocks] test_node.sync_with_ping() # Now announce a header that forks the last two blocks tip = blocks[0].sha256 height -= 2 blocks = [] # Create extra blocks for later for _ in range(20): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 # Announcing one block on fork should not trigger direct fetch # (less work than tip) test_node.last_message.pop("getdata", None) test_node.send_header_for_blocks(blocks[0:1]) test_node.sync_with_ping() with p2p_lock: assert "getdata" not in test_node.last_message # Announcing one more block on fork should trigger direct fetch for # both blocks (same work as tip) test_node.send_header_for_blocks(blocks[1:2]) test_node.sync_with_ping() test_node.wait_for_getdata([x.sha256 for x in blocks[0:2]], timeout=DIRECT_FETCH_RESPONSE_TIME) # Announcing 16 more headers should trigger direct fetch for 14 more # blocks test_node.send_header_for_blocks(blocks[2:18]) test_node.sync_with_ping() test_node.wait_for_getdata([x.sha256 for x in blocks[2:16]], timeout=DIRECT_FETCH_RESPONSE_TIME) # Announcing 1 more header should not trigger any response test_node.last_message.pop("getdata", None) test_node.send_header_for_blocks(blocks[18:19]) test_node.sync_with_ping() with p2p_lock: assert "getdata" not in test_node.last_message self.log.info("Part 4: success!") # Now deliver all those blocks we announced. [test_node.send_message(msg_block(x)) for x in blocks] self.log.info("Part 5: Testing handling of unconnecting headers") # First we test that receipt of an unconnecting header doesn't prevent # chain sync. for i in range(10): self.log.debug("Part 5.{}: starting...".format(i)) test_node.last_message.pop("getdata", None) blocks = [] # Create two more blocks. for _ in range(2): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 # Send the header of the second block -> this won't connect. with p2p_lock: test_node.last_message.pop("getheaders", None) test_node.send_header_for_blocks([blocks[1]]) test_node.wait_for_getheaders() test_node.send_header_for_blocks(blocks) test_node.wait_for_getdata([x.sha256 for x in blocks]) [test_node.send_message(msg_block(x)) for x in blocks] test_node.sync_with_ping() assert_equal(int(self.nodes[0].getbestblockhash(), 16), blocks[1].sha256) blocks = [] # Now we test that if we repeatedly don't send connecting headers, we # don't go into an infinite loop trying to get them to connect. MAX_UNCONNECTING_HEADERS = 10 for _ in range(MAX_UNCONNECTING_HEADERS + 1): blocks.append(create_block(tip, create_coinbase(height), block_time)) blocks[-1].solve() tip = blocks[-1].sha256 block_time += 1 height += 1 for i in range(1, MAX_UNCONNECTING_HEADERS): # Send a header that doesn't connect, check that we get a getheaders. with p2p_lock: test_node.last_message.pop("getheaders", None) test_node.send_header_for_blocks([blocks[i]]) test_node.wait_for_getheaders() # Next header will connect, should re-set our count: test_node.send_header_for_blocks([blocks[0]]) # Remove the first two entries (blocks[1] would connect): blocks = blocks[2:] # Now try to see how many unconnecting headers we can send # before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS for i in range(5 * MAX_UNCONNECTING_HEADERS - 1): # Send a header that doesn't connect, check that we get a getheaders. with p2p_lock: test_node.last_message.pop("getheaders", None) test_node.send_header_for_blocks([blocks[i % len(blocks)]]) test_node.wait_for_getheaders() # Eventually this stops working. test_node.send_header_for_blocks([blocks[-1]]) # Should get disconnected test_node.wait_for_disconnect() self.log.info("Part 5: success!") # Finally, check that the inv node never received a getdata request, # throughout the test assert "getdata" not in inv_node.last_message if __name__ == '__main__': SendHeadersTest().main()
the-stack_106_29200
# Copyright 2015 Intel Corporation. # 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. from nova.api import openstack from nova.api.openstack import compute from nova.api.openstack import wsgi from nova.tests.functional import api_paste_fixture from nova.tests.functional import integrated_helpers class LegacyV2CompatibleTestBase(integrated_helpers._IntegratedTestBase): _api_version = 'v2' def setUp(self): self.useFixture(api_paste_fixture.ApiPasteV2CompatibleFixture()) super(LegacyV2CompatibleTestBase, self).setUp() self._check_api_endpoint('/v2', [compute.APIRouterV21, openstack.LegacyV2CompatibleWrapper]) def test_request_with_microversion_headers(self): response = self.api.api_post('os-keypairs', {"keypair": {"name": "test"}}, headers={wsgi.API_VERSION_REQUEST_HEADER: '2.100'}) self.assertNotIn(wsgi.API_VERSION_REQUEST_HEADER, response.headers) self.assertNotIn('Vary', response.headers) self.assertNotIn('type', response.body["keypair"]) def test_request_without_addtional_properties_check(self): response = self.api.api_post('os-keypairs', {"keypair": {"name": "test", "foooooo": "barrrrrr"}}, headers={wsgi.API_VERSION_REQUEST_HEADER: '2.100'}) self.assertNotIn(wsgi.API_VERSION_REQUEST_HEADER, response.headers) self.assertNotIn('Vary', response.headers) self.assertNotIn('type', response.body["keypair"])
the-stack_106_29202
import logging from tests.helpers.log_helper import log_operation def create_namespace(database, namespace_name): """ Create a namespace """ db, db_name = database log_operation.info(f"Create a namespace with name '{namespace_name}' on database '{db_name}'") try: db.namespace_open(namespace_name) except Exception as e: logging.error(e) def drop_namespace(database, namespace_name): """ Drop a namespace """ db, db_name = database log_operation.info(f"Drop a namespace with name '{namespace_name}' on database '{db_name}'") db.namespace_drop(namespace_name) def get_namespace_list(database): """ Get list of namespaces in database """ log_operation.info("Get list of namespaces in database") db, db_name = database namespace_list = db.namespaces_enum() return namespace_list def get_ns_description(database, namespace): """ Get information about namespace in database """ db, namespace_name = namespace namespace_list = get_namespace_list(database) log_operation.info(f"Get information about namespace {namespace_name} in database") ns_entry = list(filter(lambda ns: ns['name'] == namespace_name, namespace_list)) return ns_entry
the-stack_106_29205
import cv2 as cv import numpy as np class Blender: BLENDER_CHOICES = ('multiband', 'feather', 'no',) DEFAULT_BLENDER = 'multiband' DEFAULT_BLEND_STRENGTH = 5 def __init__(self, blender_type=DEFAULT_BLENDER, blend_strength=DEFAULT_BLEND_STRENGTH): self.blender_type = blender_type self.blend_strength = blend_strength self.blender = None def prepare(self, corners, sizes): dst_sz = cv.detail.resultRoi(corners=corners, sizes=sizes) blend_width = (np.sqrt(dst_sz[2] * dst_sz[3]) * self.blend_strength / 100) if self.blender_type == 'no' or blend_width < 1: self.blender = cv.detail.Blender_createDefault( cv.detail.Blender_NO ) elif self.blender_type == "multiband": self.blender = cv.detail_MultiBandBlender() self.blender.setNumBands((np.log(blend_width) / np.log(2.) - 1.).astype(np.int)) elif self.blender_type == "feather": self.blender = cv.detail_FeatherBlender() self.blender.setSharpness(1. / blend_width) self.blender.prepare(dst_sz) def feed(self, img, mask, corner): """https://docs.opencv.org/master/d6/d4a/classcv_1_1detail_1_1Blender.html#a64837308bcf4e414a6219beff6cbe37a""" # noqa self.blender.feed(cv.UMat(img.astype(np.int16)), mask, corner) def blend(self): """https://docs.opencv.org/master/d6/d4a/classcv_1_1detail_1_1Blender.html#aa0a91ce0d6046d3a63e0123cbb1b5c00""" # noqa result = None result_mask = None result, result_mask = self.blender.blend(result, result_mask) result = cv.convertScaleAbs(result) return result
the-stack_106_29208
from pfunk import Collection, StringField, EnumField, Enum, ReferenceField, SlugField from pfunk.resources import Index from pfunk.contrib.auth.collections import User, Group from pfunk.contrib.auth.resources import GenericGroupBasedRole, GenericUserBasedRole GENDER_PRONOUN = Enum(name='gender_pronouns', choices=['he', 'her', 'they']) class SimpleIndex(Index): name = 'simple-index' terms = ['name', 'slug'] unique = True source = 'Project' class Sport(Collection): _use_crud_functions = True name = StringField(required=True) slug = SlugField() def __unicode__(self): return self.name class Meta: unique_together = [('name', 'slug')] class Person(Collection): _roles = [GenericGroupBasedRole] _verbose_plural_name = 'people' first_name = StringField(required=True) last_name = StringField(required=True) gender_pronoun = EnumField(GENDER_PRONOUN) sport = ReferenceField(Sport) group = ReferenceField(Group) def __unicode__(self): return f"{self.first_name} {self.last_name}" class House(Collection): _roles = [GenericUserBasedRole] address = StringField(required=True) user = ReferenceField(User) def __unicode__(self): return self.address
the-stack_106_29210
from __future__ import absolute_import from __future__ import division from __future__ import print_function import json import os import tensorflow.compat.v1 as tf from . import modeling def _get_initializer(FLAGS): """Get variable intializer.""" if FLAGS.init == 'uniform': initializer = tf.initializers.random_uniform( minval=-FLAGS.init_range, maxval=FLAGS.init_range, seed=None ) elif FLAGS.init == 'normal': initializer = tf.initializers.random_normal( stddev=FLAGS.init_std, seed=None ) else: raise ValueError('Initializer {} not supported'.format(FLAGS.init)) return initializer class XLNetConfig(object): """XLNetConfig contains hyperparameters that are specific to a model checkpoint; i.e., these hyperparameters should be the same between pretraining and finetuning. The following hyperparameters are defined: n_layer: int, the number of layers. d_model: int, the hidden size. n_head: int, the number of attention heads. d_head: int, the dimension size of each attention head. d_inner: int, the hidden size in feed-forward layers. ff_activation: str, "relu" or "gelu". untie_r: bool, whether to untie the biases in attention. n_token: int, the vocab size. """ def __init__(self, FLAGS=None, json_path=None): """Constructing an XLNetConfig. One of FLAGS or json_path should be provided.""" assert FLAGS is not None or json_path is not None self.keys = [ 'n_layer', 'd_model', 'n_head', 'd_head', 'd_inner', 'ff_activation', 'untie_r', 'n_token', ] if FLAGS is not None: self.init_from_flags(FLAGS) if json_path is not None: self.init_from_json(json_path) def init_from_flags(self, FLAGS): for key in self.keys: setattr(self, key, getattr(FLAGS, key)) def init_from_json(self, json_path): with tf.gfile.Open(json_path) as f: json_data = json.load(f) for key in self.keys: setattr(self, key, json_data[key]) def to_json(self, json_path): """Save XLNetConfig to a json file.""" json_data = {} for key in self.keys: json_data[key] = getattr(self, key) json_dir = os.path.dirname(json_path) if not tf.gfile.Exists(json_dir): tf.gfile.MakeDirs(json_dir) with tf.gfile.Open(json_path, 'w') as f: json.dump(json_data, f, indent=4, sort_keys=True) def create_run_config(is_training, is_finetune, FLAGS): kwargs = dict( is_training=is_training, use_tpu=FLAGS.use_tpu, use_bfloat16=FLAGS.use_bfloat16, dropout=FLAGS.dropout, dropatt=FLAGS.dropatt, init=FLAGS.init, init_range=FLAGS.init_range, init_std=FLAGS.init_std, clamp_len=FLAGS.clamp_len, ) if not is_finetune: kwargs.update( dict( mem_len=FLAGS.mem_len, reuse_len=FLAGS.reuse_len, bi_data=FLAGS.bi_data, clamp_len=FLAGS.clamp_len, same_length=FLAGS.same_length, ) ) return RunConfig(**kwargs) class RunConfig(object): """RunConfig contains hyperparameters that could be different between pretraining and finetuning. These hyperparameters can also be changed from run to run. We store them separately from XLNetConfig for flexibility. """ def __init__( self, is_training, use_tpu, use_bfloat16, dropout, dropatt, init='normal', init_range=0.1, init_std=0.02, mem_len=None, reuse_len=None, bi_data=False, clamp_len=-1, same_length=False, ): """ Args: is_training: bool, whether in training mode. use_tpu: bool, whether TPUs are used. use_bfloat16: bool, use bfloat16 instead of float32. dropout: float, dropout rate. dropatt: float, dropout rate on attention probabilities. init: str, the initialization scheme, either "normal" or "uniform". init_range: float, initialize the parameters with a uniform distribution in [-init_range, init_range]. Only effective when init="uniform". init_std: float, initialize the parameters with a normal distribution with mean 0 and stddev init_std. Only effective when init="normal". mem_len: int, the number of tokens to cache. reuse_len: int, the number of tokens in the currect batch to be cached and reused in the future. bi_data: bool, whether to use bidirectional input pipeline. Usually set to True during pretraining and False during finetuning. clamp_len: int, clamp all relative distances larger than clamp_len. -1 means no clamping. same_length: bool, whether to use the same attention length for each token. """ self.init = init self.init_range = init_range self.init_std = init_std self.is_training = is_training self.dropout = dropout self.dropatt = dropatt self.use_tpu = use_tpu self.use_bfloat16 = use_bfloat16 self.mem_len = mem_len self.reuse_len = reuse_len self.bi_data = bi_data self.clamp_len = clamp_len self.same_length = same_length class XLNetModel(object): """A wrapper of the XLNet model used during both pretraining and finetuning.""" def __init__( self, xlnet_config, run_config, input_ids, seg_ids, input_mask, mems=None, perm_mask=None, target_mapping=None, inp_q=None, **kwargs ): """ Args: xlnet_config: XLNetConfig, run_config: RunConfig, input_ids: int32 Tensor in shape [len, bsz], the input token IDs. seg_ids: int32 Tensor in shape [len, bsz], the input segment IDs. input_mask: float32 Tensor in shape [len, bsz], the input mask. 0 for real tokens and 1 for padding. mems: a list of float32 Tensors in shape [mem_len, bsz, d_model], memory from previous batches. The length of the list equals n_layer. If None, no memory is used. perm_mask: float32 Tensor in shape [len, len, bsz]. If perm_mask[i, j, k] = 0, i attend to j in batch k; if perm_mask[i, j, k] = 1, i does not attend to j in batch k. If None, each position attends to all the others. target_mapping: float32 Tensor in shape [num_predict, len, bsz]. If target_mapping[i, j, k] = 1, the i-th predict in batch k is on the j-th token. Only used during pretraining for partial prediction. Set to None during finetuning. inp_q: float32 Tensor in shape [len, bsz]. 1 for tokens with losses and 0 for tokens without losses. Only used during pretraining for two-stream attention. Set to None during finetuning. """ initializer = _get_initializer(run_config) tfm_args = dict( n_token=xlnet_config.n_token, initializer=initializer, attn_type='bi', n_layer=xlnet_config.n_layer, d_model=xlnet_config.d_model, n_head=xlnet_config.n_head, d_head=xlnet_config.d_head, d_inner=xlnet_config.d_inner, ff_activation=xlnet_config.ff_activation, untie_r=xlnet_config.untie_r, is_training=run_config.is_training, use_bfloat16=run_config.use_bfloat16, use_tpu=run_config.use_tpu, dropout=run_config.dropout, dropatt=run_config.dropatt, mem_len=run_config.mem_len, reuse_len=run_config.reuse_len, bi_data=run_config.bi_data, clamp_len=run_config.clamp_len, same_length=run_config.same_length, ) input_args = dict( inp_k=input_ids, seg_id=seg_ids, input_mask=input_mask, mems=mems, perm_mask=perm_mask, target_mapping=target_mapping, inp_q=inp_q, ) tfm_args.update(input_args) with tf.variable_scope('model', reuse=tf.AUTO_REUSE): ( self.output, self.new_mems, self.lookup_table, self.lookup_table_2, ) = modeling.transformer_xl(**tfm_args) self.input_mask = input_mask self.initializer = initializer self.xlnet_config = xlnet_config self.run_config = run_config def get_pooled_out(self, summary_type, use_summ_proj=True): """ Args: summary_type: str, "last", "first", "mean", or "attn". The method to pool the input to get a vector representation. use_summ_proj: bool, whether to use a linear projection during pooling. Returns: float32 Tensor in shape [bsz, d_model], the pooled representation. """ xlnet_config = self.xlnet_config run_config = self.run_config with tf.variable_scope('model', reuse=tf.AUTO_REUSE): summary = modeling.summarize_sequence( summary_type=summary_type, hidden=self.output, d_model=xlnet_config.d_model, n_head=xlnet_config.n_head, d_head=xlnet_config.d_head, dropout=run_config.dropout, dropatt=run_config.dropatt, is_training=run_config.is_training, input_mask=self.input_mask, initializer=self.initializer, use_proj=use_summ_proj, ) return summary def get_sequence_output(self): """ Returns: float32 Tensor in shape [len, bsz, d_model]. The last layer hidden representation of XLNet. """ return self.output def get_new_memory(self): """ Returns: list of float32 Tensors in shape [mem_len, bsz, d_model], the new memory that concatenates the previous memory with the current input representations. The length of the list equals n_layer. """ return self.new_mems def get_embedding_table(self): """ Returns: float32 Tensor in shape [n_token, d_model]. The embedding lookup table. Used for tying embeddings between input and output layers. """ return self.lookup_table def get_embedding_table2(self): """ Returns: float32 Tensor in shape [n_token, d_model]. The embedding lookup table. Used for tying embeddings between input and output layers. """ return self.lookup_table_2 def get_initializer(self): """ Returns: A tf initializer. Used to initialize variables in layers on top of XLNet. """ return self.initializer
the-stack_106_29213
__version__ = '1.0.0b4' import io import cmd import sys import readline import shlex import traceback import importlib.util from argparse import _SubParsersAction from argparse import _HelpAction, Action from contextlib import redirect_stdout # Prevent to execute exit() when help and error method in argparse.Argparser sys.exit = lambda: None ################################################################################ class ArgumentCmd(cmd.Cmd): argument_parser = None # ========================================================================== def __init__(self): super(ArgumentCmd, self).__init__() readline.set_completer_delims(' ') ArgumentCmd.read_prompt() # ========================================================================== def _do_command(self, line, *args, **kwargs): parser = self.argument_parser prog = kwargs["prog"].strip() try: command = f'{prog} {line}'.strip() spec = parser.parse_args(shlex.split(command)) if 'func' not in spec: return if any(x in command for x in ('-h', '--help')): return spec.func(spec) except TypeError: # parse_args raise exception when wrong input. return except Exception as e: traceback.print_exc() # Todo: Do something for errors return # ========================================================================== def emptyline(self): pass # ========================================================================== def postcmd(self, stop: bool, line: str) -> bool: ArgumentCmd.read_prompt() return cmd.Cmd.postcmd(self, stop, line) # ========================================================================== def complete(self, text, state): if state == 0: origline = readline.get_line_buffer() line = origline.lstrip() command, args, foo = self.parseline(line) if command == '': result = self.completedefault else: result = ArgumentCmd.get_complete_list( shlex.split(line), self.argument_parser) result = [x + ' ' for x in result] result.append(None) self.completion_matches = result try: return self.completion_matches[state] except IndexError: return None # ========================================================================== @staticmethod def get_complete_list(line, parser, result=None): if None is result: result = list() word = '' if line: word = line.pop(0) for action in parser._actions: if isinstance(action, _HelpAction): continue elif isinstance(action, _SubParsersAction): rc = [x for x in action.choices.keys() if x.startswith(word)] if 1 == len(rc) and word == rc[0]: return ArgumentCmd.get_complete_list( line, action.choices[word], list()) result += [x for x in action.choices.keys() if x.startswith(word)] elif isinstance(action, Action): result += [x for x in action.option_strings if x.startswith(word)] else: pass return result # ========================================================================== @staticmethod def get_empty_func(_type, action, parser): def do(self, line): self._do_command(self, line, prog=action.prog) def complete(self, text, line, start_index, end_index): return self._complete_command( self, text, line, start_index, end_index) f = {'do': do, 'complete': complete} return f[_type] # ========================================================================== @classmethod def _add_functions(cls, actions, parser): for action in actions.choices.values(): with io.StringIO() as buf, redirect_stdout(buf): print(action.print_usage()) output = buf.getvalue() for _type in ('do',): command = ArgumentCmd.get_empty_func( _type, action=action, parser=parser) command.__doc__ = output command.__name__ = f"{_type}_{action.prog.split()[-1].strip()}" setattr(cls, command.__name__, classmethod(command)) # ========================================================================== @classmethod def _add_command(cls, parser): for action in parser._actions: if isinstance(action, _HelpAction): continue if isinstance(action, _SubParsersAction): ArgumentCmd._add_functions(action, parser) # ========================================================================== @classmethod def set_cli_parser(cls, parser): cls.argument_parser = parser cls._add_command(parser) # ========================================================================== @staticmethod def read_prompt(): try: with open('prompt', 'r') as f: prompt = f.read() if prompt: ArgumentCmd.prompt = prompt + ' ' except FileNotFoundError: pass return ArgumentCmd.prompt ################################################################################ def run(cli_package): # Import user CLI package module_name = 'cli' spec = importlib.util.spec_from_file_location('cli', cli_package) module = importlib.util.module_from_spec(spec) sys.modules[module_name] = module spec.loader.exec_module(module) cli_parser = module.argument_parser() # Run CLI-Arguments command = ArgumentCmd command.set_cli_parser(cli_parser) my_cmd = command() my_cmd.cmdloop()
the-stack_106_29214
# Copyright (c) 2001-2004 Twisted Matrix Laboratories. # See LICENSE for details. # """ Parsing for the moduli file, which contains Diffie-Hellman prime groups. Maintainer: Paul Swartz """ def parseModuliFile(filename): lines = open(filename).readlines() primes = {} for l in lines: l = l.strip() if not l or l[0]=='#': continue tim, typ, tst, tri, size, gen, mod = l.split() size = int(size) + 1 gen = long(gen) mod = long(mod, 16) if not primes.has_key(size): primes[size] = [] primes[size].append((gen, mod)) return primes
the-stack_106_29215
#importing the necessary modules from sklearn import datasets from sklearn.model_selection import train_test_split import numpy as np import matplotlib.pyplot as plt #calcuating the mean def mean(values): return sum(values)/float(len(values)) #calculating the variance def variance(values,mean): return sum([(x-mean)**2 for x in values]) #calcuating the coeffcients b1 and b0 for the equation yhat = b0+b1*x def coefficients(iris_X,mean_iris_X,iris_Y,mean_iris_Y,var_iris_X): n = len(iris_X) numerator = 0 for i in range(n): numerator += (iris_X[i] - mean_iris_X) * (iris_Y[i] - mean_iris_Y) b1 = numerator/var_iris_X b0 = mean_iris_Y - (b1 * mean_iris_X) return(b1,b0) #training model and predecting values of dependent variables def linear_regression(iris_X_train,iris_Y_train,iris_X_test,iris_Y_test): predection = [] mean_iris_X , mean_iris_Y = mean(iris_X_train), mean(iris_Y_train) var_iris_X , var_iris_Y = variance(iris_X_train,mean_iris_X), variance(iris_Y_train,mean_iris_Y) for x in iris_X_test: b1,b0=coefficients(iris_X_train,mean_iris_X,iris_Y_train,mean_iris_Y,var_iris_X) yhat = b0 + b1*x predection.append(yhat) return predection #calcuting the mean squared error def calc_error(predected,iris_Y_test): m = len(predected) error = 0 for ele in predected: i = 0 error += ((ele- iris_Y_test[i])**2 / m) i+=1 return error #main function iris_X , iris_Y = datasets.load_iris(return_X_y = True) #loading the dataset from the sklearn iris_X = iris_X[:,np.newaxis,2] #settings only petal length and petal width as features iris_X_train,iris_X_test,iris_Y_train,iris_Y_test = train_test_split(iris_X, iris_Y, test_size=.32,random_state=30) #splitting the data into test and train datset predected = linear_regression(iris_X_train,iris_Y_train,iris_X_test,iris_Y_test) #calling the linear_regression function to predict the values of y print("Mean squared error : ", calc_error(predected,iris_Y_test)) #displaying the error #visulaising the model plt.scatter(iris_X_test,iris_Y_test, color = 'red') plt.plot(iris_X_test,predected, color = 'blue',linewidth = 2) #displaying the plot on screen plt.show()
the-stack_106_29218
# Copyright 2016 OpenMarket Ltd # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Contains all the units for the spec. This file loads swagger and JSON schema files and parses out the useful bits and returns them as Units for use in Batesian. For the actual conversion of data -> RST (including templates), see the sections file instead. """ from batesian.units import Units from collections import OrderedDict import logging import json import os import os.path import re import subprocess import sys import yaml from functools import reduce from six.moves.urllib.parse import urlencode, quote matrix_doc_dir=reduce(lambda acc,_: os.path.dirname(acc), range(1, 5), os.path.abspath(__file__)) HTTP_APIS = { os.path.join(matrix_doc_dir, "api/application-service"): "as", os.path.join(matrix_doc_dir, "api/client-server"): "cs", os.path.join(matrix_doc_dir, "api/identity"): "is", os.path.join(matrix_doc_dir, "api/push-gateway"): "push", os.path.join(matrix_doc_dir, "api/server-server"): "ss", } SWAGGER_DEFINITIONS = { os.path.join(matrix_doc_dir, "api/application-service/definitions"): "as", os.path.join(matrix_doc_dir, "api/client-server/definitions"): "cs", os.path.join(matrix_doc_dir, "api/identity/definitions"): "is", os.path.join(matrix_doc_dir, "api/push-gateway/definitions"): "push", os.path.join(matrix_doc_dir, "api/server-server/definitions"): "ss", } EVENT_EXAMPLES = os.path.join(matrix_doc_dir, "event-schemas/examples") EVENT_SCHEMA = os.path.join(matrix_doc_dir, "event-schemas/schema") CORE_EVENT_SCHEMA = os.path.join(matrix_doc_dir, "event-schemas/schema/core-event-schema") CHANGELOG_DIR = os.path.join(matrix_doc_dir, "changelogs") TARGETS = os.path.join(matrix_doc_dir, "specification/targets.yaml") ROOM_EVENT = "core-event-schema/room_event.yaml" STATE_EVENT = "core-event-schema/state_event.yaml" SAS_EMOJI_JSON = os.path.join(matrix_doc_dir, "data-definitions/sas-emoji.json") logger = logging.getLogger(__name__) # a yaml Loader which loads mappings into OrderedDicts instead of regular # dicts, so that we preserve the ordering of properties from the api files. # # with thanks to http://stackoverflow.com/a/21912744/637864 class OrderedLoader(yaml.Loader): pass def construct_mapping(loader, node): loader.flatten_mapping(node) pairs = loader.construct_pairs(node) return OrderedDict(pairs) OrderedLoader.add_constructor( yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, construct_mapping) class TypeTable(object): """Describes a table documenting an object type Attributes: title(str|None): Title of the table - normally the object type desc(str|None): description of the object rows(list[TypeTableRow]): the rows in the table """ def __init__(self, title=None, desc=None, rows=[]): self.title=title self.desc=desc self._rows = [] for row in rows: self.add_row(row) def add_row(self, row): if not isinstance(row, TypeTableRow): raise ValueError("Can only add TypeTableRows to TypeTable") self._rows.append(row) def __getattr__(self, item): if item == 'rows': return list(self._rows) return super(TypeTable, self).__getattr__(item) def __repr__(self): return "TypeTable[%s, rows=%s]" % (self.title, self._rows) class TypeTableRow(object): """Describes an object field defined in the json schema """ def __init__(self, key, title, desc, required=False): self.key = key self.title = title self.desc = desc self.required = required def __repr__(self): return "TypeTableRow[%s: %s]" % (self.key, self.desc) def resolve_references(path, schema): if isinstance(schema, dict): # do $ref first if '$ref' in schema: value = schema['$ref'] path = os.path.join(os.path.dirname(path), value) with open(path, encoding="utf-8") as f: ref = yaml.load(f, OrderedLoader) result = resolve_references(path, ref) del schema['$ref'] else: result = OrderedDict() for key, value in schema.items(): result[key] = resolve_references(path, value) return result elif isinstance(schema, list): return [resolve_references(path, value) for value in schema] else: return schema def inherit_parents(obj): """ Recurse through the 'allOf' declarations in the object """ logger.debug("inherit_parents %r" % obj) parents = obj.get("allOf", []) if not parents: return obj result = {} # settings defined in the child take priority over the parents, so we # iterate through the parents first, and then overwrite with the settings # from the child. for p in list(map(inherit_parents, parents)) + [obj]: # child blats out type, title and description for key in ('type', 'title', 'description'): if p.get(key): result[key] = p[key] # other fields get merged for key in ('required', ): if p.get(key): result.setdefault(key, []).extend(p[key]) for key in ('properties', 'additionalProperties', 'patternProperties'): if p.get(key): result.setdefault(key, OrderedDict()).update(p[key]) return result def get_json_schema_object_fields(obj, enforce_title=False): """Parse a JSON schema object definition Args: obj(dict): definition from the JSON schema file. $refs should already have been resolved. enforce_title (bool): if True, and the definition has no "title", the 'title' result will be set to 'NO_TITLE' (otherwise it will be set to None) Returns: dict: with the following fields: - title (str): title (normally the type name) for the object - tables (list[TypeTable]): list of the tables for the type definition """ # Algorithm: # f.e. property => add field info (if field is object then recurse) if obj.get("type") != "object": raise Exception( "get_json_schema_object_fields: Object %s isn't an object." % obj ) obj_title = obj.get("title") logger.debug("Processing object with title '%s'", obj_title) additionalProps = obj.get("additionalProperties") props = obj.get("properties") if additionalProps and not props: # not "really" an object, just a KV store logger.debug("%s is a pseudo-object", obj_title) key_type = additionalProps.get("x-pattern", "string") res = process_data_type(additionalProps) return { "title": "{%s: %s}" % (key_type, res["title"]), "tables": res["tables"], } if not props: props = obj.get("patternProperties") if props: # try to replace horrible regex key names with pretty x-pattern ones for key_name in props.keys(): pretty_key = props[key_name].get("x-pattern") if pretty_key: props[pretty_key] = props[key_name] del props[key_name] # Sometimes you just want to specify that a thing is an object without # doing all the keys. if not props: return { "title": obj_title if obj_title else 'object', "tables": [], } if enforce_title and not obj_title: # Force a default titile of "NO_TITLE" to make it obvious in the # specification output which parts of the schema are missing a title obj_title = 'NO_TITLE' required_keys = set(obj.get("required", [])) first_table_rows = [] tables = [] for key_name in props: try: logger.debug("Processing property %s.%s", obj_title, key_name) required = key_name in required_keys res = process_data_type(props[key_name], required) first_table_rows.append(TypeTableRow( key=key_name, title=res["title"], required=required, desc=res["desc"], )) tables.extend(res["tables"]) logger.debug("Done property %s" % key_name) except Exception as e: e2 = Exception("Error reading property %s.%s: %s" % (obj_title, key_name, str(e))) # throw the new exception with the old stack trace, so that # we don't lose information about where the error occurred. raise e2.with_traceback(sys.exc_info()[2]) tables.insert(0, TypeTable(title=obj_title, rows=first_table_rows)) for table in tables: assert isinstance(table, TypeTable) return { "title": obj_title, "tables": tables, } # process a data type definition. returns a dictionary with the keys: # title: stringified type name # desc: description # enum_desc: description of permissible enum fields # is_object: true if the data type is an object # tables: list of additional table definitions def process_data_type(prop, required=False, enforce_title=True): prop = inherit_parents(prop) prop_type = prop.get('oneOf', prop.get('type', [])) assert prop_type tables = [] enum_desc = None is_object = False if prop_type == "object": res = get_json_schema_object_fields( prop, enforce_title=enforce_title, ) prop_title = res["title"] tables = res["tables"] is_object = True elif prop_type == "array": items = prop["items"] # Items can be a list of schemas or a schema itself # http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.4 if isinstance(items, list): nested_titles = [] for i in items: nested = process_data_type(i) tables.extend(nested['tables']) nested_titles.append(nested['title']) prop_title = "[%s]" % (", ".join(nested_titles), ) else: nested = process_data_type(prop["items"]) prop_title = "[%s]" % nested["title"] tables = nested["tables"] enum_desc = nested["enum_desc"] elif isinstance(prop_type, list): prop_title = [] for t in prop_type: if isinstance(t, dict): nested = process_data_type(t) tables.extend(nested['tables']) prop_title.append(nested['title']) # Assuming there's at most one enum among type options enum_desc = nested['enum_desc'] if enum_desc: enum_desc = "%s if the type is enum" % enum_desc else: prop_title.append(t) else: prop_title = prop_type if prop.get("enum"): if len(prop["enum"]) > 1: prop_title = "enum" enum_desc = ( "One of: %s" % json.dumps(prop["enum"]) ) else: enum_desc = ( "Must be '%s'." % prop["enum"][0] ) if isinstance(prop_title, list): prop_title = " or ".join(prop_title) rq = "**Required.**" if required else None desc = " ".join(x for x in [rq, prop.get("description"), enum_desc] if x) for table in tables: assert isinstance(table, TypeTable) return { "title": prop_title, "desc": desc, "enum_desc": enum_desc, "is_object": is_object, "tables": tables, } def deduplicate_tables(tables): # the result may contain duplicates, if objects are referred to more than # once. Filter them out. # # Go through the tables backwards so that we end up with a breadth-first # rather than depth-first ordering. titles = set() filtered = [] for table in reversed(tables): if table.title in titles: continue titles.add(table.title) filtered.append(table) filtered.reverse() return filtered def get_tables_for_schema(schema): pv = process_data_type(schema, enforce_title=False) return deduplicate_tables(pv["tables"]) def get_tables_for_response(schema): pv = process_data_type(schema, enforce_title=False) tables = deduplicate_tables(pv["tables"]) # make up the first table, with just the 'body' row in, unless the response # is an object, in which case there's little point in having one. if not pv["is_object"]: first_table_row = TypeTableRow( key="<body>", title=pv["title"], desc=pv["desc"], ) tables.insert(0, TypeTable(None, rows=[first_table_row])) logger.debug("response: %r" % tables) return tables def get_example_for_schema(schema): """Returns a python object representing a suitable example for this object""" schema = inherit_parents(schema) if 'example' in schema: example = schema['example'] return example proptype = schema['type'] if proptype == 'object': if 'properties' not in schema: raise Exception('"object" property has neither properties nor example') res = OrderedDict() for prop_name, prop in schema['properties'].items(): logger.debug("Parsing property %r" % prop_name) prop_example = get_example_for_schema(prop) res[prop_name] = prop_example return res if proptype == 'array': if 'items' not in schema: raise Exception('"array" property has neither items nor example') items = schema['items'] if isinstance(items, list): return [get_example_for_schema(i) for i in items] return [get_example_for_schema(items)] if proptype == 'integer': return 0 if proptype == 'string': return proptype raise Exception("Don't know to make an example %s" % proptype) def get_example_for_param(param): """Returns a stringified example for a parameter""" if 'x-example' in param: return param['x-example'] schema = param.get('schema') if not schema: return None exampleobj = None if 'example' in schema: exampleobj = schema['example'] if exampleobj is None: exampleobj = get_example_for_schema(schema) return json.dumps(exampleobj, indent=2) def get_example_for_response(response): """Returns a stringified example for a response""" exampleobj = None if 'examples' in response: exampleobj = response["examples"].get("application/json") if exampleobj is None: schema = response.get('schema') if schema: if schema['type'] == 'file': # no example for 'file' responses return None exampleobj = get_example_for_schema(schema) if exampleobj is None: return None return json.dumps(exampleobj, indent=2) class MatrixUnits(Units): def _load_swagger_meta(self, api, group_name): endpoints = [] base_path = api.get("basePath", "") for path in api["paths"]: for method in api["paths"][path]: logger.info(" ------- Endpoint: %s %s ------- " % (method, path)) try: endpoint = self._handle_endpoint( api["paths"][path][method], method, base_path.rstrip("/") + path) endpoints.append(endpoint) except Exception as e: logger.error("Error handling endpoint %s %s: %s", method, path, e) raise return { "base": api.get("basePath").rstrip("/"), "group": group_name, "endpoints": endpoints, } def _handle_endpoint(self, endpoint_swagger, method, path): endpoint = { "title": endpoint_swagger.get("summary", ""), "deprecated": endpoint_swagger.get("deprecated", False), "desc": endpoint_swagger.get("description", endpoint_swagger.get("summary", "")), "method": method.upper(), "path": path.strip(), "requires_auth": "security" in endpoint_swagger, "rate_limited": 429 in endpoint_swagger.get("responses", {}), "req_param_by_loc": {}, "req_body_tables": [], "res_headers": None, "res_tables": [], "responses": [], "example": { "req": "", } } path_template = path example_query_params = [] example_body = "" example_mime = "application/json" for param in endpoint_swagger.get("parameters", []): # even body params should have names, otherwise the active docs don't work. param_name = param["name"] try: param_loc = param["in"] if param_loc == "body": self._handle_body_param(param, endpoint) example_body = get_example_for_param(param) continue if param_loc == "header": if param["name"] == "Content-Type" and param["x-example"]: example_mime = param["x-example"] # description desc = param.get("description", "") if param.get("required"): desc = "**Required.** " + desc # assign value expected for this param val_type = param.get("type") # integer/string if val_type == "array": items = param.get("items") if items: if isinstance(items, list): types = ", ".join(i.get("type") for i in items) val_type = "[%s]" % (types,) else: val_type = "[%s]" % items.get("type") if param.get("enum"): val_type = "enum" desc += ( " One of: %s" % json.dumps(param.get("enum")) ) endpoint["req_param_by_loc"].setdefault(param_loc, []).append( TypeTableRow(key=param_name, title=val_type, desc=desc), ) example = get_example_for_param(param) if example is None: continue if param_loc == "path": path_template = path_template.replace( "{%s}" % param_name, quote(example) ) elif param_loc == "query": if type(example) == list: for value in example: example_query_params.append((param_name, value)) else: example_query_params.append((param_name, example)) except Exception as e: raise Exception("Error handling parameter %s" % param_name, e) # endfor[param] good_response = None for code in sorted(endpoint_swagger.get("responses", {}).keys()): res = endpoint_swagger["responses"][code] if not good_response and code == 200: good_response = res description = res.get("description", "") example = get_example_for_response(res) endpoint["responses"].append({ "code": code, "description": description, "example": example, }) # add response params if this API has any. if good_response: if "schema" in good_response: endpoint["res_tables"] = get_tables_for_response( good_response["schema"] ) if "headers" in good_response: headers = TypeTable() for (header_name, header) in good_response["headers"].items(): headers.add_row( TypeTableRow(key=header_name, title=header["type"], desc=header["description"]), ) endpoint["res_headers"] = headers query_string = "" if len( example_query_params) == 0 else "?" + urlencode( example_query_params) if example_body: endpoint["example"][ "req"] = "%s %s%s HTTP/1.1\nContent-Type: %s\n\n%s" % ( method.upper(), path_template, query_string, example_mime, example_body ) else: endpoint["example"]["req"] = "%s %s%s HTTP/1.1\n\n" % ( method.upper(), path_template, query_string ) return endpoint def _handle_body_param(self, param, endpoint_data): """Update endpoint_data object with the details of the body param :param string filepath path to the yaml :param dict param the parameter data from the yaml :param dict endpoint_data dictionary of endpoint data to be updated """ try: schema = inherit_parents(param["schema"]) if schema["type"] != "object": logger.warn( "Unsupported body type %s for %s %s", schema["type"], endpoint_data["method"], endpoint_data["path"] ) return req_body_tables = get_tables_for_schema(schema) if req_body_tables == []: # no fields defined for the body. return # put the top-level parameters into 'req_param_by_loc', and the others # into 'req_body_tables' body_params = endpoint_data['req_param_by_loc'].setdefault("JSON body",[]) body_params.extend(req_body_tables[0].rows) body_tables = req_body_tables[1:] endpoint_data['req_body_tables'].extend(body_tables) except Exception as e: e2 = Exception( "Error decoding body of API endpoint %s %s: %s" % (endpoint_data["method"], endpoint_data["path"], e) ) raise e2.with_traceback(sys.exc_info()[2]) def load_swagger_apis(self): apis = {} for path, suffix in HTTP_APIS.items(): for filename in os.listdir(path): if not filename.endswith(".yaml"): continue filepath = os.path.join(path, filename) logger.info("Reading swagger API: %s" % filepath) with open(filepath, "r", encoding="utf-8") as f: # strip .yaml group_name = filename[:-5].replace("-", "_") group_name = "%s_%s" % (group_name, suffix) api = yaml.load(f, OrderedLoader) api = resolve_references(filepath, api) api["__meta"] = self._load_swagger_meta( api, group_name ) apis[group_name] = api return apis def load_swagger_definitions(self): defs = {} for path, prefix in SWAGGER_DEFINITIONS.items(): self._load_swagger_definitions_in_dir(defs, path, prefix) return defs def _load_swagger_definitions_in_dir(self, defs, path, prefix, recurse=True): if not os.path.exists(path): return defs for filename in os.listdir(path): filepath = os.path.join(path, filename) if os.path.isdir(filepath) and recurse: safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", filename) dir_prefix = "_".join([prefix, safe_name]) # We don't recurse because we have to stop at some point self._load_swagger_definitions_in_dir( defs, filepath, dir_prefix, recurse=False) if not filename.endswith(".yaml"): continue filepath = os.path.join(path, filename) logger.info("Reading swagger definition: %s" % filepath) with open(filepath, "r", encoding="utf-8") as f: # strip .yaml group_name = re.sub(r"[^a-zA-Z0-9_]", "_", filename[:-5]) group_name = "%s_%s" % (prefix, group_name) definition = yaml.load(f, OrderedLoader) definition = resolve_references(filepath, definition) if 'type' not in definition: continue try: example = get_example_for_schema(definition) except: example = None pass # do nothing - we don't care if 'title' not in definition: definition['title'] = "NO_TITLE" definition['tables'] = get_tables_for_schema(definition) defs[group_name] = { "definition": definition, "examples": [example] if example is not None else [], } return defs def load_common_event_fields(self): """Parse the core event schema files Returns: dict: with the following properties: "title": Event title (from the 'title' field of the schema) "desc": desc "tables": list[TypeTable] """ path = CORE_EVENT_SCHEMA event_types = {} for filename in os.listdir(path): if not filename.endswith(".yaml"): continue filepath = os.path.join(path, filename) event_type = filename[:-5] # strip the ".yaml" logger.info("Reading event schema: %s" % filepath) with open(filepath, encoding="utf-8") as f: event_schema = yaml.load(f, OrderedLoader) event_schema = resolve_references(filepath, event_schema) schema_info = process_data_type( event_schema, enforce_title=True, ) event_types[event_type] = schema_info return event_types def load_apis(self, substitutions): cs_ver = substitutions.get("%CLIENT_RELEASE_LABEL%", "unstable") fed_ver = substitutions.get("%SERVER_RELEASE_LABEL%", "unstable") is_ver = substitutions.get("%IDENTITY_RELEASE_LABEL%", "unstable") as_ver = substitutions.get("%APPSERVICE_RELEASE_LABEL%", "unstable") push_gw_ver = substitutions.get("%PUSH_GATEWAY_RELEASE_LABEL%", "unstable") # we abuse the typetable to return this info to the templates return TypeTable(rows=[ TypeTableRow( "`Client-Server API <client_server/"+cs_ver+".html>`_", cs_ver, "Interaction between clients and servers", ), TypeTableRow( "`Server-Server API <server_server/"+fed_ver+".html>`_", fed_ver, "Federation between servers", ), TypeTableRow( "`Application Service API <application_service/"+as_ver+".html>`_", as_ver, "Privileged server plugins", ), TypeTableRow( "`Identity Service API <identity_service/"+is_ver+".html>`_", is_ver, "Mapping of third party IDs to Matrix IDs", ), TypeTableRow( "`Push Gateway API <push_gateway/"+push_gw_ver+".html>`_", push_gw_ver, "Push notifications for Matrix events", ), ]) def load_event_examples(self): path = EVENT_EXAMPLES examples = {} for filename in os.listdir(path): if not filename.startswith("m."): continue event_name = filename.split("$")[0] filepath = os.path.join(path, filename) logger.info("Reading event example: %s" % filepath) try: with open(filepath, "r", encoding="utf-8") as f: example = resolve_references(filepath, json.load(f)) examples[filename] = examples.get(filename, []) examples[filename].append(example) if filename != event_name: examples[event_name] = examples.get(event_name, []) examples[event_name].append(example) except Exception as e: e2 = Exception("Error reading event example "+filepath+": "+ str(e)) # throw the new exception with the old stack trace, so that # we don't lose information about where the error occurred. raise e2.with_traceback(sys.exc_info()[2]) return examples def load_event_schemas(self): path = EVENT_SCHEMA schemata = {} for filename in os.listdir(path): if not filename.startswith("m."): continue filepath = os.path.join(path, filename) try: schemata[filename] = self.read_event_schema(filepath) except Exception as e: e2 = Exception("Error reading event schema "+filepath+": "+ str(e)) # throw the new exception with the old stack trace, so that # we don't lose information about where the error occurred. raise e2.with_traceback(sys.exc_info()[2]) return schemata def read_event_schema(self, filepath): logger.info("Reading %s" % filepath) with open(filepath, "r", encoding="utf-8") as f: json_schema = yaml.load(f, OrderedLoader) schema = { # one of "Message Event" or "State Event" "typeof": "", "typeof_info": "", # event type, eg "m.room.member". Note *not* the type of the # event object (which should always be 'object'). "type": None, "title": None, "desc": None, "msgtype": None, "type_with_msgtype": None, # for the template's sake "content_fields": [ # <TypeTable> ] } # before we resolve the references, see if the first reference is to # the message event or state event schemas, and add typeof info if so. base_defs = { ROOM_EVENT: "Message Event", STATE_EVENT: "State Event" } if type(json_schema.get("allOf")) == list: firstRef = json_schema["allOf"][0]["$ref"] if firstRef in base_defs: schema["typeof"] = base_defs[firstRef] json_schema = resolve_references(filepath, json_schema) # add type schema["type"] = Units.prop( json_schema, "properties/type/enum" )[0] # add summary and desc schema["title"] = json_schema.get("title") schema["desc"] = json_schema.get("description", "") # walk the object for field info schema["content_fields"] = get_tables_for_schema( Units.prop(json_schema, "properties/content") ) # grab msgtype if it is the right kind of event msgtype = Units.prop( json_schema, "properties/content/properties/msgtype/enum" ) if msgtype: schema["msgtype"] = msgtype[0] # enum prop schema["type_with_msgtype"] = schema["type"] + " (" + msgtype[0] + ")" # link to msgtypes for m.room.message if schema["type"] == "m.room.message" and not msgtype: schema["desc"] += ( " For more information on ``msgtypes``, see "+ "`m.room.message msgtypes`_." ) # method types for m.key.verification.start if schema["type"] == "m.key.verification.start": methods = Units.prop( json_schema, "properties/content/properties/method/enum" ) if methods: schema["type_with_msgtype"] = schema["type"] + " (" + methods[0] + ")" # Assign state key info if it has some if schema["typeof"] == "State Event": skey_desc = Units.prop( json_schema, "properties/state_key/description" ) if not skey_desc: raise Exception("Missing description for state_key") schema["typeof_info"] = "``state_key``: %s" % skey_desc return schema def load_changelogs(self, substitutions): """Loads the changelog unit for later rendering in a section. Args: substitutions: dict of variable name to value. Provided by the gendoc script. Returns: A dict of API name ("client_server", for example) to changelog. """ changelogs = {} # The APIs and versions we'll prepare changelogs for. We use the substitutions # to ensure that we pick up the right version for generated documentation. This # defaults to "unstable" as a version for incremental generated documentation (CI). prepare_versions = { "server_server": substitutions.get("%SERVER_RELEASE_LABEL%", "unstable"), "client_server": substitutions.get("%CLIENT_RELEASE_LABEL%", "unstable"), "identity_service": substitutions.get("%IDENTITY_RELEASE_LABEL%", "unstable"), "push_gateway": substitutions.get("%PUSH_GATEWAY_RELEASE_LABEL%", "unstable"), "application_service": substitutions.get("%APPSERVICE_RELEASE_LABEL%", "unstable"), } # Changelogs are split into two places: towncrier for the unstable changelog and # the RST file for historical versions. If the prepare_versions dict above has # a version other than "unstable" specified for an API, we'll use the historical # changelog and otherwise generate the towncrier log in-memory. for api_name, target_version in prepare_versions.items(): logger.info("Generating changelog for %s at %s" % (api_name, target_version,)) changelog_lines = [] if target_version == 'unstable': # generate towncrier log changelog_lines = self._read_towncrier_changelog(api_name) else: # read in the existing RST changelog changelog_lines = self._read_rst_changelog(api_name) # Parse the changelog lines to find the header we're looking for and therefore # the changelog body. prev_line = None title_part = None changelog_body_lines = [] for line in changelog_lines: if prev_line is None: prev_line = line continue if re.match("^[=]{3,}$", line.strip()): # the last line was a header - use that as our new title_part title_part = prev_line.strip() # take off the last line from the changelog_body_lines because it's the title if len(changelog_body_lines) > 0: changelog_body_lines = changelog_body_lines[:len(changelog_body_lines) - 1] continue if re.match("^[-]{3,}$", line.strip()): # the last line is a subheading - drop this line because it's the underline # and that causes problems with rendering. We'll keep the header text though. continue if line.strip().startswith(".. "): # skip comments continue if title_part == target_version: # if we made it this far, append the line to the changelog body. We indent it so # that it renders correctly in the section. We also add newlines so that there's # intentionally blank lines that make rst2html happy. changelog_body_lines.append(" " + line + '\n') prev_line = line if len(changelog_body_lines) > 0: changelogs[api_name] = "".join(changelog_body_lines) else: raise ValueError("No changelog for %s at %s" % (api_name, target_version,)) # return our `dict[api_name] => changelog` as the last step. return changelogs def _read_towncrier_changelog(self, api_name): tc_path = os.path.join(CHANGELOG_DIR, api_name) if os.path.isdir(tc_path): logger.info("Generating towncrier changelog for: %s" % api_name) p = subprocess.Popen( ['towncrier', '--version', 'unstable', '--name', api_name, '--draft'], cwd=tc_path, stderr=subprocess.PIPE, stdout=subprocess.PIPE, ) stdout, stderr = p.communicate() if p.returncode != 0: # Something broke - dump as much information as we can logger.error("Towncrier exited with code %s" % p.returncode) logger.error(stdout.decode('UTF-8')) logger.error(stderr.decode('UTF-8')) raw_log = "" else: raw_log = stdout.decode('UTF-8') # This is a bit of a hack, but it does mean that the log at least gets *something* # to tell us it broke if not raw_log.startswith("unstable"): logger.error("Towncrier appears to have failed to generate a changelog") logger.error(raw_log) raw_log = "" return raw_log.splitlines() return [] def _read_rst_changelog(self, api_name): logger.info("Reading changelog RST for %s" % api_name) rst_path = os.path.join(CHANGELOG_DIR, "%s.rst" % api_name) with open(rst_path, 'r', encoding="utf-8") as f: return f.readlines() def load_unstable_warnings(self, substitutions): warning = """ .. WARNING:: You are viewing an unstable version of this specification. Unstable specifications may change at any time without notice. To view the current specification, please `click here <latest.html>`_. """ warnings = {} for var in substitutions.keys(): key = var[1:-1] # take off the surrounding %-signs if substitutions.get(var, "unstable") == "unstable": warnings[key] = warning else: warnings[key] = "" return warnings def load_spec_targets(self): with open(TARGETS, "r") as f: return yaml.load(f.read()) def load_git_version(self): null = open(os.devnull, 'w') cwd = os.path.dirname(os.path.abspath(__file__)) try: git_branch = subprocess.check_output( ['git', 'rev-parse', '--abbrev-ref', 'HEAD'], stderr=null, cwd=cwd, ).strip().decode('UTF-8') except subprocess.CalledProcessError: git_branch = "" try: git_tag = subprocess.check_output( ['git', 'describe', '--exact-match'], stderr=null, cwd=cwd, ).strip().decode('UTF-8') git_tag = "tag=" + git_tag except subprocess.CalledProcessError: git_tag = "" try: git_commit = subprocess.check_output( ['git', 'rev-parse', '--short', 'HEAD'], stderr=null, cwd=cwd, ).strip().decode('UTF-8') except subprocess.CalledProcessError: git_commit = "" try: dirty_string = "-this_is_a_dirty_checkout" is_dirty = subprocess.check_output( ['git', 'describe', '--dirty=' + dirty_string, "--all"], stderr=null, cwd=cwd, ).strip().decode('UTF-8').endswith(dirty_string) git_dirty = "dirty" if is_dirty else "" except subprocess.CalledProcessError: git_dirty = "" git_version = "Unknown" if git_branch or git_tag or git_commit or git_dirty: git_version = ",".join( s for s in (git_branch, git_tag, git_commit, git_dirty,) if s ).encode("ascii").decode('ascii') return { "string": git_version, "revision": git_commit } def load_sas_emoji(self): with open(SAS_EMOJI_JSON, 'r', encoding='utf-8') as sas_json: emoji = json.load(sas_json) # Verify the emoji matches the unicode for c in emoji: e = c['emoji'] logger.info("Checking emoji %s (%s)", e, c['description']) u = re.sub(r'U\+([0-9a-fA-F]+)', lambda m: chr(int(m.group(1), 16)), c['unicode']) if e != u: raise Exception("Emoji %s should be %s not %s" % ( c['description'], repr(e), c['unicode'], )) return emoji
the-stack_106_29219
"""Spark helper functions""" import csv import logging import os from pathlib import Path from typing import AnyStr, List, Union from pyspark.sql import Row, SparkSession from pyspark.sql.types import StructType, StringType from pyspark import SparkConf from dsgrid.exceptions import DSGInvalidField from dsgrid.utils.files import load_data from dsgrid.utils.timing import Timer, track_timing, timer_stats_collector logger = logging.getLogger(__name__) def init_spark(name="dsgrid"): """Initialize a SparkSession.""" cluster = os.environ.get("SPARK_CLUSTER") if cluster is not None: logger.info("Create SparkSession %s on existing cluster %s", name, cluster) conf = SparkConf().setAppName(name).setMaster(cluster) spark = SparkSession.builder.config(conf=conf).getOrCreate() else: logger.info("Create SparkSession %s in local-mode cluster", name) spark = SparkSession.builder.master("local").appName(name).getOrCreate() logger.info("Spark conf: %s", str(spark.sparkContext.getConf().getAll())) return spark @track_timing(timer_stats_collector) def create_dataframe(records, cache=False, require_unique=None): """Create a spark DataFrame from a list of records. Parameters ---------- records : list list of spark.sql.Row cache : bool If True, cache the DataFrame in memory. require_unique : list list of column names (str) to check for uniqueness Returns ------- spark.sql.DataFrame """ df = SparkSession.getActiveSession().createDataFrame(records) _post_process_dataframe(df, cache=cache, require_unique=require_unique) return df @track_timing(timer_stats_collector) def read_dataframe(filename, cache=False, require_unique=None, read_with_spark=True): """Create a spark DataFrame from a file. Supported formats when read_with_spark=True: .csv, .json, .parquet Supported formats when read_with_spark=False: .csv, .json Parameters ---------- filename : str | Path path to file cache : bool If True, cache the DataFrame in memory. require_unique : list list of column names (str) to check for uniqueness read_with_spark : bool If True, read the file with pyspark.read. Otherwise, read the file into a list of dicts, convert to pyspark Rows, and then to a DataFrame. Returns ------- spark.sql.DataFrame Raises ------ ValueError Raised if a require_unique column has duplicate values. """ filename = Path(filename) func = _read_with_spark if read_with_spark else _read_natively df = func(filename) _post_process_dataframe(df, cache=cache, require_unique=require_unique) return df def _read_with_spark(filename): spark = SparkSession.getActiveSession() path = str(filename) if filename.suffix == ".csv": df = spark.read.csv(path, inferSchema=True, header=True) elif Path(filename).suffix == ".parquet": df = spark.read.parquet(path) elif Path(filename).suffix == ".json": df = spark.read.json(path, mode="FAILFAST") else: assert False, f"Unsupported file extension: {filename}" return df def _read_natively(filename): if filename.suffix == ".csv": with open(filename, encoding="utf-8-sig") as f_in: rows = [Row(**x) for x in csv.DictReader(f_in)] elif Path(filename).suffix == ".json": rows = load_data(filename) else: assert False, f"Unsupported file extension: {filename}" return SparkSession.getActiveSession().createDataFrame(rows) def _post_process_dataframe(df, cache=False, require_unique=None): # TODO This is causing Spark warning messages. Disable until we know why. # if cache: # df = df.cache() if require_unique is not None: with Timer(timer_stats_collector, "check_unique"): for column in require_unique: unique = df.select(column).distinct() if unique.count() != df.count(): raise DSGInvalidField(f"DataFrame has duplicate entries for {column}") def get_unique_values(df, columns: Union[AnyStr, List]): """Return the unique values of a dataframe in one column or a list of columns. Parameters ---------- df : pyspark.sql.DataFrame column : str or list of str Returns ------- set """ dfc = df.select(columns).distinct().collect() if isinstance(columns, list): values = {tuple(getattr(row, col) for col in columns) for row in dfc} else: values = {getattr(x, columns) for x in dfc} return values @track_timing(timer_stats_collector) def models_to_dataframe(models, cache=False): """Converts a list of Pydantic models to a Spark DataFrame. Parameters ---------- models : list cache : If True, cache the DataFrame. Returns ------- pyspark.sql.DataFrame """ assert models cls = type(models[0]) rows = [] for model in models: row = Row(**{f: getattr(model, f) for f in cls.__fields__}) rows.append(row) df = SparkSession.getActiveSession().createDataFrame(rows) if cache: df.cache() return df @track_timing(timer_stats_collector) def create_dataframe_from_dimension_ids(records, *dimension_types, cache=True): """Return a DataFrame created from the IDs of dimension_types. Parameters ---------- records : sequence Iterable of lists of record IDs dimension_types : tuple cache : If True, cache the DataFrame. Returns ------- pyspark.sql.DataFrame """ schema = StructType() for dimension_type in dimension_types: schema.add(dimension_type.value, StringType(), nullable=False) df = SparkSession.getActiveSession().createDataFrame(records, schema=schema) if cache: df.cache() return df @track_timing(timer_stats_collector) def check_for_nulls(df, exclude_columns=None): """Check if a DataFrame has null values. Parameters ---------- df : spark.sql.DataFrame exclude_columns : None or Set Raises ------ DSGInvalidField Raised if null exists in any column. """ if exclude_columns is None: exclude_columns = set() cols_to_check = set(df.columns).difference(exclude_columns) cols_str = ", ".join(cols_to_check) filter_str = " OR ".join((f"{x} is NULL" for x in cols_to_check)) df.createOrReplaceTempView("tmp_table") try: # Avoid iterating with many checks unless we know there is at least one failure. nulls = sql(f"SELECT {cols_str} FROM tmp_table WHERE {filter_str}") if not nulls.rdd.isEmpty(): cols_with_null = set() for col in cols_to_check: if not nulls.select(col).filter(f"{col} is NULL").rdd.isEmpty(): cols_with_null.add(col) assert cols_with_null, "Did not find any columns with NULL values" raise DSGInvalidField( f"DataFrame contains NULL value(s) for column(s): {cols_with_null}" ) finally: sql("DROP VIEW tmp_table") def sql(query): """Run a SQL query with Spark. Parameters ---------- query : str Returns ------- pyspark.sql.DataFrame """ logger.debug("Run SQL query [%s]", query) return SparkSession.getActiveSession().sql(query) def sql_from_sqlalchemy(query): """Run a SQL query with Spark where the query was generated by sqlalchemy. Parameters ---------- query : sqlalchemy.orm.query.Query Returns ------- pyspark.sql.DataFrame """ logger.debug("sqlchemy query = %s", query) return sql(str(query).replace('"', ""))
the-stack_106_29220
"""meltano run command and supporting functions.""" from typing import List, Union import click import structlog from meltano.core.block.blockset import BlockSet from meltano.core.block.parser import BlockParser, validate_block_sets from meltano.core.block.plugin_command import PluginCommandBlock from meltano.core.project import Project from meltano.core.runner import RunnerError from meltano.core.tracking import GoogleAnalyticsTracker from meltano.core.utils import click_run_async from . import CliError, cli from .params import pass_project logger = structlog.getLogger(__name__) @cli.command(short_help="[preview] Run a set of plugins in series.") @click.option( "--full-refresh", help="Perform a full refresh (ignore state left behind by any previous runs). Applies to all pipelines.", is_flag=True, ) @click.option( "--no-state-update", help="Run without state saving. Applies to all pipelines.", is_flag=True, ) @click.option( "--force", "-f", help="Force a new run even if a pipeline with the same Job ID is already present. Applies to all pipelines.", is_flag=True, ) @click.argument( "blocks", nargs=-1, ) @pass_project(migrate=True) @click_run_async async def run( project: Project, full_refresh: bool, no_state_update: bool, force: bool, blocks: List[str], ): """ Run a set of command blocks in series. Blocks are specified as a list of plugin names, e.g. `meltano run some_extractor some_loader some_plugin:some_command` and are run in the order they are specified from left to right. A failure in any block will cause the entire run to abort. Multiple commmand blocks can be chained together or repeated, and tap/target pairs will automatically be linked: `meltano run tap-gitlab target-postgres dbt:test dbt:run`\n `meltano run tap-gitlab target-postgres tap-salesforce target-mysql ...`\n `meltano run tap-gitlab target-postgres dbt:run tap-postgres target-bigquery ...`\n When running within an active environment, meltano run activates incremental job support. Job ID's are autogenerated using the format `{active_environment.name}:{extractor_name}-to-{loader_name}` for each extract/load pair found: `meltano --environment=prod run tap-gitlab target-postgres tap-salesforce target-mysql`\n The above command will create two jobs with the IDs `prod:tap-gitlab-to-target-postgres` and `prod:tap-salesforce-to-target-mysql`. This a preview feature - its functionality and cli signature is still evolving. \b\nRead more at https://meltano.com/docs/command-line-interface.html#run """ parser = BlockParser(logger, project, blocks, full_refresh, no_state_update, force) parsed_blocks = list(parser.find_blocks(0)) if not parsed_blocks: logger.info("No valid blocks found.") return if validate_block_sets(logger, parsed_blocks): logger.debug("All ExtractLoadBlocks validated, starting execution.") else: raise CliError("Some ExtractLoadBlocks set failed validation.") await _run_blocks(parsed_blocks) tracker = GoogleAnalyticsTracker(project) tracker.track_meltano_run(blocks) async def _run_blocks(parsed_blocks: List[Union[BlockSet, PluginCommandBlock]]) -> None: for idx, blk in enumerate(parsed_blocks): try: await blk.run() except RunnerError as err: logger.error( "Block run completed.", set_number=idx, block_type=blk.__class__.__name__, success=False, err=err, exit_codes=err.exitcodes, ) raise CliError( f"Run invocation could not be completed as block failed: {err}" ) from err logger.info( "Block run completed.", set_number=idx, block_type=blk.__class__.__name__, success=True, err=None, )
the-stack_106_29221
""" ************************************************************************* * Copyright 2020 Adobe. All rights reserved. * This file is licensed to you 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 REPRESENTATIONS * OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. **************************************************************************/ """ from converter.aem_dispatcher_converter import AEMDispatcherConverter from util import constants from argparse import ArgumentParser from shutil import copytree, rmtree from os.path import exists parser = ArgumentParser() parser.add_argument('--sdk_src', help='Absolute path to the src folder of the dispatcher sdk') parser.add_argument('--cfg', help='Absolute path to dispatcher config folder') args = parser.parse_args() # if `target` folder already exists, delete it if exists(constants.TARGET_FOLDER): rmtree(constants.TARGET_FOLDER) copytree(args.cfg, constants.TARGET_DISPATCHER_SRC_FOLDER, True) converter = AEMDispatcherConverter(args.sdk_src, constants.TARGET_DISPATCHER_SRC_FOLDER) converter.__transform__() print("\nTransformation Complete!\n") print("Please check", constants.TARGET_DISPATCHER_SRC_FOLDER, "folder for transformed configuration files.") print("Please check", constants.SUMMARY_REPORT_FILE, "for summary report.") print("Please check", constants.LOG_FILE, "for logs.")
the-stack_106_29224
import os import time import pandas as pd from tqdm import tqdm from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.algo.conformance.tokenreplay import algorithm as token_replay from skmultiflow.utils import calculate_object_size from utils import read_log from utils import sort_alphanumeric from utils import retrieve_traces def compute_alignments(replayed_traces): trace_is_fit, trace_fitness, missing_tokens, consumed_tokens, remaining_tokens, produced_tokens = [], [], [], [], [], [] for replayed in replayed_traces: trace_is_fit.append(replayed['trace_is_fit']) trace_fitness.append(float(replayed['trace_fitness'])) missing_tokens.append(float(replayed['missing_tokens'])) consumed_tokens.append(float(replayed['consumed_tokens'])) remaining_tokens.append(float(replayed['remaining_tokens'])) produced_tokens.append(float(replayed['produced_tokens'])) return [trace_is_fit, trace_fitness, missing_tokens, consumed_tokens, remaining_tokens, produced_tokens] path = './event_logs' save_path = './encoding_results/tokenreplay' os.makedirs(save_path, exist_ok=True) for file in tqdm(sort_alphanumeric(os.listdir(path))): # read event log and import case id and labels ids, traces, y = retrieve_traces(read_log(path, file)) # import xes log for process discovery file_xes = file.split('.csv')[0] log = xes_importer.apply(f'{path}_xes/{file_xes}.xes') start_time = time.time() # generate process model net, initial_marking, final_marking = inductive_miner.apply(log) # calculating tokenreplay replayed_traces = token_replay.apply(log, net, initial_marking, final_marking) end_time = time.time() - start_time memory = calculate_object_size(replayed_traces) final_token_replay = compute_alignments(replayed_traces) # saving out_df = pd.DataFrame() out_df['trace_is_fit'] = final_token_replay[0] out_df['trace_fitness'] = final_token_replay[1] out_df['missing_tokens'] = final_token_replay[2] out_df['consumed_tokens'] = final_token_replay[3] out_df['remaining_tokens'] = final_token_replay[4] out_df['produced_tokens'] = final_token_replay[5] out_df['case'] = ids out_df['time'] = end_time out_df['memory'] = memory out_df['label'] = y out_df.to_csv(f'{save_path}/{file}', index=False)
the-stack_106_29225
import rlkit.misc.hyperparameter as hyp from multiworld.envs.pygame import PickAndPlaceEnv from rlkit.launchers.launcher_util import run_experiment from rlkit.torch.sets.vae_launcher import train_set_vae if __name__ == "__main__": variant = dict( env_id='OneObject-PickAndPlace-BigBall-RandomInit-2D-v1', renderer_kwargs=dict( output_image_format='CHW', ), create_vae_kwargs=dict( latent_dim=128, use_fancy_architecture=True, decoder_distribution='gaussian_fixed_unit_variance', ), vae_trainer_kwargs=dict( vae_lr=1e-3, vae_visualization_config=dict( num_recons=10, num_samples=20, # debug_period=50, debug_period=10, unnormalize_images=True, image_format='CHW', ), beta=2, set_loss_weight=0, ), reward_visualization_period=10, beta_scale_schedule_kwargs=dict( version='piecewise_linear', x_values=[0, 20, 40, 60, 80, 100], ), data_loader_kwargs=dict( batch_size=128, ), vae_algo_kwargs=dict( num_iters=101, num_epochs_per_iter=20, progress_csv_file_name='vae_progress.csv', ), include_env_debug=True, generate_test_set_kwargs=dict( num_samples_per_set=128, set_configs=[ dict( version='move_a_to_b', offsets_from_b=(4, 0), a_axis_to_b_axis={ 0: 2, 1: 3, }, ), ], ), generate_train_set_kwargs=dict( num_samples_per_set=128, set_configs=[ dict( version='move_a_to_b', offsets_from_b=(4, 0), a_axis_to_b_axis={ 0: 2, 1: 3, }, ), ], ), num_ungrouped_images=12800, logger_config=dict( push_prefix=False, ), ) n_seeds = 1 mode = 'local' exp_name = 'dev-{}'.format( __file__.replace('/', '-').replace('_', '-').split('.')[0] ) n_seeds = 1 mode = 'sss' exp_name = __file__.split('/')[-1].split('.')[0].replace('_', '-') print('exp_name', exp_name) search_space = { 'vae_algo_kwargs.num_iters': [101], 'create_vae_kwargs.decoder_distribution': [ 'gaussian_fixed_unit_variance', ], 'create_vae_kwargs.use_fancy_architecture': [ True, ], 'vae_trainer_kwargs.set_loss_weight': [ 0., 1., 2., 5., 10., ], 'create_vae_kwargs.latent_dim': [ 8, ], 'beta_scale_schedule_kwargs.y_values': [ [1, 1, 1, 1, 1, 1], [0, 1, 5, 10, 10, 10], [0, 10, 20, 30, 40, 50], ], } sweeper = hyp.DeterministicHyperparameterSweeper( search_space, default_parameters=variant, ) variants = list(sweeper.iterate_hyperparameters()) for _ in range(n_seeds): for exp_id, variant in enumerate(variants): variant['vae_trainer_kwargs']['beta'] = ( 1. / variant['create_vae_kwargs']['latent_dim'] ) variant['vae_trainer_kwargs']['debug_bad_recons'] = ( variant['create_vae_kwargs']['decoder_distribution'] == 'gaussian_learned_global_scalar_variance' ) if mode == 'local': variant['vae_algo_kwargs']['num_iters'] = 1 variant['vae_algo_kwargs']['num_epochs_per_iter'] = 1 # variant['generate_train_set_kwargs']['saved_filename'] = ( # 'manual-upload/sets/hand2xy_hand2x_1obj2xy_1obj2x_num_objs_1.pickle' # ) run_experiment( train_set_vae, exp_name=exp_name, prepend_date_to_exp_name=True, num_exps_per_instance=2, mode=mode, variant=variant, # slurm_config_name='cpu', use_gpu=True, # gpu_id=1, )
the-stack_106_29226
import http.client con_obj = http.client.HTTPSConnection("www.imdb.com") con_obj.request("GET", "/") response = con_obj.getresponse() print("Status: {}".format(response.status)) read_data = response.read(1000) print(read_data) con_obj.close()
the-stack_106_29228
import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable import math from functools import partial __all__ = ['WideResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101'] def conv3x3x3(in_planes, out_planes, stride=1): # 3x3x3 convolution with padding return nn.Conv3d( in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False) def downsample_basic_block(x, planes, stride): out = F.avg_pool3d(x, kernel_size=1, stride=stride) zero_pads = torch.Tensor( out.size(0), planes - out.size(1), out.size(2), out.size(3), out.size(4)).zero_() if isinstance(out.data, torch.cuda.FloatTensor): zero_pads = zero_pads.cuda() out = Variable(torch.cat([out.data, zero_pads], dim=1)) return out class WideBottleneck(nn.Module): expansion = 2 def __init__(self, inplanes, planes, stride=1, downsample=None): super(WideBottleneck, self).__init__() self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False) self.bn1 = nn.BatchNorm3d(planes) self.conv2 = nn.Conv3d( planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn2 = nn.BatchNorm3d(planes) self.conv3 = nn.Conv3d( planes, planes * self.expansion, kernel_size=1, bias=False) self.bn3 = nn.BatchNorm3d(planes * self.expansion) self.relu = nn.ReLU(inplace=True) self.downsample = downsample self.stride = stride def forward(self, x): residual = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) if self.downsample is not None: residual = self.downsample(x) out += residual out = self.relu(out) return out class WideResNet(nn.Module): def __init__(self, block, layers, sample_height, sample_width, sample_duration, k=1, shortcut_type='B', num_classes=400): self.inplanes = 64 super(WideResNet, self).__init__() self.conv1 = nn.Conv3d( 3, 64, kernel_size=7, stride=(1, 2, 2), padding=(3, 3, 3), bias=False) self.bn1 = nn.BatchNorm3d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool3d(kernel_size=(3, 3, 3), stride=2, padding=1) self.layer1 = self._make_layer(block, 64 * k, layers[0], shortcut_type) self.layer2 = self._make_layer( block, 128 * k, layers[1], shortcut_type, stride=2) self.layer3 = self._make_layer( block, 256 * k, layers[2], shortcut_type, stride=2) self.layer4 = self._make_layer( block, 512 * k, layers[3], shortcut_type, stride=2) last_duration = int(math.ceil(sample_duration / 16)) last_size_height = int(math.ceil(sample_height / 32)) last_size_width = int(math.ceil(sample_width / 32)) self.avgpool = nn.AvgPool3d( (last_duration, last_size_height, last_size_width), stride=1) self.fc = nn.Linear(512 * k * block.expansion, num_classes) for m in self.modules(): if isinstance(m, nn.Conv3d): m.weight = nn.init.kaiming_normal(m.weight, mode='fan_out') elif isinstance(m, nn.BatchNorm3d): m.weight.data.fill_(1) m.bias.data.zero_() def _make_layer(self, block, planes, blocks, shortcut_type, stride=1): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: if shortcut_type == 'A': downsample = partial( downsample_basic_block, planes=planes * block.expansion, stride=stride) else: downsample = nn.Sequential( nn.Conv3d( self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), nn.BatchNorm3d(planes * block.expansion)) layers = [] layers.append(block(self.inplanes, planes, stride, downsample)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append(block(self.inplanes, planes)) return nn.Sequential(*layers) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.maxpool(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.avgpool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x def get_fine_tuning_parameters(model, ft_begin_index): if ft_begin_index == 0: return model.parameters() ft_module_names = [] for i in range(ft_begin_index, 5): ft_module_names.append('layer{}'.format(i)) ft_module_names.append('fc') parameters = [] for k, v in model.named_parameters(): for ft_module in ft_module_names: if ft_module in k: parameters.append({'params': v}) break else: parameters.append({'params': v, 'lr': 0.0}) return parameters def resnet50(**kwargs): """Constructs a ResNet-50 model. """ model = WideResNet(WideBottleneck, [3, 4, 6, 3], **kwargs) return model
the-stack_106_29230
# -*- coding: utf-8 -*- import logging from subprocess import CalledProcessError, check_call from apps.offline.models import THUMBNAIL_HEIGHT def create_thumbnail(instance): logger = logging.getLogger(__name__) logger.debug('Checking for thumbnail for "%s".' % instance.title) if instance.thumbnail_exists is False: logger.debug('Thumbnail for "%s" not found - creating...' % instance.title) # Fixes an annoying Exception in logs, not really needed # http://stackoverflow.com/questions/13193278/ { import threading threading._DummyThread._Thread__stop = lambda x: 42 # } try: check_call(["convert", "-resize", "x" + str(THUMBNAIL_HEIGHT), instance.url + "[0]", instance.thumbnail]) except (OSError, CalledProcessError) as e: logger.debug("ERROR: {0}".format(e)) logger.debug('Thumbnail created, and is located at: %s' % instance.thumbnail) else: logger.debug('Thumbnail already exists, and is located at: %s' % instance.thumbnail)
the-stack_106_29234
# pylint: disable=E1101 from warnings import catch_warnings from datetime import datetime, timedelta from functools import partial from textwrap import dedent from operator import methodcaller import pytz import pytest import dateutil import numpy as np import pandas as pd import pandas.tseries.offsets as offsets import pandas.util.testing as tm from pandas import (Series, DataFrame, Panel, Index, isna, notna, Timestamp) from pandas.core.dtypes.generic import ABCSeries, ABCDataFrame from pandas.compat import range, lrange, zip, product, OrderedDict from pandas.core.base import SpecificationError, AbstractMethodError from pandas.errors import UnsupportedFunctionCall from pandas.core.groupby import DataError from pandas.tseries.frequencies import MONTHS, DAYS from pandas.tseries.frequencies import to_offset from pandas.core.indexes.datetimes import date_range from pandas.tseries.offsets import Minute, BDay from pandas.core.indexes.period import period_range, PeriodIndex, Period from pandas.core.resample import (DatetimeIndex, TimeGrouper, DatetimeIndexResampler) from pandas.core.indexes.timedeltas import timedelta_range, TimedeltaIndex from pandas.util.testing import (assert_series_equal, assert_almost_equal, assert_frame_equal, assert_index_equal) from pandas._libs.period import IncompatibleFrequency bday = BDay() # The various methods we support downsample_methods = ['min', 'max', 'first', 'last', 'sum', 'mean', 'sem', 'median', 'prod', 'var', 'ohlc'] upsample_methods = ['count', 'size'] series_methods = ['nunique'] resample_methods = downsample_methods + upsample_methods + series_methods def _simple_ts(start, end, freq='D'): rng = date_range(start, end, freq=freq) return Series(np.random.randn(len(rng)), index=rng) def _simple_pts(start, end, freq='D'): rng = period_range(start, end, freq=freq) return Series(np.random.randn(len(rng)), index=rng) class TestResampleAPI(object): def setup_method(self, method): dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='Min') self.series = Series(np.random.rand(len(dti)), dti) self.frame = DataFrame( {'A': self.series, 'B': self.series, 'C': np.arange(len(dti))}) def test_str(self): r = self.series.resample('H') assert ('DatetimeIndexResampler [freq=<Hour>, axis=0, closed=left, ' 'label=left, convention=start, base=0]' in str(r)) def test_api(self): r = self.series.resample('H') result = r.mean() assert isinstance(result, Series) assert len(result) == 217 r = self.series.to_frame().resample('H') result = r.mean() assert isinstance(result, DataFrame) assert len(result) == 217 def test_api_changes_v018(self): # change from .resample(....., how=...) # to .resample(......).how() r = self.series.resample('H') assert isinstance(r, DatetimeIndexResampler) for how in ['sum', 'mean', 'prod', 'min', 'max', 'var', 'std']: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = self.series.resample('H', how=how) expected = getattr(self.series.resample('H'), how)() tm.assert_series_equal(result, expected) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = self.series.resample('H', how='ohlc') expected = self.series.resample('H').ohlc() tm.assert_frame_equal(result, expected) # compat for pandas-like methods for how in ['sort_values', 'isna']: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): getattr(r, how)() # invalids as these can be setting operations r = self.series.resample('H') pytest.raises(ValueError, lambda: r.iloc[0]) pytest.raises(ValueError, lambda: r.iat[0]) pytest.raises(ValueError, lambda: r.loc[0]) pytest.raises(ValueError, lambda: r.loc[ Timestamp('2013-01-01 00:00:00', offset='H')]) pytest.raises(ValueError, lambda: r.at[ Timestamp('2013-01-01 00:00:00', offset='H')]) def f(): r[0] = 5 pytest.raises(ValueError, f) # str/repr r = self.series.resample('H') with tm.assert_produces_warning(None): str(r) with tm.assert_produces_warning(None): repr(r) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): tm.assert_numpy_array_equal(np.array(r), np.array(r.mean())) # masquerade as Series/DataFrame as needed for API compat assert isinstance(self.series.resample('H'), ABCSeries) assert not isinstance(self.frame.resample('H'), ABCSeries) assert not isinstance(self.series.resample('H'), ABCDataFrame) assert isinstance(self.frame.resample('H'), ABCDataFrame) # bin numeric ops for op in ['__add__', '__mul__', '__truediv__', '__div__', '__sub__']: if getattr(self.series, op, None) is None: continue r = self.series.resample('H') with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): assert isinstance(getattr(r, op)(2), pd.Series) # unary numeric ops for op in ['__pos__', '__neg__', '__abs__', '__inv__']: if getattr(self.series, op, None) is None: continue r = self.series.resample('H') with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): assert isinstance(getattr(r, op)(), pd.Series) # comparison ops for op in ['__lt__', '__le__', '__gt__', '__ge__', '__eq__', '__ne__']: r = self.series.resample('H') with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): assert isinstance(getattr(r, op)(2), pd.Series) # IPython introspection shouldn't trigger warning GH 13618 for op in ['_repr_json', '_repr_latex', '_ipython_canary_method_should_not_exist_']: r = self.series.resample('H') with tm.assert_produces_warning(None): getattr(r, op, None) # getitem compat df = self.series.to_frame('foo') # same as prior versions for DataFrame pytest.raises(KeyError, lambda: df.resample('H')[0]) # compat for Series # but we cannot be sure that we need a warning here with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = self.series.resample('H')[0] expected = self.series.resample('H').mean()[0] assert result == expected with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = self.series.resample('H')['2005-01-09 23:00:00'] expected = self.series.resample('H').mean()['2005-01-09 23:00:00'] assert result == expected def test_groupby_resample_api(self): # GH 12448 # .groupby(...).resample(...) hitting warnings # when appropriate df = DataFrame({'date': pd.date_range(start='2016-01-01', periods=4, freq='W'), 'group': [1, 1, 2, 2], 'val': [5, 6, 7, 8]}).set_index('date') # replication step i = pd.date_range('2016-01-03', periods=8).tolist() + \ pd.date_range('2016-01-17', periods=8).tolist() index = pd.MultiIndex.from_arrays([[1] * 8 + [2] * 8, i], names=['group', 'date']) expected = DataFrame({'val': [5] * 7 + [6] + [7] * 7 + [8]}, index=index) result = df.groupby('group').apply( lambda x: x.resample('1D').ffill())[['val']] assert_frame_equal(result, expected) def test_groupby_resample_on_api(self): # GH 15021 # .groupby(...).resample(on=...) results in an unexpected # keyword warning. df = pd.DataFrame({'key': ['A', 'B'] * 5, 'dates': pd.date_range('2016-01-01', periods=10), 'values': np.random.randn(10)}) expected = df.set_index('dates').groupby('key').resample('D').mean() result = df.groupby('key').resample('D', on='dates').mean() assert_frame_equal(result, expected) def test_plot_api(self): tm._skip_if_no_mpl() # .resample(....).plot(...) # hitting warnings # GH 12448 s = Series(np.random.randn(60), index=date_range('2016-01-01', periods=60, freq='1min')) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = s.resample('15min').plot() tm.assert_is_valid_plot_return_object(result) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = s.resample('15min', how='sum').plot() tm.assert_is_valid_plot_return_object(result) def test_getitem(self): r = self.frame.resample('H') tm.assert_index_equal(r._selected_obj.columns, self.frame.columns) r = self.frame.resample('H')['B'] assert r._selected_obj.name == self.frame.columns[1] # technically this is allowed r = self.frame.resample('H')['A', 'B'] tm.assert_index_equal(r._selected_obj.columns, self.frame.columns[[0, 1]]) r = self.frame.resample('H')['A', 'B'] tm.assert_index_equal(r._selected_obj.columns, self.frame.columns[[0, 1]]) def test_select_bad_cols(self): g = self.frame.resample('H') pytest.raises(KeyError, g.__getitem__, ['D']) pytest.raises(KeyError, g.__getitem__, ['A', 'D']) with tm.assert_raises_regex(KeyError, '^[^A]+$'): # A should not be referenced as a bad column... # will have to rethink regex if you change message! g[['A', 'D']] def test_attribute_access(self): r = self.frame.resample('H') tm.assert_series_equal(r.A.sum(), r['A'].sum()) # getting pytest.raises(AttributeError, lambda: r.F) # setting def f(): r.F = 'bah' pytest.raises(ValueError, f) def test_api_compat_before_use(self): # make sure that we are setting the binner # on these attributes for attr in ['groups', 'ngroups', 'indices']: rng = pd.date_range('1/1/2012', periods=100, freq='S') ts = pd.Series(np.arange(len(rng)), index=rng) rs = ts.resample('30s') # before use getattr(rs, attr) # after grouper is initialized is ok rs.mean() getattr(rs, attr) def tests_skip_nuisance(self): df = self.frame df['D'] = 'foo' r = df.resample('H') result = r[['A', 'B']].sum() expected = pd.concat([r.A.sum(), r.B.sum()], axis=1) assert_frame_equal(result, expected) expected = r[['A', 'B', 'C']].sum() result = r.sum() assert_frame_equal(result, expected) def test_downsample_but_actually_upsampling(self): # this is reindex / asfreq rng = pd.date_range('1/1/2012', periods=100, freq='S') ts = pd.Series(np.arange(len(rng), dtype='int64'), index=rng) result = ts.resample('20s').asfreq() expected = Series([0, 20, 40, 60, 80], index=pd.date_range('2012-01-01 00:00:00', freq='20s', periods=5)) assert_series_equal(result, expected) def test_combined_up_downsampling_of_irregular(self): # since we are reallydoing an operation like this # ts2.resample('2s').mean().ffill() # preserve these semantics rng = pd.date_range('1/1/2012', periods=100, freq='S') ts = pd.Series(np.arange(len(rng)), index=rng) ts2 = ts.iloc[[0, 1, 2, 3, 5, 7, 11, 15, 16, 25, 30]] with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = ts2.resample('2s', how='mean', fill_method='ffill') expected = ts2.resample('2s').mean().ffill() assert_series_equal(result, expected) def test_transform(self): r = self.series.resample('20min') expected = self.series.groupby( pd.Grouper(freq='20min')).transform('mean') result = r.transform('mean') assert_series_equal(result, expected) def test_fillna(self): # need to upsample here rng = pd.date_range('1/1/2012', periods=10, freq='2S') ts = pd.Series(np.arange(len(rng), dtype='int64'), index=rng) r = ts.resample('s') expected = r.ffill() result = r.fillna(method='ffill') assert_series_equal(result, expected) expected = r.bfill() result = r.fillna(method='bfill') assert_series_equal(result, expected) with pytest.raises(ValueError): r.fillna(0) def test_apply_without_aggregation(self): # both resample and groupby should work w/o aggregation r = self.series.resample('20min') g = self.series.groupby(pd.Grouper(freq='20min')) for t in [g, r]: result = t.apply(lambda x: x) assert_series_equal(result, self.series) def test_agg_consistency(self): # make sure that we are consistent across # similar aggregations with and w/o selection list df = DataFrame(np.random.randn(1000, 3), index=pd.date_range('1/1/2012', freq='S', periods=1000), columns=['A', 'B', 'C']) r = df.resample('3T') with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): expected = r[['A', 'B', 'C']].agg({'r1': 'mean', 'r2': 'sum'}) result = r.agg({'r1': 'mean', 'r2': 'sum'}) assert_frame_equal(result, expected) # TODO: once GH 14008 is fixed, move these tests into # `Base` test class def test_agg(self): # test with all three Resampler apis and TimeGrouper np.random.seed(1234) index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') index.name = 'date' df = pd.DataFrame(np.random.rand(10, 2), columns=list('AB'), index=index) df_col = df.reset_index() df_mult = df_col.copy() df_mult.index = pd.MultiIndex.from_arrays([range(10), df.index], names=['index', 'date']) r = df.resample('2D') cases = [ r, df_col.resample('2D', on='date'), df_mult.resample('2D', level='date'), df.groupby(pd.Grouper(freq='2D')) ] a_mean = r['A'].mean() a_std = r['A'].std() a_sum = r['A'].sum() b_mean = r['B'].mean() b_std = r['B'].std() b_sum = r['B'].sum() expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1) expected.columns = pd.MultiIndex.from_product([['A', 'B'], ['mean', 'std']]) for t in cases: result = t.aggregate([np.mean, np.std]) assert_frame_equal(result, expected) expected = pd.concat([a_mean, b_std], axis=1) for t in cases: result = t.aggregate({'A': np.mean, 'B': np.std}) assert_frame_equal(result, expected, check_like=True) expected = pd.concat([a_mean, a_std], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), ('A', 'std')]) for t in cases: result = t.aggregate({'A': ['mean', 'std']}) assert_frame_equal(result, expected) expected = pd.concat([a_mean, a_sum], axis=1) expected.columns = ['mean', 'sum'] for t in cases: result = t['A'].aggregate(['mean', 'sum']) assert_frame_equal(result, expected) expected = pd.concat([a_mean, a_sum], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), ('A', 'sum')]) for t in cases: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t.aggregate({'A': {'mean': 'mean', 'sum': 'sum'}}) assert_frame_equal(result, expected, check_like=True) expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), ('A', 'sum'), ('B', 'mean2'), ('B', 'sum2')]) for t in cases: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t.aggregate({'A': {'mean': 'mean', 'sum': 'sum'}, 'B': {'mean2': 'mean', 'sum2': 'sum'}}) assert_frame_equal(result, expected, check_like=True) expected = pd.concat([a_mean, a_std, b_mean, b_std], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'mean'), ('A', 'std'), ('B', 'mean'), ('B', 'std')]) for t in cases: result = t.aggregate({'A': ['mean', 'std'], 'B': ['mean', 'std']}) assert_frame_equal(result, expected, check_like=True) expected = pd.concat([a_mean, a_sum, b_mean, b_sum], axis=1) expected.columns = pd.MultiIndex.from_tuples([('r1', 'A', 'mean'), ('r1', 'A', 'sum'), ('r2', 'B', 'mean'), ('r2', 'B', 'sum')]) def test_agg_misc(self): # test with all three Resampler apis and TimeGrouper np.random.seed(1234) index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') index.name = 'date' df = pd.DataFrame(np.random.rand(10, 2), columns=list('AB'), index=index) df_col = df.reset_index() df_mult = df_col.copy() df_mult.index = pd.MultiIndex.from_arrays([range(10), df.index], names=['index', 'date']) r = df.resample('2D') cases = [ r, df_col.resample('2D', on='date'), df_mult.resample('2D', level='date'), df.groupby(pd.Grouper(freq='2D')) ] # passed lambda for t in cases: result = t.agg({'A': np.sum, 'B': lambda x: np.std(x, ddof=1)}) rcustom = t['B'].apply(lambda x: np.std(x, ddof=1)) expected = pd.concat([r['A'].sum(), rcustom], axis=1) assert_frame_equal(result, expected, check_like=True) # agg with renamers expected = pd.concat([t['A'].sum(), t['B'].sum(), t['A'].mean(), t['B'].mean()], axis=1) expected.columns = pd.MultiIndex.from_tuples([('result1', 'A'), ('result1', 'B'), ('result2', 'A'), ('result2', 'B')]) for t in cases: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t[['A', 'B']].agg(OrderedDict([('result1', np.sum), ('result2', np.mean)])) assert_frame_equal(result, expected, check_like=True) # agg with different hows expected = pd.concat([t['A'].sum(), t['A'].std(), t['B'].mean(), t['B'].std()], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'sum'), ('A', 'std'), ('B', 'mean'), ('B', 'std')]) for t in cases: result = t.agg(OrderedDict([('A', ['sum', 'std']), ('B', ['mean', 'std'])])) assert_frame_equal(result, expected, check_like=True) # equivalent of using a selection list / or not for t in cases: result = t[['A', 'B']].agg({'A': ['sum', 'std'], 'B': ['mean', 'std']}) assert_frame_equal(result, expected, check_like=True) # series like aggs for t in cases: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t['A'].agg({'A': ['sum', 'std']}) expected = pd.concat([t['A'].sum(), t['A'].std()], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'sum'), ('A', 'std')]) assert_frame_equal(result, expected, check_like=True) expected = pd.concat([t['A'].agg(['sum', 'std']), t['A'].agg(['mean', 'std'])], axis=1) expected.columns = pd.MultiIndex.from_tuples([('A', 'sum'), ('A', 'std'), ('B', 'mean'), ('B', 'std')]) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t['A'].agg({'A': ['sum', 'std'], 'B': ['mean', 'std']}) assert_frame_equal(result, expected, check_like=True) # errors # invalid names in the agg specification for t in cases: def f(): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): t[['A']].agg({'A': ['sum', 'std'], 'B': ['mean', 'std']}) pytest.raises(SpecificationError, f) def test_agg_nested_dicts(self): np.random.seed(1234) index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') index.name = 'date' df = pd.DataFrame(np.random.rand(10, 2), columns=list('AB'), index=index) df_col = df.reset_index() df_mult = df_col.copy() df_mult.index = pd.MultiIndex.from_arrays([range(10), df.index], names=['index', 'date']) r = df.resample('2D') cases = [ r, df_col.resample('2D', on='date'), df_mult.resample('2D', level='date'), df.groupby(pd.Grouper(freq='2D')) ] for t in cases: def f(): t.aggregate({'r1': {'A': ['mean', 'sum']}, 'r2': {'B': ['mean', 'sum']}}) pytest.raises(ValueError, f) for t in cases: expected = pd.concat([t['A'].mean(), t['A'].std(), t['B'].mean(), t['B'].std()], axis=1) expected.columns = pd.MultiIndex.from_tuples([('ra', 'mean'), ( 'ra', 'std'), ('rb', 'mean'), ('rb', 'std')]) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t[['A', 'B']].agg({'A': {'ra': ['mean', 'std']}, 'B': {'rb': ['mean', 'std']}}) assert_frame_equal(result, expected, check_like=True) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = t.agg({'A': {'ra': ['mean', 'std']}, 'B': {'rb': ['mean', 'std']}}) assert_frame_equal(result, expected, check_like=True) def test_selection_api_validation(self): # GH 13500 index = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') df = pd.DataFrame({'date': index, 'a': np.arange(len(index), dtype=np.int64)}, index=pd.MultiIndex.from_arrays([ np.arange(len(index), dtype=np.int64), index], names=['v', 'd'])) df_exp = pd.DataFrame({'a': np.arange(len(index), dtype=np.int64)}, index=index) # non DatetimeIndex with pytest.raises(TypeError): df.resample('2D', level='v') with pytest.raises(ValueError): df.resample('2D', on='date', level='d') with pytest.raises(TypeError): df.resample('2D', on=['a', 'date']) with pytest.raises(KeyError): df.resample('2D', level=['a', 'date']) # upsampling not allowed with pytest.raises(ValueError): df.resample('2D', level='d').asfreq() with pytest.raises(ValueError): df.resample('2D', on='date').asfreq() exp = df_exp.resample('2D').sum() exp.index.name = 'date' assert_frame_equal(exp, df.resample('2D', on='date').sum()) exp.index.name = 'd' assert_frame_equal(exp, df.resample('2D', level='d').sum()) class Base(object): """ base class for resampling testing, calling .create_series() generates a series of each index type """ def create_index(self, *args, **kwargs): """ return the _index_factory created using the args, kwargs """ factory = self._index_factory() return factory(*args, **kwargs) @pytest.fixture def _index_start(self): return datetime(2005, 1, 1) @pytest.fixture def _index_end(self): return datetime(2005, 1, 10) @pytest.fixture def _index_freq(self): return 'D' @pytest.fixture def index(self, _index_start, _index_end, _index_freq): return self.create_index(_index_start, _index_end, freq=_index_freq) @pytest.fixture def _series_name(self): raise AbstractMethodError(self) @pytest.fixture def _static_values(self, index): return np.arange(len(index)) @pytest.fixture def series(self, index, _series_name, _static_values): return Series(_static_values, index=index, name=_series_name) @pytest.fixture def frame(self, index, _static_values): return DataFrame({'value': _static_values}, index=index) @pytest.fixture(params=[Series, DataFrame]) def series_and_frame(self, request, index, _series_name, _static_values): if request.param == Series: return Series(_static_values, index=index, name=_series_name) if request.param == DataFrame: return DataFrame({'value': _static_values}, index=index) @pytest.mark.parametrize('freq', ['2D', '1H']) def test_asfreq(self, series_and_frame, freq): obj = series_and_frame result = obj.resample(freq).asfreq() if freq == '2D': new_index = obj.index.take(np.arange(0, len(obj.index), 2)) new_index.freq = to_offset('2D') else: new_index = self.create_index(obj.index[0], obj.index[-1], freq=freq) expected = obj.reindex(new_index) assert_almost_equal(result, expected) def test_asfreq_fill_value(self): # test for fill value during resampling, issue 3715 s = self.create_series() result = s.resample('1H').asfreq() new_index = self.create_index(s.index[0], s.index[-1], freq='1H') expected = s.reindex(new_index) assert_series_equal(result, expected) frame = s.to_frame('value') frame.iloc[1] = None result = frame.resample('1H').asfreq(fill_value=4.0) new_index = self.create_index(frame.index[0], frame.index[-1], freq='1H') expected = frame.reindex(new_index, fill_value=4.0) assert_frame_equal(result, expected) def test_resample_interpolate(self): # # 12925 df = self.create_series().to_frame('value') assert_frame_equal( df.resample('1T').asfreq().interpolate(), df.resample('1T').interpolate()) def test_raises_on_non_datetimelike_index(self): # this is a non datetimelike index xp = DataFrame() pytest.raises(TypeError, lambda: xp.resample('A').mean()) def test_resample_empty_series(self): # GH12771 & GH12868 s = self.create_series()[:0] for freq in ['M', 'D', 'H']: # need to test for ohlc from GH13083 methods = [method for method in resample_methods if method != 'ohlc'] for method in methods: result = getattr(s.resample(freq), method)() expected = s.copy() expected.index = s.index._shallow_copy(freq=freq) assert_index_equal(result.index, expected.index) assert result.index.freq == expected.index.freq assert_series_equal(result, expected, check_dtype=False) def test_resample_empty_dataframe(self): # GH13212 index = self.create_series().index[:0] f = DataFrame(index=index) for freq in ['M', 'D', 'H']: # count retains dimensions too methods = downsample_methods + upsample_methods for method in methods: result = getattr(f.resample(freq), method)() if method != 'size': expected = f.copy() else: # GH14962 expected = Series([]) expected.index = f.index._shallow_copy(freq=freq) assert_index_equal(result.index, expected.index) assert result.index.freq == expected.index.freq assert_almost_equal(result, expected, check_dtype=False) # test size for GH13212 (currently stays as df) def test_resample_empty_dtypes(self): # Empty series were sometimes causing a segfault (for the functions # with Cython bounds-checking disabled) or an IndexError. We just run # them to ensure they no longer do. (GH #10228) for index in tm.all_timeseries_index_generator(0): for dtype in (np.float, np.int, np.object, 'datetime64[ns]'): for how in downsample_methods + upsample_methods: empty_series = pd.Series([], index, dtype) try: getattr(empty_series.resample('d'), how)() except DataError: # Ignore these since some combinations are invalid # (ex: doing mean with dtype of np.object) pass def test_resample_loffset_arg_type(self): # GH 13218, 15002 df = self.create_series().to_frame('value') expected_means = [df.values[i:i + 2].mean() for i in range(0, len(df.values), 2)] expected_index = self.create_index(df.index[0], periods=len(df.index) / 2, freq='2D') # loffset coerces PeriodIndex to DateTimeIndex if isinstance(expected_index, PeriodIndex): expected_index = expected_index.to_timestamp() expected_index += timedelta(hours=2) expected = DataFrame({'value': expected_means}, index=expected_index) for arg in ['mean', {'value': 'mean'}, ['mean']]: result_agg = df.resample('2D', loffset='2H').agg(arg) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result_how = df.resample('2D', how=arg, loffset='2H') if isinstance(arg, list): expected.columns = pd.MultiIndex.from_tuples([('value', 'mean')]) # GH 13022, 7687 - TODO: fix resample w/ TimedeltaIndex if isinstance(expected.index, TimedeltaIndex): with pytest.raises(AssertionError): assert_frame_equal(result_agg, expected) assert_frame_equal(result_how, expected) else: assert_frame_equal(result_agg, expected) assert_frame_equal(result_how, expected) def test_apply_to_empty_series(self): # GH 14313 series = self.create_series()[:0] for freq in ['M', 'D', 'H']: result = series.resample(freq).apply(lambda x: 1) expected = series.resample(freq).apply(np.sum) assert_series_equal(result, expected, check_dtype=False) class TestDatetimeIndex(Base): _index_factory = lambda x: date_range @pytest.fixture def _series_name(self): return 'dti' def setup_method(self, method): dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='Min') self.series = Series(np.random.rand(len(dti)), dti) def create_series(self): i = date_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') return Series(np.arange(len(i)), index=i, name='dti') def test_custom_grouper(self): dti = DatetimeIndex(freq='Min', start=datetime(2005, 1, 1), end=datetime(2005, 1, 10)) s = Series(np.array([1] * len(dti)), index=dti, dtype='int64') b = TimeGrouper(Minute(5)) g = s.groupby(b) # check all cython functions work funcs = ['add', 'mean', 'prod', 'ohlc', 'min', 'max', 'var'] for f in funcs: g._cython_agg_general(f) b = TimeGrouper(Minute(5), closed='right', label='right') g = s.groupby(b) # check all cython functions work funcs = ['add', 'mean', 'prod', 'ohlc', 'min', 'max', 'var'] for f in funcs: g._cython_agg_general(f) assert g.ngroups == 2593 assert notna(g.mean()).all() # construct expected val arr = [1] + [5] * 2592 idx = dti[0:-1:5] idx = idx.append(dti[-1:]) expect = Series(arr, index=idx) # GH2763 - return in put dtype if we can result = g.agg(np.sum) assert_series_equal(result, expect) df = DataFrame(np.random.rand(len(dti), 10), index=dti, dtype='float64') r = df.groupby(b).agg(np.sum) assert len(r.columns) == 10 assert len(r.index) == 2593 def test_resample_basic(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 00:13:00', freq='min', name='index') s = Series(np.random.randn(14), index=rng) result = s.resample('5min', closed='right', label='right').mean() exp_idx = date_range('1/1/2000', periods=4, freq='5min', name='index') expected = Series([s[0], s[1:6].mean(), s[6:11].mean(), s[11:].mean()], index=exp_idx) assert_series_equal(result, expected) assert result.index.name == 'index' result = s.resample('5min', closed='left', label='right').mean() exp_idx = date_range('1/1/2000 00:05', periods=3, freq='5min', name='index') expected = Series([s[:5].mean(), s[5:10].mean(), s[10:].mean()], index=exp_idx) assert_series_equal(result, expected) s = self.series result = s.resample('5Min').last() grouper = TimeGrouper(Minute(5), closed='left', label='left') expect = s.groupby(grouper).agg(lambda x: x[-1]) assert_series_equal(result, expect) def test_resample_how(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 00:13:00', freq='min', name='index') s = Series(np.random.randn(14), index=rng) grouplist = np.ones_like(s) grouplist[0] = 0 grouplist[1:6] = 1 grouplist[6:11] = 2 grouplist[11:] = 3 args = downsample_methods def _ohlc(group): if isna(group).all(): return np.repeat(np.nan, 4) return [group[0], group.max(), group.min(), group[-1]] inds = date_range('1/1/2000', periods=4, freq='5min', name='index') for arg in args: if arg == 'ohlc': func = _ohlc else: func = arg try: result = getattr(s.resample( '5min', closed='right', label='right'), arg)() expected = s.groupby(grouplist).agg(func) assert result.index.name == 'index' if arg == 'ohlc': expected = DataFrame(expected.values.tolist()) expected.columns = ['open', 'high', 'low', 'close'] expected.index = Index(inds, name='index') assert_frame_equal(result, expected) else: expected.index = inds assert_series_equal(result, expected) except BaseException as exc: exc.args += ('how=%s' % arg,) raise def test_numpy_compat(self): # see gh-12811 s = Series([1, 2, 3, 4, 5], index=date_range( '20130101', periods=5, freq='s')) r = s.resample('2s') msg = "numpy operations are not valid with resample" for func in ('min', 'max', 'sum', 'prod', 'mean', 'var', 'std'): tm.assert_raises_regex(UnsupportedFunctionCall, msg, getattr(r, func), func, 1, 2, 3) tm.assert_raises_regex(UnsupportedFunctionCall, msg, getattr(r, func), axis=1) def test_resample_how_callables(self): # GH 7929 data = np.arange(5, dtype=np.int64) ind = pd.DatetimeIndex(start='2014-01-01', periods=len(data), freq='d') df = pd.DataFrame({"A": data, "B": data}, index=ind) def fn(x, a=1): return str(type(x)) class fn_class: def __call__(self, x): return str(type(x)) df_standard = df.resample("M").apply(fn) df_lambda = df.resample("M").apply(lambda x: str(type(x))) df_partial = df.resample("M").apply(partial(fn)) df_partial2 = df.resample("M").apply(partial(fn, a=2)) df_class = df.resample("M").apply(fn_class()) assert_frame_equal(df_standard, df_lambda) assert_frame_equal(df_standard, df_partial) assert_frame_equal(df_standard, df_partial2) assert_frame_equal(df_standard, df_class) def test_resample_with_timedeltas(self): expected = DataFrame({'A': np.arange(1480)}) expected = expected.groupby(expected.index // 30).sum() expected.index = pd.timedelta_range('0 days', freq='30T', periods=50) df = DataFrame({'A': np.arange(1480)}, index=pd.to_timedelta( np.arange(1480), unit='T')) result = df.resample('30T').sum() assert_frame_equal(result, expected) s = df['A'] result = s.resample('30T').sum() assert_series_equal(result, expected['A']) def test_resample_single_period_timedelta(self): s = Series(list(range(5)), index=pd.timedelta_range( '1 day', freq='s', periods=5)) result = s.resample('2s').sum() expected = Series([1, 5, 4], index=pd.timedelta_range( '1 day', freq='2s', periods=3)) assert_series_equal(result, expected) def test_resample_timedelta_idempotency(self): # GH 12072 index = pd.timedelta_range('0', periods=9, freq='10L') series = pd.Series(range(9), index=index) result = series.resample('10L').mean() expected = series assert_series_equal(result, expected) def test_resample_rounding(self): # GH 8371 # odd results when rounding is needed data = """date,time,value 11-08-2014,00:00:01.093,1 11-08-2014,00:00:02.159,1 11-08-2014,00:00:02.667,1 11-08-2014,00:00:03.175,1 11-08-2014,00:00:07.058,1 11-08-2014,00:00:07.362,1 11-08-2014,00:00:08.324,1 11-08-2014,00:00:08.830,1 11-08-2014,00:00:08.982,1 11-08-2014,00:00:09.815,1 11-08-2014,00:00:10.540,1 11-08-2014,00:00:11.061,1 11-08-2014,00:00:11.617,1 11-08-2014,00:00:13.607,1 11-08-2014,00:00:14.535,1 11-08-2014,00:00:15.525,1 11-08-2014,00:00:17.960,1 11-08-2014,00:00:20.674,1 11-08-2014,00:00:21.191,1""" from pandas.compat import StringIO df = pd.read_csv(StringIO(data), parse_dates={'timestamp': [ 'date', 'time']}, index_col='timestamp') df.index.name = None result = df.resample('6s').sum() expected = DataFrame({'value': [ 4, 9, 4, 2 ]}, index=date_range('2014-11-08', freq='6s', periods=4)) assert_frame_equal(result, expected) result = df.resample('7s').sum() expected = DataFrame({'value': [ 4, 10, 4, 1 ]}, index=date_range('2014-11-08', freq='7s', periods=4)) assert_frame_equal(result, expected) result = df.resample('11s').sum() expected = DataFrame({'value': [ 11, 8 ]}, index=date_range('2014-11-08', freq='11s', periods=2)) assert_frame_equal(result, expected) result = df.resample('13s').sum() expected = DataFrame({'value': [ 13, 6 ]}, index=date_range('2014-11-08', freq='13s', periods=2)) assert_frame_equal(result, expected) result = df.resample('17s').sum() expected = DataFrame({'value': [ 16, 3 ]}, index=date_range('2014-11-08', freq='17s', periods=2)) assert_frame_equal(result, expected) def test_resample_basic_from_daily(self): # from daily dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='D', name='index') s = Series(np.random.rand(len(dti)), dti) # to weekly result = s.resample('w-sun').last() assert len(result) == 3 assert (result.index.dayofweek == [6, 6, 6]).all() assert result.iloc[0] == s['1/2/2005'] assert result.iloc[1] == s['1/9/2005'] assert result.iloc[2] == s.iloc[-1] result = s.resample('W-MON').last() assert len(result) == 2 assert (result.index.dayofweek == [0, 0]).all() assert result.iloc[0] == s['1/3/2005'] assert result.iloc[1] == s['1/10/2005'] result = s.resample('W-TUE').last() assert len(result) == 2 assert (result.index.dayofweek == [1, 1]).all() assert result.iloc[0] == s['1/4/2005'] assert result.iloc[1] == s['1/10/2005'] result = s.resample('W-WED').last() assert len(result) == 2 assert (result.index.dayofweek == [2, 2]).all() assert result.iloc[0] == s['1/5/2005'] assert result.iloc[1] == s['1/10/2005'] result = s.resample('W-THU').last() assert len(result) == 2 assert (result.index.dayofweek == [3, 3]).all() assert result.iloc[0] == s['1/6/2005'] assert result.iloc[1] == s['1/10/2005'] result = s.resample('W-FRI').last() assert len(result) == 2 assert (result.index.dayofweek == [4, 4]).all() assert result.iloc[0] == s['1/7/2005'] assert result.iloc[1] == s['1/10/2005'] # to biz day result = s.resample('B').last() assert len(result) == 7 assert (result.index.dayofweek == [4, 0, 1, 2, 3, 4, 0]).all() assert result.iloc[0] == s['1/2/2005'] assert result.iloc[1] == s['1/3/2005'] assert result.iloc[5] == s['1/9/2005'] assert result.index.name == 'index' def test_resample_upsampling_picked_but_not_correct(self): # Test for issue #3020 dates = date_range('01-Jan-2014', '05-Jan-2014', freq='D') series = Series(1, index=dates) result = series.resample('D').mean() assert result.index[0] == dates[0] # GH 5955 # incorrect deciding to upsample when the axis frequency matches the # resample frequency import datetime s = Series(np.arange(1., 6), index=[datetime.datetime( 1975, 1, i, 12, 0) for i in range(1, 6)]) expected = Series(np.arange(1., 6), index=date_range( '19750101', periods=5, freq='D')) result = s.resample('D').count() assert_series_equal(result, Series(1, index=expected.index)) result1 = s.resample('D').sum() result2 = s.resample('D').mean() assert_series_equal(result1, expected) assert_series_equal(result2, expected) def test_resample_frame_basic(self): df = tm.makeTimeDataFrame() b = TimeGrouper('M') g = df.groupby(b) # check all cython functions work funcs = ['add', 'mean', 'prod', 'min', 'max', 'var'] for f in funcs: g._cython_agg_general(f) result = df.resample('A').mean() assert_series_equal(result['A'], df['A'].resample('A').mean()) result = df.resample('M').mean() assert_series_equal(result['A'], df['A'].resample('M').mean()) df.resample('M', kind='period').mean() df.resample('W-WED', kind='period').mean() def test_resample_loffset(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 00:13:00', freq='min') s = Series(np.random.randn(14), index=rng) result = s.resample('5min', closed='right', label='right', loffset=timedelta(minutes=1)).mean() idx = date_range('1/1/2000', periods=4, freq='5min') expected = Series([s[0], s[1:6].mean(), s[6:11].mean(), s[11:].mean()], index=idx + timedelta(minutes=1)) assert_series_equal(result, expected) expected = s.resample( '5min', closed='right', label='right', loffset='1min').mean() assert_series_equal(result, expected) expected = s.resample( '5min', closed='right', label='right', loffset=Minute(1)).mean() assert_series_equal(result, expected) assert result.index.freq == Minute(5) # from daily dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='D') ser = Series(np.random.rand(len(dti)), dti) # to weekly result = ser.resample('w-sun').last() expected = ser.resample('w-sun', loffset=-bday).last() assert result.index[0] - bday == expected.index[0] def test_resample_loffset_count(self): # GH 12725 start_time = '1/1/2000 00:00:00' rng = date_range(start_time, periods=100, freq='S') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.resample('10S', loffset='1s').count() expected_index = ( date_range(start_time, periods=10, freq='10S') + timedelta(seconds=1) ) expected = pd.Series(10, index=expected_index) assert_series_equal(result, expected) # Same issue should apply to .size() since it goes through # same code path result = ts.resample('10S', loffset='1s').size() assert_series_equal(result, expected) def test_resample_upsample(self): # from daily dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='D', name='index') s = Series(np.random.rand(len(dti)), dti) # to minutely, by padding result = s.resample('Min').pad() assert len(result) == 12961 assert result[0] == s[0] assert result[-1] == s[-1] assert result.index.name == 'index' def test_resample_how_method(self): # GH9915 s = pd.Series([11, 22], index=[Timestamp('2015-03-31 21:48:52.672000'), Timestamp('2015-03-31 21:49:52.739000')]) expected = pd.Series([11, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, 22], index=[Timestamp('2015-03-31 21:48:50'), Timestamp('2015-03-31 21:49:00'), Timestamp('2015-03-31 21:49:10'), Timestamp('2015-03-31 21:49:20'), Timestamp('2015-03-31 21:49:30'), Timestamp('2015-03-31 21:49:40'), Timestamp('2015-03-31 21:49:50')]) assert_series_equal(s.resample("10S").mean(), expected) def test_resample_extra_index_point(self): # GH 9756 index = DatetimeIndex(start='20150101', end='20150331', freq='BM') expected = DataFrame({'A': Series([21, 41, 63], index=index)}) index = DatetimeIndex(start='20150101', end='20150331', freq='B') df = DataFrame( {'A': Series(range(len(index)), index=index)}, dtype='int64') result = df.resample('BM').last() assert_frame_equal(result, expected) def test_upsample_with_limit(self): rng = date_range('1/1/2000', periods=3, freq='5t') ts = Series(np.random.randn(len(rng)), rng) result = ts.resample('t').ffill(limit=2) expected = ts.reindex(result.index, method='ffill', limit=2) assert_series_equal(result, expected) def test_nearest_upsample_with_limit(self): rng = date_range('1/1/2000', periods=3, freq='5t') ts = Series(np.random.randn(len(rng)), rng) result = ts.resample('t').nearest(limit=2) expected = ts.reindex(result.index, method='nearest', limit=2) assert_series_equal(result, expected) def test_resample_ohlc(self): s = self.series grouper = TimeGrouper(Minute(5)) expect = s.groupby(grouper).agg(lambda x: x[-1]) result = s.resample('5Min').ohlc() assert len(result) == len(expect) assert len(result.columns) == 4 xs = result.iloc[-2] assert xs['open'] == s[-6] assert xs['high'] == s[-6:-1].max() assert xs['low'] == s[-6:-1].min() assert xs['close'] == s[-2] xs = result.iloc[0] assert xs['open'] == s[0] assert xs['high'] == s[:5].max() assert xs['low'] == s[:5].min() assert xs['close'] == s[4] def test_resample_ohlc_result(self): # GH 12332 index = pd.date_range('1-1-2000', '2-15-2000', freq='h') index = index.union(pd.date_range('4-15-2000', '5-15-2000', freq='h')) s = Series(range(len(index)), index=index) a = s.loc[:'4-15-2000'].resample('30T').ohlc() assert isinstance(a, DataFrame) b = s.loc[:'4-14-2000'].resample('30T').ohlc() assert isinstance(b, DataFrame) # GH12348 # raising on odd period rng = date_range('2013-12-30', '2014-01-07') index = rng.drop([Timestamp('2014-01-01'), Timestamp('2013-12-31'), Timestamp('2014-01-04'), Timestamp('2014-01-05')]) df = DataFrame(data=np.arange(len(index)), index=index) result = df.resample('B').mean() expected = df.reindex(index=date_range(rng[0], rng[-1], freq='B')) assert_frame_equal(result, expected) def test_resample_ohlc_dataframe(self): df = ( pd.DataFrame({ 'PRICE': { Timestamp('2011-01-06 10:59:05', tz=None): 24990, Timestamp('2011-01-06 12:43:33', tz=None): 25499, Timestamp('2011-01-06 12:54:09', tz=None): 25499}, 'VOLUME': { Timestamp('2011-01-06 10:59:05', tz=None): 1500000000, Timestamp('2011-01-06 12:43:33', tz=None): 5000000000, Timestamp('2011-01-06 12:54:09', tz=None): 100000000}}) ).reindex(['VOLUME', 'PRICE'], axis=1) res = df.resample('H').ohlc() exp = pd.concat([df['VOLUME'].resample('H').ohlc(), df['PRICE'].resample('H').ohlc()], axis=1, keys=['VOLUME', 'PRICE']) assert_frame_equal(exp, res) df.columns = [['a', 'b'], ['c', 'd']] res = df.resample('H').ohlc() exp.columns = pd.MultiIndex.from_tuples([ ('a', 'c', 'open'), ('a', 'c', 'high'), ('a', 'c', 'low'), ('a', 'c', 'close'), ('b', 'd', 'open'), ('b', 'd', 'high'), ('b', 'd', 'low'), ('b', 'd', 'close')]) assert_frame_equal(exp, res) # dupe columns fail atm # df.columns = ['PRICE', 'PRICE'] def test_resample_dup_index(self): # GH 4812 # dup columns with resample raising df = DataFrame(np.random.randn(4, 12), index=[2000, 2000, 2000, 2000], columns=[Period(year=2000, month=i + 1, freq='M') for i in range(12)]) df.iloc[3, :] = np.nan result = df.resample('Q', axis=1).mean() expected = df.groupby(lambda x: int((x.month - 1) / 3), axis=1).mean() expected.columns = [ Period(year=2000, quarter=i + 1, freq='Q') for i in range(4)] assert_frame_equal(result, expected) def test_resample_reresample(self): dti = DatetimeIndex(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq='D') s = Series(np.random.rand(len(dti)), dti) bs = s.resample('B', closed='right', label='right').mean() result = bs.resample('8H').mean() assert len(result) == 22 assert isinstance(result.index.freq, offsets.DateOffset) assert result.index.freq == offsets.Hour(8) def test_resample_timestamp_to_period(self): ts = _simple_ts('1/1/1990', '1/1/2000') result = ts.resample('A-DEC', kind='period').mean() expected = ts.resample('A-DEC').mean() expected.index = period_range('1990', '2000', freq='a-dec') assert_series_equal(result, expected) result = ts.resample('A-JUN', kind='period').mean() expected = ts.resample('A-JUN').mean() expected.index = period_range('1990', '2000', freq='a-jun') assert_series_equal(result, expected) result = ts.resample('M', kind='period').mean() expected = ts.resample('M').mean() expected.index = period_range('1990-01', '2000-01', freq='M') assert_series_equal(result, expected) result = ts.resample('M', kind='period').mean() expected = ts.resample('M').mean() expected.index = period_range('1990-01', '2000-01', freq='M') assert_series_equal(result, expected) def test_ohlc_5min(self): def _ohlc(group): if isna(group).all(): return np.repeat(np.nan, 4) return [group[0], group.max(), group.min(), group[-1]] rng = date_range('1/1/2000 00:00:00', '1/1/2000 5:59:50', freq='10s') ts = Series(np.random.randn(len(rng)), index=rng) resampled = ts.resample('5min', closed='right', label='right').ohlc() assert (resampled.loc['1/1/2000 00:00'] == ts[0]).all() exp = _ohlc(ts[1:31]) assert (resampled.loc['1/1/2000 00:05'] == exp).all() exp = _ohlc(ts['1/1/2000 5:55:01':]) assert (resampled.loc['1/1/2000 6:00:00'] == exp).all() def test_downsample_non_unique(self): rng = date_range('1/1/2000', '2/29/2000') rng2 = rng.repeat(5).values ts = Series(np.random.randn(len(rng2)), index=rng2) result = ts.resample('M').mean() expected = ts.groupby(lambda x: x.month).mean() assert len(result) == 2 assert_almost_equal(result[0], expected[1]) assert_almost_equal(result[1], expected[2]) def test_asfreq_non_unique(self): # GH #1077 rng = date_range('1/1/2000', '2/29/2000') rng2 = rng.repeat(2).values ts = Series(np.random.randn(len(rng2)), index=rng2) pytest.raises(Exception, ts.asfreq, 'B') def test_resample_axis1(self): rng = date_range('1/1/2000', '2/29/2000') df = DataFrame(np.random.randn(3, len(rng)), columns=rng, index=['a', 'b', 'c']) result = df.resample('M', axis=1).mean() expected = df.T.resample('M').mean().T tm.assert_frame_equal(result, expected) def test_resample_panel(self): rng = date_range('1/1/2000', '6/30/2000') n = len(rng) with catch_warnings(record=True): panel = Panel(np.random.randn(3, n, 5), items=['one', 'two', 'three'], major_axis=rng, minor_axis=['a', 'b', 'c', 'd', 'e']) result = panel.resample('M', axis=1).mean() def p_apply(panel, f): result = {} for item in panel.items: result[item] = f(panel[item]) return Panel(result, items=panel.items) expected = p_apply(panel, lambda x: x.resample('M').mean()) tm.assert_panel_equal(result, expected) panel2 = panel.swapaxes(1, 2) result = panel2.resample('M', axis=2).mean() expected = p_apply(panel2, lambda x: x.resample('M', axis=1).mean()) tm.assert_panel_equal(result, expected) def test_resample_panel_numpy(self): rng = date_range('1/1/2000', '6/30/2000') n = len(rng) with catch_warnings(record=True): panel = Panel(np.random.randn(3, n, 5), items=['one', 'two', 'three'], major_axis=rng, minor_axis=['a', 'b', 'c', 'd', 'e']) result = panel.resample('M', axis=1).apply(lambda x: x.mean(1)) expected = panel.resample('M', axis=1).mean() tm.assert_panel_equal(result, expected) panel = panel.swapaxes(1, 2) result = panel.resample('M', axis=2).apply(lambda x: x.mean(2)) expected = panel.resample('M', axis=2).mean() tm.assert_panel_equal(result, expected) def test_resample_anchored_ticks(self): # If a fixed delta (5 minute, 4 hour) evenly divides a day, we should # "anchor" the origin at midnight so we get regular intervals rather # than starting from the first timestamp which might start in the # middle of a desired interval rng = date_range('1/1/2000 04:00:00', periods=86400, freq='s') ts = Series(np.random.randn(len(rng)), index=rng) ts[:2] = np.nan # so results are the same freqs = ['t', '5t', '15t', '30t', '4h', '12h'] for freq in freqs: result = ts[2:].resample(freq, closed='left', label='left').mean() expected = ts.resample(freq, closed='left', label='left').mean() assert_series_equal(result, expected) def test_resample_single_group(self): mysum = lambda x: x.sum() rng = date_range('2000-1-1', '2000-2-10', freq='D') ts = Series(np.random.randn(len(rng)), index=rng) assert_series_equal(ts.resample('M').sum(), ts.resample('M').apply(mysum)) rng = date_range('2000-1-1', '2000-1-10', freq='D') ts = Series(np.random.randn(len(rng)), index=rng) assert_series_equal(ts.resample('M').sum(), ts.resample('M').apply(mysum)) # GH 3849 s = Series([30.1, 31.6], index=[Timestamp('20070915 15:30:00'), Timestamp('20070915 15:40:00')]) expected = Series([0.75], index=[Timestamp('20070915')]) result = s.resample('D').apply(lambda x: np.std(x)) assert_series_equal(result, expected) def test_resample_base(self): rng = date_range('1/1/2000 00:00:00', '1/1/2000 02:00', freq='s') ts = Series(np.random.randn(len(rng)), index=rng) resampled = ts.resample('5min', base=2).mean() exp_rng = date_range('12/31/1999 23:57:00', '1/1/2000 01:57', freq='5min') tm.assert_index_equal(resampled.index, exp_rng) def test_resample_base_with_timedeltaindex(self): # GH 10530 rng = timedelta_range(start='0s', periods=25, freq='s') ts = Series(np.random.randn(len(rng)), index=rng) with_base = ts.resample('2s', base=5).mean() without_base = ts.resample('2s').mean() exp_without_base = timedelta_range(start='0s', end='25s', freq='2s') exp_with_base = timedelta_range(start='5s', end='29s', freq='2s') tm.assert_index_equal(without_base.index, exp_without_base) tm.assert_index_equal(with_base.index, exp_with_base) def test_resample_categorical_data_with_timedeltaindex(self): # GH #12169 df = DataFrame({'Group_obj': 'A'}, index=pd.to_timedelta(list(range(20)), unit='s')) df['Group'] = df['Group_obj'].astype('category') result = df.resample('10s').agg(lambda x: (x.value_counts().index[0])) expected = DataFrame({'Group_obj': ['A', 'A'], 'Group': ['A', 'A']}, index=pd.to_timedelta([0, 10], unit='s')) expected = expected.reindex(['Group_obj', 'Group'], axis=1) tm.assert_frame_equal(result, expected) def test_resample_daily_anchored(self): rng = date_range('1/1/2000 0:00:00', periods=10000, freq='T') ts = Series(np.random.randn(len(rng)), index=rng) ts[:2] = np.nan # so results are the same result = ts[2:].resample('D', closed='left', label='left').mean() expected = ts.resample('D', closed='left', label='left').mean() assert_series_equal(result, expected) def test_resample_to_period_monthly_buglet(self): # GH #1259 rng = date_range('1/1/2000', '12/31/2000') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.resample('M', kind='period').mean() exp_index = period_range('Jan-2000', 'Dec-2000', freq='M') tm.assert_index_equal(result.index, exp_index) def test_period_with_agg(self): # aggregate a period resampler with a lambda s2 = pd.Series(np.random.randint(0, 5, 50), index=pd.period_range('2012-01-01', freq='H', periods=50), dtype='float64') expected = s2.to_timestamp().resample('D').mean().to_period() result = s2.resample('D').agg(lambda x: x.mean()) assert_series_equal(result, expected) def test_resample_segfault(self): # GH 8573 # segfaulting in older versions all_wins_and_wagers = [ (1, datetime(2013, 10, 1, 16, 20), 1, 0), (2, datetime(2013, 10, 1, 16, 10), 1, 0), (2, datetime(2013, 10, 1, 18, 15), 1, 0), (2, datetime(2013, 10, 1, 16, 10, 31), 1, 0)] df = pd.DataFrame.from_records(all_wins_and_wagers, columns=("ID", "timestamp", "A", "B") ).set_index("timestamp") result = df.groupby("ID").resample("5min").sum() expected = df.groupby("ID").apply(lambda x: x.resample("5min").sum()) assert_frame_equal(result, expected) def test_resample_dtype_preservation(self): # GH 12202 # validation tests for dtype preservation df = DataFrame({'date': pd.date_range(start='2016-01-01', periods=4, freq='W'), 'group': [1, 1, 2, 2], 'val': Series([5, 6, 7, 8], dtype='int32')} ).set_index('date') result = df.resample('1D').ffill() assert result.val.dtype == np.int32 result = df.groupby('group').resample('1D').ffill() assert result.val.dtype == np.int32 def test_resample_dtype_coerceion(self): pytest.importorskip('scipy.interpolate') # GH 16361 df = {"a": [1, 3, 1, 4]} df = pd.DataFrame( df, index=pd.date_range("2017-01-01", "2017-01-04")) expected = (df.astype("float64") .resample("H") .mean() ["a"] .interpolate("cubic") ) result = df.resample("H")["a"].mean().interpolate("cubic") tm.assert_series_equal(result, expected) result = df.resample("H").mean()["a"].interpolate("cubic") tm.assert_series_equal(result, expected) def test_weekly_resample_buglet(self): # #1327 rng = date_range('1/1/2000', freq='B', periods=20) ts = Series(np.random.randn(len(rng)), index=rng) resampled = ts.resample('W').mean() expected = ts.resample('W-SUN').mean() assert_series_equal(resampled, expected) def test_monthly_resample_error(self): # #1451 dates = date_range('4/16/2012 20:00', periods=5000, freq='h') ts = Series(np.random.randn(len(dates)), index=dates) # it works! ts.resample('M') def test_nanosecond_resample_error(self): # GH 12307 - Values falls after last bin when # Resampling using pd.tseries.offsets.Nano as period start = 1443707890427 exp_start = 1443707890400 indx = pd.date_range( start=pd.to_datetime(start), periods=10, freq='100n' ) ts = pd.Series(range(len(indx)), index=indx) r = ts.resample(pd.tseries.offsets.Nano(100)) result = r.agg('mean') exp_indx = pd.date_range( start=pd.to_datetime(exp_start), periods=10, freq='100n' ) exp = pd.Series(range(len(exp_indx)), index=exp_indx) assert_series_equal(result, exp) def test_resample_anchored_intraday(self): # #1471, #1458 rng = date_range('1/1/2012', '4/1/2012', freq='100min') df = DataFrame(rng.month, index=rng) result = df.resample('M').mean() expected = df.resample( 'M', kind='period').mean().to_timestamp(how='end') tm.assert_frame_equal(result, expected) result = df.resample('M', closed='left').mean() exp = df.tshift(1, freq='D').resample('M', kind='period').mean() exp = exp.to_timestamp(how='end') tm.assert_frame_equal(result, exp) rng = date_range('1/1/2012', '4/1/2012', freq='100min') df = DataFrame(rng.month, index=rng) result = df.resample('Q').mean() expected = df.resample( 'Q', kind='period').mean().to_timestamp(how='end') tm.assert_frame_equal(result, expected) result = df.resample('Q', closed='left').mean() expected = df.tshift(1, freq='D').resample('Q', kind='period', closed='left').mean() expected = expected.to_timestamp(how='end') tm.assert_frame_equal(result, expected) ts = _simple_ts('2012-04-29 23:00', '2012-04-30 5:00', freq='h') resampled = ts.resample('M').mean() assert len(resampled) == 1 def test_resample_anchored_monthstart(self): ts = _simple_ts('1/1/2000', '12/31/2002') freqs = ['MS', 'BMS', 'QS-MAR', 'AS-DEC', 'AS-JUN'] for freq in freqs: ts.resample(freq).mean() def test_resample_anchored_multiday(self): # When resampling a range spanning multiple days, ensure that the # start date gets used to determine the offset. Fixes issue where # a one day period is not a multiple of the frequency. # # See: https://github.com/pandas-dev/pandas/issues/8683 index = pd.date_range( '2014-10-14 23:06:23.206', periods=3, freq='400L' ) | pd.date_range( '2014-10-15 23:00:00', periods=2, freq='2200L') s = pd.Series(np.random.randn(5), index=index) # Ensure left closing works result = s.resample('2200L').mean() assert result.index[-1] == pd.Timestamp('2014-10-15 23:00:02.000') # Ensure right closing works result = s.resample('2200L', label='right').mean() assert result.index[-1] == pd.Timestamp('2014-10-15 23:00:04.200') def test_corner_cases(self): # miscellaneous test coverage rng = date_range('1/1/2000', periods=12, freq='t') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.resample('5t', closed='right', label='left').mean() ex_index = date_range('1999-12-31 23:55', periods=4, freq='5t') tm.assert_index_equal(result.index, ex_index) len0pts = _simple_pts('2007-01', '2010-05', freq='M')[:0] # it works result = len0pts.resample('A-DEC').mean() assert len(result) == 0 # resample to periods ts = _simple_ts('2000-04-28', '2000-04-30 11:00', freq='h') result = ts.resample('M', kind='period').mean() assert len(result) == 1 assert result.index[0] == Period('2000-04', freq='M') def test_anchored_lowercase_buglet(self): dates = date_range('4/16/2012 20:00', periods=50000, freq='s') ts = Series(np.random.randn(len(dates)), index=dates) # it works! ts.resample('d').mean() def test_upsample_apply_functions(self): # #1596 rng = pd.date_range('2012-06-12', periods=4, freq='h') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.resample('20min').aggregate(['mean', 'sum']) assert isinstance(result, DataFrame) def test_resample_not_monotonic(self): rng = pd.date_range('2012-06-12', periods=200, freq='h') ts = Series(np.random.randn(len(rng)), index=rng) ts = ts.take(np.random.permutation(len(ts))) result = ts.resample('D').sum() exp = ts.sort_index().resample('D').sum() assert_series_equal(result, exp) def test_resample_median_bug_1688(self): for dtype in ['int64', 'int32', 'float64', 'float32']: df = DataFrame([1, 2], index=[datetime(2012, 1, 1, 0, 0, 0), datetime(2012, 1, 1, 0, 5, 0)], dtype=dtype) result = df.resample("T").apply(lambda x: x.mean()) exp = df.asfreq('T') tm.assert_frame_equal(result, exp) result = df.resample("T").median() exp = df.asfreq('T') tm.assert_frame_equal(result, exp) def test_how_lambda_functions(self): ts = _simple_ts('1/1/2000', '4/1/2000') result = ts.resample('M').apply(lambda x: x.mean()) exp = ts.resample('M').mean() tm.assert_series_equal(result, exp) foo_exp = ts.resample('M').mean() foo_exp.name = 'foo' bar_exp = ts.resample('M').std() bar_exp.name = 'bar' result = ts.resample('M').apply( [lambda x: x.mean(), lambda x: x.std(ddof=1)]) result.columns = ['foo', 'bar'] tm.assert_series_equal(result['foo'], foo_exp) tm.assert_series_equal(result['bar'], bar_exp) # this is a MI Series, so comparing the names of the results # doesn't make sense result = ts.resample('M').aggregate({'foo': lambda x: x.mean(), 'bar': lambda x: x.std(ddof=1)}) tm.assert_series_equal(result['foo'], foo_exp, check_names=False) tm.assert_series_equal(result['bar'], bar_exp, check_names=False) def test_resample_unequal_times(self): # #1772 start = datetime(1999, 3, 1, 5) # end hour is less than start end = datetime(2012, 7, 31, 4) bad_ind = date_range(start, end, freq="30min") df = DataFrame({'close': 1}, index=bad_ind) # it works! df.resample('AS').sum() def test_resample_consistency(self): # GH 6418 # resample with bfill / limit / reindex consistency i30 = pd.date_range('2002-02-02', periods=4, freq='30T') s = pd.Series(np.arange(4.), index=i30) s[2] = np.NaN # Upsample by factor 3 with reindex() and resample() methods: i10 = pd.date_range(i30[0], i30[-1], freq='10T') s10 = s.reindex(index=i10, method='bfill') s10_2 = s.reindex(index=i10, method='bfill', limit=2) rl = s.reindex_like(s10, method='bfill', limit=2) r10_2 = s.resample('10Min').bfill(limit=2) r10 = s.resample('10Min').bfill() # s10_2, r10, r10_2, rl should all be equal assert_series_equal(s10_2, r10) assert_series_equal(s10_2, r10_2) assert_series_equal(s10_2, rl) def test_resample_timegrouper(self): # GH 7227 dates1 = [datetime(2014, 10, 1), datetime(2014, 9, 3), datetime(2014, 11, 5), datetime(2014, 9, 5), datetime(2014, 10, 8), datetime(2014, 7, 15)] dates2 = dates1[:2] + [pd.NaT] + dates1[2:4] + [pd.NaT] + dates1[4:] dates3 = [pd.NaT] + dates1 + [pd.NaT] for dates in [dates1, dates2, dates3]: df = DataFrame(dict(A=dates, B=np.arange(len(dates)))) result = df.set_index('A').resample('M').count() exp_idx = pd.DatetimeIndex(['2014-07-31', '2014-08-31', '2014-09-30', '2014-10-31', '2014-11-30'], freq='M', name='A') expected = DataFrame({'B': [1, 0, 2, 2, 1]}, index=exp_idx) assert_frame_equal(result, expected) result = df.groupby(pd.Grouper(freq='M', key='A')).count() assert_frame_equal(result, expected) df = DataFrame(dict(A=dates, B=np.arange(len(dates)), C=np.arange( len(dates)))) result = df.set_index('A').resample('M').count() expected = DataFrame({'B': [1, 0, 2, 2, 1], 'C': [1, 0, 2, 2, 1]}, index=exp_idx, columns=['B', 'C']) assert_frame_equal(result, expected) result = df.groupby(pd.Grouper(freq='M', key='A')).count() assert_frame_equal(result, expected) def test_resample_nunique(self): # GH 12352 df = DataFrame({ 'ID': {pd.Timestamp('2015-06-05 00:00:00'): '0010100903', pd.Timestamp('2015-06-08 00:00:00'): '0010150847'}, 'DATE': {pd.Timestamp('2015-06-05 00:00:00'): '2015-06-05', pd.Timestamp('2015-06-08 00:00:00'): '2015-06-08'}}) r = df.resample('D') g = df.groupby(pd.Grouper(freq='D')) expected = df.groupby(pd.Grouper(freq='D')).ID.apply(lambda x: x.nunique()) assert expected.name == 'ID' for t in [r, g]: result = r.ID.nunique() assert_series_equal(result, expected) result = df.ID.resample('D').nunique() assert_series_equal(result, expected) result = df.ID.groupby(pd.Grouper(freq='D')).nunique() assert_series_equal(result, expected) def test_resample_nunique_with_date_gap(self): # GH 13453 index = pd.date_range('1-1-2000', '2-15-2000', freq='h') index2 = pd.date_range('4-15-2000', '5-15-2000', freq='h') index3 = index.append(index2) s = pd.Series(range(len(index3)), index=index3, dtype='int64') r = s.resample('M') # Since all elements are unique, these should all be the same results = [ r.count(), r.nunique(), r.agg(pd.Series.nunique), r.agg('nunique') ] assert_series_equal(results[0], results[1]) assert_series_equal(results[0], results[2]) assert_series_equal(results[0], results[3]) def test_resample_group_info(self): # GH10914 for n, k in product((10000, 100000), (10, 100, 1000)): dr = date_range(start='2015-08-27', periods=n // 10, freq='T') ts = Series(np.random.randint(0, n // k, n).astype('int64'), index=np.random.choice(dr, n)) left = ts.resample('30T').nunique() ix = date_range(start=ts.index.min(), end=ts.index.max(), freq='30T') vals = ts.values bins = np.searchsorted(ix.values, ts.index, side='right') sorter = np.lexsort((vals, bins)) vals, bins = vals[sorter], bins[sorter] mask = np.r_[True, vals[1:] != vals[:-1]] mask |= np.r_[True, bins[1:] != bins[:-1]] arr = np.bincount(bins[mask] - 1, minlength=len(ix)).astype('int64', copy=False) right = Series(arr, index=ix) assert_series_equal(left, right) def test_resample_size(self): n = 10000 dr = date_range('2015-09-19', periods=n, freq='T') ts = Series(np.random.randn(n), index=np.random.choice(dr, n)) left = ts.resample('7T').size() ix = date_range(start=left.index.min(), end=ts.index.max(), freq='7T') bins = np.searchsorted(ix.values, ts.index.values, side='right') val = np.bincount(bins, minlength=len(ix) + 1)[1:].astype('int64', copy=False) right = Series(val, index=ix) assert_series_equal(left, right) def test_resample_across_dst(self): # The test resamples a DatetimeIndex with values before and after a # DST change # Issue: 14682 # The DatetimeIndex we will start with # (note that DST happens at 03:00+02:00 -> 02:00+01:00) # 2016-10-30 02:23:00+02:00, 2016-10-30 02:23:00+01:00 df1 = DataFrame([1477786980, 1477790580], columns=['ts']) dti1 = DatetimeIndex(pd.to_datetime(df1.ts, unit='s') .dt.tz_localize('UTC') .dt.tz_convert('Europe/Madrid')) # The expected DatetimeIndex after resampling. # 2016-10-30 02:00:00+02:00, 2016-10-30 02:00:00+01:00 df2 = DataFrame([1477785600, 1477789200], columns=['ts']) dti2 = DatetimeIndex(pd.to_datetime(df2.ts, unit='s') .dt.tz_localize('UTC') .dt.tz_convert('Europe/Madrid')) df = DataFrame([5, 5], index=dti1) result = df.resample(rule='H').sum() expected = DataFrame([5, 5], index=dti2) assert_frame_equal(result, expected) def test_resample_dst_anchor(self): # 5172 dti = DatetimeIndex([datetime(2012, 11, 4, 23)], tz='US/Eastern') df = DataFrame([5], index=dti) assert_frame_equal(df.resample(rule='D').sum(), DataFrame([5], index=df.index.normalize())) df.resample(rule='MS').sum() assert_frame_equal( df.resample(rule='MS').sum(), DataFrame([5], index=DatetimeIndex([datetime(2012, 11, 1)], tz='US/Eastern'))) dti = date_range('2013-09-30', '2013-11-02', freq='30Min', tz='Europe/Paris') values = range(dti.size) df = DataFrame({"a": values, "b": values, "c": values}, index=dti, dtype='int64') how = {"a": "min", "b": "max", "c": "count"} assert_frame_equal( df.resample("W-MON").agg(how)[["a", "b", "c"]], DataFrame({"a": [0, 48, 384, 720, 1056, 1394], "b": [47, 383, 719, 1055, 1393, 1586], "c": [48, 336, 336, 336, 338, 193]}, index=date_range('9/30/2013', '11/4/2013', freq='W-MON', tz='Europe/Paris')), 'W-MON Frequency') assert_frame_equal( df.resample("2W-MON").agg(how)[["a", "b", "c"]], DataFrame({"a": [0, 48, 720, 1394], "b": [47, 719, 1393, 1586], "c": [48, 672, 674, 193]}, index=date_range('9/30/2013', '11/11/2013', freq='2W-MON', tz='Europe/Paris')), '2W-MON Frequency') assert_frame_equal( df.resample("MS").agg(how)[["a", "b", "c"]], DataFrame({"a": [0, 48, 1538], "b": [47, 1537, 1586], "c": [48, 1490, 49]}, index=date_range('9/1/2013', '11/1/2013', freq='MS', tz='Europe/Paris')), 'MS Frequency') assert_frame_equal( df.resample("2MS").agg(how)[["a", "b", "c"]], DataFrame({"a": [0, 1538], "b": [1537, 1586], "c": [1538, 49]}, index=date_range('9/1/2013', '11/1/2013', freq='2MS', tz='Europe/Paris')), '2MS Frequency') df_daily = df['10/26/2013':'10/29/2013'] assert_frame_equal( df_daily.resample("D").agg({"a": "min", "b": "max", "c": "count"}) [["a", "b", "c"]], DataFrame({"a": [1248, 1296, 1346, 1394], "b": [1295, 1345, 1393, 1441], "c": [48, 50, 48, 48]}, index=date_range('10/26/2013', '10/29/2013', freq='D', tz='Europe/Paris')), 'D Frequency') def test_resample_with_nat(self): # GH 13020 index = DatetimeIndex([pd.NaT, '1970-01-01 00:00:00', pd.NaT, '1970-01-01 00:00:01', '1970-01-01 00:00:02']) frame = DataFrame([2, 3, 5, 7, 11], index=index) index_1s = DatetimeIndex(['1970-01-01 00:00:00', '1970-01-01 00:00:01', '1970-01-01 00:00:02']) frame_1s = DataFrame([3, 7, 11], index=index_1s) assert_frame_equal(frame.resample('1s').mean(), frame_1s) index_2s = DatetimeIndex(['1970-01-01 00:00:00', '1970-01-01 00:00:02']) frame_2s = DataFrame([5, 11], index=index_2s) assert_frame_equal(frame.resample('2s').mean(), frame_2s) index_3s = DatetimeIndex(['1970-01-01 00:00:00']) frame_3s = DataFrame([7], index=index_3s) assert_frame_equal(frame.resample('3s').mean(), frame_3s) assert_frame_equal(frame.resample('60s').mean(), frame_3s) def test_resample_timedelta_values(self): # GH 13119 # check that timedelta dtype is preserved when NaT values are # introduced by the resampling times = timedelta_range('1 day', '4 day', freq='4D') df = DataFrame({'time': times}, index=times) times2 = timedelta_range('1 day', '4 day', freq='2D') exp = Series(times2, index=times2, name='time') exp.iloc[1] = pd.NaT res = df.resample('2D').first()['time'] tm.assert_series_equal(res, exp) res = df['time'].resample('2D').first() tm.assert_series_equal(res, exp) def test_resample_datetime_values(self): # GH 13119 # check that datetime dtype is preserved when NaT values are # introduced by the resampling dates = [datetime(2016, 1, 15), datetime(2016, 1, 19)] df = DataFrame({'timestamp': dates}, index=dates) exp = Series([datetime(2016, 1, 15), pd.NaT, datetime(2016, 1, 19)], index=date_range('2016-01-15', periods=3, freq='2D'), name='timestamp') res = df.resample('2D').first()['timestamp'] tm.assert_series_equal(res, exp) res = df['timestamp'].resample('2D').first() tm.assert_series_equal(res, exp) class TestPeriodIndex(Base): _index_factory = lambda x: period_range @pytest.fixture def _series_name(self): return 'pi' def create_series(self): # TODO: replace calls to .create_series() by injecting the series # fixture i = period_range(datetime(2005, 1, 1), datetime(2005, 1, 10), freq='D') return Series(np.arange(len(i)), index=i, name='pi') @pytest.mark.parametrize('freq', ['2D', '1H', '2H']) @pytest.mark.parametrize('kind', ['period', None, 'timestamp']) def test_asfreq(self, series_and_frame, freq, kind): # GH 12884, 15944 # make sure .asfreq() returns PeriodIndex (except kind='timestamp') obj = series_and_frame if kind == 'timestamp': expected = obj.to_timestamp().resample(freq).asfreq() else: start = obj.index[0].to_timestamp(how='start') end = (obj.index[-1] + 1).to_timestamp(how='start') new_index = date_range(start=start, end=end, freq=freq, closed='left') expected = obj.to_timestamp().reindex(new_index).to_period(freq) result = obj.resample(freq, kind=kind).asfreq() assert_almost_equal(result, expected) def test_asfreq_fill_value(self): # test for fill value during resampling, issue 3715 s = self.create_series() new_index = date_range(s.index[0].to_timestamp(how='start'), (s.index[-1]).to_timestamp(how='start'), freq='1H') expected = s.to_timestamp().reindex(new_index, fill_value=4.0) result = s.resample('1H', kind='timestamp').asfreq(fill_value=4.0) assert_series_equal(result, expected) frame = s.to_frame('value') new_index = date_range(frame.index[0].to_timestamp(how='start'), (frame.index[-1]).to_timestamp(how='start'), freq='1H') expected = frame.to_timestamp().reindex(new_index, fill_value=3.0) result = frame.resample('1H', kind='timestamp').asfreq(fill_value=3.0) assert_frame_equal(result, expected) @pytest.mark.parametrize('freq', ['H', '12H', '2D', 'W']) @pytest.mark.parametrize('kind', [None, 'period', 'timestamp']) def test_selection(self, index, freq, kind): # This is a bug, these should be implemented # GH 14008 df = pd.DataFrame({'date': index, 'a': np.arange(len(index), dtype=np.int64)}, index=pd.MultiIndex.from_arrays([ np.arange(len(index), dtype=np.int64), index], names=['v', 'd'])) with pytest.raises(NotImplementedError): df.resample(freq, on='date', kind=kind) with pytest.raises(NotImplementedError): df.resample(freq, level='d', kind=kind) def test_annual_upsample_D_s_f(self): self._check_annual_upsample_cases('D', 'start', 'ffill') def test_annual_upsample_D_e_f(self): self._check_annual_upsample_cases('D', 'end', 'ffill') def test_annual_upsample_D_s_b(self): self._check_annual_upsample_cases('D', 'start', 'bfill') def test_annual_upsample_D_e_b(self): self._check_annual_upsample_cases('D', 'end', 'bfill') def test_annual_upsample_B_s_f(self): self._check_annual_upsample_cases('B', 'start', 'ffill') def test_annual_upsample_B_e_f(self): self._check_annual_upsample_cases('B', 'end', 'ffill') def test_annual_upsample_B_s_b(self): self._check_annual_upsample_cases('B', 'start', 'bfill') def test_annual_upsample_B_e_b(self): self._check_annual_upsample_cases('B', 'end', 'bfill') def test_annual_upsample_M_s_f(self): self._check_annual_upsample_cases('M', 'start', 'ffill') def test_annual_upsample_M_e_f(self): self._check_annual_upsample_cases('M', 'end', 'ffill') def test_annual_upsample_M_s_b(self): self._check_annual_upsample_cases('M', 'start', 'bfill') def test_annual_upsample_M_e_b(self): self._check_annual_upsample_cases('M', 'end', 'bfill') def _check_annual_upsample_cases(self, targ, conv, meth, end='12/31/1991'): for month in MONTHS: ts = _simple_pts('1/1/1990', end, freq='A-%s' % month) result = getattr(ts.resample(targ, convention=conv), meth)() expected = result.to_timestamp(targ, how=conv) expected = expected.asfreq(targ, meth).to_period() assert_series_equal(result, expected) def test_basic_downsample(self): ts = _simple_pts('1/1/1990', '6/30/1995', freq='M') result = ts.resample('a-dec').mean() expected = ts.groupby(ts.index.year).mean() expected.index = period_range('1/1/1990', '6/30/1995', freq='a-dec') assert_series_equal(result, expected) # this is ok assert_series_equal(ts.resample('a-dec').mean(), result) assert_series_equal(ts.resample('a').mean(), result) def test_not_subperiod(self): # These are incompatible period rules for resampling ts = _simple_pts('1/1/1990', '6/30/1995', freq='w-wed') pytest.raises(ValueError, lambda: ts.resample('a-dec').mean()) pytest.raises(ValueError, lambda: ts.resample('q-mar').mean()) pytest.raises(ValueError, lambda: ts.resample('M').mean()) pytest.raises(ValueError, lambda: ts.resample('w-thu').mean()) @pytest.mark.parametrize('freq', ['D', '2D']) def test_basic_upsample(self, freq): ts = _simple_pts('1/1/1990', '6/30/1995', freq='M') result = ts.resample('a-dec').mean() resampled = result.resample(freq, convention='end').ffill() expected = result.to_timestamp(freq, how='end') expected = expected.asfreq(freq, 'ffill').to_period(freq) assert_series_equal(resampled, expected) def test_upsample_with_limit(self): rng = period_range('1/1/2000', periods=5, freq='A') ts = Series(np.random.randn(len(rng)), rng) result = ts.resample('M', convention='end').ffill(limit=2) expected = ts.asfreq('M').reindex(result.index, method='ffill', limit=2) assert_series_equal(result, expected) def test_annual_upsample(self): ts = _simple_pts('1/1/1990', '12/31/1995', freq='A-DEC') df = DataFrame({'a': ts}) rdf = df.resample('D').ffill() exp = df['a'].resample('D').ffill() assert_series_equal(rdf['a'], exp) rng = period_range('2000', '2003', freq='A-DEC') ts = Series([1, 2, 3, 4], index=rng) result = ts.resample('M').ffill() ex_index = period_range('2000-01', '2003-12', freq='M') expected = ts.asfreq('M', how='start').reindex(ex_index, method='ffill') assert_series_equal(result, expected) def test_quarterly_upsample(self): targets = ['D', 'B', 'M'] for month in MONTHS: ts = _simple_pts('1/1/1990', '12/31/1995', freq='Q-%s' % month) for targ, conv in product(targets, ['start', 'end']): result = ts.resample(targ, convention=conv).ffill() expected = result.to_timestamp(targ, how=conv) expected = expected.asfreq(targ, 'ffill').to_period() assert_series_equal(result, expected) def test_monthly_upsample(self): targets = ['D', 'B'] ts = _simple_pts('1/1/1990', '12/31/1995', freq='M') for targ, conv in product(targets, ['start', 'end']): result = ts.resample(targ, convention=conv).ffill() expected = result.to_timestamp(targ, how=conv) expected = expected.asfreq(targ, 'ffill').to_period() assert_series_equal(result, expected) def test_resample_basic(self): # GH3609 s = Series(range(100), index=date_range( '20130101', freq='s', periods=100, name='idx'), dtype='float') s[10:30] = np.nan index = PeriodIndex([ Period('2013-01-01 00:00', 'T'), Period('2013-01-01 00:01', 'T')], name='idx') expected = Series([34.5, 79.5], index=index) result = s.to_period().resample('T', kind='period').mean() assert_series_equal(result, expected) result2 = s.resample('T', kind='period').mean() assert_series_equal(result2, expected) @pytest.mark.parametrize('freq,expected_vals', [('M', [31, 29, 31, 9]), ('2M', [31 + 29, 31 + 9])]) def test_resample_count(self, freq, expected_vals): # GH12774 series = pd.Series(1, index=pd.period_range(start='2000', periods=100)) result = series.resample(freq).count() expected_index = pd.period_range(start='2000', freq=freq, periods=len(expected_vals)) expected = pd.Series(expected_vals, index=expected_index) assert_series_equal(result, expected) def test_resample_same_freq(self): # GH12770 series = pd.Series(range(3), index=pd.period_range( start='2000', periods=3, freq='M')) expected = series for method in resample_methods: result = getattr(series.resample('M'), method)() assert_series_equal(result, expected) def test_resample_incompat_freq(self): with pytest.raises(IncompatibleFrequency): pd.Series(range(3), index=pd.period_range( start='2000', periods=3, freq='M')).resample('W').mean() def test_with_local_timezone_pytz(self): # see gh-5430 local_timezone = pytz.timezone('America/Los_Angeles') start = datetime(year=2013, month=11, day=1, hour=0, minute=0, tzinfo=pytz.utc) # 1 day later end = datetime(year=2013, month=11, day=2, hour=0, minute=0, tzinfo=pytz.utc) index = pd.date_range(start, end, freq='H') series = pd.Series(1, index=index) series = series.tz_convert(local_timezone) result = series.resample('D', kind='period').mean() # Create the expected series # Index is moved back a day with the timezone conversion from UTC to # Pacific expected_index = (pd.period_range(start=start, end=end, freq='D') - 1) expected = pd.Series(1, index=expected_index) assert_series_equal(result, expected) def test_with_local_timezone_dateutil(self): # see gh-5430 local_timezone = 'dateutil/America/Los_Angeles' start = datetime(year=2013, month=11, day=1, hour=0, minute=0, tzinfo=dateutil.tz.tzutc()) # 1 day later end = datetime(year=2013, month=11, day=2, hour=0, minute=0, tzinfo=dateutil.tz.tzutc()) index = pd.date_range(start, end, freq='H', name='idx') series = pd.Series(1, index=index) series = series.tz_convert(local_timezone) result = series.resample('D', kind='period').mean() # Create the expected series # Index is moved back a day with the timezone conversion from UTC to # Pacific expected_index = (pd.period_range(start=start, end=end, freq='D', name='idx') - 1) expected = pd.Series(1, index=expected_index) assert_series_equal(result, expected) def test_fill_method_and_how_upsample(self): # GH2073 s = Series(np.arange(9, dtype='int64'), index=date_range('2010-01-01', periods=9, freq='Q')) last = s.resample('M').ffill() both = s.resample('M').ffill().resample('M').last().astype('int64') assert_series_equal(last, both) def test_weekly_upsample(self): targets = ['D', 'B'] for day in DAYS: ts = _simple_pts('1/1/1990', '12/31/1995', freq='W-%s' % day) for targ, conv in product(targets, ['start', 'end']): result = ts.resample(targ, convention=conv).ffill() expected = result.to_timestamp(targ, how=conv) expected = expected.asfreq(targ, 'ffill').to_period() assert_series_equal(result, expected) def test_resample_to_timestamps(self): ts = _simple_pts('1/1/1990', '12/31/1995', freq='M') result = ts.resample('A-DEC', kind='timestamp').mean() expected = ts.to_timestamp(how='end').resample('A-DEC').mean() assert_series_equal(result, expected) def test_resample_to_quarterly(self): for month in MONTHS: ts = _simple_pts('1990', '1992', freq='A-%s' % month) quar_ts = ts.resample('Q-%s' % month).ffill() stamps = ts.to_timestamp('D', how='start') qdates = period_range(ts.index[0].asfreq('D', 'start'), ts.index[-1].asfreq('D', 'end'), freq='Q-%s' % month) expected = stamps.reindex(qdates.to_timestamp('D', 's'), method='ffill') expected.index = qdates assert_series_equal(quar_ts, expected) # conforms, but different month ts = _simple_pts('1990', '1992', freq='A-JUN') for how in ['start', 'end']: result = ts.resample('Q-MAR', convention=how).ffill() expected = ts.asfreq('Q-MAR', how=how) expected = expected.reindex(result.index, method='ffill') # .to_timestamp('D') # expected = expected.resample('Q-MAR').ffill() assert_series_equal(result, expected) def test_resample_fill_missing(self): rng = PeriodIndex([2000, 2005, 2007, 2009], freq='A') s = Series(np.random.randn(4), index=rng) stamps = s.to_timestamp() filled = s.resample('A').ffill() expected = stamps.resample('A').ffill().to_period('A') assert_series_equal(filled, expected) def test_cant_fill_missing_dups(self): rng = PeriodIndex([2000, 2005, 2005, 2007, 2007], freq='A') s = Series(np.random.randn(5), index=rng) pytest.raises(Exception, lambda: s.resample('A').ffill()) @pytest.mark.parametrize('freq', ['5min']) @pytest.mark.parametrize('kind', ['period', None, 'timestamp']) def test_resample_5minute(self, freq, kind): rng = period_range('1/1/2000', '1/5/2000', freq='T') ts = Series(np.random.randn(len(rng)), index=rng) expected = ts.to_timestamp().resample(freq).mean() if kind != 'timestamp': expected = expected.to_period(freq) result = ts.resample(freq, kind=kind).mean() assert_series_equal(result, expected) def test_upsample_daily_business_daily(self): ts = _simple_pts('1/1/2000', '2/1/2000', freq='B') result = ts.resample('D').asfreq() expected = ts.asfreq('D').reindex(period_range('1/3/2000', '2/1/2000')) assert_series_equal(result, expected) ts = _simple_pts('1/1/2000', '2/1/2000') result = ts.resample('H', convention='s').asfreq() exp_rng = period_range('1/1/2000', '2/1/2000 23:00', freq='H') expected = ts.asfreq('H', how='s').reindex(exp_rng) assert_series_equal(result, expected) def test_resample_irregular_sparse(self): dr = date_range(start='1/1/2012', freq='5min', periods=1000) s = Series(np.array(100), index=dr) # subset the data. subset = s[:'2012-01-04 06:55'] result = subset.resample('10min').apply(len) expected = s.resample('10min').apply(len).loc[result.index] assert_series_equal(result, expected) def test_resample_weekly_all_na(self): rng = date_range('1/1/2000', periods=10, freq='W-WED') ts = Series(np.random.randn(len(rng)), index=rng) result = ts.resample('W-THU').asfreq() assert result.isna().all() result = ts.resample('W-THU').asfreq().ffill()[:-1] expected = ts.asfreq('W-THU').ffill() assert_series_equal(result, expected) def test_resample_tz_localized(self): dr = date_range(start='2012-4-13', end='2012-5-1') ts = Series(lrange(len(dr)), dr) ts_utc = ts.tz_localize('UTC') ts_local = ts_utc.tz_convert('America/Los_Angeles') result = ts_local.resample('W').mean() ts_local_naive = ts_local.copy() ts_local_naive.index = [x.replace(tzinfo=None) for x in ts_local_naive.index.to_pydatetime()] exp = ts_local_naive.resample( 'W').mean().tz_localize('America/Los_Angeles') assert_series_equal(result, exp) # it works result = ts_local.resample('D').mean() # #2245 idx = date_range('2001-09-20 15:59', '2001-09-20 16:00', freq='T', tz='Australia/Sydney') s = Series([1, 2], index=idx) result = s.resample('D', closed='right', label='right').mean() ex_index = date_range('2001-09-21', periods=1, freq='D', tz='Australia/Sydney') expected = Series([1.5], index=ex_index) assert_series_equal(result, expected) # for good measure result = s.resample('D', kind='period').mean() ex_index = period_range('2001-09-20', periods=1, freq='D') expected = Series([1.5], index=ex_index) assert_series_equal(result, expected) # GH 6397 # comparing an offset that doesn't propagate tz's rng = date_range('1/1/2011', periods=20000, freq='H') rng = rng.tz_localize('EST') ts = DataFrame(index=rng) ts['first'] = np.random.randn(len(rng)) ts['second'] = np.cumsum(np.random.randn(len(rng))) expected = DataFrame( { 'first': ts.resample('A').sum()['first'], 'second': ts.resample('A').mean()['second']}, columns=['first', 'second']) result = ts.resample( 'A').agg({'first': np.sum, 'second': np.mean}).reindex(columns=['first', 'second']) assert_frame_equal(result, expected) def test_closed_left_corner(self): # #1465 s = Series(np.random.randn(21), index=date_range(start='1/1/2012 9:30', freq='1min', periods=21)) s[0] = np.nan result = s.resample('10min', closed='left', label='right').mean() exp = s[1:].resample('10min', closed='left', label='right').mean() assert_series_equal(result, exp) result = s.resample('10min', closed='left', label='left').mean() exp = s[1:].resample('10min', closed='left', label='left').mean() ex_index = date_range(start='1/1/2012 9:30', freq='10min', periods=3) tm.assert_index_equal(result.index, ex_index) assert_series_equal(result, exp) def test_quarterly_resampling(self): rng = period_range('2000Q1', periods=10, freq='Q-DEC') ts = Series(np.arange(10), index=rng) result = ts.resample('A').mean() exp = ts.to_timestamp().resample('A').mean().to_period() assert_series_equal(result, exp) def test_resample_weekly_bug_1726(self): # 8/6/12 is a Monday ind = DatetimeIndex(start="8/6/2012", end="8/26/2012", freq="D") n = len(ind) data = [[x] * 5 for x in range(n)] df = DataFrame(data, columns=['open', 'high', 'low', 'close', 'vol'], index=ind) # it works! df.resample('W-MON', closed='left', label='left').first() def test_resample_with_dst_time_change(self): # GH 15549 index = pd.DatetimeIndex([1457537600000000000, 1458059600000000000], tz='UTC').tz_convert('America/Chicago') df = pd.DataFrame([1, 2], index=index) result = df.resample('12h', closed='right', label='right').last().ffill() expected_index_values = ['2016-03-09 12:00:00-06:00', '2016-03-10 00:00:00-06:00', '2016-03-10 12:00:00-06:00', '2016-03-11 00:00:00-06:00', '2016-03-11 12:00:00-06:00', '2016-03-12 00:00:00-06:00', '2016-03-12 12:00:00-06:00', '2016-03-13 00:00:00-06:00', '2016-03-13 13:00:00-05:00', '2016-03-14 01:00:00-05:00', '2016-03-14 13:00:00-05:00', '2016-03-15 01:00:00-05:00', '2016-03-15 13:00:00-05:00'] index = pd.DatetimeIndex(expected_index_values, tz='UTC').tz_convert('America/Chicago') expected = pd.DataFrame([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0], index=index) assert_frame_equal(result, expected) def test_resample_bms_2752(self): # GH2753 foo = pd.Series(index=pd.bdate_range('20000101', '20000201')) res1 = foo.resample("BMS").mean() res2 = foo.resample("BMS").mean().resample("B").mean() assert res1.index[0] == Timestamp('20000103') assert res1.index[0] == res2.index[0] # def test_monthly_convention_span(self): # rng = period_range('2000-01', periods=3, freq='M') # ts = Series(np.arange(3), index=rng) # # hacky way to get same thing # exp_index = period_range('2000-01-01', '2000-03-31', freq='D') # expected = ts.asfreq('D', how='end').reindex(exp_index) # expected = expected.fillna(method='bfill') # result = ts.resample('D', convention='span').mean() # assert_series_equal(result, expected) def test_default_right_closed_label(self): end_freq = ['D', 'Q', 'M', 'D'] end_types = ['M', 'A', 'Q', 'W'] for from_freq, to_freq in zip(end_freq, end_types): idx = DatetimeIndex(start='8/15/2012', periods=100, freq=from_freq) df = DataFrame(np.random.randn(len(idx), 2), idx) resampled = df.resample(to_freq).mean() assert_frame_equal(resampled, df.resample(to_freq, closed='right', label='right').mean()) def test_default_left_closed_label(self): others = ['MS', 'AS', 'QS', 'D', 'H'] others_freq = ['D', 'Q', 'M', 'H', 'T'] for from_freq, to_freq in zip(others_freq, others): idx = DatetimeIndex(start='8/15/2012', periods=100, freq=from_freq) df = DataFrame(np.random.randn(len(idx), 2), idx) resampled = df.resample(to_freq).mean() assert_frame_equal(resampled, df.resample(to_freq, closed='left', label='left').mean()) def test_all_values_single_bin(self): # 2070 index = period_range(start="2012-01-01", end="2012-12-31", freq="M") s = Series(np.random.randn(len(index)), index=index) result = s.resample("A").mean() tm.assert_almost_equal(result[0], s.mean()) def test_evenly_divisible_with_no_extra_bins(self): # 4076 # when the frequency is evenly divisible, sometimes extra bins df = DataFrame(np.random.randn(9, 3), index=date_range('2000-1-1', periods=9)) result = df.resample('5D').mean() expected = pd.concat( [df.iloc[0:5].mean(), df.iloc[5:].mean()], axis=1).T expected.index = [Timestamp('2000-1-1'), Timestamp('2000-1-6')] assert_frame_equal(result, expected) index = date_range(start='2001-5-4', periods=28) df = DataFrame( [{'REST_KEY': 1, 'DLY_TRN_QT': 80, 'DLY_SLS_AMT': 90, 'COOP_DLY_TRN_QT': 30, 'COOP_DLY_SLS_AMT': 20}] * 28 + [{'REST_KEY': 2, 'DLY_TRN_QT': 70, 'DLY_SLS_AMT': 10, 'COOP_DLY_TRN_QT': 50, 'COOP_DLY_SLS_AMT': 20}] * 28, index=index.append(index)).sort_index() index = date_range('2001-5-4', periods=4, freq='7D') expected = DataFrame( [{'REST_KEY': 14, 'DLY_TRN_QT': 14, 'DLY_SLS_AMT': 14, 'COOP_DLY_TRN_QT': 14, 'COOP_DLY_SLS_AMT': 14}] * 4, index=index) result = df.resample('7D').count() assert_frame_equal(result, expected) expected = DataFrame( [{'REST_KEY': 21, 'DLY_TRN_QT': 1050, 'DLY_SLS_AMT': 700, 'COOP_DLY_TRN_QT': 560, 'COOP_DLY_SLS_AMT': 280}] * 4, index=index) result = df.resample('7D').sum() assert_frame_equal(result, expected) @pytest.mark.parametrize('kind', ['period', None, 'timestamp']) @pytest.mark.parametrize('agg_arg', ['mean', {'value': 'mean'}, ['mean']]) def test_loffset_returns_datetimeindex(self, frame, kind, agg_arg): # make sure passing loffset returns DatetimeIndex in all cases # basic method taken from Base.test_resample_loffset_arg_type() df = frame expected_means = [df.values[i:i + 2].mean() for i in range(0, len(df.values), 2)] expected_index = self.create_index(df.index[0], periods=len(df.index) / 2, freq='2D') # loffset coerces PeriodIndex to DateTimeIndex expected_index = expected_index.to_timestamp() expected_index += timedelta(hours=2) expected = DataFrame({'value': expected_means}, index=expected_index) result_agg = df.resample('2D', loffset='2H', kind=kind).agg(agg_arg) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result_how = df.resample('2D', how=agg_arg, loffset='2H', kind=kind) if isinstance(agg_arg, list): expected.columns = pd.MultiIndex.from_tuples([('value', 'mean')]) assert_frame_equal(result_agg, expected) assert_frame_equal(result_how, expected) @pytest.mark.parametrize('freq, period_mult', [('H', 24), ('12H', 2)]) @pytest.mark.parametrize('kind', [None, 'period']) def test_upsampling_ohlc(self, freq, period_mult, kind): # GH 13083 pi = PeriodIndex(start='2000', freq='D', periods=10) s = Series(range(len(pi)), index=pi) expected = s.to_timestamp().resample(freq).ohlc().to_period(freq) # timestamp-based resampling doesn't include all sub-periods # of the last original period, so extend accordingly: new_index = PeriodIndex(start='2000', freq=freq, periods=period_mult * len(pi)) expected = expected.reindex(new_index) result = s.resample(freq, kind=kind).ohlc() assert_frame_equal(result, expected) @pytest.mark.parametrize('periods, values', [([pd.NaT, '1970-01-01 00:00:00', pd.NaT, '1970-01-01 00:00:02', '1970-01-01 00:00:03'], [2, 3, 5, 7, 11]), ([pd.NaT, pd.NaT, '1970-01-01 00:00:00', pd.NaT, pd.NaT, pd.NaT, '1970-01-01 00:00:02', '1970-01-01 00:00:03', pd.NaT, pd.NaT], [1, 2, 3, 5, 6, 8, 7, 11, 12, 13])]) @pytest.mark.parametrize('freq, expected_values', [('1s', [3, np.NaN, 7, 11]), ('2s', [3, int((7 + 11) / 2)]), ('3s', [int((3 + 7) / 2), 11])]) def test_resample_with_nat(self, periods, values, freq, expected_values): # GH 13224 index = PeriodIndex(periods, freq='S') frame = DataFrame(values, index=index) expected_index = period_range('1970-01-01 00:00:00', periods=len(expected_values), freq=freq) expected = DataFrame(expected_values, index=expected_index) result = frame.resample(freq).mean() assert_frame_equal(result, expected) def test_resample_with_only_nat(self): # GH 13224 pi = PeriodIndex([pd.NaT] * 3, freq='S') frame = DataFrame([2, 3, 5], index=pi) expected_index = PeriodIndex(data=[], freq=pi.freq) expected = DataFrame([], index=expected_index) result = frame.resample('1s').mean() assert_frame_equal(result, expected) class TestTimedeltaIndex(Base): _index_factory = lambda x: timedelta_range @pytest.fixture def _index_start(self): return '1 day' @pytest.fixture def _index_end(self): return '10 day' @pytest.fixture def _series_name(self): return 'tdi' def create_series(self): i = timedelta_range('1 day', '10 day', freq='D') return Series(np.arange(len(i)), index=i, name='tdi') def test_asfreq_bug(self): import datetime as dt df = DataFrame(data=[1, 3], index=[dt.timedelta(), dt.timedelta(minutes=3)]) result = df.resample('1T').asfreq() expected = DataFrame(data=[1, np.nan, np.nan, 3], index=timedelta_range('0 day', periods=4, freq='1T')) assert_frame_equal(result, expected) class TestResamplerGrouper(object): def setup_method(self, method): self.frame = DataFrame({'A': [1] * 20 + [2] * 12 + [3] * 8, 'B': np.arange(40)}, index=date_range('1/1/2000', freq='s', periods=40)) def test_back_compat_v180(self): df = self.frame for how in ['sum', 'mean', 'prod', 'min', 'max', 'var', 'std']: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = df.groupby('A').resample('4s', how=how) expected = getattr(df.groupby('A').resample('4s'), how)() assert_frame_equal(result, expected) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): result = df.groupby('A').resample('4s', how='mean', fill_method='ffill') expected = df.groupby('A').resample('4s').mean().ffill() assert_frame_equal(result, expected) def test_tab_complete_ipython6_warning(self, ip): from IPython.core.completer import provisionalcompleter code = dedent("""\ import pandas.util.testing as tm s = tm.makeTimeSeries() rs = s.resample("D") """) ip.run_code(code) with tm.assert_produces_warning(None): with provisionalcompleter('ignore'): list(ip.Completer.completions('rs.', 1)) def test_deferred_with_groupby(self): # GH 12486 # support deferred resample ops with groupby data = [['2010-01-01', 'A', 2], ['2010-01-02', 'A', 3], ['2010-01-05', 'A', 8], ['2010-01-10', 'A', 7], ['2010-01-13', 'A', 3], ['2010-01-01', 'B', 5], ['2010-01-03', 'B', 2], ['2010-01-04', 'B', 1], ['2010-01-11', 'B', 7], ['2010-01-14', 'B', 3]] df = DataFrame(data, columns=['date', 'id', 'score']) df.date = pd.to_datetime(df.date) f = lambda x: x.set_index('date').resample('D').asfreq() expected = df.groupby('id').apply(f) result = df.set_index('date').groupby('id').resample('D').asfreq() assert_frame_equal(result, expected) df = DataFrame({'date': pd.date_range(start='2016-01-01', periods=4, freq='W'), 'group': [1, 1, 2, 2], 'val': [5, 6, 7, 8]}).set_index('date') f = lambda x: x.resample('1D').ffill() expected = df.groupby('group').apply(f) result = df.groupby('group').resample('1D').ffill() assert_frame_equal(result, expected) def test_getitem(self): g = self.frame.groupby('A') expected = g.B.apply(lambda x: x.resample('2s').mean()) result = g.resample('2s').B.mean() assert_series_equal(result, expected) result = g.B.resample('2s').mean() assert_series_equal(result, expected) result = g.resample('2s').mean().B assert_series_equal(result, expected) def test_getitem_multiple(self): # GH 13174 # multiple calls after selection causing an issue with aliasing data = [{'id': 1, 'buyer': 'A'}, {'id': 2, 'buyer': 'B'}] df = pd.DataFrame(data, index=pd.date_range('2016-01-01', periods=2)) r = df.groupby('id').resample('1D') result = r['buyer'].count() expected = pd.Series([1, 1], index=pd.MultiIndex.from_tuples( [(1, pd.Timestamp('2016-01-01')), (2, pd.Timestamp('2016-01-02'))], names=['id', None]), name='buyer') assert_series_equal(result, expected) result = r['buyer'].count() assert_series_equal(result, expected) def test_nearest(self): # GH 17496 # Resample nearest index = pd.date_range('1/1/2000', periods=3, freq='T') result = pd.Series(range(3), index=index).resample('20s').nearest() expected = pd.Series( [0, 0, 1, 1, 1, 2, 2], index=pd.DatetimeIndex( ['2000-01-01 00:00:00', '2000-01-01 00:00:20', '2000-01-01 00:00:40', '2000-01-01 00:01:00', '2000-01-01 00:01:20', '2000-01-01 00:01:40', '2000-01-01 00:02:00'], dtype='datetime64[ns]', freq='20S')) assert_series_equal(result, expected) def test_methods(self): g = self.frame.groupby('A') r = g.resample('2s') for f in ['first', 'last', 'median', 'sem', 'sum', 'mean', 'min', 'max']: result = getattr(r, f)() expected = g.apply(lambda x: getattr(x.resample('2s'), f)()) assert_frame_equal(result, expected) for f in ['size']: result = getattr(r, f)() expected = g.apply(lambda x: getattr(x.resample('2s'), f)()) assert_series_equal(result, expected) for f in ['count']: result = getattr(r, f)() expected = g.apply(lambda x: getattr(x.resample('2s'), f)()) assert_frame_equal(result, expected) # series only for f in ['nunique']: result = getattr(r.B, f)() expected = g.B.apply(lambda x: getattr(x.resample('2s'), f)()) assert_series_equal(result, expected) for f in ['nearest', 'backfill', 'ffill', 'asfreq']: result = getattr(r, f)() expected = g.apply(lambda x: getattr(x.resample('2s'), f)()) assert_frame_equal(result, expected) result = r.ohlc() expected = g.apply(lambda x: x.resample('2s').ohlc()) assert_frame_equal(result, expected) for f in ['std', 'var']: result = getattr(r, f)(ddof=1) expected = g.apply(lambda x: getattr(x.resample('2s'), f)(ddof=1)) assert_frame_equal(result, expected) def test_apply(self): g = self.frame.groupby('A') r = g.resample('2s') # reduction expected = g.resample('2s').sum() def f(x): return x.resample('2s').sum() result = r.apply(f) assert_frame_equal(result, expected) def f(x): return x.resample('2s').apply(lambda y: y.sum()) result = g.apply(f) assert_frame_equal(result, expected) def test_apply_with_mutated_index(self): # GH 15169 index = pd.date_range('1-1-2015', '12-31-15', freq='D') df = pd.DataFrame(data={'col1': np.random.rand(len(index))}, index=index) def f(x): s = pd.Series([1, 2], index=['a', 'b']) return s expected = df.groupby(pd.Grouper(freq='M')).apply(f) result = df.resample('M').apply(f) assert_frame_equal(result, expected) # A case for series expected = df['col1'].groupby(pd.Grouper(freq='M')).apply(f) result = df['col1'].resample('M').apply(f) assert_series_equal(result, expected) def test_resample_groupby_with_label(self): # GH 13235 index = date_range('2000-01-01', freq='2D', periods=5) df = DataFrame(index=index, data={'col0': [0, 0, 1, 1, 2], 'col1': [1, 1, 1, 1, 1]} ) result = df.groupby('col0').resample('1W', label='left').sum() mi = [np.array([0, 0, 1, 2]), pd.to_datetime(np.array(['1999-12-26', '2000-01-02', '2000-01-02', '2000-01-02']) ) ] mindex = pd.MultiIndex.from_arrays(mi, names=['col0', None]) expected = DataFrame(data={'col0': [0, 0, 2, 2], 'col1': [1, 1, 2, 1]}, index=mindex ) assert_frame_equal(result, expected) def test_consistency_with_window(self): # consistent return values with window df = self.frame expected = pd.Int64Index([1, 2, 3], name='A') result = df.groupby('A').resample('2s').mean() assert result.index.nlevels == 2 tm.assert_index_equal(result.index.levels[0], expected) result = df.groupby('A').rolling(20).mean() assert result.index.nlevels == 2 tm.assert_index_equal(result.index.levels[0], expected) def test_median_duplicate_columns(self): # GH 14233 df = pd.DataFrame(np.random.randn(20, 3), columns=list('aaa'), index=pd.date_range('2012-01-01', periods=20, freq='s')) df2 = df.copy() df2.columns = ['a', 'b', 'c'] expected = df2.resample('5s').median() result = df.resample('5s').median() expected.columns = result.columns assert_frame_equal(result, expected) class TestTimeGrouper(object): def setup_method(self, method): self.ts = Series(np.random.randn(1000), index=date_range('1/1/2000', periods=1000)) def test_apply(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): grouper = pd.TimeGrouper(freq='A', label='right', closed='right') grouped = self.ts.groupby(grouper) f = lambda x: x.sort_values()[-3:] applied = grouped.apply(f) expected = self.ts.groupby(lambda x: x.year).apply(f) applied.index = applied.index.droplevel(0) expected.index = expected.index.droplevel(0) assert_series_equal(applied, expected) def test_count(self): self.ts[::3] = np.nan expected = self.ts.groupby(lambda x: x.year).count() with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): grouper = pd.TimeGrouper(freq='A', label='right', closed='right') result = self.ts.groupby(grouper).count() expected.index = result.index assert_series_equal(result, expected) result = self.ts.resample('A').count() expected.index = result.index assert_series_equal(result, expected) def test_numpy_reduction(self): result = self.ts.resample('A', closed='right').prod() expected = self.ts.groupby(lambda x: x.year).agg(np.prod) expected.index = result.index assert_series_equal(result, expected) def test_apply_iteration(self): # #2300 N = 1000 ind = pd.date_range(start="2000-01-01", freq="D", periods=N) df = DataFrame({'open': 1, 'close': 2}, index=ind) tg = TimeGrouper('M') _, grouper, _ = tg._get_grouper(df) # Errors grouped = df.groupby(grouper, group_keys=False) f = lambda df: df['close'] / df['open'] # it works! result = grouped.apply(f) tm.assert_index_equal(result.index, df.index) def test_panel_aggregation(self): ind = pd.date_range('1/1/2000', periods=100) data = np.random.randn(2, len(ind), 4) with catch_warnings(record=True): wp = Panel(data, items=['Item1', 'Item2'], major_axis=ind, minor_axis=['A', 'B', 'C', 'D']) tg = TimeGrouper('M', axis=1) _, grouper, _ = tg._get_grouper(wp) bingrouped = wp.groupby(grouper) binagg = bingrouped.mean() def f(x): assert (isinstance(x, Panel)) return x.mean(1) result = bingrouped.agg(f) tm.assert_panel_equal(result, binagg) def test_fails_on_no_datetime_index(self): index_names = ('Int64Index', 'Index', 'Float64Index', 'MultiIndex') index_funcs = (tm.makeIntIndex, tm.makeUnicodeIndex, tm.makeFloatIndex, lambda m: tm.makeCustomIndex(m, 2)) n = 2 for name, func in zip(index_names, index_funcs): index = func(n) df = DataFrame({'a': np.random.randn(n)}, index=index) with tm.assert_raises_regex(TypeError, "Only valid with " "DatetimeIndex, TimedeltaIndex " "or PeriodIndex, but got an " "instance of %r" % name): df.groupby(TimeGrouper('D')) def test_aaa_group_order(self): # GH 12840 # check TimeGrouper perform stable sorts n = 20 data = np.random.randn(n, 4) df = DataFrame(data, columns=['A', 'B', 'C', 'D']) df['key'] = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3), datetime(2013, 1, 4), datetime(2013, 1, 5)] * 4 grouped = df.groupby(TimeGrouper(key='key', freq='D')) tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 1)), df[::5]) tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 2)), df[1::5]) tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 3)), df[2::5]) tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 4)), df[3::5]) tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 5)), df[4::5]) def test_aggregate_normal(self): # check TimeGrouper's aggregation is identical as normal groupby n = 20 data = np.random.randn(n, 4) normal_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) normal_df['key'] = [1, 2, 3, 4, 5] * 4 dt_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) dt_df['key'] = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3), datetime(2013, 1, 4), datetime(2013, 1, 5)] * 4 normal_grouped = normal_df.groupby('key') dt_grouped = dt_df.groupby(TimeGrouper(key='key', freq='D')) for func in ['min', 'max', 'prod', 'var', 'std', 'mean']: expected = getattr(normal_grouped, func)() dt_result = getattr(dt_grouped, func)() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') assert_frame_equal(expected, dt_result) for func in ['count', 'sum']: expected = getattr(normal_grouped, func)() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') dt_result = getattr(dt_grouped, func)() assert_frame_equal(expected, dt_result) # GH 7453 for func in ['size']: expected = getattr(normal_grouped, func)() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') dt_result = getattr(dt_grouped, func)() assert_series_equal(expected, dt_result) # GH 7453 for func in ['first', 'last']: expected = getattr(normal_grouped, func)() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') dt_result = getattr(dt_grouped, func)() assert_frame_equal(expected, dt_result) # if TimeGrouper is used included, 'nth' doesn't work yet """ for func in ['nth']: expected = getattr(normal_grouped, func)(3) expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') dt_result = getattr(dt_grouped, func)(3) assert_frame_equal(expected, dt_result) """ @pytest.mark.parametrize('method, unit', [ ('sum', 0), ('prod', 1), ]) def test_resample_entirly_nat_window(self, method, unit): s = pd.Series([0] * 2 + [np.nan] * 2, index=pd.date_range('2017', periods=4)) # 0 / 1 by default result = methodcaller(method)(s.resample("2d")) expected = pd.Series([0.0, unit], index=pd.to_datetime(['2017-01-01', '2017-01-03'])) tm.assert_series_equal(result, expected) # min_count=0 result = methodcaller(method, min_count=0)(s.resample("2d")) expected = pd.Series([0.0, unit], index=pd.to_datetime(['2017-01-01', '2017-01-03'])) tm.assert_series_equal(result, expected) # min_count=1 result = methodcaller(method, min_count=1)(s.resample("2d")) expected = pd.Series([0.0, np.nan], index=pd.to_datetime(['2017-01-01', '2017-01-03'])) tm.assert_series_equal(result, expected) @pytest.mark.parametrize('func, fill_value', [ ('min', np.nan), ('max', np.nan), ('sum', 0), ('prod', 1), ('count', 0), ]) def test_aggregate_with_nat(self, func, fill_value): # check TimeGrouper's aggregation is identical as normal groupby # if NaT is included, 'var', 'std', 'mean', 'first','last' # and 'nth' doesn't work yet n = 20 data = np.random.randn(n, 4).astype('int64') normal_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) normal_df['key'] = [1, 2, np.nan, 4, 5] * 4 dt_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) dt_df['key'] = [datetime(2013, 1, 1), datetime(2013, 1, 2), pd.NaT, datetime(2013, 1, 4), datetime(2013, 1, 5)] * 4 normal_grouped = normal_df.groupby('key') dt_grouped = dt_df.groupby(TimeGrouper(key='key', freq='D')) normal_result = getattr(normal_grouped, func)() dt_result = getattr(dt_grouped, func)() pad = DataFrame([[fill_value] * 4], index=[3], columns=['A', 'B', 'C', 'D']) expected = normal_result.append(pad) expected = expected.sort_index() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') assert_frame_equal(expected, dt_result) assert dt_result.index.name == 'key' def test_aggregate_with_nat_size(self): # GH 9925 n = 20 data = np.random.randn(n, 4).astype('int64') normal_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) normal_df['key'] = [1, 2, np.nan, 4, 5] * 4 dt_df = DataFrame(data, columns=['A', 'B', 'C', 'D']) dt_df['key'] = [datetime(2013, 1, 1), datetime(2013, 1, 2), pd.NaT, datetime(2013, 1, 4), datetime(2013, 1, 5)] * 4 normal_grouped = normal_df.groupby('key') dt_grouped = dt_df.groupby(TimeGrouper(key='key', freq='D')) normal_result = normal_grouped.size() dt_result = dt_grouped.size() pad = Series([0], index=[3]) expected = normal_result.append(pad) expected = expected.sort_index() expected.index = date_range(start='2013-01-01', freq='D', periods=5, name='key') assert_series_equal(expected, dt_result) assert dt_result.index.name == 'key' def test_repr(self): # GH18203 result = repr(TimeGrouper(key='A', freq='H')) expected = ("TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, " "closed='left', label='left', how='mean', " "convention='e', base=0)") assert result == expected @pytest.mark.parametrize('method, unit', [ ('sum', 0), ('prod', 1), ]) def test_upsample_sum(self, method, unit): s = pd.Series(1, index=pd.date_range("2017", periods=2, freq="H")) resampled = s.resample("30T") index = pd.to_datetime(['2017-01-01T00:00:00', '2017-01-01T00:30:00', '2017-01-01T01:00:00']) # 0 / 1 by default result = methodcaller(method)(resampled) expected = pd.Series([1, unit, 1], index=index) tm.assert_series_equal(result, expected) # min_count=0 result = methodcaller(method, min_count=0)(resampled) expected = pd.Series([1, unit, 1], index=index) tm.assert_series_equal(result, expected) # min_count=1 result = methodcaller(method, min_count=1)(resampled) expected = pd.Series([1, np.nan, 1], index=index) tm.assert_series_equal(result, expected) # min_count>1 result = methodcaller(method, min_count=2)(resampled) expected = pd.Series([np.nan, np.nan, np.nan], index=index) tm.assert_series_equal(result, expected)
the-stack_106_29235
import os import torch import pickle from MeLU import MeLU from options import config def selection(melu, master_path, topk): if not os.path.exists("{}/scores/".format(master_path)): os.mkdir("{}/scores/".format(master_path)) if config['use_cuda']: melu.cuda() melu.eval() target_state = 'warm_state' dataset_size = int(len(os.listdir("{}/{}".format(master_path, target_state))) / 4) grad_norms = {} for j in list(range(dataset_size)): support_xs = pickle.load(open("{}/{}/supp_x_{}.pkl".format(master_path, target_state, j), "rb")) support_ys = pickle.load(open("{}/{}/supp_y_{}.pkl".format(master_path, target_state, j), "rb")) item_ids = [] with open("{}/log/{}/supp_x_{}_u_m_ids.txt".format(master_path, target_state, j), "r") as f: for line in f.readlines(): item_id = line.strip().split()[1] item_ids.append(item_id) for support_x, support_y, item_id in zip(support_xs, support_ys, item_ids): support_x = support_x.view(1, -1) support_y = support_y.view(1, -1) norm = melu.get_weight_avg_norm(support_x, support_y, config['inner']) try: grad_norms[item_id]['discriminative_value'] += norm.item() grad_norms[item_id]['popularity_value'] += 1 except: grad_norms[item_id] = { 'discriminative_value': norm.item(), 'popularity_value': 1 } d_value_max = 0 p_value_max = 0 for item_id in grad_norms.keys(): grad_norms[item_id]['discriminative_value'] /= grad_norms[item_id]['popularity_value'] if grad_norms[item_id]['discriminative_value'] > d_value_max: d_value_max = grad_norms[item_id]['discriminative_value'] if grad_norms[item_id]['popularity_value'] > p_value_max: p_value_max = grad_norms[item_id]['popularity_value'] for item_id in grad_norms.keys(): grad_norms[item_id]['discriminative_value'] /= float(d_value_max) grad_norms[item_id]['popularity_value'] /= float(p_value_max) grad_norms[item_id]['final_score'] = grad_norms[item_id]['discriminative_value'] * grad_norms[item_id]['popularity_value'] movie_info = {} with open("./movielens/ml-1m/movies_extrainfos.dat", encoding="utf-8") as f: for line in f.readlines(): tmp = line.strip().split("::") movie_info[tmp[0]] = "{} ({})".format(tmp[1], tmp[2]) evidence_candidates = [] for item_id, value in list(sorted(grad_norms.items(), key=lambda x: x[1]['final_score'], reverse=True))[:topk]: evidence_candidates.append((movie_info[item_id], value['final_score'])) return evidence_candidates
the-stack_106_29237
import numpy as np from bokeh import plotting from bokeh.embed import components from bokeh.io import curdoc from bokeh.models import FuncTickFormatter, OpenURL, TapTool from bokeh.models import Label, Legend, LegendItem, LogAxis, Range1d from bokeh.themes import Theme from utils import get_update_time, load_data, log_axis_labels # get the exoplot theme theme = Theme(filename="./exoplots_theme.yaml") curdoc().theme = theme # what order to plot things and what the legend labels will say methods = ['Transit', 'Radial Velocity',] # markers and colors in the same order as the missions above markers = ['circle', 'square', 'triangle', 'diamond', 'inverted_triangle'] # colorblind friendly palette from https://personal.sron.nl/~pault/ # other ideas: # https://thenode.biologists.com/data-visualization-with-flying-colors/research/ colors = ['#228833', '#ee6677', '#ccbb44', '#aa3377', '#4477aa', '#aaaaaa', '#66ccee'] # output files embedfile = '_includes/radius_tsm_embed.html' fullfile = '_includes/radius_tsm.html' # set up the full output file plotting.output_file(fullfile, title='Radius Mass Plot') # load the data dfcon, dfkoi, dfk2, dftoi = load_data() # what to display when hovering over a data point TOOLTIPS = [ ("Planet", "@planet"), # only give the decimal and sig figs if needed ("Period", "@period{0,0[.][0000]} days"), ("Radius", "@radius_e{0,0[.][00]} Earth; @jupradius{0,0[.][0000]} Jup"), ("Mass", "@mass{0,0[.][00]} Earth; @jupmass{0,0[.][0000]} Jup"), ("TSM","@TSM{0,0[.][000]}"), ("Discovered via", "@method") ] # create the figure fig = plotting.figure(x_axis_type='log', y_axis_type='log', tooltips=TOOLTIPS) # allow for something to happen when you click on data points fig.add_tools(TapTool()) # need to store min and max radius values to create the second axis ymin = 1 ymax = 1 # save the output plots to rearrange them in the legend glyphs = [] counts = [] for ii, imeth in enumerate(methods): # select the appropriate set of planets for each mission if imeth == 'Other': good = ((~np.in1d(dfcon['pl_discmethod'], methods)) & (~dfcon['pl_discmethod'].str.contains('Timing')) & np.isfinite(dfcon['pl_bmasse']) & np.isfinite(dfcon['pl_rade']) & np.isfinite(dfcon['pl_eqt']) & np.isfinite(dfcon['st_rad']) & np.isfinite(dfcon['st_j']) & np.isfinite(dfcon['pl_orbper'])) elif imeth == 'Timing Variations': good = (dfcon['pl_discmethod'].str.contains('Timing') & np.isfinite(dfcon['pl_bmasse']) & np.isfinite(dfcon['pl_rade']) & np.isfinite(dfcon['pl_eqt']) & np.isfinite(dfcon['st_rad']) & np.isfinite(dfcon['st_j']) & np.isfinite(dfcon['pl_orbper'])) else: good = ((dfcon['pl_discmethod'] == imeth) & np.isfinite(dfcon['pl_bmasse']) & np.isfinite(dfcon['pl_rade']) & np.isfinite(dfcon['pl_eqt']) & np.isfinite(dfcon['st_rad']) & np.isfinite(dfcon['st_j']) & np.isfinite(dfcon['pl_orbper'])) scale_factor = np.zeros((dfcon['pl_rade'][good]).size) + 1.15 # base case scale_factor[dfcon['pl_rade'][good] < 1.5] = 0.190 scale_factor[(1.5 <= dfcon['pl_rade'][good]) & (dfcon['pl_rade'][good] < 2.75)] = 1.26 scale_factor[(2.75 <= dfcon['pl_rade'][good]) & (dfcon['pl_rade'][good] < 4)] = 1.28 #if dfcon['pl_rade'] < 1.5: # Scale_Factor = .190 #elif 1.5<dfcon['pl_rade']<2.75: # Scale_Factor = 1.26 #elif 2.75<dfcon['pl_rade']<4: # Scale_Factor = 1.28 #else: # Scale_Factor = 1.15 # make the alpha of large groups lower so they don't dominate so much alpha = 1. - good.sum()/1000. alpha = max(0.2, alpha) # what the hover tooltip draws its values from source = plotting.ColumnDataSource(data=dict( planet=dfcon['pl_name'][good], period=dfcon['pl_orbper'][good], host=dfcon['pl_hostname'][good], mass=dfcon['pl_bmasse'][good], method=dfcon['pl_discmethod'][good], jupmass=dfcon['pl_bmassj'][good], jupradius=dfcon['pl_radj'][good], radius_e=dfcon['pl_rade'][good], equil_temp=dfcon['pl_eqt'][good], radius_sun=dfcon['st_rad'][good], mag_star=dfcon['st_j'][good], TSM=scale_factor* ((((dfcon['pl_rade'][good])**3)*(dfcon['pl_eqt'][good]))/((dfcon['pl_bmasse'][good])*(dfcon['st_rad'][good])**2))*(10**(-1*(dfcon['st_j'][good])/5)), url=dfcon['url'][good] )) print(imeth, ': ', good.sum()) counts.append(f'{good.sum():,}') # plot the planets # nonselection stuff is needed to prevent planets in that category from # disappearing when you click on a data point ("select" it) glyph = fig.scatter('radius_e', 'TSM', color=colors[ii], source=source, size=8, alpha=alpha, marker=markers[ii], nonselection_alpha=alpha, nonselection_color=colors[ii]) glyphs.append(glyph) # save the global min/max ymin = min(ymin, source.data['mass'].min()) ymax = max(ymax, source.data['mass'].max()) # set up where to send people when they click on a planet url = "@url" taptool = fig.select(TapTool) taptool.callback = OpenURL(url=url) # figure out what the default axis limits are ydiff = np.log10(ymax) - np.log10(ymin) ystart = 10.**(np.log10(ymin) - 0.05*ydiff) yend = 10.**(np.log10(ymax) + 0.05*ydiff) # jupiter/earth mass ratio massratio = 317.8 # add the first y-axis's label and use our custom log formatting for both axes fig.yaxis.axis_label = 'TSM' fig.yaxis.formatter = FuncTickFormatter(code=log_axis_labels()) # add the x-axis's label and use our custom log formatting fig.xaxis.axis_label = 'Radius (Earth Radii)' fig.xaxis.formatter = FuncTickFormatter(code=log_axis_labels()) # set up all the legend objects items = [LegendItem(label=ii + f' ({counts[methods.index(ii)]})', renderers=[jj]) for ii, jj in zip(methods, glyphs)] # create the legend legend = Legend(items=items, location="center") legend.title = 'Discovered via' legend.spacing = 10 legend.margin = 8 fig.add_layout(legend, 'above') # overall figure title fig.title.text = 'Confirmed Planets' # create the three lines of credit text in the two bottom corners label_opts1 = dict( x=-84, y=42, x_units='screen', y_units='screen' ) label_opts2 = dict( x=-84, y=47, x_units='screen', y_units='screen' ) label_opts3 = dict( x=612, y=64, x_units='screen', y_units='screen', text_align='right', text_font_size='9pt' ) msg1 = 'By Exoplots' # when did the data last get updated modtimestr = get_update_time().strftime('%Y %b %d') msg3 = 'Data: NASA Exoplanet Archive' caption1 = Label(text=msg1, **label_opts1) caption2 = Label(text=modtimestr, **label_opts2) caption3 = Label(text=msg3, **label_opts3) fig.add_layout(caption1, 'below') fig.add_layout(caption2, 'below') fig.add_layout(caption3, 'below') plotting.save(fig) # save the individual pieces so we can just embed the figure without the whole # html page script, div = components(fig, theme=theme) with open(embedfile, 'w') as ff: ff.write(script) ff.write(div)
the-stack_106_29238
from typing import Set import logging from pathlib import Path import itertools as it import re from zensols.config import YamlConfig logger = logging.getLogger(__name__) class AppConfig(YamlConfig): """Application specific configuration access and parsing. Since much of the application centers around configuration of what to persist, this class does more heavy lifting than most configuraetion like classes. """ ROOT = 'discover' OBJECTS_PATH = f'{ROOT}.objects' PROFILES_PATH = f'{ROOT}.profiles' EMPTY_DIR_PATH = f'{ROOT}.empty_dirs' OBJECTS_PROFILE_PATH = f'{PROFILES_PATH}.{{}}.objects' EMPTY_DIR_PROFILE_PATH = f'{PROFILES_PATH}.{{}}.empty_dirs' def __init__(self, config_file=None, default_vars=None): super(AppConfig, self).__init__( config_file, delimiter='^', default_vars=default_vars) @property def _find_profiles(self): opts = self.get_options(self.PROFILES_PATH, expect=False) if opts is None: opts = () return opts @property def all_profiles(self) -> Set[str]: return set(self._find_profiles.keys()) @staticmethod def _split_profiles(profile_str): return re.split(r'\s*,\s*', profile_str) @property def _default_profiles(self): strlist = self.get_option( f'{self.ROOT}.default_profiles', expect=False) if strlist is not None: return self._split_profiles(strlist) def get_profiles(self, profile_overide_str): if profile_overide_str is None: profiles = self._default_profiles else: profiles = self._split_profiles(profile_overide_str) if profiles is None: profiles = self._find_profiles profiles = list(profiles) # protect user error if 'default' not in profiles: profiles = ['default'] + list(profiles) if 'nodefault' in profiles: profiles.pop(profiles.index('default')) profiles.pop(profiles.index('nodefault')) return profiles def _iterate_objects(self, profile): if profile == 'default': path = self.OBJECTS_PATH else: path = self.OBJECTS_PROFILE_PATH.format(profile) opts = self.get_options(path, expect=False) if opts is None and profile == 'default': opts = () if opts is None: logger.warning( f'no such profile for objects: {profile} for path {path}' + '--maybe entries exist in other profiles') opts = () return map(lambda x: x.strip(), opts) def get_discoverable_objects(self, profiles): return it.chain(*map(self._iterate_objects, profiles)) def get_empty_dirs(self, profiles): paths = [] for profile in profiles: if profile == 'default': path = self.EMPTY_DIR_PATH else: path = self.EMPTY_DIR_PROFILE_PATH.format(profile) opts = self.get_options(path) if opts is None: ## warnings for missing empty directory entries is worth it # logger.warning( # f'no such profile for objects: {profile} for path {path}' + # '--maybe entries exist in other profiles') pass else: paths.extend(opts) return map(lambda x: Path(x).expanduser().absolute(), paths) def _get_path(self, name): return Path(self.get_option(name, expect=True)).expanduser().absolute() @property def dist_dir(self): return self._get_path(f'{self.ROOT}.local.dist_dir') @dist_dir.setter def dist_dir(self, dist_dir): if self.default_vars is None: self.default_vars = {} self.default_vars[f'{self.ROOT}.local.dist_dir'] = dist_dir @property def wheel_dir_name(self): return self._get_path(f'{self.ROOT}.local.wheels_dir') @property def bootstrap_script_file(self): return Path(self.dist_dir, 'bootstrap.sh')
the-stack_106_29239
""" ============== SGD: Penalties ============== Contours of where the penalty is equal to 1 for the three penalties L1, L2 and elastic-net. All of the above are supported by :class:`sklearn.linear_model.stochastic_gradient`. """ print(__doc__) import numpy as np import matplotlib.pyplot as plt l1_color = "navy" l2_color = "c" elastic_net_color = "darkorange" line = np.linspace(-1.5, 1.5, 1001) xx, yy = np.meshgrid(line, line) l2 = xx ** 2 + yy ** 2 l1 = np.abs(xx) + np.abs(yy) rho = 0.5 elastic_net = rho * l1 + (1 - rho) * l2 plt.figure(figsize=(10, 10), dpi=100) ax = plt.gca() elastic_net_contour = plt.contour(xx, yy, elastic_net, levels=[1], colors=elastic_net_color) l2_contour = plt.contour(xx, yy, l2, levels=[1], colors=l2_color) l1_contour = plt.contour(xx, yy, l1, levels=[1], colors=l1_color) ax.set_aspect("equal") ax.spines['left'].set_position('center') ax.spines['right'].set_color('none') ax.spines['bottom'].set_position('center') ax.spines['top'].set_color('none') plt.clabel(elastic_net_contour, inline=1, fontsize=18, fmt={1.0: 'elastic-net'}, manual=[(-1, -1)]) plt.clabel(l2_contour, inline=1, fontsize=18, fmt={1.0: 'L2'}, manual=[(-1, -1)]) plt.clabel(l1_contour, inline=1, fontsize=18, fmt={1.0: 'L1'}, manual=[(-1, -1)]) plt.tight_layout() plt.show()
the-stack_106_29241
# -*- coding: utf-8 -*- """VGG16 model for Keras. # Reference - [Very Deep Convolutional Networks for Large-Scale Image Recognition](https://arxiv.org/abs/1409.1556) """ from __future__ import print_function from __future__ import absolute_import from __future__ import division import warnings from keras.models import Model from keras.layers import Flatten, Dense, Input, Conv2D, MaxPooling2D, Dropout from keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D, TimeDistributed from keras.engine.topology import get_source_inputs from keras.utils import layer_utils from keras.utils.data_utils import get_file from keras import backend as K from keras_frcnn.RoiPoolingConv import RoiPoolingConv def get_weight_path(): if K.image_dim_ordering() == 'th': print('pretrained weights not available for VGG with theano backend') return else: return 'vgg16_weights_tf_dim_ordering_tf_kernels.h5' def get_img_output_length(width, height): def get_output_length(input_length): return input_length//16 return get_output_length(width), get_output_length(height) def nn_base(input_tensor=None, trainable=False): ''' 输入向量 没用,可删去 ''' # Determine proper input shape if K.image_dim_ordering() == 'th': input_shape = (3, None, None) else: input_shape = (None, None, 3) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if K.image_dim_ordering() == 'tf': bn_axis = 3 else: bn_axis = 1 # Block 1 x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) # Block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) # Block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x) # x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x) return x def rpn(base_layers, num_anchors): ''' 定义RPN网络(区域预选网络) x_class:每一个锚点属于前景还是背景【注:这里使用的是sigmoid激活函数所以其输出的通道数是num_anchors】 x_regr:每一个锚点对应的回归梯度 ''' x = Conv2D(512, (3, 3), padding='same', activation='relu', kernel_initializer='normal', name='rpn_conv1')(base_layers) x_class = Conv2D(num_anchors, (1, 1), activation='sigmoid', kernel_initializer='uniform', name='rpn_out_class')(x) x_regr = Conv2D(num_anchors * 4, (1, 1), activation='linear', kernel_initializer='zero', name='rpn_out_regress')(x) return [x_class, x_regr, base_layers] def classifier(base_layers, input_rois, num_rois, nb_classes = 21, trainable=False): ''' RoiPoolingConv:返回的shape为(1, 32, 7, 7, 512)含义是batch_size,预选框的个数,特征图宽,特征图高度,特征图深度 TimeDistributed:输入至少为3D张量,下标为1的维度将被认为是时间维。即对以一个维度下的变量当作一个完整变量来看待本文是32。你要实现的目的就是对32个预选宽提出的32个图片做出判断。 out_class的shape:(?, 32, 21);out_regr的shape:(?, 32, 80) ''' # compile times on theano tend to be very high, so we use smaller ROI pooling regions to workaround if K.backend() == 'tensorflow': pooling_regions = 7 input_shape = (num_rois,7,7,512) elif K.backend() == 'theano': pooling_regions = 7 input_shape = (num_rois,512,7,7) out_roi_pool = RoiPoolingConv(pooling_regions, num_rois)([base_layers, input_rois]) out = TimeDistributed(Flatten(name='flatten'))(out_roi_pool) out = TimeDistributed(Dense(4096, activation='relu', name='fc1'))(out) out = TimeDistributed(Dropout(0.5))(out) out = TimeDistributed(Dense(4096, activation='relu', name='fc2'))(out) out = TimeDistributed(Dropout(0.5))(out) out_class = TimeDistributed(Dense(nb_classes, activation='softmax', kernel_initializer='zero'), name='dense_class_{}'.format(nb_classes))(out) # note: no regression target for bg class out_regr = TimeDistributed(Dense(4 * (nb_classes-1), activation='linear', kernel_initializer='zero'), name='dense_regress_{}'.format(nb_classes))(out) return [out_class, out_regr]
the-stack_106_29242
#!/usr/bin/env python # Copyright 2016 gRPC authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Run performance tests locally or remotely.""" from __future__ import print_function import argparse import collections import itertools import json import multiprocessing import os import pipes import re import subprocess import sys import tempfile import time import traceback import uuid import six import performance.scenario_config as scenario_config import python_utils.jobset as jobset import python_utils.report_utils as report_utils _ROOT = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '../..')) os.chdir(_ROOT) _REMOTE_HOST_USERNAME = 'jenkins' class QpsWorkerJob: """Encapsulates a qps worker server job.""" def __init__(self, spec, language, host_and_port, perf_file_base_name=None): self._spec = spec self.language = language self.host_and_port = host_and_port self._job = None self.perf_file_base_name = perf_file_base_name def start(self): self._job = jobset.Job( self._spec, newline_on_success=True, travis=True, add_env={}) def is_running(self): """Polls a job and returns True if given job is still running.""" return self._job and self._job.state() == jobset._RUNNING def kill(self): if self._job: self._job.kill() self._job = None def create_qpsworker_job(language, shortname=None, port=10000, remote_host=None, perf_cmd=None): cmdline = (language.worker_cmdline() + ['--driver_port=%s' % port]) if remote_host: host_and_port = '%s:%s' % (remote_host, port) else: host_and_port = 'localhost:%s' % port perf_file_base_name = None if perf_cmd: perf_file_base_name = '%s-%s' % (host_and_port, shortname) # specify -o output file so perf.data gets collected when worker stopped cmdline = perf_cmd + ['-o', '%s-perf.data' % perf_file_base_name ] + cmdline worker_timeout = 3 * 60 if remote_host: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, remote_host) ssh_cmd = ['ssh'] cmdline = ['timeout', '%s' % (worker_timeout + 30)] + cmdline ssh_cmd.extend([ str(user_at_host), 'cd ~/performance_workspace/grpc/ && python tools/run_tests/start_port_server.py && %s' % ' '.join(cmdline) ]) cmdline = ssh_cmd jobspec = jobset.JobSpec( cmdline=cmdline, shortname=shortname, timeout_seconds= worker_timeout, # workers get restarted after each scenario verbose_success=True) return QpsWorkerJob(jobspec, language, host_and_port, perf_file_base_name) def create_scenario_jobspec(scenario_json, workers, remote_host=None, bq_result_table=None, server_cpu_load=0): """Runs one scenario using QPS driver.""" # setting QPS_WORKERS env variable here makes sure it works with SSH too. cmd = 'QPS_WORKERS="%s" ' % ','.join(workers) if bq_result_table: cmd += 'BQ_RESULT_TABLE="%s" ' % bq_result_table cmd += 'tools/run_tests/performance/run_qps_driver.sh ' cmd += '--scenarios_json=%s ' % pipes.quote( json.dumps({ 'scenarios': [scenario_json] })) cmd += '--scenario_result_file=scenario_result.json ' if server_cpu_load != 0: cmd += '--search_param=offered_load --initial_search_value=1000 --targeted_cpu_load=%d --stride=500 --error_tolerance=0.01' % server_cpu_load if remote_host: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, remote_host) cmd = 'ssh %s "cd ~/performance_workspace/grpc/ && "%s' % ( user_at_host, pipes.quote(cmd)) return jobset.JobSpec( cmdline=[cmd], shortname='qps_json_driver.%s' % scenario_json['name'], timeout_seconds=12 * 60, shell=True, verbose_success=True) def create_quit_jobspec(workers, remote_host=None): """Runs quit using QPS driver.""" # setting QPS_WORKERS env variable here makes sure it works with SSH too. cmd = 'QPS_WORKERS="%s" bins/opt/qps_json_driver --quit' % ','.join( w.host_and_port for w in workers) if remote_host: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, remote_host) cmd = 'ssh %s "cd ~/performance_workspace/grpc/ && "%s' % ( user_at_host, pipes.quote(cmd)) return jobset.JobSpec( cmdline=[cmd], shortname='qps_json_driver.quit', timeout_seconds=3 * 60, shell=True, verbose_success=True) def create_netperf_jobspec(server_host='localhost', client_host=None, bq_result_table=None): """Runs netperf benchmark.""" cmd = 'NETPERF_SERVER_HOST="%s" ' % server_host if bq_result_table: cmd += 'BQ_RESULT_TABLE="%s" ' % bq_result_table if client_host: # If netperf is running remotely, the env variables populated by Jenkins # won't be available on the client, but we need them for uploading results # to BigQuery. jenkins_job_name = os.getenv('JOB_NAME') if jenkins_job_name: cmd += 'JOB_NAME="%s" ' % jenkins_job_name jenkins_build_number = os.getenv('BUILD_NUMBER') if jenkins_build_number: cmd += 'BUILD_NUMBER="%s" ' % jenkins_build_number cmd += 'tools/run_tests/performance/run_netperf.sh' if client_host: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, client_host) cmd = 'ssh %s "cd ~/performance_workspace/grpc/ && "%s' % ( user_at_host, pipes.quote(cmd)) return jobset.JobSpec( cmdline=[cmd], shortname='netperf', timeout_seconds=60, shell=True, verbose_success=True) def archive_repo(languages): """Archives local version of repo including submodules.""" # Directory contains symlinks that can't be correctly untarred on Windows # so we just skip them as a workaround. # See https://github.com/grpc/grpc/issues/16334 bad_symlinks_dir = '../grpc/third_party/libcxx/test/std/experimental/filesystem/Inputs/static_test_env' cmdline = [ 'tar', '--exclude', bad_symlinks_dir, '-cf', '../grpc.tar', '../grpc/' ] if 'java' in languages: cmdline.append('../grpc-java') if 'go' in languages: cmdline.append('../grpc-go') if 'node' in languages or 'node_purejs' in languages: cmdline.append('../grpc-node') archive_job = jobset.JobSpec( cmdline=cmdline, shortname='archive_repo', timeout_seconds=3 * 60) jobset.message('START', 'Archiving local repository.', do_newline=True) num_failures, _ = jobset.run( [archive_job], newline_on_success=True, maxjobs=1) if num_failures == 0: jobset.message( 'SUCCESS', 'Archive with local repository created successfully.', do_newline=True) else: jobset.message( 'FAILED', 'Failed to archive local repository.', do_newline=True) sys.exit(1) def prepare_remote_hosts(hosts, prepare_local=False): """Prepares remote hosts (and maybe prepare localhost as well).""" prepare_timeout = 10 * 60 prepare_jobs = [] for host in hosts: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, host) prepare_jobs.append( jobset.JobSpec( cmdline=['tools/run_tests/performance/remote_host_prepare.sh'], shortname='remote_host_prepare.%s' % host, environ={'USER_AT_HOST': user_at_host}, timeout_seconds=prepare_timeout)) if prepare_local: # Prepare localhost as well prepare_jobs.append( jobset.JobSpec( cmdline=['tools/run_tests/performance/kill_workers.sh'], shortname='local_prepare', timeout_seconds=prepare_timeout)) jobset.message('START', 'Preparing hosts.', do_newline=True) num_failures, _ = jobset.run( prepare_jobs, newline_on_success=True, maxjobs=10) if num_failures == 0: jobset.message( 'SUCCESS', 'Prepare step completed successfully.', do_newline=True) else: jobset.message( 'FAILED', 'Failed to prepare remote hosts.', do_newline=True) sys.exit(1) def build_on_remote_hosts(hosts, languages=scenario_config.LANGUAGES.keys(), build_local=False): """Builds performance worker on remote hosts (and maybe also locally).""" build_timeout = 45 * 60 # Kokoro VMs (which are local only) do not have caching, so they need more time to build local_build_timeout = 60 * 60 build_jobs = [] for host in hosts: user_at_host = '%s@%s' % (_REMOTE_HOST_USERNAME, host) build_jobs.append( jobset.JobSpec( cmdline=['tools/run_tests/performance/remote_host_build.sh'] + languages, shortname='remote_host_build.%s' % host, environ={'USER_AT_HOST': user_at_host, 'CONFIG': 'opt'}, timeout_seconds=build_timeout)) if build_local: # Build locally as well build_jobs.append( jobset.JobSpec( cmdline=['tools/run_tests/performance/build_performance.sh'] + languages, shortname='local_build', environ={'CONFIG': 'opt'}, timeout_seconds=local_build_timeout)) jobset.message('START', 'Building.', do_newline=True) num_failures, _ = jobset.run( build_jobs, newline_on_success=True, maxjobs=10) if num_failures == 0: jobset.message('SUCCESS', 'Built successfully.', do_newline=True) else: jobset.message('FAILED', 'Build failed.', do_newline=True) sys.exit(1) def create_qpsworkers(languages, worker_hosts, perf_cmd=None): """Creates QPS workers (but does not start them).""" if not worker_hosts: # run two workers locally (for each language) workers = [(None, 10000), (None, 10010)] elif len(worker_hosts) == 1: # run two workers on the remote host (for each language) workers = [(worker_hosts[0], 10000), (worker_hosts[0], 10010)] else: # run one worker per each remote host (for each language) workers = [(worker_host, 10000) for worker_host in worker_hosts] return [ create_qpsworker_job( language, shortname='qps_worker_%s_%s' % (language, worker_idx), port=worker[1] + language.worker_port_offset(), remote_host=worker[0], perf_cmd=perf_cmd) for language in languages for worker_idx, worker in enumerate(workers) ] def perf_report_processor_job(worker_host, perf_base_name, output_filename, flame_graph_reports): print('Creating perf report collection job for %s' % worker_host) cmd = '' if worker_host != 'localhost': user_at_host = "%s@%s" % (_REMOTE_HOST_USERNAME, worker_host) cmd = "USER_AT_HOST=%s OUTPUT_FILENAME=%s OUTPUT_DIR=%s PERF_BASE_NAME=%stools/run_tests/performance/process_remote_perf_flamegraphs.sh" % ( user_at_host, output_filename, flame_graph_reports, perf_base_name) else: cmd = "OUTPUT_FILENAME=%s OUTPUT_DIR=%s PERF_BASE_NAME=%stools/run_tests/performance/process_local_perf_flamegraphs.sh" % ( output_filename, flame_graph_reports, perf_base_name) return jobset.JobSpec( cmdline=cmd, timeout_seconds=3 * 60, shell=True, verbose_success=True, shortname='process perf report') Scenario = collections.namedtuple('Scenario', 'jobspec workers name') def create_scenarios(languages, workers_by_lang, remote_host=None, regex='.*', category='all', bq_result_table=None, netperf=False, netperf_hosts=[], server_cpu_load=0): """Create jobspecs for scenarios to run.""" all_workers = [ worker for workers in workers_by_lang.values() for worker in workers ] scenarios = [] _NO_WORKERS = [] if netperf: if not netperf_hosts: netperf_server = 'localhost' netperf_client = None elif len(netperf_hosts) == 1: netperf_server = netperf_hosts[0] netperf_client = netperf_hosts[0] else: netperf_server = netperf_hosts[0] netperf_client = netperf_hosts[1] scenarios.append( Scenario( create_netperf_jobspec( server_host=netperf_server, client_host=netperf_client, bq_result_table=bq_result_table), _NO_WORKERS, 'netperf')) for language in languages: for scenario_json in language.scenarios(): if re.search(regex, scenario_json['name']): categories = scenario_json.get('CATEGORIES', ['scalable', 'smoketest']) if category in categories or category == 'all': workers = workers_by_lang[str(language)][:] # 'SERVER_LANGUAGE' is an indicator for this script to pick # a server in different language. custom_server_lang = scenario_json.get( 'SERVER_LANGUAGE', None) custom_client_lang = scenario_json.get( 'CLIENT_LANGUAGE', None) scenario_json = scenario_config.remove_nonproto_fields( scenario_json) if custom_server_lang and custom_client_lang: raise Exception( 'Cannot set both custom CLIENT_LANGUAGE and SERVER_LANGUAGE' 'in the same scenario') if custom_server_lang: if not workers_by_lang.get(custom_server_lang, []): print('Warning: Skipping scenario %s as' % scenario_json['name']) print( 'SERVER_LANGUAGE is set to %s yet the language has ' 'not been selected with -l' % custom_server_lang) continue for idx in range(0, scenario_json['num_servers']): # replace first X workers by workers of a different language workers[idx] = workers_by_lang[custom_server_lang][ idx] if custom_client_lang: if not workers_by_lang.get(custom_client_lang, []): print('Warning: Skipping scenario %s as' % scenario_json['name']) print( 'CLIENT_LANGUAGE is set to %s yet the language has ' 'not been selected with -l' % custom_client_lang) continue for idx in range(scenario_json['num_servers'], len(workers)): # replace all client workers by workers of a different language, # leave num_server workers as they are server workers. workers[idx] = workers_by_lang[custom_client_lang][ idx] scenario = Scenario( create_scenario_jobspec( scenario_json, [w.host_and_port for w in workers], remote_host=remote_host, bq_result_table=bq_result_table, server_cpu_load=server_cpu_load), workers, scenario_json['name']) scenarios.append(scenario) return scenarios def finish_qps_workers(jobs, qpsworker_jobs): """Waits for given jobs to finish and eventually kills them.""" retries = 0 num_killed = 0 while any(job.is_running() for job in jobs): for job in qpsworker_jobs: if job.is_running(): print('QPS worker "%s" is still running.' % job.host_and_port) if retries > 10: print('Killing all QPS workers.') for job in jobs: job.kill() num_killed += 1 retries += 1 time.sleep(3) print('All QPS workers finished.') return num_killed profile_output_files = [] # Collect perf text reports and flamegraphs if perf_cmd was used # Note the base names of perf text reports are used when creating and processing # perf data. The scenario name uniqifies the output name in the final # perf reports directory. # Alos, the perf profiles need to be fetched and processed after each scenario # in order to avoid clobbering the output files. def run_collect_perf_profile_jobs(hosts_and_base_names, scenario_name, flame_graph_reports): perf_report_jobs = [] global profile_output_files for host_and_port in hosts_and_base_names: perf_base_name = hosts_and_base_names[host_and_port] output_filename = '%s-%s' % (scenario_name, perf_base_name) # from the base filename, create .svg output filename host = host_and_port.split(':')[0] profile_output_files.append('%s.svg' % output_filename) perf_report_jobs.append( perf_report_processor_job(host, perf_base_name, output_filename, flame_graph_reports)) jobset.message( 'START', 'Collecting perf reports from qps workers', do_newline=True) failures, _ = jobset.run( perf_report_jobs, newline_on_success=True, maxjobs=1) jobset.message( 'END', 'Collecting perf reports from qps workers', do_newline=True) return failures def main(): argp = argparse.ArgumentParser(description='Run performance tests.') argp.add_argument( '-l', '--language', choices=['all'] + sorted(scenario_config.LANGUAGES.keys()), nargs='+', required=True, help='Languages to benchmark.') argp.add_argument( '--remote_driver_host', default=None, help= 'Run QPS driver on given host. By default, QPS driver is run locally.') argp.add_argument( '--remote_worker_host', nargs='+', default=[], help='Worker hosts where to start QPS workers.') argp.add_argument( '--dry_run', default=False, action='store_const', const=True, help='Just list scenarios to be run, but don\'t run them.') argp.add_argument( '-r', '--regex', default='.*', type=str, help='Regex to select scenarios to run.') argp.add_argument( '--bq_result_table', default=None, type=str, help='Bigquery "dataset.table" to upload results to.') argp.add_argument( '--category', choices=['smoketest', 'all', 'scalable', 'sweep'], default='all', help='Select a category of tests to run.') argp.add_argument( '--netperf', default=False, action='store_const', const=True, help='Run netperf benchmark as one of the scenarios.') argp.add_argument( '--server_cpu_load', default=0, type=int, help='Select a targeted server cpu load to run. 0 means ignore this flag' ) argp.add_argument( '-x', '--xml_report', default='report.xml', type=str, help='Name of XML report file to generate.') argp.add_argument( '--perf_args', help=('Example usage: "--perf_args=record -F 99 -g". ' 'Wrap QPS workers in a perf command ' 'with the arguments to perf specified here. ' '".svg" flame graph profiles will be ' 'created for each Qps Worker on each scenario. ' 'Files will output to "<repo_root>/<args.flame_graph_reports>" ' 'directory. Output files from running the worker ' 'under perf are saved in the repo root where its ran. ' 'Note that the perf "-g" flag is necessary for ' 'flame graphs generation to work (assuming the binary ' 'being profiled uses frame pointers, check out ' '"--call-graph dwarf" option using libunwind otherwise.) ' 'Also note that the entire "--perf_args=<arg(s)>" must ' 'be wrapped in quotes as in the example usage. ' 'If the "--perg_args" is unspecified, "perf" will ' 'not be used at all. ' 'See http://www.brendangregg.com/perf.html ' 'for more general perf examples.')) argp.add_argument( '--skip_generate_flamegraphs', default=False, action='store_const', const=True, help=('Turn flame graph generation off. ' 'May be useful if "perf_args" arguments do not make sense for ' 'generating flamegraphs (e.g., "--perf_args=stat ...")')) argp.add_argument( '-f', '--flame_graph_reports', default='perf_reports', type=str, help= 'Name of directory to output flame graph profiles to, if any are created.' ) argp.add_argument( '-u', '--remote_host_username', default='', type=str, help='Use a username that isn\'t "Jenkins" to SSH into remote workers.') args = argp.parse_args() global _REMOTE_HOST_USERNAME if args.remote_host_username: _REMOTE_HOST_USERNAME = args.remote_host_username languages = set( scenario_config.LANGUAGES[l] for l in itertools.chain.from_iterable( six.iterkeys(scenario_config.LANGUAGES) if x == 'all' else [x] for x in args.language)) # Put together set of remote hosts where to run and build remote_hosts = set() if args.remote_worker_host: for host in args.remote_worker_host: remote_hosts.add(host) if args.remote_driver_host: remote_hosts.add(args.remote_driver_host) if not args.dry_run: if remote_hosts: archive_repo(languages=[str(l) for l in languages]) prepare_remote_hosts(remote_hosts, prepare_local=True) else: prepare_remote_hosts([], prepare_local=True) build_local = False if not args.remote_driver_host: build_local = True if not args.dry_run: build_on_remote_hosts( remote_hosts, languages=[str(l) for l in languages], build_local=build_local) perf_cmd = None if args.perf_args: print('Running workers under perf profiler') # Expect /usr/bin/perf to be installed here, as is usual perf_cmd = ['/usr/bin/perf'] perf_cmd.extend(re.split('\s+', args.perf_args)) qpsworker_jobs = create_qpsworkers( languages, args.remote_worker_host, perf_cmd=perf_cmd) # get list of worker addresses for each language. workers_by_lang = dict([(str(language), []) for language in languages]) for job in qpsworker_jobs: workers_by_lang[str(job.language)].append(job) scenarios = create_scenarios( languages, workers_by_lang=workers_by_lang, remote_host=args.remote_driver_host, regex=args.regex, category=args.category, bq_result_table=args.bq_result_table, netperf=args.netperf, netperf_hosts=args.remote_worker_host, server_cpu_load=args.server_cpu_load) if not scenarios: raise Exception('No scenarios to run') total_scenario_failures = 0 qps_workers_killed = 0 merged_resultset = {} perf_report_failures = 0 for scenario in scenarios: if args.dry_run: print(scenario.name) else: scenario_failures = 0 try: for worker in scenario.workers: worker.start() jobs = [scenario.jobspec] if scenario.workers: jobs.append( create_quit_jobspec( scenario.workers, remote_host=args.remote_driver_host)) scenario_failures, resultset = jobset.run( jobs, newline_on_success=True, maxjobs=1) total_scenario_failures += scenario_failures merged_resultset = dict( itertools.chain( six.iteritems(merged_resultset), six.iteritems(resultset))) finally: # Consider qps workers that need to be killed as failures qps_workers_killed += finish_qps_workers( scenario.workers, qpsworker_jobs) if perf_cmd and scenario_failures == 0 and not args.skip_generate_flamegraphs: workers_and_base_names = {} for worker in scenario.workers: if not worker.perf_file_base_name: raise Exception( 'using perf buf perf report filename is unspecified' ) workers_and_base_names[ worker.host_and_port] = worker.perf_file_base_name perf_report_failures += run_collect_perf_profile_jobs( workers_and_base_names, scenario.name, args.flame_graph_reports) # Still write the index.html even if some scenarios failed. # 'profile_output_files' will only have names for scenarios that passed if perf_cmd and not args.skip_generate_flamegraphs: # write the index fil to the output dir, with all profiles from all scenarios/workers report_utils.render_perf_profiling_results( '%s/index.html' % args.flame_graph_reports, profile_output_files) report_utils.render_junit_xml_report( merged_resultset, args.xml_report, suite_name='benchmarks') if total_scenario_failures > 0 or qps_workers_killed > 0: print('%s scenarios failed and %s qps worker jobs killed' % (total_scenario_failures, qps_workers_killed)) sys.exit(1) if perf_report_failures > 0: print('%s perf profile collection jobs failed' % perf_report_failures) sys.exit(1) if __name__ == "__main__": main()
the-stack_106_29243
''' Created on Apr 1, 2015 @author: bgt ''' import unittest import github from GitHubDao import GitHubDao import NonSomeFinder class FunctionalityTest(unittest.TestCase): def setUp(self): self.positiveCase="sferik/twitter" self.negativeCase="tomibgt/GitHubResearchDataMiner" self.urlToParse="http://tucs.fi/bgt/github.html" self.gitDao = GitHubDao() ''' Issue #1 ''' def testPositiveTwitter(self): self.assertTrue(self.gitDao.usesTwitter(self.positiveCase)[0], self.positiveCase+" not detected as positive case.") def testNegativeTwitter(self): self.assertFalse(self.gitDao.usesTwitter(self.negativeCase)[0], self.negativeCase+" not detected as negative case.") ''' Issue #2 ''' def testUrlParsing(self): result = self.gitDao.parseRepositoriesFromUrl(self.urlToParse) self.assertTrue(len(result)==2, "The parser failed to detect two URLs on the test page : "+str(len(result))) self.assertEqual(result[0], "sferik/twitter", "Missparsed sferik/twitter : "+result[0]) self.assertEqual(result[1], "tomibgt/GitHubResearchDataMiner", "Missparsed tomibgt/GitHubResearchDataMiner : "+result[1]) ''' Issue #3 ''' def testRepositorySearch(self): result = self.gitDao.findRepositoryNamesWithSearchPhrase("pygithub") count = 0 foo = False for repo in result: count += 1 if repo.id == 3544490: foo = True self.assertGreaterEqual(count, 15, "There should be at least 15 repositories discovered with keyphrase 'pygithub'? Found "+str(count)) self.assertTrue(foo, "Couldn't find the PyGithub/PyGithub project (id 3544490)") ''' Issue #5 ''' def testAnalysisOfBlockedRepository(self): testrepo = self.gitDao.github.get_repo("bs/starling") testlist = [testrepo] NonSomeFinder.analyseRepositories(testlist) if __name__ == "__main__": #import sys;sys.argv = ['', 'Test.testName'] unittest.main()
the-stack_106_29244
from complementos import * eps = 1e-10 #1 def Leer_Datos(filename): df = pd.read_csv(filename, sep = "\t") np_arr = df.to_numpy() np_arr = np_arr.T temp = [np.ones(np_arr.shape[1]).tolist()] for i in np_arr: temp.append(i.tolist()) answer = np.asarray(temp) return answer #2 def Normalizar_Datos(np_arr): Media, Desviacion = desviacion_estandar_2(np_arr[1:-1]) np_arr[1:-1] = (np_arr[1:-1] - Media) / Desviacion return np_arr, Media, Desviacion def Normalizar_Datos_MD(np_arr, Media, Desviacion): np_arr[1:-1] = (np_arr[1:-1] - Media) / Desviacion return answer #3 def Sigmoidal(X, theta): return 1/(1 + np.exp(-np.dot(theta.T, X) + eps) + eps) #4 def Calcular_Funcion_Costo(X, theta, Y): return -np.sum(Y * np.log(Sigmoidal(X, theta) + eps) + (1 - Y) * np.log(1 - Sigmoidal(X, theta) + eps)) / Y.shape[1] #5 def Calcular_Gradiente(X, theta, Y): return np.sum(np.dot(X, (Sigmoidal(X, theta) - Y).T), axis = 1, keepdims = True) / Y.shape[1] #7 def Calcular_Accuracy(X, theta, Y): predicciones = (Sigmoidal(X, theta) >= .5).astype(int) comparacion = (predicciones == Y).astype(float) #print(comparacion) unique, counts = np.unique(comparacion, return_counts = True) dict_t = dict(zip(unique, counts)) return (dict_t[1] / comparacion.shape[1]) #6 def Gradiente_Descendiente(X, theta, Y, iteraciones = 3501, learning_rate = 0.4, step = 500): lista_costos = [] lista_accuracy = [] lista_thetas = [] for it in range(1, iteraciones): theta = theta - learning_rate * Calcular_Gradiente(X, theta, Y) if it % step == 0: lista_costos.append(Calcular_Funcion_Costo(X, theta, Y)) lista_accuracy.append(Calcular_Accuracy(X, theta, Y)) lista_thetas.append(theta) return theta, lista_costos, lista_accuracy, lista_thetas #8 def Crear_k_folds(np_arr, k = 3): # Only works with y = 0 or 1 unique, counts = np.unique(np_arr[-1], return_counts = True) np_arr = np_arr.T dict_unique = {} for i in unique: dict_unique[i] = [] for i in np_arr: dict_unique[i[-1]].append(i.tolist()) dict_answer = {} for i in range(k): dict_answer["k" + str(i)] = [] for i in range(k - 1): for u, c in zip(unique, counts): for j in range(int(c / k) * i, int(c / k) * (i + 1)): dict_answer["k" + str(i)].append(dict_unique[u][j]) for u, c in zip(unique, counts): for j in range(int(c / k) * (k - 1), c): dict_answer["k" + str(k - 1)].append(dict_unique[u][j]) for i in range(k): temp = np.array(dict_answer["k" + str(i)]) np.random.shuffle(temp) dict_answer["k" + str(i)] = temp.T return dict_answer
the-stack_106_29245
import os, sys import numpy as np import matplotlib.pyplot as plt import functools import argparse import inspect def parse(func): """ Quick and dirty way to make any main with optional keyword arguments parsable from the command line. """ @functools.wraps(func) def wrapper(**kwargs): # Get default kwargs signature_kwargs = {k:v.default for k, v in inspect.signature(func).parameters.items()} # Update default values with values of caller signature_kwargs.update(kwargs) # Parse kwargs parser = argparse.ArgumentParser() for key, value in signature_kwargs.items(): value_type = type(value) if isinstance(value, bool): value_type = bool_parse parser.add_argument(f'--{key}', dest=key, default=value, type=value_type) kwargs = vars(parser.parse_args()) # Returns the original func with new kwargs return func(**kwargs) return wrapper def bool_parse(arg): if arg.lower() in ('true', 't', 'yes', 'y', '1'): return True elif arg.lower() in ('false', 'f', 'no', 'n', '0'): return False else: raise argparse.ArgumentTypeError('Boolean value expected.') def identity_func(arg): return arg def identity_method(self, arg): return arg def compute_subplots_shape(N, aspect_ratio=9/16): """ Returns the shape (n, m) of the subplots that will fit N images with respect to the given aspect_ratio. """ if aspect_ratio == 0: return N, 1 n = int(np.sqrt(aspect_ratio*N)) m = int(np.sqrt(1/aspect_ratio*N)) while m*n < N: if n/m <= aspect_ratio: n += 1 else: m += 1 return n, m def make_fig_axes(N, aspect_ratio=9/16): n, m = compute_subplots_shape(N) fig, axes = plt.subplots(n, m) # Reshaping axes if n == 1 and m == 1: axes = [[axes]] elif n == 1 or m == 1: axes = [axes] axes = [ax for line_axes in axes for ax in line_axes] for ax in axes[N:]: ax.axis('off') return fig, axes[:N] def split_int(n, k): """ Equivalent of numpy 'array_split' function, but for integers instead of arrays. Returns n%k tuples of integers with difference equal to (n//k) + 1 and k - n%k tuples of integers with difference equal to n//k. """ idx0, idx1 = 0, 0 for i in range(k): idx0 = idx1 idx1 = idx1 + n//k if i < n%k: idx1 += 1 yield (idx0, idx1) if __name__ == '__main__': print([i for i in split_int(10,3)])
the-stack_106_29246
import pyb def test_irq(): # test basic disable/enable i1 = pyb.disable_irq() print(i1) pyb.enable_irq() # by default should enable IRQ # check that interrupts are enabled by waiting for ticks pyb.delay(10) # check nested disable/enable i1 = pyb.disable_irq() i2 = pyb.disable_irq() print(i1, i2) pyb.enable_irq(i2) pyb.enable_irq(i1) # check that interrupts are enabled by waiting for ticks pyb.delay(10) test_irq()
the-stack_106_29247
# -*- coding: utf-8 -*- """Implements classes for generating data by schema.""" from typing import Any, Callable, Final, Iterator, List, Optional, Sequence from mimesis.exceptions import FieldError, SchemaError from mimesis.locales import Locale from mimesis.providers.generic import Generic from mimesis.typing import JSON, SchemaType, Seed __all__ = ["BaseField", "Field", "Schema"] class BaseField: """ BaseField is a class for generating data by the name of the method. Instance of this object takes any string which represents the name of any method of any supported data provider (:class:`~mimesis.Generic`) and the ``**kwargs`` of the method. See :class:`~mimesis.schema.BaseField.perform` for more details. """ class Meta: base = True def __init__( self, locale: Locale = Locale.DEFAULT, seed: Optional[Seed] = None, providers: Optional[Sequence[Any]] = None, ) -> None: """Initialize field. :param locale: Locale :param seed: Seed for random. """ self._gen = Generic(locale, seed) if providers: self._gen.add_providers(*providers) self._table = {} # type: ignore def perform( self, name: Optional[str] = None, key: Optional[Callable[[Any], Any]] = None, **kwargs: Any ) -> Any: """Performs the value of the field by its name. It takes any string which represents the name of any method of any supported data provider and the ``**kwargs`` of this method. .. note:: Some data providers have methods with the same names and in such cases, you can explicitly define that the method belongs to data-provider ``name='provider.name'`` otherwise it will return the data from the first provider which has a method ``name``. You can apply a *key function* to the result returned by the method, bt passing a parameter **key** with a callable object which returns the final result. :param name: Name of the method. :param key: A key function (or any other callable object) which will be applied to result. :param kwargs: Kwargs of method. :return: Value which represented by method. :raises ValueError: if provider not supported or if field not defined. """ if name is None: raise FieldError() def tail_parser(tails: str, obj: Any) -> Any: """Return method from end of tail. :param tails: Tail string :param obj: Search tail from this object :return last tailed method """ provider_name, method_name = tails.split(".", 1) if "." in method_name: raise FieldError(name) attr = getattr(obj, provider_name) if attr is not None: try: return getattr(attr, method_name) except AttributeError: raise FieldError(name) try: if name not in self._table: if "." not in name: # Fix https://github.com/lk-geimfari/mimesis/issues/619 if name == self._gen.choice.Meta.name: self._table[name] = self._gen.choice else: for provider in dir(self._gen): provider = getattr(self._gen, provider) if name in dir(provider): self._table[name] = getattr(provider, name) else: self._table[name] = tail_parser(name, self._gen) result = self._table[name](**kwargs) if key and callable(key): return key(result) return result except KeyError: raise FieldError(name) def __str__(self) -> str: return "{} <{}>".format(self.__class__.__name__, self._gen.locale) class Field(BaseField): """Greedy field. The field whcih evaluates immediately. Example: >>> _ = Field() >>> _('username') Dogtag_1836 """ def __call__(self, *args: Any, **kwargs: Any) -> Any: return self.perform(*args, **kwargs) class Schema: """Class which return list of filled schemas.""" _MIN_ITERATIONS_VALUE: Final = 1 __slots__ = ("_schema",) def __init__(self, schema: SchemaType) -> None: """Initialize schema. :param schema: A schema (must be a callable object). """ if schema and callable(schema): self._schema = schema else: raise SchemaError() def create(self, iterations: int = 1) -> List[JSON]: """Creates a list of a fulfilled schemas. .. note:: This method evaluates immediately, so be careful on creating large datasets otherwise you're risking running out of memory. If you need a lazy version of this method, see :meth:`iterator` :param iterations: Number of iterations. :return: List of fulfilled schemas. """ if iterations < self._MIN_ITERATIONS_VALUE: raise ValueError("The number of iterations must be greater than 0.") return [self._schema() for _ in range(iterations)] def iterator(self, iterations: int = 1) -> Iterator[JSON]: """Fulfills schema in a lazy way. :param iterations: Number of iterations. :return: List of fulfilled schemas. """ if iterations < self._MIN_ITERATIONS_VALUE: raise ValueError("The number of iterations must be greater than 0.") for item in range(iterations): yield self._schema()
the-stack_106_29248
import click from amusement import Parks @click.command() @click.argument('name', nargs=1, type=click.Choice(Parks.keys())) @click.option('--type', type=click.Choice(['rides', 'shows']), prompt='Please choose rides or shows') def cli(name, type): park = Parks[name] if type == 'rides': print_rides(park.rides()) if type == 'shows': print(park.shows()) def print_rides(ride_array): longest_name = max(len(key['name']) for key in ride_array) one_closed = False in [key['isOpen'] for key in ride_array] for ride in ride_array: line = '' line += ride['name'] + ' ' * (longest_name - len(ride['name'])) line += ' ' * 3 if ride['isOpen'] is True: line += 'Open' # make sure the times are aligned b/c closed longer than open if one_closed: line += ' ' * 2 else: line += 'Closed' line += ' ' * 5 line += str(ride['wait']) + ' mins' click.echo(line) if __name__ == "__main__": cli()
the-stack_106_29249
from typing import Any, Dict, List, Optional, Tuple from ConfigSpace.configuration_space import Configuration, ConfigurationSpace import numpy as np from sklearn.base import ClassifierMixin from autoPyTorch.pipeline.base_pipeline import BasePipeline from autoPyTorch.pipeline.components.base_choice import autoPyTorchChoice from autoPyTorch.pipeline.components.preprocessing.image_preprocessing.normalise.base_normalizer_choice import ( NormalizerChoice ) from autoPyTorch.pipeline.components.setup.augmentation.image.ImageAugmenter import ImageAugmenter from autoPyTorch.pipeline.components.setup.early_preprocessor.EarlyPreprocessing import EarlyPreprocessing # from autoPyTorch.pipeline.components.setup.lr_scheduler.base_scheduler_choice import SchedulerChoice # from autoPyTorch.pipeline.components.setup.network.base_network_choice import NetworkChoice # from autoPyTorch.pipeline.components.setup.optimizer.base_optimizer_choice import OptimizerChoice # from autoPyTorch.pipeline.components.setup.network_initializer.base_network_init_choice import ( # NetworkInitializerChoice # ) class ImageClassificationPipeline(ClassifierMixin, BasePipeline): """This class is a proof of concept to integrate AutoSklearn Components It implements a pipeline, which includes as steps: ->One preprocessing step ->One neural network Contrary to the sklearn API it is not possible to enumerate the possible parameters in the __init__ function because we only know the available classifiers at runtime. For this reason the user must specifiy the parameters by passing an instance of ConfigSpace.configuration_space.Configuration. Args: config (Configuration) The configuration to evaluate. random_state (Optional[RandomState): random_state is the random number generator Attributes: Examples """ def __init__( self, config: Optional[Configuration] = None, steps: Optional[List[Tuple[str, autoPyTorchChoice]]] = None, dataset_properties: Optional[Dict[str, Any]] = None, include: Optional[Dict[str, Any]] = None, exclude: Optional[Dict[str, Any]] = None, random_state: Optional[np.random.RandomState] = None, init_params: Optional[Dict[str, Any]] = None ): super().__init__( config, steps, dataset_properties, include, exclude, random_state, init_params) def fit_transformer( self, X: np.ndarray, y: np.ndarray, fit_params: Optional[Dict[str, Any]] = None ) -> Tuple[np.ndarray, Optional[Dict[str, Any]]]: """Fits the pipeline given a training (X,y) pair Args: X (np.ndarray): features from which to guess targets y (np.ndarray): classification targets for this task fit_params (Optional[Dict[str, Any]]]): handy communication dictionary, so that inter-stages of the pipeline can share information Returns: np.ndarray: the transformed features Optional[Dict[str, Any]]]: A dictionary to share fit informations within the pipeline stages """ if fit_params is None: fit_params = {} X, fit_params = super().fit_transformer( X, y, fit_params=fit_params) return X, fit_params def predict_proba(self, X: np.ndarray, batch_size: Optional[int] = None) -> np.ndarray: """predict_proba. Args: X (np.ndarray): input to the pipeline, from which to guess targets batch_size (Optional[int]): batch_size controls whether the pipeline will be called on small chunks of the data. Useful when calling the predict method on the whole array X results in a MemoryError. Returns: np.ndarray: Probabilities of the target being certain class """ if batch_size is None: return super().predict_proba(X) else: if not isinstance(batch_size, int): raise ValueError("Argument 'batch_size' must be of type int, " "but is '%s'" % type(batch_size)) if batch_size <= 0: raise ValueError("Argument 'batch_size' must be positive, " "but is %d" % batch_size) else: # Probe for the target array dimensions target = self.predict_proba(X[0:2].copy()) y = np.zeros((X.shape[0], target.shape[1]), dtype=np.float32) for k in range(max(1, int(np.ceil(float(X.shape[0]) / batch_size)))): batch_from = k * batch_size batch_to = min([(k + 1) * batch_size, X.shape[0]]) pred_prob = self.predict_proba(X[batch_from:batch_to], batch_size=None) y[batch_from:batch_to] = pred_prob.astype(np.float32) return y def _get_hyperparameter_search_space(self, dataset_properties: Dict[str, Any], include: Optional[Dict[str, Any]] = None, exclude: Optional[Dict[str, Any]] = None, ) -> ConfigurationSpace: """Create the hyperparameter configuration space. For the given steps, and the Choices within that steps, this procedure returns a configuration space object to explore. Args: include (Optional[Dict[str, Any]]): what hyper-parameter configurations to honor when creating the configuration space exclude (Optional[Dict[str, Any]]): what hyper-parameter configurations to remove from the configuration space dataset_properties (Optional[Dict[str, Union[str, int]]]): Caracteristics of the dataset to guide the pipeline choices of components Returns: cs (Configuration): The configuration space describing the SimpleRegressionClassifier. """ cs = ConfigurationSpace() if dataset_properties is None or not isinstance(dataset_properties, dict): dataset_properties = dict() if 'target_type' not in dataset_properties: dataset_properties['target_type'] = 'image_classification' if dataset_properties['target_type'] != 'image_classification': dataset_properties['target_type'] = 'image_classification' # get the base search space given this # dataset properties. Then overwrite with custom # classification requirements cs = self._get_base_search_space( cs=cs, dataset_properties=dataset_properties, exclude=exclude, include=include, pipeline=self.steps) # Here we add custom code, like this with this # is not a valid configuration self.configuration_space = cs self.dataset_properties = dataset_properties return cs def _get_pipeline_steps(self, dataset_properties: Optional[Dict[str, Any]], ) -> List[Tuple[str, autoPyTorchChoice]]: """ Defines what steps a pipeline should follow. The step itself has choices given via autoPyTorchChoice. Returns: List[Tuple[str, autoPyTorchChoice]]: list of steps sequentially exercised by the pipeline. """ steps = [] # type: List[Tuple[str, autoPyTorchChoice]] default_dataset_properties = {'target_type': 'image_classification'} if dataset_properties is not None: default_dataset_properties.update(dataset_properties) steps.extend([ ("normalizer", NormalizerChoice(default_dataset_properties)), ("preprocessing", EarlyPreprocessing()), ("image_augmenter", ImageAugmenter()) # ("network", NetworkChoice(default_dataset_properties)), # ("network_init", NetworkInitializerChoice(default_dataset_properties)), # ("optimizer", OptimizerChoice(default_dataset_properties)), # ("lr_scheduler", SchedulerChoice(default_dataset_properties)), ]) return steps def _get_estimator_hyperparameter_name(self) -> str: """ Returns the name of the current estimator. Returns: str: name of the pipeline type """ return "image_classifier"
the-stack_106_29253
# -*- coding: utf-8 -*- import tempfile import threading from urllib.parse import quote import json import datetime import time import math import re import sys import os try: from selenium import webdriver from selenium.common.exceptions import TimeoutException, WebDriverException from selenium.common.exceptions import ElementNotVisibleException from selenium.webdriver.common.keys import Keys from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait # available since 2.4.0 from selenium.webdriver.support import expected_conditions as EC # available since 2.26.0 from selenium.webdriver.common.desired_capabilities import DesiredCapabilities except ImportError as ie: print(ie) sys.exit('You can install missing modules with `pip3 install [modulename]`') from GoogleScraper.scraping import SearchEngineScrape, SeleniumSearchError, get_base_search_url_by_search_engine, MaliciousRequestDetected from GoogleScraper.user_agents import random_user_agent import logging logger = logging.getLogger(__name__) def get_selenium_scraper_by_search_engine_name(config, search_engine_name, *args, **kwargs): """Get the appropriate selenium scraper for the given search engine name. Args: search_engine_name: The search engine name. args: The arguments for the target search engine instance creation. kwargs: The keyword arguments for the target search engine instance creation. Returns; Either a concrete SelScrape instance specific for the given search engine or the abstract SelScrape object. """ class_name = search_engine_name[0].upper() + search_engine_name[1:].lower() + 'SelScrape' ns = globals() if class_name in ns: return ns[class_name](config, *args, **kwargs) return SelScrape(config, *args, **kwargs) class SelScrape(SearchEngineScrape, threading.Thread): """Instances of this class make use of selenium browser objects to query the search engines on a high level. """ next_page_selectors = { 'google': '#pnnext', 'yandex': '.pager__button_kind_next', 'bing': '.sb_pagN', 'yahoo': '#pg-next', 'baidu': '.n', 'ask': '#paging div a.txt3.l_nu', 'blekko': '', 'duckduckgo': '', 'googleimg': '#pnnext', 'baiduimg': '.n', } input_field_selectors = { 'google': (By.NAME, 'q'), 'yandex': (By.NAME, 'text'), 'bing': (By.NAME, 'q'), 'yahoo': (By.NAME, 'p'), 'baidu': (By.NAME, 'wd'), 'duckduckgo': (By.NAME, 'q'), 'ask': (By.NAME, 'q'), 'blekko': (By.NAME, 'q'), 'google': (By.NAME, 'q'), 'googleimg': (By.NAME, 'as_q'), 'baiduimg': (By.NAME, 'word'), } param_field_selectors = { 'googleimg': { 'image_type': (By.ID, 'imgtype_input'), 'image_size': (By.ID, 'imgsz_input'), }, } search_params = { 'googleimg': { 'image_type': None, 'image_size': None, }, } normal_search_locations = { 'google': 'https://www.google.com/', 'yandex': 'http://www.yandex.ru/', 'bing': 'http://www.bing.com/', 'yahoo': 'https://yahoo.com/', 'baidu': 'http://baidu.com/', 'duckduckgo': 'https://duckduckgo.com/', 'ask': 'http://ask.com/', 'blekko': 'http://blekko.com/', } image_search_locations = { 'google': 'https://www.google.com/imghp', 'yandex': 'http://yandex.ru/images/', 'bing': 'https://www.bing.com/?scope=images', 'yahoo': 'http://images.yahoo.com/', 'baidu': 'http://image.baidu.com/', 'duckduckgo': None, # duckduckgo doesnt't support direct image search 'ask': 'http://www.ask.com/pictures/', 'blekko': None, 'googleimg':'https://www.google.com/advanced_image_search', 'baiduimg': 'http://image.baidu.com/', } def __init__(self, config, *args, captcha_lock=None, browser_num=1, **kwargs): """Create a new SelScraper thread Instance. Args: captcha_lock: To sync captcha solving (stdin) proxy: Optional, if set, use the proxy to route all scrapign through it. browser_num: A unique, semantic number for each thread. """ self.search_input = None threading.Thread.__init__(self) SearchEngineScrape.__init__(self, config, *args, **kwargs) self.browser_type = self.config.get('sel_browser', 'chrome').lower() self.browser_num = browser_num self.captcha_lock = captcha_lock self.scrape_method = 'selenium' self.xvfb_display = self.config.get('xvfb_display', None) self.search_param_values = self._get_search_param_values() # get the base search url based on the search engine. self.base_search_url = get_base_search_url_by_search_engine(self.config, self.search_engine_name, self.scrape_method) super().instance_creation_info(self.__class__.__name__) def set_proxy(self): """Install a proxy on the communication channel.""" def switch_proxy(self, proxy): """Switch the proxy on the communication channel.""" def proxy_check(self, proxy): assert self.proxy and self.webdriver, 'Scraper instance needs valid webdriver and proxy instance to make the proxy check' online = False status = 'Proxy check failed: {host}:{port} is not used while requesting'.format(**self.proxy.__dict__) ipinfo = {} try: self.webdriver.get(self.config.get('proxy_info_url')) try: text = re.search(r'(\{.*?\})', self.webdriver.page_source, flags=re.DOTALL).group(0) ipinfo = json.loads(text) except ValueError as v: logger.critical(v) except Exception as e: status = str(e) if 'ip' in ipinfo and ipinfo['ip']: online = True status = 'Proxy is working.' else: logger.warning(status) super().update_proxy_status(status, ipinfo, online) return online def _save_debug_screenshot(self): """ Saves a debug screenshot of the browser window to figure out what went wrong. """ tempdir = tempfile.gettempdir() location = os.path.join(tempdir, '{}_{}_debug_screenshot.png'.format(self.search_engine_name, self.browser_type)) self.webdriver.get_screenshot_as_file(location) def _set_xvfb_display(self): # TODO: should we check the format of the config? if self.xvfb_display: os.environ['DISPLAY'] = self.xvfb_display def _get_webdriver(self): """Return a webdriver instance and set it up with the according profile/ proxies. Chrome is quite fast, but not as stealthy as PhantomJS. Returns: The appropriate webdriver mode according to self.browser_type. If no webdriver mode could be found, return False. """ if self.browser_type == 'chrome': return self._get_Chrome() elif self.browser_type == 'firefox': return self._get_Firefox() elif self.browser_type == 'phantomjs': return self._get_PhantomJS() return False def _get_Chrome(self): try: if self.proxy: chrome_ops = webdriver.ChromeOptions() chrome_ops.add_argument( '--proxy-server={}://{}:{}'.format(self.proxy.proto, self.proxy.host, self.proxy.port)) self.webdriver = webdriver.Chrome(chrome_options=chrome_ops) else: self.webdriver = webdriver.Chrome()#service_log_path='/tmp/chromedriver_log.log') return True except WebDriverException as e: # we don't have a chrome executable or a chrome webdriver installed raise return False def _get_Firefox(self): try: if self.proxy: profile = webdriver.FirefoxProfile() profile.set_preference("network.proxy.type", 1) # this means that the proxy is user set, regardless of the type if self.proxy.proto.lower().startswith('socks'): profile.set_preference("network.proxy.socks", self.proxy.host) profile.set_preference("network.proxy.socks_port", self.proxy.port) profile.set_preference("network.proxy.socks_version", 5 if self.proxy.proto[-1] == '5' else 4) profile.update_preferences() elif self.proxy.proto == 'http': profile.set_preference("network.proxy.http", self.proxy.host) profile.set_preference("network.proxy.http_port", self.proxy.port) else: raise ValueError('Invalid protocol given in proxyfile.') profile.update_preferences() self.webdriver = webdriver.Firefox(firefox_profile=profile) else: self.webdriver = webdriver.Firefox() return True except WebDriverException as e: # reaching here is bad, since we have no available webdriver instance. logger.error(e) return False def _get_PhantomJS(self): try: service_args = [] if self.proxy: service_args.extend([ '--proxy={}:{}'.format(self.proxy.host, self.proxy.port), '--proxy-type={}'.format(self.proxy.proto), ]) if self.proxy.username and self.proxy.password: service_args.append( '--proxy-auth={}:{}'.format(self.proxy.username, self.proxy.password) ) dcap = dict(DesiredCapabilities.PHANTOMJS) dcap["phantomjs.page.settings.userAgent"] = random_user_agent(only_desktop=True) self.webdriver = webdriver.PhantomJS(service_args=service_args, desired_capabilities=dcap) return True except WebDriverException as e: logger.error(e) return False def handle_request_denied(self, status_code): """Checks whether Google detected a potentially harmful request. Whenever such potential abuse is detected, Google shows an captcha. This method just blocks as long as someone entered the captcha in the browser window. When the window is not visible (For example when using PhantomJS), this method makes a png from the html code and shows it to the user, which should enter it in a command line. Returns: The search input field. Raises: MaliciousRequestDetected when there was not way to stp Google From denying our requests. """ # selenium webdriver objects have no status code :/ super().handle_request_denied('400') needles = self.malicious_request_needles[self.search_engine_name] if needles and needles['inurl'] in self.webdriver.current_url \ and needles['inhtml'] in self.webdriver.page_source: if self.config.get('manual_captcha_solving', False): with self.captcha_lock: import tempfile tf = tempfile.NamedTemporaryFile('wb') tf.write(self.webdriver.get_screenshot_as_png()) import webbrowser webbrowser.open('file://{}'.format(tf.name)) solution = input('enter the captcha please...') self.webdriver.find_element_by_name('submit').send_keys(solution + Keys.ENTER) try: self.search_input = WebDriverWait(self.webdriver, 5).until( EC.visibility_of_element_located(self._get_search_input_field())) except TimeoutException: raise MaliciousRequestDetected('Requesting with this ip is not possible at the moment.') tf.close() else: # Just wait until the user solves the captcha in the browser window # 10 hours if needed :D logger.info('Waiting for user to solve captcha') return self._wait_until_search_input_field_appears(10 * 60 * 60) def build_search(self): """Build the search for SelScrapers""" assert self.webdriver, 'Webdriver needs to be ready to build the search' if self.config.get('search_type', 'normal') == 'image': starting_point = self.image_search_locations[self.search_engine_name] else: starting_point = self.base_search_url self.webdriver.get(starting_point) def _get_search_param_values(self): search_param_values = {} if self.search_engine_name in self.search_params: for param_key in self.search_params[self.search_engine_name]: cfg = self.config.get(param_key, None) if cfg: search_param_values[param_key] = cfg return search_param_values def _get_search_input_field(self): """Get the search input field for the current search_engine. Returns: A tuple to locate the search field as used by seleniums function presence_of_element_located() """ return self.input_field_selectors[self.search_engine_name] def _get_search_param_fields(self): if self.search_engine_name in self.param_field_selectors: return self.param_field_selectors[self.search_engine_name] else: return {} def _wait_until_search_input_field_appears(self, max_wait=5): """Waits until the search input field can be located for the current search engine Args: max_wait: How long to wait maximally before returning False. Returns: False if the search input field could not be located within the time or the handle to the search input field. """ def find_visible_search_input(driver): input_field = driver.find_element(*self._get_search_input_field()) return input_field try: search_input = WebDriverWait(self.webdriver, max_wait).until(find_visible_search_input) return search_input except TimeoutException as e: logger.error('{}: TimeoutException waiting for search input field: {}'.format(self.name, e)) return False def _wait_until_search_param_fields_appears(self, max_wait=5): """Waits until the search input field contains the query. Args: max_wait: How long to wait maximally before returning False. """ def find_visible_search_param(driver): for param, field in self._get_search_param_fields().items(): input_field = driver.find_element(*field) if not input_field: return False return True try: fields = WebDriverWait(self.webdriver, max_wait).until(find_visible_search_param) return fields except TimeoutException as e: logger.error('{}: TimeoutException waiting for search param field: {}'.format(self.name, e)) return False def _goto_next_page(self): """ Click the next page element, Returns: The url of the next page or False if there is no such url (end of available pages for instance). """ next_url = '' element = self._find_next_page_element() if hasattr(element, 'click'): next_url = element.get_attribute('href') try: element.click() except WebDriverException: # See http://stackoverflow.com/questions/11908249/debugging-element-is-not-clickable-at-point-error # first move mouse to the next element, some times the element is not visibility, like blekko.com selector = self.next_page_selectors[self.search_engine_name] if selector: try: next_element = WebDriverWait(self.webdriver, 5).until( EC.presence_of_element_located((By.CSS_SELECTOR, selector))) webdriver.ActionChains(self.webdriver).move_to_element(next_element).perform() # wait until the next page link emerges WebDriverWait(self.webdriver, 8).until( EC.visibility_of_element_located((By.CSS_SELECTOR, selector))) element = self.webdriver.find_element_by_css_selector(selector) next_url = element.get_attribute('href') element.click() except WebDriverException: pass # wait until the next page was loaded if not next_url: return False else: return next_url def _find_next_page_element(self): """Finds the element that locates the next page for any search engine. Returns: The element that needs to be clicked to get to the next page or a boolean value to indicate an error condition. """ if self.search_type == 'normal': selector = self.next_page_selectors[self.search_engine_name] try: # wait until the next page link is clickable WebDriverWait(self.webdriver, 5).until(EC.element_to_be_clickable((By.CSS_SELECTOR, selector))) except (WebDriverException, TimeoutException) as e: self._save_debug_screenshot() raise Exception('{}: Cannot locate next page element: {}'.format(self.name, str(e))) return self.webdriver.find_element_by_css_selector(selector) elif self.search_type == 'image': self.page_down() return True def wait_until_serp_loaded(self): """ This method tries to wait until the page requested is loaded. We know that the correct page is loaded when self.page_number appears in the navigation of the page. """ if self.search_type == 'normal': if self.search_engine_name == 'google': selector = '#navcnt td.cur' elif self.search_engine_name == 'yandex': selector = '.pager__item_current_yes font font' elif self.search_engine_name == 'bing': selector = 'nav li a.sb_pagS' elif self.search_engine_name == 'yahoo': selector = '.compPagination strong' elif self.search_engine_name == 'baidu': selector = '#page .fk_cur + .pc' elif self.search_engine_name == 'duckduckgo': # no pagination in duckduckgo pass elif self.search_engine_name == 'ask': selector = '#paging .pgcsel .pg' if self.search_engine_name == 'duckduckgo': time.sleep(1.5) else: try: WebDriverWait(self.webdriver, 5).\ until(EC.text_to_be_present_in_element((By.CSS_SELECTOR, selector), str(self.page_number))) except TimeoutException as e: self._save_debug_screenshot() content = self.webdriver.find_element_by_css_selector(selector).text raise Exception('Pagenumber={} did not appear in navigation. Got "{}" instead'\ .format(self.page_number), content) elif self.search_type == 'image': self.wait_until_title_contains_keyword() else: self.wait_until_title_contains_keyword() def wait_until_title_contains_keyword(self): try: WebDriverWait(self.webdriver, 5).until(EC.title_contains(self.query)) except TimeoutException: logger.debug(SeleniumSearchError( '{}: Keyword "{}" not found in title: {}'.format(self.name, self.query, self.webdriver.title))) def search(self): """Search with webdriver. Fills out the search form of the search engine for each keyword. Clicks the next link while pages_per_keyword is not reached. """ for self.query, self.pages_per_keyword in self.jobs.items(): self.search_input = self._wait_until_search_input_field_appears() if self.search_input is False and self.config.get('stop_on_detection'): self.status = 'Malicious request detected' return if self.search_input is False: # @todo: pass status_code self.search_input = self.handle_request_denied() if self.search_input: self.search_input.clear() time.sleep(.25) self.search_param_fields = self._get_search_param_fields() if self.search_param_fields: wait_res = self._wait_until_search_param_fields_appears() if wait_res is False: raise Exception('Waiting search param input fields time exceeds') for param, field in self.search_param_fields.items(): if field[0] == By.ID: js_tpl = ''' var field = document.getElementById("%s"); field.setAttribute("value", "%s"); ''' elif field[0] == By.NAME: js_tpl = ''' var fields = document.getElementsByName("%s"); for (var f in fields) { f.setAttribute("value", "%s"); } ''' js_str = js_tpl % (field[1], self.search_param_values[param]) self.webdriver.execute_script(js_str) try: self.search_input.send_keys(self.query + Keys.ENTER) except ElementNotVisibleException: time.sleep(2) self.search_input.send_keys(self.query + Keys.ENTER) self.requested_at = datetime.datetime.utcnow() else: logger.debug('{}: Cannot get handle to the input form for keyword {}.'.format(self.name, self.query)) continue super().detection_prevention_sleep() super().keyword_info() for self.page_number in self.pages_per_keyword: self.wait_until_serp_loaded() try: self.html = self.webdriver.execute_script('return document.body.innerHTML;') except WebDriverException as e: self.html = self.webdriver.page_source super().after_search() # Click the next page link not when leaving the loop # in the next iteration. if self.page_number in self.pages_per_keyword: next_url = self._goto_next_page() self.requested_at = datetime.datetime.utcnow() if not next_url: break def page_down(self): """Scrolls down a page with javascript. Used for next page in image search mode or when the next results are obtained by scrolling down a page. """ js = ''' var w = window, d = document, e = d.documentElement, g = d.getElementsByTagName('body')[0], y = w.innerHeight|| e.clientHeight|| g.clientHeight; window.scrollBy(0,y); return y; ''' self.webdriver.execute_script(js) def run(self): """Run the SelScraper.""" self._set_xvfb_display() if not self._get_webdriver(): raise Exception('{}: Aborting due to no available selenium webdriver.'.format(self.name)) try: self.webdriver.set_window_size(400, 400) self.webdriver.set_window_position(400 * (self.browser_num % 4), 400 * (math.floor(self.browser_num // 4))) except WebDriverException as e: logger.debug('Cannot set window size: {}'.format(e)) super().before_search() if self.startable: self.build_search() self.search() if self.webdriver: self.webdriver.quit() """ For most search engines, the normal SelScrape works perfectly, but sometimes the scraping logic is different for other search engines. Duckduckgo loads new results on the fly (via ajax) and doesn't support any "next page" link. Other search engines like gekko.com have a completely different SERP page format. That's why we need to inherit from SelScrape for specific logic that only applies for the given search engine. The following functionality may differ in particular: - _goto_next_page() - _get_search_input() - _wait_until_search_input_field_appears() - _handle_request_denied() - wait_until_serp_loaded() """ class DuckduckgoSelScrape(SelScrape): """ Duckduckgo is a little special since new results are obtained by ajax. next page thus is then to scroll down. Furthermore duckduckgo.com doesn't seem to work with Phantomjs. Maybe they block it, but I don't know how ??! It cannot be the User-Agent, because I already tried this. """ def __init__(self, *args, **kwargs): SelScrape.__init__(self, *args, **kwargs) self.largest_id = 0 def _goto_next_page(self): super().page_down() return 'No more results' not in self.html def wait_until_serp_loaded(self): super()._wait_until_search_input_field_appears() class BlekkoSelScrape(SelScrape): def __init__(self, *args, **kwargs): SelScrape.__init__(self, *args, **kwargs) def _goto_next_page(self): pass class AskSelScrape(SelScrape): def __init__(self, *args, **kwargs): SelScrape.__init__(self, *args, **kwargs) def wait_until_serp_loaded(self): def wait_until_keyword_in_url(driver): try: return quote(self.query) in driver.current_url or \ self.query.replace(' ', '+') in driver.current_url except WebDriverException: pass WebDriverWait(self.webdriver, 5).until(wait_until_keyword_in_url)
the-stack_106_29254
from collections import OrderedDict, defaultdict from copy import deepcopy from typing import Any, Dict import pytest from zulipterminal.config.keys import keys_for_command from zulipterminal.helper import initial_index as helper_initial_index from zulipterminal.ui_tools.boxes import MessageBox from zulipterminal.ui_tools.buttons import StreamButton, UserButton from zulipterminal.version import ( MINIMUM_SUPPORTED_SERVER_VERSION, SUPPORTED_SERVER_VERSIONS, ) @pytest.fixture(autouse=True) def no_requests(monkeypatch): """ Forces all the tests to work offline. """ monkeypatch.delattr("requests.sessions.Session.request") @pytest.fixture(autouse=True) def no_asynch(mocker): """ Make all function calls synchronous. """ mocker.patch("zulipterminal.helper.asynch") # --------------- Controller Fixtures ----------------------------------------- @pytest.fixture def stream_button(mocker): """ Mocked stream button. """ view_mock = mocker.Mock() view_mock.palette = [(None, "black", "white")] button = StreamButton( properties={ "name": "PTEST", "id": 205, "color": "#bfd56f", "invite_only": False, "description": "Test stream description", }, controller=mocker.patch("zulipterminal.core.Controller"), width=40, view=view_mock, count=30, ) return button @pytest.fixture def user_button(mocker, width=38): """ Mocked User Button. """ return UserButton( user={ "user_id": 5179, "full_name": "Boo Boo", "email": "[email protected]", }, width=width, controller=mocker.patch("zulipterminal.core.Controller"), view=mocker.patch("zulipterminal.ui.View"), state_marker="*", ) @pytest.fixture def msg_box(mocker, messages_successful_response): """ Mocked MessageBox with stream message """ return MessageBox( messages_successful_response["messages"][0], mocker.patch("zulipterminal.model.Model"), None, ) # --------------- Model Fixtures ---------------------------------------------- @pytest.fixture def users_fixture(logged_on_user): users = [logged_on_user] for i in range(1, 3): users.append( { "user_id": 10 + i, "full_name": f"Human {i}", "email": f"person{i}@example.com", "avatar_url": None, "is_active": True, "bot_type": None, "is_bot": False, "is_admin": False, } ) return users @pytest.fixture def user_groups_fixture(): user_groups = [] members = [[1001, 11], [11, 12], [12], []] for i in range(1, 5): user_groups.append( { "id": 10 + i, "name": f"Group {i}", "description": f"Core developers of Group {i}", "members": members[i - 1], } ) return user_groups @pytest.fixture def logged_on_user(): return { "user_id": 1001, "full_name": "Human Myself", "email": "[email protected]", "short_name": "Human", } general_stream = { "name": "Some general stream", "invite_only": False, "color": "#b0a5fd", # Color in '#xxxxxx' format "pin_to_top": False, "stream_id": 1000, "in_home_view": True, "audible_notifications": False, "description": "General Stream", "is_old_stream": True, "desktop_notifications": False, "stream_weekly_traffic": 0, "push_notifications": False, "email_address": "[email protected]", "subscribers": [1001, 11, 12], } # This is a private stream; # only description/stream_id/invite_only/name/color vary from above secret_stream = { "description": "Some private stream", "stream_id": 99, "pin_to_top": False, "invite_only": True, "name": "Secret stream", "email_address": "[email protected]", "color": "#ccc", # Color in '#xxx' format "in_home_view": True, "audible_notifications": False, "is_old_stream": True, "desktop_notifications": False, "stream_weekly_traffic": 0, "push_notifications": False, "subscribers": [1001, 11], } @pytest.fixture def streams_fixture(): streams = [general_stream, secret_stream] for i in range(1, 3): streams.append( { "name": f"Stream {i}", "invite_only": False, "color": "#b0a5fd", "pin_to_top": False, "stream_id": i, "in_home_view": True, "audible_notifications": False, "description": f"A description of stream {i}", "is_old_stream": True, "desktop_notifications": False, "stream_weekly_traffic": 0, "push_notifications": False, "email_address": f"stream{i}@example.com", "subscribers": [1001, 11, 12], } ) return deepcopy(streams) @pytest.fixture def realm_emojis(): # Omitting source_url, author_id (server version 3.0), # author (server version < 3.0) since they are not used. return { "1": { "deactivated": True, "id": "1", "name": "green_tick", }, "202020": { "deactivated": False, "id": "202020", "name": "joker", }, "2": { "deactivated": True, "id": "2", "name": "joy_cat", }, "3": { "deactivated": False, "id": "3", "name": "singing", }, "4": { "deactivated": False, "id": "4", "name": "zulip", }, } @pytest.fixture def realm_emojis_data(): return OrderedDict( [ ("joker", {"code": "202020", "type": "realm_emoji"}), ("singing", {"code": "3", "type": "realm_emoji"}), ("zulip", {"code": "4", "type": "realm_emoji"}), ] ) @pytest.fixture def unicode_emojis(): return OrderedDict( [ ("happy", {"code": "1f600", "type": "unicode_emoji"}), ("joker", {"code": "1f0cf", "type": "unicode_emoji"}), ("joy_cat", {"code": "1f639", "type": "unicode_emoji"}), ("rock_on", {"code": "1f918", "type": "unicode_emoji"}), ("smile", {"code": "263a", "type": "unicode_emoji"}), ("smiley", {"code": "1f603", "type": "unicode_emoji"}), ("smirk", {"code": "1f60f", "type": "unicode_emoji"}), ] ) @pytest.fixture def zulip_emoji(): return OrderedDict([("zulip", {"code": "zulip", "type": "zulip_extra_emoji"})]) stream_msg_template = { "id": 537286, "sender_full_name": "Foo Foo", "timestamp": 1520918722, "client": "website", "recipient_id": 6076, "sender_email": "[email protected]", "type": "stream", "sender_realm_str": "", "flags": ["read"], "sender_id": 5140, "content_type": "text/x-markdown", "stream_id": 205, "subject": "Test", "reactions": [], "subject_links": [], "avatar_url": "dummy_avatar_url", "is_me_message": False, "sender_short_name": "foo", "content": "Stream content here.", "display_recipient": "PTEST", } pm_template = { "id": 537287, "sender_full_name": "Foo Foo", "timestamp": 1520918736, "client": "website", "recipient_id": 5780, "is_me_message": False, "sender_email": "[email protected]", "flags": ["read"], "sender_id": 5140, "content_type": "text/x-markdown", "sender_realm_str": "", "subject": "", "reactions": [], "type": "private", "avatar_url": "dummy_avatar_url", "subject_links": [], "sender_short_name": "foo", "content": "Hey PM content here.", "display_recipient": [ { "id": 5179, "is_mirror_dummy": False, "full_name": "Boo Boo", "short_name": "boo", "email": "[email protected]", }, { "short_name": "foo", "id": 5140, "is_mirror_dummy": False, "full_name": "Foo Foo", "email": "[email protected]", }, ], } group_pm_template = { "id": 537288, "sender_full_name": "Foo Foo", "timestamp": 1520918737, "client": "website", "recipient_id": 5780, # FIXME Unsure "is_me_message": False, "sender_email": "[email protected]", "flags": ["read"], "sender_id": 5140, "content_type": "text/x-markdown", "sender_realm_str": "", "subject": "", "reactions": [], "type": "private", "avatar_url": "dummy_avatar_url", "subject_links": [], "sender_short_name": "foo", "content": "Hey PM content here again.", "display_recipient": [ { "id": 5179, "is_mirror_dummy": False, "full_name": "Boo Boo", "short_name": "boo", "email": "[email protected]", }, { "short_name": "foo", "id": 5140, "is_mirror_dummy": False, "full_name": "Foo Foo", "email": "[email protected]", }, { "short_name": "bar", "id": 5180, "is_mirror_dummy": False, "full_name": "Bar Bar", "email": "[email protected]", }, ], } @pytest.fixture( params=[stream_msg_template, pm_template, group_pm_template], ids=["stream_message", "pm_message", "group_pm_message"], ) def message_fixture(request): """ Acts as a parametrize fixture for stream msg, pms and group_pms. """ return deepcopy(request.param) @pytest.fixture def messages_successful_response() -> Dict[str, Any]: """ A successful response from a /messages API query. """ return deepcopy( { "anchor": 10000000000000000, "messages": [ stream_msg_template, pm_template, group_pm_template, ], "result": "success", "msg": "", } ) @pytest.fixture( params=SUPPORTED_SERVER_VERSIONS, ids=(lambda param: "server_version:{}-server_feature_level:{}".format(*param)), ) def zulip_version(request): """ Fixture to test different components based on the server version and the feature level. """ return request.param @pytest.fixture( params=[ [ { "content": "Hello!", "timestamp": 1530129122, "topic": "hello world", "user_id": 1001, # ... } ], [ { "content": "Hello!", "timestamp": 1530129122, "topic": "party at my houz", "user_id": 1001, # ... }, { "content": "Howdy!", "prev_content": "Hello!", "prev_topic": "party at my houz", "timestamp": 1530129134, "topic": "party at my house", "user_id": 1001, # ... }, ], ], ids=[ "unedited_message", "edited_message", ], ) def message_history(request): """ Returns message edit history for a message. """ return request.param @pytest.fixture def topics(): return ["Topic 1", "This is a topic", "Hello there!"] @pytest.fixture def initial_data(logged_on_user, users_fixture, streams_fixture, realm_emojis): """ Response from /register API request. """ return { "full_name": logged_on_user["full_name"], "email": logged_on_user["email"], "user_id": logged_on_user["user_id"], "realm_name": "Test Organization Name", "unsubscribed": [ { "audible_notifications": False, "description": "announce", "stream_id": 7, "is_old_stream": True, "desktop_notifications": False, "pin_to_top": False, "stream_weekly_traffic": 0, "invite_only": False, "name": "announce", "push_notifications": False, "email_address": "", "color": "#bfd56f", "in_home_view": True, } ], "result": "success", "queue_id": "1522420755:786", "realm_users": users_fixture, "cross_realm_bots": [ { "full_name": "Notification Bot", "timezone": "", "is_bot": True, "date_joined": "2015-12-28T19:58:29.035543+00:00", "email": "[email protected]", "user_id": 5, "is_admin": False, "avatar_url": "dummy_avatar_url", }, { "full_name": "Email Gateway", "timezone": "", "is_bot": True, "date_joined": "2015-12-28T19:58:29.037658+00:00", "email": "[email protected]", "user_id": 6, "is_admin": False, "avatar_url": "dummy_avatar_url", }, { "full_name": "Welcome Bot", "timezone": "", "is_bot": True, "date_joined": "2015-12-28T19:58:29.033231+00:00", "email": "[email protected]", "user_id": 4, "is_admin": False, "avatar_url": "dummy_avatar_url", }, { "full_name": "Zulip Feedback Bot", "timezone": "", "is_bot": True, "date_joined": "2015-12-28T19:58:28.972281+00:00", "email": "[email protected]", "user_id": 1, "is_admin": False, "avatar_url": "dummy_avatar_url", }, ], "subscriptions": streams_fixture, "msg": "", "max_message_id": 552761, "never_subscribed": [ { "invite_only": False, "description": "Announcements from the Zulip GCI Mentors", "stream_id": 87, "name": "GCI announce", "is_old_stream": True, "stream_weekly_traffic": 0, }, { "invite_only": False, "description": "General discussion", "stream_id": 74, "name": "GCI general", "is_old_stream": True, "stream_weekly_traffic": 0, }, ], "unread_msgs": { "pms": [ {"sender_id": 1, "unread_message_ids": [1, 2]}, {"sender_id": 2, "unread_message_ids": [3]}, ], "count": 0, "mentions": [], "streams": [ { "stream_id": 1000, "topic": "Some general unread topic", "unread_message_ids": [4, 5, 6], "sender_ids": [1, 2], }, { "stream_id": 99, "topic": "Some private unread topic", "unread_message_ids": [7], "sender_ids": [1, 2], }, ], "huddles": [ {"user_ids_string": "1001,11,12", "unread_message_ids": [11, 12, 13]}, { "user_ids_string": "1001,11,12,13", "unread_message_ids": [101, 102], }, ], }, "presences": { "[email protected]": { "ZulipElectron": { "pushable": False, "client": "ZulipElectron", "status": "idle", "timestamp": 1522484059, }, "ZulipMobile": { "pushable": False, "client": "ZulipMobile", "status": "idle", "timestamp": 1522384165, }, "aggregated": { "timestamp": 1522484059, "client": "ZulipElectron", "status": "idle", }, }, logged_on_user["email"]: { "website": { "pushable": True, "client": "website", "status": "active", "timestamp": 1522458138, }, "ZulipMobile": { "pushable": True, "client": "ZulipMobile", "status": "active", "timestamp": 1522480103, }, "aggregated": { "timestamp": 1522480103, "client": "ZulipMobile", "status": "active", }, }, }, "twenty_four_hour_time": True, "realm_emoji": realm_emojis, "last_event_id": -1, "muted_topics": [], "realm_user_groups": [], # Deliberately use hard-coded zulip version and feature level to avoid # adding extra tests unnecessarily. "zulip_version": MINIMUM_SUPPORTED_SERVER_VERSION[0], "zulip_feature_level": MINIMUM_SUPPORTED_SERVER_VERSION[1], "starred_messages": [1117554, 1117558, 1117574], } @pytest.fixture def initial_index(): return deepcopy(helper_initial_index) @pytest.fixture def empty_index(): return deepcopy( { "pointer": defaultdict(set, {}), "all_msg_ids": set(), "starred_msg_ids": set(), "mentioned_msg_ids": set(), "private_msg_ids": set(), "private_msg_ids_by_user_ids": defaultdict(set, {}), "stream_msg_ids_by_stream_id": defaultdict(set, {}), "topic_msg_ids": defaultdict(dict, {}), "edited_messages": set(), "topics": defaultdict(list), "search": set(), "messages": defaultdict( dict, { stream_msg_template["id"]: stream_msg_template, pm_template["id"]: pm_template, group_pm_template["id"]: group_pm_template, }, ), } ) @pytest.fixture def index_all_messages(empty_index): """ Expected index of `initial_data` fixture when model.narrow = [] """ return dict(empty_index, **{"all_msg_ids": {537286, 537287, 537288}}) @pytest.fixture def index_stream(empty_index): """ Expected index of initial_data when model.narrow = [['stream', '7']] """ diff = { "stream_msg_ids_by_stream_id": defaultdict(set, {205: {537286}}), "private_msg_ids": {537287, 537288}, } return dict(empty_index, **diff) @pytest.fixture def index_topic(empty_index): """ Expected index of initial_data when model.narrow = [['stream', '7'], ['topic', 'Test']] """ diff = {"topic_msg_ids": defaultdict(dict, {205: {"Test": {537286}}})} return dict(empty_index, **diff) @pytest.fixture def index_user(empty_index): """ Expected index of initial_data when model.narrow = [['pm_with', '[email protected]'], """ user_ids = frozenset({5179, 5140}) diff = { "private_msg_ids_by_user_ids": defaultdict(set, {user_ids: {537287}}), "private_msg_ids": {537287, 537288}, } return dict(empty_index, **diff) @pytest.fixture def index_user_multiple(empty_index): """ Expected index of initial_data when model.narrow = [['pm_with', '[email protected], [email protected]'], """ user_ids = frozenset({5179, 5140, 5180}) diff = { "private_msg_ids_by_user_ids": defaultdict(set, {user_ids: {537288}}), "private_msg_ids": {537287, 537288}, } return dict(empty_index, **diff) @pytest.fixture( params=[ {537286, 537287, 537288}, {537286}, {537287}, {537288}, {537286, 537287}, {537286, 537288}, {537287, 537288}, ] ) def index_all_starred(empty_index, request): msgs_with_stars = request.param index = dict( empty_index, starred_msg_ids=msgs_with_stars, private_msg_ids={537287, 537288} ) for msg_id, msg in index["messages"].items(): if msg_id in msgs_with_stars and "starred" not in msg["flags"]: msg["flags"].append("starred") return index @pytest.fixture( params=[ {537286, 537287, 537288}, {537286}, {537287}, {537288}, {537286, 537287}, {537286, 537288}, {537287, 537288}, ] ) def index_all_mentions(empty_index, request): mentioned_messages = request.param index = dict( empty_index, mentioned_msg_ids=mentioned_messages, private_msg_ids={537287, 537288}, ) for msg_id, msg in index["messages"].items(): if msg_id in mentioned_messages and "mentioned" not in msg["flags"]: msg["flags"].append("mentioned") return index @pytest.fixture def user_profile(logged_on_user): return { # FIXME These should all be self-consistent with others? "max_message_id": 589270, "short_name": logged_on_user["short_name"], "full_name": logged_on_user["full_name"], "email": logged_on_user["email"], "is_bot": False, "user_id": logged_on_user["user_id"], "result": "success", "client_id": "abcd", "msg": "", "is_admin": False, "pointer": 589234, } @pytest.fixture def error_response(): return {"msg": "Invalid API key", "result": "error"} @pytest.fixture def user_dict(logged_on_user): """ User_dict created according to `initial_data` fixture. """ return { logged_on_user["email"]: { "full_name": logged_on_user["full_name"], "email": logged_on_user["email"], "status": "active", "user_id": logged_on_user["user_id"], }, "[email protected]": { "full_name": "Human 1", "email": "[email protected]", "user_id": 11, "status": "inactive", }, "[email protected]": { "full_name": "Human 2", "email": "[email protected]", "user_id": 12, "status": "inactive", }, "[email protected]": { "email": "[email protected]", "full_name": "Email Gateway", "status": "inactive", "user_id": 6, }, "[email protected]": { "email": "[email protected]", "full_name": "Zulip Feedback Bot", "status": "inactive", "user_id": 1, }, "[email protected]": { "email": "[email protected]", "full_name": "Notification Bot", "status": "inactive", "user_id": 5, }, "[email protected]": { "email": "[email protected]", "full_name": "Welcome Bot", "status": "inactive", "user_id": 4, }, } @pytest.fixture def user_list(logged_on_user): """ List of users created corresponding to `initial_data` fixture. """ # NOTE These are sorted active > idle, then according to full_name return [ { "full_name": logged_on_user["full_name"], "email": logged_on_user["email"], "status": "active", "user_id": logged_on_user["user_id"], }, { "email": "[email protected]", "full_name": "Email Gateway", "status": "inactive", "user_id": 6, }, { "full_name": "Human 1", "email": "[email protected]", "user_id": 11, "status": "inactive", }, { "full_name": "Human 2", "email": "[email protected]", "user_id": 12, "status": "inactive", }, { "email": "[email protected]", "full_name": "Notification Bot", "status": "inactive", "user_id": 5, }, { "email": "[email protected]", "full_name": "Welcome Bot", "status": "inactive", "user_id": 4, }, { "email": "[email protected]", "full_name": "Zulip Feedback Bot", "status": "inactive", "user_id": 1, }, ] @pytest.fixture def streams(): """ List of streams created corresponding to `initial_data` fixture. """ return [ { "name": "Secret stream", "id": 99, "color": "#ccc", "invite_only": True, "description": "Some private stream", }, { "name": "Some general stream", "id": 1000, "color": "#baf", "invite_only": False, "description": "General Stream", }, { "name": "Stream 1", "id": 1, "color": "#baf", "invite_only": False, "description": "A description of stream 1", }, { "name": "Stream 2", "id": 2, "color": "#baf", "invite_only": False, "description": "A description of stream 2", }, ] @pytest.fixture def user_id(logged_on_user): """ Default User id of the current user, i.e., Tomás Farías according to current Fixtures. """ return logged_on_user["user_id"] @pytest.fixture def stream_dict(streams_fixture): return {stream["stream_id"]: stream for stream in streams_fixture} @pytest.fixture( params=[ { ("Stream 1", "muted stream muted topic"): None, ("Stream 2", "muted topic"): None, }, { ("Stream 1", "muted stream muted topic"): 1530129122, ("Stream 2", "muted topic"): 1530129122, }, ], ids=[ "zulip_feature_level:None", "zulip_feature_level:1", ], ) def processed_muted_topics(request): """ Locally processed muted topics data (see _muted_topics in Model.__init__). """ return request.param @pytest.fixture def classified_unread_counts(): """ Unread counts return by helper.classify_unread_counts function. """ return { "all_msg": 12, "all_pms": 8, "unread_topics": { (1000, "Some general unread topic"): 3, (99, "Some private unread topic"): 1, }, "unread_pms": { 1: 2, 2: 1, }, "unread_huddles": { frozenset({1001, 11, 12}): 3, frozenset({1001, 11, 12, 13}): 2, }, "streams": {1000: 3, 99: 1}, } # --------------- UI Fixtures ----------------------------------------- @pytest.fixture( params=[ (key, expected_key) for keys, expected_key in [ (keys_for_command("GO_UP"), "up"), (keys_for_command("GO_DOWN"), "down"), (keys_for_command("SCROLL_UP"), "page up"), (keys_for_command("SCROLL_DOWN"), "page down"), (keys_for_command("GO_TO_BOTTOM"), "end"), ] for key in keys ], ids=lambda param: "key:{}-expected_key:{}".format(*param), ) def navigation_key_expected_key_pair(request): """ Fixture to generate pairs of navigation keys with their respective expected key. The expected key is the one which is passed to the super `keypress` calls. """ return request.param @pytest.fixture def widget_size(): """ Returns widget size for any widget. """ def _widget_size(widget): widget_type, *_ = widget.sizing() if widget_type == "box": return (200, 20) elif widget_type == "flow": return (20,) else: None return _widget_size
the-stack_106_29259
from __future__ import division, absolute_import import re import numpy as np from dataset_loader import DatasetLoader import tflearn from tflearn.layers.core import input_data, dropout, fully_connected, flatten from tflearn.layers.conv import conv_2d, max_pool_2d, avg_pool_2d from tflearn.layers.merge_ops import merge from tflearn.layers.normalization import local_response_normalization from tflearn.layers.estimator import regression from constants import * from os.path import isfile, join import random import sys class EmotionRecognition: def __init__(self): self.dataset = DatasetLoader() def build_network(self): # Smaller 'AlexNet' # https://github.com/tflearn/tflearn/blob/master/examples/images/alexnet.py print('[+] Building CNN') self.network = input_data(shape = [None, SIZE_FACE, SIZE_FACE, 1]) self.network = conv_2d(self.network, 64, 5, activation = 'relu') #self.network = local_response_normalization(self.network) self.network = max_pool_2d(self.network, 3, strides = 2) self.network = conv_2d(self.network, 64, 5, activation = 'relu') self.network = max_pool_2d(self.network, 3, strides = 2) self.network = conv_2d(self.network, 128, 4, activation = 'relu') self.network = dropout(self.network, 0.3) self.network = fully_connected(self.network, 3072, activation = 'relu') self.network = fully_connected(self.network, len(EMOTIONS), activation = 'softmax') self.network = regression(self.network, optimizer = 'momentum', loss = 'categorical_crossentropy') self.model = tflearn.DNN( self.network, checkpoint_path = SAVE_DIRECTORY + '/emotion_recognition', max_checkpoints = 1, tensorboard_verbose = 2 ) self.load_model() def load_saved_dataset(self): self.dataset.load_from_save() print('[+] Dataset found and loaded') def start_training(self): self.load_saved_dataset() self.build_network() if self.dataset is None: self.load_saved_dataset() # Training print('[+] Training network') self.model.fit( self.dataset.images, self.dataset.labels, validation_set = (self.dataset.images_test, self.dataset._labels_test), n_epoch = 100, batch_size = 50, shuffle = True, show_metric = True, snapshot_step = 200, snapshot_epoch = True, run_id = 'emotion_recognition' ) def predict(self, image): if image is None: return None image = image.reshape([-1, SIZE_FACE, SIZE_FACE, 1]) return self.model.predict(image) def save_model(self): self.model.save(join(SAVE_DIRECTORY, SAVE_MODEL_FILENAME)) print('[+] Model trained and saved at ' + SAVE_MODEL_FILENAME) def load_model(self): if isfile(join(SAVE_DIRECTORY, SAVE_MODEL_FILENAME)): self.model.load(join(SAVE_DIRECTORY, SAVE_MODEL_FILENAME)) print('[+] Model loaded from ' + SAVE_MODEL_FILENAME) def show_usage(): # I din't want to have more dependecies print('[!] Usage: python emotion_recognition.py') print('\t emotion_recognition.py train \t Trains and saves model with saved dataset') print('\t emotion_recognition.py poc \t Launch the proof of concept') if __name__ == "__main__": if len(sys.argv) <= 1: show_usage() exit() network = EmotionRecognition() if sys.argv[1] == 'train': network.start_training() network.save_model() elif sys.argv[1] == 'poc': import poc else: show_usage()
the-stack_106_29261
from os import path def run(): with open(path.join(path.dirname(__file__), '../inputs/03.txt')) as file: n = int(file.read()) print('part 1:', spiral_distance(n)) print('part 2:', first_greater_than(n)) def first_greater_than(n): x = 0 y = 0 directions = [(1, 0), (0, 1), (-1, 0), (0, -1)] neighbors = directions + [(1, 1), (1, -1), (-1, 1), (-1, -1)] dir_count = len(directions) dir_idx = -1 cells = {(0, 0): 1} while True: new_dir_idx = (dir_idx + 1) % dir_count new_dir = directions[new_dir_idx] new_pos = (x + new_dir[0], y + new_dir[1]) if new_pos in cells: same_dir = directions[dir_idx] new_pos = (x + same_dir[0], y + same_dir[1]) else: dir_idx = new_dir_idx x = new_pos[0] y = new_pos[1] value = 0 for neighbor in neighbors: neighbor_pos = (x + neighbor[0], y + neighbor[1]) value += cells.get(neighbor_pos, 0) cells[new_pos] = value if value > n: return value def spiral_distance(n): x = 0 y = 0 directions = [(1, 0), (0, 1), (-1, 0), (0, -1)] dir_count = len(directions) dir_idx = -1 width = 1 turn_in = 0 for i in range(1, n): if turn_in == 0: turn_in = width - 1 dir_idx = (dir_idx + 1) % dir_count else: turn_in -= 1 if i == width * width + width: width += 1 x += directions[dir_idx][0] y += directions[dir_idx][1] return abs(x) + abs(y) if __name__ == '__main__': run()
the-stack_106_29262
# Copyright (c) 2018 PaddlePaddle 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 # # Unlessf 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 __future__ import print_function from ..layer_helper import LayerHelper from ..param_attr import ParamAttr from ..framework import convert_np_dtype_to_dtype_ from ..framework import Variable from ..initializer import Constant, force_init_on_cpu from ..core import VarDesc from .layer_function_generator import templatedoc import numpy __all__ = [ 'create_tensor', 'create_parameter', 'create_global_var', 'cast', 'concat', 'sums', 'assign', 'fill_constant_batch_size_like', 'fill_constant', 'argmin', 'argmax', 'argsort', 'ones', 'zeros', 'reverse', ] def create_tensor(dtype, name=None, persistable=False): """ Create an variable, which will hold a LoDTensor with data type dtype. Args: dtype(string): 'float32'|'int32'|..., the data type of the created tensor. name(string): The name of the created tensor, if not set, the name will be a random unique one. persistable(bool): Set the persistable flag of the create tensor. Returns: Variable: The tensor variable storing the created tensor. Examples: .. code-block:: python tensor = fluid.layers.create_tensor(dtype='float32') """ helper = LayerHelper("create_tensor", **locals()) return helper.create_variable( name=helper.name, dtype=dtype, persistable=persistable) def create_parameter(shape, dtype, name=None, attr=None, is_bias=False, default_initializer=None): """ Create a parameter. The parameter is a learnable variable, which can have gradient, and can be optimized. NOTE: this is a very low-level API. This API is useful when you create operator by your self. instead of using layers. Args: shape(list[int]): shape of the parameter dtype(string): element type of the parameter attr(ParamAttr): attributes of the parameter is_bias(bool): This can affect which default initializer is chosen when default_initializer is None. If is_bias, initializer.Constant(0.0) will be used. Otherwise, Xavier() will be used. default_initializer(Initializer): initializer for the parameter Returns: the created parameter. Examples: >>> W = fluid.layers.create_parameter(shape=[784, 200], dtype='float32') >>> data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False) >>> hidden = fluid.layers.matmul(x=data, y=W) """ helper = LayerHelper("create_parameter", **locals()) if attr is None: attr = ParamAttr(name=name) return helper.create_parameter(attr, shape, dtype, is_bias, default_initializer) def create_global_var(shape, value, dtype, persistable=False, force_cpu=False, name=None): """ Create a new variable in the global block(block 0). Args: shape(list[int]): shape of the variable value(float): the value of the variable. The new created variable will be filled with it. dtype(string): data type of the variable persistable(bool): if this variable is persistable. Default: False force_cpu(bool): force this variable to be on CPU. Default: False name(str|None): The name of the variable. If set to None the variable name will be generated automatically. Default: None Returns: Variable: the created Variable Examples: .. code-block:: python var = fluid.create_global_var(shape=[2,3], value=1.0, dtype='float32', persistable=True, force_cpu=True, name='new_var') """ helper = LayerHelper("global_var", **locals()) var = helper.create_global_variable( dtype=dtype, shape=shape, persistable=persistable, name=name) helper.set_variable_initializer( var, initializer=Constant( value=float(value), force_cpu=force_cpu)) return var def cast(x, dtype): """ This layer takes in the Variable :attr:`x` with :attr:`x.dtype` and casts it to the output with :attr:`dtype`. Args: x (Variable): The input Variable for casting. dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output Variable. Returns: Variable: The output Variable after casting. Examples: .. code-block:: python data = fluid.layers.data(name='x', shape=[13], dtype='float32') result = fluid.layers.cast(x=data, dtype='float64') """ helper = LayerHelper('cast', **locals()) out = helper.create_tmp_variable(dtype=dtype) helper.append_op( type='cast', inputs={'X': [x]}, outputs={'Out': [out]}, attrs={'in_dtype': x.dtype, 'out_dtype': out.dtype}) return out def concat(input, axis=0, name=None): """ **Concat** This function concatenates the input along the axis mentioned and returns that as the output. Args: input(list): List of tensors to be concatenated axis(int): Integer axis along which the tensors will be concatenated name(str|None): A name for this layer(optional). If set None, the layer will be named automatically. Returns: Variable: Output variable of the concatenation Examples: .. code-block:: python out = fluid.layers.concat(input=[Efirst, Esecond, Ethird, Efourth]) """ helper = LayerHelper('concat', **locals()) out = helper.create_tmp_variable(dtype=helper.input_dtype()) helper.append_op( type='concat', inputs={'X': input}, outputs={'Out': [out]}, attrs={'axis': axis}) return out def sums(input, out=None): """ This function performs the sum operation on the input and returns the result as the output. Args: input (Variable|list): The input tensor that has the elements that need to be summed up. out (Variable|None): Output parameter. The sum result. Default: None Returns: Variable: the sum of input. The same as the argument 'out' Examples: .. code-block:: python tmp = fluid.layers.zeros(shape=[10], dtype='int32') i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10) a0 = layers.array_read(array=tmp, i=i) i = layers.increment(x=i) a1 = layers.array_read(array=tmp, i=i) mean_a0 = layers.mean(a0) mean_a1 = layers.mean(a1) a_sum = layers.sums(input=[mean_a0, mean_a1]) """ helper = LayerHelper('sum', **locals()) if out is None: out = helper.create_tmp_variable(dtype=helper.input_dtype()) helper.append_op( type='sum', inputs={'X': input}, outputs={'Out': out}, attrs={'use_mkldnn': False}) return out def assign(input, output=None): """ **Assign** This function copies the *input* Variable to the *output* Variable. Args: input(Variable|numpy.ndarray): The source variable output(Variable|None): The destination variable Returns: Variable: The destination variable that was supplied as the *output*. Examples: .. code-block:: python out = fluid.layers.create_tensor(dtype='float32') hidden = fluid.layers.fc(input=data, size=10) fluid.layers.assign(hidden, out) """ helper = LayerHelper('assign', **locals()) if output is None: output = helper.create_tmp_variable(dtype=input.dtype) if isinstance(input, Variable): helper.append_op( type='assign', inputs={'X': [input]}, outputs={'Out': [output]}) elif isinstance(input, numpy.ndarray): dtype = convert_np_dtype_to_dtype_(input.dtype) if dtype == VarDesc.VarType.FP32: value_name = "fp32_values" values = [float(v) for v in input.flat] elif dtype == VarDesc.VarType.INT32: value_name = "int32_values" values = [int(v) for v in input.flat] else: raise ValueError("Unsupported dtype %s", input.dtype) if input.size > 1024 * 1024: raise ValueError("The size of input is too big. Please consider " "saving it to file and 'load_op' to load it") helper.append_op( type='assign_value', outputs={'Out': [output]}, attrs={ 'dtype': dtype, 'shape': list(input.shape), value_name: values }) else: raise ValueError("Wrong type for assign input: %s" % type(input)) return output def fill_constant(shape, dtype, value, force_cpu=False, out=None): """ **fill_constant** This function creates a tensor with specified `shape` and `dtype`, and initializes it with a constant specifed by `value`. The attribute `stop_gradient` of the created tensor is set to True. Args: shape(tuple|list|None): Shape of the output tensor. dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output tensor. value(float): The constant value used to initialize the output tensor. out(Variable): The output tensor. force_cpu(True|False): data should be on CPU if set true. Returns: Variable: The tensor variable storing the output. Examples: .. code-block:: python data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64') """ helper = LayerHelper("fill_constant", **locals()) if out is None: out = helper.create_tmp_variable(dtype=dtype) helper.append_op( type='fill_constant', inputs={}, outputs={'Out': [out]}, attrs={ 'shape': shape, 'dtype': out.dtype, 'value': float(value), 'force_cpu': force_cpu or force_init_on_cpu() }) out.stop_gradient = True return out @templatedoc() def fill_constant_batch_size_like(input, shape, dtype, value, input_dim_idx=0, output_dim_idx=0): """ ${comment} It also sets *stop_gradient* to True. >>> data = fluid.layers.fill_constant_batch_size_like( >>> input=like, shape=[1], value=0, dtype='int64') Args: input(${input_type}): ${input_comment}. shape(${shape_type}): ${shape_comment}. dtype(${dtype_type}): ${dtype_comment}. value(${value_type}): ${value_comment}. input_dim_idx(${input_dim_idx_type}): ${input_dim_idx_comment}. output_dim_idx(${output_dim_idx_type}): ${output_dim_idx_comment}. Returns: ${out_comment}. """ helper = LayerHelper("fill_constant_batch_size_like", **locals()) out = helper.create_tmp_variable(dtype=dtype) helper.append_op( type='fill_constant_batch_size_like', inputs={'Input': input}, outputs={'Out': [out]}, attrs={ 'shape': shape, 'dtype': out.dtype, 'value': float(value), 'input_dim_idx': input_dim_idx, 'output_dim_idx': output_dim_idx }) out.stop_gradient = True return out def argmin(x, axis=0): """ **argmin** This function computes the indices of the min elements of the input tensor's element along the provided axis. Args: x(Variable): The input to compute the indices of the min elements. axis(int): Axis to compute indices along. Returns: Variable: The tensor variable storing the output Examples: .. code-block:: python out = fluid.layers.argmin(x=in, axis=0) out = fluid.layers.argmin(x=in, axis=-1) """ helper = LayerHelper("arg_min", **locals()) out = helper.create_tmp_variable(VarDesc.VarType.INT64) helper.append_op( type='arg_min', inputs={'X': x}, outputs={'Out': [out]}, attrs={'axis': axis}) return out def argmax(x, axis=0): """ **argmax** This function computes the indices of the max elements of the input tensor's element along the provided axis. Args: x(Variable): The input to compute the indices of the max elements. axis(int): Axis to compute indices along. Returns: Variable: The tensor variable storing the output Examples: .. code-block:: python out = fluid.layers.argmax(x=in, axis=0) out = fluid.layers.argmax(x=in, axis=-1) """ helper = LayerHelper("arg_max", **locals()) out = helper.create_tmp_variable(VarDesc.VarType.INT64) helper.append_op( type='arg_max', inputs={'X': x}, outputs={'Out': [out]}, attrs={'axis': axis}) return out def argsort(input, axis=-1, name=None): """ Performs sorting on the input Variable along the given axis, and outputs sorted data Varibale and its corresponding index Variable with the same shape as :attr:`input`. .. code-block:: text For example, the given axis is -1 and the input Variable input = [[0.15849551, 0.45865775, 0.8563702 ], [0.12070083, 0.28766365, 0.18776911]], after argsort, the sorted Vairable becomes out = [[0.15849551, 0.45865775, 0.8563702 ], [0.12070083, 0.18776911, 0.28766365]], and the sorted indices along the given axis turn outs to be indices = [[0, 1, 2], [0, 2, 1]] Args: input(Variable): The input Variable for sorting. axis(int): The axis along which to sort the input Variable. When :attr:`axis` < 0, the actual axis will be :attr:`axis` + rank(:attr:`input`). Default -1, the last dimension. name(str|None): (optional) A name for this layer. If set None, the layer will be named automatically. Returns: tuple: A tuple of sorted data Variable and the sorted indices. Examples: .. code-block:: python input = fluid.layers.data(data=[2, 3]) out, indices = fluid.layers.argsort(input, axis=0) """ helper = LayerHelper("argsort", **locals()) out = helper.create_tmp_variable(dtype=input.dtype, stop_gradient=True) ids = helper.create_tmp_variable(VarDesc.VarType.INT64, stop_gradient=True) helper.append_op( type='argsort', inputs={'X': input}, outputs={'Out': out, 'Indices': ids}, attrs={'axis': axis}) return out, ids def ones(shape, dtype, force_cpu=False): """ **ones** This function creates a tensor of specified *shape* and *dtype*, and initializes this with 1. It also sets *stop_gradient* to True. Args: shape(tuple|list|None): Shape of output tensor dtype(np.dtype|core.VarDesc.VarType|str): Data type of output tensor Returns: Variable: The tensor variable storing the output Examples: .. code-block:: python data = fluid.layers.ones(shape=[1], dtype='int64') """ return fill_constant(value=1.0, **locals()) def zeros(shape, dtype, force_cpu=False): """ **zeros** This function creates a tensor of specified *shape* and *dtype*, and initializes this with 0. It also sets *stop_gradient* to True. Args: shape(tuple|list|None): Shape of output tensor. dtype(np.dtype|core.VarDesc.VarType|str): Data type of output tensor. force_cpu(bool, default False): Whether to make output stay on CPU. Returns: Variable: The tensor variable storing the output. Examples: .. code-block:: python data = fluid.layers.zeros(shape=[1], dtype='int64') """ return fill_constant(value=0.0, **locals()) def reverse(x, axis): """ **reverse** This function reverse the input 'x' along given axises. Args: x(Vairbale): the input to be reversed. axis(int|tuple|list): Axis that along which order of elements is reversed. If it is a tuple or a list, reversing will be apply on each axis in the tuple or list. Returns: Variable: The reversed tensor. Examples: .. code-block:: python out = fluid.layers.reverse(x=in, axis=0) # or: out = fluid.layers.reverse(x=in, axis=[0,1]) """ if isinstance(axis, int): axis = [axis] helper = LayerHelper("reverse", **locals()) out = helper.create_tmp_variable(dtype=x.dtype) helper.append_op( type='reverse', inputs={'Input': x}, outputs={'Out': [out]}, attrs={'axis': axis}) return out def save(x, file_path, overwrite=True): """ Saves a variable as a file. Args: x(variable): The Tensor/LoDTensor to be saved. file_path(str): The file path where the variable will be saved. overwrite(bool): Whether or not cover the given file when it has already existed. If it's set 'False' and the file is existed, a runtime error will be thrown. """ helper = LayerHelper("save", **locals()) helper.append_op( type="save", inputs={"input": x}, outputs={}, args={"file_path": file_path, "overwrite": overwrite}) def save_combine(x, file_path, overwrite=True): """ Saves a list of variables into a single file. Args: x(list): A list of Tensor/LoDTensor variables to be saved together in a single file. file_path(str): The file path where variables will be saved. overwrite(bool): Whether or not cover the given file when it has already existed. If it's set 'False' and the file is existed, a runtime error will be thrown. Returns: There is no return value. Examples: .. code-block:: python v1 = fluid.layers.data(name="data", shape=(4, 6), dtype="float32") v2 = fluid.layers.data(name="data", shape=(6, 8, 4), dtype="float32") normed = fluid.layers.save_combine([v1, v2], file_path="output") """ helper = LayerHelper("save_combine", **locals()) helper.append_op( type="save_combine", inputs={"input": x}, outputs={}, args={"file_path": file_path, "overwrite": overwrite}) def load_combine(out, file_path): """ Loads a list of vairables from a single file. Args: out(list): The list of variables to be read from the disk file. file_path(str): The path of the disk file. """ helper = LayerHelper("load_combine", **locals()) helper.append_op( type="load_combine", inputs={}, output={"Out": out}, args={"file_path": file_path})
the-stack_106_29264
#!/usr/bin/env python3 # Safe Update: A simple service that waits for network access and tries to # update every 10 minutes. It's intended to make the OP update process more # robust against Git repository corruption. This service DOES NOT try to fix # an already-corrupt BASEDIR Git repo, only prevent it from happening. # # During normal operation, both onroad and offroad, the update process makes # no changes to the BASEDIR install of OP. All update attempts are performed # in a disposable staging area provided by OverlayFS. It assumes the deleter # process provides enough disk space to carry out the process. # # If an update succeeds, a flag is set, and the update is swapped in at the # next reboot. If an update is interrupted or otherwise fails, the OverlayFS # upper layer and metadata can be discarded before trying again. # # The swap on boot is triggered by launch_chffrplus.sh # gated on the existence of $FINALIZED/.overlay_consistent and also the # existence and mtime of $BASEDIR/.overlay_init. # # Other than build byproducts, BASEDIR should not be modified while this # service is running. Developers modifying code directly in BASEDIR should # disable this service. import os import datetime import subprocess import psutil import shutil import signal import fcntl import time import threading from pathlib import Path from typing import List, Tuple, Optional from common.basedir import BASEDIR from common.markdown import parse_markdown from common.params import Params from selfdrive.hardware import EON, TICI, HARDWARE from selfdrive.swaglog import cloudlog from selfdrive.controls.lib.alertmanager import set_offroad_alert from selfdrive.version import is_tested_branch LOCK_FILE = os.getenv("UPDATER_LOCK_FILE", "/tmp/safe_staging_overlay.lock") STAGING_ROOT = os.getenv("UPDATER_STAGING_ROOT", "/data/safe_staging") NEOSUPDATE_DIR = os.getenv("UPDATER_NEOSUPDATE_DIR", "/data/neoupdate") OVERLAY_UPPER = os.path.join(STAGING_ROOT, "upper") OVERLAY_METADATA = os.path.join(STAGING_ROOT, "metadata") OVERLAY_MERGED = os.path.join(STAGING_ROOT, "merged") FINALIZED = os.path.join(STAGING_ROOT, "finalized") DAYS_NO_CONNECTIVITY_MAX = 14 # do not allow to engage after this many days DAYS_NO_CONNECTIVITY_PROMPT = 10 # send an offroad prompt after this many days class WaitTimeHelper: def __init__(self, proc): self.proc = proc self.ready_event = threading.Event() self.shutdown = False signal.signal(signal.SIGTERM, self.graceful_shutdown) signal.signal(signal.SIGINT, self.graceful_shutdown) signal.signal(signal.SIGHUP, self.update_now) def graceful_shutdown(self, signum: int, frame) -> None: # umount -f doesn't appear effective in avoiding "device busy" on NEOS, # so don't actually die until the next convenient opportunity in main(). cloudlog.info("caught SIGINT/SIGTERM, dismounting overlay at next opportunity") # forward the signal to all our child processes child_procs = self.proc.children(recursive=True) for p in child_procs: p.send_signal(signum) self.shutdown = True self.ready_event.set() def update_now(self, signum: int, frame) -> None: cloudlog.info("caught SIGHUP, running update check immediately") self.ready_event.set() def sleep(self, t: float) -> None: self.ready_event.wait(timeout=t) def run(cmd: List[str], cwd: Optional[str] = None, low_priority: bool = False): if low_priority: cmd = ["nice", "-n", "19"] + cmd return subprocess.check_output(cmd, cwd=cwd, stderr=subprocess.STDOUT, encoding='utf8') def set_consistent_flag(consistent: bool) -> None: os.sync() consistent_file = Path(os.path.join(FINALIZED, ".overlay_consistent")) if consistent: consistent_file.touch() elif not consistent: consistent_file.unlink(missing_ok=True) os.sync() def set_params(new_version: bool, failed_count: int, exception: Optional[str]) -> None: params = Params() params.put("UpdateFailedCount", str(failed_count)) last_update = datetime.datetime.utcnow() if failed_count == 0: t = last_update.isoformat() params.put("LastUpdateTime", t.encode('utf8')) else: try: t = params.get("LastUpdateTime", encoding='utf8') last_update = datetime.datetime.fromisoformat(t) except (TypeError, ValueError): pass if exception is None: params.delete("LastUpdateException") else: params.put("LastUpdateException", exception) # Write out release notes for new versions if new_version: try: with open(os.path.join(FINALIZED, "RELEASES.md"), "rb") as f: r = f.read().split(b'\n\n', 1)[0] # Slice latest release notes try: params.put("ReleaseNotes", parse_markdown(r.decode("utf-8"))) except Exception: params.put("ReleaseNotes", r + b"\n") except Exception: params.put("ReleaseNotes", "") params.put_bool("UpdateAvailable", True) # Handle user prompt for alert in ("Offroad_UpdateFailed", "Offroad_ConnectivityNeeded", "Offroad_ConnectivityNeededPrompt"): set_offroad_alert(alert, False) now = datetime.datetime.utcnow() dt = now - last_update if failed_count > 15 and exception is not None: if is_tested_branch(): extra_text = "Ensure the software is correctly installed" else: extra_text = exception set_offroad_alert("Offroad_UpdateFailed", True, extra_text=extra_text) elif dt.days > DAYS_NO_CONNECTIVITY_MAX and failed_count > 1: set_offroad_alert("Offroad_ConnectivityNeeded", True) elif dt.days > DAYS_NO_CONNECTIVITY_PROMPT: remaining = max(DAYS_NO_CONNECTIVITY_MAX - dt.days, 1) set_offroad_alert("Offroad_ConnectivityNeededPrompt", True, extra_text=f"{remaining} day{'' if remaining == 1 else 's'}.") def setup_git_options(cwd: str) -> None: # We sync FS object atimes (which NEOS doesn't use) and mtimes, but ctimes # are outside user control. Make sure Git is set up to ignore system ctimes, # because they change when we make hard links during finalize. Otherwise, # there is a lot of unnecessary churn. This appears to be a common need on # OSX as well: https://www.git-tower.com/blog/make-git-rebase-safe-on-osx/ # We are using copytree to copy the directory, which also changes # inode numbers. Ignore those changes too. # Set protocol to the new version (default after git 2.26) to reduce data # usage on git fetch --dry-run from about 400KB to 18KB. git_cfg = [ ("core.trustctime", "false"), ("core.checkStat", "minimal"), ("protocol.version", "2"), ("gc.auto", "0"), ("gc.autoDetach", "false"), ] for option, value in git_cfg: run(["git", "config", option, value], cwd) def dismount_overlay() -> None: if os.path.ismount(OVERLAY_MERGED): cloudlog.info("unmounting existing overlay") args = ["umount", "-l", OVERLAY_MERGED] if TICI: args = ["sudo"] + args run(args) def init_overlay() -> None: overlay_init_file = Path(os.path.join(BASEDIR, ".overlay_init")) # Re-create the overlay if BASEDIR/.git has changed since we created the overlay if overlay_init_file.is_file(): git_dir_path = os.path.join(BASEDIR, ".git") new_files = run(["find", git_dir_path, "-newer", str(overlay_init_file)]) if not len(new_files.splitlines()): # A valid overlay already exists return else: cloudlog.info(".git directory changed, recreating overlay") cloudlog.info("preparing new safe staging area") params = Params() params.put_bool("UpdateAvailable", False) set_consistent_flag(False) dismount_overlay() if TICI: run(["sudo", "rm", "-rf", STAGING_ROOT]) if os.path.isdir(STAGING_ROOT): shutil.rmtree(STAGING_ROOT) for dirname in [STAGING_ROOT, OVERLAY_UPPER, OVERLAY_METADATA, OVERLAY_MERGED]: os.mkdir(dirname, 0o755) if os.lstat(BASEDIR).st_dev != os.lstat(OVERLAY_MERGED).st_dev: raise RuntimeError("base and overlay merge directories are on different filesystems; not valid for overlay FS!") # Leave a timestamped canary in BASEDIR to check at startup. The device clock # should be correct by the time we get here. If the init file disappears, or # critical mtimes in BASEDIR are newer than .overlay_init, continue.sh can # assume that BASEDIR has used for local development or otherwise modified, # and skips the update activation attempt. consistent_file = Path(os.path.join(BASEDIR, ".overlay_consistent")) if consistent_file.is_file(): consistent_file.unlink() overlay_init_file.touch() os.sync() overlay_opts = f"lowerdir={BASEDIR},upperdir={OVERLAY_UPPER},workdir={OVERLAY_METADATA}" mount_cmd = ["mount", "-t", "overlay", "-o", overlay_opts, "none", OVERLAY_MERGED] if TICI: run(["sudo"] + mount_cmd) run(["sudo", "chmod", "755", os.path.join(OVERLAY_METADATA, "work")]) else: run(mount_cmd) git_diff = run(["git", "diff"], OVERLAY_MERGED, low_priority=True) params.put("GitDiff", git_diff) cloudlog.info(f"git diff output:\n{git_diff}") def finalize_update(wait_helper: WaitTimeHelper) -> None: """Take the current OverlayFS merged view and finalize a copy outside of OverlayFS, ready to be swapped-in at BASEDIR. Copy using shutil.copytree""" # Remove the update ready flag and any old updates cloudlog.info("creating finalized version of the overlay") set_consistent_flag(False) # Copy the merged overlay view and set the update ready flag if os.path.exists(FINALIZED): shutil.rmtree(FINALIZED) shutil.copytree(OVERLAY_MERGED, FINALIZED, symlinks=True) run(["git", "reset", "--hard"], FINALIZED) run(["git", "submodule", "foreach", "--recursive", "git", "reset"], FINALIZED) cloudlog.info("Starting git gc") t = time.monotonic() try: run(["git", "gc"], FINALIZED) cloudlog.event("Done git gc", duration=time.monotonic() - t) except subprocess.CalledProcessError: cloudlog.exception(f"Failed git gc, took {time.monotonic() - t:.3f} s") if wait_helper.shutdown: cloudlog.info("got interrupted finalizing overlay") else: set_consistent_flag(True) cloudlog.info("done finalizing overlay") def handle_agnos_update(wait_helper: WaitTimeHelper) -> None: from selfdrive.hardware.tici.agnos import flash_agnos_update, get_target_slot_number cur_version = HARDWARE.get_os_version() updated_version = run(["bash", "-c", r"unset AGNOS_VERSION && source launch_env.sh && \ echo -n $AGNOS_VERSION"], OVERLAY_MERGED).strip() cloudlog.info(f"AGNOS version check: {cur_version} vs {updated_version}") if cur_version == updated_version: return # prevent an openpilot getting swapped in with a mismatched or partially downloaded agnos set_consistent_flag(False) cloudlog.info(f"Beginning background installation for AGNOS {updated_version}") set_offroad_alert("Offroad_NeosUpdate", True) manifest_path = os.path.join(OVERLAY_MERGED, "selfdrive/hardware/tici/agnos.json") target_slot_number = get_target_slot_number() flash_agnos_update(manifest_path, target_slot_number, cloudlog) set_offroad_alert("Offroad_NeosUpdate", False) def handle_neos_update(wait_helper: WaitTimeHelper) -> None: from selfdrive.hardware.eon.neos import download_neos_update cur_neos = HARDWARE.get_os_version() updated_neos = run(["bash", "-c", r"unset REQUIRED_NEOS_VERSION && source launch_env.sh && \ echo -n $REQUIRED_NEOS_VERSION"], OVERLAY_MERGED).strip() cloudlog.info(f"NEOS version check: {cur_neos} vs {updated_neos}") if cur_neos == updated_neos: return cloudlog.info(f"Beginning background download for NEOS {updated_neos}") set_offroad_alert("Offroad_NeosUpdate", True) update_manifest = os.path.join(OVERLAY_MERGED, "selfdrive/hardware/eon/neos.json") neos_downloaded = False start_time = time.monotonic() # Try to download for one day while not neos_downloaded and not wait_helper.shutdown and \ (time.monotonic() - start_time < 60*60*24): wait_helper.ready_event.clear() try: download_neos_update(update_manifest, cloudlog) neos_downloaded = True except Exception: cloudlog.info("NEOS background download failed, retrying") wait_helper.sleep(120) # If the download failed, we'll show the alert again when we retry set_offroad_alert("Offroad_NeosUpdate", False) if not neos_downloaded: raise Exception("Failed to download NEOS update") cloudlog.info(f"NEOS background download successful, took {time.monotonic() - start_time} seconds") def check_git_fetch_result(fetch_txt: str) -> bool: err_msg = "Failed to add the host to the list of known hosts (/data/data/com.termux/files/home/.ssh/known_hosts).\n" return len(fetch_txt) > 0 and (fetch_txt != err_msg) def check_for_update() -> Tuple[bool, bool]: setup_git_options(OVERLAY_MERGED) try: git_fetch_output = run(["git", "fetch", "--dry-run"], OVERLAY_MERGED, low_priority=True) return True, check_git_fetch_result(git_fetch_output) except subprocess.CalledProcessError: return False, False def fetch_update(wait_helper: WaitTimeHelper) -> bool: cloudlog.info("attempting git fetch inside staging overlay") setup_git_options(OVERLAY_MERGED) git_fetch_output = run(["git", "fetch"], OVERLAY_MERGED, low_priority=True) cloudlog.info("git fetch success: %s", git_fetch_output) cur_hash = run(["git", "rev-parse", "HEAD"], OVERLAY_MERGED).rstrip() upstream_hash = run(["git", "rev-parse", "@{u}"], OVERLAY_MERGED).rstrip() new_version: bool = cur_hash != upstream_hash git_fetch_result = check_git_fetch_result(git_fetch_output) cloudlog.info(f"comparing {cur_hash} to {upstream_hash}") if new_version or git_fetch_result: cloudlog.info("Running update") if new_version: cloudlog.info("git reset in progress") r = [ run(["git", "reset", "--hard", "@{u}"], OVERLAY_MERGED, low_priority=True), run(["git", "clean", "-xdf"], OVERLAY_MERGED, low_priority=True ), run(["git", "submodule", "init"], OVERLAY_MERGED, low_priority=True), run(["git", "submodule", "update"], OVERLAY_MERGED, low_priority=True), ] cloudlog.info("git reset success: %s", '\n'.join(r)) if EON: handle_neos_update(wait_helper) elif TICI: handle_agnos_update(wait_helper) # Create the finalized, ready-to-swap update finalize_update(wait_helper) cloudlog.info("openpilot update successful!") else: cloudlog.info("nothing new from git at this time") return new_version def main() -> None: params = Params() if params.get_bool("DisableUpdates"): cloudlog.warning("updates are disabled by the DisableUpdates param") exit(0) ov_lock_fd = open(LOCK_FILE, 'w') try: fcntl.flock(ov_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) except OSError as e: raise RuntimeError("couldn't get overlay lock; is another instance running?") from e # Set low io priority proc = psutil.Process() if psutil.LINUX: proc.ionice(psutil.IOPRIO_CLASS_BE, value=7) # Check if we just performed an update if Path(os.path.join(STAGING_ROOT, "old_openpilot")).is_dir(): cloudlog.event("update installed") if not params.get("InstallDate"): t = datetime.datetime.utcnow().isoformat() params.put("InstallDate", t.encode('utf8')) overlay_init = Path(os.path.join(BASEDIR, ".overlay_init")) overlay_init.unlink(missing_ok=True) first_run = True last_fetch_time = 0.0 update_failed_count = 0 # TODO: Load from param? # Wait for IsOffroad to be set before our first update attempt wait_helper = WaitTimeHelper(proc) wait_helper.sleep(30) # Run the update loop # * every 5m, do a lightweight internet/update check # * every 10m, do a full git fetch while not wait_helper.shutdown: update_now = wait_helper.ready_event.is_set() wait_helper.ready_event.clear() # Attempt an update exception = None new_version = False update_failed_count += 1 try: init_overlay() internet_ok, update_available = check_for_update() if internet_ok and not update_available: update_failed_count = 0 # Fetch updates at most every 10 minutes if internet_ok and (update_now or time.monotonic() - last_fetch_time > 60*10): new_version = fetch_update(wait_helper) update_failed_count = 0 last_fetch_time = time.monotonic() if first_run and not new_version and os.path.isdir(NEOSUPDATE_DIR): shutil.rmtree(NEOSUPDATE_DIR) first_run = False except subprocess.CalledProcessError as e: cloudlog.event( "update process failed", cmd=e.cmd, output=e.output, returncode=e.returncode ) exception = f"command failed: {e.cmd}\n{e.output}" overlay_init.unlink(missing_ok=True) except Exception as e: cloudlog.exception("uncaught updated exception, shouldn't happen") exception = str(e) overlay_init.unlink(missing_ok=True) if not wait_helper.shutdown: try: set_params(new_version, update_failed_count, exception) except Exception: cloudlog.exception("uncaught updated exception while setting params, shouldn't happen") # TODO: replace this with a good backoff wait_helper.sleep(300) dismount_overlay() if __name__ == "__main__": main()
the-stack_106_29267
import numpy as np import json import os import cv2 import matplotlib.pyplot as plt from scipy.spatial.distance import cdist from scipy.optimize import linear_sum_assignment import argparse def computeIoU(head_bb, person_bb, epsilon=0.1, threshold=0.7): """ compute the ratio of intersection and union of the given head and the given person the area of the person is weighted by epsilon intersection over union = area of overlap / (area of head-box + epsilon * area of body-box) :param person_bb: person bounding box :param head_bb: head bounding box :param epsilon: weight for person area :return: "intersection over union"-like stuff """ headbox_area = (head_bb[2]-head_bb[0])*(head_bb[3]-head_bb[1]) person_area = (person_bb[2]-person_bb[0])*(person_bb[3]-person_bb[1]) dx = min(head_bb[2], person_bb[2])-max(head_bb[0], person_bb[0]) dy = min(head_bb[3], person_bb[3])-max(head_bb[1], person_bb[1]) result = 0 overlap_area = 0 if dx > 0 and dy > 0: # make sure person and head intersects overlap_area = dx * dy if computeIoH(overlap_area, headbox_area) > threshold: # TODO max problem instead of min result = -overlap_area / (headbox_area + epsilon * person_area) # if np.abs(result) > threshold: # return result # else: # return 0 return result def computeIoH(overlap, head): """ compute the ratio of intersection (of head and person) and head area intersection over head-box = area of overlap / area of head-box :param overlap: area of intersection :param head: area of head :return: IoH """ return overlap/head # in progress... def center(person_bb, head_bb, distance='euclidean'): # compute distance from the two centers width_head = head_bb[2]-head_bb[0] height_head = head_bb[3]-head_bb[1] center_head = np.array([head_bb[0]+width_head/2, head_bb[1]+height_head/2]) width_person = person_bb[2]-person_bb[0] height_person = person_bb[3]-person_bb[3] center_person = np.array([person_bb[0]+width_person/2, person_bb[1]+height_person/2]) return distance def generateColor(): """ random generate a colour :return: random GBR color """ color = tuple(np.random.choice(range(256), size=3)) return tuple(int(c) for c in color) def getSuffix(person_dir): suffix = (person_dir.strip().split('/'))[-1] if suffix == '': suffix = (person_dir.strip().split('/'))[-2] return suffix def makeOutDir(person_dir, out_dir_path): if out_dir_path == None: suffix = getSuffix(person_dir) out_dir_path = os.path.join('results/match', suffix) if not os.path.exists(out_dir_path): os.makedirs(out_dir_path) return out_dir_path def getMismatchedIndices(bboxes, aligned_indices): """ compute the indices of the bounding boxes that do not appear in any of the head-person pairs (matched by the hungarian algorithm) :param bboxes: bounding boxes :param aligned_indices: matched indices of bounding boxes :return: list of indices (of bounding boxes) that are not matched """ return [i for i in range(len(bboxes)) if i not in aligned_indices] def drawRectangles(indices, C, head_bbs, person_bbs, image): """ draw head and body bounding boxes on image :param indices: indices of the paired head bounding boxes and body bounding boxes :param C: cost matrix :param head_bbs: head bounding boxes :param person_bbs: person bounding boxes :param image: image to draw the rectangles on """ pair_indices = [(ind1, ind2) for ind1, ind2 in zip(indices[0], indices[1])] for (row_ind, col_ind) in pair_indices: if C[row_ind, col_ind] < 0: # print('Head: ', row_ind, head_bbs[row_ind], '\nPerson: ', col_ind, person_bbs[col_ind]) color = generateColor() cv2.rectangle(image, (head_bbs[row_ind][0], head_bbs[row_ind][1]), (head_bbs[row_ind][2], head_bbs[row_ind][3]), color, 2) cv2.rectangle(image, (person_bbs[col_ind][0], person_bbs[col_ind][1]), (person_bbs[col_ind][2], person_bbs[col_ind][3]), color, 1) else: (indices[0].tolist()).remove(row_ind) (indices[1].tolist()).remove(col_ind) for i in getMismatchedIndices(head_bbs, indices[0]): cv2.rectangle(image, (head_bbs[i][0], head_bbs[i][1]), (head_bbs[i][2], head_bbs[i][3]), (0, 0, 255), 2) for i in getMismatchedIndices(person_bbs, indices[1]): cv2.rectangle(image, (person_bbs[i][0], person_bbs[i][1]), (person_bbs[i][2], person_bbs[i][3]), (0, 255, 0), 1) def getPersonBoundingBoxes(person_dir, filename): json_data = json.load(open(os.path.join(person_dir, filename))) detections = [] if 'detections' in json_data.keys(): detections = json_data['detections'] person_bbs = [det['bbox'] for det in detections if det['class'] == 'person'] return person_bbs def getHeadBoundingBoxes(head_file, person_dir, filename): heads = open(head_file, 'r').readlines() raw_filename = (person_dir.strip().split('/'))[-1] + '/' + '.'.join((filename.strip().split('.'))[0:-1]) head_line = [line for line in heads if line.find(raw_filename) != -1] # print(raw_filename, head_line, person_bbs) head_bbs = [] if len(head_line) > 0: # and len(person_bbs) > 0: head_bbs = (head_line[0].strip().split('\t'))[1:] head_bbs = [[int(head_bbs[i]), int(head_bbs[i + 1]), int(head_bbs[i + 2]), int(head_bbs[i + 3])] for i in range(len(head_bbs)) if i % 5 == 0] return head_bbs def computeAlginments(head_bbs, person_bbs): indices = np.array([[], []]) C = np.zeros([len(head_bbs), len(person_bbs)]) if len(head_bbs) > 0 and len(person_bbs) > 0: C = cdist(XA=np.array(head_bbs), XB=np.array(person_bbs), metric=computeIoU) # maximize indices = linear_sum_assignment(C) return indices, C def Align(head_file, person_dir, image_dir, out_dir): # heads = open(head_file, 'r').readlines() # heads.extend(open(HEAD_bb_path_2, 'r').readlines()) print('Reading in files') for filename in os.listdir(person_dir): if filename.find('.json') != -1: person_bbs = getPersonBoundingBoxes(person_dir, filename) head_bbs = getHeadBoundingBoxes(head_file, person_dir, filename) indices, C = computeAlginments(head_bbs, person_bbs) img_format = '.png' if image_dir.find('HollywoodHeads')!=-1: img_format = '.jpeg' elif image_dir.find('MPII')!=-1: img_format = '.jpg' img_filename = '.'.join((filename.strip().split('.'))[0:-1]) + img_format image = cv2.imread(os.path.join(image_dir, img_filename)) drawRectangles(indices, C, head_bbs, person_bbs, image) print('image saved to ', os.path.join(out_dir, img_filename)) cv2.imwrite(os.path.join(OUT_DIR, img_filename), image) def parseArgs(argv=None): parser = argparse.ArgumentParser( description='(yolact) body-head aligner') parser.add_argument('--head', default='results/head_bounding_boxes/train_v3.csv', type=str, help='Path to annotated head bounding boxes csv file', required=False) parser.add_argument('--person', default='results/person_bounding_boxes/film8', type=str, help='Path to (yolact) directory containing person bounding boxes jsons', required=False) parser.add_argument('--images', default='data/head_det_corpus_v3/film8', type=str, help='Path to directory containing raw images', required=False) parser.add_argument('--outdir', default=None, type=str, help='Path to output directory', required=False) global args args = parser.parse_args(argv) if __name__ == '__main__': parseArgs() HEAD_FILE = args.head PERSON_DIR = args.person IMAGE_DIR = args.images OUT_DIR = makeOutDir(PERSON_DIR, args.outdir) Align(HEAD_FILE, PERSON_DIR, IMAGE_DIR, OUT_DIR)
the-stack_106_29268
from datetime import datetime, timedelta from urllib.parse import urljoin from isodate import parse_datetime, parse_duration import requests from solcast.base import Base class RadiationEstimatedActuals(Base): end_point = 'radiation/estimated_actuals' def __init__(self, latitude, longitude, *args, **kwargs): self.latitude = latitude self.longitude = longitude self.latest = kwargs.get('latest', False) self.estimated_actuals = None self.params = {'latitude' : self.latitude, 'longitude' : self.longitude} if self.latest: self.end_point = self.end_point + '/latest' self._get(*args, **kwargs) if self.ok: self._generate_est_acts_dict() def _generate_est_acts_dict(self): self.estimated_actuals = [] for est_act in self.content.get('estimated_actuals'): # Convert period_end and period. All other fields should already be # the correct type est_act['period_end'] = parse_datetime(est_act['period_end']) est_act['period'] = parse_duration(est_act['period']) self.estimated_actuals.append(est_act)
the-stack_106_29269
#!/usr/bin/env python # -*- coding: utf-8 -*- # Part of the PsychoPy library # Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2021 Open Science Tools Ltd. # Distributed under the terms of the GNU General Public License (GPL). """Minolta light-measuring devices See http://www.konicaminolta.com/instruments ---------- """ from __future__ import absolute_import, print_function from builtins import range from builtins import object from psychopy import logging import struct import sys import time try: import serial except ImportError: serial = False class LS100(object): """A class to define a Minolta LS100 (or LS110?) photometer You need to connect a LS100 to the serial (RS232) port and **when you turn it on press the F key** on the device. This will put it into the correct mode to communicate with the serial port. usage:: from psychopy.hardware import minolta phot = minolta.LS100(port) if phot.OK: # then we successfully made a connection print(phot.getLum()) :parameters: port: string the serial port that should be checked maxAttempts: int If the device doesn't respond first time how many attempts should be made? If you're certain that this is the correct port and the device is on and correctly configured then this could be set high. If not then set this low. :troubleshooting: Various messages are printed to the log regarding the function of this device, but to see them you need to set the printing of the log to the correct level:: from psychopy import logging logging.console.setLevel(logging.ERROR) # error messages only logging.console.setLevel(logging.INFO) # more info logging.console.setLevel(logging.DEBUG) # log all communications If you're using a keyspan adapter (at least on macOS) be aware that it needs a driver installed. Otherwise no ports will be found. Error messages: ``ERROR: Couldn't connect to Minolta LS100/110 on ____``: This likely means that the device is not connected to that port (although the port has been found and opened). Check that the device has the `[` in the bottom right of the display; if not turn off and on again holding the `F` key. ``ERROR: No reply from LS100``: The port was found, the connection was made and an initial command worked, but then the device stopped communating. If the first measurement taken with the device after connecting does not yield a reasonable intensity the device can sulk (not a technical term!). The "[" on the display will disappear and you can no longer communicate with the device. Turn it off and on again (with F depressed) and use a reasonably bright screen for your first measurement. Subsequent measurements can be dark (or we really would be in trouble!!). """ longName = "Minolta LS100/LS110" driverFor = ["ls110", "ls100"] def __init__(self, port, maxAttempts=1): super(LS100, self).__init__() if not serial: raise ImportError("The module serial is needed to connect to " "photometers. On most systems this can be " "installed with\n\t easy_install pyserial") if type(port) in [int, float]: # add one so that port 1=COM1 self.portNumber = port self.portString = 'COM%i' % self.portNumber else: self.portString = port self.portNumber = None self.isOpen = 0 self.lastQual = 0 self.lastLum = None self.type = 'LS100' self.com = False self.OK = True # until we fail self.maxAttempts = maxAttempts self.codes = { 'ER00\r\n': 'Unknown command', 'ER01\r\n': 'Setting error', 'ER11\r\n': 'Memory value error', 'ER10\r\n': 'Measuring range over', 'ER19\r\n': 'Display range over', 'ER20\r\n': 'EEPROM error (the photometer needs repair)', 'ER30\r\n': 'Photometer battery exhausted', } # try to open the port _linux = sys.platform.startswith('linux') if sys.platform in ('darwin', 'win32') or _linux: try: self.com = serial.Serial(self.portString) except Exception: msg = ("Couldn't connect to port %s. Is it being used by " "another program?") self._error(msg % self.portString) else: msg = "I don't know how to handle serial ports on %s" self._error(msg % sys.platform) # setup the params for comms if self.OK: self.com.close() # not sure why this helps but on win32 it does!! # this is a slightly odd characteristic of the Minolta LS100 self.com.bytesize = 7 self.com.baudrate = 4800 self.com.parity = serial.PARITY_EVEN # none self.com.stopbits = serial.STOPBITS_TWO try: if not self.com.isOpen(): self.com.open() except Exception: msg = "Opened serial port %s, but couldn't connect to LS100" self._error(msg % self.portString) else: self.isOpen = 1 if self.OK: # we have an open com port. try to send a command for repN in range(self.maxAttempts): time.sleep(0.2) for n in range(10): # set to use absolute measurements reply = self.sendMessage('MDS,04') if reply[0:2] == 'OK': self.OK = True break elif reply not in self.codes: self.OK = False break # wasn't valid else: self.OK = False # false so far but keep trying if self.OK: # we have successfully sent and read a command logging.info("Successfully opened %s" % self.portString) def setMode(self, mode='04'): """Set the mode for measurements. Returns True (success) or False '04' means absolute measurements. '08' = peak '09' = cont See user manual for other modes """ reply = self.sendMessage('MDS,%s' % mode) return self.checkOK(reply) def measure(self): """Measure the current luminance and set .lastLum to this value """ reply = self.sendMessage('MES') if self.checkOK(reply): lum = float(reply.split()[-1]) return lum else: return -1 def getLum(self): """Makes a measurement and returns the luminance value """ return self.measure() def clearMemory(self): """Clear the memory of the device from previous measurements """ reply = self.sendMessage('CLE') ok = self.checkOK(reply) return ok def checkOK(self, msg): """Check that the message from the photometer is OK. If there's an error show it (printed). Then return True (OK) or False. """ # also check that the reply is what was expected if msg[0:2] != 'OK': if msg == '': logging.error('No reply from LS100') sys.stdout.flush() else: logging.error('Error message from LS100:' + self.codes[msg]) sys.stdout.flush() return False else: return True def sendMessage(self, message, timeout=5.0): """Send a command to the photometer and wait an allotted timeout for a response. The message can be in either bytes or unicode but the returned string will always be utf-encoded. """ # append a newline if necessary (for either str or bytes) if type(message) == str: if message[-2:] != '\r\n': message += '\r\n' elif type(message) == bytes: if message[-2:] != b'\r\n': message += b'\r\n' # flush the read buffer first # read as many chars as are in the buffer self.com.read(self.com.inWaiting()) # then send message and catch any returned chars for attemptN in range(self.maxAttempts): # send the message time.sleep(0.1) if type(message) != bytes: message = bytes(message, 'utf-8') self.com.write(message) self.com.flush() time.sleep(0.1) # get reply (within timeout limit) self.com.timeout = timeout # send complete message logging.debug('Sent command:' + str(message[:-2])) retVal = self.com.readline().decode('utf-8') if len(retVal) > 0: break # we got a reply so can stop trying return retVal def _error(self, msg): self.OK = False logging.error(msg) def setMaxAttempts(self, maxAttempts): """Changes the number of attempts to send a message and read the output. Typically this should be low initially, if you aren't sure that the device is setup correctly but then, after the first successful reading, set it higher. """ self.maxAttempts = maxAttempts
the-stack_106_29272
import sys from PyQt5.QtCore import Qt, QDir, QUrl from PyQt5.QtGui import QFont from PyQt5.QtWidgets import QWidget, QGridLayout, QLabel, QPushButton, QApplication from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer class janela_vencedor(QWidget): def __init__(self, equipe_vencedora): QWidget.__init__(self) layout = QGridLayout() self.setLayout(layout) self.setFixedSize(800,400) titulo = QLabel("CAMPEAO DO VOLBSI 2019") titulo.setStyleSheet("color: yellow") titulo.setFont(QFont("Courier", 36)) titulo.setAlignment(Qt.AlignHCenter) layout.addWidget(titulo) campeao = QLabel(f'\ {equipe_vencedora} /') campeao.setStyleSheet("color: white") campeao.setFont(QFont("Decorative", 48)) campeao.setAlignment(Qt.AlignCenter) layout.addWidget(campeao) self.botao_sair = QPushButton("SAIR") self.botao_sair.setFont(QFont("Courier", 16)) self.botao_sair.clicked.connect(quit) layout.addWidget(self.botao_sair) self.music = '/home/Documentos/projetos/volbsi/music.mp3' self.player = QMediaPlayer() self.player.setMedia(QMediaContent(QUrl.fromLocalFile(self.music))) self.player.play() self.show() app = QApplication(sys.argv) screen = janela_vencedor("CORNOS FC") screen.show() sys.exit(app.exec_())
the-stack_106_29273
from constants import * from utils.db import connect_db @connect_db def add_email(db, email): table = db[EMAILS_TABLE] table.upsert(email, [EMAIL_KEY]) @connect_db def remove_email(db, email): table = db[EMAILS_TABLE] table.delete(email=email) @connect_db def get_email(db, email): table = db[EMAILS_TABLE] row = table.find_one(email=email) if row is not None: return row return None @connect_db def get_blocked_subscribers(db, offset, limit): table = db[EMAILS_TABLE] return table.find(status="blacklisted") @connect_db def remove_subscriber(db, uuid): table = db[EMAILS_TABLE] table.delete(uuid=str(uuid)) @connect_db def get_subscriber(db, uuid): table = db[EMAILS_TABLE] row = table.find_one(uuid=str(uuid)) if row is not None: return row return None @connect_db def get_all_emails(db, offset, limit): table = db[EMAILS_TABLE] return table.find() @connect_db def get_all_emails_unpaginated(db): table = db[EMAILS_TABLE] return table.find() @connect_db def add_uppy_config(db, config): table = db[UPPY_TABLE] config["id"] = 1 table.upsert(config, ["id"]) @connect_db def get_uppy_config(db): table = db[UPPY_TABLE] row = table.find_one(id=1) if row is not None: return row return None @connect_db def add_campaign(db, campaign): table = db[CAMPAIGNS_TABLE] campaign[UUID_KEY] = str(campaign[UUID_KEY]) campaign[TEMPLATE_KEY] = str(campaign[TEMPLATE_KEY]) table.upsert(campaign, [UUID_KEY]) @connect_db def get_campaign(db, uuid): table = db[CAMPAIGNS_TABLE] row = table.find_one(uuid=str(uuid)) if row is not None: return row return None @connect_db def get_all_campaigns(db, offset, limit): table = db[CAMPAIGNS_TABLE] return table.find() @connect_db def get_all_campaigns_unpaginated(db): table = db[CAMPAIGNS_TABLE] return table.find() @connect_db def get_campaign_count(db): return len(db[CAMPAIGNS_TABLE]) @connect_db def add_campaign_config(db, config): table = db[CONFIG_TABLE] config[UUID_KEY] = str(config[UUID_KEY]) table.upsert(config, [UUID_KEY]) @connect_db def remove_campaign_config(db, uuid): table = db[CONFIG_TABLE] table.delete(uuid=str(uuid)) @connect_db def get_campaign_config(db, uuid): table = db[CONFIG_TABLE] row = table.find_one(uuid=str(uuid)) if row is not None: return row return None @connect_db def get_campaign_config_default(db): table = db[CONFIG_TABLE] row = table.find_one(id=id) if row is not None: return row return None @connect_db def get_all_campaign_configs(db, offset, limit): table = db[CONFIG_TABLE] return table.find()
the-stack_106_29275
import os import sys import shutil import json import time import datetime import tempfile import warnings from collections import defaultdict import tensorflow as tf from tensorflow.python import pywrap_tensorflow from tensorflow.core.util import event_pb2 from tensorflow.python.util import compat DEBUG = 10 INFO = 20 WARN = 30 ERROR = 40 DISABLED = 50 class KVWriter(object): """ Key Value writer """ def writekvs(self, kvs): """ write a dictionary to file :param kvs: (dict) """ raise NotImplementedError class SeqWriter(object): """ sequence writer """ def writeseq(self, seq): """ write an array to file :param seq: (list) """ raise NotImplementedError class HumanOutputFormat(KVWriter, SeqWriter): def __init__(self, filename_or_file): """ log to a file, in a human readable format :param filename_or_file: (str or File) the file to write the log to """ if isinstance(filename_or_file, str): self.file = open(filename_or_file, 'wt') self.own_file = True else: assert hasattr(filename_or_file, 'write'), 'Expected file or str, got {}'.format(filename_or_file) self.file = filename_or_file self.own_file = False def writekvs(self, kvs): # Create strings for printing key2str = {} for (key, val) in sorted(kvs.items()): if isinstance(val, float): valstr = '%-8.3g' % (val,) else: valstr = str(val) key2str[self._truncate(key)] = self._truncate(valstr) # Find max widths if len(key2str) == 0: warnings.warn('Tried to write empty key-value dict') return else: keywidth = max(map(len, key2str.keys())) valwidth = max(map(len, key2str.values())) # Write out the data dashes = '-' * (keywidth + valwidth + 7) lines = [dashes] for (key, val) in sorted(key2str.items()): lines.append('| %s%s | %s%s |' % ( key, ' ' * (keywidth - len(key)), val, ' ' * (valwidth - len(val)), )) lines.append(dashes) self.file.write('\n'.join(lines) + '\n') # Flush the output to the file self.file.flush() @classmethod def _truncate(cls, string): return string[:20] + '...' if len(string) > 23 else string def writeseq(self, seq): seq = list(seq) for (i, elem) in enumerate(seq): self.file.write(elem) if i < len(seq) - 1: # add space unless this is the last one self.file.write(' ') self.file.write('\n') self.file.flush() def close(self): """ closes the file """ if self.own_file: self.file.close() class JSONOutputFormat(KVWriter): def __init__(self, filename): """ log to a file, in the JSON format :param filename: (str) the file to write the log to """ self.file = open(filename, 'wt') def writekvs(self, kvs): for key, value in sorted(kvs.items()): if hasattr(value, 'dtype'): if value.shape == () or len(value) == 1: # if value is a dimensionless numpy array or of length 1, serialize as a float kvs[key] = float(value) else: # otherwise, a value is a numpy array, serialize as a list or nested lists kvs[key] = value.tolist() self.file.write(json.dumps(kvs) + '\n') self.file.flush() def close(self): """ closes the file """ self.file.close() class CSVOutputFormat(KVWriter): def __init__(self, filename): """ log to a file, in a CSV format :param filename: (str) the file to write the log to """ self.file = open(filename, 'w+t') self.keys = [] self.sep = ',' def writekvs(self, kvs): # Add our current row to the history extra_keys = kvs.keys() - self.keys if extra_keys: self.keys.extend(extra_keys) self.file.seek(0) lines = self.file.readlines() self.file.seek(0) for (i, key) in enumerate(self.keys): if i > 0: self.file.write(',') self.file.write(key) self.file.write('\n') for line in lines[1:]: self.file.write(line[:-1]) self.file.write(self.sep * len(extra_keys)) self.file.write('\n') for i, key in enumerate(self.keys): if i > 0: self.file.write(',') value = kvs.get(key) if value is not None: self.file.write(str(value)) self.file.write('\n') self.file.flush() def close(self): """ closes the file """ self.file.close() def summary_val(key, value): """ :param key: (str) :param value: (float) """ kwargs = {'tag': key, 'simple_value': float(value)} return tf.Summary.Value(**kwargs) def valid_float_value(value): """ Returns True if the value can be successfully cast into a float :param value: (Any) the value to check :return: (bool) """ try: float(value) return True except TypeError: return False class TensorBoardOutputFormat(KVWriter): def __init__(self, folder): """ Dumps key/value pairs into TensorBoard's numeric format. :param folder: (str) the folder to write the log to """ os.makedirs(folder, exist_ok=True) self.dir = folder self.step = 1 prefix = 'events' path = os.path.join(os.path.abspath(folder), prefix) self.writer = pywrap_tensorflow.EventsWriter(compat.as_bytes(path)) def writekvs(self, kvs): summary = tf.Summary(value=[summary_val(k, v) for k, v in kvs.items() if valid_float_value(v)]) event = event_pb2.Event(wall_time=time.time(), summary=summary) event.step = self.step # is there any reason why you'd want to specify the step? self.writer.WriteEvent(event) self.writer.Flush() self.step += 1 def close(self): """ closes the file """ if self.writer: self.writer.Close() self.writer = None def make_output_format(_format, ev_dir, log_suffix=''): """ return a logger for the requested format :param _format: (str) the requested format to log to ('stdout', 'log', 'json', 'csv' or 'tensorboard') :param ev_dir: (str) the logging directory :param log_suffix: (str) the suffix for the log file :return: (KVWrite) the logger """ os.makedirs(ev_dir, exist_ok=True) if _format == 'stdout': return HumanOutputFormat(sys.stdout) elif _format == 'log': return HumanOutputFormat(os.path.join(ev_dir, 'log%s.txt' % log_suffix)) elif _format == 'json': return JSONOutputFormat(os.path.join(ev_dir, 'progress%s.json' % log_suffix)) elif _format == 'csv': return CSVOutputFormat(os.path.join(ev_dir, 'progress%s.csv' % log_suffix)) elif _format == 'tensorboard': return TensorBoardOutputFormat(os.path.join(ev_dir, 'tb%s' % log_suffix)) else: raise ValueError('Unknown format specified: %s' % (_format,)) # ================================================================ # API # ================================================================ def logkv(key, val): """ Log a value of some diagnostic Call this once for each diagnostic quantity, each iteration If called many times, last value will be used. :param key: (Any) save to log this key :param val: (Any) save to log this value """ Logger.CURRENT.logkv(key, val) def logkv_mean(key, val): """ The same as logkv(), but if called many times, values averaged. :param key: (Any) save to log this key :param val: (Number) save to log this value """ Logger.CURRENT.logkv_mean(key, val) def logkvs(key_values): """ Log a dictionary of key-value pairs :param key_values: (dict) the list of keys and values to save to log """ for key, value in key_values.items(): logkv(key, value) def dumpkvs(): """ Write all of the diagnostics from the current iteration """ Logger.CURRENT.dumpkvs() def getkvs(): """ get the key values logs :return: (dict) the logged values """ return Logger.CURRENT.name2val def log(*args, level=INFO): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). level: int. (see logger.py docs) If the global logger level is higher than the level argument here, don't print to stdout. :param args: (list) log the arguments :param level: (int) the logging level (can be DEBUG=10, INFO=20, WARN=30, ERROR=40, DISABLED=50) """ Logger.CURRENT.log(*args, level=level) def debug(*args): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). Using the DEBUG level. :param args: (list) log the arguments """ log(*args, level=DEBUG) def info(*args): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). Using the INFO level. :param args: (list) log the arguments """ log(*args, level=INFO) def warn(*args): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). Using the WARN level. :param args: (list) log the arguments """ log(*args, level=WARN) def error(*args): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). Using the ERROR level. :param args: (list) log the arguments """ log(*args, level=ERROR) def set_level(level): """ Set logging threshold on current logger. :param level: (int) the logging level (can be DEBUG=10, INFO=20, WARN=30, ERROR=40, DISABLED=50) """ Logger.CURRENT.set_level(level) def get_level(): """ Get logging threshold on current logger. :return: (int) the logging level (can be DEBUG=10, INFO=20, WARN=30, ERROR=40, DISABLED=50) """ return Logger.CURRENT.level def get_dir(): """ Get directory that log files are being written to. will be None if there is no output directory (i.e., if you didn't call start) :return: (str) the logging directory """ return Logger.CURRENT.get_dir() record_tabular = logkv dump_tabular = dumpkvs class ProfileKV: def __init__(self, name): """ Usage: with logger.ProfileKV("interesting_scope"): code :param name: (str) the profiling name """ self.name = "wait_" + name def __enter__(self): self.start_time = time.time() def __exit__(self, _type, value, traceback): Logger.CURRENT.name2val[self.name] += time.time() - self.start_time def profile(name): """ Usage: @profile("my_func") def my_func(): code :param name: (str) the profiling name :return: (function) the wrapped function """ def decorator_with_name(func): def func_wrapper(*args, **kwargs): with ProfileKV(name): return func(*args, **kwargs) return func_wrapper return decorator_with_name # ================================================================ # Backend # ================================================================ class Logger(object): # A logger with no output files. (See right below class definition) # So that you can still log to the terminal without setting up any output files DEFAULT = None CURRENT = None # Current logger being used by the free functions above def __init__(self, folder, output_formats): """ the logger class :param folder: (str) the logging location :param output_formats: ([str]) the list of output format """ self.name2val = defaultdict(float) # values this iteration self.name2cnt = defaultdict(int) self.level = INFO self.dir = folder self.output_formats = output_formats # Logging API, forwarded # ---------------------------------------- def logkv(self, key, val): """ Log a value of some diagnostic Call this once for each diagnostic quantity, each iteration If called many times, last value will be used. :param key: (Any) save to log this key :param val: (Any) save to log this value """ self.name2val[key] = val def logkv_mean(self, key, val): """ The same as logkv(), but if called many times, values averaged. :param key: (Any) save to log this key :param val: (Number) save to log this value """ if val is None: self.name2val[key] = None return oldval, cnt = self.name2val[key], self.name2cnt[key] self.name2val[key] = oldval * cnt / (cnt + 1) + val / (cnt + 1) self.name2cnt[key] = cnt + 1 def dumpkvs(self): """ Write all of the diagnostics from the current iteration """ if self.level == DISABLED: return for fmt in self.output_formats: if isinstance(fmt, KVWriter): fmt.writekvs(self.name2val) self.name2val.clear() self.name2cnt.clear() def log(self, *args, level=INFO): """ Write the sequence of args, with no separators, to the console and output files (if you've configured an output file). level: int. (see logger.py docs) If the global logger level is higher than the level argument here, don't print to stdout. :param args: (list) log the arguments :param level: (int) the logging level (can be DEBUG=10, INFO=20, WARN=30, ERROR=40, DISABLED=50) """ if self.level <= level: self._do_log(args) # Configuration # ---------------------------------------- def set_level(self, level): """ Set logging threshold on current logger. :param level: (int) the logging level (can be DEBUG=10, INFO=20, WARN=30, ERROR=40, DISABLED=50) """ self.level = level def get_dir(self): """ Get directory that log files are being written to. will be None if there is no output directory (i.e., if you didn't call start) :return: (str) the logging directory """ return self.dir def close(self): """ closes the file """ for fmt in self.output_formats: fmt.close() # Misc # ---------------------------------------- def _do_log(self, args): """ log to the requested format outputs :param args: (list) the arguments to log """ for fmt in self.output_formats: if isinstance(fmt, SeqWriter): fmt.writeseq(map(str, args)) Logger.DEFAULT = Logger.CURRENT = Logger(folder=None, output_formats=[HumanOutputFormat(sys.stdout)]) def configure(folder=None, format_strs=None): """ configure the current logger :param folder: (str) the save location (if None, $OPENAI_LOGDIR, if still None, tempdir/openai-[date & time]) :param format_strs: (list) the output logging format (if None, $OPENAI_LOG_FORMAT, if still None, ['stdout', 'log', 'csv']) """ if folder is None: folder = os.getenv('OPENAI_LOGDIR') if folder is None: folder = os.path.join(tempfile.gettempdir(), datetime.datetime.now().strftime("openai-%Y-%m-%d-%H-%M-%S-%f")) assert isinstance(folder, str) os.makedirs(folder, exist_ok=True) log_suffix = '' from mpi4py import MPI rank = MPI.COMM_WORLD.Get_rank() if rank > 0: log_suffix = "-rank%03i" % rank if format_strs is None: if rank == 0: format_strs = os.getenv('OPENAI_LOG_FORMAT', 'stdout,log,csv').split(',') else: format_strs = os.getenv('OPENAI_LOG_FORMAT_MPI', 'log').split(',') format_strs = filter(None, format_strs) output_formats = [make_output_format(f, folder, log_suffix) for f in format_strs] Logger.CURRENT = Logger(folder=folder, output_formats=output_formats) log('Logging to %s' % folder) def reset(): """ reset the current logger """ if Logger.CURRENT is not Logger.DEFAULT: Logger.CURRENT.close() Logger.CURRENT = Logger.DEFAULT log('Reset logger') class ScopedConfigure(object): def __init__(self, folder=None, format_strs=None): """ Class for using context manager while logging usage: with ScopedConfigure(folder=None, format_strs=None): {code} :param folder: (str) the logging folder :param format_strs: ([str]) the list of output logging format """ self.dir = folder self.format_strs = format_strs self.prevlogger = None def __enter__(self): self.prevlogger = Logger.CURRENT configure(folder=self.dir, format_strs=self.format_strs) def __exit__(self, *args): Logger.CURRENT.close() Logger.CURRENT = self.prevlogger # ================================================================ def _demo(): """ tests for the logger module """ info("hi") debug("shouldn't appear") set_level(DEBUG) debug("should appear") folder = "/tmp/testlogging" if os.path.exists(folder): shutil.rmtree(folder) configure(folder=folder) logkv("a", 3) logkv("b", 2.5) dumpkvs() logkv("b", -2.5) logkv("a", 5.5) dumpkvs() info("^^^ should see a = 5.5") logkv_mean("b", -22.5) logkv_mean("b", -44.4) logkv("a", 5.5) dumpkvs() with ScopedConfigure(None, None): info("^^^ should see b = 33.3") with ScopedConfigure("/tmp/test-logger/", ["json"]): logkv("b", -2.5) dumpkvs() reset() logkv("a", "longasslongasslongasslongasslongasslongassvalue") dumpkvs() warn("hey") error("oh") logkvs({"test": 1}) # ================================================================ # Readers # ================================================================ def read_json(fname): """ read a json file using pandas :param fname: (str) the file path to read :return: (pandas DataFrame) the data in the json """ import pandas data = [] with open(fname, 'rt') as file_handler: for line in file_handler: data.append(json.loads(line)) return pandas.DataFrame(data) def read_csv(fname): """ read a csv file using pandas :param fname: (str) the file path to read :return: (pandas DataFrame) the data in the csv """ import pandas return pandas.read_csv(fname, index_col=None, comment='#') def read_tb(path): """ read a tensorboard output :param path: (str) a tensorboard file OR a directory, where we will find all TB files of the form events. :return: (pandas DataFrame) the tensorboad data """ import pandas import numpy as np from glob import glob # from collections import defaultdict import tensorflow as tf if os.path.isdir(path): fnames = glob(os.path.join(path, "events.*")) elif os.path.basename(path).startswith("events."): fnames = [path] else: raise NotImplementedError("Expected tensorboard file or directory containing them. Got %s" % path) tag2pairs = defaultdict(list) maxstep = 0 for fname in fnames: for summary in tf.train.summary_iterator(fname): if summary.step > 0: for value in summary.summary.value: pair = (summary.step, value.simple_value) tag2pairs[value.tag].append(pair) maxstep = max(summary.step, maxstep) data = np.empty((maxstep, len(tag2pairs))) data[:] = np.nan tags = sorted(tag2pairs.keys()) for (colidx, tag) in enumerate(tags): pairs = tag2pairs[tag] for (step, value) in pairs: data[step - 1, colidx] = value return pandas.DataFrame(data, columns=tags) if __name__ == "__main__": _demo()
the-stack_106_29276
#!/usr/bin/env python # -*- coding: UTF-8 -*- # 地址:http: //www.runoob.com/python/python-exercise-example85.html def func(num): j = 1 sum = 9 m = 9 flag = True while flag: if sum % num == 0: print(sum) flag = False else: m *= 10 sum += m j += 1 print("%d 个 9 可以被 %d 整除 : %d" % (j, num, sum)) r = sum / num print("%d / %d = %d" % (sum, num, r)) # 给出一个奇数需要多少个99 才可以除尽它 if __name__ == "__main__": num = 21 # num = int(input("请输入一个正奇数:")) if num > 0 and num % 2 == 1: func(num) else: print("输入错误")
the-stack_106_29280
# circulaRprint # # Circular Plotter controller for Raspberry Pi # # Author: Oehrly, 2018 # ################################################# # # SegmentAccelerationPlanner and StepAccelerationPlanner # The SegmentAP manages the acceleration from segment to segment. # The StepAP manages the per step acceleration within a segment. # # Acknowledgement: # ... and may somebody else help you back on track when you're lost. # Thank you to Grbl for inspiration and to the one who wrote the extensive and useful comments. # for comparison see https://github.com/gnea/grbl/blob/master/grbl/planner.c # Calculations heavily rely on the fact that every PathSegment contains ONE (!) Beta axis step at max. # This is guaranteed by the way the XYPlaner handles path calculations. from math import sqrt, radians, ceil from datastructures import PathSegment class SegmentAccelerationPlanner: # Calculates the acceleration plan based on the following guidelines: # # 1. No junction speed may be higher than the specified junction speed limits or the entry/exit # speeds of neighbouring segments. # 2. The velocity difference between entry and exit speed of one segment has to be within the # allowable acceleration/deceleration limits for the head and all axes. # 3. Every segment should run at the acceleration limit so the speed is as high as possible # within the limits. # # Therefore the planner goes over every segment first in reverse order always making sure that the deceleration is # always at the maximum limit for reaching the entry speed of the following segment. # The last segment is always planned from a full stop to ensure that deceleration to a full stop is always possible. # # After that the planner goes over every segment in chronological (forward) order to ensure that no acceleration is # higher than allowed. It dials down the entry speeds of the next segments accordingly. # # To increase computational efficiency the planner checks during the forward pass up to which index of the buffer # the acceleration is already optimally planned. A indicator is set to this index. On the next go the planner only # calculates from the back of the buffer up to that index and back. # # If the buffer length is set too low, it can happen that the maximum speed is never reached as the total distance # in the buffer is not long enough to accelerate to the maximum speed. def __init__(self, config, provider): # load data from configuration self.FEED_RATE_MM = float(config['feed_rate']) self.ACCELERATION = float(config['acceleration']) self.MINIMUM_SPEED = float(config['minimum_feed_rate']) self.JUNCTION_DEVIATION = float(config['junction_deviation']) self.BETA_RADIUS = float(config['rB']) self.ALPHA_RES = float(radians(config['alpha_res'])) self.BETA_RES = float(radians(config['beta_res'])) self.ALPHA_ACCELERATION = float(config['a_acceleration']) self.BETA_ACCELERATION = float(config['b_acceleration']) # load max axis feed rates and convert from mm/sec to degree/sec self.ALPHA_FEED_RATE = float(config['a_feed_rate']) * self.ALPHA_RES self.BETA_FEED_RATE = float(config['b_feed_rate']) * self.BETA_RES self.Z_DELAY = 1 / float(config['z_feed_rate']) # calculate maximum beta acceleration in mm/sec^2 from steps/sec^2 # this is calculated independently per segment for alpha, # as the alpha radius changes depending on the current position self.BETA_ACCELERATION_MM = self.BETA_ACCELERATION * self.BETA_RADIUS * self.BETA_RES self.previous_nominal_speed = 0 self.previous_segment_x = 0 self.previous_segment_y = 0 self.previous_x_unit_vec = 0 self.previous_y_unit_vec = 0 self.previous_alpha = 0 self.previous_beta = 0 # the processing buffer is used to store the segments while they are used for calculations # testing revealed that a list seems to be fastest in the current implementation # an experimental ringbuffer was faster shifting the data through, # but it had to much overhead for iterations through the whole buffer self.processing_buffer = list() self.buffer_length = int(config['SegAP_buffer_length']) # buffer_planned indicates up to which index the buffer is already calculated optimally # After recalculation is done, all segments which are already optimal are deleted from the # processing buffer. After that the buffer is topped up again. self.buffer_planned = 0 # completed segments stores segments which are already fully calculated until they are requested self.completed_segments = list() self.bypass = list() self.last_segment_index = int(0) self.provider = provider # class which provides new segments def serve_next(self): if self.bypass and self.bypass[0].index == self.last_segment_index + 1: self.last_segment_index = self.bypass[0].index return self.bypass.pop(0) if self.completed_segments: self.last_segment_index = self.completed_segments[0].index return self.completed_segments.pop(0) else: while len(self.processing_buffer) < self.buffer_length: segment = self.provider.serve_next() if not segment: break segment, go_on = self.initiate_segment(segment) if go_on: self.processing_buffer.append(segment) else: if segment.index == self.last_segment_index + 1: self.last_segment_index = segment.index return segment else: self.bypass.append(segment) if not self.processing_buffer: return None if len(self.processing_buffer) > 1: self.recalculate_segment_buffer() if self.buffer_planned < 1: self.last_segment_index = self.processing_buffer[0].index ret = self.processing_buffer.pop(0) return ret else: self.completed_segments = self.processing_buffer[:self.buffer_planned + 1] del self.processing_buffer[:self.buffer_planned + 1] self.buffer_planned = 1 self.last_segment_index = self.completed_segments[0].index return self.completed_segments.pop(0) def recalculate_segment_buffer(self): # reverse pass through the processing buffer # always starts with an empty segment at the end to represent a stop current_seg = PathSegment(0, 0, 0, 0, 0, 0, 0, 0, None, None) for idx in range(-1, -len(self.processing_buffer) + self.buffer_planned, -1): next_seg = current_seg current_seg = self.processing_buffer[idx] # calculate the maximum entry speed by decelerating over the current segment # (mathematically we accelerate in reverse) entry_speed_sqr = next_seg.entry_speed_sqr + 2 * current_seg.acceleration * current_seg.distance if entry_speed_sqr < current_seg.max_entry_speed_sqr: current_seg.entry_speed_sqr = entry_speed_sqr else: current_seg.entry_speed_sqr = current_seg.max_entry_speed_sqr # forward_pass next_seg = self.processing_buffer[self.buffer_planned] for idx in range(self.buffer_planned + 1, len(self.processing_buffer), 1): current_seg = next_seg next_seg = self.processing_buffer[idx] # calculate maximum entry speed by accelerating over the current segment if current_seg.entry_speed_sqr < next_seg.entry_speed_sqr: entry_speed_sqr = current_seg.entry_speed_sqr + 2 * current_seg.acceleration * current_seg.distance if entry_speed_sqr < next_seg.entry_speed_sqr: next_seg.entry_speed_sqr = entry_speed_sqr # the current segment is at maximum acceleration, the buffer can not be improved anymore up to here # the buffer_planned indicator gets set to the new position self.buffer_planned = idx - 2 def limit_feed_rate_by_axis_limit(self, segment): # limits the feed rate for this segment to the lowest value of head, alpha and beta # calculate the minimum duration for the segment based on how far the axes # need to move and their maximum speeds (time = distance / velocity) alpha_dif = abs(self.previous_alpha - segment.alpha) t_min_a = alpha_dif / self.ALPHA_FEED_RATE beta_dif = abs(self.previous_beta - segment.beta) t_min_b = beta_dif / self.BETA_FEED_RATE # calculate maximum feed rate in mm/sec (velocity = distance / time) axis_feed_limit_mm = segment.distance / max(t_min_a, t_min_b) return min(self.FEED_RATE_MM, axis_feed_limit_mm) def limit_acceleration_by_axis_limit(self, segment): # limits the acceleration in this segment to the axes' maximum and the head's maximum # head acceleration is always relevant so it is added to the list of possible limits # by default acceleration_values = [self.ACCELERATION] # The alpha axis acceleration limit is set in steps/sec^2. This corresponds to a different amount # of mm/sec^2 depending on the distance of the current position to the table's center. # Therefore the acceleration limit in mm/sec^2 needs to be calculated for every segment # if the alpha axis needs to move. # In theory it needs to be calculated for every step but per segment should be exact enough. if segment.a_steps: alpha_dif = abs(self.previous_alpha - segment.alpha) distance_to_centre = sqrt(segment.x ** 2 + segment.y ** 2) # TODO set value in PathPlanner distance_per_alpha_step = (distance_to_centre * alpha_dif) / abs(segment.a_steps) alpha_acceleration_mm = self.ALPHA_ACCELERATION * distance_per_alpha_step # mm/s^2 = steps/s^2 * mm/step acceleration_values.append(alpha_acceleration_mm) # If the beta axis needs to move, the precalculated acceleration limit is added # to the list of possible values if segment.b_steps: acceleration_values.append(self.BETA_ACCELERATION_MM) return min(acceleration_values) def initiate_segment(self, segment): # All necessary values for further calculations are set here. # After this the segment can be loaded into the processing buffer. # # Technically some of these calculations are only suitable for cartesian printers. # Though, as one segment covers a very short distance only (normally), # everything should be approximately right. (For very short distances the movement is almost linear) # set z axis delay segment.z_delay = self.Z_DELAY # calculate distance covered by segment x_distance = segment.x - self.previous_segment_x y_distance = segment.y - self.previous_segment_y segment.distance = sqrt(x_distance ** 2 + y_distance ** 2) if not segment.a_steps and not segment.b_steps: return segment, False # filter out zero-length segments # calculate unit vectors segment.x_unit_vector = x_distance / segment.distance segment.y_unit_vector = y_distance / segment.distance # calculate feedrate and acceleration # TODO: add G00/G01 differences here segment.nominal_speed = self.limit_feed_rate_by_axis_limit(segment) segment.acceleration = self.limit_acceleration_by_axis_limit(segment) # calculate angle between previous and current path # the angle is the dot product of the two vectors # the calculation of the dot product is simplified through the usage of the unit vectors junction_cos_theta = -self.previous_x_unit_vec * segment.x_unit_vector - self.previous_y_unit_vec * segment.y_unit_vector if junction_cos_theta > 0.999999: # angle is 0 degrees i.e. the path makes a full turn segment.max_junction_speed_sqr = self.MINIMUM_SPEED ** 2 elif junction_cos_theta < -0.999999: # angle is 180 degrees i.e. the junction is a straight line segment.max_junction_speed_sqr = float('inf') else: sin_theta_d2 = sqrt(0.5 * (1.0 - junction_cos_theta)) # Trig half angle identity. Always positive. (Whatever that means; just taken from Grbl; it works...yeahy ;) # TODO: segment.acceleration is better replaced with junction_acceleration (see grbl) segment.max_junction_speed_sqr = max((self.MINIMUM_SPEED ** 2, (segment.acceleration * self.JUNCTION_DEVIATION * sin_theta_d2) / (1 - sin_theta_d2) )) # calculate max entry speed if segment.nominal_speed > self.previous_nominal_speed: segment.max_entry_speed_sqr = self.previous_nominal_speed ** 2 else: segment.max_entry_speed_sqr = segment.nominal_speed ** 2 if segment.max_entry_speed_sqr > segment.max_junction_speed_sqr: segment.max_entry_speed_sqr = segment.max_junction_speed_sqr # these variables are needed as a reference back to the current segment when calculating the next one self.previous_nominal_speed = segment.nominal_speed self.previous_x_unit_vec = segment.x_unit_vector self.previous_y_unit_vec = segment.y_unit_vector self.previous_segment_x = segment.x self.previous_segment_y = segment.y self.previous_alpha = segment.alpha self.previous_beta = segment.beta return segment, True class StepAccelerationPlanner: # Calculates the per step timing from segment entry and exit speeds # Goals are: # 1. Run both axis at as high as possible speeds for as long as possible # 2. Stay within all acceleration limits # # The planner accelerates/decelerates or cruises the axes so that the required exit speeds are reached. # This should always be possible within the per axis acceleration limits, as these are taken into account # when calculating the per segment acceleration in SegmentAccelerationPlanner. # If there are are enough steps to accelerate higher than the exit speed and decelerate again in time, # the planner will do so to maximize running speeds. def __init__(self, config, provider): # Load data from configuration file self.ALPHA_MAX_RATE = float(config['a_feed_rate']) self.BETA_MAX_RATE = float(config['b_feed_rate']) self.ALPHA_ACCELERATION = float(config['a_acceleration']) self.BETA_ACCELERATION = float(config['b_acceleration']) self.MINIMUM_RATE = float(config['minimum_axis_feed_rate']) # current and next segment; the current one is calculated, # the next one is needed as reference for the exit speed self.current = None self.next = None self.bypass = list() self.last_segment_index = 0 # current per axis step rates in steps/second self.rate_a = float(0) self.rate_b = float(0) self.provider = provider def serve_next(self): while 'this loop just goes on until a segment is returned': if self.bypass and self.bypass[0].index == self.last_segment_index + 1: self.last_segment_index = self.bypass[0].index return self.bypass.pop(0) while not self.next: # should only happen on first call and maybe next few # while there has not been a usable segment for self.next yet next_segment = self.provider.serve_next() if next_segment.a_steps and next_segment.b_steps: self.next = next_segment else: self.last_segment_index = next_segment.index return next_segment segment = self.provider.serve_next() if not segment: segment = PathSegment(0, 0, 0, 0, 0, 0, 0, 0, None, None) elif not segment.a_steps and not segment.b_steps: self.bypass.append(segment) continue self.current = self.next self.next = segment current_max_rate_a, current_max_rate_b = self.nominal_rate(self.current) next_max_entry_rate_a, next_max_entry_rate_b = self.max_entry_rate(self.next) self.accelerate_a(self.current, current_max_rate_a, next_max_entry_rate_a) self.accelerate_b(self.current, current_max_rate_b, next_max_entry_rate_b) self.last_segment_index = self.current.index return self.current def max_entry_rate(self, segment): # calculate the maximum entry step rate (steps/sec) for each axis in this segment # the calculation assumes the whole segment would be run at its entry speed (which is not really the case) # but it gives a theoretical segment duration which allows to calculate the entry rate if segment.entry_speed_sqr: t = segment.distance / sqrt(segment.entry_speed_sqr) max_entry_rate_a = abs(segment.a_steps) / t max_entry_rate_b = abs(segment.b_steps) / t return max(max_entry_rate_a, self.MINIMUM_RATE), max(max_entry_rate_b, self.MINIMUM_RATE) # return a low but non-zero rate # if the calculation returned 0 in case of a 0 entry speed, the printer would pause forever # also if the returned value is too low, the printer will no longer run smooth at slow speeds # a high value will not allow the printer to go slow enough and will also result in non-smooth runs return self.MINIMUM_RATE, self.MINIMUM_RATE def nominal_rate(self, segment): # calculate the nominal (i.e. maximum) step rate per axis for this segment # the calculation assumes the whole segment is run at its nominal speed. This results in a minimum # segment duration which allows to calculate the maximum step rate if segment.nominal_speed: t = segment.distance / segment.nominal_speed max_rate_a = abs(segment.a_steps) / t max_rate_b = abs(segment.b_steps) / t return max(max_rate_a, self.MINIMUM_RATE), max(max_rate_b, self.MINIMUM_RATE) # return a low but non-zero rate # same reasoning as for max_entry_rate() above return self.MINIMUM_RATE, self.MINIMUM_RATE def accelerate_a(self, segment, max_rate_a, exit_rate_a): # this function handles acceleration, cruising and deceleration for the alpha axis within one segment # possible scenarios are: # acc # acc acc cruise cruise cruise decel # only cruise only decel decel only # / ---- -------------- ---------- ---- \ # / / / \ \ \ # / / / \ \ \ # # for acc/cruise/decel the entry speed can be lower/equal/higher than the exit speed # # reverse counting the number of steps gives us the remaining number of steps for this segment # i.e. n is the number of steps remaining in this segment for remaining in range(abs(segment.a_steps), 0, -1): v_dif_a = self.rate_a - exit_rate_a # if slower than exit speed, always accelerate if v_dif_a < 0: self.rate_a += sqrt(2 * self.ALPHA_ACCELERATION) # check that neither current maximum nor next maximum entry speed are exceeded if self.rate_a > max_rate_a: self.rate_a = max_rate_a if self.rate_a > exit_rate_a and remaining == 1: self.rate_a = exit_rate_a # if faster than or equal to exit speed else: # calculate the number of steps it takes to decelerate from current rate to exit_rate breaking_dist = ceil((v_dif_a ** 2) / (2 * self.ALPHA_ACCELERATION)) # accelerate if there are enough steps left for decelerating within the acceleration limit # and current step rate is below max rate # check against breaking_dist + 1 is necessary because one step of acceleration also requires # one more step of deceleration than was required before accelerating if breaking_dist + 1 < remaining and self.rate_a < max_rate_a: self.rate_a += sqrt(2 * self.ALPHA_ACCELERATION) # check that current maximum rate is not exceeded if self.rate_a > max_rate_a: self.rate_a = max_rate_a # decelerate now elif breaking_dist + 1 >= remaining: self.rate_a -= sqrt(2 * self.ALPHA_ACCELERATION) # don't decelerate to a slower speed than required if self.rate_a < exit_rate_a: self.rate_a = exit_rate_a # if none of conditions above is met self.rate_a is not change (i.e. cruise) # TODO not possible at all?!? segment.a_timing.append(1 / self.rate_a) def accelerate_b(self, segment, max_rate_b, exit_rate_b): # Handles acceleration/cruising/deceleration for the beta axis # As each path segment may contain only one beta step, only one of these is possible per segment # do nothing if there is no b step if not segment.b_steps: return v_dif_b = self.rate_b - exit_rate_b # accelerate, current speed is slower than exit speed if v_dif_b < 0: self.rate_b += sqrt(2 * self.BETA_ACCELERATION) # check that neither current maximum nor next maximum entry speed are exceeded if self.rate_b > max_rate_b: self.rate_b = max_rate_b if self.rate_b > exit_rate_b: self.rate_b = exit_rate_b # decelerate, faster than exit speed elif v_dif_b > 0: self.rate_b -= sqrt(2 * self.BETA_ACCELERATION) # don't decelerate to a slower speed than required if self.rate_b < exit_rate_b: self.rate_b = exit_rate_b # if none of the above two conditions is met, the axis is already running at the desired speed b_delay = 1 / self.rate_b segment.b_timing.append(b_delay)
the-stack_106_29282
import argparse import datetime import json import logging import os import os.path import random import sys import time import urllib.request from mastodon import Mastodon import tracery from tracery.modifiers import base_english logging.basicConfig(level=logging.INFO) class Config: def __init__(self, path): self.path = os.path.abspath(os.path.expanduser(path)) with open(self.path) as f: self.from_dict(json.load(f)) def from_dict(self, json): self.base_url = json['base_url'] self.client_id = json['client_id'] self.client_secret = json['client_secret'] self.access_token = json['access_token'] self.post_interval = json['post_interval'] self.grammar_file = json['grammar_file'] def get_api(config): return Mastodon(client_id=config.client_id, client_secret=config.client_secret, api_base_url=config.base_url, access_token=config.access_token) class TraceryBot: def __init__(self, config): self.config = config self.api = get_api(self.config) with open(self.config.grammar_file) as f: self.grammar = tracery.Grammar(json.load(f)) self.grammar.add_modifiers(base_english) self.last_notification = -1 def handle_notifications(self): try: notifications = self.api.notifications() except Exception as e: logging.error('Exception while fetching notifications: %s', e) return if isinstance(notifications, dict) and ('error' in notifications): raise Exception('API error: {}'.format(notifications['error'])) if self.last_notification == -1: # if we've just started running, don't autorespond # retroactively if len(notifications) > 0: self.last_notification = int(notifications[0]['id']) logging.debug('Ignoring previous notifications up to %d', self.last_notification) else: self.last_notification = 0 else: # reversed order to process notification in chronological order for notification in notifications[::-1]: if int(notification['id']) <= self.last_notification: continue if notification['type'] != 'mention': continue logging.debug('Handling notification %s', notification['id']) self.last_notification = int(notification['id']) sender = notification['status']['account']['acct'] reply_attempts_remaining = 10 while reply_attempts_remaining: reply = '@{} {}'.format( sender, self.grammar.flatten("#reply#")) if len(reply) <= 500: break reply_attempts_remaining -= 1 if reply_attempts_remaining == 0: logging.debug("Couldn't generate reply to notification %s", notification['id']) return reply_sent = self.api.status_post(reply, in_reply_to_id=notification['status']['id']) logging.info('Responded to status %s from %s', notification['status']['id'], notification['status']['account']['acct']) def post_toot(self): attempts_remaining = 10 while attempts_remaining: toot = self.grammar.flatten("#toot#") if len(toot) <= 500: break attempts_remaining -= 1 if attempts_remaining == 0: logging.debug("Couldn't generate toot") return self.api.status_post(toot, visibility='public') def run(self): countdown = 0 while True: if countdown <= 0: self.post_toot() countdown = self.config.post_interval countdown -= 1 self.handle_notifications() time.sleep(60) def main(): parser = argparse.ArgumentParser() parser.add_argument('-c', '--config', help='File to load the config from.', default='config.json') args = parser.parse_args() config = Config(args.config) bot = TraceryBot(config) bot.run() if __name__ == '__main__': main()
the-stack_106_29283
import pkg_resources from mako.lookup import TemplateLookup from bravado_types.config import Config from bravado_types.data_model import SpecInfo from bravado_types.metadata import Metadata def render(metadata: Metadata, spec: SpecInfo, config: Config) -> None: """ Render module and stub files for a given Swagger schema. :param metadata: Code generation metadata. :param spec: SpecInfo representing the schema. :param config: Code generation configuration. """ template_dirs = [] if config.custom_templates_dir: template_dirs.append(config.custom_templates_dir) template_dirs.append( pkg_resources.resource_filename(__name__, "templates/")) lookup = TemplateLookup(directories=template_dirs) py_template = lookup.get_template("module.py.mako") with open(config.py_path, "w") as f: f.write(py_template.render(metadata=metadata, spec=spec, config=config)) pyi_template = lookup.get_template("module.pyi.mako") with open(config.pyi_path, "w") as f: f.write(pyi_template.render(metadata=metadata, spec=spec, config=config)) if config.postprocessor: config.postprocessor(config.py_path, config.pyi_path)
the-stack_106_29286
import pytest import torch from deepspeech.models import DeepSpeech2 @pytest.fixture def model(): return DeepSpeech2() def test_load_state_dict_restores_parameters(model): act_model = DeepSpeech2() act_model.load_state_dict(model.state_dict()) # Naive equality check: all network parameters are equal. exp_params = dict(model.network.named_parameters()) print(exp_params.keys()) for act_name, act_param in act_model.network.named_parameters(): assert torch.allclose(act_param.float(), exp_params[act_name].float())
the-stack_106_29288
import logging import requests import pickle import os import json import urllib from math import sin, cos, sqrt, atan2, radians log = logging.getLogger(__name__) # Telegram tokens - see https://www.mariansauter.de/2018/01/send-telegram-notifications-to-your-mobile-from-python-opensesame/ # bot_token = 'your token' bot_chatID = 'your chat id' # Constants # # average ICE g/km ice_emissions = 120.1 # Average UK g/kWh # electric_emissions = 225.0 # Octopus g/kWh electric_emissions = 0.0 # max range # wltp = 279 # FIX THIS - add in SOH to calcs # list of non-stanard chargers # chargers = [ {'latitude':0, 'longitude':0, 'msg':'At home, '+'5p/KWh overnight'} ] """ Poll to see if car is being charged. If so : 1. Disable auto sleep whilst charging 2. Send Telegram message when charging starts - Estimated miles per kWh ( based on miles travelled and delta Accumulative Charge Power ) - Estimaed CO2 saved on fuel since last charged ( based on ICE emissions and electricity supplier ) - Estimated total CO2 saved since purchase ( based on total milage and ICE emissions ) - Details of nearest charger ( ie probabally what is being used to charge car ) - Estimated range ( based on WLTP ) 3. Send Telegram message when charging reaches each 10% 5. Send Telegram message when charging stops """ def poll(): # enable sleep in case anything goes wrong below # enable_sleep() # load previous status # persistance = load() # check if we are driving or charging # driving = get_driving() if driving == 1 or driving == -1: if persistance['charging'] == True: if persistance['soc'] >= 99: persistance['soc'] = 100 bot_sendtext('Charging *stopped*. Last known State of charge *'+format(persistance['soc'],'.1f')+'%* ('+format(wltp*persistance['soc']/100, '.1f')+' miles) charged '+format(persistance['cec']-persistance['start_cec'],'.1f')+'kWh') persistance['charging'] = False save(persistance) return {'msg': 'Not charging'} batt_power = get_charging_power() # avoid fake charging # if batt_power <= 0: return {'msg': 'Not charging - power less than zero'} # now we are charging # disable_sleep() soc = get_soc() cec = get_cec() # alert if just started to charge # if persistance['charging'] == False: last_charge_odo = persistance['odo'] last_charge_soc = persistance['soc'] odo = get_odometer() persistance['odo'] = odo persistance['start_cec'] = cec if last_charge_soc != soc: mperkwh = (odo-last_charge_odo)/(last_charge_soc*64.0/100.0-soc*64.0/100.0) else: mperkwh = 0.0 co2saved = (ice_emissions*(odo-last_charge_odo)*1.609) - electric_emissions*(last_charge_soc*64.0/100.0-soc*64.0/100.0) bot_sendtext('Estmated *'+format(mperkwh,'.2f')+'mi/kWh* since last charge') bot_sendtext('*'+format(co2saved/1000,'.2f')+'Kg* CO2 saved since last charge') bot_sendtext('*'+format(odo*ice_emissions/1000000,'.2f')+'tonnes* CO2 saved in total') bot_sendtext(nearest_charger()) bot_sendtext('Charging *started* at a rate of '+format(batt_power,'.2f')+'kW. State of charge now *'+format(soc,'.1f')+'%* ('+format(wltp*soc/100, '.1f')+' miles)') # each 10% alaert # for level in xrange(0, 100, 10): if soc >= level and persistance['soc'] < level: bot_sendtext('Charging *now* at a rate of '+format(batt_power,'.2f')+'kW. State of charge now *'+format(soc,'.1f')+'%* ('+format(wltp*soc/100, '.1f')+' miles)') break # store status for next time # persistance['charging'] = True persistance['soc'] = soc persistance['cec'] = cec save(persistance) return {'msg': 'Charging at '+format(batt_power,'.2f')+'kW, SOC now *'+format(soc,'.1f')+'%*'} # send message to telegram # def bot_sendtext(bot_message): send_text = 'https://api.telegram.org/bot' + bot_token + '/sendMessage?' + urllib.urlencode({'chat_id': bot_chatID, 'parse_mode': 'Markdown', 'text': unicode(bot_message).encode('utf-8')}) requests.get(send_text) # load persistance # def load(): try: p = pickle.load( open( 'charge_status.p', 'rb' ) ) except: p = { 'charging': False, 'soc': 0.0, 'odo': 0, 'cec': 0.0, 'start_cec': 0.0 } return p # save persistance # def save(p): pickle.dump( p, open( 'charge_status.p', 'wb' ) ) # delete persistance # def delete(): os.remove('charge_status.p') # dump persistance # def dump(): return load() # check if we are driving. Returns : # 0 - charging # 1 - driving # -1 - can't read data def get_driving(): try: args = ['driving'] kwargs = { 'mode': '220', 'pid': '101', 'header': '7E4', 'baudrate': 500000, 'formula': 'bytes_to_int(message.data[53:54])', 'protocol': '6', 'verify': False, 'force': True, } # note - sums are done outside of the forumla due to autopi failing # with 0 # return (int(__salt__['obd.query'](*args, **kwargs)['value'])&4)/4 except: return -1 # get charging power # def get_charging_power(): args = ['charging_power'] kwargs = { 'mode': '220', 'pid': '101', 'header': '7E4', 'baudrate': 500000, 'formula': '(twos_comp(bytes_to_int(message.data[13:14])*256+bytes_to_int(message.data[14:15]),16)/10.0)*((bytes_to_int(message.data[15:16])*256+bytes_to_int(message.data[16:17]))/10.0)/1000.0', 'protocol': '6', 'verify': False, 'force': True, } return __salt__['obd.query'](*args, **kwargs)['value']*-1.0 # get display state of charge # def get_soc(): args = ['soc'] kwargs = { 'mode': '220', 'pid': '105', 'header': '7E4', 'baudrate': 500000, 'formula': 'bytes_to_int(message.data[34:35])/2.0', 'protocol': '6', 'verify': False, 'force': True, } return __salt__['obd.query'](*args, **kwargs)['value'] # get odometer # def get_odometer(): args = ['odometer'] kwargs = { 'mode': '22', 'pid': 'B002', 'header': '7C6', 'baudrate': 500000, 'formula': 'bytes_to_int(message.data[11:12])*16777216+bytes_to_int(message.data[12:13])*65536+bytes_to_int(message.data[13:14])*256+bytes_to_int(message.data[14:15])', 'protocol': '6', 'verify': False, 'force': True, } return __salt__['obd.query'](*args, **kwargs)['value'] # get Accumulative Charge Power # def get_cec(): args = ['odometer'] kwargs = { 'mode': '220', 'pid': '101', 'header': '7E4', 'baudrate': 500000, 'formula': '(bytes_to_int(message.data[41:42])*16777216+bytes_to_int(message.data[42:43])*65536+bytes_to_int(message.data[43:44])*256+bytes_to_int(message.data[44:45]))/10.0', 'protocol': '6', 'verify': False, 'force': True, } return __salt__['obd.query'](*args, **kwargs)['value'] # enable autopi sleep # def enable_sleep(): args = ['sleep'] kwargs = { 'enable': True, } __salt__['power.sleep_timer'](**kwargs) # disable autopi sleep # def disable_sleep(): args = ['sleep'] kwargs = { 'enable': False, } __salt__['power.sleep_timer'](**kwargs) # get location # def get_location(): args = [] kwargs = {} return __salt__['ec2x.gnss_nmea_gga'](*args, **kwargs) # get nearest charger # def nearest_charger(): location = get_location() for charger in chargers: lat1 = radians(charger['latitude']) lon1 = radians(charger['longitude']) lat2 = radians(location['latitude']) lon2 = radians(location['longitude']) dlon = lon2 - lon1 dlat = lat2 - lat1 a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) dist = 6373.0 * c if dist < 0.02: log.info('found local charger '+charger['msg']) return charger['msg'] log.info('https://api.openchargemap.io/v3/poi/?output=json&distance=0.1&maxresults=1&latitude='+str(location['latitude'])+'&longitude='+str(location['longitude'])) result = requests.get('https://api.openchargemap.io/v3/poi/?output=json&distance=0.1&maxresults=1&latitude='+str(location['latitude'])+'&longitude='+str(location['longitude'])) for i in result.json(): return i['OperatorInfo']['Title']+', '+i['AddressInfo']['Title']+', '+i['UsageCost'] return 'No local charger found'
the-stack_106_29289
import _plotly_utils.basevalidators class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): def __init__( self, plotly_name='textfont', parent_name='scatterpolargl.selected', **kwargs ): super(TextfontValidator, self).__init__( plotly_name=plotly_name, parent_name=parent_name, data_class_str='Textfont', data_docs=""" color Sets the text font color of selected points. """, **kwargs )
the-stack_106_29290
import os import sys import torch import torch.nn as nn import torch.nn.functional as F from train_noff1 import main, create_argparser import valid_noff1 from multiprocessing import Process from datetime import datetime from time import sleep def hidden_dim_search(): # get default args and manipulate them args = create_argparser().parse_args([]) args.valid_batches_max = 10 args.save_model = True args.lambda_srv = 1.0 args.logdir = '/publicwork/adler/melvin/runs' hidden_dim = [256, 128, 64, 32] lr = [0.01, 0.02, 0.05, 0.1] gpu = [0, 1, 2, 3] proc = [] for h, l, g in zip(hidden_dim, lr, gpu): args.name = 'h%d_l%d' % (h, int(l*100)) args.lstm_hidden_dim = h args.snn_hidden_dim = [h, h, h] args.lr = l args.gpu = 0 #g proc.append(Process(target=main, args=(args,))) proc[-1].start() [p.join() for p in proc] def compare_srv_loss(): # get default args and manipulate them args = create_argparser().parse_args([]) args.valid_batches_max = 10 args.save_model = True #args.logdir = '/publicwork/adler/melvin/runs' args.lstm_hidden_dim = 256 args.snn_hidden_dim = [256] * 3 args.epochs = 6 args.lr = 0.01 args.gpu = 0 args.lambda_srv = 1.0 args.srv_loss = 'poisson_binomial' proc = [] for lambda_srv in [1.0]: args.name = args.srv_loss + '_%.1f' % lambda_srv args.lambda_srv = lambda_srv proc.append(Process(target=main, args=(args,))) proc[-1].start() [p.join() for p in proc] def srvreg(): # get default args and manipulate them args = create_argparser().parse_args([]) name = datetime.now().strftime('%Y-%m-%dT%H-%M-%S') + '/srvreg_' args.logdir = '/home/tomte/projects/melvin/runs' args.lstm_hidden_dim = 256 args.snn_hidden_dim = [256] * 3 args.epochs = 6 args.gpu = 0 srv_loss = ['mse', 'poisson_binomial'] lr = [0.001, 0.017] task = ['srv', 'srv'] proc = [] for t, s, l in zip(task, srv_loss, lr): args.name = name + s args.lr = l args.srv_loss = s args.task = t proc.append(Process(target=main, args=(args,))) proc[-1].start() [p.join() for p in proc] def cross_validation(): name = 'fold%02d' # training args args = create_argparser().parse_args([]) args.logdir = '/publicwork/adler/melvin/ccv' args.lstm_hidden_dim = 1024 args.lr = 0.1 args.batch_size = 512 args.log_interval = 100 args.data = '/local00/bioinf/adler/melvinNoFF1Train.db' # validation args valid_args = valid_noff1.create_argparser().parse_args([]) valid_args.batch_size = 4096 valid_args.gpu = 0 valid_args.data = '/local00/bioinf/adler/melvinNoFF1Train.db' train_job = [] valid_job = [] # start training jobs in parallel on 4 GPUs for fold in range(11): args.fold = fold args.name = name % fold args.gpu = fold % 4 args.stdout = name % fold + '_train.log' # start training job train_job.append(Process(target=main, args=(args,))) train_job[-1].start() # wait until initial models are written to file sleep(15) # start validation jobs for fold in range(11): valid_args.gpu = fold % 4 valid_args.stdout = name % fold + '_valid.log' valid_args.model_name = os.path.join(args.logdir, name % fold, 'model') valid_job.append(Process(target=valid_noff1.main, args=(valid_args,))) valid_job[-1].start() # wait for training jobs to finish and terminate validation jobs for t, v in zip(train_job, valid_job): t.join() sleep(300) # give validation job another 5 mins to finish v.terminate() v.join() if sys.version_info.major >= 3 and sys.version_info.minor >= 7: t.close() v.close() def fold08_grid_search(): #FIXME: get this to work!!!! name = 'f08gs_h%d_lr%f_bs%d' # training args args = create_argparser().parse_args([]) args.logdir = '/publicwork/adler/melvin/grid' args.embedding_dim = 512 h = [4096, 2048] lr = [0.1, 0.1] bs = [128, 128] args.log_interval = 100 args.data = '/local00/bioinf/adler/melvinNoFF1Train.db' args.fold = 8 train_job = [] for i, (h_, lr_, bs_) in enumerate(zip(h, lr, bs)): args.name = name % (h_, lr_, bs_) args.lstm_hidden_dim = h_ args.lr = lr_ args.batch_size = bs_ args.gpu = i % 4 args.stdout = os.path.join(args.logdir, args.name, 'train.log') train_job.append(Process(target=main, args=(args,))) train_job[-1].start() print('job started') sleep(30) # validation args valid_args = valid_noff1.create_argparser().parse_args([]) valid_args.batch_size = 4096 valid_args.data = '/local00/bioinf/adler/melvinNoFF1Train.db' valid_job = [] for i, (h_, lr_, bs_) in enumerate(zip(h, lr, bs)): valid_args.name = name % (h_, lr_, bs_) valid_args.gpu = i % 4 valid_args.stdout = os.path.join(args.logdir, valid_args.name, 'valid.log') valid_args.model_name = os.path.join(args.logdir, valid_args.name, 'model') valid_job.append(Process(target=valid_noff1.main, args=(valid_args,))) valid_job[-1].start() # wait for training jobs to finish for j in train_job: j.join() if sys.version_info.major >= 3 and sys.version_info.minor >= 7: j.close() # give validation jobs another 10 mins sleep(600) # terminate validation jobs for j in valid_job: j.terminate() j.join() if sys.version_info.major >= 3 and sys.version_info.minor >= 7: j.close() if __name__ == '__main__': fold08_grid_search()
the-stack_106_29291
# -*- coding: utf-8 -*- import re from pathlib import Path from textwrap import dedent from unittest.mock import call, patch import pytest from jsonschema import ValidationError from jaffle.config.jaffle_config import JaffleConfig from jaffle.config.template_string import TemplateString from jaffle.config.value import ConfigDict def test_jaffle_config(): conf = JaffleConfig({}) assert conf.namespace == {} namespace = {'foo': 'FOO', 'bar': 'BAR'} conf = JaffleConfig( namespace, variable={'baz': 'BAZ'}, kernel={'my_kernel': { 'kernel_name': 'python3' }}, app={ 'my_app': { 'class': 'my.app.MyApp', 'logger': { 'suppress_regex': ['pat1 ${foo}', 'pat2'], 'replace_regex': [{ 'from': 'pat_from ${foo}', 'to': 'pat_to ${bar}' }] } } }, process={'my_proc': { 'command': 'my_proc' }}, job={'my_job': { 'command': 'my_job' }}, logger={ 'level': 'debug', 'suppress_regex': ['global_pat1', 'global_pat2 ${foo}'], 'replace_regex': [{ 'from': 'global_pat_from ${bar}', 'to': 'global_pat_to ${foo}' }] } ) assert conf.namespace == namespace assert conf.variable == ConfigDict({'baz': 'BAZ'}, namespace) assert conf.kernel == ConfigDict({'my_kernel': {'kernel_name': 'python3'}}, namespace) assert conf.app == ConfigDict({ 'my_app': { 'class': 'my.app.MyApp', 'logger': { 'suppress_regex': ['pat1 ${foo}', 'pat2'], 'replace_regex': [{ 'from': 'pat_from ${foo}', 'to': 'pat_to ${bar}' }] } } }, namespace) assert conf.process == ConfigDict({'my_proc': {'command': 'my_proc'}}, namespace) assert conf.job == ConfigDict({'my_job': {'command': 'my_job'}}, namespace) assert conf.logger == ConfigDict({ 'level': 'debug', 'suppress_regex': ['global_pat1', 'global_pat2 ${foo}'], 'replace_regex': [{ 'from': 'global_pat_from ${bar}', 'to': 'global_pat_to ${foo}' }] }, namespace) assert conf.app_log_suppress_patterns == { 'my_app': [re.compile('pat1 FOO'), re.compile('pat2')] } assert conf.app_log_replace_patterns == { 'my_app': [(re.compile('pat_from FOO'), 'pat_to ${bar}')] } pat_to = conf.app_log_replace_patterns['my_app'][0][1] assert isinstance(pat_to, TemplateString) assert pat_to.render() == 'pat_to BAR' assert conf.global_log_suppress_patterns == [ re.compile('global_pat1'), re.compile('global_pat2 FOO') ] assert conf.global_log_replace_patterns == [ (re.compile('global_pat_from BAR'), 'global_pat_to ${foo}') ] pat_to = conf.global_log_replace_patterns[0][1] assert isinstance(pat_to, TemplateString) assert pat_to.render() == 'global_pat_to FOO' def test_load(): data1 = {'kernel': {'my_kernel': {'kernel_name': 'python3', 'pass_env': []}}} ns = {'HOME': '/home/foo'} variables = {'name': 'foo'} with patch.object(JaffleConfig, '_load_file', return_value=data1) as load_file: with patch.object(JaffleConfig, 'create') as create: config = JaffleConfig.load(['jaffle.hcl'], ns, variables) assert config is create.return_value load_file.assert_called_once_with('jaffle.hcl') create.assert_called_once_with(data1, ns, variables) data2 = { 'kernel': { 'my_kernel': { 'kernel_name': 'pyspark', 'pass_env': ['HOME'] } }, 'app': { 'my_app': True } } with patch.object(JaffleConfig, '_load_file', side_effect=[data1, data2]) as load_file: with patch.object(JaffleConfig, 'create') as create: config = JaffleConfig.load(['jaffle.hcl', 'my_jaffle.hcl'], ns, variables) assert config is create.return_value load_file.assert_has_calls([call('jaffle.hcl'), call('my_jaffle.hcl')]) create.assert_called_once_with({ 'kernel': { 'my_kernel': { 'kernel_name': 'pyspark', 'pass_env': ['HOME'] } }, 'app': { 'my_app': True } }, ns, variables) data1 = {'kernel': {'my_kernel': {'kernel_name': 'python3', 'invalid_param': True}}} with patch.object(JaffleConfig, '_load_file', return_value=data1) as load_file: with patch.object(JaffleConfig, 'create') as create: with pytest.raises(ValidationError) as e: JaffleConfig.load(['jaffle.hcl'], {}, {}) assert "'invalid_param' was unexpected" in str(e) def test_create(): def echo(msg): return msg functions = [echo] with patch('jaffle.config.jaffle_config.functions', functions): with patch('jaffle.config.jaffle_config.VariablesNamespace') as vn: with patch.object(JaffleConfig, '__init__', return_value=None) as init: JaffleConfig.create({ 'kernel': { 'my_kernel': { 'kernel_name': 'python3' } } }, {'HOME': '/home/foo'}, {'foo': True}) init.assert_called_once_with({ 'HOME': '/home/foo', 'var': vn.return_value, 'echo': echo, }, kernel={'my_kernel': {'kernel_name': 'python3'}}) # yapf: disable def test_load_file(tmpdir): tmp_file = Path(str(tmpdir)) / 'jaffle.hcl' with tmp_file.open('w') as f: f.write( dedent( ''' kernel "my_kernel" { kernel_name = "python3" } ''' ).strip() # yapf: disable ) data = JaffleConfig._load_file(tmp_file) assert data == {'kernel': {'my_kernel': {'kernel_name': 'python3'}}} data = JaffleConfig._load_file(str(tmp_file)) assert data == {'kernel': {'my_kernel': {'kernel_name': 'python3'}}}
the-stack_106_29292
# 🚩 Dada Ki Jay Ho 🚩 import os import webbrowser from Resources.UsedForBoth.text_to_speech import sayAndWait path = "" def open_folder(cmd:str): global path if "open" in cmd and ("folder" in cmd or "drive" in cmd): if "drive" in cmd: cmd = cmd.replace("drive", "") drive_name = cmd[5:].strip() path = "" path += drive_name + ":/" if os.path.isdir(path): webbrowser.open(path) else: sayAndWait("No such drive is available") else: cmd = cmd.replace("folder", "") folder_name = cmd[5:].strip() path += folder_name + "/" if os.path.isdir(path): webbrowser.open(path) else: sayAndWait("No such folder is available") print(path)
the-stack_106_29294
# -*- coding: utf-8 -*- from simmate.workflow_engine import s3task_to_workflow from simmate.calculators.vasp.tasks.relaxation import ( Quality01Relaxation as Quality01RelaxationTask, ) from simmate.calculators.vasp.database.relaxation import ( Quality01Relaxation as Quality01RelaxationResults, ) workflow = s3task_to_workflow( name="relaxation/quality01", module=__name__, project_name="Simmate-Relaxation", s3task=Quality01RelaxationTask, calculation_table=Quality01RelaxationResults, register_kwargs=["prefect_flow_run_id", "structure", "source"], )
the-stack_106_29295
# Copyright (c) 2018 PaddlePaddle 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. from __future__ import print_function import numpy as np import unittest import paddle.fluid as fluid import paddle.fluid.core as core import paddle.fluid.layers as layers import paddle.fluid.framework as framework from paddle.fluid.backward import append_backward from paddle.fluid.executor import Executor from paddle.fluid.framework import Program, program_guard from simple_nets import simple_fc_net_with_inputs, batchnorm_fc_with_inputs np.random.seed(123) class TestCondInputOutput(unittest.TestCase): def test_return_single_var(self): """ pseudocode: if 0.23 < 0.1: return 2 else: return -1 """ def true_func(): return layers.fill_constant(shape=[2, 3], dtype='int32', value=2) def false_func(): return layers.fill_constant(shape=[3, 2], dtype='int32', value=-1) main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): x = layers.fill_constant(shape=[1], dtype='float32', value=0.1) y = layers.fill_constant(shape=[1], dtype='float32', value=0.23) pred = layers.less_than(y, x) out = layers.cond(pred, true_func, false_func) # out is one tensor place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) ret = exe.run(main_program, fetch_list=[out.name]) self.assertTrue( np.allclose(np.asarray(ret), np.full((3, 2), -1, np.int32))) def test_return_var_tuple(self): """ pseudocode: if True: return 1, True else: return 3, 2 """ def true_func(): return layers.fill_constant( shape=[1, 2], dtype='int32', value=1), layers.fill_constant( shape=[2, 3], dtype='bool', value=True) def false_func(): return layers.fill_constant( shape=[3, 4], dtype='float32', value=3), layers.fill_constant( shape=[4, 5], dtype='int64', value=2) main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): pred = layers.fill_constant(shape=[1], dtype='bool', value=True) out = layers.cond(pred, true_func, false_func) # out is a tuple containing 2 tensors place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) ret = exe.run(main_program, fetch_list=out) self.assertTrue( np.allclose(np.asarray(ret[0]), np.full((1, 2), 1, np.int32))) self.assertTrue( np.allclose(np.asarray(ret[1]), np.full((2, 3), True, np.bool))) def test_pass_and_modify_var(self): """ pseudocode: for i in range(5): a = 7 if i % 2 == 0: a = a * (i + 1) else: a = a - (i - 1) """ def true_func(a, i): a = a * (i + 1) return a def false_func(a, i): a = a - (i - 1) return a main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): a = layers.fill_constant(shape=[3, 2, 1], dtype='int32', value=7) i = fluid.data(name="i", shape=[1], dtype='int32') pred = ((i % 2) == 0) a = layers.cond(pred, lambda: true_func(a, i), lambda: false_func(a, i)) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) for feed_i in range(5): expected_a = 7 * (feed_i + 1) if feed_i % 2 == 0 else 8 - feed_i ret = exe.run(main_program, feed={'i': np.full((1), feed_i, np.int32)}, fetch_list=[a]) self.assertTrue( np.allclose( np.asarray(ret), np.full((3, 2, 1), expected_a, np.int32))) def test_return_none(self): """ pseudocode: test doing nothing in branches for i in range(5): if i % 2 == 0: pass else: pass """ def true_func(): pass def false_func(): return None main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): i = fluid.data(name="i", shape=[1], dtype='int32') pred = ((i % 2) == 0) out1 = layers.cond(pred, true_func, false_func) out2 = layers.cond(pred, None, false_func) out3 = layers.cond(pred, true_func, None) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) for feed_i in range(5): # Test that output is None is runnable exe.run(main_program, feed={'i': np.full((1), feed_i, np.int32)}) self.assertIsNone(out1) self.assertIsNone(out2) self.assertIsNone(out3) def test_wrong_structure_exception(self): """ test returning different number of tensors cannot merge into output """ def func_return_none(): return None def func_return_one_tensor(): return layers.fill_constant(shape=[2, 7], dtype='int32', value=3) def func_return_two_tensors(): return layers.fill_constant( shape=[3, 1], dtype='int32', value=7), layers.fill_constant( shape=[3, 1], dtype='int32', value=8) main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): i = fluid.data(name="i", shape=[1], dtype='int32') pred = ((i % 2) == 0) with self.assertRaises(Exception) as e: out = layers.cond(pred, i, func_return_one_tensor) self.assertEqual("The true_fn in cond must be callable", str(e.exception)) with self.assertRaises(Exception) as e: out = layers.cond(pred, func_return_one_tensor, np.asarray([3])) self.assertEqual("The false_fn in cond must be callable", str(e.exception)) with self.assertRaises(Exception) as e: out = layers.cond(pred, func_return_none, func_return_one_tensor) self.assertTrue( "Incompatible return values of true_fn and false_fn in cond" in str(e.exception)) with self.assertRaises(Exception) as e: out = layers.cond(pred, func_return_two_tensors, func_return_none) self.assertTrue( "Incompatible return values of true_fn and false_fn in cond" in str(e.exception)) with self.assertRaises(Exception) as e: out = layers.cond(pred, func_return_one_tensor, func_return_two_tensors) self.assertTrue( "Incompatible return values of true_fn and false_fn in cond" in str(e.exception)) def test_extremely_simple_net_with_op_in_condition(self): main_program = fluid.Program() startup_program = fluid.Program() with fluid.program_guard(main_program, startup_program): a = fluid.layers.fill_constant( shape=[1], dtype='float32', value=1.23) a.stop_gradient = False b = fluid.layers.fill_constant( shape=[1], dtype='float32', value=1.25) b.stop_gradient = False out = layers.cond(a - b < -1.0, lambda: a, lambda: b) append_backward(out) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) ret = exe.run(main_program, fetch_list=[out, a.grad_name, b.grad_name]) # Note: fill_constant has loss of precision, you have to assertEqual # with values doens't lose precision in float-point number. self.assertEqual(ret[0][0], 1.25) self.assertEqual(ret[1][0], 0.0) self.assertEqual(ret[2][0], 1.0) class TestCondNestedControlFlow(unittest.TestCase): def test_cond_inside_cond(self): """ pseudocode: for i in range(1, 10): a = 2 * i if i < 5: if i >= 3: return a + a else: return a - a else: if i < 8: return a * a else: return a / a """ def less_than_branch(i, a): return layers.cond(i >= 3.0, lambda: layers.elementwise_add(a, a), lambda: layers.elementwise_sub(a, a)) def greater_equal_branch(i, a): return layers.cond(i < 8.0, lambda: layers.elementwise_mul(a, a), lambda: layers.elementwise_div(a, a)) main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): i = fluid.data(name="i", shape=[1], dtype='float32') a = 2.0 * i out = layers.cond(i < 5.0, lambda: less_than_branch(i, a), lambda: greater_equal_branch(i, a)) mean = layers.mean(out) append_backward(mean) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) for feed_i in range(0, 10): expected_a = 2.0 * feed_i if feed_i < 5: expected_ret = expected_a + expected_a if feed_i >= 3 else 0.0 expected_a_grad = 2.0 if feed_i >= 3 else 0.0 else: expected_ret = expected_a * expected_a if feed_i < 8 else 1.0 expected_a_grad = 2.0 * expected_a if feed_i < 8 else 0.0 ret = exe.run(main_program, feed={'i': np.full((1), feed_i, np.float32)}, fetch_list=[out.name, a.grad_name]) self.assertEqual(ret[0][0], expected_ret) self.assertEqual(ret[1][0], expected_a_grad) def test_cond_op_in_condition(self): main_program = fluid.Program() startup_program = fluid.Program() with fluid.program_guard(main_program, startup_program): a = fluid.layers.fill_constant( shape=[1], dtype='float32', value=1.23) a.stop_gradient = False b = fluid.layers.fill_constant( shape=[1], dtype='float32', value=1.24) b.stop_gradient = False out = fluid.layers.cond( a < b, lambda: fluid.layers.cond(a - b < -1.0, lambda: fluid.layers.elementwise_add(a, b), lambda: fluid.layers.elementwise_mul(a, b)), lambda: fluid.layers.cond(a == b, lambda: fluid.layers.elementwise_sub(a, b), lambda: fluid.layers.elementwise_pow(a, b)) ) append_backward(out) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) ret = exe.run(main_program, fetch_list=[out, a.grad_name, b.grad_name]) # Note: fill_constant has loss of precision, so we assertAlmostEqual. self.assertAlmostEqual(ret[0][0], 1.5252) self.assertAlmostEqual(ret[1][0], 1.24) self.assertAlmostEqual(ret[2][0], 1.23) class TestCondBackward(unittest.TestCase): def backward_value_helper(self, cond_func): """ Helper function that compares calculated backward value is close to dy/dx """ main_program = Program() main_program.random_seed = 123 startup_program = Program() startup_program.random_seed = 123 with program_guard(main_program, startup_program): img = fluid.data(name='image', shape=[-1, 9], dtype='float32') img.stop_gradient = False label = fluid.data(name='label', shape=[-1, 1], dtype='int64') i = fluid.data(name="i", shape=[1], dtype='int32') loss = cond_func(i, img, label) append_backward(loss) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(startup_program) delta = 0.005 for feed_i in range(0, 10): feed_img = np.random.random(size=[1, 9]).astype(np.float32) feed_label = np.random.randint( low=0, high=10, size=[1, 1], dtype=np.int64) img_grad, loss_value = exe.run( main_program, feed={ 'i': np.full((1), feed_i, np.int32), 'image': feed_img, 'label': feed_label }, fetch_list=[img.grad_name, loss.name]) numerical_grad = np.zeros(shape=[1, 9], dtype=np.float32) feed_img_delta = np.copy(feed_img) for j in range(9): feed_img_delta[0][j] = feed_img[0][j] + delta loss_delta = exe.run(main_program, feed={ 'i': np.full((1), feed_i, np.int32), 'image': feed_img_delta, 'label': feed_label }, fetch_list=[loss.name]) numerical_grad[0][j] = (loss_delta[0] - loss_value[0]) / delta feed_img_delta[0][j] = feed_img[0][j] self.assertTrue( np.isclose( img_grad, numerical_grad, atol=0.05, rtol=0.05).all()) def add_optimizer_helper(self, cond_func): """ Test that program is runnable when add optimizer """ main_program = Program() startup_program = Program() with program_guard(main_program, startup_program): img = fluid.data(name='image', shape=[-1, 784], dtype='float32') label = fluid.data(name='label', shape=[-1, 1], dtype='int64') i = fluid.data(name="i", shape=[1], dtype='int32') loss = cond_func(i, img, label) optimizer = fluid.optimizer.SGD(learning_rate=0.1) optimizer.minimize(loss) place = fluid.CUDAPlace(0) if core.is_compiled_with_cuda( ) else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(startup_program) for feed_i in range(0, 10): feed_img = np.random.random(size=[16, 784]).astype(np.float32) feed_label = np.random.randint( low=0, high=10, size=[16, 1], dtype=np.int64) exe.run(main_program, feed={ 'i': np.full((1), feed_i, np.int32), 'image': feed_img, 'label': feed_label }, fetch_list=[loss]) def test_cond_backward(self): def cond_func(i, img, label): predicate = ((i % 2) == 0) return layers.cond(predicate, lambda: simple_fc_net_with_inputs(img, label, class_num=10), lambda: batchnorm_fc_with_inputs(img, label, class_num=10)) self.backward_value_helper(cond_func) self.add_optimizer_helper(cond_func) def test_half_nested_cond_backward(self): def branch(i, img, label): return layers.cond((i % 2) == 0, lambda: simple_fc_net_with_inputs(img, label, class_num=10), lambda: batchnorm_fc_with_inputs(img, label, class_num=10)) def cond_func_simple_net_at_true(i, img, label): return layers.cond(i < 5, lambda: branch(i, img, label), lambda: layers.mean(img)) def cond_func_simple_net_at_false(i, img, label): return layers.cond(i < 5, lambda: layers.mean(img), lambda: branch(i, img, label)) self.backward_value_helper(cond_func_simple_net_at_true) self.add_optimizer_helper(cond_func_simple_net_at_true) self.backward_value_helper(cond_func_simple_net_at_false) self.add_optimizer_helper(cond_func_simple_net_at_false) def test_nested_cond_backward(self): def branch(i, img, label, mod_two): if mod_two: predicate = ((i % 2) == 0) else: predicate = ((i % 2) != 0) return layers.cond(predicate, lambda: simple_fc_net_with_inputs(img, label, class_num=10), lambda: batchnorm_fc_with_inputs(img, label, class_num=10)) def cond_func(i, img, label): return layers.cond(i < 5, lambda: branch(i, img, label, True), lambda: branch(i, img, label, False)) self.backward_value_helper(cond_func) self.add_optimizer_helper(cond_func) if __name__ == '__main__': unittest.main()
the-stack_106_29296
from __future__ import unicode_literals import os import shlex import subprocess import sys import syslog import time from traceback import format_exception from cyder.base.mixins import MutexMixin from cyder.base.utils import (copy_tree, dict_merge, log, run_command, set_attrs, shell_out) from cyder.base.vcs import GitRepo from cyder.core.utils import fail_mail from cyder.core.ctnr.models import Ctnr from cyder.cydhcp.network.models import Network from cyder.cydhcp.vrf.models import Vrf from cyder.cydhcp.workgroup.models import Workgroup from cyder.settings import DHCPBUILD class DHCPBuilder(MutexMixin): def __init__(self, *args, **kwargs): kwargs = dict_merge(DHCPBUILD, { 'verbose': True, 'debug': False, }, kwargs) set_attrs(self, kwargs) if self.log_syslog: syslog.openlog(b'dhcp_build', 0, syslog.LOG_LOCAL6) self.repo = GitRepo(self.prod_dir, self.line_change_limit, self.line_removal_limit, debug=self.debug, log_syslog=self.log_syslog, logger=syslog) def log_debug(self, msg, to_stderr=None): if to_stderr is None: to_stderr = self.debug log(msg, log_level='LOG_DEBUG', to_syslog=False, to_stderr=to_stderr, logger=syslog) def log_info(self, msg, to_stderr=None): if to_stderr is None: to_stderr = self.verbose log(msg, log_level='LOG_INFO', to_syslog=self.log_syslog, to_stderr=to_stderr, logger=syslog) def log_notice(self, msg, to_stderr=None): if to_stderr is None: to_stderr = self.verbose log(msg, log_level='LOG_NOTICE', to_syslog=self.log_syslog, to_stderr=to_stderr, logger=syslog) def log_err(self, msg, to_stderr=True): log(msg, log_level='LOG_ERR', to_syslog=self.log_syslog, to_stderr=to_stderr, logger=syslog) def run_command(self, command, log=True, failure_msg=None): if log: command_logger = self.log_debug failure_logger = self.log_err else: command_logger = None failure_logger = None return run_command(command, command_logger=command_logger, failure_logger=failure_logger, failure_msg=failure_msg) def build(self): try: with open(self.stop_file) as stop_fd: now = time.time() contents = stop_fd.read() last = os.path.getmtime(self.stop_file) msg = ('The stop file ({0}) exists. Build canceled.\n' 'Reason for skipped build:\n' '{1}'.format(self.stop_file, contents)) self.log_notice(msg, to_stderr=False) if (self.stop_file_email_interval is not None and now - last > self.stop_file_email_interval): os.utime(self.stop_file, (now, now)) fail_mail(msg, subject="DHCP builds have stopped") raise Exception(msg) except IOError as e: if e.errno == 2: # IOError: [Errno 2] No such file or directory pass else: raise self.log_info('Building...') try: with open(os.path.join(self.stage_dir, self.target_file), 'w') \ as f: for ctnr in Ctnr.objects.all(): f.write(ctnr.build_legacy_classes()) for vrf in Vrf.objects.all(): f.write(vrf.build_vrf()) for network in Network.objects.filter(enabled=True): f.write(network.build_subnet()) for workgroup in Workgroup.objects.all(): f.write(workgroup.build_workgroup()) except: self.error() if self.check_file: self.check_syntax() self.log_info('DHCP build successful') def push(self, sanity_check=True): self.repo.reset_and_pull() try: copy_tree(self.stage_dir, self.prod_dir) except: self.repo.reset_to_head() raise self.repo.commit_and_push('Update config', sanity_check=sanity_check) def error(self): ei = sys.exc_info() exc_msg = ''.join(format_exception(*ei)).rstrip('\n') self.log_err( 'DHCP build failed.\nOriginal exception: ' + exc_msg, to_stderr=False) raise def check_syntax(self): out, err, ret = run_command("{0} -t -cf {1}".format( self.dhcpd, os.path.join(self.stage_dir, self.check_file) )) if ret != 0: log_msg = 'DHCP build failed due to a syntax error' exception_msg = log_msg + ('\n{0} said:\n{1}' .format(self.dhcpd, err)) self.log_err(log_msg, to_stderr=False) raise Exception(exception_msg) def _lock_failure(self, pid): self.log_err( 'Failed to acquire lock on {0}. Process {1} currently ' 'has it.'.format(self.lock_file, pid), to_stderr=False) fail_mail( 'An attempt was made to start the DHCP build script while an ' 'instance of the script was already running. The attempt was ' 'denied.', subject="Concurrent DHCP builds attempted.") super(DHCPBuilder, self)._lock_failure(pid)
the-stack_106_29297
from flask import Flask, render_template, request import jsonify import requests import pickle import numpy as np import sklearn from sklearn.preprocessing import StandardScaler app = Flask(__name__) model = pickle.load(open('random_forest_regression_model.pkl', 'rb')) @app.route('/',methods=['GET']) def Home(): return render_template('index.html') standard_to = StandardScaler() @app.route("/predict", methods=['POST']) def predict(): Fuel_Type_Diesel=0 if request.method == 'POST': Year = int(request.form['Year']) Present_Price=float(request.form['Present_Price']) Kms_Driven=int(request.form['Kms_Driven']) Kms_Driven2=np.log(Kms_Driven) Owner=int(request.form['Owner']) Fuel_Type_Petrol=request.form['Fuel_Type_Petrol'] if(Fuel_Type_Petrol=='Petrol'): Fuel_Type_Petrol=1 Fuel_Type_Diesel=0 else: Fuel_Type_Petrol=0 Fuel_Type_Diesel=1 Year=2020-Year Seller_Type_Individual=request.form['Seller_Type_Individual'] if(Seller_Type_Individual=='Individual'): Seller_Type_Individual=1 else: Seller_Type_Individual=0 Transmission_Mannual=request.form['Transmission_Mannual'] if(Transmission_Mannual=='Mannual'): Transmission_Mannual=1 else: Transmission_Mannual=0 prediction=model.predict([[Present_Price,Kms_Driven2,Owner,Year,Fuel_Type_Diesel,Fuel_Type_Petrol,Seller_Type_Individual,Transmission_Mannual]]) output=round(prediction[0],2) if output<0: return render_template('index.html',prediction_texts="Sorry you can't sell this car") else: return render_template('index.html',prediction_text="You Can Sell The Car at {}".format(output)) else: return render_template('index.html') if __name__=="__main__": app.run(debug=True)
the-stack_106_29298
# encoding=utf8 # pylint: disable=anomalous-backslash-in-string import math __all__ = ['Whitley'] class Whitley(object): r"""Implementation of Whitley function. Date: 2018 Authors: Grega Vrbančič and Lucija Brezočnik License: MIT Function: **Whitley function** :math:`f(\mathbf{x}) = \sum_{i=1}^D \sum_{j=1}^D \left(\frac{(100(x_i^2-x_j)^2 + (1-x_j)^2)^2}{4000} - \cos(100(x_i^2-x_j)^2 + (1-x_j)^2)+1\right)` **Input domain:** The function can be defined on any input domain but it is usually evaluated on the hypercube :math:`x_i ∈ [-10.24, 10.24]`, for all :math:`i = 1, 2,..., D`. **Global minimum:** :math:`f(x^*) = 0`, at :math:`x^* = (1,...,1)` LaTeX formats: Inline: $f(\mathbf{x}) = \sum_{i=1}^D \sum_{j=1}^D \left(\frac{(100(x_i^2-x_j)^2 + (1-x_j)^2)^2}{4000} - \cos(100(x_i^2-x_j)^2 + (1-x_j)^2)+1\right)$ Equation: \begin{equation}f(\mathbf{x}) = \sum_{i=1}^D \sum_{j=1}^D \left(\frac{(100(x_i^2-x_j)^2 + (1-x_j)^2)^2}{4000} - \cos(100(x_i^2-x_j)^2 + (1-x_j)^2)+1\right) \end{equation} Domain: $-10.24 \leq x_i \leq 10.24$ Reference paper: Jamil, M., and Yang, X. S. (2013). A literature survey of benchmark functions for global optimisation problems. International Journal of Mathematical Modelling and Numerical Optimisation, 4(2), 150-194. """ def __init__(self, Lower=-10.24, Upper=10.24): self.Lower = Lower self.Upper = Upper @classmethod def function(cls): def evaluate(D, sol): val = 0.0 for i in range(D): for j in range(D): temp = 100 * \ math.pow((math.pow(sol[i], 2) - sol[j]), 2) + math.pow( 1 - sol[j], 2) val += (float(math.pow(temp, 2)) / 4000.0) - \ math.cos(temp) + 1 return val return evaluate
the-stack_106_29299
import os def migratoryBirds(arr): count = [0, 0, 0, 0, 0] for i in range(len(arr)): if arr[i] == 1: count[0] += 1 if arr[i] == 2: count[1] += 1 if arr[i] == 3: count[2] += 1 if arr[i] == 4: count[3] += 1 if arr[i] == 5: count[4] += 1 return count.index(max(count))+1 if __name__ == '__main__': fptr = open(os.environ['OUTPUT_PATH'], 'w') arr_count = int(input().strip()) arr = list(map(int, input().rstrip().split())) result = migratoryBirds(arr) fptr.write(str(result) + '\n') fptr.close()
the-stack_106_29301
######## # Copyright (c) 2019 Cloudify Platform Ltd. 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. import glob import os import shutil import errno from datetime import datetime import unicodedata from retrying import retry from cloudify.decorators import workflow from cloudify.deployment_dependencies import create_deployment_dependency from cloudify.manager import get_rest_client from cloudify.workflows import workflow_context from cloudify.utils import parse_utc_datetime_relative from cloudify_rest_client.client import CloudifyClient from cloudify_rest_client.exceptions import CloudifyClientError from dsl_parser import constants as dsl from dsl_parser import tasks def _get_display_name(display_name, settings): display_name = display_name or settings.get('display_name') if not display_name: return if len(display_name) > 256: raise ValueError( 'The deployment display name is too long. ' 'Maximum allowed length is 256 characters' ) if any(unicodedata.category(char)[0] == 'C' for char in display_name): raise ValueError( 'The deployment display name contains illegal characters. ' 'Control characters are not allowed' ) return unicodedata.normalize('NFKC', display_name) def _parse_plan_datetime(time_expression, base_datetime): """ :param time_expression: Either a string representing an absolute datetime, or a relative time delta, such as '+4 hours' or '+1y+1d'. :param base_datetime: a datetime object representing the absolute date and time to which we apply the time delta. :return: A naive datetime object, in UTC time. """ time_fmt = '%Y-%m-%d %H:%M:%S' if time_expression.startswith('+'): return parse_utc_datetime_relative(time_expression, base_datetime) return datetime.strptime(time_expression, time_fmt) def _create_schedules(client, deployment_id, schedules): base_time = datetime.utcnow() for name, spec in schedules.items(): workflow_id = spec.pop('workflow') if 'since' in spec: spec['since'] = _parse_plan_datetime(spec['since'], base_time) if 'until' in spec: spec['until'] = _parse_plan_datetime(spec['until'], base_time) if 'workflow_parameters' in spec: spec['parameters'] = spec.pop('workflow_parameters') client.execution_schedules.create( name, deployment_id=deployment_id, workflow_id=workflow_id, **spec ) def _join_groups(client, deployment_id, groups): for group_name in groups: try: client.deployment_groups.add_deployments( group_name, deployment_ids=[deployment_id]) except CloudifyClientError as e: if e.status_code != 404: raise client.deployment_groups.put( group_name, deployment_ids=[deployment_id]) def _get_deployment_labels(new_labels, plan_labels): labels = {tuple(label) for label in new_labels} for name, label_spec in plan_labels.items(): labels |= {(name.lower(), value) for value in label_spec.get('values', [])} return [{k: v} for k, v in labels] @workflow def create(ctx, labels=None, inputs=None, skip_plugins_validation=False, display_name=None, **_): client = get_rest_client(tenant=ctx.tenant_name) bp = client.blueprints.get(ctx.blueprint.id) deployment_plan = tasks.prepare_deployment_plan( bp.plan, client.secrets.get, inputs, runtime_only_evaluation=ctx.deployment.runtime_only_evaluation) nodes = deployment_plan['nodes'] node_instances = deployment_plan['node_instances'] labels_to_create = _get_deployment_labels( labels or [], deployment_plan.get('labels', {})) ctx.logger.info('Setting deployment attributes') client.deployments.set_attributes( ctx.deployment.id, description=deployment_plan['description'], workflows=deployment_plan['workflows'], inputs=deployment_plan['inputs'], policy_types=deployment_plan['policy_types'], policy_triggers=deployment_plan['policy_triggers'], groups=deployment_plan['groups'], scaling_groups=deployment_plan['scaling_groups'], outputs=deployment_plan['outputs'], capabilities=deployment_plan.get('capabilities', {}), labels=labels_to_create, ) ctx.logger.info('Creating %d nodes', len(nodes)) client.nodes.create_many(ctx.deployment.id, nodes) ctx.logger.info('Creating %d node-instances', len(node_instances)) client.node_instances.create_many(ctx.deployment.id, node_instances) # deployment_settings can depend on labels etc, so we must evaluate # functions in it after setting labels deployment_settings = client.evaluate.functions( ctx.deployment.id, {}, deployment_plan.get('deployment_settings', {}), )['payload'] display_name = _get_display_name(display_name, deployment_settings) if display_name: client.deployments.set_attributes( ctx.deployment.id, display_name=display_name) _join_groups(client, ctx.deployment.id, deployment_settings.get('default_groups', [])) _create_schedules(client, ctx.deployment.id, deployment_settings.get('default_schedules', {})) ctx.logger.info('Creating deployment work directory') _create_deployment_workdir( deployment_id=ctx.deployment.id, tenant=ctx.tenant_name, logger=ctx.logger) new_dependencies = deployment_plan.setdefault( dsl.INTER_DEPLOYMENT_FUNCTIONS, {}) if new_dependencies: ctx.logger.info('Creating inter-deployment dependencies') manager_ips = [manager.private_ip for manager in client.manager.get_managers()] ext_client, client_config, ext_deployment_id = \ _get_external_clients(nodes, manager_ips) local_tenant_name = ctx.tenant_name if ext_client else None local_idds, external_idds = _create_inter_deployment_dependencies( [manager.private_ip for manager in client.manager.get_managers()], client_config, new_dependencies, ctx.deployment.id, local_tenant_name, bool(ext_client), ext_deployment_id) if local_idds: client.inter_deployment_dependencies.create_many( ctx.deployment.id, local_idds) if external_idds: ext_client.inter_deployment_dependencies.create_many( ctx.deployment.id, external_idds) @workflow def delete(ctx, delete_logs, **_): ctx.logger.info('Deleting deployment environment: %s', ctx.deployment.id) _delete_deployment_workdir(ctx) if delete_logs: ctx.logger.info("Deleting management workers' logs for deployment %s", ctx.deployment.id) _delete_logs(ctx) def _delete_logs(ctx): log_dir = os.environ.get('AGENT_LOG_DIR') if log_dir: log_file_path = os.path.join(log_dir, 'logs', '{0}.log'.format(ctx.deployment.id)) if os.path.exists(log_file_path): try: with open(log_file_path, 'w') as f: # Truncating instead of deleting because the logging # server currently holds a file descriptor open to this # file. If we delete the file, the logs for new # deployments that get created with the same deployment # id, will get written to a stale file descriptor and # will essentially be lost. f.truncate() except IOError: ctx.logger.warn( 'Failed truncating {0}.'.format(log_file_path), exc_info=True) for rotated_log_file_path in glob.glob('{0}.*'.format( log_file_path)): try: os.remove(rotated_log_file_path) except IOError: ctx.logger.exception( 'Failed removing rotated log file {0}.'.format( rotated_log_file_path), exc_info=True) def _retry_if_file_already_exists(exception): """Retry if file already exist exception raised.""" return ( isinstance(exception, OSError) and exception.errno == errno.EEXIST ) @workflow_context.task_config(send_task_events=False) @retry(retry_on_exception=_retry_if_file_already_exists, stop_max_delay=60000, wait_fixed=2000) def _create_deployment_workdir(deployment_id, logger, tenant): deployment_workdir = _workdir(deployment_id, tenant) if os.path.exists(deployment_workdir): # Otherwise we experience pain on snapshot restore return os.makedirs(deployment_workdir) def _delete_deployment_workdir(ctx): deployment_workdir = _workdir(ctx.deployment.id, ctx.tenant_name) if not os.path.exists(deployment_workdir): return try: shutil.rmtree(deployment_workdir) except os.error: ctx.logger.warning( 'Failed deleting directory %s. Current directory content: %s', deployment_workdir, os.listdir(deployment_workdir), exc_info=True) def _workdir(deployment_id, tenant): return os.path.join('/opt', 'manager', 'resources', 'deployments', tenant, deployment_id) def _create_inter_deployment_dependencies(manager_ips: list, client_config, new_dependencies: dict, local_deployment_id: str, local_tenant_name: str, external: bool, ext_deployment_id: str) -> tuple: local_idds = [] external_idds = [] for func_id, deployment_id_func in new_dependencies.items(): target_deployment_id, target_deployment_func = deployment_id_func if external: local_idds += [ create_deployment_dependency( dependency_creator=func_id, target_deployment=None, external_target={ 'deployment': (ext_deployment_id if ext_deployment_id else None), 'client_config': client_config })] external_idds += [ create_deployment_dependency( dependency_creator=func_id, target_deployment=(target_deployment_id if target_deployment_id else ' '), external_source={ 'deployment': local_deployment_id, 'tenant': local_tenant_name, 'host': manager_ips, })] else: # It should be safe to assume that if the target_deployment # is known, there's no point passing target_deployment_func. # Also because in this case the target_deployment_func will # be of type string, while REST endpoint expects a dict. local_idds += [ create_deployment_dependency( dependency_creator=func_id, target_deployment=target_deployment_id, target_deployment_func=( target_deployment_func if not target_deployment_id else None) )] return local_idds, external_idds def _get_external_clients(nodes: list, manager_ips: list): client_config = None target_deployment = None for node in nodes: if node['type'] in ['cloudify.nodes.Component', 'cloudify.nodes.SharedResource']: client_config = node['properties'].get('client') target_deployment = node['properties'].get( 'resource_config').get('deployment') break external_client = None if client_config: internal_hosts = ({'127.0.0.1', 'localhost'} | set(manager_ips)) host = client_config['host'] host = {host} if type(host) == str else set(host) if not (host & internal_hosts): external_client = CloudifyClient(**client_config) return external_client, client_config, \ target_deployment.get('id') if target_deployment else None @workflow def update_deployment(ctx, **kwargs): """Run an update on this deployment. Any kwargs are passed to the update. This exposes deployment update creation as a workflow on the deployment. """ client = get_rest_client(tenant=ctx.tenant_name) deployment_update = \ client.deployment_updates.update_with_existing_blueprint( deployment_id=ctx.deployment.id, **kwargs ) ctx.logger.info('Started update of deployment %s: %s', ctx.deployment.id, deployment_update.id)
the-stack_106_29304
def func1(): import dtlpy as dl if dl.token_expired(): dl.login() def func2(): project = dl.projects.create(project_name='project-sdk-tutorial') project.datasets.create(dataset_name='dataset-sdk-tutorial') def func3(): project = dl.projects.get(project_name='project-sdk-tutorial') dataset = project.datasets.get(dataset_name='dataset-sdk-tutorial') def func4(): import dtlpy as dl import cv2 import numpy as np class ImageProcess(dl.BaseServiceRunner): @staticmethod def rgb2gray(item: dl.Item): """ Function to convert RGB image to GRAY Will also add a modality to the original item :param item: dl.Item to convert :return: None """ buffer = item.download(save_locally=False) bgr = cv2.imdecode(np.frombuffer(buffer.read(), np.uint8), -1) gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY) gray_item = item.dataset.items.upload(local_path=gray, remote_path='/gray' + item.dir, remote_name=item.filename) # add modality item.modalities.create(name='gray', ref=gray_item.id) item.update(system_metadata=True) @staticmethod def clahe_equalization(item: dl.Item): """ Function to perform histogram equalization (CLAHE) Will add a modality to the original item Based on opencv https://docs.opencv.org/4.x/d5/daf/tutorial_py_histogram_equalization.html :param item: dl.Item to convert :return: None """ buffer = item.download(save_locally=False) bgr = cv2.imdecode(np.frombuffer(buffer.read(), np.uint8), -1) # create a CLAHE object (Arguments are optional). lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB) lab_planes = cv2.split(lab) clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) lab_planes[0] = clahe.apply(lab_planes[0]) lab = cv2.merge(lab_planes) bgr_equalized = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR) bgr_equalized_item = item.dataset.items.upload(local_path=bgr_equalized, remote_path='/equ' + item.dir, remote_name=item.filename) # add modality item.modalities.create(name='equ', ref=bgr_equalized_item.id) item.update(system_metadata=True) def func5(): modules = [dl.PackageModule(name='image-processing-module', entry_point='main.py', class_name='ImageProcess', functions=[dl.PackageFunction(name='rgb2gray', description='Converting RGB to gray', inputs=[dl.FunctionIO(type=dl.PackageInputType.ITEM, name='item')]), dl.PackageFunction(name='clahe_equalization', description='CLAHE histogram equalization', inputs=[dl.FunctionIO(type=dl.PackageInputType.ITEM, name='item')]) ])] def func6(): src_path = 'functions/opencv_functions' project = dl.projects.get(project_name='project-sdk-tutorial') package = project.packages.push(package_name='image-processing', modules=modules, src_path=src_path) def func7(): service = package.services.deploy(service_name='image-processing', runtime=dl.KubernetesRuntime(concurrency=32), module_name='image-processing-module') def func8(): filters = dl.Filters() filters.add(field='datasetId', values=dataset.id) trigger = service.triggers.create(name='image-processing2', function_name='clahe_equalization', execution_mode=dl.TriggerExecutionMode.ONCE, resource=dl.TriggerResource.ITEM, actions=dl.TriggerAction.CREATED, filters=filters) def func9(): trigger = service.triggers.create(name='image-processing-rgb', function_name='rgb2gray', execution_mode=dl.TriggerExecutionMode.ALWAYS, resource=dl.TriggerResource.ITEM, actions=dl.TriggerAction.UPDATED, filters=filters) def func10(): item = dataset.items.upload( local_path=['https://raw.githubusercontent.com/dataloop-ai/tiny_coco/master/images/train2017/000000463730.jpg']) # Remote path is optional, images will go to the main directory by default def func11(): service.log() def func12(): item.open_in_web() def func13(): service.pause()
the-stack_106_29305
import os import pandas as pd import korbinian from Bio import SeqIO # import debugging tools from korbinian.utils import pr, pc, pn, aaa def create_nonred_uniprot_flatfile_via_uniref(s, uniprot_dir, selected_uniprot_records_flatfile, logging): """ Creates a non-redundant UniProt flatfile from redundant redundant UniProt tab files, redundant flatfiles and UniRef cluster tab file. The final output is the selected list of flatfiles, in the uniprot/selected folder (E.g. List08_selected_uniprot_records_flatfile.txt) Parameters ---------- s : dict Settings dictionary extracted from excel settings file. uniprot_dir : str Path to databases/uniprot folder. list_number : int List number (e.g. 8), determining the input and output files. selected_uniprot_records_flatfile : str Path to output UniProt flatfile of selected records. E.g. List08_selected_uniprot_records_flatfile.txt logging : logging.Logger Logger for printing to console and logfile. Saved Files and Figures ----------------------- selected_uniprot_records_flatfile : flatfile UniProt flatfile of non-redundant sequences. """ logging.info('~~~~~~~~~~~~starting create_nonred_uniprot_flatfile_via_uniref~~~~~~~~~~~~') # load uniref cutoff used (typically 50, for UniRef50) uniref_cutoff = s["uniref_cluster_cutoff"] # define path to csv file containing the list of redundant uniprot accessions, e.g. List08_redundant_list_uniprot_acc.tab redundant_uniprot_acc_tab = os.path.join(uniprot_dir, "List%02d_redundant_list_uniprot_acc.tab" % s["list_number"]) # define path to uniprot flatfile containing the redundant protein records, e.g. List08_redundant_uniprot_flatfile.txt redundant_uniprot_flatfile = os.path.join(uniprot_dir, "List%02d_redundant_uniprot_flatfile.txt" % s["list_number"]) # define path to the csv file containing the relevant uniref clusters applicable to this list of proteins, e.g. List08_UniRef50_clusters.tab uniref_clusters_tab = os.path.join(uniprot_dir, "List%02d_UniRef%02d_clusters.tab" % (s["list_number"], uniref_cutoff)) # output uniprot list with redundancy determined nonred_uniprot_acc_csv = os.path.join(uniprot_dir, "List%02d_nonred_list_uniprot_acc.csv" % s["list_number"]) result = korbinian.prot_list.uniprot_nonredundant.match_list_uniprot_acc_to_uniref_clusters(redundant_uniprot_acc_tab, uniref_clusters_tab, nonred_uniprot_acc_csv, uniref_cutoff, logging) if result is None: logging.warning('~~~~~~~~~~~~create_nonred_uniprot_flatfile_via_uniref NOT DONE~~~~~~~~~~~~') return None # reopen output file dfu = pd.read_csv(nonred_uniprot_acc_csv, index_col=0) # create a list of uniprot accessions that are nonredundant list_nonred_acc = list(dfu.loc[dfu['nonred'] == True].index) # create a uniprot flatfile containing only the desired nonredundant accessions korbinian.prot_list.uniprot_nonredundant.retrieve_selected_uniprot_records_from_flatfile(list_nonred_acc, redundant_uniprot_flatfile, selected_uniprot_records_flatfile, logging) logging.info('~~~~~~~~~~~~create_nonred_uniprot_flatfile_via_uniref is finished~~~~~~~~~~~~') return True def match_list_uniprot_acc_to_uniref_clusters(redundant_uniprot_acc_tab, uniref_clusters_tab, nonred_uniprot_acc_csv, uniref_cutoff, logging): """ Assigns UniRef clusters to each acc in a list of UniProt accessions. Takes an input list of redundand UniProt accessions (downloaded in .tab format) For each accession, finds the respective UniRef cluster number, within a UniRef cluster list (downloaded in .tab format) [note that to speed things up, we've iteratively removed clusters as they are identified, resulting in redundant proteins whose UniRef representative is not found] Creates a boolean for each acc, determining whether it is "nonredundant" (nonred) according to the UniRef clusters. - preferentially labels the UniRef cluster representative as nonredundant - if the acc is not the cluster representative, preferentially takes the "reviewed" SwissProt recods Parameters: ----------- redundant_uniprot_acc_tab : str Path to redundant uniprot list of accessions (csv downloaded in .tab format from UniProt website) uniref_clusters_tab : str Path to list of UniRef clusters (csv downloaded in .tab format from UniProt website) nonred_uniprot_acc_csv : str Path for output file, the uniprot list of accessions with annotated UniRef cluster, and redundancy. uniref_cutoff : int UniRef % identity cutoff used for that cluster (either 50, 90 or 100). logging : logging.Logger Logger for printing to console and logfile. Saved Files and Figures ----------------------- nonred_uniprot_acc_csv : csv csv with the identified cluster_ID for each protein, and whether or not it is classified as redundant e.g. List01_nonred_list_uniprot_acc.csv index = UniProt accession columns = Protein names Gene names Organism Length nonred cluster_ID """ if not os.path.isfile(uniref_clusters_tab): logging.warning("REDUNDANCY REDUCTION NOT POSSIBLE, no uniref clusters found ({})".format(uniref_clusters_tab)) return None # create a new dataframe with the uniref csv file, containing the accessions of the reference sequences dfr = pd.read_table(uniref_clusters_tab) # to simplify, keep only the columns with the uniprot accessions # for backwards compatibility, replace old header 'Cluster member(s)' with a consistent column name dfr.rename(columns={'Cluster member(s)': 'cluster_members', 'Cluster members': 'cluster_members', 'Cluster ID': 'cluster_ID'}, inplace=True) # to simplify, keep only the columns with the uniprot accessions dfr = dfr[['cluster_ID', 'cluster_members']]# 'Organisms' # remove the isoforms, which for some reason are given separate UniRef numbers (SP|P45880, SP|P45880-1, SP|P45880-2 etc) dfr['cluster_ID'] = dfr['cluster_ID'].apply(lambda x: x[:-2] if "-" in x[-2:] else x) dfr = dfr.set_index('cluster_ID', drop=False) # change the cluster_ID to the index dfr.index.names = ['cluster_ID'] # extract the representative uniprot accession from each cluster_ID dfr['cluster_rep'] = dfr['cluster_ID'].str[9:] # convert the list of uniprot accessions in each cluster to a python list format #dfr['all_acc_in_cluster'] = dfr['cluster_members'].apply(lambda x : [x.strip() for x in x.split(';')]) # delete the original list of clusters #dfr.drop("cluster_members", axis=1, inplace=True) if os.path.isfile(redundant_uniprot_acc_tab) == False: logging.warning('warning, file with nonredundant uniprot acc does not exist : %s' % redundant_uniprot_acc_tab) raise FileNotFoundError() # open up large csv containing the redundant list of uniprot acc dfu = pd.read_table(redundant_uniprot_acc_tab) # set the uniprot acc as the index dfu = dfu.set_index('Entry', drop=False) n_initial_records = dfu.shape[0] ################################################################################################################## # # # Use intersection to find accessions that are cluster representatives # # # ################################################################################################################## # create a set of cluster representatives (e.g. {'UniRef50_Q7Z7M0', 'UniRef50_Q96I36', 'UniRef50_P20333',....} cluster_reps_set = set(dfr['cluster_rep']) # create a set of all the proteins in orig redundant list red_protein_acc_set = set(dfu.index) # use intersection to find the acc that are cluster representatives cluster_reps_acc_set = cluster_reps_set.intersection(red_protein_acc_set) # annotate the cluster representatives as non-redundant, and add the cluster ID dfu.loc[cluster_reps_acc_set, "nonred"] = True dfu.loc[cluster_reps_acc_set, "cluster_ID"] = dfu.loc[cluster_reps_acc_set,:].Entry.apply(lambda x : "UniRef{}_{}".format(uniref_cutoff, x)) # collect a set of the cluster IDs corresponding to the representatives in the list reps_cluster_ID_set = set(dfu.loc[cluster_reps_acc_set, "cluster_ID"]) n_prot_that_are_ref_seqs = len(reps_cluster_ID_set) ################################################################################################################## # # # For non representatives, search each cluster separately to see if it contains the accession # # # ################################################################################################################## # OPTIONAL: to make the check faster, drop any of the UniRef clusters whose reference protein was in the non-redundant list # NOTE: this means that there will be less clusters to search, BUT, you won't find the cluster for proteins who belong # to a cluster, where the representative protein was in the original list. These will be labelled "not found". unassigned = set(dfr.index) - reps_cluster_ID_set dfr_unassigned = dfr.loc[unassigned, :].copy() n_clusters = dfr.shape[0] logging.info("Number of initial redundant proteins : {}\n" "Number of uniref clusters : {}\n" "Number of proteins that were ref seqs for a cluster : {}".format(n_initial_records, n_clusters, n_prot_that_are_ref_seqs)) ################################################################################################################## # # # FOR EACH CLUSTER REPRESENTATIVE, GRAB THE INTERSECTION OF CLUSTER ACC and LIST ACC # # # ################################################################################################################## # split into accessions and convert to a set dfr_unassigned["cluster_members"] = dfr_unassigned.cluster_members.str.split("; ") dfr_unassigned["cluster_members"] = dfr_unassigned["cluster_members"].apply(lambda x : set(x)) # create a set of the accessions that still need to be assigned set_red_acc = set(dfu.loc[dfu.nonred.isnull()].index) # make a new column, showing the intersection between the list of acc in that cluster, and the list of acc of unassigned proteins dfr_unassigned["acc_intersection_cluster_and_unassigned"] = dfr_unassigned["cluster_members"].apply(lambda x: x.intersection(set_red_acc)) # drop any UniRef clusters that don't contain a reference to the remaining unassigned accessions dfr_unassigned = dfr_unassigned.loc[dfr_unassigned["acc_intersection_cluster_and_unassigned"] != set()] ################################################################################################################## # # # Reverse the dataset so the ACC is the index, and the ClusterIDs are the values in a new dataframe # # # ################################################################################################################## # create a new dataframe to df_acc_to_cluster = pd.DataFrame() # iterate through the unassigned cluster IDs for cluster_ID in dfr_unassigned.index: # grab the set of acc for that cluster, which are also in the protein list acc_intersection_cluster_and_unassigned = dfr_unassigned.loc[cluster_ID, "acc_intersection_cluster_and_unassigned"] # for some reason, there are sometimes redundant UniRef clusters!! if isinstance(acc_intersection_cluster_and_unassigned, pd.Series): # take the first list as the correct one acc_intersection_cluster_and_unassigned = acc_intersection_cluster_and_unassigned.iloc[0] # skip the empty sets if acc_intersection_cluster_and_unassigned != set(): counter = 0 # the multiple acc all have the same cluster ID, which can be assigned in the new dataframe for acc in acc_intersection_cluster_and_unassigned: df_acc_to_cluster.loc[acc, "cluster_ID"] = cluster_ID # IF THERE ARE MORE THAN 2, TRY TO TAKE THE "REVIEWED" PROTEIN FROM SWISSPROT if len(acc_intersection_cluster_and_unassigned) >= 2: if "Status" in dfu.columns: # first make a series whether they are "reviewed" or "unreviewed" reviewed_ser = dfu.loc[acc_intersection_cluster_and_unassigned, "Status"] # sort the series so that the "reviewed" proteins are at the top reviewed_ser.sort_values(inplace=True) for acc in reviewed_ser.index: if counter == 0: # take the first protein, which should be "reviewed", if available df_acc_to_cluster.loc[acc, "nonred"] = True else: # label all following proteins as redundant, to be excluded from the final list df_acc_to_cluster.loc[acc, "nonred"] = False counter += 1 else: # there is no reviewed or unreviewed status in the cluster data # simply take the first acc as the non-redundant, and mark the others as redundant for acc in acc_intersection_cluster_and_unassigned: if counter == 0: # take the first protein, which should be "reviewed", if available df_acc_to_cluster.loc[acc, "nonred"] = True else: # label all following proteins as redundant, to be excluded from the final list df_acc_to_cluster.loc[acc, "nonred"] = False counter += 1 ################################################################################################################## # # # Join the "nonred" and "cluster_ID" series from the two methods: # # 1) cluster representatives # # 2) taking the first (or reviewed) from the non-cluster representatives # # # ################################################################################################################## # series 1 nonred_from_reps = dfu["nonred"].dropna() # series 2 if 'nonred' in df_acc_to_cluster.columns: nonred_from_cluster_search = df_acc_to_cluster["nonred"].dropna() else: nonred_from_cluster_search = df_acc_to_cluster # join series complete_series_nonred_annotation = nonred_from_reps.append(nonred_from_cluster_search) # add to output file dfu["nonred"] = complete_series_nonred_annotation # series 1 cluster_IDs_from_reps_ser = dfu["cluster_ID"].dropna() # series 2, join series complete_series_cluster_IDs = cluster_IDs_from_reps_ser.append(df_acc_to_cluster["cluster_ID"].dropna()) # add to output file dfu["cluster_ID"] = complete_series_cluster_IDs ################################################################################################################## # # # save list and print record numbers # # # ################################################################################################################## # save list after redundancy check dfu.to_csv(nonred_uniprot_acc_csv) # log the number of redundant an nonredundant accessions nonred_value_counts = dfu['nonred'].value_counts() number_nonredundant_records = nonred_value_counts[True] #number_total_records = dfu.shape[0] number_redundant_records = n_initial_records - number_nonredundant_records if "not_found" in dfu["cluster_ID"].tolist(): number_acc_not_found_in_UniRef = dfu["cluster_ID"].value_counts()["not_found"] acc_not_found_list = list(dfu["cluster_ID"].isnull().index) logging.info("{} acc not found in UniRef clusters\n{}".format(number_acc_not_found_in_UniRef, acc_not_found_list)) logging.info('final number of non-redundant records : {}\n({} redundant removed)'.format(number_nonredundant_records, number_redundant_records)) logging.info("~~~~~~~~~~~~match_list_uniprot_acc_to_uniref_clusters is finished~~~~~~~~~~~~") return True def retrieve_selected_uniprot_records_from_flatfile(input_accession_list, large_input_uniprot_flatfile, output_flatfile, logging): '''Function to select records from a large uniprot flatfile, and save them as a smaller flatfile of selected records. Parameters: ----------- input_accession_list : list List of UniProt accessions. large_input_uniprot_flatfile : str Path to large UniProt flatfile, from which the UniProt flatfiles will be extracted. output_flatfile : str Path to output UniProt flatfile of selected records. logging : logging.Logger Logger for printing to console and logfile. Notes: ------ This script is quite slow for large lists, and large initial flatfiles. ''' #accession_list = [line.strip() for line in open(input_accession_list, "r")] #open input flatfile uniprot_index_handle = SeqIO.index(large_input_uniprot_flatfile, "swiss") #create an empty list to hold all the accessions that are not in the flatfile list_acc_not_in_flatfile = [] n = 0 with open(output_flatfile, "wb") as output: for n, acc in enumerate(input_accession_list): try: #get the raw uniprot record, and write to the output file output.write(uniprot_index_handle.get_raw(acc)) #if the record is not in the file except KeyError: list_acc_not_in_flatfile.append(acc) if n % 50 == 0: if n!= 0: logging.info('%i records retrieved from large flatfile' % n) logging.info('{} records retrieved from large flatfile ({} not found)'.format(n + 1, len(list_acc_not_in_flatfile))) if len(list_acc_not_in_flatfile) > 0: logging.info("SwissProt records not found in {}:\n{}.".format(large_input_uniprot_flatfile, list_acc_not_in_flatfile)) logging.info("~~~~~~~~~~~~retrieve_selected_uniprot_records_from_flatfile is finished~~~~~~~~~~~~")
the-stack_106_29308
import datetime import pytest from blackbox import config from blackbox import noop_pg_backup_statements from blackbox import small_push_dir from gs_integration_help import default_test_gs_bucket from os import path from s3_integration_help import default_test_bucket from stage_pgxlog import pg_xlog # Quiet pyflakes about pytest fixtures. assert config assert default_test_bucket assert default_test_gs_bucket assert noop_pg_backup_statements assert pg_xlog assert small_push_dir def test_wal_push_fetch(pg_xlog, tmpdir, config): contents = 'abcdefghijlmnopqrstuvwxyz\n' * 10000 seg_name = '00000001' * 3 pg_xlog.touch(seg_name, '.ready') pg_xlog.seg(seg_name).write(contents) config.main('wal-push', 'pg_xlog/' + seg_name) # Recall file and check for equality. download_file = tmpdir.join('TEST-DOWNLOADED') config.main('wal-fetch', '-p0', seg_name, str(download_file)) assert download_file.read() == contents config.main('wal-prefetch', path.dirname(str(download_file)), seg_name) assert tmpdir.join('.wal-e', 'prefetch', seg_name).check(file=1) def test_wal_push_parallel(pg_xlog, config, monkeypatch): from wal_e.worker import upload old_info = upload.logger.info class GatherActions(object): def __init__(self): self.actions = set() def __call__(self, *args, **kwargs): s = kwargs['structured'] self.actions.add((s['action'], s['state'])) return old_info(*args, **kwargs) ga = GatherActions() monkeypatch.setattr(upload.logger, 'info', ga) def seg_name(*parts): return ''.join(str(p).zfill(8) for p in parts) segments = [seg_name(1, 1, x) for x in range(1, 4)] for s in segments: pg_xlog.touch(s, '.ready') # Prepare the second segment with *only* a ready file, to make # sure parallel-push doesn't crash when pg_xlog's file is missing. pg_xlog.seg(segments[1]).remove() # This push has enough parallelism that it should attempt all the # wal segments staged. config.main('wal-push', '-p8', 'pg_xlog/' + segments[0]) # Ensure all three action types, particularly the "skip" state, # are encountered. assert ga.actions == set([('push-wal', 'begin'), ('push-wal', 'skip'), ('push-wal', 'complete')]) # An explicit request to upload a segment that doesn't exist must # yield a failure. # # NB: Normally one would use pytest.raises, but in this case, # e.value was *sometimes* giving an integer value, and sometimes # the SystemExit value, whereas the builtin try/except constructs # appear reliable by comparison. try: config.main('wal-push', '-p8', 'pg_xlog/' + segments[1]) except SystemExit as e: assert e.code == 1 else: assert False def test_wal_fetch_non_existent(tmpdir, config): # Recall file and check for equality. download_file = tmpdir.join('TEST-DOWNLOADED') with pytest.raises(SystemExit) as e: config.main('wal-fetch', '-p0', 'irrelevant', str(download_file)) assert e.value.code == 1 def test_backup_push_fetch(tmpdir, small_push_dir, monkeypatch, config, noop_pg_backup_statements): import wal_e.tar_partition # check that _fsync_files() is called with the right # arguments. There's a separate unit test in test_tar_hacks.py # that it actually fsyncs the right files. fsynced_files = [] monkeypatch.setattr(wal_e.tar_partition, '_fsync_files', lambda filenames: fsynced_files.extend(filenames)) config.main('backup-push', str(small_push_dir)) fetch_dir = tmpdir.join('fetch-to').ensure(dir=True) # Spin around backup-fetch LATEST for a while to paper over race # conditions whereby a backup may not be visible to backup-fetch # immediately. from boto import exception start = datetime.datetime.now() deadline = start + datetime.timedelta(seconds=15) while True: try: config.main('backup-fetch', str(fetch_dir), 'LATEST') except exception.S3ResponseError: if datetime.datetime.now() > deadline: raise else: continue else: break assert fetch_dir.join('arbitrary-file').read() == \ small_push_dir.join('arbitrary-file').read() for filename in fetch_dir.listdir(): if filename.check(link=0): assert str(filename) in fsynced_files elif filename.check(link=1): assert str(filename) not in fsynced_files def test_delete_everything(config, small_push_dir, noop_pg_backup_statements): config.main('backup-push', str(small_push_dir)) config.main('delete', '--confirm', 'everything')
the-stack_106_29310
import numpy as np import pytest import taichi as ti @pytest.mark.skipif(not ti.has_pytorch(), reason='Pytorch not installed.') @ti.test(exclude=ti.opengl) def test_ndarray_2d(): n = 4 m = 7 @ti.kernel def run(x: ti.any_arr(), y: ti.any_arr()): for i in range(n): for j in range(m): x[i, j] += i + j + y[i, j] a = ti.ndarray(ti.i32, shape=(n, m)) for i in range(n): for j in range(m): a[i, j] = i * j b = np.ones((n, m), dtype=np.int32) run(a, b) for i in range(n): for j in range(m): assert a[i, j] == i * j + i + j + 1 run(b, a) for i in range(n): for j in range(m): assert b[i, j] == i * j + (i + j + 1) * 2
the-stack_106_29312
import sys import torch import argparse import numpy as np import torch.nn as nn import torch.nn.functional as F import shutil from torch.autograd import Variable from torch.utils import data import os from dataset import IC15Loader from metrics import runningScore import models from util import Logger, AverageMeter import time import util def ohem_single(score, gt_text, training_mask): pos_num = (int)(np.sum(gt_text > 0.5)) - (int)(np.sum((gt_text > 0.5) & (training_mask <= 0.5))) if pos_num == 0: # selected_mask = gt_text.copy() * 0 # may be not good selected_mask = training_mask selected_mask = selected_mask.reshape(1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32') return selected_mask neg_num = (int)(np.sum(gt_text <= 0.5)) neg_num = (int)(min(pos_num * 3, neg_num)) if neg_num == 0: selected_mask = training_mask selected_mask = selected_mask.reshape(1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32') return selected_mask neg_score = score[gt_text <= 0.5] neg_score_sorted = np.sort(-neg_score) threshold = -neg_score_sorted[neg_num - 1] selected_mask = ((score >= threshold) | (gt_text > 0.5)) & (training_mask > 0.5) selected_mask = selected_mask.reshape(1, selected_mask.shape[0], selected_mask.shape[1]).astype('float32') return selected_mask def ohem_batch(scores, gt_texts, training_masks): scores = scores.data.cpu().numpy() gt_texts = gt_texts.data.cpu().numpy() training_masks = training_masks.data.cpu().numpy() selected_masks = [] for i in range(scores.shape[0]): selected_masks.append(ohem_single(scores[i, :, :], gt_texts[i, :, :], training_masks[i, :, :])) selected_masks = np.concatenate(selected_masks, 0) selected_masks = torch.from_numpy(selected_masks).float() return selected_masks def dice_loss(input, target, mask): input = torch.sigmoid(input) input = input.contiguous().view(input.size()[0], -1) target = target.contiguous().view(target.size()[0], -1) mask = mask.contiguous().view(mask.size()[0], -1) input = input * mask target = target * mask a = torch.sum(input * target, 1) b = torch.sum(input * input, 1) + 0.001 c = torch.sum(target * target, 1) + 0.001 d = (2 * a) / (b + c) dice_loss = torch.mean(d) return 1 - dice_loss def cal_text_score(texts, gt_texts, training_masks, running_metric_text): training_masks = training_masks.data.cpu().numpy() pred_text = torch.sigmoid(texts).data.cpu().numpy() * training_masks pred_text[pred_text <= 0.5] = 0 pred_text[pred_text > 0.5] = 1 pred_text = pred_text.astype(np.int32) gt_text = gt_texts.data.cpu().numpy() * training_masks gt_text = gt_text.astype(np.int32) running_metric_text.update(gt_text, pred_text) score_text, _ = running_metric_text.get_scores() return score_text def cal_kernel_score(kernels, gt_kernels, gt_texts, training_masks, running_metric_kernel): mask = (gt_texts * training_masks).data.cpu().numpy() kernel = kernels[:, -1, :, :] gt_kernel = gt_kernels[:, -1, :, :] pred_kernel = torch.sigmoid(kernel).data.cpu().numpy() pred_kernel[pred_kernel <= 0.5] = 0 pred_kernel[pred_kernel > 0.5] = 1 pred_kernel = (pred_kernel * mask).astype(np.int32) gt_kernel = gt_kernel.data.cpu().numpy() gt_kernel = (gt_kernel * mask).astype(np.int32) running_metric_kernel.update(gt_kernel, pred_kernel) score_kernel, _ = running_metric_kernel.get_scores() return score_kernel def train(train_loader, model, criterion, optimizer, epoch): model.train() batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() running_metric_text = runningScore(2) running_metric_kernel = runningScore(2) end = time.time() for batch_idx, (imgs, gt_texts, gt_kernels, training_masks) in enumerate(train_loader): data_time.update(time.time() - end) imgs = Variable(imgs.cuda()) gt_texts = Variable(gt_texts.cuda()) gt_kernels = Variable(gt_kernels.cuda()) training_masks = Variable(training_masks.cuda()) outputs = model(imgs) texts = outputs[:, 0, :, :] kernels = outputs[:, 1:, :, :] selected_masks = ohem_batch(texts, gt_texts, training_masks) selected_masks = Variable(selected_masks.cuda()) loss_text = criterion(texts, gt_texts, selected_masks) loss_kernels = [] mask0 = torch.sigmoid(texts).data.cpu().numpy() mask1 = training_masks.data.cpu().numpy() selected_masks = ((mask0 > 0.5) & (mask1 > 0.5)).astype('float32') selected_masks = torch.from_numpy(selected_masks).float() selected_masks = Variable(selected_masks.cuda()) for i in range(6): kernel_i = kernels[:, i, :, :] gt_kernel_i = gt_kernels[:, i, :, :] loss_kernel_i = criterion(kernel_i, gt_kernel_i, selected_masks) loss_kernels.append(loss_kernel_i) loss_kernel = sum(loss_kernels) / len(loss_kernels) loss = 0.7 * loss_text + 0.3 * loss_kernel losses.update(loss.item(), imgs.size(0)) optimizer.zero_grad() loss.backward() optimizer.step() score_text = cal_text_score(texts, gt_texts, training_masks, running_metric_text) score_kernel = cal_kernel_score(kernels, gt_kernels, gt_texts, training_masks, running_metric_kernel) batch_time.update(time.time() - end) end = time.time() if batch_idx % 20 == 0: output_log = '({batch}/{size}) Batch: {bt:.3f}s | TOTAL: {total:.0f}min | ETA: {eta:.0f}min | Loss: {loss:.4f} | Acc_t: {acc: .4f} | IOU_t: {iou_t: .4f} | IOU_k: {iou_k: .4f}'.format( batch=batch_idx + 1, size=len(train_loader), bt=batch_time.avg, total=batch_time.avg * batch_idx / 60.0, eta=batch_time.avg * (len(train_loader) - batch_idx) / 60.0, loss=losses.avg, acc=score_text['Mean Acc'], iou_t=score_text['Mean IoU'], iou_k=score_kernel['Mean IoU']) print(output_log) sys.stdout.flush() return ( losses.avg, score_text['Mean Acc'], score_kernel['Mean Acc'], score_text['Mean IoU'], score_kernel['Mean IoU']) def adjust_learning_rate(args, optimizer, epoch): global state if epoch in args.schedule: args.lr = args.lr * 0.1 for param_group in optimizer.param_groups: param_group['lr'] = args.lr def save_checkpoint(state, checkpoint='checkpoint', filename='checkpoint.pth.tar'): filepath = os.path.join(checkpoint, filename) torch.save(state, filepath) def main(args): if args.checkpoint == '': args.checkpoint = "checkpoints/ic15_%s_bs_%d_ep_%d" % (args.arch, args.batch_size, args.n_epoch) if args.pretrain: if 'synth' in args.pretrain: args.checkpoint += "_pretrain_synth" else: args.checkpoint += "_pretrain_ic17" print('checkpoint path: %s' % args.checkpoint) print('init lr: %.8f' % args.lr) print('schedule: ', args.schedule) sys.stdout.flush() if not os.path.isdir(args.checkpoint): os.makedirs(args.checkpoint) kernel_num = 7 min_scale = 0.4 start_epoch = 0 data_loader = IC15Loader(is_transform=True, img_size=args.img_size, kernel_num=kernel_num, min_scale=min_scale) train_loader = torch.utils.data.DataLoader( data_loader, batch_size=args.batch_size, shuffle=True, num_workers=3, drop_last=True, pin_memory=True) if args.arch == "resnet50": model = models.resnet50(pretrained=True, num_classes=kernel_num) elif args.arch == "resnet101": model = models.resnet101(pretrained=True, num_classes=kernel_num) elif args.arch == "resnet152": model = models.resnet152(pretrained=True, num_classes=kernel_num) model = torch.nn.DataParallel(model).cuda() if hasattr(model.module, 'optimizer'): optimizer = model.module.optimizer else: optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.99, weight_decay=5e-4) title = 'icdar2015' if args.pretrain: print('Using pretrained model.') assert os.path.isfile(args.pretrain), 'Error: no checkpoint directory found!' checkpoint = torch.load(args.pretrain) model.load_state_dict(checkpoint['state_dict']) logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title) logger.set_names(['Learning Rate', 'Train Loss', 'Train Acc.', 'Train IOU.']) elif args.resume: print('Resuming from checkpoint.') assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!' checkpoint = torch.load(args.resume) start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True) else: print('Training from scratch.') logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title) logger.set_names(['Learning Rate', 'Train Loss', 'Train Acc.', 'Train IOU.']) for epoch in range(start_epoch, args.n_epoch): adjust_learning_rate(args, optimizer, epoch) print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.n_epoch, optimizer.param_groups[0]['lr'])) train_loss, train_te_acc, train_ke_acc, train_te_iou, train_ke_iou = train(train_loader, model, dice_loss, optimizer, epoch) save_checkpoint({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'lr': args.lr, 'optimizer': optimizer.state_dict(), }, checkpoint=args.checkpoint) logger.append([optimizer.param_groups[0]['lr'], train_loss, train_te_acc, train_te_iou]) logger.close() if __name__ == '__main__': parser = argparse.ArgumentParser(description='Hyperparams') parser.add_argument('--arch', nargs='?', type=str, default='resnet50') parser.add_argument('--img_size', nargs='?', type=int, default=640, help='Height of the input image') parser.add_argument('--n_epoch', nargs='?', type=int, default=600, help='# of the epochs') parser.add_argument('--schedule', type=int, nargs='+', default=[200, 400], help='Decrease learning rate at these epochs.') parser.add_argument('--batch_size', nargs='?', type=int, default=16, help='Batch Size') parser.add_argument('--lr', nargs='?', type=float, default=1e-3, help='Learning Rate') parser.add_argument('--resume', nargs='?', type=str, default=None, help='Path to previous saved model to restart from') parser.add_argument('--pretrain', nargs='?', type=str, default=None, help='Path to previous saved model to restart from') parser.add_argument('--checkpoint', default='', type=str, metavar='PATH', help='path to save checkpoint (default: checkpoint)') args = parser.parse_args() main(args)
the-stack_106_29313
import logging import sdk_cmd LOG = logging.getLogger(__name__) def add_acls(user: str, task: str, topic: str, zookeeper_endpoint: str, env_str=None): """ Add Porducer and Consumer ACLs for the specifed user and topic """ _add_role_acls("producer", user, task, topic, zookeeper_endpoint, env_str) _add_role_acls("consumer --group=*", user, task, topic, zookeeper_endpoint, env_str) def _add_role_acls(role: str, user: str, task: str, topic: str, zookeeper_endpoint: str, env_str=None): cmd = "bash -c \"{setup_env}kafka-acls \ --topic {topic_name} \ --authorizer-properties zookeeper.connect={zookeeper_endpoint} \ --add \ --allow-principal User:{user} \ --{role}\"".format(setup_env="{} && ".format(env_str) if env_str else "", topic_name=topic, zookeeper_endpoint=zookeeper_endpoint, user=user, role=role) LOG.info("Running: %s", cmd) output = sdk_cmd.task_exec(task, cmd) LOG.info(output) def filter_empty_offsets(offsets: list, additional: list=[]) -> list: ignored_offsets = [None, {}, {"0": ""}] ignored_offsets.extend(additional) LOG.info("Filtering %s from %s", ignored_offsets, offsets) remaining = [o for o in offsets if o not in ignored_offsets] LOG.info("Remaining offsets: %s", remaining) return remaining
the-stack_106_29314
from tkinter import * from PIL import ImageTk, Image # Picture Processing library """ Instatantiate new window and define its properties """ # Create Window root = Tk() # Create Title root.title('ME362') # Define Default Window Size root.geometry("800x800") #(Width x Height) # root.state('zoomed') #Fullscreen """ Widgets """ # Label aFont = ("Century Gothic", 30) test_label1 = Label(root, text="This is a label", font=aFont) #(window location, the label) test_label1.grid(row=0, column=0) #(grid position of the widgets) test_label2 = Label(root, text="This also a label") #(window location, the label) test_label2.grid(row=1, column=0) #(grid position of the widgets) # Frame frame = LabelFrame(root) frame.grid(row=0, column=1, padx= 30, pady=32, ipadx=60, ipady=62) label_inframe = Label(frame, text="This also a label") #(window location, the label) label_inframe.grid(row=1, column=0) #(grid position of the widgets) #button n = 0 def a_function(an_argument): print(f'current value = {an_argument}') global n n += 1 myButton = Button( root, # Location text="Button", # Text in the button font=('Arial', 15), # Font style command= lambda: a_function(n), # Function ran on click fg = 'blue', # foreground color (in this case the text) bg = 'salmon', # background color activebackground='red' # background color while pressed ) myButton.grid(row = 2, column = 0) # Entry Boxes entry = Entry( root, width = 20, font = aFont, justify="center", state='readonly' ) entry.grid(row=1, column=1) entry.configure(state='normal') entry.insert(0, '23') entry.configure(state='readonly') value = entry.get() print(value) # Check Box def checkFunction(var): print(var) varCheck = StringVar() varCheck.set("On") checkBox = Checkbutton( root, text='Switch', onvalue= "On", offvalue= "Off", variable=varCheck, command= lambda: checkFunction(varCheck.get()) ) checkBox.grid(row = 2, column= 1) # Sliders def scaleFunction(args): global slider global sliderEntry sliderEntry.configure(state='normal') sliderEntry.delete(0, END) sliderEntry.insert(0, f'{10**(slider.get()/10):.2f}') sliderEntry.configure(state='readonly') sliderFrame = LabelFrame(root) sliderFrame.grid(row=3, column=0, padx= 30, pady=32, ipadx=60, ipady=62) slider = Scale( sliderFrame, from_=-20, to=20, orient="horizontal", width=20, length=200, showvalue=0, command=scaleFunction ) slider.grid(row=4, column=1) sliderEntry = Entry( sliderFrame, width = 10, borderwidth= 5, font = ('verdana', 15), justify="center", state='readonly' ) sliderEntry.grid(row=1, column=1) sliderEntry.configure(state='normal') sliderEntry.insert(0, 1.00) sliderEntry.configure(state='readonly') # Radio Button radioFrame = LabelFrame(root) radioFrame.grid(row=4, column=0, padx= 30, pady=32) colorMapVar = StringVar() colorMapVar.set('jet') radioJet = Radiobutton( radioFrame, variable=colorMapVar, text='Jet', value='jet', font=('arial',10)) radioCopper = Radiobutton( radioFrame, variable=colorMapVar, text='Copper', value='copper') radioCool = Radiobutton( radioFrame, variable=colorMapVar, text='Cool', value='cool') 'Optionally, use image instead of text beside the radio button' # imageJet = Image.open('jet.png') # imageCopper = Image.open('copper.png') # imageCool = Image.open('cool.png') # imageJet = ImageTk.PhotoImage(imageJet.resize((100,20))) # imageCopper = ImageTk.PhotoImage(imageCopper.resize((100,20))) # imageCool = ImageTk.PhotoImage(imageCool.resize((100,20))) # radioJet.configure(image=imageJet) # radioCopper.configure(image=imageCopper) # radioCool.configure(image=imageCool) radioJet.grid(row=0, column=0) radioCopper.grid(row=1, column=0) radioCool.grid(row=2, column=0) # Keep it open root.mainloop()
the-stack_106_29315
import collections import filecmp import logging import os import shutil import pytest from mock import patch from dvc.cache.base import CloudCache from dvc.dvcfile import DVC_FILE_SUFFIX, PIPELINE_FILE, Dvcfile from dvc.exceptions import ( CheckoutError, CheckoutErrorSuggestGit, ConfirmRemoveError, DvcException, NoOutputOrStageError, ) from dvc.main import main from dvc.remote.base import Remote from dvc.repo import Repo as DvcRepo from dvc.stage import Stage from dvc.stage.exceptions import StageFileDoesNotExistError from dvc.system import System from dvc.tree.local import LocalTree from dvc.tree.s3 import S3Tree from dvc.utils import relpath from dvc.utils.fs import walk_files from dvc.utils.yaml import dump_yaml, load_yaml from tests.basic_env import TestDvc, TestDvcGit from tests.func.test_repro import TestRepro from tests.remotes import S3 logger = logging.getLogger("dvc") class TestCheckout(TestRepro): def setUp(self): super().setUp() stages = self.dvc.add(self.DATA_DIR) self.assertEqual(len(stages), 1) self.data_dir_stage = stages[0] self.assertTrue(self.data_dir_stage is not None) self.orig = "orig" shutil.copy(self.FOO, self.orig) os.unlink(self.FOO) self.orig_dir = "orig_dir" shutil.copytree(self.DATA_DIR, self.orig_dir) shutil.rmtree(self.DATA_DIR) def test(self): self.dvc.checkout(force=True) self._test_checkout() def _test_checkout(self): self.assertTrue(os.path.isfile(self.FOO)) self.assertTrue(filecmp.cmp(self.FOO, self.orig, shallow=False)) class TestCheckoutSingleStage(TestCheckout): def test(self): ret = main(["checkout", "--force", self.foo_stage.path]) self.assertEqual(ret, 0) ret = main(["checkout", "--force", self.data_dir_stage.path]) self.assertEqual(ret, 0) self._test_checkout() class TestCheckoutCorruptedCacheFile(TestRepro): def test(self): cache = self.foo_stage.outs[0].cache_path os.chmod(cache, 0o644) with open(cache, "a") as fd: fd.write("1") with pytest.raises(CheckoutError): self.dvc.checkout(force=True) self.assertFalse(os.path.isfile(self.FOO)) self.assertFalse(os.path.isfile(cache)) class TestCheckoutCorruptedCacheDir(TestDvc): def test(self): # NOTE: using 'copy' so that cache and link don't have same inode ret = main(["config", "cache.type", "copy"]) self.assertEqual(ret, 0) self.dvc = DvcRepo(".") stages = self.dvc.add(self.DATA_DIR) self.assertEqual(len(stages), 1) self.assertEqual(len(stages[0].outs), 1) out = stages[0].outs[0] # NOTE: modifying cache file for one of the files inside the directory # to check if dvc will detect that the cache is corrupted. entry = self.dvc.cache.local.load_dir_cache(out.checksum)[0] entry_hash = entry[self.dvc.cache.local.tree.PARAM_CHECKSUM] cache = os.fspath( self.dvc.cache.local.tree.hash_to_path_info(entry_hash) ) os.chmod(cache, 0o644) with open(cache, "w+") as fobj: fobj.write("1") with pytest.raises(CheckoutError): self.dvc.checkout(force=True) self.assertFalse(os.path.exists(cache)) class TestCmdCheckout(TestCheckout): def test(self): ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) self._test_checkout() class CheckoutBase(TestDvcGit): GIT_IGNORE = ".gitignore" def commit_data_file(self, fname, content="random text"): with open(fname, "w") as fd: fd.write(content) stages = self.dvc.add(fname) self.assertEqual(len(stages), 1) self.assertTrue(stages[0] is not None) self.dvc.scm.add([fname + ".dvc", ".gitignore"]) self.dvc.scm.commit("adding " + fname) def read_ignored(self): with open(self.GIT_IGNORE) as f: return [s.strip("\n") for s in f.readlines()] def outs_info(self, stage): FileInfo = collections.namedtuple("FileInfo", "path inode") paths = [ path for output in stage["outs"] for path in self.dvc.tree.walk_files(output["path"]) ] return [ FileInfo(path=path, inode=System.inode(path)) for path in paths ] class TestRemoveFilesWhenCheckout(CheckoutBase): def test(self): fname = "file_in_a_branch" branch_master = "master" branch_1 = "b1" self.dvc.scm.add(self.dvc.scm.untracked_files()) self.dvc.scm.commit("add all files") # add the file into a separate branch self.dvc.scm.checkout(branch_1, True) ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) self.commit_data_file(fname) # Checkout back in master self.dvc.scm.checkout(branch_master) self.assertTrue(os.path.exists(fname)) # Make sure `dvc checkout` removes the file # self.dvc.checkout() ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) self.assertFalse(os.path.exists(fname)) class TestCheckoutCleanWorkingDir(CheckoutBase): @patch("dvc.prompt.confirm", return_value=True) def test(self, mock_prompt): mock_prompt.return_value = True stages = self.dvc.add(self.DATA_DIR) stage = stages[0] working_dir_change = os.path.join(self.DATA_DIR, "not_cached.txt") with open(working_dir_change, "w") as f: f.write("not_cached") ret = main(["checkout", stage.relpath]) self.assertEqual(ret, 0) self.assertFalse(os.path.exists(working_dir_change)) @patch("dvc.prompt.confirm", return_value=False) def test_force(self, mock_prompt): mock_prompt.return_value = False stages = self.dvc.add(self.DATA_DIR) self.assertEqual(len(stages), 1) stage = stages[0] working_dir_change = os.path.join(self.DATA_DIR, "not_cached.txt") with open(working_dir_change, "w") as f: f.write("not_cached") ret = main(["checkout", stage.relpath]) self.assertNotEqual(ret, 0) mock_prompt.assert_called() self.assertNotEqual(ret, 0) self.assertRaises(DvcException) class TestCheckoutSelectiveRemove(CheckoutBase): def test(self): # Use copy to test for changes in the inodes ret = main(["config", "cache.type", "copy"]) self.assertEqual(ret, 0) ret = main(["add", self.DATA_DIR]) self.assertEqual(0, ret) stage_path = self.DATA_DIR + DVC_FILE_SUFFIX stage = load_yaml(stage_path) staged_files = self.outs_info(stage) # move instead of remove, to lock inode assigned to stage_files[0].path # if we were to use remove, we might end up with same inode assigned to # newly checked out file shutil.move(staged_files[0].path, "random_name") ret = main(["checkout", "--force", stage_path]) self.assertEqual(ret, 0) checkedout_files = self.outs_info(stage) self.assertEqual(len(staged_files), len(checkedout_files)) self.assertEqual(staged_files[0].path, checkedout_files[0].path) self.assertNotEqual(staged_files[0].inode, checkedout_files[0].inode) self.assertEqual(staged_files[1].inode, checkedout_files[1].inode) class TestGitIgnoreBasic(CheckoutBase): def test(self): fname1 = "file_1" fname2 = "file_2" fname3 = "file_3" self.dvc.scm.add(self.dvc.scm.untracked_files()) self.dvc.scm.commit("add all files") self.assertFalse(os.path.exists(self.GIT_IGNORE)) self.commit_data_file(fname1) self.commit_data_file(fname2) self.dvc.run( single_stage=True, cmd=f"python {self.CODE} {self.FOO} {fname3}", deps=[self.CODE, self.FOO], outs_no_cache=[fname3], ) self.assertTrue(os.path.exists(self.GIT_IGNORE)) ignored = self.read_ignored() self.assertEqual(len(ignored), 2) self.assertIn("/" + fname1, ignored) self.assertIn("/" + fname2, ignored) class TestGitIgnoreWhenCheckout(CheckoutBase): def test(self): fname_master = "file_in_a_master" branch_master = "master" fname_branch = "file_in_a_branch" branch_1 = "b1" self.dvc.scm.add(self.dvc.scm.untracked_files()) self.dvc.scm.commit("add all files") self.commit_data_file(fname_master) self.dvc.scm.checkout(branch_1, True) ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) self.commit_data_file(fname_branch) self.dvc.scm.checkout(branch_master) ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) ignored = self.read_ignored() self.assertEqual(len(ignored), 1) self.assertIn("/" + fname_master, ignored) self.dvc.scm.checkout(branch_1) ret = main(["checkout", "--force"]) self.assertEqual(ret, 0) ignored = self.read_ignored() self.assertIn("/" + fname_branch, ignored) class TestCheckoutMissingMd5InStageFile(TestRepro): def test(self): d = load_yaml(self.file1_stage) del d[Stage.PARAM_OUTS][0][LocalTree.PARAM_CHECKSUM] del d[Stage.PARAM_DEPS][0][LocalTree.PARAM_CHECKSUM] dump_yaml(self.file1_stage, d) with pytest.raises(CheckoutError): self.dvc.checkout(force=True) class TestCheckoutEmptyDir(TestDvc): def test(self): dname = "empty_dir" os.mkdir(dname) stages = self.dvc.add(dname) self.assertEqual(len(stages), 1) stage = stages[0] self.assertTrue(stage is not None) self.assertEqual(len(stage.outs), 1) stage.outs[0].remove() self.assertFalse(os.path.exists(dname)) stats = self.dvc.checkout(force=True) assert stats["added"] == [dname + os.sep] self.assertTrue(os.path.isdir(dname)) self.assertEqual(len(os.listdir(dname)), 0) class TestCheckoutNotCachedFile(TestDvc): def test(self): cmd = "python {} {} {}".format(self.CODE, self.FOO, "out") self.dvc.add(self.FOO) stage = self.dvc.run( cmd=cmd, deps=[self.FOO, self.CODE], outs_no_cache=["out"], single_stage=True, ) self.assertTrue(stage is not None) stats = self.dvc.checkout(force=True) assert not any(stats.values()) class TestCheckoutWithDeps(TestRepro): def test(self): os.unlink(self.FOO) os.unlink(self.file1) self.assertFalse(os.path.exists(self.FOO)) self.assertFalse(os.path.exists(self.file1)) ret = main(["checkout", "--force", self.file1_stage, "--with-deps"]) self.assertEqual(ret, 0) self.assertTrue(os.path.exists(self.FOO)) self.assertTrue(os.path.exists(self.file1)) class TestCheckoutDirectory(TestRepro): def test(self): stage = self.dvc.add(self.DATA_DIR)[0] shutil.rmtree(self.DATA_DIR) self.assertFalse(os.path.exists(self.DATA_DIR)) ret = main(["checkout", stage.path]) self.assertEqual(ret, 0) self.assertTrue(os.path.exists(self.DATA_DIR)) class TestCheckoutHook(TestDvc): @patch("sys.stdout.isatty", return_value=True) @patch("dvc.prompt.input", side_effect=EOFError) def test(self, _mock_input, _mock_isatty): """ Test that dvc checkout handles EOFError gracefully, which is what it will experience when running in a git hook. """ stages = self.dvc.add(self.DATA_DIR) self.assertEqual(len(stages), 1) stage = stages[0] self.assertNotEqual(stage, None) self.create(os.path.join(self.DATA_DIR, "test"), "test") with self.assertRaises(ConfirmRemoveError): self.dvc.checkout() class TestCheckoutSuggestGit(TestRepro): def test(self): # pylint: disable=no-member try: self.dvc.checkout(targets="gitbranch") except DvcException as exc: self.assertIsInstance(exc, CheckoutErrorSuggestGit) self.assertIsInstance(exc.__cause__, NoOutputOrStageError) self.assertIsInstance( exc.__cause__.__cause__, StageFileDoesNotExistError ) try: self.dvc.checkout(targets=self.FOO) except DvcException as exc: self.assertIsInstance(exc, CheckoutErrorSuggestGit) self.assertIsInstance(exc.__cause__, NoOutputOrStageError) self.assertIsNone(exc.__cause__.__cause__) try: self.dvc.checkout(targets="looks-like-dvcfile.dvc") except DvcException as exc: self.assertIsInstance(exc, CheckoutErrorSuggestGit) self.assertIsInstance(exc.__cause__, StageFileDoesNotExistError) self.assertIsNone(exc.__cause__.__cause__) class TestCheckoutTargetRecursiveShouldNotRemoveOtherUsedFiles(TestDvc): def test(self): ret = main(["add", self.DATA_DIR, self.FOO, self.BAR]) self.assertEqual(0, ret) ret = main(["checkout", "-R", self.DATA_DIR]) self.assertEqual(0, ret) self.assertTrue(os.path.exists(self.FOO)) self.assertTrue(os.path.exists(self.BAR)) class TestCheckoutRecursiveNotDirectory(TestDvc): def test(self): ret = main(["add", self.FOO]) self.assertEqual(0, ret) stats = self.dvc.checkout(targets=[self.FOO + ".dvc"], recursive=True) assert stats == {"added": [], "modified": [], "deleted": []} class TestCheckoutMovedCacheDirWithSymlinks(TestDvc): def test(self): ret = main(["config", "cache.type", "symlink"]) self.assertEqual(ret, 0) ret = main(["add", self.FOO]) self.assertEqual(ret, 0) ret = main(["add", self.DATA_DIR]) self.assertEqual(ret, 0) self.assertTrue(System.is_symlink(self.FOO)) old_foo_link = os.path.realpath(self.FOO) self.assertTrue(System.is_symlink(self.DATA)) old_data_link = os.path.realpath(self.DATA) old_cache_dir = self.dvc.cache.local.cache_dir new_cache_dir = old_cache_dir + "_new" os.rename(old_cache_dir, new_cache_dir) ret = main(["cache", "dir", new_cache_dir]) self.assertEqual(ret, 0) ret = main(["checkout", "-f"]) self.assertEqual(ret, 0) self.assertTrue(System.is_symlink(self.FOO)) new_foo_link = os.path.realpath(self.FOO) self.assertTrue(System.is_symlink(self.DATA)) new_data_link = os.path.realpath(self.DATA) self.assertEqual( relpath(old_foo_link, old_cache_dir), relpath(new_foo_link, new_cache_dir), ) self.assertEqual( relpath(old_data_link, old_cache_dir), relpath(new_data_link, new_cache_dir), ) def test_checkout_no_checksum(tmp_dir, dvc): tmp_dir.gen("file", "file content") stage = dvc.run( outs=["file"], no_exec=True, cmd="somecmd", single_stage=True ) with pytest.raises(CheckoutError): dvc.checkout([stage.path], force=True) assert not os.path.exists("file") @pytest.mark.parametrize( "link, link_test_func", [("hardlink", System.is_hardlink), ("symlink", System.is_symlink)], ) def test_checkout_relink(tmp_dir, dvc, link, link_test_func): dvc.cache.local.cache_types = [link] tmp_dir.dvc_gen({"dir": {"data": "text"}}) dvc.unprotect("dir/data") assert not link_test_func("dir/data") stats = dvc.checkout(["dir.dvc"], relink=True) assert stats == empty_checkout assert link_test_func("dir/data") @pytest.mark.parametrize("link", ["hardlink", "symlink", "copy"]) def test_checkout_relink_protected(tmp_dir, dvc, link): dvc.cache.local.cache_types = [link] tmp_dir.dvc_gen("foo", "foo") dvc.unprotect("foo") assert os.access("foo", os.W_OK) stats = dvc.checkout(["foo.dvc"], relink=True) assert stats == empty_checkout # NOTE: Windows symlink perms don't propagate to the target if link == "copy" or (link == "symlink" and os.name == "nt"): assert os.access("foo", os.W_OK) else: assert not os.access("foo", os.W_OK) @pytest.mark.parametrize( "target", [os.path.join("dir", "subdir"), os.path.join("dir", "subdir", "file")], ) def test_partial_checkout(tmp_dir, dvc, target): tmp_dir.dvc_gen({"dir": {"subdir": {"file": "file"}, "other": "other"}}) shutil.rmtree("dir") stats = dvc.checkout([target]) assert stats["added"] == ["dir" + os.sep] assert list(walk_files("dir")) == [os.path.join("dir", "subdir", "file")] empty_checkout = {"added": [], "deleted": [], "modified": []} def test_stats_on_empty_checkout(tmp_dir, dvc, scm): assert dvc.checkout() == empty_checkout tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}, "other": "other"}}, commit="initial", ) assert dvc.checkout() == empty_checkout def test_stats_on_checkout(tmp_dir, dvc, scm): tmp_dir.dvc_gen( { "dir": {"subdir": {"file": "file"}, "other": "other"}, "foo": "foo", "bar": "bar", }, commit="initial", ) scm.checkout("HEAD~") stats = dvc.checkout() assert set(stats["deleted"]) == {"dir" + os.sep, "foo", "bar"} scm.checkout("-") stats = dvc.checkout() assert set(stats["added"]) == {"bar", "dir" + os.sep, "foo"} tmp_dir.gen({"lorem": "lorem", "bar": "new bar", "dir2": {"file": "file"}}) (tmp_dir / "foo").unlink() scm.repo.git.rm("foo.dvc") tmp_dir.dvc_add(["bar", "lorem", "dir2"], commit="second") scm.checkout("HEAD~") stats = dvc.checkout() assert set(stats["modified"]) == {"bar"} assert set(stats["added"]) == {"foo"} assert set(stats["deleted"]) == {"lorem", "dir2" + os.sep} scm.checkout("-") stats = dvc.checkout() assert set(stats["modified"]) == {"bar"} assert set(stats["added"]) == {"dir2" + os.sep, "lorem"} assert set(stats["deleted"]) == {"foo"} def test_checkout_stats_on_failure(tmp_dir, dvc, scm): tmp_dir.dvc_gen( {"foo": "foo", "dir": {"subdir": {"file": "file"}}, "other": "other"}, commit="initial", ) stage = Dvcfile(dvc, "foo.dvc").stage tmp_dir.dvc_gen({"foo": "foobar", "other": "other other"}, commit="second") # corrupt cache cache = stage.outs[0].cache_path os.chmod(cache, 0o644) with open(cache, "a") as fd: fd.write("destroy cache") scm.checkout("HEAD~") with pytest.raises(CheckoutError) as exc: dvc.checkout(force=True) assert exc.value.stats == { **empty_checkout, "failed": ["foo"], "modified": ["other"], } def test_stats_on_added_file_from_tracked_dir(tmp_dir, dvc, scm): tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}, "other": "other"}}, commit="initial", ) tmp_dir.gen("dir/subdir/newfile", "newfile") tmp_dir.dvc_add("dir", commit="add newfile") scm.checkout("HEAD~") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout scm.checkout("-") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout def test_stats_on_updated_file_from_tracked_dir(tmp_dir, dvc, scm): tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}, "other": "other"}}, commit="initial", ) tmp_dir.gen("dir/subdir/file", "what file?") tmp_dir.dvc_add("dir", commit="update file") scm.checkout("HEAD~") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout scm.checkout("-") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout def test_stats_on_removed_file_from_tracked_dir(tmp_dir, dvc, scm): tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}, "other": "other"}}, commit="initial", ) (tmp_dir / "dir" / "subdir" / "file").unlink() tmp_dir.dvc_add("dir", commit="removed file from subdir") scm.checkout("HEAD~") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout scm.checkout("-") assert dvc.checkout() == {**empty_checkout, "modified": ["dir" + os.sep]} assert dvc.checkout() == empty_checkout def test_stats_on_show_changes_does_not_show_summary( tmp_dir, dvc, scm, caplog ): tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}}, "other": "other"}, commit="initial", ) scm.checkout("HEAD~") with caplog.at_level(logging.INFO, logger="dvc"): caplog.clear() assert main(["checkout"]) == 0 for out in ["D\tdir" + os.sep, "D\tother"]: assert out in caplog.text assert "modified" not in caplog.text assert "deleted" not in caplog.text assert "added" not in caplog.text def test_stats_does_not_show_changes_by_default(tmp_dir, dvc, scm, caplog): tmp_dir.dvc_gen( {"dir": {"subdir": {"file": "file"}}, "other": "other"}, commit="initial", ) scm.checkout("HEAD~") with caplog.at_level(logging.INFO, logger="dvc"): caplog.clear() assert main(["checkout", "--summary"]) == 0 assert "2 files deleted" in caplog.text assert "dir" not in caplog.text assert "other" not in caplog.text @pytest.mark.parametrize("link", ["hardlink", "symlink", "copy"]) def test_checkout_with_relink_existing(tmp_dir, dvc, link): tmp_dir.dvc_gen("foo", "foo") (tmp_dir / "foo").unlink() tmp_dir.dvc_gen("bar", "bar") dvc.cache.local.cache_types = [link] stats = dvc.checkout(relink=True) assert stats == {**empty_checkout, "added": ["foo"]} def test_checkout_with_deps(tmp_dir, dvc): tmp_dir.dvc_gen({"foo": "foo"}) dvc.run( fname="copy_file.dvc", cmd="echo foo > bar", outs=["bar"], deps=["foo"], single_stage=True, ) (tmp_dir / "bar").unlink() (tmp_dir / "foo").unlink() stats = dvc.checkout(["copy_file.dvc"], with_deps=False) assert stats == {**empty_checkout, "added": ["bar"]} (tmp_dir / "bar").unlink() stats = dvc.checkout(["copy_file.dvc"], with_deps=True) assert set(stats["added"]) == {"foo", "bar"} def test_checkout_recursive(tmp_dir, dvc): tmp_dir.gen({"dir": {"foo": "foo", "bar": "bar"}}) dvc.add("dir", recursive=True) (tmp_dir / "dir" / "foo").unlink() (tmp_dir / "dir" / "bar").unlink() stats = dvc.checkout(["dir"], recursive=True) assert set(stats["added"]) == { os.path.join("dir", "foo"), os.path.join("dir", "bar"), } @pytest.mark.skipif( not S3.should_test(), reason="Only run with S3 credentials" ) def test_checkout_for_external_outputs(tmp_dir, dvc): dvc.cache.s3 = CloudCache(S3Tree(dvc, {"url": S3.get_url()})) remote = Remote(S3Tree(dvc, {"url": S3.get_url()})) file_path = remote.tree.path_info / "foo" remote.tree.s3.put_object( Bucket=remote.tree.path_info.bucket, Key=file_path.path, Body="foo" ) dvc.add(str(remote.tree.path_info / "foo"), external=True) remote.tree.remove(file_path) stats = dvc.checkout(force=True) assert stats == {**empty_checkout, "added": [str(file_path)]} assert remote.tree.exists(file_path) remote.tree.s3.put_object( Bucket=remote.tree.path_info.bucket, Key=file_path.path, Body="foo\nfoo", ) stats = dvc.checkout(force=True) assert stats == {**empty_checkout, "modified": [str(file_path)]} def test_checkouts_with_different_addressing(tmp_dir, dvc, run_copy): tmp_dir.gen({"foo": "foo", "lorem": "lorem"}) run_copy("foo", "bar", name="copy-foo-bar") run_copy("lorem", "ipsum", name="copy-lorem-ipsum") (tmp_dir / "bar").unlink() (tmp_dir / "ipsum").unlink() assert set(dvc.checkout(PIPELINE_FILE)["added"]) == {"bar", "ipsum"} (tmp_dir / "bar").unlink() (tmp_dir / "ipsum").unlink() assert set(dvc.checkout(":")["added"]) == {"bar", "ipsum"} (tmp_dir / "bar").unlink() assert dvc.checkout("copy-foo-bar")["added"] == ["bar"] (tmp_dir / "bar").unlink() assert dvc.checkout("dvc.yaml:copy-foo-bar")["added"] == ["bar"] (tmp_dir / "bar").unlink() assert dvc.checkout(":copy-foo-bar")["added"] == ["bar"] (tmp_dir / "bar").unlink() (tmp_dir / "data").mkdir() with (tmp_dir / "data").chdir(): assert dvc.checkout(relpath(tmp_dir / "dvc.yaml") + ":copy-foo-bar")[ "added" ] == [relpath(tmp_dir / "bar")] (tmp_dir / "bar").unlink() assert dvc.checkout("bar")["added"] == ["bar"] def test_checkouts_on_same_stage_name_and_output_name(tmp_dir, dvc, run_copy): tmp_dir.gen("foo", "foo") run_copy("foo", "bar", name="copy-foo-bar") run_copy("foo", "copy-foo-bar", name="make_collision") (tmp_dir / "bar").unlink() (tmp_dir / "copy-foo-bar").unlink() assert dvc.checkout("copy-foo-bar")["added"] == ["bar"] assert dvc.checkout("./copy-foo-bar")["added"] == ["copy-foo-bar"] def test_checkouts_for_pipeline_tracked_outs(tmp_dir, dvc, scm, run_copy): tmp_dir.gen("foo", "foo") stage1 = run_copy("foo", "bar", name="copy-foo-bar") tmp_dir.gen("lorem", "lorem") stage2 = run_copy("lorem", "ipsum", name="copy-lorem-ipsum") for out in ["bar", "ipsum"]: (tmp_dir / out).unlink() assert dvc.checkout(["bar"])["added"] == ["bar"] (tmp_dir / "bar").unlink() assert set(dvc.checkout([PIPELINE_FILE])["added"]) == {"bar", "ipsum"} for out in ["bar", "ipsum"]: (tmp_dir / out).unlink() assert set(dvc.checkout([stage1.addressing])["added"]) == {"bar"} (tmp_dir / "bar").unlink() assert set(dvc.checkout([stage2.addressing])["added"]) == {"ipsum"} (tmp_dir / "ipsum").unlink() assert set(dvc.checkout()["added"]) == {"bar", "ipsum"}
the-stack_106_29319
# Copyright 2018 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. # ============================================================================== """TPU embedding APIs.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import collections import copy import math import re import six from tensorflow.contrib.framework.python.framework import experimental from tensorflow.contrib.tpu.ops import gen_tpu_ops from tensorflow.contrib.tpu.proto import tpu_embedding_configuration_pb2 as elc from tensorflow.contrib.tpu.python.ops import tpu_ops from tensorflow.contrib.tpu.python.tpu import tpu_system_metadata as tpu_system_metadata_lib from tensorflow.python.framework import dtypes from tensorflow.python.framework import ops from tensorflow.python.framework import sparse_tensor from tensorflow.python.ops import array_ops from tensorflow.python.ops import control_flow_ops from tensorflow.python.ops import init_ops from tensorflow.python.ops import math_ops from tensorflow.python.ops import partitioned_variables from tensorflow.python.ops import state_ops from tensorflow.python.ops import variable_scope from tensorflow.python.ops import variables TRAINING = elc.TPUEmbeddingConfiguration.TRAINING INFERENCE = elc.TPUEmbeddingConfiguration.INFERENCE class TableConfig( collections.namedtuple( 'TableConfig', ['vocabulary_size', 'dimension', 'initializer', 'combiner'])): """Embedding table configuration.""" @experimental def __new__(cls, vocabulary_size, dimension, initializer=None, combiner='mean'): """Embedding table configuration. Args: vocabulary_size: Number of vocabulary (/rows) in the table. dimension: The embedding dimension. initializer: A variable initializer function to be used in embedding variable initialization. If not specified, defaults to `tf.truncated_normal_initializer` with mean `0.0` and standard deviation `1/sqrt(dimension)`. combiner: A string specifying how to reduce if there are multiple entries in a single row. Currently 'mean', 'sqrtn' and 'sum' are supported, with 'mean' the default. 'sqrtn' often achieves good accuracy, in particular with bag-of-words columns. For more information, see `tf.nn.embedding_lookup_sparse`. Returns: `TableConfig`. Raises: ValueError: if `vocabulary_size` is not positive integer. ValueError: if `dimension` is not positive integer. ValueError: if `initializer` is specified and is not callable. ValueError: if `combiner` is not supported. """ if not isinstance(vocabulary_size, int) or vocabulary_size < 1: raise ValueError('Invalid vocabulary_size {}.'.format(vocabulary_size)) if not isinstance(dimension, int) or dimension < 1: raise ValueError('Invalid dimension {}.'.format(dimension)) if (initializer is not None) and (not callable(initializer)): raise ValueError('initializer must be callable if specified.') if initializer is None: initializer = init_ops.truncated_normal_initializer( mean=0.0, stddev=1 / math.sqrt(dimension)) if combiner not in ('mean', 'sum', 'sqrtn'): raise ValueError('Invalid combiner {}'.format(combiner)) return super(TableConfig, cls).__new__(cls, vocabulary_size, dimension, initializer, combiner) # TODO(shizhiw): Factor `use_gradient_accumulation` and # `pipeline_execution_with_tensor_core` out of `_OptimizationParameters`. class _OptimizationParameters(object): """Parameters common to all optimizations.""" def __init__(self, learning_rate, use_gradient_accumulation, pipeline_execution_with_tensor_core): self.learning_rate = learning_rate self.use_gradient_accumulation = use_gradient_accumulation self.pipeline_execution_with_tensor_core = ( pipeline_execution_with_tensor_core) class AdagradParameters(_OptimizationParameters): """Optimization parameters for Adagrad.""" def __init__(self, learning_rate, initial_accumulator, use_gradient_accumulation=False, pipeline_execution_with_tensor_core=True): """Optimization parameters for Adagrad. Args: learning_rate: used for updating embedding table. initial_accumulator: initial accumulator for Adagrad. use_gradient_accumulation: setting this to `True` makes embedding gradients calculation more accurate but slower. Please see `optimization_parameters.proto` for details. for details. pipeline_execution_with_tensor_core: setting this to `True` makes training faster, but trained model will be different if step N and step N+1 involve the same set of embedding ID. Please see `tpu_embedding_configuration.proto` for details. """ super(AdagradParameters, self).__init__(learning_rate, use_gradient_accumulation, pipeline_execution_with_tensor_core) self.initial_accumulator = initial_accumulator class AdamParameters(_OptimizationParameters): """Optimization parameters for Adam.""" def __init__(self, learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-08, lazy_adam=True, sum_inside_sqrt=True, use_gradient_accumulation=False, pipeline_execution_with_tensor_core=True): """Optimization parameters for Adam. Args: learning_rate: a floating point value. The learning rate. beta1: A float value. The exponential decay rate for the 1st moment estimates. beta2: A float value. The exponential decay rate for the 2nd moment estimates. epsilon: A small constant for numerical stability. lazy_adam: Use lazy Adam instead of Adam. Lazy Adam trains faster. Please see `optimization_parameters.proto` for details. sum_inside_sqrt: This improves training speed. Please see `optimization_parameters.proto` for details. use_gradient_accumulation: setting this to `True` makes embedding gradients calculation more accurate but slower. Please see `optimization_parameters.proto` for details. for details. pipeline_execution_with_tensor_core: setting this to `True` makes training faster, but trained model will be different if step N and step N+1 involve the same set of embedding ID. Please see `tpu_embedding_configuration.proto` for details. """ super(AdamParameters, self).__init__(learning_rate, use_gradient_accumulation, pipeline_execution_with_tensor_core) self.beta1 = beta1 self.beta2 = beta2 self.epsilon = epsilon self.lazy_adam = lazy_adam self.sum_inside_sqrt = sum_inside_sqrt class StochasticGradientDescentParameters(_OptimizationParameters): """Optimization parameters for stochastic gradient descent. Args: learning_rate: a floating point value. The learning rate. use_gradient_accumulation: setting this to `True` makes embedding gradients calculation more accurate but slower. Please see `optimization_parameters.proto` for details. pipeline_execution_with_tensor_core: setting this to `True` makes training faster, but trained model will be different if step N and step N+1 involve the same set of embedding ID. Please see `tpu_embedding_configuration.proto` for details. """ def __init__(self, learning_rate, use_gradient_accumulation=False, pipeline_execution_with_tensor_core=True): super(StochasticGradientDescentParameters, self).__init__( learning_rate, use_gradient_accumulation, pipeline_execution_with_tensor_core) class TPUEmbedding(object): """API for using TPU for embedding. Example: ``` table_config_user = tpu_embedding.TableConfig( vocabulary_size=4, dimension=2, initializer=initializer, combiner='mean') table_to_config_dict = {'video': table_config_video, 'user': table_config_user} feature_to_table_dict = {'watched': 'video', 'favorited': 'video', 'friends': 'user'} batch_size = 4 num_hosts = 1 optimization_parameters = tpu_embedding.AdagradParameters(1., 1.) mode = tpu_embedding.TRAINING embedding = tpu_embedding.TPUEmbedding( table_to_config_dict, feature_to_table_dict, batch_size, num_hosts, mode, optimization_parameters) batch_size_per_core = embedding.batch_size_per_core sparse_features_list = [] for host in hosts: with ops.device(host): for _ in range(embedding.num_cores_per_host): sparse_features = {} sparse_features['watched'] = sparse_tensor.SparseTensor(...) sparse_features['favorited'] = sparse_tensor.SparseTensor(...) sparse_features['friends'] = sparse_tensor.SparseTensor(...) sparse_features_list.append(sparse_features) enqueue_ops = embedding.generate_enqueue_ops(sparse_features_list) def computation(): activations = embedding.get_activations() loss = compute_loss(activations) base_optimizer = gradient_descent.GradientDescentOptimizer( learning_rate=1) cross_shard_optimizer = tpu_optimizer.CrossShardOptimizer( base_optimizer) train_op = cross_shard_optimizer.minimize(loss) # `train_op` and `send_gradients_op` must happen in order. with ops.control_dependencies([train_op]): send_gradients_op = embedding.generate_send_gradients_op() with ops.control_dependencies([send_gradients_op]): loss = array_ops.identity(loss) loss = tpu.shard(computation, num_shards=embedding.num_cores) with self.test_session() as sess: sess.run(tpu.initialize_system(embedding_config= embedding.config_proto)) sess.run(variables.global_variables_initializer()) sess.run(embedding.init_ops) sess.run(enqueue_ops) loss_val = sess.run(loss) ``` """ # TODO(shizhiw): Instead of `feature_to_table_dict` which maps to table # name, consider `feature_to_config_dict` which maps to `FeatureConfig`. # `FeatureConfig` could have fields other than table name. For example, it # could have a field to indicate that the feature should not be used to # update embedding table (cr/204852758, cr/204940540). Also, this can support # different combiners for different features within the same table. # TODO(shizhiw, b/118512626): Remove `batch_size` from `__init__` and move it # to `FeatureConfig`? # TODO(shizhiw): will it be cleaner to make `table_to_config_dict` and # `feature_to_table_dict` lists of `TableSpec` and `FeatureSpec` respectively? # TODO(shizhiw): Consider adding `input_fn` as an option to remove boilerplate # for-loops around construction of inputs. # `optimization_parameter` applies to all tables. If the need arises, # we can add `optimization_parameters` to `TableConfig` to override this # global setting. @experimental def __init__(self, table_to_config_dict, feature_to_table_dict, batch_size, mode, master, optimization_parameters=None): """API for using TPU for embedding lookups. Args: table_to_config_dict: A dictionary mapping from string of table name to `TableConfig`. Table refers to an embedding table, e.g. `params` argument to `tf.nn.embedding_lookup_sparse()`. feature_to_table_dict: A dictionary mapping from string of feature name to string of table name. Feature refers to ids to lookup in embedding table, e.g. `sp_ids` argument to `tf.nn.embedding_lookup_sparse()`. batch_size: An `int` representing the global batch size. mode: `TRAINING` or `INFERENCE`. master: A `string` representing the TensorFlow master to use. optimization_parameters: `AdagradParameters`, `AdamParameters`, `Stochasticgradientdescentparameters`. Must be set in training and must be `None` in inference. Raises: ValueError: if any input is invalid. """ _validate_table_to_config_dict(table_to_config_dict) # Avoid nondeterminism from `Dict` iteration order by using `OrderedDict`. self._table_to_config_dict = _create_ordered_dict(table_to_config_dict) self._combiners = _create_combiners(self._table_to_config_dict) _validate_feature_to_table_dict(table_to_config_dict, feature_to_table_dict) self._feature_to_table_dict = _create_ordered_dict(feature_to_table_dict) self._table_to_features_dict = _create_table_to_features_dict( self._feature_to_table_dict) self._batch_size = batch_size self._master = master self._tpu_system_metadata = ( tpu_system_metadata_lib._query_tpu_system_metadata(self._master)) # pylint: disable=protected-access if self._tpu_system_metadata.num_cores == 0: raise ValueError('TPUEmbedding needs TPUs, but master {} does not have ' 'TPUs.'.format(self._master)) self._num_hosts = self._tpu_system_metadata.num_hosts self._hosts = [device.name for device in self._tpu_system_metadata.devices if 'device:CPU:' in device.name] self._num_cores_per_host = self._tpu_system_metadata.num_of_cores_per_host self._num_cores = self._tpu_system_metadata.num_cores _validate_batch_size(self._batch_size, self._num_cores) self._batch_size_per_core = self._batch_size // self._num_cores self._init_ops = [] # TODO(shizhiw): remove `mode`? if mode == TRAINING: _validate_optimization_parameters(optimization_parameters) self._optimization_parameters = optimization_parameters elif mode == INFERENCE: if optimization_parameters is not None: raise ValueError('`optimization_parameters` should be `None` ' 'for inference mode.') self._optimization_parameters = ( StochasticGradientDescentParameters(1.)) else: raise ValueError('`mode` only supports {} and {}; got {}.' .format(TRAINING, INFERENCE, mode)) self._mode = mode # TODO(shizhiw): move `optimization_parameters` into `_optimizer_handler` # and create special handler for inference that inherits from # StochasticGradientDescentHandler with more user-friendly error message # on get_slot(). self._optimizer_handler = _get_optimization_handler( self._optimization_parameters) dummy_table_variables_init_op = self._create_dummy_table_variables() self._init_ops.append(dummy_table_variables_init_op) self._config_proto = self._create_config_proto() self._create_variables_and_ops() self._init_ops.extend(self._load_parameters_ops) @property def hosts(self): """A list of device names for CPU hosts. Returns: A list of device names for CPU hosts. """ return copy.copy(self._hosts) # TODO(shizhiw): change to num_tensor_cores_per_host to be more explicit and # to be consistent with `tpu_embedding_configuration.proto`. @property def num_cores_per_host(self): """Number of TPU cores on a CPU host. Returns: Number of TPU cores on a CPU host. """ return self._num_cores_per_host @property def num_cores(self): """Total number of TPU cores on all hosts. Returns: Total number of TPU cores on all hosts. """ return self._num_cores @property def batch_size_per_core(self): """Batch size for each TPU core. The sparse tensors in `sparse_features_list` to `generate_enqueue_ops` must have batch dimension equal to this. Returns: Batch size for each TPU core. """ return self._batch_size_per_core @property def config_proto(self): """Create embedding config proto for `tpu.initialize_system()`. Returns: an `TPUEmbeddingConfiguration` proto describing the desired configuration of the hardware embedding lookup tables, which is passed to `tpu.initialize_system()`. """ return self._config_proto @property def init_ops(self): """Initialization ops for TPU embedding. It must be called after all global variables have been initialized, i.e. after `global_variables_initializer()`, as it loads embedding tables into TPU. Returns: A list of ops. """ return self._init_ops # TODO(shizhiw): get table variables the same way as getting slot variables. @property def table_to_table_variables_dict(self): return copy.copy(self._table_to_table_variables_dict) @property def feature_to_table_dict(self): return copy.copy(self._feature_to_table_dict) def get_slot_names(self): """Return a list of the names of slots created by `TPUEmbedding`.""" return self._optimizer_handler.get_slot_names() def get_slot(self, table, name): """Return a slot named `name` create for `table` by `TPUEmbedding`.""" return self._optimizer_handler.get_slot(table, name) # TODO(shizhiw): expose load to user too? @property def retrieve_parameters_ops(self): return self._retrieve_parameters_ops def _create_config_proto(self): """Create `TPUEmbeddingConfiguration`.""" config_proto = elc.TPUEmbeddingConfiguration() for table in self._table_to_config_dict: table_descriptor = config_proto.table_descriptor.add() table_descriptor.name = table table_config = self._table_to_config_dict[table] table_descriptor.vocabulary_size = table_config.vocabulary_size table_descriptor.dimension = table_config.dimension features_for_table = self._table_to_features_dict[table] table_descriptor.num_features = len(features_for_table) table_descriptor.optimization_parameters.learning_rate.constant = ( self._optimization_parameters.learning_rate) table_descriptor.optimization_parameters.use_gradient_accumulation = ( self._optimization_parameters.use_gradient_accumulation) self._optimizer_handler.set_optimization_parameters(table_descriptor) config_proto.mode = self._mode config_proto.batch_size_per_tensor_core = self._batch_size_per_core config_proto.num_hosts = self._num_hosts config_proto.num_tensor_cores = self._num_cores config_proto.sharding_strategy = elc.TPUEmbeddingConfiguration.DIV_DEFAULT config_proto.pipeline_execution_with_tensor_core = ( self._optimization_parameters.pipeline_execution_with_tensor_core) return config_proto def _create_variables_and_ops(self): """Create embedding variables and return ops to load them into TPU.""" self._load_parameters_ops = [] self._retrieve_parameters_ops = [] self._table_to_table_variables_dict = {} for table in self._table_to_config_dict: device_fn = _create_device_fn(self._hosts) with ops.device(device_fn): # TODO(shizhiw): allow user to specify variable name so that # they could make the name consistent with CPU etc. variable_name = table table_variables = _create_partitioned_variables( name=variable_name, num_hosts=self._num_hosts, vocabulary_size=self._table_to_config_dict[table].vocabulary_size, embedding_dimension=self._table_to_config_dict[table].dimension, initializer=self._table_to_config_dict[table].initializer, collections=[ops.GraphKeys.GLOBAL_VARIABLES]) self._table_to_table_variables_dict[table] = table_variables self._optimizer_handler.create_variables_and_ops( table, variable_name, self._num_hosts, self._table_to_config_dict[table], table_variables, self._load_parameters_ops, self._retrieve_parameters_ops) def _create_dummy_table_variables(self): """Create dummy embedding table variables. The sole purpose of these dummy variables are to trigger gradient calcuation wrt them so that the gradients wrt activation can be captured and later sent to TPU embedding. Returns: Initializer for these variables. Raises: RuntimeError: if collection to store gradients already exists and is not empty. """ self._dummy_table_variables = [] # TODO(shizhiw): remove table id. for table_id, table in enumerate(self._table_to_features_dict): self._dummy_table_variables.append( variable_scope.get_variable( 'tpu_embedding_dummy_table_variable_%s' % table, dtype=dtypes.float32, shape=[1], use_resource=True, trainable=True, # TODO(shizhiw): Remove these dummy variables as # tensorflow optimizer creates slot variable for them which # is undesirable. # e.g. tpu_embedding_dummy_table_variable_mlp_user/Adam{_1}. # Explicitly specifying collections prevents this variable from # being added to the GLOBAL_VARIABLES collection, so that Saver() # ignores it. collections=['tpu_embedding_dummy_table_variables'])) g = ops.get_default_graph() table_gradients = g.get_collection_ref( 'tpu_embedding_gradients_table_%d' % table_id) if table_gradients: raise RuntimeError( 'tpu_embedding_gradients_table_%d is not empty.' % table_id) table_gradients.extend([None] * len(self._table_to_features_dict[table])) return variables.variables_initializer( self._dummy_table_variables, name='tpu_embedding_dummy_table_variables_init') def generate_enqueue_ops(self, sparse_features_list): """Generate enqueue ops. Args: sparse_features_list: a list of dictionary mapping from string of feature names to sparse tensor. Each dictionary is for one TPU core. Dictionaries for the same core should be contiguous on the list. Returns: Ops to enqueue to TPU for embedding. """ self._validate_generate_enqueue_ops_sparse_features_list( sparse_features_list) return [ self._generate_enqueue_op( sparse_features, device_ordinal=i % self._num_cores_per_host) for i, sparse_features in enumerate(sparse_features_list) ] def _validate_generate_enqueue_ops_sparse_features_list( self, sparse_features_list): """Validate `sparse_features_list`.""" if len(sparse_features_list) != self._num_cores: raise ValueError('Length of `sparse_features_list` should match the ' 'number of cores; ' '`len(sparse_features_list)` is {}, ' 'number of cores is {}.'.format( len(sparse_features_list), self._num_cores)) feature_set = set(self._feature_to_table_dict.keys()) contiguous_device = None for i, sparse_features in enumerate(sparse_features_list): used_feature_set = set(sparse_features.keys()) # Check features are valid. missing_feature_set = feature_set - used_feature_set if missing_feature_set: raise ValueError('`sparse_features_list[{}]` misses a feature that is ' 'in `feature_to_config_dict`: {}.'.format( i, missing_feature_set)) extra_feature_set = used_feature_set - feature_set if extra_feature_set: raise ValueError('`sparse_features_list[{}]` has a feature that is not ' 'in `feature_to_config_dict`: {}.'.format( i, extra_feature_set)) device = None device_feature = None for feature, tensor in six.iteritems(sparse_features): if not isinstance(tensor, sparse_tensor.SparseTensor): raise ValueError('`sparse_features_list[{}]` has a feature that is ' 'not mapped to `SparseTensor`. ' '`feature`: {}, type: {}'.format( i, feature, type(tensor))) # Check all features are on the same device. if device is None: device = tensor.op.device device_feature = feature else: if device != tensor.op.device: raise ValueError('Devices are different between features in ' '`sparse_features_list[{}]`; ' 'devices: {}, {}; features: {}, {}.'.format( i, device, tensor.op.device, feature, device_feature)) if i % self._num_cores_per_host: if device != contiguous_device: raise ValueError('We expect the `sparse_features` which are on the ' 'same host to be contiguous in ' '`sparse_features_list`, ' '`sparse_features_list[{}]` is on device {}, ' 'but is expected to be on device {}.'.format( i, device, contiguous_device)) else: contiguous_device = device def _generate_enqueue_op(self, sparse_features, device_ordinal): with ops.colocate_with(list(sparse_features.values())[0]): sample_idcs, embedding_idcs, aggregation_weights = ( self._format_for_tpu_embedding_sparse_batch(sparse_features)) return tpu_ops.enqueue_tpu_embedding_sparse_batch( sample_idcs, embedding_idcs, aggregation_weights, combiners=self._combiners, device_ordinal=device_ordinal) def _format_for_tpu_embedding_sparse_batch(self, sparse_features): """Format sparse features for `enqueue_tpu_embedding_sparse_batch()`. Args: sparse_features: a `Dict` of `SparseTensor`s for embedding. Returns: Arguments for `enqueue_tpu_embedding_sparse_batch()`. """ sample_idcs, embedding_idcs, aggregation_weights = list(), list(), list() for table in self._table_to_features_dict: sample_t, indices_t, weights_t = list(), list(), list() features = self._table_to_features_dict[table] for i, feature in enumerate(features): tensor = sparse_features[feature] sample_indices = tensor.indices[:, 0] embedding_indices = tensor.values weights = array_ops.ones_like(embedding_indices) sample_t.append(i * self._batch_size_per_core + sample_indices) indices_t.append(embedding_indices) weights_t.append(weights) sample_idcs.append( math_ops.cast(array_ops.concat(sample_t, axis=0), dtype=dtypes.int32)) embedding_idcs.append( math_ops.cast( array_ops.concat(indices_t, axis=0), dtype=dtypes.int32)) aggregation_weights.append( math_ops.cast( array_ops.concat(weights_t, axis=0), dtype=dtypes.float32)) return sample_idcs, embedding_idcs, aggregation_weights def get_activations(self): """Get activations for features. This should be called within `computation` that is passed to `tpu.replicate` and friends. Returns: A dictionary mapping from `String` of feature name to `Tensor` of activation. """ recv_activations = tpu_ops.recv_tpu_embedding_activations( num_outputs=len(self._table_to_config_dict), config=self._config_proto.SerializeToString()) activations = collections.OrderedDict() for table_id, table in enumerate(self._table_to_features_dict): features = self._table_to_features_dict[table] for lookup_id, feature in enumerate(features): start_row = lookup_id * self._batch_size_per_core end_row = start_row + self._batch_size_per_core activations[feature] = gen_tpu_ops.tpu_embedding_activations( self._dummy_table_variables[table_id], recv_activations[table_id][start_row:end_row, :], table_id=table_id, lookup_id=lookup_id) return activations # TODO(shizhiw): Make `gradient_multiplier` per feature. Setting it to 0 would # have the effect of `tf.stop_gradients()`. # TODO(shizhiw): Consider alternative ways to capture gradients wrt embedding # layer outputs to remove `_dummy_table_variables`, # `_embedding_activation_grad` and `tpu_embedding_gradients_table_%d'. def generate_send_gradients_op(self, gradient_multipliers=None): """Retrieve gradients from collections and send them to TPU embedding. Args: gradient_multipliers: None, or dict mapping table names to gradient multiplier Tensors. Returns: SendTPUEmbeddingGradients Op. Raises: ValueError: If required gradients have not been defined. RuntimeError: If `mode` is not `TRAINING`. """ if self._mode != TRAINING: raise RuntimeError('Only in training mode gradients need to ' 'be sent to TPU embedding; got mode {}.' .format(self._mode)) g = ops.get_default_graph() gradients = list() for table_id, table in enumerate(self._table_to_config_dict): table_gradients = g.get_collection( 'tpu_embedding_gradients_table_%d' % table_id) if any(gradient is None for gradient in table_gradients): raise ValueError( 'Table {}/{} has undefined gradients: this is probably because the ' 'model asked TPUEmbedding to compute activations that were not ' 'used.'.format(table_id, table)) concat_table_grads = array_ops.concat(table_gradients, axis=0) if gradient_multipliers is not None: concat_table_grads *= gradient_multipliers[table.name] gradients.append(concat_table_grads) return tpu_ops.send_tpu_embedding_gradients( inputs=gradients, config=self.config_proto.SerializeToString()) def _validate_table_to_config_dict(table_to_config_dict): """Validate `table_to_config_dict`.""" for k, v in six.iteritems(table_to_config_dict): if not isinstance(v, TableConfig): raise ValueError('Value of `table_to_config_dict` must be of type ' '`TableConfig`, got {} for {}.'.format(type(v), k)) def _validate_feature_to_table_dict(table_to_config_dict, feature_to_table_dict): """Validate `feature_to_table_dict`.""" used_table_set = set(feature_to_table_dict.values()) table_set = set(table_to_config_dict.keys()) unused_table_set = table_set - used_table_set if unused_table_set: raise ValueError('`table_to_config_dict` specifies table that is not ' 'used in `feature_to_table_dict`: {}.' .format(unused_table_set)) extra_table_set = used_table_set - table_set if extra_table_set: raise ValueError('`feature_to_table_dict` refers to a table that is not ' 'specified in `table_to_config_dict`: {}.' .format(extra_table_set)) def _validate_batch_size(batch_size, num_cores): if batch_size % num_cores: raise ValueError('`batch_size` is not a multiple of number of ' 'cores. `batch_size`={}, `_num_cores`={}.'.format( batch_size, num_cores)) def _validate_optimization_parameters(optimization_parameters): if not isinstance(optimization_parameters, _OptimizationParameters): raise ValueError('`optimization_parameters` must inherit from ' '`_OptimizationPramaters`. ' '`type(optimization_parameters)`={}'.format( type(optimization_parameters))) class _OptimizerHandler(object): """Interface class for handling optimizer specific logic.""" def __init__(self, optimization_parameters): self._optimization_parameters = optimization_parameters def set_optimization_parameters(self, table_descriptor): raise NotImplementedError() def create_variables_and_ops(self, table, variable_name): raise NotImplementedError() def get_slot_names(self): raise NotImplementedError() def get_slot(self, table, name): raise NotImplementedError() class _AdagradHandler(_OptimizerHandler): """Handles Adagrad specific logic.""" def __init__(self, optimization_parameters): super(_AdagradHandler, self).__init__(optimization_parameters) self._table_to_accumulator_variables_dict = {} def set_optimization_parameters(self, table_descriptor): table_descriptor.optimization_parameters.adagrad.SetInParent() def create_variables_and_ops(self, table, variable_name, num_hosts, table_config, table_variables, load_parameters_ops, retrieve_parameters_ops): optimizer_name = 'Adagrad' accumulator_initializer = init_ops.constant_initializer( self._optimization_parameters.initial_accumulator) accumulator_variables = _create_partitioned_variables( name='%s/%s' % (variable_name, optimizer_name), num_hosts=num_hosts, vocabulary_size=table_config.vocabulary_size, embedding_dimension=table_config.dimension, collections=[ops.GraphKeys.GLOBAL_VARIABLES], initializer=accumulator_initializer) self._table_to_accumulator_variables_dict[table] = accumulator_variables for host_id, table_variable, accumulator_variable in (zip( range(num_hosts), table_variables, accumulator_variables)): with ops.colocate_with(table_variable): load_parameters_op = ( tpu_ops.load_tpu_embedding_adagrad_parameters( parameters=table_variable, accumulators=accumulator_variable, table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieved_table, retrieved_accumulator = ( tpu_ops.retrieve_tpu_embedding_adagrad_parameters( table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieve_parameters_op = control_flow_ops.group( state_ops.assign(table_variable, retrieved_table), state_ops.assign(accumulator_variable, retrieved_accumulator)) load_parameters_ops.append(load_parameters_op) retrieve_parameters_ops.append(retrieve_parameters_op) def get_slot_names(self): return ['accumulator'] def get_slot(self, table, name): if name not in self.get_slot_names(): raise ValueError('Adagrad has {} as slot names; got {}.' .format(self.get_slot_names(), name)) return self._table_to_accumulator_variables_dict[table] class _AdamHandler(_OptimizerHandler): """Handles Adam specific logic.""" def __init__(self, optimization_parameters): super(_AdamHandler, self).__init__(optimization_parameters) self._table_to_m_variables_dict = {} self._table_to_v_variables_dict = {} def set_optimization_parameters(self, table_descriptor): table_descriptor.optimization_parameters.adam.beta1 = ( self._optimization_parameters.beta1) table_descriptor.optimization_parameters.adam.beta2 = ( self._optimization_parameters.beta2) table_descriptor.optimization_parameters.adam.epsilon = ( self._optimization_parameters.epsilon) table_descriptor.optimization_parameters.adam.use_non_lazy_adam = ( not self._optimization_parameters.lazy_adam) table_descriptor.optimization_parameters.adam.use_sum_inside_sqrt = ( self._optimization_parameters.sum_inside_sqrt) def create_variables_and_ops(self, table, variable_name, num_hosts, table_config, table_variables, load_parameters_ops, retrieve_parameters_ops): optimizer_name = 'Adam' m_initializer = init_ops.zeros_initializer() m_variables = _create_partitioned_variables( name='%s/%s/m' % (variable_name, optimizer_name), num_hosts=num_hosts, vocabulary_size=table_config.vocabulary_size, embedding_dimension=table_config.dimension, collections=[ops.GraphKeys.GLOBAL_VARIABLES], initializer=m_initializer) v_initializer = init_ops.zeros_initializer() v_variables = _create_partitioned_variables( name='%s/%s/v' % (variable_name, optimizer_name), num_hosts=num_hosts, vocabulary_size=table_config.vocabulary_size, embedding_dimension=table_config.dimension, collections=[ops.GraphKeys.GLOBAL_VARIABLES], initializer=v_initializer) self._table_to_m_variables_dict[table] = m_variables self._table_to_v_variables_dict[table] = v_variables for host_id, table_variable, m_variable, v_variable in (zip( range(num_hosts), table_variables, m_variables, v_variables)): with ops.colocate_with(table_variable): load_parameters_op = ( tpu_ops.load_tpu_embedding_adam_parameters( parameters=table_variable, momenta=m_variable, velocities=v_variable, table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieved_table, retrieved_m, retrieved_v = ( tpu_ops.retrieve_tpu_embedding_adam_parameters( table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieve_parameters_op = control_flow_ops.group( state_ops.assign(table_variable, retrieved_table), state_ops.assign(m_variable, retrieved_m), state_ops.assign(v_variable, retrieved_v)) load_parameters_ops.append(load_parameters_op) retrieve_parameters_ops.append(retrieve_parameters_op) def get_slot_names(self): return ['m', 'v'] def get_slot(self, table, name): if name == 'm': return self._table_to_m_variables_dict[table] elif name == 'v': return self._table_to_v_variables_dict[table] else: raise ValueError('Adam has {} as slot names; got {}.' .format(self.get_slot_names(), name)) class _StochasticGradientDescentHandler(_OptimizerHandler): """Handles stochastic gradient descent specific logic.""" def set_optimization_parameters(self, table_descriptor): (table_descriptor.optimization_parameters.stochastic_gradient_descent .SetInParent()) def create_variables_and_ops(self, table, variable_name, num_hosts, table_config, table_variables, load_parameters_ops, retrieve_parameters_ops): del table_config for host_id, table_variable in (zip( range(num_hosts), table_variables)): with ops.colocate_with(table_variable): load_parameters_op = ( tpu_ops .load_tpu_embedding_stochastic_gradient_descent_parameters( parameters=table_variable, table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieved_table = ( tpu_ops .retrieve_tpu_embedding_stochastic_gradient_descent_parameters( table_name=table, num_shards=num_hosts, shard_id=host_id)) retrieve_parameters_op = control_flow_ops.group( state_ops.assign(table_variable, retrieved_table)) load_parameters_ops.append(load_parameters_op) retrieve_parameters_ops.append(retrieve_parameters_op) def get_slot_names(self): return [] def get_slot(self, table, name): raise ValueError('Stochastic gradient descent does not have slot variable.') def _get_optimization_handler(optimization_parameters): if isinstance(optimization_parameters, AdagradParameters): return _AdagradHandler(optimization_parameters) elif isinstance(optimization_parameters, AdamParameters): return _AdamHandler(optimization_parameters) elif isinstance(optimization_parameters, StochasticGradientDescentParameters): return _StochasticGradientDescentHandler(optimization_parameters) else: return NotImplementedError() def _create_ordered_dict(d): """Create an OrderedDict from Dict.""" return collections.OrderedDict((k, d[k]) for k in sorted(d)) def _create_combiners(table_to_config_dict): return [table_to_config_dict[t].combiner for t in table_to_config_dict] def _create_table_to_features_dict(feature_to_table_dict): """Create mapping from table to a list of its features.""" table_to_features_dict_tmp = {} for feature, table in six.iteritems(feature_to_table_dict): if table in table_to_features_dict_tmp: table_to_features_dict_tmp[table].append(feature) else: table_to_features_dict_tmp[table] = [feature] table_to_features_dict = collections.OrderedDict() for table in sorted(table_to_features_dict_tmp): table_to_features_dict[table] = sorted(table_to_features_dict_tmp[table]) return table_to_features_dict def _create_device_fn(hosts): """Create device_fn() to use with _create_partitioned_variables().""" def device_fn(op): """Returns the `device` for `op`.""" part_match = re.match(r'.*/part_(\d+)(/|$)', op.name) if part_match: idx = int(part_match.group(1)) else: raise RuntimeError('Internal Error: ' 'Expected %s to contain /part_*.' % op.name) device = hosts[idx] return device return device_fn def _create_partitioned_variables(name, num_hosts, vocabulary_size, embedding_dimension, initializer, collections=None): # pylint: disable=redefined-outer-name """Creates ParitionedVariables based on `num_hosts` for `table`.""" # TODO(shizhiw): automatically place embedding lookup elsewhere? if vocabulary_size < num_hosts: raise ValueError('`vocabulary_size`({}) is smaller than `num_hosts`({}). ' 'As TPU embedding is not optimized for small tables, ' 'please consider other ways for this embedding lookup.') return list(variable_scope.get_variable( name, shape=(vocabulary_size, embedding_dimension), partitioner=partitioned_variables.fixed_size_partitioner(num_hosts), dtype=dtypes.float32, initializer=initializer, collections=collections, trainable=False))
the-stack_106_29323
import turtle import ball num_balls = int(input("Number of balls to simulate: ")) turtle.speed(0) turtle.tracer(0) turtle.hideturtle() canvas_width = turtle.screensize()[0] canvas_height = turtle.screensize()[1] ball_radius = 0.05 * canvas_width turtle.colormode(255) color_list = [] xpos = [] ypos = [] vx = [] vy = [] ball_color = [] ball.initilizing(xpos, ypos, vx, vy, ball_color, canvas_width, canvas_height, ball_radius, num_balls) while (True): turtle.clear() for i in range(num_balls): ball.draw_circle(ball_color[i], ball_radius, xpos[i], ypos[i]) ball.move_circle(i, xpos, ypos, vx, vy, canvas_width, canvas_height, ball_radius) turtle.update() # hold the window; close it by clicking the window close 'x' mark turtle.done()
the-stack_106_29330
import numpy as np from perfect_information_game.tablebases import SymmetryTransform from perfect_information_game.tablebases import AbstractTablebaseManager, get_verified_chess_subclass class ChessTablebaseManager(AbstractTablebaseManager): """ Each tablebase has a descriptor, in a form such as KQkn (king and queen vs king and knight). Only the symmetrically unique variants of each position are stored in the tablebases. """ def __init__(self, GameClass=None): super().__init__(get_verified_chess_subclass(GameClass)) def query_position(self, state, outcome_only=False): """ Checks if the given position is in one of the existing tablebases. Returns a tuple containing the state after the optimal move has been made, the game's outcome, and the terminal distance. If the position is not available in the tablebases, then (None, np.nan, np.nan) will be returned. If the position is a draw by insufficient material, then (None, 0, 0) will be returned. :param state: :param outcome_only: If True, then the state after the move has been made will not be included in the returned tuple. """ if self.GameClass.is_over(state): outcome = self.GameClass.get_winner(state) return (outcome, 0) if outcome_only else (None, outcome, 0) if np.any(state[:, :, -2] == 1): # any positions with en passant or castling are excluded from the tablebase return (np.nan, np.nan) if outcome_only else (None, np.nan, np.nan) symmetry_transform = SymmetryTransform(self.GameClass, state) transformed_state = symmetry_transform.transform_state(state) descriptor = self.GameClass.get_position_descriptor(transformed_state, pawn_ranks=True) if descriptor in self.GameClass.DRAWING_DESCRIPTORS: return (0, 0) if outcome_only else (None, 0, 0) if descriptor not in self.available_tablebases: return (np.nan, np.nan) if outcome_only else (None, np.nan, np.nan) self.ensure_loaded(descriptor) tablebase = self.tablebases[descriptor] move_bytes = tablebase[self.GameClass.encode_board_bytes(transformed_state)] (start_i, start_j, end_i, end_j), outcome, terminal_distance = self.GameClass.parse_move_bytes(move_bytes) outcome = symmetry_transform.transform_outcome(outcome) if outcome_only: return outcome, terminal_distance if terminal_distance == 0: return None, outcome, 0 transformed_move_state = self.GameClass.apply_from_to_move(transformed_state, start_i, start_j, end_i, end_j) move_state = symmetry_transform.untransform_state(transformed_move_state) return move_state, outcome, terminal_distance def get_random_endgame(self, descriptor, condition=None): state = super().get_random_endgame(descriptor, condition) return SymmetryTransform.random(self.GameClass, descriptor).transform_state(state)
the-stack_106_29331
# Copyright (c) 2009 Raymond Hettinger # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation files # (the "Software"), to deal in the Software without restriction, # including without limitation the rights to use, copy, modify, merge, # publish, distribute, sublicense, and/or sell copies of the Software, # and to permit persons to whom the Software is furnished to do so, # subject to the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. from UserDict import DictMixin class OrderedDict(dict, DictMixin): def __init__(self, *args, **kwds): if len(args) > 1: raise TypeError('expected at most 1 arguments, got %d' % len(args)) try: self.__end except AttributeError: self.clear() self.update(*args, **kwds) def clear(self): self.__end = end = [] end += [None, end, end] # sentinel node for doubly linked list self.__map = {} # key --> [key, prev, next] dict.clear(self) def __setitem__(self, key, value): if key not in self: end = self.__end curr = end[1] curr[2] = end[1] = self.__map[key] = [key, curr, end] dict.__setitem__(self, key, value) def __delitem__(self, key): dict.__delitem__(self, key) key, prev, next = self.__map.pop(key) prev[2] = next next[1] = prev def __iter__(self): end = self.__end curr = end[2] while curr is not end: yield curr[0] curr = curr[2] def __reversed__(self): end = self.__end curr = end[1] while curr is not end: yield curr[0] curr = curr[1] def popitem(self, last=True): if not self: raise KeyError('dictionary is empty') if last: key = next(reversed(self)) else: key = next(iter(self)) value = self.pop(key) return key, value def __reduce__(self): items = [[k, self[k]] for k in self] tmp = self.__map, self.__end del self.__map, self.__end inst_dict = vars(self).copy() self.__map, self.__end = tmp if inst_dict: return (self.__class__, (items,), inst_dict) return self.__class__, (items,) def keys(self): return list(self) setdefault = DictMixin.setdefault update = DictMixin.update pop = DictMixin.pop values = DictMixin.values items = DictMixin.items iterkeys = DictMixin.iterkeys itervalues = DictMixin.itervalues iteritems = DictMixin.iteritems def __repr__(self): if not self: return '%s()' % (self.__class__.__name__,) return '%s(%r)' % (self.__class__.__name__, self.items()) def copy(self): return self.__class__(self) @classmethod def fromkeys(cls, iterable, value=None): d = cls() for key in iterable: d[key] = value return d def __eq__(self, other): if isinstance(other, OrderedDict): if len(self) != len(other): return False for p, q in zip(self.items(), other.items()): if p != q: return False return True return dict.__eq__(self, other) def __ne__(self, other): return not self == other
the-stack_106_29332
# (C) Datadog, Inc. 2020-present # All rights reserved # Licensed under a 3-clause BSD style license (see LICENSE) import re from io import StringIO DESCRIPTION_LINE_LENGTH_LIMIT = 120 TAB_SECTION_START = '<!-- xxx tabs xxx -->' TAB_SECTION_END = '<!-- xxz tabs xxx -->' TAB_START = '<!-- xxx tab "{}" xxx -->' TAB_END = '<!-- xxz tab xxx -->' INLINE_REF = re.compile(r"(\[[\s\S]+?\])\s*(\(.*?\))") class ReadmeWriter(object): def __init__(self): self.writer = StringIO() self.errors = [] def write(self, *strings): for s in strings: self.writer.write(s) def new_error(self, s): self.errors.append(s) @property def contents(self): return self.writer.getvalue() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.writer.close() def update_links(link, links): newref = max(links.values() or [0]) + 1 links[link] = newref def process_links(section, links): """Extract inline links and replace with references.""" text = section['description'] matches = INLINE_REF.findall(text) for m in matches: lnk = m[1] if lnk not in links: update_links(lnk, links) # replace (link) with [ref] newtext = INLINE_REF.sub(lambda x: '{}[{}]'.format(x.group(1), links[x.group(2)]), text) section['description'] = newtext def write_section(section, writer): header = '{} {}'.format('#' * section['header_level'], section['name']) description = section['description'] writer.write(header) writer.write('\n\n') writer.write(description) writer.write('\n') def get_references(links): refs = [] for link, ref in links.items(): line = f"[{ref}]: {link.lstrip('(').rstrip(')')}" refs.append(line) return '\n'.join(refs) class ReadmeConsumer(object): def __init__(self, spec): self.spec = spec def render(self): files = {} for file in self.spec['files']: with ReadmeWriter() as writer: links = dict() writer.write('# Agent Check: {}'.format(self.spec['name'])) writer.write('\n\n') sections = file['sections'] tab = None for section in sections: if section['hidden']: continue if section['tab']: if tab is None: tab = section['tab'] writer.write(TAB_SECTION_START + '\n') else: writer.write(TAB_END + '\n') writer.write(TAB_START.format(tab) + '\n') writer.write('\n') elif tab is not None: writer.write(TAB_END + '\n') writer.write(TAB_SECTION_END + '\n') writer.write('\n') tab = None process_links(section, links) write_section(section, writer) writer.write('\n') # add link references to the end of document refs = get_references(links) writer.write(refs) files[file['render_name']] = (writer.contents, writer.errors) return files
the-stack_106_29333
#!/usr/bin/python # -*- coding: UTF-8 -*- # @Time : 2020-07-16 09:01 # @Author : WangCong # @Email : [email protected] import numpy as np import cv2 camera_parameter = { # R "R": [[-0.91536173, 0.40180837, 0.02574754], [0.05154812, 0.18037357, -0.98224649], [-0.39931903, -0.89778361, -0.18581953]], # T "T": [1841.10702775, 4955.28462345, 1563.4453959], # f/dx, f/dy "f": [1145.04940459, 1143.78109572], # center point "c": [512.54150496, 515.45148698] } def pixel_to_world(camera_intrinsics, r, t, img_points): K_inv = camera_intrinsics.I R_inv = np.asmatrix(r).I R_inv_T = np.dot(R_inv, np.asmatrix(t)) world_points = [] coords = np.zeros((3, 1), dtype=np.float64) for img_point in img_points: coords[0] = img_point[0] coords[1] = img_point[1] coords[2] = 1.0 cam_point = np.dot(K_inv, coords) cam_R_inv = np.dot(R_inv, cam_point) scale = R_inv_T[2][0] / cam_R_inv[2][0] scale_world = np.multiply(scale, cam_R_inv) world_point = np.asmatrix(scale_world) - np.asmatrix(R_inv_T) pt = np.zeros((3, 1), dtype=np.float64) pt[0] = world_point[0] pt[1] = world_point[1] pt[2] = 0 world_points.append(pt.T.tolist()) return world_points if __name__ == '__main__': f = camera_parameter["f"] c = camera_parameter["c"] camera_intrinsic = np.mat(np.zeros((3, 3), dtype=np.float64)) camera_intrinsic[0, 0] = f[0] camera_intrinsic[1, 1] = f[1] camera_intrinsic[0, 2] = c[0] camera_intrinsic[1, 2] = c[1] camera_intrinsic[2, 2] = np.float64(1) r = camera_parameter["R"] t = np.asmatrix(camera_parameter["T"]).T # img_points = [[100, 200], # [150, 300]] img_points = np.array(([100, 200], [150, 300]), dtype=np.double) result = pixel_to_world(camera_intrinsic, r, t, img_points) print(result) print('----') axis = np.float32([[7700, 73407, 0], [-66029, -605036, 0]]) r2 = np.asmatrix(camera_parameter["R"]) result2, _ = cv2.projectPoints(axis, r2, t, camera_intrinsic, 0) print(result2)
the-stack_106_29335
import numpy as np from datetime import datetime import time from flask import Flask from flask import Markup from flask import Flask, request from flask import render_template from . import database from .core import publishers from . import apis from . import exceptions app = Flask(__name__) def get_weekly_topic_stats(language, topic): rows = None with database.connection() as conn: cur = conn.cursor() begin = datetime(2018, 10, 1) cur.execute(f"""SELECT date_trunc('week', created_at::date) AS week, COUNT(*), AVG(negative) AS avg_negative, AVG(neutral) AS avg_neutral, AVG(positive) AS avg_positive FROM tweets WHERE '{begin}'::date < created_at AND '{language}' = language AND '{topic}' = ANY(topics) GROUP BY week ORDER BY week;""") rows = cur.fetchall() colnames = [desc[0] for desc in cur.description] cur.close() rows = [dict(zip(colnames, row)) for row in rows] for row in rows: row["week"] = row["week"].strftime("%Y-%m-%d") return rows def get_thirty_days_topics(language): res = None with database.connection() as conn: cur = conn.cursor() cur.execute(f"SELECT begin, topics FROM thirty_days_topics WHERE language = '{language}'") res = cur.fetchall() cur.close() # return [{"begin": begin, "topics": topics} for begin, topics in res] return [{"topics": topics} for _, topics in res] @app.route("/") def chart(): languages = database.get_languages() topics = database.get_topics() topics_stats = {} thirty_days_stats = {} for language in languages: topics_stats[language] = {} for topic in topics: topics_stats[language][topic] = get_weekly_topic_stats(language, topic) thirty_days_stats[language] = get_thirty_days_topics(language) return render_template('index.html', thirty_days_stats=thirty_days_stats) # return render_template('chart.html', languages=languages, topics_stats=topics_stats, # thirty_days_stats=thirty_days_stats, topics=topics) def get_weekly_count(token): rows = None begin = datetime(2018, 10, 1) with database.connection() as conn: cur = conn.cursor() cur.execute(f"""SELECT date_trunc('week', created_at::date) AS week, COUNT(*) FROM tweets WHERE '{token}' = ANY(tokens) AND '{begin}'::date < created_at GROUP BY week ORDER BY week;""") rows = cur.fetchall() colnames = [desc[0] for desc in cur.description] cur.close() rows = [dict(zip(colnames, row)) for row in rows] for row in rows: row["week"] = row["week"].strftime("%Y-%m-%d") return rows @app.route('/search_engine') def search_engine(): tokens = [] if "text" in request.args: text = request.args.get('text') tokens = [token.strip() for token in text.lower().split(',')] weekly_count = {} for token in tokens: weekly_count[token] = get_weekly_count(token) return render_template('search_engine.html', tokens_weekly_count=weekly_count, tokens=tokens) def get_token_evolution(token): totals_view = """ CREATE VIEW totals AS SELECT publisher, date_trunc('month', created_at) AS month, COUNT(*) FROM tweets GROUP BY publisher, month """ tokens_view = """ CREATE MATERIALIZED VIEW tokenized_tweets AS SELECT publishers.name AS publisher, date_trunc('month', created_at) AS month, to_tsvector('simple', unaccent(text)) AS tokens FROM tweets JOIN publishers ON tweets.publisher = publishers.screen_name WITH DATA """ # tokens_view = """ # CREATE MATERIALIZED VIEW tokenized_tweets AS # SELECT publishers.name AS publisher, date_trunc('month', created_at) AS month, # to_tsvector(publishers.language::regconfig, unaccent(text)) AS tokens # FROM tweets # JOIN publishers ON tweets.publisher = publishers.screen_name # WITH DATA # """ query = f""" SELECT publisher, COUNT(*) AS matches, month FROM tokenized_tweets WHERE tokens @@ to_tsquery('{token}') GROUP by publisher, month ORDER BY publisher, month """ # query = f""" # SELECT totals.month, totals.publisher, # CASE WHEN matching.count is NULL THEN 0 ELSE matching.count END AS matches, totals.count AS total # FROM (SELECT publisher, COUNT(*), month # FROM tokenized_tweets # WHERE tokens @@ to_tsquery('{token}') # GROUP by publisher, month) as matching # RIGHT OUTER JOIN totals ON matching.publisher = totals.publisher and matching.month = totals.month # ORDER BY totals.publisher, totals.month # """ # query = f""" # SELECT total.month, total.publisher, # CASE WHEN matching.count is NULL THEN 0 ELSE matching.count END AS matches, # total.count AS total # FROM (SELECT publisher, count(*), date_trunc('month', created_at) AS month # FROM tweets JOIN publishers ON tweets.publisher = publishers.screen_name # WHERE to_tsvector(publishers.language::regconfig, unaccent(text)) @@ to_tsquery('{token}') # GROUP BY publisher, month) AS matching # RIGHT OUTER JOIN (SELECT publisher, date_trunc('month', created_at) AS month, COUNT(*) # FROM tweets # GROUP BY publisher, month) AS total # ON matching.publisher = total.publisher AND matching.month = total.month # ORDER BY total.publisher, total.month # """ with database.connection() as conn: cur = conn.cursor() cur.execute(query) rows = cur.fetchall() colnames = [desc[0] for desc in cur.description] cur.close() data = [dict(zip(colnames, row)) for row in rows] for i, record in enumerate(data): data[i]["month"] = record["month"].strftime('%Y-%m') return data @app.route("/token_evolution", methods=["GET"]) def token_evolution(): data = None query = None if "token" in request.args: query = request.args["token"] data = get_token_evolution(request.args["token"]) # data = [{"month": datetime(2018, 11, 1).strftime('%Y-%m'), "publisher": "a", "matches": 23, "total": 20},{"month": datetime(2018, 12, 1).strftime('%Y-%m'), "publisher": "a", "matches": 22, "total": 20}, # {"month": datetime(2018, 10, 1).strftime('%Y-%m'), "publisher": "b", "matches": 4, "total": 20}, {"month": datetime(2018, 11, 1).strftime('%Y-%m'), "publisher": "b", "matches": 1, "total": 20}] return render_template('token_evolution.html', data=data, query=query) def run_query(query): res = None with database.connection() as conn: cur = conn.cursor() cur.execute(query) res = cur.fetchall() return render_template('db_stats.html', query_text=query_response) @app.route('/db_stats') def db_stats(): tokens = [] query_response = "" if "text" in request.args and request.args.get('text') != "": query = request.args.get('text') query_response = run_query(query) if query_response is not None: query_response = [', '.join([str(item) for item in row]) for row in query_response] query_response = '<br>'.join(query_response) return render_template('db_stats.html', query_text=query_response) @app.route('/publishers') def publishers_route(): print(request.args) message = None languages = database.get_languages() if ("screen_name" in request.args and request.args.get("screen_name") != "") \ and ("language" in request.args): language = request.args.get("language").lower() if language not in languages: message = f"'{language}' not in {database.get_languages()}" else: twitter_name = request.args.get("screen_name") api = apis.get_twitter() try: publisher = publishers.get_info(api, twitter_name) except exceptions.InvalidTwitterUserException as exc: message = f"Twitter user '{twitter_name}' not found" else: try: publishers.insert_db([publisher]) message = f"Added {publisher['name']} - {publisher['screen_name']} into DB" except exceptions.DuplicateDBEntryException: message = f"{publisher['name']} is already present in DB" publishers_stats = publishers.get_publishers() for publisher in publishers_stats: for key in publisher: if publisher[key] is None or key == "insert_timestamp": publisher[key] = "" return render_template('publishers.html', publishers=publishers_stats, message=message, language_pattern='|'.join(languages)) if __name__ == "__main__": app.run(host="127.0.0.1", port=8080) # app.run(host="192.168.1.237", port=8080) # app.run(host="192.168.1.11", port=8080)
the-stack_106_29336
# a123_apple_1.py import turtle as trtl #-----setup----- t=0 tstep = 0.25 delx = 2 g = -1 yvel = 20 y=0 apple_image = "apple.gif" # Store the file name of your shape pear_image = "pear.gif" # Store the file name of your shape wn = trtl.Screen() wn.setup(width=0.3, height=0.35) wn.bgpic("background.gif") wn.addshape(apple_image) # Make the screen aware of the new file wn.addshape(pear_image) # Make the screen aware of the new file # apple = trtl.Turtle() # apple.hideturtle() pear = trtl.Turtle() WorldBorder = (3,4) drawer = trtl.Turtle() posVal = True #-----functions----- # given a turtle, set that turtle to be shaped by the image file def border_control(border): for object_range in range(0,100,1): border.goto(100,-200) def draw_apple(active_apple): global posVal active_apple.shape(apple_image) active_apple.penup() active_apple.goto(0,-200) if posVal == True: posVal = False active_apple.goto(-280,-200) else: posVal = True active_apple.goto(280,-200) wn.update() def draw_pear(activate_pear): activate_pear.shape(pear_image) wn.update() def object_fall(object): global t, yvel, y, tstep, delx, g for vel_sample in range(0,5,1): object.goto(vel_sample,-200) num = 0 while (5): t=t+tstep x=t*delx yvel = yvel + g * tstep y=y + yvel * tstep object.goto(x,y) num = num + 1 if object.ycor() < -200: print("OBJECT BORDER REACHED: ",object.ycor()) if num > 200: object.clear() t=0 tstep = 0.25 delx = 2 g = -1 yvel = 20 y=0 break print(num) def get_mouse_click_coor(x, y): print(x, y) def draw_an_A(): drawer.color("blue") drawer.write("A", font=("Arial", 74, "bold")) drawer.penup() drawer.forward(30) draw_pear(pear) object_fall(pear) #-----function calls----- trtl.onscreenclick(get_mouse_click_coor) wn.onkeypress(draw_an_A, "a") wn.listen() wn.mainloop()
the-stack_106_29337
import requests import pandas as pd import datetime as dt import numpy as np #### dict_keys(['table', 'currency', 'code', 'rates']) def getCurrencyLow(days, currency, currencyName): # Getting currency below 350 days (used for getting data from larger time periods) today = dt.datetime.today() for i in range(days + 1): last = today - dt.timedelta(days = i) startDate = today.strftime('%Y-%m-%d') endDate = last.strftime('%Y-%m-%d') connect = 'http://api.nbp.pl/api/exchangerates/rates/a/' + currency + '/' + endDate + '/' + startDate connectResult = requests.get(connect) response = connectResult.json() data = pd.DataFrame(response['rates'], columns=['effectiveDate', 'mid'], index=None) NewNames = {'effectiveDate': 'Data', 'mid': currencyName} data.rename(columns=NewNames, inplace=True) return data def getCurrency(numberofDays, currency, currencyName): # Downloading currency data from larger time periods if numberofDays < 350: result = getCurrencyLow(numberofDays, currency, currencyName) return result else: results = [] condition = round(numberofDays / 350) currentDays = 350 start = dt.datetime.today() #print("condition:", condition) for section in range(condition + 1): #print("section:", section) for i in range(currentDays + 1): last = start - dt.timedelta(days=i) startDate = start.strftime('%Y-%m-%d') endDate = last.strftime('%Y-%m-%d') connect = 'http://api.nbp.pl/api/exchangerates/rates/a/' + currency + '/' + endDate + '/' + startDate #print(connect) connectResult = requests.get(connect) response = connectResult.json() data = pd.DataFrame(response['rates'], columns=['effectiveDate', 'mid'], index=None) NewNames = {'effectiveDate': 'Data', 'mid': currencyName} data.rename(columns=NewNames, inplace=True) data.sort_values(by='Data', inplace=True, ascending=False) data = data.reset_index(drop=True) results.append(data) start = last numberofDays -= 350 if numberofDays < 350: currentDays = numberofDays return results ################################################################################# ############################### Final function ################################## # # Modifying downloaded data, adding the previous day # to holidays in order to complete all records. # ################################################################################# def finalDownload(finalDays, finalCurrencyCode, finalCurrencyName): tempCurrency = getCurrency(finalDays, finalCurrencyCode, finalCurrencyName) downloadedCurrency = tempCurrency[0] for i in range(len(tempCurrency) - 1): downloadedCurrency = downloadedCurrency.append(tempCurrency[i + 1]) downloadedCurrency.drop_duplicates(subset='Data', inplace=True) downloadedCurrency = downloadedCurrency.reset_index(drop=True) downloadedCurrency = downloadedCurrency.astype({'Data': 'datetime64'}) daysResult = [] Results = [] for i in range(downloadedCurrency.shape[0] - 1): result = (downloadedCurrency['Data'][i] - downloadedCurrency['Data'][i + 1]).days if result != 1: Results.append(result) daysResult.append([downloadedCurrency['Data'][i], downloadedCurrency['Data'][i + 1], downloadedCurrency[finalCurrencyName][i + 1]]) for i in range(len(daysResult)): checkFinal = downloadedCurrency['Data'].isin([daysResult[i][1]]) checkFinalindex = checkFinal[checkFinal == True].index slicePart = checkFinalindex[0] for j in range(Results[i] - 1): line = pd.DataFrame({'Data': 'Dzień wolny', finalCurrencyName: daysResult[i][2]}, index=[slicePart]) downloadedCurrency = downloadedCurrency.append(line, ignore_index=False) downloadedCurrency = downloadedCurrency.sort_index().reset_index(drop=True) del downloadedCurrency['Data'] newDates = [] toDay = dt.datetime.today() for k in range(downloadedCurrency.shape[0]): lastDay = toDay - dt.timedelta(days=k) newDates.append(lastDay.strftime('%Y-%m-%d')) downloadedCurrency.insert(0, 'Data', newDates) downloadedCurrency.sort_values(by='Data', inplace=True, ascending=False) downloadedCurrency = downloadedCurrency.reset_index(drop=True) return downloadedCurrency
the-stack_106_29340
import os import cloudpickle from quake.client.base.client import Client from quake.client.base.plan import Plan _global_plan = Plan() _global_client = None _pickle_cache = {} _inouts_objs = {} def get_inout_obj(obj): pair = _inouts_objs.get(id(obj)) if pair: return pair[0] else: return None def set_inout_obj(obj, value): _inouts_objs[id(obj)] = (value, obj) def pop_inout_obj(obj): obj_id = id(obj) if obj_id is not _inouts_objs: return None pair = _inouts_objs.pop(obj_id) return pair[0] def pickle_function(fn): data = _pickle_cache.get(fn) if data is None: data = cloudpickle.dumps(fn) _pickle_cache[fn] = data return data def get_global_plan(): return _global_plan def flush_global_plan(client): tasks = _global_plan.take_tasks() if tasks: client.submit(tasks) # for task in tasks: # print("QE: task_id = {} <-> call_id = {}, outputs={}" # .format(task.task_id, task.call_id, task.n_outputs)) def ensure_global_client(): global _global_client if _global_client is None: server = os.environ.get("QUAKE_SERVER") if server is None: raise Exception( "No global server is defined." "Set variable QUAKE_SERVER or call quake.client.set_global_client()" ) if ":" in server: hostname, port = server.rsplit(":", 1) try: port = int(port) except ValueError: raise Exception("Invalid format of QUAKE_SERVER variable") _global_client = Client(hostname, port) else: _global_client = Client(server) return _global_client