Merge pull request 'Linting src in backend' (#40) from backend/linting-src into main

Reviewed-on: #40

backend/.pylintrc

@@ -1,2 +1,648 @@
 [MAIN]
-max-line-length=240
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Clear in-memory caches upon conclusion of linting. Useful if running pylint
+# in a server-like mode.
+clear-cache-post-run=no
+
+# Load and enable all available extensions. Use --list-extensions to see a list
+# all available extensions.
+#enable-all-extensions=
+
+# In error mode, messages with a category besides ERROR or FATAL are
+# suppressed, and no reports are done by default. Error mode is compatible with
+# disabling specific errors.
+#errors-only=
+
+# Always return a 0 (non-error) status code, even if lint errors are found.
+# This is primarily useful in continuous integration scripts.
+#exit-zero=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Return non-zero exit code if any of these messages/categories are detected,
+# even if score is above --fail-under value. Syntax same as enable. Messages
+# specified are enabled, while categories only check already-enabled messages.
+fail-on=
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=10
+
+# Interpret the stdin as a python script, whose filename needs to be passed as
+# the module_or_package argument.
+#from-stdin=
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=CVS
+
+# Add files or directories matching the regular expressions patterns to the
+# ignore-list. The regex matches against paths and can be in Posix or Windows
+# format. Because '\\' represents the directory delimiter on Windows systems,
+# it can't be used as an escape character.
+ignore-paths=
+
+# Files or directories matching the regular expression patterns are skipped.
+# The regex matches against base names, not paths. The default value ignores
+# Emacs file locks
+ignore-patterns=^\.#
+
+# List of module names for which member attributes should not be checked and
+# will not be imported (useful for modules/projects where namespaces are
+# manipulated during runtime and thus existing member attributes cannot be
+# deduced by static analysis). It supports qualified module names, as well as
+# Unix pattern matching.
+ignored-modules=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use, and will cap the count on Windows to
+# avoid hangs.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Resolve imports to .pyi stubs if available. May reduce no-member messages and
+# increase not-an-iterable messages.
+prefer-stubs=no
+
+# Minimum Python version to use for version dependent checks. Will default to
+# the version used to run pylint.
+py-version=3.12
+
+# Discover python modules and packages in the file system subtree.
+recursive=no
+
+# Add paths to the list of the source roots. Supports globbing patterns. The
+# source root is an absolute path or a path relative to the current working
+# directory used to determine a package namespace for modules located under the
+# source root.
+source-roots=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# In verbose mode, extra non-checker-related info will be displayed.
+#verbose=
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style. If left empty, argument names will be checked with the set
+# naming style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style. If left empty, attribute names will be checked with the set naming
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style. If left empty, class attribute names will be checked
+# with the set naming style.
+#class-attribute-rgx=
+
+# Naming style matching correct class constant names.
+class-const-naming-style=UPPER_CASE
+
+# Regular expression matching correct class constant names. Overrides class-
+# const-naming-style. If left empty, class constant names will be checked with
+# the set naming style.
+#class-const-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style. If left empty, class names will be checked with the set naming style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style. If left empty, constant names will be checked with the set naming
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style. If left empty, function names will be checked with the set
+# naming style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+           j,
+           k,
+           ex,
+           Run,
+           _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style. If left empty, inline iteration names will be checked
+# with the set naming style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style. If left empty, method names will be checked with the set naming style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style. If left empty, module names will be checked with the set naming style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct type alias names. If left empty, type
+# alias names will be checked with the set naming style.
+#typealias-rgx=
+
+# Regular expression matching correct type variable names. If left empty, type
+# variable names will be checked with the set naming style.
+#typevar-rgx=
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style. If left empty, variable names will be checked with the set
+# naming style.
+#variable-rgx=
+
+
+[CLASSES]
+
+# Warn about protected attribute access inside special methods
+check-protected-access-in-special-methods=no
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp,
+                      asyncSetUp,
+                      __post_init__
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[DESIGN]
+
+# List of regular expressions of class ancestor names to ignore when counting
+# public methods (see R0903)
+exclude-too-few-public-methods=
+
+# List of qualified class names to ignore when counting class parents (see
+# R0901)
+ignored-parents=
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of positional arguments for function / method.
+max-positional-arguments=5
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when caught.
+overgeneral-exceptions=builtins.BaseException,builtins.Exception
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Maximum number of characters on a single line.
+max-line-length=105
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow explicit reexports by alias from a package __init__.
+allow-reexport-from-package=no
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=
+
+# Output a graph (.gv or any supported image format) of external dependencies
+# to the given file (report RP0402 must not be disabled).
+ext-import-graph=
+
+# Output a graph (.gv or any supported image format) of all (i.e. internal and
+# external) dependencies to the given file (report RP0402 must not be
+# disabled).
+import-graph=
+
+# Output a graph (.gv or any supported image format) of internal dependencies
+# to the given file (report RP0402 must not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[LOGGING]
+
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
+# UNDEFINED.
+confidence=HIGH,
+           CONTROL_FLOW,
+           INFERENCE,
+           INFERENCE_FAILURE,
+           UNDEFINED
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then re-enable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+        use-implicit-booleaness-not-comparison-to-string,
+        use-implicit-booleaness-not-comparison-to-zero,
+        import-error
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=
+
+
+[METHOD_ARGS]
+
+# List of qualified names (i.e., library.method) which require a timeout
+# parameter e.g. 'requests.api.get,requests.api.post'
+timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+# Regular expression of note tags to take in consideration.
+notes-rgx=
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit,argparse.parse_error
+
+# Let 'consider-using-join' be raised when the separator to join on would be
+# non-empty (resulting in expected fixes of the type: ``"- " + " -
+# ".join(items)``)
+suggest-join-with-non-empty-separator=yes
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'fatal', 'error', 'warning', 'refactor',
+# 'convention', and 'info' which contain the number of messages in each
+# category, as well as 'statement' which is the total number of statements
+# analyzed. This score is used by the global evaluation report (RP0004).
+evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+msg-template=
+
+# Set the output format. Available formats are: text, parseable, colorized,
+# json2 (improved json format), json (old json format) and msvs (visual
+# studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+#output-format=
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[SIMILARITIES]
+
+# Comments are removed from the similarity computation
+ignore-comments=yes
+
+# Docstrings are removed from the similarity computation
+ignore-docstrings=yes
+
+# Imports are removed from the similarity computation
+ignore-imports=yes
+
+# Signatures are removed from the similarity computation
+ignore-signatures=yes
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. No available dictionaries : You need to install
+# both the python package and the system dependency for enchant to work.
+spelling-dict=
+
+# List of comma separated words that should be considered directives if they
+# appear at the beginning of a comment and should not be checked.
+spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of symbolic message names to ignore for Mixin members.
+ignored-checks-for-mixins=no-member,
+                          not-async-context-manager,
+                          not-context-manager,
+                          attribute-defined-outside-init
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# Regex pattern to define which classes are considered mixins.
+mixin-class-rgx=.*[Mm]ixin
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of names allowed to shadow builtins
+allowed-redefined-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io

backend/src/constants.py

@@ -1,6 +1,9 @@
-import logging.config
-from pathlib import Path
+"""Module allowing to access the parameters of route generation"""
+
+import logging
 import os
+from pathlib import Path
+
 
 LOCATION_PREFIX = Path('src')
 PARAMETERS_DIR = LOCATION_PREFIX / 'parameters'
@@ -9,12 +12,10 @@ LANDMARK_PARAMETERS_PATH = PARAMETERS_DIR / 'landmark_parameters.yaml'
 OPTIMIZER_PARAMETERS_PATH = PARAMETERS_DIR / 'optimizer_parameters.yaml'
 
 
-
 cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache')
 OSM_CACHE_DIR = Path(cache_dir_string)
 
 
-import logging
 # if we are in a debug session, set verbose and rich logging
 if os.getenv('DEBUG', "false") == "true":
     from rich.logging import RichHandler

backend/src/main.py

@@ -1,5 +1,7 @@
+"""Main app for backend api"""
+
 import logging
-from fastapi import FastAPI, Query, Body, HTTPException
+from fastapi import FastAPI, HTTPException
 
 from .structs.landmark import Landmark
 from .structs.preferences import Preferences
@@ -20,26 +22,54 @@ refiner = Refiner(optimizer=optimizer)
 
 
 @app.post("/trip/new")
-def new_trip(preferences: Preferences, start: tuple[float, float], end: tuple[float, float] | None = None) -> Trip:
-    '''
+def new_trip(preferences: Preferences,
+             start: tuple[float, float],
+             end: tuple[float, float] | None = None) -> Trip:
+    """
     Main function to call the optimizer.
-    :param preferences: the preferences specified by the user as the post body
-    :param start: the coordinates of the starting point as a tuple of floats (as url query parameters)
-    :param end: the coordinates of the finishing point as a tuple of floats (as url query parameters)
-    :return: the uuid of the first landmark in the optimized route
-    '''
+
+    Args:
+        preferences : the preferences specified by the user as the post body
+        start       : the coordinates of the starting point
+        end         : the coordinates of the finishing point
+    Returns: 
+        (uuid) : The uuid of the first landmark in the optimized route
+    """
     if preferences is None:
-        raise HTTPException(status_code=406, detail="Preferences not provided")
-    if preferences.shopping.score == 0 and preferences.sightseeing.score == 0 and preferences.nature.score == 0:
-        raise HTTPException(status_code=406, detail="All preferences are 0.")
+        raise HTTPException(status_code=406,
+                            detail="Preferences not provided or incomplete.")
+    if (preferences.shopping.score == 0 and
+        preferences.sightseeing.score == 0 and
+        preferences.nature.score == 0) :
+        raise HTTPException(status_code=406,
+                            detail="All preferences are 0.")
     if start is None:
-        raise HTTPException(status_code=406, detail="Start coordinates not provided")
+        raise HTTPException(status_code=406,
+                            detail="Start coordinates not provided")
+    if not (-90 <= start[0] <= 90 or -180 <= start[1] <= 180):
+        raise HTTPException(status_code=423,
+                            detail="Start coordinates not in range")
     if end is None:
         end = start
         logger.info("No end coordinates provided. Using start=end.")
 
-    start_landmark = Landmark(name='start', type='start', location=(start[0], start[1]), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
-    end_landmark = Landmark(name='finish', type='finish', location=(end[0], end[1]), osm_type='end', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
+    start_landmark = Landmark(name='start',
+                              type='start',
+                              location=(start[0], start[1]),
+                              osm_type='start',
+                              osm_id=0,
+                              attractiveness=0,
+                              must_do=True,
+                              n_tags = 0)
+    
+    end_landmark = Landmark(name='finish',
+                            type='finish',
+                            location=(end[0], end[1]),
+                            osm_type='end',
+                            osm_id=0,
+                            attractiveness=0,
+                            must_do=True,
+                            n_tags = 0)
 
     # Generate the landmarks from the start location
     landmarks, landmarks_short = manager.generate_landmarks_list(
@@ -50,20 +80,22 @@ def new_trip(preferences: Preferences, start: tuple[float, float], end: tuple[fl
     # insert start and finish to the landmarks list
     landmarks_short.insert(0, start_landmark)
     landmarks_short.append(end_landmark)
-    
+
     # First stage optimization
     try:
         base_tour = optimizer.solve_optimization(preferences.max_time_minute, landmarks_short)
-    except ArithmeticError:
-        raise HTTPException(status_code=500, detail="No solution found")
-    except TimeoutError:
-        raise HTTPException(status_code=500, detail="Optimzation took too long")
-    
+    except ArithmeticError as exc:
+        raise HTTPException(status_code=500, detail="No solution found") from exc
+    except TimeoutError as exc:
+        raise HTTPException(status_code=500, detail="Optimzation took too long") from exc
+
     # Second stage optimization
-    refined_tour = refiner.refine_optimization(landmarks, base_tour, preferences.max_time_minute, preferences.detour_tolerance_minute)
+    refined_tour = refiner.refine_optimization(landmarks, base_tour,
+                                               preferences.max_time_minute,
+                                               preferences.detour_tolerance_minute)
 
     linked_tour = LinkedLandmarks(refined_tour)
-    # upon creation of the trip, persistence of both the trip and its landmarks is ensured
+    # upon creation of the trip, persistence of both the trip and its landmarks is ensured.
     trip = Trip.from_linked_landmarks(linked_tour, cache_client)
     return trip
 
@@ -71,17 +103,36 @@ def new_trip(preferences: Preferences, start: tuple[float, float], end: tuple[fl
 #### For already existing trips/landmarks
 @app.get("/trip/{trip_uuid}")
 def get_trip(trip_uuid: str) -> Trip:
+    """
+    Look-up the cache for a trip that has been previously generated using its identifier.
+
+    Args:
+        trip_uuid (str) : unique identifier for a trip.
+
+    Returns:
+        (Trip)          : the corresponding trip.
+    """
     try:
         trip = cache_client.get(f"trip_{trip_uuid}")
         return trip
-    except KeyError:
-        raise HTTPException(status_code=404, detail="Trip not found")
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Trip not found") from exc
 
 
 @app.get("/landmark/{landmark_uuid}")
 def get_landmark(landmark_uuid: str) -> Landmark:
+    """
+    Returns a Landmark from its unique identifier.
+
+    Args:
+        landmark_uuid (str) : unique identifier for a Landmark.
+
+    Returns:
+        (Landmark)          : the corresponding Landmark.
+    """
     try:
         landmark = cache_client.get(f"landmark_{landmark_uuid}")
         return landmark
-    except KeyError:
-        raise HTTPException(status_code=404, detail="Landmark not found")
+    except KeyError as exc:
+        raise HTTPException(status_code=404,
+                            detail="Landmark not found") from exc

backend/src/parameters/amenity_selectors.yaml

@@ -71,8 +71,10 @@ sightseeing:
     - castle
     - museum
 
-
-
+museums:
+  tourism:
+    - museum
+    - aquarium
 
 # to be used later on
 restauration:

backend/src/persistence.py

@@ -1,17 +1,65 @@
+"""Module used for handling cache"""
+
 from pymemcache.client.base import Client
 
 from .constants import MEMCACHED_HOST_PATH
 
 
 class DummyClient:
+    """
+    A dummy in-memory client that mimics the behavior of a memcached client.
+
+    This class is designed to simulate the behavior of the `pymemcache.Client`
+    for testing or development purposes. It stores data in a Python dictionary
+    and provides methods to set, get, and update key-value pairs.
+
+    Attributes:
+        _data (dict): A dictionary that holds the key-value pairs.
+
+    Methods:
+        set(key, value, **kwargs):
+            Stores the given key-value pair in the internal dictionary.
+
+        set_many(data, **kwargs):
+            Updates the internal dictionary with multiple key-value pairs.
+
+        get(key, **kwargs):
+            Retrieves the value associated with the given key from the internal
+            dictionary.
+    """
     _data = {}
-    def set(self, key, value, **kwargs):
+    def set(self, key, value, **kwargs):    # pylint: disable=unused-argument
+        """
+        Store a key-value pair in the internal dictionary.
+
+        Args:
+            key: The key for the item to be stored.
+            value: The value to be stored under the given key.
+            **kwargs: Additional keyword arguments (unused).
+        """
         self._data[key] = value
 
-    def set_many(self, data, **kwargs):
+    def set_many(self, data, **kwargs): # pylint: disable=unused-argument
+        """
+        Update the internal dictionary with multiple key-value pairs.
+
+        Args:
+            data: A dictionary containing key-value pairs to be added.
+            **kwargs: Additional keyword arguments (unused).
+        """
         self._data.update(data)
 
-    def get(self, key, **kwargs):
+    def get(self, key, **kwargs):   # pylint: disable=unused-argument
+        """
+        Retrieve the value associated with the given key.
+
+        Args:
+            key: The key for the item to be retrieved.
+            **kwargs: Additional keyword arguments (unused).
+
+        Returns:
+            The value associated with the given key if it exists.
+        """
         return self._data[key]
 
 

backend/src/structs/landmark.py

@@ -1,10 +1,41 @@
+"""Definition of the Landmark class to handle visitable objects across the world."""
+
 from typing import Optional, Literal
+from uuid import uuid4
 from pydantic import BaseModel, Field
 
-from uuid import uuid4
 
 # Output to frontend
 class Landmark(BaseModel) :
+    """
+    A class representing a landmark or point of interest (POI) in the context of a trip.
+
+    The Landmark class is used to model visitable locations, such as tourist attractions,
+    natural sites, shopping locations, and start/end points in travel itineraries. It
+    holds information about the landmark's attributes and supports comparisons and
+    calculations, such as distance between landmarks.
+
+    Attributes:
+        name (str): The name of the landmark.
+        type (Literal): The type of the landmark, which can be one of ['sightseeing', 'nature', 
+            'shopping', 'start', 'finish'].
+        location (tuple): A tuple representing the (latitude, longitude) of the landmark.
+        osm_type (str): The OpenStreetMap (OSM) type of the landmark.
+        osm_id (int): The OpenStreetMap (OSM) ID of the landmark.
+        attractiveness (int): A score representing the attractiveness of the landmark.
+        n_tags (int): The number of tags associated with the landmark.
+        image_url (Optional[str]): A URL to an image of the landmark.
+        website_url (Optional[str]): A URL to the landmark's official website.
+        description (Optional[str]): A text description of the landmark.
+        duration (Optional[int]): The estimated time to visit the landmark (in minutes).
+        name_en (Optional[str]): The English name of the landmark.
+        uuid (str): A unique identifier for the landmark, generated by default using uuid4.
+        must_do (Optional[bool]): Whether the landmark is a "must-do" attraction.
+        must_avoid (Optional[bool]): Whether the landmark should be avoided.
+        is_secondary (Optional[bool]): Whether the landmark is secondary or less important.
+        time_to_reach_next (Optional[int]): Estimated time (in minutes) to reach the next landmark.
+        next_uuid (Optional[str]): UUID of the next landmark in sequence (if applicable).
+    """
 
     # Properties of the landmark
     name : str
@@ -26,27 +57,63 @@ class Landmark(BaseModel) :
     # Additional properties depending on specific tour
     must_do : Optional[bool] = False
     must_avoid : Optional[bool] = False
-    is_secondary : Optional[bool] = False                       # TODO future   
+    is_secondary : Optional[bool] = False
 
     time_to_reach_next : Optional[int] = 0
     next_uuid : Optional[str] = None
 
     def __str__(self) -> str:
-        time_to_next_str = f", time_to_next={self.time_to_reach_next}" if self.time_to_reach_next else ""
-        is_secondary_str = f", secondary" if self.is_secondary else ""
+        """
+        String representation of the Landmark object.
+
+        Returns:
+            str: A formatted string with the landmark's type, name, location, attractiveness score,
+            time to the next landmark (if available), and whether the landmark is secondary.
+        """
+        t_to_next_str = f", time_to_next={self.time_to_reach_next}" if self.time_to_reach_next else ""
+        is_secondary_str = ", secondary" if self.is_secondary else ""
         type_str = '(' + self.type + ')'
-        if self.type in ["start", "finish", "nature", "shopping"] : type_str += '\t '
-        return f'Landmark{type_str}: [{self.name} @{self.location}, score={self.attractiveness}{time_to_next_str}{is_secondary_str}]'
+        if self.type in ["start", "finish", "nature", "shopping"] :
+            type_str += '\t '
+
+        return (f'Landmark{type_str}: [{self.name} @{self.location}, '
+                f'score={self.attractiveness}{t_to_next_str}{is_secondary_str}]')
 
     def distance(self, value: 'Landmark') -> float:
+        """
+        Calculates the squared distance between this landmark and another.
+
+        Args:
+            value (Landmark): Another Landmark object to calculate the distance to.
+
+        Returns:
+            float: The squared Euclidean distance between the two landmarks.
+        """
         return (self.location[0] - value.location[0])**2 + (self.location[1] - value.location[1])**2
 
     def __hash__(self) -> int:
+        """
+        Generates a hash for the Landmark based on its name.
+
+        Returns:
+            int: The hash of the landmark.
+        """
         return hash(self.name)
 
     def __eq__(self, value: 'Landmark') -> bool:
+        """
+        Checks equality between two Landmark objects based on UUID, OSM ID, and name.
+
+        Args:
+            value (Landmark): Another Landmark object to compare.
+
+        Returns:
+            bool: True if the landmarks are equal, False otherwise.
+        """
         # eq and hash must be consistent
         # in particular, if two objects are equal, their hash must be equal
         # uuid and osm_id are just shortcuts to avoid comparing all the properties
         # if they are equal, we know that the name is also equal and in turn the hash is equal
-        return self.uuid == value.uuid or self.osm_id == value.osm_id or (self.name == value.name and self.distance(value) < 0.001)
+        return (self.uuid == value.uuid or
+                self.osm_id == value.osm_id or
+                (self.name == value.name and self.distance(value) < 0.001))

backend/src/structs/linked_landmarks.py

@@ -1,21 +1,30 @@
+"""Linked and ordered list of Landmarks that represents the visiting order."""
+
 from .landmark import Landmark
 from ..utils.get_time_separation import get_time
 
 class LinkedLandmarks:
     """
     A list of landmarks that are linked together, e.g. in a route.
-    Each landmark serves as a node in the linked list, but since we expect these to be consumed through the rest API, a pythonic reference to the next landmark is not well suited. Instead we use the uuid of the next landmark to reference the next landmark in the list. This is not very efficient, but appropriate for the expected use case ("short" trips with onyl few landmarks).
+    Each landmark serves as a node in the linked list, but since we expect
+    these to be consumed through the rest API, a pythonic reference to the next
+    landmark is not well suited. Instead we use the uuid of the next landmark
+    to reference the next landmark in the list. This is not very efficient,
+    but appropriate for the expected use case
+    ("short" trips with onyl few landmarks).
     """
-    
+
     _landmarks = list[Landmark]
     total_time: int = 0
 
     def __init__(self, data: list[Landmark] = None) -> None:
         """
-        Initialize a new LinkedLandmarks object. This expects an ORDERED list of landmarks, where the first landmark is the starting point and the last landmark is the end point.
-        
+        Initialize a new LinkedLandmarks object. This expects an ORDERED list of landmarks,
+        where the first landmark is the starting point and the last landmark is the end point.
+
         Args:
-            data (list[Landmark], optional): The list of landmarks that are linked together. Defaults to None.
+            data (list[Landmark], optional):    The list of landmarks that are linked together.
+                                                Defaults to None.
         """
         self._landmarks = data if data else []
         self._link_landmarks()
@@ -23,7 +32,8 @@ class LinkedLandmarks:
 
     def _link_landmarks(self) -> None:
         """
-        Create the links between the landmarks in the list by setting their .next_uuid and the .time_to_next attributes.
+        Create the links between the landmarks in the list by setting their 
+        .next_uuid and the .time_to_next attributes.
         """
 
         # Mark secondary landmarks as such
@@ -41,25 +51,28 @@ class LinkedLandmarks:
         self._landmarks[-1].time_to_reach_next = 0
 
     def update_secondary_landmarks(self) -> None:
+        """
+        Mark landmarks with lower importance as secondary.
+        """
         # Extract the attractiveness scores and sort them in descending order
         scores = sorted([landmark.attractiveness for landmark in self._landmarks], reverse=True)
-        
+
         # Determine the 10th highest score
         if len(scores) >= 10:
             threshold_score = scores[9]
         else:
-            # If there are fewer than 10 landmarks, use the lowest score in the list as the threshold
+            # If there are fewer than 10 landmarks, use the lowest score as the threshold
             threshold_score = min(scores) if scores else 0
-        
+
         # Update 'is_secondary' for landmarks with attractiveness below the threshold score
         for landmark in self._landmarks:
-            if landmark.attractiveness < threshold_score and landmark.type not in ["start", "finish"]:
+            if (landmark.attractiveness < threshold_score and landmark.type not in ["start", "finish"]):
                 landmark.is_secondary = True
 
 
     def __getitem__(self, index: int) -> Landmark:
         return self._landmarks[index]
-    
+
 
     def __str__(self) -> str:
         return f"LinkedLandmarks [{' ->'.join([str(landmark) for landmark in self._landmarks])}]"

backend/src/structs/preferences.py

@@ -1,12 +1,26 @@
-from pydantic import BaseModel
+"""Defines the Preferences used as input for trip generation."""
+
 from typing import Optional, Literal
+from pydantic import BaseModel
+
 
 class Preference(BaseModel) :
+    """
+    Type of preference.
+
+    Attributes:
+        type: what kind of landmark type.
+        score: how important that type is.
+    """
     type: Literal['sightseeing', 'nature', 'shopping', 'start', 'finish']
     score: int          # score could be from 1 to 5
 
+
 # Input for optimization
 class Preferences(BaseModel) :
+    """"
+    Full collection of preferences needed to generate a personalized trip.
+    """
     # Sightseeing / History & Culture (Musées, bâtiments historiques, opéras, églises)
     sightseeing : Preference
 
@@ -16,5 +30,5 @@ class Preferences(BaseModel) :
     # Shopping (diriger plutôt vers des zones / rues commerçantes)
     shopping : Preference
 
-    max_time_minute: Optional[int] = 6*60
+    max_time_minute: Optional[int] = 3*60
     detour_tolerance_minute: Optional[int] = 0

backend/src/structs/trip.py

@@ -1,17 +1,31 @@
+"""Definition of the Trip class."""
+
+import uuid
 from pydantic import BaseModel, Field
 from pymemcache.client.base import Client
 
 from .linked_landmarks import LinkedLandmarks
-import uuid
+
 
 class Trip(BaseModel):
+    """"
+    A Trip represents the final guided tour that can be passed to frontend.
+
+    Attributes:
+        uuid: unique identifier for this particular trip.
+        total_time: duration of the trip (in minutes).
+        first_landmark_uuid: unique identifier of the first Landmark to visit.
+
+    Methods:
+        from_linked_landmarks: create a Trip from LinkedLandmarks object.
+    """
     uuid: str = Field(default_factory=uuid.uuid4)
     total_time: int
     first_landmark_uuid: str
 
 
     @classmethod
-    def from_linked_landmarks(self, landmarks: LinkedLandmarks, cache_client: Client) -> "Trip":
+    def from_linked_landmarks(cls, landmarks: LinkedLandmarks, cache_client: Client) -> "Trip":
         """
         Initialize a new Trip object and ensure it is stored in the cache.
         """
@@ -22,8 +36,11 @@ class Trip(BaseModel):
 
         # Store the trip in the cache
         cache_client.set(f"trip_{trip.uuid}", trip)
-        # make sure to await the result (noreply=False). Otherwise the cache might not be inplace when the trip is actually requested
-        cache_client.set_many({f"landmark_{landmark.uuid}": landmark for landmark in landmarks}, expire=3600, noreply=False)
+
+        # Make sure to await the result (noreply=False).
+        # Otherwise the cache might not be inplace when the trip is actually requested.
+        cache_client.set_many({f"landmark_{landmark.uuid}": landmark for landmark in landmarks},
+                              expire=3600, noreply=False)
         # is equivalent to:
         # for landmark in landmarks:
         #     cache_client.set(f"landmark_{landmark.uuid}", landmark, expire=3600)

backend/src/tester.py

@@ -1,80 +0,0 @@
-import logging
-import yaml
-
-from .utils.landmarks_manager import LandmarkManager
-from .utils.optimizer import Optimizer
-from .utils.refiner import Refiner
-from .structs.landmark import Landmark
-from .structs.linked_landmarks import LinkedLandmarks
-from .structs.preferences import Preferences, Preference
-
-
-logger = logging.getLogger(__name__)
-
-
-
-def test(start_coords: tuple[float, float], finish_coords: tuple[float, float] = None) -> list[Landmark]:
-    manager = LandmarkManager()
-    optimizer = Optimizer()
-    refiner = Refiner(optimizer=optimizer)
-
-    
-    preferences = Preferences(
-        sightseeing=Preference(type='sightseeing', score = 5),
-        nature=Preference(type='nature', score = 5),
-        shopping=Preference(type='shopping', score = 0),
-        max_time_minute=30,
-        detour_tolerance_minute=0
-    )
-
-    # Create start and finish 
-    if finish_coords is None :
-        finish_coords = start_coords
-    start = Landmark(name='start', type='start', location=start_coords, osm_type='', osm_id=0, attractiveness=0, n_tags = 0)
-    finish = Landmark(name='finish', type='finish', location=finish_coords, osm_type='', osm_id=0, attractiveness=0, n_tags = 0)
-    #finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.8777055, 2.3640967), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
-    #start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(48.847132, 2.312359), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
-    #finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.843185, 2.344533), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
-    #finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.847132, 2.312359), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
-    
-
-
-    # Generate the landmarks from the start location
-    landmarks, landmarks_short = manager.generate_landmarks_list(
-        center_coordinates = start_coords,
-        preferences = preferences
-    )
-    
-    # Store data to file for debug purposes
-    # write_data(landmarks, "landmarks_Strasbourg.txt")
-
-    # Insert start and finish to the landmarks list
-    landmarks_short.insert(0, start)
-    landmarks_short.append(finish)
-
-    # First stage optimization
-    base_tour = optimizer.solve_optimization(max_time=preferences.max_time_minute, landmarks=landmarks_short)
-
-    # Second stage using linear optimization
-    refined_tour = refiner.refine_optimization(all_landmarks=landmarks, base_tour=base_tour, max_time = preferences.max_time_minute, detour = preferences.detour_tolerance_minute)
-
-    linked_tour = LinkedLandmarks(refined_tour)
-    total_time = 0           
-    logger.info("Optimized route : ")
-    for l in linked_tour :
-        logger.info(f"{l}")
-    logger.info(f"Estimated length of tour : {linked_tour.total_time} mintutes and visiting {len(linked_tour._landmarks)} landmarks.")
-
-    # with open('linked_tour.yaml', 'w') as f:
-    #     yaml.dump(linked_tour.asdict(), f)
-
-    return linked_tour
-
-
-# test(tuple((48.8344400, 2.3220540)))       # Café Chez César 
-# test(tuple((48.8375946, 2.2949904)))       # Point random
-# test(tuple((47.377859, 8.540585)))         # Zurich HB
-test(tuple((45.758217, 4.831814)))         # Lyon Bellecour
-# test(tuple((48.5848435, 7.7332974)))       # Strasbourg Gare
-# test(tuple((48.2067858, 16.3692340)))      # Vienne
-# test(tuple((48.2432090, 7.3892691)))         # Orschwiller 

backend/src/tests/test_invalid_input.py

@@ -0,0 +1,62 @@
+"""Collection of tests to ensure correct handling of invalid input."""
+
+from fastapi.testclient import TestClient
+import pytest
+
+from ..main import app
+
+
+@pytest.fixture(scope="module")
+def invalid_client():
+    """Client used to call the app."""
+    return TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "start,preferences,status_code",
+    [
+        # Invalid case: no preferences at all.
+        ([48.8566, 2.3522], {}, 422),
+
+        # Invalid cases: incomplete preferences.
+        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no shopping
+                                 "nature": {"type": "nature", "score": 5},
+                                 }, 422),
+        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no nature
+                                 "shopping": {"type": "shopping", "score": 5},
+                                 }, 422),
+        ([48.084588, 7.280405], {"nature": {"type": "nature", "score": 5},      # no sightseeing
+                                 "shopping": {"type": "shopping", "score": 5},
+                                 }, 422),
+
+        # Invalid cases: unexisting coords
+        ([91, 181], {"sightseeing": {"type": "nature", "score": 5},
+                     "nature": {"type": "nature", "score": 5},
+                     "shopping": {"type": "shopping", "score": 5},
+                    }, 423),
+        ([-91, 181], {"sightseeing": {"type": "nature", "score": 5},
+                     "nature": {"type": "nature", "score": 5},
+                     "shopping": {"type": "shopping", "score": 5},
+                    }, 423),
+        ([91, -181], {"sightseeing": {"type": "nature", "score": 5},
+                     "nature": {"type": "nature", "score": 5},
+                     "shopping": {"type": "shopping", "score": 5},
+                    }, 423),
+        ([-91, -181], {"sightseeing": {"type": "nature", "score": 5},
+                     "nature": {"type": "nature", "score": 5},
+                     "shopping": {"type": "shopping", "score": 5},
+                    }, 423),
+    ]
+)
+def test_input(invalid_client, start, preferences, status_code):   # pylint: disable=redefined-outer-name
+    """
+    Test new trip creation with different sets of preferences and locations.
+    """
+    response = invalid_client.post(
+        "/trip/new",
+        json={
+            "preferences": preferences,
+            "start": start
+        }
+    )
+    assert response.status_code == status_code

backend/src/tests/test_main.py

@@ -1,34 +1,34 @@
+"""Collection of tests to ensure correct implementation and track progress. """
+
 from fastapi.testclient import TestClient
-from typing import List
 import pytest
+
+from .test_utils import landmarks_to_osmid, load_trip_landmarks, log_trip_details
 from ..main import app
-from ..structs.landmark import Landmark
 
-
-@pytest.fixture()
+@pytest.fixture(scope="module")
 def client():
+    """Client used to call the app."""
     return TestClient(app)
 
 
-# Base test for checking if the API returns correct error code when no preferences are specified.
-def test_new_trip_invalid_prefs(client):
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {},
-            "start": [48.8566, 2.3522]
-            }
-        )
-    assert response.status_code == 422
+def test_turckheim(client, request):    # pylint: disable=redefined-outer-name
+    """
+    Test n°1 : Custom test in Turckheim to ensure small villages are also supported.
 
-    
-# Test no. 2
-def test_turckheim(client, request):
+    Args:
+        client:
+        request:
+    """
     duration_minutes = 15
     response = client.post(
         "/trip/new",
         json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5}, "nature": {"type": "nature", "score": 5}, "shopping": {"type": "shopping", "score": 5}, "max_time_minute": duration_minutes, "detour_tolerance_minute": 0},
+            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
+            "nature": {"type": "nature", "score": 5},
+            "shopping": {"type": "shopping", "score": 5},
+            "max_time_minute": duration_minutes,
+            "detour_tolerance_minute": 0},
             "start": [48.084588, 7.280405]
             }
         )
@@ -45,13 +45,23 @@ def test_turckheim(client, request):
     assert len(landmarks) > 2           # check that there is something to visit
 
 
-# Test no. 3
-def test_bellecour(client, request) :
-    duration_minutes = 60
+def test_bellecour(client, request) :   # pylint: disable=redefined-outer-name
+    """
+    Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
+    
+    Args:
+        client:
+        request:
+    """
+    duration_minutes = 30
     response = client.post(
         "/trip/new",
         json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5}, "nature": {"type": "nature", "score": 5}, "shopping": {"type": "shopping", "score": 5}, "max_time_minute": duration_minutes, "detour_tolerance_minute": 0},
+            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
+                            "nature": {"type": "nature", "score": 5},
+                            "shopping": {"type": "shopping", "score": 5},
+                            "max_time_minute": duration_minutes,
+                            "detour_tolerance_minute": 0},
             "start": [45.7576485, 4.8330241]
             }
         )
@@ -69,87 +79,15 @@ def test_bellecour(client, request) :
 
 
 
-def landmarks_to_osmid(landmarks: List[Landmark]) -> List[int] :
-    """
-    Convert the list of landmarks into a list containing their osm ids for quick landmark checking.
-    
-    Args :
-        landmarks (list): the list of landmarks
-    
-    Returns :
-        ids (list)      : the list of corresponding OSM ids
-    """
-    ids = []
-    for landmark in landmarks :
-        ids.append(landmark.osm_id)
-
-    return ids
-
-def fetch_landmark(client, landmark_uuid: str):
-    """
-    Fetch landmark data from the API based on the landmark UUID.
-
-    Args:
-        landmark_uuid (str): The UUID of the landmark.
-
-    Returns:
-        dict: Landmark data fetched from the API.
-    """
-    response = client.get(f"/landmark/{landmark_uuid}")
-
-    if response.status_code != 200:
-        raise Exception(f"Failed to fetch landmark with UUID {landmark_uuid}: {response.status_code}")
-    
-    json_data = response.json()
-    
-    if "detail" in json_data:
-        raise Exception(json_data["detail"])
-    
-    return json_data
-
-
-def load_trip_landmarks(client, first_uuid: str) -> List[Landmark]:
-    """
-    Load all landmarks for a trip using the response from the API.
-
-    Args:
-        first_uuid (str) : The first UUID of the landmark.
-
-    Returns:
-        landmarks (list) : An list containing all landmarks for the trip.
-    """
-    landmarks = []
-    next_uuid = first_uuid
-
-    while next_uuid is not None:
-        landmark_data = fetch_landmark(client, next_uuid)
-        # # Convert UUIDs to strings explicitly
-        # landmark_data = {
-        #     key: str(value) if isinstance(value, UUID) else value
-        #     for key, value in landmark_data.items()
-        # }
-        landmarks.append(Landmark(**landmark_data)) # Create Landmark objects
-        next_uuid = landmark_data.get('next_uuid')  # Prepare for the next iteration
-
-    return landmarks
-
-
-def log_trip_details(request, landmarks: List[Landmark], duration: int, target_duration: int) :
-
-    # Create the trip string
-    trip_string = [f"{landmark.name} ({landmark.attractiveness} | {landmark.duration}) - {landmark.time_to_reach_next}" for landmark in landmarks]
-    
-    # Pass additional info to pytest for reporting
-    request.node.trip_details = trip_string
-    request.node.trip_duration = str(duration)              # result['total_time']
-    request.node.target_duration = str(target_duration)
-
-
 # def test_new_trip_single_prefs(client):
 #     response = client.post(
 #         "/trip/new",
 #         json={
-#             "preferences": {"sightseeing": {"type": "sightseeing", "score": 1}, "nature": {"type": "nature", "score": 1}, "shopping": {"type": "shopping", "score": 1}, "max_time_minute": 360, "detour_tolerance_minute": 0},
+#             "preferences": {"sightseeing": {"type": "sightseeing", "score": 1},
+#             "nature": {"type": "nature", "score": 1},
+#             "shopping": {"type": "shopping", "score": 1},
+#             "max_time_minute": 360,
+#             "detour_tolerance_minute": 0},
 #             "start": [48.8566, 2.3522]
 #             }
 #         )
@@ -157,5 +95,4 @@ def log_trip_details(request, landmarks: List[Landmark], duration: int, target_d
 
 
 # def test_new_trip_matches_prefs(client):
-#     # todo
 #     pass

backend/src/tests/test_utils.py

@@ -0,0 +1,90 @@
+"""Helper methods for testing."""
+from typing import List
+from fastapi import HTTPException
+
+from ..structs.landmark import Landmark
+
+
+def landmarks_to_osmid(landmarks: List[Landmark]) -> List[int] :
+    """
+    Convert the list of landmarks into a list containing their osm ids for quick landmark checking.
+    
+    Args :
+        landmarks (list): the list of landmarks
+    
+    Returns :
+        ids (list)      : the list of corresponding OSM ids
+    """
+    ids = []
+    for landmark in landmarks :
+        ids.append(landmark.osm_id)
+
+    return ids
+
+def fetch_landmark(client, landmark_uuid: str):
+    """
+    Fetch landmark data from the API based on the landmark UUID.
+
+    Args:
+        landmark_uuid (str): The UUID of the landmark.
+
+    Returns:
+        dict: Landmark data fetched from the API.
+    """
+    response = client.get(f"/landmark/{landmark_uuid}")
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=999,
+                            detail=f"Failed to fetch landmark with UUID {landmark_uuid}: {response.status_code}")
+
+    json_data = response.json()
+
+    if "detail" in json_data:
+        raise HTTPException(status_code=999, detail=json_data["detail"])
+
+
+    return json_data
+
+
+def load_trip_landmarks(client, first_uuid: str) -> List[Landmark]:
+    """
+    Load all landmarks for a trip using the response from the API.
+
+    Args:
+        first_uuid (str) : The first UUID of the landmark.
+
+    Returns:
+        landmarks (list) : An list containing all landmarks for the trip.
+    """
+    landmarks = []
+    next_uuid = first_uuid
+
+    while next_uuid is not None:
+        landmark_data = fetch_landmark(client, next_uuid)
+        # # Convert UUIDs to strings explicitly
+        # landmark_data = {
+        #     key: str(value) if isinstance(value, UUID) else value
+        #     for key, value in landmark_data.items()
+        # }
+        landmarks.append(Landmark(**landmark_data)) # Create Landmark objects
+        next_uuid = landmark_data.get('next_uuid')  # Prepare for the next iteration
+
+    return landmarks
+
+
+def log_trip_details(request, landmarks: List[Landmark], duration: int, target_duration: int) :
+    """
+    Allows to show the detailed trip in the html test report.
+    
+    Args:
+        request:
+        landmarks (list): the ordered list of visited landmarks 
+        duration (int): the total duration of this trip
+        target_duration(int): the target duration of this trip
+    """
+    trip_string = [f"{landmark.name} ({landmark.attractiveness} | {landmark.duration}) - {landmark.time_to_reach_next}" for landmark in landmarks]
+
+    # Pass additional info to pytest for reporting
+    request.node.trip_details = trip_string
+    request.node.trip_duration = str(duration)              # result['total_time']
+    request.node.target_duration = str(target_duration)

backend/src/utils/landmarks_manager.py

@@ -63,7 +63,7 @@ class LandmarkManager:
         and current location. It scores and corrects these landmarks, removes duplicates, and then selects the most important
         landmarks based on a predefined criterion.
 
-        Parameters:
+        Args:
         center_coordinates (tuple[float, float]): The latitude and longitude of the center location around which to search.
         preferences (Preferences): The user's preference settings that influence the landmark selection.
 

backend/src/utils/refiner.py

@@ -38,11 +38,11 @@ class Refiner :
         Create a corridor around the path connecting the landmarks.
 
         Args:
-            landmarks (list[Landmark]): the landmark path around which to create the corridor
-            width (float): Width of the corridor in meters.
+            landmarks (list[Landmark]) : the landmark path around which to create the corridor
+            width (float) : width of the corridor in meters.
 
         Returns:
-            Geometry: A buffered geometry object representing the corridor around the path.
+            Geometry: a buffered geometry object representing the corridor around the path.
         """
 
         corrected_width = (180*width)/(6371000*pi)

backend/src/utils/take_most_important.py

@@ -3,7 +3,7 @@ from ..structs.landmark import Landmark
 def take_most_important(landmarks: list[Landmark], n_important) -> list[Landmark]:
     """
     Given a list of landmarks, return the n_important most important landmarks
-    Parameters:
+    Args:
     landmarks: list[Landmark] - list of landmarks
     n_important: int - number of most important landmarks to return
     Returns: