class SingletonScopeCache(ScopeCache): def __init__(self, name: str, scoped_components: List[type]): """ :param name: human-readable name :param scoped_components: components managed by this scope """ super().__init__(name) self.scoped_components = Stream(scoped_components).map( lambda clazz: (clazz, None)).toDict() def handles_component(self, component: type) -> bool: return component in self.scoped_components.keys() def is_stored(self, component: type) -> bool: return self.scoped_components[component] is not None def get(self, component: type) -> object: stored_component = self.scoped_components.get(component) if stored_component is None: raise UninstantiatedObjectException(component) return stored_component def store(self, component: type, instance: object): if component not in self.scoped_components.keys(): raise ComponentNotHandledByScopeException(component) self.scoped_components[component] = instance
def test_whenCountingElementsOfIterableWithoutLength_thenIndividuallyCountElements( self): self.stream = Stream(zip(self.COLLECTION, self.COLLECTION)) count = self.stream.count() self.assertEqual(len(self.COLLECTION), count)
def create_route_handlers(self, request: Request) -> Iterable[RouteHandler]: route_registrations = Stream(self.routing_rules) \ .map(lambda rule: rule.get_route_registrations(request.path)) \ .flat().toList() routable_http_methods = Stream(route_registrations).map( lambda route: route.http_method).toSet() if len(route_registrations) == 0: raise UnknownPathException(request.path) if self.is_cors_request( request) and OPTIONS not in routable_http_methods: return Stream.of( self.cors_handler_factory.create_cors_preflight_handler( request.path)) if request.method_annotation not in routable_http_methods: raise MethodNotAllowedException() return Stream(self.routing_rules) \ .map(lambda rule: rule.create_route_handlers(request, self.service_locator, self.deserializer)) \ .flat() \ .map(lambda route_handler: self.cors_handler_factory.apply_cors_rules(request.path, route_handler))
def __getitem__(self, item: str) -> str: found_header = Stream(self.content.items()).firstMatch( lambda key, value: key == item or _format_camel_case( key) == _format_camel_case(item)) if found_header: return found_header.get()[1] return None
def serialize(self, obj: object) -> Union[dict, list]: res = Stream(self.strategies) \ .firstMatch(lambda s: s.can_handle_serialization(obj)) \ .map(lambda s: s.serialize(obj)) if res.isPresent(): return res.get() if obj is None: return None if issubclass(type(obj), BUILTIN_TYPES): return obj if isinstance(obj, list) or isinstance(obj, tuple): return [self.serialize(x) for x in obj] if isinstance(obj, dict): dictionary = obj for key, value in dictionary.items(): dictionary[key] = self.serialize(value) return dictionary if hasattr(obj, '__dict__'): return self.serialize({**obj.__dict__}) raise SerializationException( f"Cannot serialize type {obj.__class__}. {obj}")
def find_sheets(self, image: Image) -> List[Sheet]: hsv_image = colourspace.bgr_to_hsv(image) white_mask = hsv_image.get_in_range_mask([0, 0, 150], [180, 255, 235]) im, contours, hier = cv2.findContours(white_mask.matrix, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) sheets = [] for c in contours: x, y, w, h = cv2.boundingRect(c) if w > 100 and h > 100: corners = cv2.boxPoints(cv2.minAreaRect(c)) distances = Stream.range(1, 4) \ .map(lambda i: (corners[i - 1], corners[i])) \ .map(euclidean_distance).toList() + [euclidean_distance(corners[-1], corners[0])] corners = Stream(corners).toList() + [corners[0]] length_threshold = (max(distances) + min(distances)) / 2 opposing_corners = Stream.zip( range(1, 5), distances + distances).filter(lambda _, d: d > length_threshold).map( lambda i, _: corners[i]).toList() origin = Stream(opposing_corners).reduce( [0, 0], lambda acc, e: e if e[1] > acc[1] else acc) opposite = Stream(opposing_corners).firstMatch( lambda e: e[0] != origin[0] or e[1] != origin[1]) sheets.append( Sheet(CameraCoordinate(*origin), CameraCoordinate(*opposite))) return sheets
def __init__(self, name: str, scoped_components: List[type]): """ :param name: human-readable name :param scoped_components: components managed by this scope """ super().__init__(name) self.scoped_components = Stream(scoped_components).map( lambda clazz: (clazz, None)).toDict()
def post(self, body: dict, callback_id="vote_callback") -> dict: unquoted_query = urllib.parse.unquote(body['text']).replace( "+", " ").replace('”', '"').replace('“', '"') tokens = Stream(re.findall( '"([^"]*)"', unquoted_query)).filter(lambda x: x != '+').toList() # args = unquoted_query.split("+") question = tokens[0] responses = tokens[1::] button_actions = Stream(responses).map( lambda x: { "callback_id": callback_id, "name": "poll", "text": x, "type": "button", "value": x }).toList() text = question for option in responses: text += f"\n- {option} -> " if len(button_actions) > 5: splitted_attachments = [ button_actions[i:i + 5] for i in range(0, len(button_actions), 5) ] response = { "response_type": "in_channel", "attachments": [{ "fallback": "poll button", "text": text, "callback_id": callback_id, "actions": splitted_attachments[0] }, *Stream(splitted_attachments[1::]).map( lambda x: { "fallback": "poll button", "text": "", "callback_id": callback_id, "actions": x })] } else: response = { "response_type": "in_channel", "attachments": [{ "fallback": "poll button", "text": text, "callback_id": callback_id, "actions": button_actions }] } return response
def test_givenCollectionOfTuples_whenForEach_thenExpandTuplesWhenCallingFunction( self): result = [] self.stream = Stream([(1, -1), (2, -2)]) add_sum_to_list = lambda x, y: result.append(x + y) self.stream.forEach(add_sum_to_list) self.assertEqual([0, 0], result)
def doFilter(self, request: Request, response: Response, chain: FilterChain): try: chain.doFilter(request, response) except Exception as e: exception_mapper = Stream(self.exception_mappers).firstMatch( lambda mapper: mapper.handles(e)) if exception_mapper.isPresent(): response.copy(exception_mapper.get().create_response(e)) else: raise e
def to_model(self, album: AlbumInfo) -> AlbumModel: tracks = Stream(album.tracks).map(lambda t: self.track_mapper.to_model(t)).toList() tracks.sort(key=lambda t: (t.disc_number, t.track_number)) return AlbumModel( str(album.id), album.name, album.artist, album.release_year, tracks, "/media/artwork/{}".format(album.id) if self.artwork_repository.has_artwork_for(album.id) else '', album.genre, str(album.artist_id))
def create_filter_chain(self, request: Request) -> FilterChain: if request.method == 'OPTIONS': filters = Stream(JIVAGO_DEFAULT_OPTIONS_FILTERS) \ .map(self.service_locator.get) \ .toList() else: filters = Stream(self.filtering_rules) \ .filter(lambda rule: rule.matches(request.path)) \ .map(lambda rule: rule.get_filters(self.service_locator)) \ .flat() \ .toList() return FilterChain(filters, self.route_handler_factory)
def __init__(self, root_module=None, *, debug: bool = False, context: Union[AbstractContext, Type[ProductionJivagoContext]] = None): self.registry = Registry() self.root_module = root_module if context is None: self.context = DebugJivagoContext(self.root_module, self.registry) if debug else ProductionJivagoContext( self.root_module, self.registry) elif isinstance(context, type): self.context = context(self.root_module, self.registry) else: self.context = context self.print_banner() self.__initialize_logger() self.LOGGER.info(f"Using {self.context.__class__.__name__} with root package {root_module}.") if self.root_module: self.LOGGER.info("Discovering annotated classes") self.__import_package_recursive(root_module) self.context.configure_service_locator() self.serviceLocator = self.context.service_locator() self.serviceLocator.bind(ApplicationProperties, self.__load_application_properties(self.context)) self.serviceLocator.bind(SystemEnvironmentProperties, self.__load_system_environment_properties()) self.LOGGER.info("Running PreInit hooks") self.call_startup_hook(PreInit) self.router = self.context.create_router_config().build(self.registry, self.serviceLocator) self.LOGGER.info("Running Init hooks") self.call_startup_hook(Init) self.LOGGER.info("Starting background workers") self.backgroundWorkers = Stream(self.get_annotated(BackgroundWorker)).map( lambda clazz: self.serviceLocator.get(clazz)).map(lambda worker: Thread(target=worker.run, daemon=True)) Stream(self.backgroundWorkers).forEach(lambda thread: thread.start()) task_schedule_initializer = TaskScheduleInitializer(self.registry, self.root_module_name) self.task_scheduler: TaskScheduler = self.serviceLocator.get(TaskScheduler) task_schedule_initializer.initialize_task_scheduler(self.task_scheduler) self.LOGGER.info("Running PostInit hooks") self.call_startup_hook(PostInit) signal.signal(signal.SIGTERM, self.cleanup) signal.signal(signal.SIGINT, self.cleanup)
def search_by_track_title(self, q: QueryParam[str]) -> TrackSearch: tracks = self.media_library.search_tracks_by_title(q) if len(tracks) > MAX_RESULTS: tracks = tracks[:MAX_RESULTS] return TrackSearch( Stream(tracks).map( lambda t: self.track_mapper.to_model(t)).toList())
def get_annotated_in_package(self, annotation: "Annotation", package: str) -> List[Registration]: if annotation not in self.content: return [] annotated = self.content[annotation] return Stream(annotated).filter( lambda r: r.is_in_package(package)).toList()
def to_model(self, artist: ArtistInfo) -> ArtistModel: return ArtistModel( str(artist.id), artist.name, Stream(artist.albums).map(lambda album: self.album_search_mapper.to_model(album)).toList(), '/media/artwork/{}'.format(artist.id) if self.artwork_repository.has_artwork_for(artist.id) else '', )
def __load_application_properties(self, context: AbstractContext) -> ApplicationProperties: composite_config_loader = GlobalConfigLoader([YamlConfigLoader(), JsonConfigLoader()]) return Stream(context.get_config_file_locations()) \ .firstMatch(lambda filepath: os.path.exists(filepath)) \ .map(lambda x: composite_config_loader.read(x)) \ .orElse(ApplicationProperties())
def deserialize(self, obj, declared_type: Optional[T]) -> Optional[T]: if obj is None: return obj non_nil_declared_type = Stream(declared_type.__args__).firstMatch( lambda x: x != type(None)).get() return self.deserializer.deserialize(obj, non_nil_declared_type)
def print_banner(self): Stream(self.context.get_banner()).forEach(lambda x: print(x)) print(f":: Running Jivago {jivago.__version__} ::") import sys sys.stdout.flush() import time time.sleep(0.01)
def get_route_registrations(self, path: str) -> List[RouteRegistration]: path_elements = split_path(path) try: route_node = self.root_node.explore(path_elements) return Stream(route_node.invocators.values()).flat().toList() except UnknownPathException: return []
def get(self, interface: type): if interface in self.literals.keys(): return self.literals[interface] if typing_meta_helper.is_typing_meta_collection(interface): return self.get_all(interface.__args__[0]) stored_component = Stream.of(self.components, self.providers) \ .firstMatch(lambda x: interface in x) \ .map(lambda x: x[interface]) \ .orElseThrow(InstantiationException("Could not instantiate {}.".format(interface))) scope = self.__get_scope(stored_component) if scope is not None and scope.is_stored(stored_component): return scope.get(stored_component) instance = None if interface in self.providers.keys(): instance = self.__inject_function(self.providers[interface]) else: constructor = stored_component.__init__ instance = self.__inject_constructor(stored_component, constructor) if scope: scope.store(stored_component, instance) return instance
def test_givenTupleIteration_whenUnzipping_thenReturnSeparateLists(self): expected = ((1, 3, 5), (2, 4, 6)) first_list, second_list = Stream([(1, 2), (3, 4), (5, 6)]).unzip() self.assertEqual(expected[0], first_list) self.assertEqual(expected[1], second_list)
def test_givenNoMatchingElements_whenCheckingNoneMatch_thenReturnTrue( self): always_false = lambda x: False result = Stream(self.COLLECTION).noneMatch(always_false) self.assertTrue(result)
def deserialize(self, obj: dict, object_clazz: Type[T]) -> T: try: return Stream(self.deserialization_strategies). \ firstMatch(lambda s: s.can_handle_deserialization(object_clazz)) \ .orElseThrow(lambda: NoMatchingDeserializationStrategyException(object_clazz)) \ .deserialize(obj, object_clazz) except (AttributeError, TypeError): raise IncorrectAttributeTypeException()
def deserialize(self, obj, declared_type: Type[T]) -> T: if _has_defined_initializer(declared_type): initializer_signature = inspect.signature(declared_type) return declared_type(**Stream(initializer_signature.parameters.items()) \ .map(lambda name, parameter: (name, self.deserializer.deserialize(obj.get(name), parameter.annotation))) \ .toDict()) else: instance = object.__new__(declared_type) attributes = declared_type.__annotations__ Stream(attributes.items()) \ .map(lambda name, attribute_type: (name, self.deserializer.deserialize(obj.get(name), attribute_type))) \ .forEach(lambda name, attribute: instance.__setattr__(name, attribute)) return instance
def _is_in(self, sheet: Sheet, sheets: List[Sheet]): matching_sheet = Stream(sheets).firstMatch( lambda sheet_to_compare: sheet.origin.isclose( sheet_to_compare.origin, 10) and sheet.opposite_corner.isclose( sheet_to_compare.opposite_corner, 10)) if matching_sheet is not None: return True return False
def test_givenMethodWhichRequiresTwoParameters_whenMapping_thenInvokeAndExpandParameters( self): calculator_object = AClassWithAMethod(0) result = Stream.zip([1, 2, 3, 4], [1, 2, 3, 4]).map( calculator_object.sum_of_two_values).toList() self.assertEqual([2, 4, 6, 8], result)
def test_givenMethodWhichRequiresAParameter_whenMapping_thenInvokeMethodWithParameter( self): calculator_object = AClassWithAMethod(0) result = Stream.of(1, 2, 3, 4).map(calculator_object.increment).toList() self.assertEqual([1, 2, 3, 4], result)
def search_by_album(self, q: QueryParam[str]) -> AlbumSearch: albums = self.media_library.search_albums(q) if len(albums) > MAX_RESULTS: albums = albums[:MAX_RESULTS] return AlbumSearch( Stream(albums).map( lambda a: self.album_mapper.to_model(a)).toList())
def search_by_artist(self, q: QueryParam[str]) -> ArtistSearch: artists = self.media_library.search_artists(q) if len(artists) > MAX_RESULTS: artists = artists[:MAX_RESULTS] return ArtistSearch( Stream(artists).map( lambda a: self.artist_mapper.to_model(a)).toList())