예제 #1
0
    def get_context_data(self, **kwargs):
        helper = utils()
        kwargs = super(UpdateAppointmentStatus, self).get_context_data(**kwargs)

        # if the doctor click the update button
        appointment_id = self.request.GET["appointment_id"]

        if self.request.GET['start'] == '1':
            # start the session
            db_sync(appointment_id, {"status": STATUS_IN_SESSION})

            # update the session start time
            dbutils.update(appointment_id, {"session_start_time": helper.get_current_time()})

            # get waiting time and update waiting_duration
            arrive_time = dbutils.query(appointment_id, "arrive_time")
            waiting_duration = helper.get_duration(arrive_time, helper.get_current_time())
            dbutils.update(appointment_id, {"waiting_duration": waiting_duration})

        else:
            # end the session
            db_sync(appointment_id, {"status": STATUS_COMPLETED})

            # get session time
            session_start_time = dbutils.query(appointment_id, "session_start_time")
            session_time = helper.get_duration(session_start_time, helper.get_current_time())
            dbutils.update(appointment_id, {"session_duration": session_time})

        messages.success(self.request, "You have updated the appointment status successfully!")
        return kwargs
예제 #2
0
    def get_context_data(self, **kwargs):
        kwargs = super(PatientCheckIn, self).get_context_data(**kwargs)
        helper = utils()

        # get first_name and last_name from url
        first_name = self.request.GET.get("first_name")
        last_name = self.request.GET.get("last_name")
        full_name = first_name + " " + last_name

        # get date_of_birth from url
        date_of_birth = self.request.GET.get("date_of_birth")

        # get all appointments
        try:
            appointments_iterator = helper.get_all_appointments(first_name, last_name, date_of_birth)
        except Exception:
            # indication of whether there exists appointment today. 1 denote there is no appointment today
            kwargs["err"] = 1
            return kwargs

        result = helper.get_appointments_render(appointments_iterator)

        # compare the newest result with db, if there is new data, add it.
        dbutils.add(result)

        # pass all appointment to the page
        kwargs["appointments"] = result

        # patient name
        kwargs["last_name"] = last_name
        kwargs["first_name"] = first_name
        kwargs["pid"] = helper.get_patient(first_name, last_name, date_of_birth)["id"]
        # size for no appointments
        kwargs["size"] = len(result)
        return kwargs
예제 #3
0
    def transition_terminar(self):
        "Crear las lineas de producto en la venta y finalizar wizard"
        logger.info('Borrar lineas del producto temporal al Finalizar Wizard')

        pool = Pool()
        t = Transaction()
        ut = utils()
        Sale = pool.get('sale.sale')
        sale = Sale.search([('id', '=', t.context['active_id'])])[0]
        OrdenTrabajo = pool.get('sale_printery_budget.orden_trabajo')
        SaleLine = pool.get('sale.line')
        interior = OrdenTrabajo.search([('id', '=', self.elegir_interior.orden_trabajo.id)])[0]
        sale_lines = SaleLine.search(['id_interior', '=', interior.id_interior])
        # Borrar lineas anteriores y orden de trabajo anterior
        SaleLine.delete(sale_lines)
        OrdenTrabajo.delete([interior])

        # Genero lineas nuevas.
        ut.interior = self.interior
        lineas_venta = ut.creo_lineas_de_venta()
        ut.creo_orden_trabajo(sale, lineas_venta)
        ut.crear_otra_cantidad_base(sale)
        ut.borrar_productos_temporales(self.interior.id_wizard_start)

        return 'end'
예제 #4
0
    def transition_terminar(self):
        "Crear las lineas de producto en la venta y finalizar wizard"
        logger.info('Borrar lineas del producto temporal al Finalizar Wizard')

        t = Transaction()
        Sale = Pool().get('sale.sale')
        sale = Sale.search([('id', '=', t.context['active_id'])])[0]
        ut = utils()
        ut.interior = self.interior

        if hasattr(self.interior, 'producto_papel') == False or self.interior.producto_papel is None:
            # Primera vez que se ejecuta la pantalla interior.
            try:
                ut.borrar_productos_temporales(self.interior.id_wizard_start)
            except:
                logger.info('Primera vez que se ejecuta la pantalla. No se pudo borrar productos temporales')

            # Debo verificar que la venta ya tiene lineas de venta. Si es así,
            # calcular otras cantidades y return 'end'.
            if sale.lines:
                ut.crear_otra_cantidad_base(sale)
            return 'end'

        lineas_venta = ut.creo_lineas_de_venta()
        ut.creo_orden_trabajo(sale, lineas_venta)
        ut.crear_otra_cantidad_base(sale)
        ut.borrar_productos_temporales(self.interior.id_wizard_start)
        return 'end'
예제 #5
0
 def __init__(self):
     self.path = None
     self.data = loader()
     self.processedmetro = None
     self.windir = None
     self.weather = None
     self.meanmetro = None
     self.helper = utils()
예제 #6
0
 def get_context_data(self, **kwargs):
     helper = utils()
     kwargs = super(TimeStat, self).get_context_data(**kwargs)
     appointment_id = self.request.GET['appointment_id']
     """
     get the time stat
     """
     kwargs["time_stat"] = helper.get_time_stat(appointment_id)
     return kwargs
예제 #7
0
파일: arm.py 프로젝트: carlkeifer3/tbRigKit
 def __init__(self):
     self.utils = utils()
     self.prefix = 'l_'
     self.suffix = 'fk'
     self.shoulder = ('%sshoulder%s' % (self.prefix, self.suffix))
     self.elbow = ('%selbow_%s' % (self.prefix, self.suffix))
     self.wrist = ('%swrist_%s' % (self.prefix, self.suffix))
     self.radius = 0.2
     self.scale = 1
예제 #8
0
 def Greedy_Search(self):
     graph = Graph()
     funcUtils = utils()
     funcUtils.read_file_first_space('Cidades_grafo.txt', graph)
     funcUtils.read_file_and_connect('Cidades_grafo.txt', graph)
     heuristics = {}
     funcUtils.create_heuristics('Cidades_Faro.txt', heuristics)
     nodeStart = input("What is the source node?\n")
     funcUtils.Greedy_Search_util(graph, heuristics, nodeStart.capitalize(),
                                  'Faro')
예제 #9
0
 def depth_Limited_Search(self):
     graph = Graph()
     funcUtils = utils()
     funcUtils.read_file_first_space('Cidades_grafo.txt', graph)
     funcUtils.read_file_and_connect('Cidades_grafo.txt', graph)
     nodeStart = input("What is the source node?\n")
     nodeGoal = input("What is the goal node?\n")
     limit = input("what is the limit?\n")
     funcUtils.depth_Limited_Search_util(graph, nodeStart.capitalize(),
                                         nodeGoal.capitalize(), limit)
예제 #10
0
 def uniform_cost_search(self):
     graph = Graph()
     funcUtils = utils()
     funcUtils.read_file_first_space('Cidades_grafo.txt', graph)
     funcUtils.read_file_and_connect('Cidades_grafo.txt', graph)
     nodeStart = input("What is the source node?\n")
     nodeGoal = input("What is the goal node?\n")
     funcUtils.uniform_cost_search_util(graph,
                                        nodeStart.capitalize(),
                                        nodeGoal.capitalize(),
                                        verbose=True)
예제 #11
0
    def default_interior(self, fields):
        "Crear las lineas de producto en la venta"
        logger.info('default_retomar_calcular_papel_interior')
        pool = Pool()
        ut = utils()
        OrdenTrabajo = pool.get('sale_printery_budget.orden_trabajo')
        interior = OrdenTrabajo.search([('id', '=', self.elegir_interior.orden_trabajo.id)])[0]
        # Borrar producto temporal anterior
        ut.interior = interior
        ut.borrar_productos_temporales(interior.id_interior)

        # Copiar la orden de trabajo en modelo interior
        res = {
                'cantidad': interior.cantidad,
                'sale_id': interior.sale.id,
                'calle_horizontal': interior.calle_horizontal,
                'calle_vertical': interior.calle_vertical,
                'cantidad': interior.cantidad,
                'colores_frente': interior.colores_frente,
                'colores_dorso': interior.colores_dorso,
                'es_tapa': interior.es_tapa,
                'tipo_papel': interior.tipo_papel.id,
                'sin_pinza': interior.sin_pinza,
                'formato_pliego': interior.formato_pliego,
                'categoria': interior.categoria,
                'ancho': interior.ancho,
                'altura': interior.altura,
                'postura_papel': interior.postura_papel,
                'postura_trabajo': interior.postura_trabajo,
                #'maquina': interior.maquina.id,
                'tinta_superficie_cubierta': interior.tinta_superficie_cubierta,
                'tinta': interior.tinta.id,
                'solapa': interior.solapa,
                'lomo': interior.lomo,
                'gramaje': interior.gramaje,
                'id_wizard_start': interior.id_interior,
                'velocidad_maquina': interior.velocidad_maquina,
                'plancha_adicional': 0,
                'cantidad_paginas': interior.cantidad_paginas,
            }

        if hasattr(interior, 'doblado') != False and interior.doblado is not None:
            res['doblado'] = interior.doblado.id

        if hasattr(interior, 'encuadernado') != False and interior.encuadernado is not None:
            res['encuadernado'] = interior.encuadernado.id
            res['cantidad_broches'] = interior.cantidad_broches

        if hasattr(interior, 'laminado') != False and interior.laminado is not None:
            res['laminado'] = interior.laminado.id
            res['laminado_orientacion'] = interior.laminado_orientacion

        return res
예제 #12
0
    def __init__(self, args, sess):
        self.sess = sess
        if args.train:
            self.mode = 'all'
        elif args.pretrain:
            self.mode = 'pretrain_generator'
        else:
            self.mode = 'test'

        #model config
        self.rec_base = 0.0
        self.rec_weight = 0.5

        self.discriminator_iterations = 3
        self.reconstructor_iterations = 3
        self.pretrain_discriminator_steps = 501
        self.coverage_weight = 0.1
        self.lmbda = 10
        self.source_sequence_length = args.source_length
        self.code_sequence_length = args.code_length
        self.batch_size = args.batch_size
        self.num_steps = args.num_steps
        self.load_model = args.load
        self.saving_step = args.saving_step
        self.result_path = args.test_output
        self.input_path = args.test_input

        #trivial things
        self.generator_lstm_length = [
            self.source_sequence_length + 1 for _ in range(self.batch_size)
        ]
        self.code_lstm_length = [
            self.code_sequence_length + 1 for _ in range(self.batch_size)
        ]
        self.utils = utils(args)

        #the model of generator, reconstructor, discriminator will be save in seperately directory
        self.model_dir = args.model_dir
        """
        if not os.path.exists(os.path.join(self.model_dir,'code')):
            os.makedirs(os.path.join(self.model_dir,'code'))
        if self.mode == 'all':
            subprocess.call('cp ./*.py '+ os.path.join(self.model_dir,'code'), shell=True)
        """
        self.vocab_size = self.utils.vocab_size
        self.word_embedding_dim = 300
        self.BOS = 1
        self.EOS = 0

        self.build_model()
        self.tensorflow_init()
예제 #13
0
파일: db_api.py 프로젝트: wbowen1993/DeDOS
    def __init__(self):
        self.utils = utils()
        self.config = self.utils.load_config()

        self.json_f = self.config['json']
        fp = open(self.json_f, 'r')
        self.json = json.load(fp)
        fp.close()

        self.db = MySQLDatabase(self.json['db_name'],
                                host = self.json['db_ip'],
                                port = self.json['db_port'],
                                user = self.json['db_user'],
                                passwd = self.json['db_pwd'])
예제 #14
0
    def __init__(self):
        self.utils = utils()
        self.config = self.utils.load_config()

        self.json_f = self.config['json']

        fp = open(self.json_f, 'r')
        self.json = json.load(fp)
        fp.close()

        #generate schema
        self.schema = self.gen_sql_schema()

        #inject schema (create/drop DB if needed)
        self.inject_schema()
예제 #15
0
    def get_context_data(self, **kwargs):
        helper = utils()
        kwargs = super(Demographic, self).get_context_data(**kwargs)
        appointment_id = self.request.GET['appointment_id']
        patient_id = self.request.GET['patient_id']
        patient_detail = helper.get_patient_id(patient_id)

        # get the recent body info
        boiler_plate_body = PatientBodyDbUtils.get_recent_body_info(patient_id)

        boiler_plate_important = helper.get_init_dict(patient_detail)
        # give the patient a boilerplate
        form = DemographicForm(initial=helper.merge(boiler_plate_body, boiler_plate_important))
        kwargs['form'] = form
        kwargs['appointment_id'] = appointment_id
        kwargs['patient_id'] = patient_id

        return kwargs
예제 #16
0
    def get_context_data(self, **kwargs):
        helper = utils()
        kwargs = super(AddAppointmentStatus, self).get_context_data(**kwargs)
        my_request_get = self.request.GET

        # construct the params for post
        res = {'doctor': DOCTOR_ID,
               'duration': my_request_get['duration'],
               'exam_room': my_request_get['exam_room'],
               'office': OFFICE_ID,
               'patient': my_request_get['patient_id'],
               'scheduled_time': my_request_get['scheduled_time']}
        try:
            helper.post_appointment(res)
            messages.success(self.request, "You have added the appointment successfully!")
        except Exception:
            messages.error(self.request, "add failure!")
        kwargs["patient_id"] = my_request_get['patient_id']
        return kwargs
예제 #17
0
def ToDoList(request):
    """
    to-do list app
    """

    helper = utils()

    if request.method == 'POST':
        form = ListForm(request.POST or None)

        if form.is_valid():
            form.save()
            all_items = List.objects.all
            messages.success(request, "new item has been added successfully!!!")
            return render(request, "to_do_list.html", {'all_items': all_items})

    else:
        all_items = List.objects.all

        return render(request, "to_do_list.html", {'all_items': all_items})
예제 #18
0
    def get_context_data(self, **kwargs):
        kwargs = super(DoctorWelcome, self).get_context_data(**kwargs)
        helper = utils()

        # get doctor info
        doctor = helper.get_doctor(DOCTOR_ID)
        # get all today's appointments for the doctor
        appointments_iterator = helper.get_all_appointments(doctor_id=DOCTOR_ID)
        # iterate
        result = helper.get_appointments_render(appointments_iterator)

        # doctor first name and last name for the welcome
        kwargs['first_name'] = doctor['first_name']
        kwargs['last_name'] = doctor['last_name']
        kwargs['appointments'] = result
        kwargs["size"] = len(result)
        # get average waiting time for today
        kwargs['average_waiting_time'] = helper.get_average_waiting_time(result)

        return kwargs
예제 #19
0
    def save_apk_info_file(self, button):
        apk_path = utils().save_file()
        text = ''
        if apk_path is not '':
            f = open(apk_path, 'w')
            start_iter = self.main_info_textview.get_buffer().get_start_iter()
            end_iter = self.main_info_textview.get_buffer().get_end_iter()
            text = self.main_info_textview.get_buffer().get_text(
                start_iter, end_iter, True)

            start_iter = self.permission_textview.get_buffer().get_start_iter()
            end_iter = self.permission_textview.get_buffer().get_end_iter()
            text += self.permission_textview.get_buffer().get_text(
                start_iter, end_iter, True)

            start_iter = self.signature_textview.get_buffer().get_start_iter()
            end_iter = self.signature_textview.get_buffer().get_end_iter()
            text += self.signature_textview.get_buffer().get_text(
                start_iter, end_iter, True)

            f.write(text)
            f.close()
예제 #20
0
    def get_context_data(self, **kwargs):
        helper = utils()
        kwargs = super(UpdatePatientInfo, self).get_context_data(**kwargs)
        my_request_get = self.request.GET
        # get appointment id
        appointment_id = my_request_get["appointment_id"]

        # get current time
        current_time = helper.get_current_time()

        # update in the local db hange the status on the remote db
        db_sync(appointment_id, {"status": STATUS_ARRIVED, "arrive_time": current_time})
        helper.change_appointment_status(appointment_id, STATUS_ARRIVED)

        # update the demographic data
        patient_id = my_request_get["patient_id"]
        helper.update_patient_info(patient_id, helper.get_init_dict(my_request_get))

        # update the patient body information to the database
        PatientBodyDbUtils.add(helper.get_body_info_dict(my_request_get))

        messages.success(self.request, "You have checked in successfully! Please wait patiently :-)")
        return kwargs
예제 #21
0
    def default_interior(self, fields):
        "Crear las lineas de producto en la venta"
        logger.info('default_interior')
        ## Desde aca puedo crear las lineas de los productos.
        # Primero preguntar si cls.interior.producto_papel es distinto de None.
        # Si es asi, entonces cargo las lineas.
        t = Transaction()
        Sale = Pool().get('sale.sale')
        ut = utils()
        ut.interior = self.interior
        sale = Sale.search([('id', '=', t.context['active_id'])])[0]
        res = {
            'categoria': 'folleto',
            'calle_horizontal': Decimal('0.5'),
            'calle_vertical': Decimal('0.5'),
            'colores_frente': 0,
            'colores_dorso': 0,
            'plancha_adicional': 0,
            'cantidad_paginas': 4,
            'cantidad': sale.cantidad,
            'sale_id': sale.id,
        }

        if hasattr(self.interior, 'producto_papel') == False or self.interior.producto_papel is None:
            # Primera vez que se ejecuta la pantalla interior.
            try:
                ut.borrar_productos_temporales(self.interior.id_wizard_start)
            except:
                logger.info('Primera vez que se ejecuta la pantalla. No se pudo borrar productos temporales')

            return res

        lineas_venta = ut.creo_lineas_de_venta()
        ut.creo_orden_trabajo(sale, lineas_venta)
        ut.crear_otra_cantidad_base(sale)
        ut.borrar_productos_temporales(self.interior.id_wizard_start)
        return res
예제 #22
0
 def get_apk_path():
     path = utils().select_file()
     return path
예제 #23
0
파일: kNN.py 프로젝트: ckalyan/MLInAction
    def classify(self,dataSet,labels,inputVector):
        '''
        tile(input,A) repeats the input A times. We want the input to be replicated m times, but no replication along columns.
         So, tile args = (dataSet.numRows,1)
        '''
        diffMat = tile(inputVector, (dataSet.shape[0],1)) - dataSet
        #calculate Euclidean distance = sqrt((in.p1-data.p1)^2 +(in.p2-data.p2)^2+...)
        sqDiffMat = diffMat**2
        sqDistances = sqDiffMat.sum(axis=1)
        distances = sqDistances**0.5
        sortedDistIndices = distances.argsort()
        classCount={}
        #for each entry in the top k, find the label for that entry, and inc count of that label.
        for i in range(self.k):
            labelI = labels[sortedDistIndices[i]]
            classCount[labelI] = classCount.get(labelI,0) +1
        #find the most frequent label.
        sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1),reverse=True)
        return sortedClassCount[0][0]
    
if __name__=='__main__':
    kNNObject = kNN(4)
    #[group,labels] = kNNObject.createTestDataSet()
    utilityObject = utils()
    [group,labels] = utilityObject.file2Matrix('../datingTestSet.txt')
    classifiedLabel = kNNObject.classify(group,labels,[999,-222,0.1])
    print classifiedLabel
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(group[:,1],group[:,2])
    plt.show()
예제 #24
0
파일: arm.py 프로젝트: carlkeifer3/tbRigKit
        ikHandle = self.createIkHandle()[0]

        # Create and constrain arm ik handle
        cmds.pointConstraint(wristControl, ikHandle)
        cmds.poleVectorConstraint(poleVector, ikHandle)

        # Create null groups
        self.utils.createNullGroup(wristControl)
        self.utils.createNullGroup(poleVector)

        # Lock controller attributes
        self.utils.lockAttrs(wristControl, rotate=True, scale=True, visibility=True)
        self.utils.lockAttrs(poleVector, rotate=True, scale=True, visibility=True)

# Create an Arm Rig
myUtils = utils()
myIkArm = IKSkeleton()
myFkArm = FKSkeleton()
prefix = 'l_'
armBindJoints = ['%sshoulder_bind' % prefix, '%selbow_bind' % prefix, '%swrist_bind' % prefix]

# Create IK Armutils
myUtils.jointCheck(armBindJoints)
ikJoints = myUtils.createJoints(armBindJoints, myIkArm.prefix, myIkArm.suffix, myIkArm.radius)
myIkArm.createIkControls()

# Create Fk Arm
fkJoints = myUtils.createJoints(armBindJoints, myFkArm.prefix, myFkArm.suffix, myFkArm.radius)
myFkArm.createFkControls(fkJoints, armBindJoints)

# Position IK/FK Switcher
예제 #25
0
# app.py - a flask api using flask_restful
from flask import Flask, request, jsonify
from flask_cors import CORS

from utils import *

import json

import uclnlp_service_pb2_grpc as pb2_grpc
import uclnlp_service_pb2 as pb2

from config import config, rpc_endpoints

app = Flask(__name__)
CORS(
    app
)  # to enable CORS for the routes, unless from the front end response becomes Network Error


@app.route('/get_score', methods=['GET'])
def get_score():
    url = request.args.get('url')
    result = utils.get_stance_classify(url)
    return str(result)


proxy_port = 7005
utils = utils()

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=proxy_port)
import cv2
import numpy as np
import PIL.Image
import matplotlib.pyplot as plt
from utils import *
import time

# Set this variable to False if you want to view a background image
# and also set the path to your background image
# Background Image Source: https://pixabay.com/photos/monoliths-clouds-storm-ruins-sky-5793364/
BLUR = True
BG_PTH = "bg1.jpg"

utilsInst = utils()
utilsInst.init()

# Load the DeepLabv3 model to memory
utilsInst.load_model()

# Read the background image to memory
bg_image = cv2.imread(BG_PTH)
bg_image = cv2.cvtColor(bg_image, cv2.COLOR_BGR2RGB)

# Start a video cam session
video_session = cv2.VideoCapture(0)

# Define a blurring value kernel size for cv2's Gaussian Blur
blur_value = (51, 51)

# Define two axes for showing the mask and the true video in realtime
# And set the ticks to none for both the axes
예제 #27
0
def db_sync(appointment_id, params):
    helper = utils()
    dbutils.update(appointment_id, params)
    helper.change_appointment_status(appointment_id, params['status'])
예제 #28
0
 def get_context_data(self, **kwargs):
     helper = utils()
     kwargs = super(NewAppointmentForm, self).get_context_data(**kwargs)
     patient_id = self.request.GET['patient_id']
     kwargs["patient_id"] = patient_id
     return kwargs