def optionalFileTypes(self, list_from_query): mime_types = [] for element in list_from_query: ext = re.search(r"\.([A-Za-z0-9-_]+)$", element[0]) if not ext: continue ext = ext.group(0) mime = types_map.get(ext) if mime: mime_types.append(types_map.get(ext).split("/")[0]) x = () for y in Counter(mime_types).most_common(3): x += y x = [str(y) for y in x] return ','.join(x)
def fileTypes(self, filelist): mime_types = [] for path_str in filelist: ext = re.search(r"\.([A-Za-z0-9-_]+)$", path_str) if not ext: continue ext = ext.group(0) mime = types_map.get(ext) if mime: mime_types.append(types_map.get(ext).split("/")[0]) x = () for y in Counter(mime_types).most_common(3): x += y x = [str(y) for y in x] return ','.join(x)
def is_image(filename: str, /) -> bool: """Returns ``True`` if the filename refers to an image. :param filename: String representing a path to a file. :return: ``True`` if the `filename` is a path to an image file, otherwise ``False``. """ return types_map.get(path.splitext(filename)[-1], '').startswith('image/')
def _get_name_and_mime(self, doc, frmt, thumbnail, page_num ): ext = "." + frmt mimetype = types_map.get(ext, 'application/' + frmt) if frmt in ('png', 'jpg'): suffix = '_small.%s' % frmt if thumbnail else '.%s' % frmt name = "%s_%s%s" % (doc.id,page_num, suffix) else : name = get_readable_name(doc) + ext return name, mimetype
def get(self, request): # Reboot server if request == 'reboot': # Set the mime type mime = types_map.get(self.REBOOT_TYPE) # Save the given time time = self.get_int_query(*self.TIME) # Load images for the next step result = self._exp.add_step(time) # Get a tile else: # Set the mime type mime = types_map.get(self.IMAGE_TYPE) # Give the requested tile result = self.parse_tile() # Set mime type self.set_header("Content-Type", mime) # Write result self.write(result)
def upload_file(self, filename, content): _, ext = splitext(filename) content_type = types_map.get(ext) r = post('%s%s' % (self.FILES_URL, filename), **self._request_kwargs(content_type=content_type, payload=content)) result = loads(r.text) if 'error' in result: raise ParseSyncException('Error trying to upload file to Parse.com: %s (%i)' % (result['error'], result['code'])) return result
def do_GET(self): fname, ext = os.path.splitext(self.path) context = zmq.Context() socket = context.socket(zmq.PAIR) socket.bind("tcp://*:5556") socket.send(self.path.strip('/')) file = socket.recv_pyobj() socket.close() self.send_response(file["status"]) self.send_header('Content-type', types_map.get(ext, "application/octet-stream")) self.end_headers() self.wfile.write(file["content"])
def handle_static(self, filepath): """ Serves a path in the `./bfly/static` directory Arguments ---------- path: str the actual path to a file on the server """ extension = os.path.splitext(filepath)[1] # Get the mimetype from the requested extension mime_type = types_map.get(extension, self._basic_mime) self.set_header("Content-Type", mime_type) data = resource_string(self._root, filepath) self.write(data)
def handle(self, filepath): """ Serves a path in the `./bfly/static` directory Arguments ---------- path: str the actual path to a file on the server """ extension = os.path.splitext(filepath)[1] # Get the mimetype from the requested extension mime_type = types_map.get(extension, self._basic_mime) self.set_header("Content-Type", mime_type) data = resource_string(self._root, filepath) self.write(data)
def upload_list(self, local_list): """ upload list of files """ for local_name in local_list: k = self.bucket.get_key(local_name) if not k: k = self.bucket.new_key(local_name) local_file_path = os.path.join(self.dir, local_name) if os.path.isfile(local_file_path): lf = open(local_file_path, "r") (base_name, ext) = os.path.splitext(local_file_path) local_hash_tuple = k.compute_md5(lf) k.set_contents_from_file(lf, md5=local_hash_tuple) k.set_metadata("Content-Type", types_map.get(ext, "application/octet-stream")) k.set_metadata("md5-hex", local_hash_tuple[0]) k.set_acl("public-read") lf.close()
def mime_type(self): """ Gets the mime type for the file_type The mime type is from :data:`INPUT.IMAGE` \ if :meth:`is_data`, or :data:`INPUT.INFO` \ otherwise. Returns -------- str The mime type from ``mimetypes.types_map`` """ info_type = self.INPUT.INFO.FORMAT.VALUE image_type = self.INPUT.IMAGE.FORMAT.VALUE # Use image type for data and info type for info file_type = image_type if self.is_data else info_type # Get the right mime type or use default for this class _basic_mime = self._basic_mime.format(file_type) return types_map.get('.' + file_type, _basic_mime)
def doFlatfile(self, req, name): ''' return flat file BEWARE: assumes that the file won't change for a week ''' try: kind = name.rsplit('.', 1)[1].lower() mime = (kind == 'ico') and 'image/x-icon' or types_map.get('.'+kind) \ or 'text/plain' # don't know why '.ico' is missing from types-map... data = open(name, 'rb').read() req.request.setHeader('content-type', mime) # prevent browser from asking for image every page request # assumes won't change for a week! req.request.setHeader('expires', httpDate(time.time()+(3600*24*7))) return data except: req.request.setResponseCode(404, "file not found") # we generally don't want a fancy rendered error page here return "file not found"
def doFlatfile(self, req, name): ''' return flat file BEWARE: assumes that the file won't change for a week ''' # print ("flat file name >>>>>:", name) try: kind = name.rsplit('.', 1)[1].lower() mime = (kind == 'ico') and 'image/x-icon' or types_map.get('.'+kind) \ or 'text/plain' # don't know why '.ico' is missing from types-map... data = open(name, 'rb').read() req.request.setHeader('content-type', mime) # prevent browser from asking for image every page request # assumes won't change for a week! req.request.setHeader('expires', httpDate(time.time() + (3600 * 24 * 7))) return data except: raise req.request.setResponseCode(404, b"file not found") # we generally don't want a fancy rendered error page here return "file not found"
def choose_content_type(self, extension): return (types_map.get(extension, None) or types_map.get(extension.lower(), None) or "text/plain")
def get_mime(self, extname): return MIME_TYPE.get(extname, "binary")
def define_mimetype(self): filename = self.environ["PATH_INFO"] self.headers["Content-type"] = MIMETYPES.get(path.splitext(filename)[1], "unknown") if self.headers["Content-type"] == "unknown": del self.headers["Content-type"]
def set_content_type(self, path, request): ext = get_extension(path).lower() request.response['Content-Type'] = types_map.get( "." + ext, 'application/octet-stream')
def encode_directory(directory): u''' Преобразование содержимого папки и её структуры в вид, пригодный для присоединения к СМЭВ-сообщению согласно МР 2.4.4-2.5.6. Результатом выполнения будет кортеж с уникальным GUID кодом (поле заголовка RequestCode) и закодированный в base64 ZIP-архив с манифестом, файлами директории и соответствующими файлами подписей. ZIP-архив формируется в памяти. :param unicode directory: Путь к папке, содержимое которой необходимо прикрепить. :return: GUID и закодированный в base64 ZIP-архив. :rtype: (unicode, unicode) ''' # Генерируем код запроса request_code = str(uuid.uuid4()) i = 1 in_memory_file = StringIO() zip_arc = ZipFile(in_memory_file, 'w') applied_documents_node = make_node('AppliedDocuments') for (path, subdirs, files) in os.walk(directory): for fn in files: path_to_file = os.path.join(path, fn).replace('\\', '/').replace('\\\\', '/') relative_path = path_to_file[len(directory):].lstrip('/') dgst = get_file_digest(path_to_file) dot_pos = fn.find('.') applied_documents = [ { 'URL': relative_path, 'Name': fn, 'DigestValue': dgst, # Пытаемся определить MIME-тип файла, но если нет - бинарный файл. 'Type': mime_types_map.get(fn[dot_pos:], 'application/octet-stream'), # TODO: выяснить правила генерации кода документа 'CodeDocument': u'0000', 'Number': i, }, # Файл с подписью по PKCS/7 { 'URL': u'%s%s' % (relative_path, '.sig'), 'Name': u'%s.sig' % fn, 'DigestValue': get_text_digest(dgst), 'Type': 'application/x-pkcs7-signature', 'CodeDocument': u'0000', 'Number': i + 1, } ] i += 2 for doc in applied_documents: app_doc_node = make_node('AppliedDocument') dict_to_xmldoc(app_doc_node, doc) applied_documents_node.append(app_doc_node) # Добавляем в ZIP-архив файл и его подпись zip_arc.write(path_to_file, arcname=relative_path) zip_arc.writestr('%s.sig' % relative_path, dgst) # Добавляем в ZIP-архив манифест и его подпись manifest_str = etree.tostring(applied_documents_node, pretty_print=True) zip_arc.writestr('req_%s.xml' % request_code, manifest_str.encode('utf-8')) zip_arc.writestr('req_%s.sig' % request_code, get_text_digest(manifest_str)) zip_arc.close() in_memory_file.seek(0) # Преобразуем ZIP-архив в base64 encoded = base64.b64encode(in_memory_file.read()) in_memory_file.close() return request_code, encoded
def encode_directory(directory): u''' Преобразование содержимого папки и её структуры в вид, пригодный для присоединения к СМЭВ-сообщению согласно МР 2.4.4-2.5.6. Результатом выполнения будет кортеж с уникальным GUID кодом (поле заголовка RequestCode) и закодированный в base64 ZIP-архив с манифестом, файлами директории и соответствующими файлами подписей. ZIP-архив формируется в памяти. :param unicode directory: Путь к папке, содержимое которой необходимо прикрепить. :return: GUID и закодированный в base64 ZIP-архив. :rtype: (unicode, unicode) ''' # Генерируем код запроса request_code = str(uuid.uuid4()) i = 1 in_memory_file = StringIO() zip_arc = ZipFile(in_memory_file, 'w') applied_documents_node = make_node('AppliedDocuments') for (path, subdirs, files) in os.walk(directory): for fn in files: path_to_file = os.path.join(path, fn).replace('\\', '/').replace('\\\\', '/') relative_path = path_to_file[len(directory):].lstrip('/') dgst = get_file_digest(path_to_file) dot_pos = fn.find('.') applied_documents = [ { 'URL': relative_path, 'Name': fn, 'DigestValue': dgst, # Пытаемся определить MIME-тип файла, но если нет - бинарный файл. 'Type': mime_types_map.get(fn[dot_pos:], 'application/octet-stream'), # TODO: выяснить правила генерации кода документа 'CodeDocument': u'0000', 'Number': i, }, # Файл с подписью по PKCS/7 { 'URL': u'%s%s' % (relative_path, '.sig'), 'Name': u'%s.sig' % fn, 'DigestValue': get_text_digest(dgst), 'Type': 'application/x-pkcs7-signature', 'CodeDocument': u'0000', 'Number': i + 1, }] i += 2 for doc in applied_documents: app_doc_node = make_node('AppliedDocument') dict_to_xmldoc(app_doc_node, doc) applied_documents_node.append(app_doc_node) # Добавляем в ZIP-архив файл и его подпись zip_arc.write(path_to_file, arcname=relative_path) zip_arc.writestr('%s.sig' % relative_path, dgst) # Добавляем в ZIP-архив манифест и его подпись manifest_str = etree.tostring(applied_documents_node, pretty_print=True) zip_arc.writestr('req_%s.xml' % request_code, manifest_str.encode('utf-8')) zip_arc.writestr('req_%s.sig' % request_code, get_text_digest(manifest_str)) zip_arc.close() in_memory_file.seek(0) # Преобразуем ZIP-архив в base64 encoded = base64.b64encode(in_memory_file.read()) in_memory_file.close() return request_code, encoded
def parse_problem( self, domain_filename: str, problem_filename: typing.Optional[str] = None ) -> 'up.model.Problem': domain_res = self._pp_domain.parseFile(domain_filename) problem = up.model.Problem( domain_res['name'], self._env, initial_defaults={self._tm.BoolType(): self._em.FALSE()}) types_map: Dict[str, 'up.model.Type'] = {} object_type_needed: bool = self._check_if_object_type_is_needed( domain_res) for types_list in domain_res.get('types', []): # types_list is a List of 1 or 2 elements, where the first one # is a List of types, and the second one can be their father, # if they have one. father: typing.Optional['up.model.Type'] = None if len(types_list) == 2: # the types have a father if types_list[1] != 'object': #the father is not object father = types_map[types_list[1]] elif object_type_needed: # the father is object, and object is needed object_type = types_map.get('object', None) if object_type is None: # the type object is not defined father = self._env.type_manager.UserType( 'object', None) types_map['object'] = father else: father = object_type else: assert len( types_list ) == 1, "Malformed list of types, I was expecting either 1 or 2 elements" # sanity check for type_name in types_list[0]: types_map[type_name] = self._env.type_manager.UserType( type_name, father) if object_type_needed and 'object' not in types_map: # The object type is needed, but has not been defined types_map['object'] = self._env.type_manager.UserType( 'object', None) # We manually define it. has_actions_cost = False for p in domain_res.get('predicates', []): n = p[0] params = OrderedDict() for g in p[1]: param_type = types_map[g[1] if len(g) > 1 else 'object'] for param_name in g[0]: params[param_name] = param_type f = up.model.Fluent(n, self._tm.BoolType(), params, self._env) problem.add_fluent(f) for p in domain_res.get('functions', []): n = p[0] params = OrderedDict() for g in p[1]: param_type = types_map[g[1] if len(g) > 1 else 'object'] for param_name in g[0]: params[param_name] = param_type f = up.model.Fluent(n, self._tm.RealType(), params, self._env) if n == 'total-cost': has_actions_cost = True self._totalcost = cast(up.model.FNode, self._em.FluentExp(f)) problem.add_fluent(f) for g in domain_res.get('constants', []): t = types_map[g[1] if len(g) > 1 else 'object'] for o in g[0]: problem.add_object(up.model.Object(o, t)) for a in domain_res.get('actions', []): n = a['name'] a_params = OrderedDict() for g in a.get('params', []): t = types_map[g[1] if len(g) > 1 else 'object'] for p in g[0]: a_params[p] = t if 'duration' in a: dur_act = up.model.DurativeAction(n, a_params, self._env) dur = a['duration'][0] if dur[0] == '=': dur_act.set_fixed_duration( self._parse_exp(problem, dur_act, types_map, {}, dur[2])) elif dur[0] == 'and': upper = None lower = None for j in range(1, len(dur)): v = Fraction(dur[j][2]) if dur[j][0] == '>=': if lower is None or v > lower: lower = v elif dur[j][0] == '<=': if upper is None or v < upper: upper = v else: raise SyntaxError( f'Not able to handle duration constraint of action {n}' ) if lower is None or upper is None: raise SyntaxError( f'Not able to handle duration constraint of action {n}' ) d = up.model.ClosedDurationInterval( self._em.Real(lower), self._em.Real(upper)) dur_act.set_duration_constraint(d) else: raise SyntaxError( f'Not able to handle duration constraint of action {n}' ) cond = a['cond'][0] self._add_condition(problem, dur_act, cond, types_map) eff = a['eff'][0] self._add_timed_effects(problem, dur_act, types_map, eff) problem.add_action(dur_act) has_actions_cost = has_actions_cost and self._durative_action_has_cost( dur_act) else: act = up.model.InstantaneousAction(n, a_params, self._env) if 'pre' in a: act.add_precondition( self._parse_exp(problem, act, types_map, {}, a['pre'][0])) if 'eff' in a: self._add_effect(problem, act, types_map, a['eff'][0]) problem.add_action(act) has_actions_cost = has_actions_cost and self._instantaneous_action_has_cost( act) if problem_filename is not None: problem_res = self._pp_problem.parseFile(problem_filename) problem.name = problem_res['name'] for g in problem_res.get('objects', []): t = types_map[g[1] if len(g) > 1 else 'object'] for o in g[0]: problem.add_object(up.model.Object(o, t)) for i in problem_res.get('init', []): if i[0] == '=': problem.set_initial_value( self._parse_exp(problem, None, types_map, {}, i[1]), self._parse_exp(problem, None, types_map, {}, i[2])) elif len(i) == 3 and i[0] == 'at' and i[1].replace( '.', '', 1).isdigit(): ti = up.model.StartTiming(Fraction(i[1])) va = self._parse_exp(problem, None, types_map, {}, i[2]) if va.is_fluent_exp(): problem.add_timed_effect(ti, va, self._em.TRUE()) elif va.is_not(): problem.add_timed_effect(ti, va.arg(0), self._em.FALSE()) elif va.is_equals(): problem.add_timed_effect(ti, va.arg(0), va.arg(1)) else: raise SyntaxError(f'Not able to handle this TIL {i}') else: problem.set_initial_value( self._parse_exp(problem, None, types_map, {}, i), self._em.TRUE()) problem.add_goal( self._parse_exp(problem, None, types_map, {}, problem_res['goal'][0])) has_actions_cost = has_actions_cost and self._problem_has_actions_cost( problem) optimization = problem_res.get('optimization', None) metric = problem_res.get('metric', None) if metric is not None: if optimization == 'minimize' and len( metric) == 1 and metric[0] == 'total-time': problem.add_quality_metric( up.model.metrics.MinimizeMakespan()) else: metric_exp = self._parse_exp(problem, None, types_map, {}, metric) if has_actions_cost and optimization == 'minimize' and metric_exp == self._totalcost: costs = {} problem._fluents.remove(self._totalcost.fluent()) problem._initial_value.pop(self._totalcost) use_plan_length = all( False for _ in problem.durative_actions) for a in problem.instantaneous_actions: cost = None for e in a.effects: if e.fluent == self._totalcost: cost = e break if cost is not None: costs[a] = cost.value a._effects.remove(cost) if cost.value != 1: use_plan_length = False else: use_plan_length = False if use_plan_length: problem.add_quality_metric( up.model.metrics.MinimizeSequentialPlanLength( )) else: problem.add_quality_metric( up.model.metrics.MinimizeActionCosts( costs, self._em.Int(0))) else: if optimization == 'minimize': problem.add_quality_metric( up.model.metrics. MinimizeExpressionOnFinalState(metric_exp)) elif optimization == 'maximize': problem.add_quality_metric( up.model.metrics. MaximizeExpressionOnFinalState(metric_exp)) return problem