def __init__(self,
domains: List[Domain],
greet_on_first_turn: bool = False):
Service.__init__(self, domain="")
self.domains = domains
self.current_domain = None
self.greet_on_first_turn = greet_on_first_turn
def __init__(self,
domain="",
camera_id: int = 0,
openface_port: int = 6004,
delay: int = 2,
identifier=None):
"""
Args:
camera_id: index of the camera you want to use (if you only have one camera: 0)
"""
Service.__init__(self, domain="", identifier=identifier)
self.camera_id = camera_id
self.openface_port = openface_port
self.openface_running = False
self.threshold = delay # provide number of seconds as parameter, one second = 15 frames
ctx = Context.instance()
self.openface_endpoint = ctx.socket(zmq.PAIR)
self.openface_endpoint.bind(f"tcp://127.0.0.1:{self.openface_port}")
startExtraction = f"{os.path.join(get_root_dir(), 'tools/OpenFace/build/bin/FaceLandmarkVidZMQ')} -device {self.camera_id} -port 6004" # todo config open face port
self.p_openface = subprocess.Popen(
startExtraction.split(), stdout=subprocess.PIPE) # start OpenFace
self.extracting = False
self.extractor_thread = None
def __init__(self):
Service.__init__(self)
self.speech_in_dir = os.path.dirname(os.path.abspath(__file__)) + '/'
self.trained_model_path = os.path.join(
'resources', 'models',
'backchannel') + '/pytorch_acoustic_backchanneller.pt'
self.load_model()
def __init__(self,
domain: Union[str, Domain] = "",
conversation_log_dir: str = None,
enable_plotting: bool = False,
threshold: int = 8000,
voice_privacy: bool = False,
identifier: str = None) -> None:
"""
A service that can record a microphone upon a key pressing event
and publish the result as an array. The end of the utterance is
detected automatically, also the voice can be masked to alleviate
privacy issues.
Args:
domain (Domain): I don't know why this is here. Service needs it, but it means nothing in this context.
conversation_log_dir (string): If this parameter is given, log files of the conversation will be created in this directory
enable_plotting (boolean): If this is set to True, the recorder is no longer real time able and thus the recordings don't work properly. This is just to be used to tune the threshold for the end of utterance detection, not during deployment.
threshold (int): The threshold below which the assumption of the end of utterance detection is silence
voice_privacy (boolean): Whether or not to enable the masking of the users voice
identifier (string): I don't know why this is here. Service needs it.
"""
Service.__init__(self, domain=domain, identifier=identifier)
self.conversation_log_dir = conversation_log_dir
self.recording_indicator = False
self.audio_interface = pyaudio.PyAudio()
self.push_to_talk_listener = keyboard.Listener(
on_press=self.start_recording)
self.threshold = threshold
self.enable_plotting = enable_plotting
self.voice_privacy = voice_privacy
def __init__(self,
domain: Domain = "",
identifier=None,
conversation_log_dir: str = None,
use_cuda=False):
"""
Transforms spoken input from the user to text for further processing.
Args:
domain (Domain): Needed for Service, but has no meaning here
identifier (string): Needed for Service
conversation_log_dir (string): If this is provided, logfiles will be placed by this Service into the specified directory.
use_cuda (boolean): Whether or not to run the computations on a GPU
"""
Service.__init__(self, domain=domain, identifier=identifier)
self.conversation_log_dir = conversation_log_dir
# load model
model_dir = os.path.join(get_root_dir(), "resources", "models",
"speech", "multi_en_20190916")
self.model, conf = load_trained_model(
os.path.join(model_dir, "model.bin"))
self.vocab = conf.char_list
# setup beam search
self.bs = BeamSearch(scorers=self.model.scorers(),
weights={
"decoder": 1.0,
"ctc": 0.0
},
sos=self.model.sos,
eos=self.model.eos,
beam_size=4,
vocab_size=len(self.vocab),
pre_beam_score_key="decoder")
self.bs.__class__ = BatchBeamSearch
# choose hardware to run on
if use_cuda:
self.device = "cuda"
else:
self.device = "cpu"
self.model.to(self.device)
self.bs.to(self.device)
# change from training mode to eval mode
self.model.eval()
self.bs.eval()
# scale and offset for feature normalization
# follows https://github.com/kaldi-asr/kaldi/blob/33255ed224500f55c8387f1e4fa40e08b73ff48a/src/transform/cmvn.cc#L92-L111
norm = torch.load(os.path.join(model_dir, "cmvn.bin"))
count = norm[0][-1]
mean = norm[0][:-1] / count
var = (norm[1][:-1] / count) - mean * mean
self.scale = 1.0 / torch.sqrt(var)
self.offset = -(mean * self.scale)
def __init__(self, domain: Domain = ""):
"""
Given a sound, this service extracts features and passes them on to the decoder for ASR
Args:
domain (Domain): Needed for Service, no meaning here
"""
Service.__init__(self, domain=domain)
def change_ip(password):
logger = logging.getLogger('change_ip')
try:
logger.debug(f"wait {Service.wait_new_ip} seconds for new ip")
time.sleep(Service.wait_new_ip)
Service.renew_connection(password)
logger.debug("get new ip")
except Exception as exp:
raise exp
def post(self):
# curl -d name="Conjured Mana Cake" -d sell_in=3 -d quality=6
# http://127.0.0.1:5000/items -X POST
args = self.parseRequest()
# 201 response: request has succeeded and
# a new resource has been created as a result.
Service.postItem(args)
return '', 201
def __init__(self):
""" Emotion recognition module.
On initialization all necessary models are loaded.
"""
Service.__init__(self)
self.emotion_dir = os.path.dirname(os.path.abspath(__file__))
self.model_path = os.path.abspath(
os.path.join(
self.emotion_dir, "..", "..", "resources", "models", "emotion"
)
)
def load_args(emo_representation):
arg_dict = pickle.load(
open(os.path.join(
self.model_path, f'{emo_representation}_args.pkl'),
'rb')
)
return arg_dict
def load_model(emo_representation, arg_dict):
ARGS = arg_dict['args']
model = cnn(
kernel_size=(ARGS.height, arg_dict['D_in']),
D_out=arg_dict['D_out'],
args=ARGS
)
model.load_state_dict(
torch.load(
os.path.join(self.model_path,
f'{emo_representation}_model_params.pt'),
map_location=torch.device('cpu')
)
)
model.eval()
return model
self.emo_representations = ['category', 'arousal', 'valence']
self.models = {}
self.args = {}
for emo_representation in self.emo_representations:
self.args[emo_representation] = load_args(emo_representation)
self.models[emo_representation] = load_model(
emo_representation,
self.args[emo_representation]
)
self.arousal_mapping = {0: 'low', 1: 'medium', 2: 'high'}
self.valence_mapping = {0: 'negative', 1: 'neutral', 2: 'positive'}
self.category_mapping = {
0: EmotionType.Angry,
1: EmotionType.Happy,
2: EmotionType.Neutral,
3: EmotionType.Sad
}
def __init__(self,
domain: JSONLookupDomain = None,
logger: DiasysLogger = None,
random: bool = True,
static_emotion: EmotionType = EmotionType.Neutral,
static_engagement: EngagementType = EngagementType.High):
Service.__init__(self, domain=domain)
self.domain = domain
self.logger = logger
self.random = random
self.engagement = static_engagement
self.emotion = static_emotion
def httpOpen(self, filename, mode):
self.manager.log.debug('httpOpen: ' + filename + ' ' + hex(mode))
if not filename:
self.manager.log.error('DLNA:HTTPOPEN:filename is None')
return None
if mode is not UpnpOpenFileMode.UPNP_READ:
self.manager.log.error(
'DLNA:HTTPOPEN:mode is not UpnpOpenFileMode.upnp_read')
return None
# We need to remove the web handle part of the filename. So for example the
# filename that was passed in could be '/web/cds.xml'. We need to make that
# be just 'cds.xml'. If the file that was requested is '/web/movies/awesome.mp4'
# this should be made into 'movies/awesome.mp4'.
filename = filename.lstrip(self.manager.webRoot)
_file = None
if filename == CDSService.CDS_LOCATION:
_file = Service.getFileMemory(
self.manager.webRoot + CDSService.CDS_LOCATION,
CDSService.CDS_DESCRIPTION)
elif filename == CMSService.CMS_LOCATION:
_file = Service.getFileMemory(
self.manager.webRoot + CMSService.CMS_LOCATION,
CMSService.CMS_DESCRIPTION)
elif filename == MSRService.MSR_LOCATION:
_file = Service.getFileMemory(
self.manager.webRoot + MSRService.MSR_LOCATION,
MSRService.MSR_DESCRIPTION)
else:
upnpId = int(filename[filename.rfind('/') + 1:filename.rfind('.')])
serverManager = OneServerManager()
entry = serverManager.rootEntry.getChild(upnpId)
if entry == None:
self.manager.log.error('DLNA:HTTPOPEN:Entry is None')
return None
if entry.fullPath == None:
self.manager.log.error('DLNA:HTTPOPEN:Entry.fullPath is None')
return None
fh = entry.generateFileHandle()
_file = WebFile(entry.fullPath, 0, fh, entry)
# Find a GUID for a handle and add it to the map.
handle = uuid.uuid4().int >> 64
DLNAService.fileHandles[handle] = _file
return handle
def __init__(self,
domain: JSONLookupDomain = None,
logger: DiasysLogger = DiasysLogger()):
"""
Initializes the policy
Arguments:
domain (JSONLookupDomain): the domain that the affective policy should operate in
"""
self.first_turn = True
Service.__init__(self, domain=domain)
self.logger = logger
def __init__(self, domain: Domain, sub_topic_domains={}, template_file: str = None,
logger: DiasysLogger = DiasysLogger(), template_file_german: str = None,
emotions: List[str] = [], debug_logger = None):
"""Constructor mainly extracts methods and rules from the template file"""
Service.__init__(self, domain=domain, sub_topic_domains=sub_topic_domains, debug_logger=debug_logger)
self.domain = domain
self.template_filename = template_file
self.templates = {}
self.logger = logger
self.emotions = emotions
self._initialise_templates()
def __init__(self, domain: Domain = ""):
Service.__init__(self, domain=domain)
self.module_dir = os.path.dirname(os.path.abspath(__file__))
# # CLAHE (Contrast Limited Adaptive Histogram Equalization)
self.CLAHE = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
# for detecting faces (returns coordinates of rectangle(s) of face area(s))
self.DETECTOR = dlib.get_frontal_face_detector()
# facial landmark predictor
predictor_file = os.path.abspath(
os.path.join(self.module_dir, '..', '..', '..', 'resources',
'models', 'video',
'shape_predictor_68_face_landmarks.dat'))
self.PREDICTOR = dlib.shape_predictor(predictor_file)
def __init__(self,
domain: Domain = "",
conversation_log_dir: str = None,
identifier: str = None):
"""
Service that plays the system utterance as sound
Args:
domain (Domain): Needed for Service, but has no meaning here
conversation_log_dir (string): If this is provided it will create log files in the specified directory.
identifier (string): Needed for Service.
"""
Service.__init__(self, domain=domain, identifier=identifier)
self.conversation_log_dir = conversation_log_dir
self.interaction_count = 0
def httpOpen(self, filename, mode):
self.manager.log.debug('httpOpen: ' + filename + ' ' + hex(mode))
if not filename:
self.manager.log.error('DLNA:HTTPOPEN:filename is None')
return None
if mode is not UpnpOpenFileMode.UPNP_READ:
self.manager.log.error('DLNA:HTTPOPEN:mode is not UpnpOpenFileMode.upnp_read')
return None
# We need to remove the web handle part of the filename. So for example the
# filename that was passed in could be '/web/cds.xml'. We need to make that
# be just 'cds.xml'. If the file that was requested is '/web/movies/awesome.mp4'
# this should be made into 'movies/awesome.mp4'.
filename = filename.lstrip(self.manager.webRoot)
_file = None
if filename == CDSService.CDS_LOCATION:
_file = Service.getFileMemory(self.manager.webRoot + CDSService.CDS_LOCATION,
CDSService.CDS_DESCRIPTION)
elif filename == CMSService.CMS_LOCATION:
_file = Service.getFileMemory(self.manager.webRoot + CMSService.CMS_LOCATION,
CMSService.CMS_DESCRIPTION)
elif filename == MSRService.MSR_LOCATION:
_file = Service.getFileMemory(self.manager.webRoot + MSRService.MSR_LOCATION,
MSRService.MSR_DESCRIPTION)
else:
upnpId = int( filename[filename.rfind('/') + 1:filename.rfind('.')])
serverManager = OneServerManager()
entry = serverManager.rootEntry.getChild(upnpId)
if entry == None:
self.manager.log.error('DLNA:HTTPOPEN:Entry is None')
return None
if entry.fullPath == None:
self.manager.log.error('DLNA:HTTPOPEN:Entry.fullPath is None')
return None
fh = entry.generateFileHandle()
_file = WebFile(entry.fullPath, 0, fh, entry)
# Find a GUID for a handle and add it to the map.
handle = uuid.uuid4().int >> 64
DLNAService.fileHandles[handle] = _file
return handle
def __init__(self, domain=None, camera_id: int = 0, capture_interval: int = 10e5, identifier: str = None):
"""
Args:
camera_id (int): device id (if only 1 camera device is connected, id is 0, if two are connected choose between 0 and 1, ...)
capture_interval (int): try to capture a frame every x microseconds - is a lower bound, no hard time guarantees (e.g. 5e5 -> every >= 0.5 seconds)
"""
Service.__init__(self, domain, identifier=identifier)
self.cap = cv2.VideoCapture(camera_id) # get handle to camera device
if not self.cap.isOpened():
self.cap.open() # open
self.terminating = Event()
self.terminating.clear()
self.capture_thread = Thread(target=self.capture) # create thread object for capturing
self.capture_interval = capture_interval
def add_numbers():
a = request.args.get('a', 0, type=str)
summarizer = Summarizer()
# a = u"http://www.asriran.com/fa/news/332468/%D9%BE%DB%8C%D8%A7%D9%85-%D8%B3%DB%8C%D8%AF-%D9%85%D8%AD%D9%85%D8%AF-%D8%AE%D8%A7%D8%AA%D9%85%DB%8C-%D8%A8%D9%87-%DA%A9%D9%86%DA%AF%D8%B1%D9%87-%D9%8A%DA%A9-%D8%AD%D8%B2%D8%A8"
page = Fetch(a)
if page.service == 'iransamane':
service = IranSamane(page.page)
elif page.service == 'news-studio':
service = NewsStudio(page.page)
else:
service = Service(page.page)
print "fetching content"
content = service.fetch_content()
# print content
print "end fetching"
summarized = summarizer.summarize(content)
print "end summarize"
res = {
'summarized': summarized,
'title': service.fetch_title(),
'tags': service.fetch_tags(),
'image': service.fetch_image(),
}
# For log
log = (datetime.datetime.now(), res['title'], content, pickle.dumps(summarized))
query_db('INSERT INTO log (submitted_time, title, source, summarized_text) VALUES (?,?,?,?)', log)
#
return jsonify(result=res)
def admin_media(request):
""" Middleware for Jinja template
Args:
request (Django request)
Returns:
DICT: Variable for jinja template
"""
try:
cluster = Cluster.objects.get()
node = cluster.get_current_node()
assert node
node_name = node.name
except (ObjectDoesNotExist, AssertionError):
node_name = ""
menu = (System().menu, Service().menu, Authentication().menu,
Portal().menu, Darwin().menu, Apps().menu, Workflows().menu)
results = {
'MENUS': menu,
'VERSION': settings.VERSION,
'CURRENT_NODE': node_name,
'DEV_MODE': settings.DEV_MODE,
'TITLE': get_hostname(),
'COLLAPSE': request.session.get('collapse')
}
return results
def __init__(self, domain: JSONLookupDomain, logger: DiasysLogger = DiasysLogger(),
max_turns: int = 25):
"""
Initializes the policy
Arguments:
domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain
"""
self.first_turn = True
Service.__init__(self, domain=domain)
self.current_suggestions = [] # list of current suggestions
self.s_index = 0 # the index in current suggestions for the current system reccomendation
self.domain_key = domain.get_primary_key()
self.logger = logger
self.max_turns = max_turns
def process_services(self, services_json):
services = []
for service in services_json.get("services", []):
auth = service.get("auth")
auth_service = None
if auth:
auth_service = self.get_auth_service(services_json, auth)
services.append(Service(service, auth=auth_service))
return services
def __init__(self, domain: LookupDomain, \
logger: DiasysLogger = DiasysLogger(), device: str = 'cpu'):
"""Creates neural networks for semantic parsing and other required utils
Args:
domain: the QA domain
logger: the logger
device: PyTorch device name
"""
Service.__init__(self, domain=domain, debug_logger=logger)
self.device = torch.device(device)
self.nn_relation = self._load_relation_model()
self.nn_entity = self._load_entity_model()
self.nn_direction = self._load_direction_model()
self.tags = self._load_tag_set()
self.max_seq_len = 40
self.embedding_creator = BertEmbedding(max_seq_length=self.max_seq_len)
def __init__(self, domain: JSONLookupDomain, logger: DiasysLogger = DiasysLogger(),
language: Language = None):
"""
Loads
- domain key
- informable slots
- requestable slots
- domain-independent regular expressions
- domain-specific regualer espressions
It sets the previous system act to None
Args:
domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain
"""
Service.__init__(self, domain=domain)
self.logger = logger
self.language = language if language else Language.ENGLISH
# Getting domain information
self.domain_name = domain.get_domain_name()
self.domain_key = domain.get_primary_key()
# Getting lists of informable and requestable slots
self.USER_INFORMABLE = domain.get_informable_slots()
self.USER_REQUESTABLE = domain.get_requestable_slots()
# Getting the relative path where regexes are stored
self.base_folder = os.path.join(get_root_dir(), 'resources', 'nlu_regexes')
# Setting previous system act to None to signal the first turn
# self.prev_sys_act = None
self.sys_act_info = {
'last_act': None, 'lastInformedPrimKeyVal': None, 'lastRequestSlot': None}
self.language = Language.ENGLISH
self._initialize()
def __init__(self,
domain: Domain,
template_file: str = None,
sub_topic_domains: Dict[str, str] = {},
logger: DiasysLogger = DiasysLogger(),
template_file_german: str = None,
language: Language = None):
"""Constructor mainly extracts methods and rules from the template file"""
Service.__init__(self,
domain=domain,
sub_topic_domains=sub_topic_domains)
self.language = language if language else Language.ENGLISH
self.template_english = template_file
# TODO: at some point if we expand languages, maybe make kwargs? --LV
self.template_german = template_file_german
self.domain = domain
self.template_filename = None
self.templates = None
self.logger = logger
self.language = Language.ENGLISH
self._initialise_language(self.language)
def delete(self):
args = self.parseRequest()
Service.deleteItem(args)
return '', 204
def get(self, quality):
return Service.get_item_by_quality(quality)
def __init__(self, config=None):
Service.__init__(self, config)
self._url = config["url"]
self._headers = config["headers"]
self._current_article = 0
def get(self):
return Service.updateQuality(tienda)
def __init__(self, domain: LookupDomain, logger: DiasysLogger = DiasysLogger()):
# only call super class' constructor
Service.__init__(self, domain=domain, debug_logger=logger)
def test_init(aff_nlg, domain): aff_nlg.__init__(domain) Service.__init__(aff_nlg, domain='superhero') assert aff_nlg.domain == 'superhero'
def __init__(self, config, service_resolver):
Service.__init__(self, config=config, service_resolver=service_resolver)
def get(self, itemName):
return Service.getItem(itemName), 200
