Merge pull request #1 from sasan-j/feature/refactor

.devcontainer/Dockerfile

@@ -2,8 +2,8 @@
 # Run: sudo docker run -v $(pwd):/workspace/project --gpus all -it --rm <project_name>
 
 ARG USERNAME=kitt
-ARG USER_UID=1005
-ARG USER_GID=100
+ARG USER_UID=320869193
+ARG USER_GID=1429829944
 
 
 FROM nvidia/cuda:12.1.1-base-ubuntu22.04

.gitignore

@@ -0,0 +1,4 @@
+audio
+.DS_Store
+.env
+__pycache__

.pylintrc

@@ -0,0 +1,642 @@
+[MAIN]
+
+# 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
+# (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
+
+# 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 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=100
+
+# 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,
+        missing-module-docstring,
+        missing-class-docstring,
+        missing-function-docstring
+
+# 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

apis.py

@@ -1,5 +1,3 @@
-import requests
-
 from geopy.geocoders import Nominatim
 
 
@@ -53,287 +51,4 @@ def check_city_coordinates(lat = "", lon = "", city = "", **kwargs):
             lon = coord.longitude
     return lat, lon, city
 
-# Select coordinates at equal distance, including the last one
-def select_equally_spaced_coordinates(coords, number_of_points=10):
-    n = len(coords)
-    selected_coords = []
-    interval = max((n - 1) / (number_of_points - 1), 1)
-    for i in range(number_of_points):
-        # Calculate the index, ensuring it doesn't exceed the bounds of the list
-        index = int(round(i * interval))
-        if index < n:
-            selected_coords.append(coords[index])
-    return selected_coords
-
-def find_points_of_interest(lat="0", lon="0", city="", type_of_poi="restaurant", **kwargs):
-    """
-    Return some of the closest points of interest for a specific location and type of point of interest. The more parameters there are, the more precise.
-    :param lat (string):  latitude
-    :param lon (string):  longitude
-    :param city (string): Required. city
-    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
-    """
-    lat, lon, city = check_city_coordinates(lat,lon,city)
-
-    r = requests.get(f'https://api.tomtom.com/search/2/search/{type_of_poi}'
-                     '.json?key={0}&lat={1}&lon={2}&radius=10000&idxSet=POI&limit=100'.format(
-                        TOMTOM_KEY,
-                        lat,
-                        lon
-    ))
-
-    # Parse JSON from the response
-    data = r.json()
-    #print(data)
-    # Extract results
-    results = data['results']
-
-    # Sort the results based on distance
-    sorted_results = sorted(results, key=lambda x: x['dist'])
-    #print(sorted_results)
-
-    # Format and limit to top 5 results
-    formatted_results = [
-        f"The {type_of_poi} {result['poi']['name']} is {int(result['dist'])} meters away"
-        for result in sorted_results[:5]
-    ]
-
-
-    return ". ".join(formatted_results)
-
-def find_route(lat_depart="0", lon_depart="0", city_depart="", address_destination="", depart_time ="", **kwargs):
-    """
-    Return the distance and the estimated time to go to a specific destination from the current place, at a specified depart time.
-    :param lat_depart (string):  latitude of depart
-    :param lon_depart (string):  longitude of depart
-    :param city_depart (string): Required. city of depart
-    :param address_destination (string): Required. The destination
-    :param depart_time (string):  departure hour, in the format '08:00:20'.
-    """
-    print(address_destination)
-    date = "2025-03-29T"
-    departure_time = '2024-02-01T' + depart_time
-    lat, lon, city = check_city_coordinates(lat_depart,lon_depart,city_depart)
-    lat_dest, lon_dest = find_coordinates(address_destination)
-    #print(lat_dest, lon_dest)
-    
-    #print(departure_time)
-
-    r = requests.get('https://api.tomtom.com/routing/1/calculateRoute/{0},{1}:{2},{3}/json?key={4}&departAt={5}'.format(
-                        lat_depart,
-                        lon_depart,
-                        lat_dest,
-                        lon_dest,
-                        TOMTOM_KEY,
-                        departure_time
-    ))
-
-    # Parse JSON from the response
-    data = r.json()
-    #print(data)
-    
-    #print(data)
-    
-    result = data['routes'][0]['summary']
-
-    # Calculate distance in kilometers (1 meter = 0.001 kilometers)
-    distance_km = result['lengthInMeters'] * 0.001
-
-    # Calculate travel time in minutes (1 second = 1/60 minutes)
-    time_minutes = result['travelTimeInSeconds'] / 60
-    if time_minutes < 60:
-        time_display = f"{time_minutes:.0f} minutes"
-    else:
-        hours = int(time_minutes / 60)
-        minutes = int(time_minutes % 60)
-        time_display = f"{hours} hours" + (f" and {minutes} minutes" if minutes > 0 else "")
-        
-    # Extract arrival time from the JSON structure
-    arrival_time_str = result['arrivalTime']
-
-    # Convert string to datetime object
-    arrival_time = datetime.fromisoformat(arrival_time_str)
-
-    # Extract and display the arrival hour in HH:MM format
-    arrival_hour_display = arrival_time.strftime("%H:%M")
-
-
-    # return the distance and time
-    return(f"The route to go to {address_destination} is {distance_km:.2f} km and {time_display}. Leaving now, the arrival time is estimated at {arrival_hour_display} " )
-
-    
-    # Sort the results based on distance
-    #sorted_results = sorted(results, key=lambda x: x['dist'])
-
-    #return ". ".join(formatted_results)
-
-
-def search_along_route(latitude_depart, longitude_depart, city_destination, type_of_poi):
-    """
-    Return some of the closest points of interest along the route from the depart point, specified by its coordinates and a city destination.
-    :param latitude_depart (string):  Required. Latitude of depart location
-    :param longitude_depart (string):  Required. Longitude of depart location
-    :param city_destination (string): Required. City destination
-    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
-    """
-    
-    lat_dest, lon_dest = find_coordinates(city_destination)
-    print(lat_dest)
-    
-    r = requests.get('https://api.tomtom.com/routing/1/calculateRoute/{0},{1}:{2},{3}/json?key={4}'.format(
-                        latitude_depart,
-                        longitude_depart,
-                        lat_dest,
-                        lon_dest,
-                        TOMTOM_KEY
-    ))
-    
-    coord_route = select_equally_spaced_coordinates(r.json()['routes'][0]['legs'][0]['points'])
-
-    # The API endpoint for searching along a route
-    url = f'https://api.tomtom.com/search/2/searchAlongRoute/{type_of_poi}.json?key={TOMTOM_KEY}&maxDetourTime=700&limit=20&sortBy=detourTime'
-
-    # The data payload
-    payload = {
-      "route": {
-        "points": [
-          {"lat": float(latitude_depart), "lon": float(longitude_depart)},
-          {"lat": float(coord_route[1]['latitude']), "lon": float(coord_route[1]['longitude'])},
-          {"lat": float(coord_route[2]['latitude']), "lon": float(coord_route[2]['longitude'])},
-          {"lat": float(coord_route[3]['latitude']), "lon": float(coord_route[3]['longitude'])},
-          {"lat": float(coord_route[4]['latitude']), "lon": float(coord_route[4]['longitude'])},
-          {"lat": float(coord_route[5]['latitude']), "lon": float(coord_route[5]['longitude'])},
-          {"lat": float(coord_route[6]['latitude']), "lon": float(coord_route[6]['longitude'])},
-          {"lat": float(coord_route[7]['latitude']), "lon": float(coord_route[7]['longitude'])},
-          {"lat": float(coord_route[8]['latitude']), "lon": float(coord_route[8]['longitude'])},
-          {"lat": float(lat_dest), "lon": float(lon_dest)},
-        ]
-      }
-    }
-
-    # Make the POST request
-    response = requests.post(url, json=payload)
-
-    # Check if the request was successful
-    if response.status_code == 200:
-        # Parse the JSON response
-        data = response.json()
-        print(json.dumps(data, indent=4))
-    else:
-        print('Failed to retrieve data:', response.status_code)
-    answer = ""
-    for result in data['results']:
-        name = result['poi']['name']
-        address = result['address']['freeformAddress']
-        detour_time = result['detourTime']
-        answer = answer + f" \nAlong the route to {city_destination}, there is the {name} at {address} that would represent a detour of {int(detour_time/60)} minutes."
-        
-    return answer
-
-
-#current weather API
-def get_weather(city_name:str= "", **kwargs):
-    """
-    Returns the CURRENT weather in a specified city.
-    Args:
-    city_name (string) : Required. The name of the city.
-    """
-    # The endpoint URL provided by WeatherAPI
-    url = f"http://api.weatherapi.com/v1/current.json?key={WEATHER_API_KEY}&q={city_name}&aqi=no"
-
-    # Make the API request
-    response = requests.get(url)
-
-    if response.status_code == 200:
-        # Parse the JSON response
-        weather_data = response.json()
-
-        # Extracting the necessary pieces of data
-        location = weather_data['location']['name']
-        region = weather_data['location']['region']
-        country = weather_data['location']['country']
-        time = weather_data['location']['localtime']
-        temperature_c = weather_data['current']['temp_c']
-        condition_text = weather_data['current']['condition']['text']
-        wind_mph = weather_data['current']['wind_mph']
-        humidity = weather_data['current']['humidity']
-        feelslike_c = weather_data['current']['feelslike_c']
-
-        # Formulate the sentences
-        weather_sentences = (
-            f"The current weather in {location}, {region}, {country} is {condition_text} "
-            f"with a temperature of {temperature_c}°C that feels like {feelslike_c}°C. "
-            f"Humidity is at {humidity}%. "
-            f"Wind speed is {wind_mph} mph."
-        )
-        return weather_sentences
-    else:
-        # Handle errors
-        return f"Failed to get weather data: {response.status_code}, {response.text}"
-
-
-
-#weather forecast API
-def get_forecast(city_name:str= "", when = 0, **kwargs):
-    """
-    Returns the weather forecast in a specified number of days for a specified city .
-    Args:
-    city_name (string) : Required. The name of the city.
-    when (int) : Required. in number of days (until the day for which we want to know the forecast) (example: tomorrow is 1, in two days is 2, etc.)
-    """
-    #print(when)
-    when +=1
-    # The endpoint URL provided by WeatherAPI
-    url = f"http://api.weatherapi.com/v1/forecast.json?key={WEATHER_API_KEY}&q={city_name}&days={str(when)}&aqi=no"
-
-
-    # Make the API request
-    response = requests.get(url)
-
-    if response.status_code == 200:
-        # Parse the JSON response
-        data = response.json()
-        
-        # Initialize an empty string to hold our result
-        forecast_sentences = ""
-
-        # Extract city information
-        location = data.get('location', {})
-        city_name = location.get('name', 'the specified location')
-        
-        #print(data)
-    
-
-        # Extract the forecast days
-        forecast_days = data.get('forecast', {}).get('forecastday', [])[when-1:]
-        #number = 0
-        
-        #print (forecast_days)
-
-        for day in forecast_days:
-            date = day.get('date', 'a specific day')
-            conditions = day.get('day', {}).get('condition', {}).get('text', 'weather conditions')
-            max_temp_c = day.get('day', {}).get('maxtemp_c', 'N/A')
-            min_temp_c = day.get('day', {}).get('mintemp_c', 'N/A')
-            chance_of_rain = day.get('day', {}).get('daily_chance_of_rain', 'N/A')
-            
-            if when == 1:
-                number_str = 'today'
-            elif when == 2:
-                number_str = 'tomorrow'
-            else:
-                number_str = f'in {when-1} days'
-
-            # Generate a sentence for the day's forecast
-            forecast_sentence = f"On {date} ({number_str}) in {city_name}, the weather will be {conditions} with a high of {max_temp_c}°C and a low of {min_temp_c}°C. There's a {chance_of_rain}% chance of rain. "
-            
-            #number = number + 1
-            # Add the sentence to the result
-            forecast_sentences += forecast_sentence
-        return forecast_sentences
-    else:
-        # Handle errors
-        print( f"Failed to get weather data: {response.status_code}, {response.text}")
-        return f'error {response.status_code}'
-    
 

car_assistant_slim.ipynb

@@ -19,13 +19,11 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/opt/conda/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
       "  _torch_pytree._register_pytree_node(\n",
-      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
       "  _torch_pytree._register_pytree_node(\n",
-      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
       "  _torch_pytree._register_pytree_node(\n"
      ]
     }
@@ -116,21 +114,35 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+      "preprocessor_config.json: 100%|██████████| 185k/185k [00:00<00:00, 94.3MB/s]\n",
+      "tokenizer_config.json: 100%|██████████| 283k/283k [00:00<00:00, 1.05MB/s]\n",
+      "vocab.json: 100%|██████████| 836k/836k [00:00<00:00, 3.03MB/s]\n",
+      "tokenizer.json: 100%|██████████| 2.48M/2.48M [00:00<00:00, 50.6MB/s]\n",
+      "merges.txt: 100%|██████████| 494k/494k [00:00<00:00, 28.8MB/s]\n",
+      "normalizer.json: 100%|██████████| 52.7k/52.7k [00:00<00:00, 67.8MB/s]\n",
+      "added_tokens.json: 100%|██████████| 34.6k/34.6k [00:00<00:00, 38.7MB/s]\n",
+      "special_tokens_map.json: 100%|██████████| 2.19k/2.19k [00:00<00:00, 8.88MB/s]\n",
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n",
+      "config.json: 100%|██████████| 1.97k/1.97k [00:00<00:00, 4.46MB/s]\n",
+      "model.safetensors: 100%|██████████| 967M/967M [00:12<00:00, 74.9MB/s] \n",
+      "generation_config.json: 100%|██████████| 3.87k/3.87k [00:00<00:00, 39.0MB/s]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " > tts_models/multilingual/multi-dataset/xtts_v1.1 is already downloaded.\n"
+      " > Downloading model to /Users/sasan.jafarnejad/Library/Application Support/tts/tts_models--multilingual--multi-dataset--xtts_v1.1\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "100%|██████████| 1.87G/1.87G [00:24<00:00, 75.6MiB/s]\n",
+      "100%|██████████| 4.70k/4.70k [00:00<00:00, 17.9kiB/s]\n",
+      "100%|██████████| 294k/294k [00:00<00:00, 1.23MiB/s]\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
       "  _torch_pytree._register_pytree_node(\n"
      ]
     },
@@ -138,6 +150,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      " > Model's license - CPML\n",
+      " > Check https://coqui.ai/cpml.txt for more info.\n",
       " > Using model: xtts\n"
      ]
     }
@@ -160,7 +174,20 @@
     "collapsed": true,
     "id": "JNALTDb0LT90"
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "config.json: 100%|█████████��| 1.42k/1.42k [00:00<00:00, 3.24MB/s]\n",
+      "model.safetensors: 100%|██████████| 1.11G/1.11G [00:13<00:00, 79.5MB/s]\n",
+      "tokenizer_config.json: 100%|██████████| 502/502 [00:00<00:00, 5.01MB/s]\n",
+      "sentencepiece.bpe.model: 100%|██████████| 5.07M/5.07M [00:00<00:00, 78.4MB/s]\n",
+      "tokenizer.json: 100%|██████████| 9.08M/9.08M [00:00<00:00, 61.5MB/s]\n",
+      "special_tokens_map.json: 100%|██████████| 239/239 [00:00<00:00, 372kB/s]\n"
+     ]
+    }
+   ],
    "source": [
     "#load model language recognition\n",
     "model_ckpt = \"papluca/xlm-roberta-base-language-detection\"\n",
@@ -183,8 +210,10 @@
    "source": [
     "#load model llama2\n",
     "mn = 'stabilityai/StableBeluga-7B' #mn = \"TheBloke/Llama-2-7b-Chat-GPTQ\" --> other possibility \n",
-    "model = AutoModelForCausalLM.from_pretrained(mn, device_map=0, load_in_4bit=True) #torch_dtype=torch.float16\n",
-    "tokr = AutoTokenizer.from_pretrained(mn, load_in_4bit=True) #tokenizer"
+    "# model = AutoModelForCausalLM.from_pretrained(mn, device_map=0, load_in_4bit=True) #torch_dtype=torch.float16\n",
+    "model = AutoModelForCausalLM.from_pretrained(mn, device_map=0) #torch_dtype=torch.float16\n",
+    "# tokr = AutoTokenizer.from_pretrained(mn, load_in_4bit=True) #tokenizer\n",
+    "tokr = AutoTokenizer.from_pretrained(mn) #tokenizer"
    ]
   },
   {
@@ -881,7 +910,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.11.8"
   }
  },
  "nbformat": 4,

core/__init__.py

@@ -0,0 +1,199 @@
+import os
+from collections import namedtuple
+import time
+import pathlib
+from typing import List
+
+import numpy as np
+import torch
+from TTS.api import TTS
+
+os.environ["COQUI_TOS_AGREED"] = "1"
+
+
+Voice = namedtuple("voice", ["name", "neutral", "angry", "speed"])
+
+file_full_path = pathlib.Path(os.path.realpath(__file__)).parent
+
+voices = [
+    Voice(
+        "Attenborough",
+        neutral=f"{file_full_path}/audio/attenborough/neutral.wav",
+        angry=None,
+        speed=1.1,
+    ),
+    Voice(
+        "Rick",
+        neutral=f"{file_full_path}/audio/rick/neutral.wav",
+        angry=None,
+        speed=1.1,
+    ),
+    Voice(
+        "Freeman",
+        neutral=f"{file_full_path}/audio/freeman/neutral.wav",
+        angry="audio/freeman/angry.wav",
+        speed=1.1,
+    ),
+    Voice(
+        "Walken",
+        neutral=f"{file_full_path}/audio/walken/neutral.wav",
+        angry=None,
+        speed=1.1,
+    ),
+    Voice(
+        "Darth Wader",
+        neutral=f"{file_full_path}/audio/darth/neutral.wav",
+        angry=None,
+        speed=1.1,
+    ),
+]
+
+
+def load_tts_pipeline():
+    # load model for text to speech
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    # device = "mps"
+    tts_pipeline = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
+    return tts_pipeline
+
+
+def compute_speaker_embedding(voice_path: str, config, pipeline, cache):
+    if voice_path not in cache:
+        cache[voice_path] = pipeline.synthesizer.tts_model.get_conditioning_latents(
+            audio_path=voice_path,
+            gpt_cond_len=config.gpt_cond_len,
+            gpt_cond_chunk_len=config.gpt_cond_chunk_len,
+            max_ref_length=config.max_ref_len,
+            sound_norm_refs=config.sound_norm_refs,
+        )
+    return cache[voice_path]
+
+
+voice_options = []
+for voice in voices:
+    if voice.neutral:
+        voice_options.append(f"{voice.name} - Neutral")
+    if voice.angry:
+        voice_options.append(f"{voice.name} - Angry")
+
+
+def voice_from_text(voice):
+    for v in voices:
+        if voice == f"{v.name} - Neutral":
+            return v.neutral
+        if voice == f"{v.name} - Angry":
+            return v.angry
+    raise ValueError(f"Voice {voice} not found.")
+
+
+def speed_from_text(voice):
+    for v in voices:
+        if voice == f"{v.name} - Neutral":
+            return v.speed
+        if voice == f"{v.name} - Angry":
+            return v.speed
+
+
+def tts(
+    self,
+    text: str = "",
+    language_name: str = "",
+    reference_wav=None,
+    gpt_cond_latent=None,
+    speaker_embedding=None,
+    split_sentences: bool = True,
+    **kwargs,
+) -> List[int]:
+    """🐸 TTS magic. Run all the models and generate speech.
+
+    Args:
+        text (str): input text.
+        speaker_name (str, optional): speaker id for multi-speaker models. Defaults to "".
+        language_name (str, optional): language id for multi-language models. Defaults to "".
+        speaker_wav (Union[str, List[str]], optional): path to the speaker wav for voice cloning. Defaults to None.
+        style_wav ([type], optional): style waveform for GST. Defaults to None.
+        style_text ([type], optional): transcription of style_wav for Capacitron. Defaults to None.
+        reference_wav ([type], optional): reference waveform for voice conversion. Defaults to None.
+        reference_speaker_name ([type], optional): speaker id of reference waveform. Defaults to None.
+        split_sentences (bool, optional): split the input text into sentences. Defaults to True.
+        **kwargs: additional arguments to pass to the TTS model.
+    Returns:
+        List[int]: [description]
+    """
+    start_time = time.time()
+    use_gl = self.vocoder_model is None
+    wavs = []
+
+    if not text and not reference_wav:
+        raise ValueError(
+            "You need to define either `text` (for sythesis) or a `reference_wav` (for voice conversion) to use the Coqui TTS API."
+        )
+
+    if text:
+        sens = [text]
+        if split_sentences:
+            print(" > Text splitted to sentences.")
+            sens = self.split_into_sentences(text)
+        print(sens)
+
+    if not reference_wav:  # not voice conversion
+        for sen in sens:
+            outputs = self.tts_model.inference(
+                sen,
+                language_name,
+                gpt_cond_latent,
+                speaker_embedding,
+                # GPT inference
+                temperature=0.75,
+                length_penalty=1.0,
+                repetition_penalty=10.0,
+                top_k=50,
+                top_p=0.85,
+                do_sample=True,
+                **kwargs,
+            )
+            waveform = outputs["wav"]
+            if (
+                torch.is_tensor(waveform)
+                and waveform.device != torch.device("cpu")
+                and not use_gl
+            ):
+                waveform = waveform.cpu()
+            if not use_gl:
+                waveform = waveform.numpy()
+            waveform = waveform.squeeze()
+
+            # # trim silence
+            # if (
+            #     "do_trim_silence" in self.tts_config.audio
+            #     and self.tts_config.audio["do_trim_silence"]
+            # ):
+            #     waveform = trim_silence(waveform, self.tts_model.ap)
+
+            wavs += list(waveform)
+            wavs += [0] * 10000
+
+    # compute stats
+    process_time = time.time() - start_time
+    audio_time = len(wavs) / self.tts_config.audio["sample_rate"]
+    print(f" > Processing time: {process_time}")
+    print(f" > Real-time factor: {process_time / audio_time}")
+    return wavs
+
+
+def tts_gradio(tts_pipeline, text, voice, cache):
+    voice_path = voice_from_text(voice)
+    (gpt_cond_latent, speaker_embedding) = compute_speaker_embedding(
+        voice_path, tts_pipeline.synthesizer.tts_config, tts_pipeline, cache
+    )
+    out = tts(
+        tts_pipeline.synthesizer,
+        text,
+        language_name="en",
+        speaker=None,
+        gpt_cond_latent=gpt_cond_latent,
+        speaker_embedding=speaker_embedding,
+        speed=1.1,
+        # file_path="out.wav",
+    )
+    return (22050, np.array(out)), dict(text=text, voice=voice)

kitt.py

@@ -0,0 +1,331 @@
+import time
+import gradio as gr
+import numpy as np
+import requests
+import torch
+import torchaudio
+from transformers import pipeline
+
+
+
+import skills
+from skills.common import config, vehicle
+from skills.routing import calculate_route
+import ollama
+
+### LLM Stuff ###
+from langchain_community.llms import Ollama
+from langchain.tools.base import StructuredTool
+
+from skills import (
+    get_weather,
+    find_route,
+    get_forecast,
+    vehicle_status as vehicle_status_fn,
+    search_points_of_interests,
+    search_along_route_w_coordinates,
+    do_anything_else,
+    date_time_info
+)
+from skills import extract_func_args
+from core import voice_options, load_tts_pipeline, tts_gradio
+
+
+global_context = {
+    "vehicle": vehicle,
+    "query": "How is the weather?",
+    "route_points": [],
+}
+
+speaker_embedding_cache = {}
+
+MODEL_FUNC = "nexusraven"
+MODEL_GENERAL = "llama3:instruct"
+
+RAVEN_PROMPT_FUNC = """You are a helpful AI assistant in a car (vehicle), that follows instructions extremely well. \
+Answer questions concisely and do not mention what you base your reply on."
+
+{raven_tools}
+
+{history}
+
+User Query: Question: {input}<human_end>
+"""
+
+def get_prompt(template, input, history, tools):
+    # "vehicle_status": vehicle_status_fn()[0]
+    kwargs = {"history": history, "input": input}
+    prompt = "<human>:\n"
+    for tool in tools:
+        func_signature, func_docstring = tool.description.split(" - ", 1)
+        prompt += f'Function:\n<func_start>def {func_signature}<func_end>\n<docstring_start>\n"""\n{func_docstring}\n"""\n<docstring_end>\n'
+    kwargs["raven_tools"] = prompt
+
+    if history:
+        kwargs["history"] = f"Previous conversation history:{history}\n"
+
+    return template.format(**kwargs).replace("{{", "{").replace("}}", "}")
+
+def use_tool(func_name, kwargs, tools):
+    for tool in tools:
+        if tool.name == func_name:
+            return tool.invoke(input=kwargs)
+    return None
+
+# llm = Ollama(model="nexusraven", stop=["\nReflection:", "\nThought:"], keep_alive=60*10)
+
+
+# Generate options for hours (00-23)
+hour_options = [f"{i:02d}:00:00" for i in range(24)]
+
+
+def search_along_route(query=""):
+    """Search for points of interest along the route/way to the destination.
+
+    Args:
+        query (str, optional): The type of point of interest to search for. Defaults to "restaurant".
+    
+    """
+    points = global_context["route_points"]
+    # maybe reshape
+    return search_along_route_w_coordinates(points, query)
+
+
+def set_time(time_picker):
+    vehicle.time = time_picker
+    return vehicle.model_dump_json()
+
+
+def get_vehicle_status(state):
+    return state.value["vehicle"].model_dump_json()
+
+
+tools = [
+    StructuredTool.from_function(get_weather),
+    StructuredTool.from_function(find_route),
+    # StructuredTool.from_function(vehicle_status),
+    StructuredTool.from_function(search_points_of_interests),
+    StructuredTool.from_function(search_along_route),
+    StructuredTool.from_function(date_time_info),
+    StructuredTool.from_function(do_anything_else),
+]
+
+
+def run_generic_model(query):
+    print(f"Running the generic model with query: {query}")
+    data = {
+        "prompt": f"Answer the question below in a short and concise manner.\n{query}",
+        "model": MODEL_GENERAL,
+        "options": {
+            # "temperature": 0.1,
+            # "stop":["\nReflection:", "\nThought:"]
+        }
+    }
+    out = ollama.generate(**data)
+    return out["response"]
+
+
+def run_model(query, voice_character):
+    query = query.strip().replace("'", "")
+    print("Query: ", query)
+    global_context["query"] = query
+    global_context["prompt"] = get_prompt(RAVEN_PROMPT_FUNC, query, "", tools)
+    print("Prompt: ", global_context["prompt"])
+    data = {
+        "prompt": global_context["prompt"],
+        # "streaming": False,
+        "model": "nexusraven",
+        # "model": "smangrul/llama-3-8b-instruct-function-calling",
+        "raw": True,
+        "options": {
+            "temperature": 0.5,
+            "stop":["\nReflection:", "\nThought:"]
+        }
+    }
+    out = ollama.generate(**data)
+    llm_response = out["response"]
+    if "Call: " in llm_response:
+        print(f"llm_response: {llm_response}")
+        llm_response = llm_response.replace("<bot_end>"," ")
+        func_name, kwargs = extract_func_args(llm_response)
+        print(f"Function: {func_name}, Args: {kwargs}")
+        if func_name == "do_anything_else":
+            output_text = run_generic_model(query)
+        else:
+            output_text = use_tool(func_name, kwargs, tools)
+    else:
+        output_text = out["response"]
+
+    if type(output_text) == tuple:
+        output_text = output_text[0]
+    gr.Info(f"Output text: {output_text}, generating voice output...")
+    return output_text, tts_gradio(tts_pipeline, output_text, voice_character, speaker_embedding_cache)[0]
+
+
+def calculate_route_gradio(origin, destination):
+    plot, vehicle_status, points = calculate_route(origin, destination)
+    global_context["route_points"] = points
+    vehicle.location_coordinates = points[0]["latitude"], points[0]["longitude"]
+    return plot, vehicle_status
+
+
+def update_vehicle_status(trip_progress):
+    n_points = len(global_context["route_points"])
+    new_coords = global_context["route_points"][min(int(trip_progress / 100 * n_points), n_points - 1)]
+    new_coords = new_coords["latitude"], new_coords["longitude"]
+    print(f"Trip progress: {trip_progress}, len: {n_points}, new_coords: {new_coords}")
+    vehicle.location_coordinates = new_coords
+    vehicle.location = ""
+    return vehicle.model_dump_json()
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en", device=device)
+
+
+def save_audio_as_wav(data, sample_rate, file_path):
+    # make a tensor from the numpy array
+    data = torch.tensor(data).reshape(1, -1)
+    torchaudio.save(file_path, data, sample_rate=sample_rate, bits_per_sample=16, encoding="PCM_S")
+
+
+def save_and_transcribe_audio(audio):
+    try:
+        # capture the audio and save it to a file as wav or mp3
+        # file_name = save("audioinput.wav")
+        sr, y = audio
+        # y = y.astype(np.float32)
+        # y /= np.max(np.abs(y))
+
+        # add timestamp to file name
+        filename = f"recordings/audio{time.time()}.wav"
+        save_audio_as_wav(y, sr, filename)
+        
+        sr, y = audio
+        y = y.astype(np.float32)
+        y /= np.max(np.abs(y))
+        text = transcriber({"sampling_rate": sr, "raw":y})["text"]
+    except Exception as e:
+        print(f"Error: {e}")
+        return "Error transcribing audio"
+    return text
+
+# to be able to use the microphone on chrome, you will have to go to chrome://flags/#unsafely-treat-insecure-origin-as-secure and enter http://10.186.115.21:7860/
+# in "Insecure origins treated as secure", enable it and relaunch chrome
+
+# example question:
+# what's the weather like outside?
+# What's the closest restaurant from here?
+
+
+tts_pipeline = load_tts_pipeline()
+
+
+with gr.Blocks(theme=gr.themes.Default()) as demo:
+    state = gr.State(
+        value={
+            # "context": initial_context,
+            "query": "",
+            "route_points": [],
+        }
+    )
+    trip_points = gr.State(value=[])
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=300):
+            time_picker = gr.Dropdown(
+                choices=hour_options,
+                label="What time is it? (HH:MM)",
+                value="08:00:00",
+                interactive=True,
+            )
+            history = gr.Radio(
+                ["Yes", "No"],
+                label="Maintain the conversation history?",
+                value="No",
+                interactive=True,
+            )
+            voice_character = gr.Radio(choices=voice_options, label='Choose a voice', value=voice_options[0], show_label=True)
+            origin = gr.Textbox(
+                value="Mondorf-les-Bains, Luxembourg", label="Origin", interactive=True
+            )
+            destination = gr.Textbox(
+                value="Rue Alphonse Weicker, Luxembourg",
+                label="Destination",
+                interactive=True,
+            )
+
+        with gr.Column(scale=2, min_width=600):
+            map_plot = gr.Plot()
+            trip_progress = gr.Slider(0, 100, step=5, label="Trip progress", interactive=True)
+
+            # map_if = gr.Interface(fn=plot_map, inputs=year_input, outputs=map_plot)
+
+    with gr.Row():
+        with gr.Column():
+            input_audio = gr.Audio(
+                type="numpy",sources=["microphone"], label="Input audio", elem_id="input_audio"
+            )
+            input_text = gr.Textbox(
+                value="How is the weather?", label="Input text", interactive=True
+            )
+            vehicle_status = gr.JSON(
+                value=vehicle.model_dump_json(), label="Vehicle status"
+            )
+        with gr.Column():
+            output_audio = gr.Audio(label="output audio", autoplay=True)
+            output_text = gr.TextArea(value="", label="Output text", interactive=False)
+    # iface = gr.Interface(
+    #     fn=transcript,
+    #     inputs=[
+    #         gr.Textbox(value=initial_context, visible=False),
+    #         gr.Audio(type="filepath", label="input audio", elem_id="recorder"),
+    #         voice_character,
+    #         emotion,
+    #         place,
+    #         time_picker,
+    #         history,
+    #         gr.State(),  # This will keep track of the context state across interactions.
+    #     ],
+    #     outputs=[gr.Audio(label="output audio"), gr.Textbox(visible=False), gr.State()],
+    #     head=shortcut_js,
+    # )
+
+    # Update plot based on the origin and destination
+    # Sets the current location and destination
+    origin.submit(
+        fn=calculate_route_gradio,
+        inputs=[origin, destination],
+        outputs=[map_plot, vehicle_status],
+    )
+    destination.submit(
+        fn=calculate_route_gradio,
+        inputs=[origin, destination],
+        outputs=[map_plot, vehicle_status],
+    )
+
+    # Update time based on the time picker
+    time_picker.select(fn=set_time, inputs=[time_picker], outputs=[vehicle_status])
+
+    # Run the model if the input text is changed
+    input_text.submit(fn=run_model, inputs=[input_text, voice_character], outputs=[output_text, output_audio])
+
+    # Set the vehicle status based on the trip progress
+    trip_progress.release(
+        fn=update_vehicle_status, inputs=[trip_progress], outputs=[vehicle_status]
+    )
+
+    # Save and transcribe the audio
+    input_audio.stop_recording(
+        fn=save_and_transcribe_audio, inputs=[input_audio], outputs=[input_text]
+    )
+
+# close all interfaces open to make the port available
+gr.close_all()
+# Launch the interface.
+
+if __name__ == "__main__":
+    # demo.launch(debug=True, server_name="0.0.0.0", server_port=7860, ssl_verify=False)
+    demo.launch(debug=True, server_name="0.0.0.0", server_port=7860, ssl_verify=True, share=True)
+
+# iface.launch(debug=True, share=False, server_name="0.0.0.0", server_port=7860, ssl_verify=False)

requirements.txt

@@ -1,11 +1,12 @@
 torch
 torchvision
+torchaudio
 matplotlib
 wurlitzer
 accelerate
 bitsandbytes
 optimum
-auto-gptq
+# auto-gptq
 gradio
 TTS
 transformers==4.36
@@ -14,4 +15,8 @@ openai-whisper
 geopy
 langchain
 text_generation
-python-dotenv
+python-dotenv
+pydantic-settings
+ollama
+langchain
+plotly-express

skills/__init__.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+import inspect
+
+from .common import execute_function_call, extract_func_args, vehicle as vehicle_obj
+from .weather import get_weather, get_forecast
+from .routing import find_route
+from .poi import search_points_of_interests, search_along_route_w_coordinates
+from .vehicle import vehicle_status
+
+
+
+def date_time_info():
+    """Get the current date and time."""
+    time = getattr(vehicle_obj, "time")
+    date = getattr(vehicle_obj, "date")
+    datetime_obj = datetime.fromisoformat(f"{date}T{time}")
+    human_readable_datetime = datetime_obj.strftime("%I:%M %p %A, %B %d, %Y")
+    return f"It is {human_readable_datetime}."
+
+
+def do_anything_else():
+    """If the user wants to do anything else call this function. If the question doesn't match any of the functions use this one."""
+    return True
+
+
+
+def format_functions_for_prompt_raven(*functions):
+    """Format functions for use in Prompt Raven.
+    
+    Args:
+    *functions (function): One or more functions to format.
+    """
+    formatted_functions = []
+    for func in functions:
+        signature = f"{func.__name__}{inspect.signature(func)}"
+        docstring = inspect.getdoc(func)
+        formatted_functions.append(
+            f"Function:\n<func_start>{signature}<func_end>\n<docstring_start>\n{docstring}\n<docstring_end>"
+        )
+    return "\n".join(formatted_functions)
+
+
+SKILLS_PROMPT = format_functions_for_prompt_raven(get_weather, get_forecast, find_route, search_points_of_interests)

skills/common.py

@@ -0,0 +1,62 @@
+import re
+from typing import Union
+
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import BaseModel
+
+import skills
+
+class Settings(BaseSettings):
+    WEATHER_API_KEY: str
+    TOMTOM_API_KEY: str
+
+    model_config = SettingsConfigDict(env_file=".env")
+
+
+class VehicleStatus(BaseModel):
+    location: str
+    location_coordinates: tuple[float, float] # (latitude, longitude)
+    date: str
+    time: str
+    destination: str
+
+
+def execute_function_call(text: str, dry_run=False) -> str:
+    function_name_match = re.search(r"Call: (\w+)", text)
+    function_name = function_name_match.group(1) if function_name_match else None
+    arguments = eval(f"dict{text.split(function_name)[1].strip()}")
+    function = getattr(skills, function_name) if function_name else None
+
+    if dry_run:
+        print(f"{function_name}(**{arguments})")
+        return "Dry run successful"
+
+    if function:
+        out = function(**arguments)
+    try:
+        if function:
+            out = function(**arguments)
+    except Exception as e:
+        out = str(e)
+    return out
+
+
+def extract_func_args(text: str) -> tuple[str, dict]:
+    function_name_match = re.search(r"Call: (\w+)", text)
+    function_name = function_name_match.group(1) if function_name_match else None
+    if not function_name:
+        raise ValueError("No function name found in text")
+    arguments = eval(f"dict{text.split(function_name)[1].strip()}")
+    return function_name, arguments
+
+
+config = Settings() # type: ignore
+
+vehicle = VehicleStatus(
+    location="Rue Alphonse Weicker, Luxembourg",
+    location_coordinates=(49.505, 6.28111),
+    date="2025-05-06",
+    time="08:00:00",
+    destination="Rue Alphonse Weicker, Luxembourg"
+)

skills/poi.py

@@ -0,0 +1,143 @@
+import json
+import requests
+from .common import config, vehicle
+
+
+# Select coordinates at equal distance, including the last one
+def select_equally_spaced_coordinates(coords, number_of_points=10):
+    n = len(coords)
+    selected_coords = []
+    interval = max((n - 1) / (number_of_points - 1), 1)
+    for i in range(number_of_points):
+        # Calculate the index, ensuring it doesn't exceed the bounds of the list
+        index = int(round(i * interval))
+        if index < n:
+            selected_coords.append(coords[index])
+    return selected_coords
+
+
+def search_points_of_interests(search_query="french restaurant"):
+    """
+    Return some of the closest points of interest matching the query.
+    :param search_query (string): Required. Describing the type of point of interest depending on what the user wants to do. Make sure to include the type of POI you are looking for. For example italian restaurant, grocery shop, etc.
+    """
+
+    # Extract the latitude and longitude of the vehicle
+    vehicle_coordinates = getattr(vehicle, "location_coordinates")
+    lat, lon = vehicle_coordinates
+    print(f"POI search vehicle's lat: {lat}, lon: {lon}")
+
+    # https://developer.tomtom.com/search-api/documentation/search-service/search
+    r = requests.get(
+        f"https://api.tomtom.com/search/2/search/{search_query}.json?key={config.TOMTOM_API_KEY}&lat={lat}&lon={lon}&category&radius=1000&limit=100",
+        timeout=5,
+    )
+
+    # Parse JSON from the response
+    data = r.json()
+    # Extract results
+    results = data["results"]
+
+    # TODO: Handle the no results case.
+    if not results:
+        return "No results found in the vicinity."
+
+    # Sort the results based on distance
+    results = sorted(results, key=lambda x: x["dist"])
+    # print(sorted_results)
+
+    # Format and limit to top 5 results
+    formatted_results = [
+        f"{result['poi']['name']}, {int(result['dist'])} meters away"
+        for result in results[:3]
+    ]
+
+    output = (
+        f"There are {len(results)} options in the vicinity. The most relevant are: "
+    )
+    return output + ".\n ".join(formatted_results)
+
+
+def find_points_of_interest(lat="0", lon="0", type_of_poi="restaurant"):
+    """
+    Return some of the closest points of interest for a specific location and type of point of interest. The more parameters there are, the more precise.
+    :param lat (string):  latitude
+    :param lon (string):  longitude
+    :param city (string): Required. city
+    :param type_of_poi (string): Required. type of point of interest depending on what the user wants to do.
+    """
+    # https://developer.tomtom.com/search-api/documentation/search-service/points-of-interest-search
+    r = requests.get(
+        f"https://api.tomtom.com/search/2/search/{type_of_poi}"
+        ".json?key={0}&lat={1}&lon={2}&radius=10000&vehicleTypeSet=Car&idxSet=POI&limit=100".format(
+            config.TOMTOM_API_KEY, lat, lon
+        )
+    )
+
+    # Parse JSON from the response
+    data = r.json()
+    # print(data)
+    # Extract results
+    results = data["results"]
+
+    # Sort the results based on distance
+    sorted_results = sorted(results, key=lambda x: x["dist"])
+    # print(sorted_results)
+
+    # Format and limit to top 5 results
+    formatted_results = [
+        f"The {type_of_poi} {result['poi']['name']}, {int(result['dist'])} meters away"
+        for result in sorted_results[:5]
+    ]
+
+    return ". ".join(formatted_results)
+
+
+def search_along_route_w_coordinates(points: list[tuple[float, float]], query: str):
+    """
+    Return some of the closest points of interest along the route/way from the depart point, specified by its coordinates.
+    :param points (list[tuple(float, float)]): Required. List of tuples of latitude and longitude of the points along the route.
+    :param query (string): Required. type of point of interest depending on what the user wants to do.
+    """
+
+    # The API endpoint for searching along a route
+    url = f"https://api.tomtom.com/search/2/searchAlongRoute/{query}.json?key={config.TOMTOM_API_KEY}&maxDetourTime=360&limit=20&sortBy=detourTime"
+
+    points = select_equally_spaced_coordinates(points, number_of_points=20)
+
+    # The data payload
+    payload = {
+        "route": {
+            "points": [{"lat": pt["latitude"], "lon": pt["longitude"]} for pt in points]
+        }
+    }
+
+    # Make the POST request
+    response = requests.post(url, json=payload, timeout=5)
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        # Parse the JSON response
+        data = response.json()
+        # print(json.dumps(data, indent=4))
+    else:
+        print("Failed to retrieve data:", response.status_code)
+        return "Failed to retrieve data. Please try again."
+    answer = ""
+    if not data["results"]:
+        return "No results found along the way."
+
+    if len(data["results"]) == 20:
+        answer = "There more than 20 results along the way. Here are the top 3 results:"
+    elif len(data["results"]) > 3:
+        answer = f"There are {len(data['results'])} results along the way. Here are the top 3 results:"
+    for result in data["results"][:3]:
+        name = result["poi"]["name"]
+        address = result["address"]["freeformAddress"]
+        detour_time = result["detourTime"]
+        answer = (
+            answer
+            + f" \n{name} at {address} would require a detour of {int(detour_time/60)} minutes."
+        )
+
+    return answer

skills/routing.py

@@ -0,0 +1,167 @@
+from datetime import datetime
+import requests
+from .common import config, vehicle
+
+
+def find_coordinates(address):
+    """
+    Find the coordinates of a specific address.
+    :param address (string): Required. The address
+    """
+    # https://developer.tomtom.com/geocoding-api/documentation/geocode
+    url = f"https://api.tomtom.com/search/2/geocode/{address}.json?key={config.TOMTOM_API_KEY}"
+    response = requests.get(url)
+    data = response.json()
+    lat = data["results"][0]["position"]["lat"]
+    lon = data["results"][0]["position"]["lon"]
+    return lat, lon
+
+
+def plot_route(points):
+    import plotly.express as px
+
+    lats = []
+    lons = []
+
+    for point in points:
+        lats.append(point["latitude"])
+        lons.append(point["longitude"])
+    # fig = px.line_geo(lat=lats, lon=lons)
+    # fig.update_geos(fitbounds="locations")
+
+    fig = px.line_mapbox(
+        lat=lats, lon=lons, zoom=12, height=600, color_discrete_sequence=["red"]
+    )
+
+    fig.update_layout(
+        mapbox_style="open-street-map",
+        # mapbox_zoom=12,
+    )
+    fig.update_geos(fitbounds="locations")
+    fig.update_layout(margin={"r": 20, "t": 20, "l": 20, "b": 20})
+    return fig
+
+
+def calculate_route(origin, destination):
+    """This function is called when the origin or destination is updated in the GUI. It calculates the route between the origin and destination."""
+    print(f"calculate_route(origin: {origin}, destination: {destination})")
+    origin_coords = find_coordinates(origin)
+    destination_coords = find_coordinates(destination)
+
+    orig_coords_str = ",".join(map(str, origin_coords))
+    dest_coords_str = ",".join(map(str, destination_coords))
+    print(f"origin_coords: {origin_coords}, destination_coords: {destination_coords}")
+
+    vehicle.destination = destination
+    vehicle.location_coordinates = origin_coords
+    vehicle.location = origin
+
+    # origin = "49.631997,6.171029"
+    # destination = "49.586745,6.140002"
+
+    url = f"https://api.tomtom.com/routing/1/calculateRoute/{orig_coords_str}:{dest_coords_str}/json?key={config.TOMTOM_API_KEY}"
+    response = requests.get(url)
+    data = response.json()
+    points = data["routes"][0]["legs"][0]["points"]
+
+    return plot_route(points), vehicle.model_dump_json(), points
+
+
+def find_route_tomtom(
+    lat_depart="0",
+    lon_depart="0",
+    lat_dest="0",
+    lon_dest="0",
+    depart_datetime="",
+    **kwargs,
+):
+    """
+    Return the distance and the estimated time to go to a specific destination from the current place, at a specified depart time.
+    :param lat_depart (string):  latitude of depart
+    :param lon_depart (string):  longitude of depart
+    :param lat_dest (string):  latitude of destination
+    :param lon_dest (string):  longitude of destination
+    :param depart_time (string):  departure hour, in the format '08:00:20'.
+    """
+    # https://developer.tomtom.com/routing-api/documentation/routing/calculate-route
+    # https://developer.tomtom.com/routing-api/documentation/routing/guidance-instructions
+    url = f"https://api.tomtom.com/routing/1/calculateRoute/{lat_depart},{lon_depart}:{lat_dest},{lon_dest}/json?key={config.TOMTOM_API_KEY}&departAt={depart_datetime}"
+
+    print(f"Calling TomTom API: {url}")
+    r = requests.get(
+        url,
+        timeout=5,
+    )
+
+    # Parse JSON from the response
+    response = r.json()
+
+    try:
+        result = response["routes"][0]["summary"]
+    except KeyError:
+        print(f"Failed to find a route: {response}")
+        return "Failed to find a route", response
+
+    distance_m = result["lengthInMeters"]
+    duration_s = result["travelTimeInSeconds"]
+    arrival_time = result["arrivalTime"]
+    # Convert string to datetime object
+    arrival_time = datetime.fromisoformat(arrival_time)
+
+    return {
+        "distance_m": distance_m,
+        "duration_s": duration_s,
+        "arrival_time": arrival_time,
+    }, response
+
+
+def find_route(destination=""):
+    """This function finds a route to a destination and returns the distance and the estimated time to go to a specific destination\
+ from the current location.
+    :param destination (string): Required. The destination
+    """
+    if not destination:
+        destination = vehicle.destination
+
+    # lat, lon, city = check_city_coordinates(lat_depart,lon_depart,city_depart)
+    lat_dest, lon_dest = find_coordinates(destination)
+    print(f"lat_dest: {lat_dest}, lon_dest: {lon_dest}")
+
+    # Extract the latitude and longitude of the vehicle
+    vehicle_coordinates = getattr(vehicle, "location_coordinates")
+    lat_depart, lon_depart = vehicle_coordinates
+    print(f"lat_depart: {lat_depart}, lon_depart: {lon_depart}")
+
+    date = getattr(vehicle, "date")
+    time = getattr(vehicle, "time")
+    departure_time = f"{date}T{time}"
+
+    trip_info, raw_response = find_route_tomtom(
+        lat_depart, lon_depart, lat_dest, lon_dest, departure_time
+    )
+
+    distance, duration, arrival_time = (
+        trip_info["distance_m"],
+        trip_info["duration_s"],
+        trip_info["arrival_time"],
+    )
+
+    # Calculate distance in kilometers (1 meter = 0.001 kilometers)
+    distance_km = distance * 0.001
+    # Calculate travel time in minutes (1 second = 1/60 minutes)
+    time_minutes = duration / 60
+    if time_minutes < 60:
+        time_display = f"{time_minutes:.0f} minutes"
+    else:
+        hours = int(time_minutes / 60)
+        minutes = int(time_minutes % 60)
+        time_display = f"{hours} hours" + (
+            f" and {minutes} minutes" if minutes > 0 else ""
+        )
+
+    # Extract and display the arrival hour in HH:MM format
+    arrival_hour_display = arrival_time.strftime("%H:%M")
+
+    # return the distance and time
+    return f"The route to {destination} is {distance_km:.2f} km which takes {time_display}. Leaving now, the arrival time is estimated at {arrival_hour_display}."
+    # raw_response["routes"][0]["legs"][0]["points"]

skills/vehicle.py

@@ -0,0 +1,35 @@
+from .common import vehicle
+
+
+STATUS_TEMPLATE = """
+We are at {location}, coordinates: {lat}, {lon},
+current time: {time}, current date: {date} and our destination is: {destination}.
+"""
+
+
+def vehicle_status() -> tuple[str, dict[str, str]]:
+    """Get current vehicle status, which includes, location, date, time, destination.
+    Call this to get the current destination or location of the car/vehicle.
+    Returns:
+        dict[str, str]: The vehicle status. For example:
+        {
+            "location": "Luxembourg Gare, Luxembourg",
+            "lat": 49.6000,
+            "lon": 6.1333,
+            "date": "2025-03-29",
+            "time": "08:00:20",
+            "destination": "Kirchberg Campus, Kirchberg"
+        }
+    """
+    # vs = {
+    #     "location": "Luxembourg Gare, Luxembourg",
+    #     "lat": 49.6000,
+    #     "lon": 6.1333,
+    #     "date": "2025-03-29",
+    #     "time": "08:00:20",
+    #     "destination": "Kirchberg Campus, Luxembourg"
+    # }
+    vs = vehicle.dict()
+    vs["lat"] = vs["location_coordinates"][0]
+    vs["lon"] = vs["location_coordinates"][1]
+    return  STATUS_TEMPLATE.format(**vs), vs

skills/weather.py

@@ -0,0 +1,113 @@
+import requests
+
+from .common import config, vehicle
+
+#current weather API
+def get_weather(location:str= ""):
+    """
+    Returns the CURRENT weather in a specified location.
+    Args:
+    location (string) : Required. The name of the location, could be a city or lat/longitude in the following format latitude,longitude (example: 37.7749,-122.4194). If the location is not specified, the function will return the weather in the current location.
+    """
+
+    if location == "":
+        print(f"get_weather: location is empty, using the vehicle location. ({vehicle.location})")
+        location = vehicle.location
+
+    # The endpoint URL provided by WeatherAPI
+    url = f"http://api.weatherapi.com/v1/current.json?key={config.WEATHER_API_KEY}&q={location}&aqi=no"
+    print(url)
+
+    # Make the API request
+    response = requests.get(url)
+
+    if response.status_code != 200:
+        print(f"Failed to get weather data: {response.status_code}, {response.text}")
+        return f"Failed to get weather data, try again", response
+
+    # Parse the JSON response
+    weather_data = response.json()
+
+    # Extracting the necessary pieces of data
+    location = weather_data['location']['name']
+    region = weather_data['location']['region']
+    country = weather_data['location']['country']
+    time = weather_data['location']['localtime']
+    temperature_c = weather_data['current']['temp_c']
+    condition_text = weather_data['current']['condition']['text']
+    if 'wind_kph' in weather_data['current']:
+        wind_kph = weather_data['current']['wind_kph']
+    humidity = weather_data['current']['humidity']
+    feelslike_c = weather_data['current']['feelslike_c']
+
+    # Formulate the sentences - {region}, {country}
+    weather_sentences = (
+        f"The current weather in {location} is {condition_text} "
+        f"with a temperature of {temperature_c}°C that feels like {feelslike_c}°C. "
+        # f"Humidity is at {humidity}%. "
+        # f"Wind speed is {wind_kph} kph." if 'wind_kph' in weather_data['current'] else ""
+    )
+    return weather_sentences, weather_data
+
+#weather forecast API
+def get_forecast(city_name:str= "", when = 0, **kwargs):
+    """
+    Returns the weather forecast in a specified number of days for a specified city .
+    Args:
+    city_name (string) : Required. The name of the city.
+    when (int) : Required. in number of days (until the day for which we want to know the forecast) (example: tomorrow is 1, in two days is 2, etc.)
+    """
+    #print(when)
+    when +=1
+    # The endpoint URL provided by WeatherAPI
+    url = f"http://api.weatherapi.com/v1/forecast.json?key={WEATHER_API_KEY}&q={city_name}&days={str(when)}&aqi=no"
+
+
+    # Make the API request
+    response = requests.get(url)
+
+    if response.status_code == 200:
+        # Parse the JSON response
+        data = response.json()
+        
+        # Initialize an empty string to hold our result
+        forecast_sentences = ""
+
+        # Extract city information
+        location = data.get('location', {})
+        city_name = location.get('name', 'the specified location')
+        
+        #print(data)
+    
+
+        # Extract the forecast days
+        forecast_days = data.get('forecast', {}).get('forecastday', [])[when-1:]
+        #number = 0
+        
+        #print (forecast_days)
+
+        for day in forecast_days:
+            date = day.get('date', 'a specific day')
+            conditions = day.get('day', {}).get('condition', {}).get('text', 'weather conditions')
+            max_temp_c = day.get('day', {}).get('maxtemp_c', 'N/A')
+            min_temp_c = day.get('day', {}).get('mintemp_c', 'N/A')
+            chance_of_rain = day.get('day', {}).get('daily_chance_of_rain', 'N/A')
+            
+            if when == 1:
+                number_str = 'today'
+            elif when == 2:
+                number_str = 'tomorrow'
+            else:
+                number_str = f'in {when-1} days'
+
+            # Generate a sentence for the day's forecast
+            forecast_sentence = f"On {date} ({number_str}) in {city_name}, the weather will be {conditions} with a high of {max_temp_c}°C and a low of {min_temp_c}°C. There's a {chance_of_rain}% chance of rain. "
+            
+            #number = number + 1
+            # Add the sentence to the result
+            forecast_sentences += forecast_sentence
+        return forecast_sentences
+    else:
+        # Handle errors
+        print( f"Failed to get weather data: {response.status_code}, {response.text}")
+        return f'error {response.status_code}'

stt.ipynb

@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "  _torch_pytree._register_pytree_node(\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "  _torch_pytree._register_pytree_node(\n",
+      "/opt/homebrew/Caskroom/miniconda/base/envs/llm/lib/python3.11/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "  _torch_pytree._register_pytree_node(\n"
+     ]
+    }
+   ],
+   "source": [
+    "#STT (speech to text)\n",
+    "from transformers import WhisperProcessor, WhisperForConditionalGeneration\n",
+    "from transformers import pipeline\n",
+    "import librosa"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load model and processor for speech-to-text\n",
+    "processor = WhisperProcessor.from_pretrained(\"openai/whisper-small\")\n",
+    "modelw = WhisperForConditionalGeneration.from_pretrained(\"openai/whisper-small\")\n",
+    "# modelw.config.forced_decoder_ids = None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+     ]
+    }
+   ],
+   "source": [
+    "transcriber = pipeline(\"automatic-speech-recognition\", model=\"openai/whisper-base.en\", device=device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "device(type='cpu')"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "transcriber.device"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "audio = \"/Users/sasan.jafarnejad/dev/uni/talking-car/audio1713724521.779008.wav\"\n",
+    "audio = \"/Users/sasan.jafarnejad/dev/uni/talking-car/audio/attenborough/neutral.wav\"\n",
+    "if type(audio) == str:\n",
+    "    link_to_audio = audio\n",
+    "    audio = torchaudio.load(link_to_audio)\n",
+    "    audio = audio[0].squeeze().numpy(), sr\n",
+    "    if len(audio[0].shape) == 2:\n",
+    "        audio = audio[0].mean(axis=0), audio[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y, sr = audio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "out = transcriber({\"sampling_rate\": sr, \"raw\":y})[\"text\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\" If you speed up time, plants begin to reveal their true nature. They're not passive organisms, as you might think, but competitive creatures every bit as aggressive as animals. They're locked in a desperate battle for light and space. They stretch and pulse as they strive to barge their way into pole position. Creepers and vines reach around for the branch or stem of another plant on which to hitch a ride. This is an assassin bug. To us, it's easy enough to spot because it moves. To its prey, that's irrelevant, because it smells like one of their number. The assassin sucks its victims dry and blues their empty husks onto its back. This one is already carrying at least 20 corpses. Its irregular shape makes it hard for other predators to spot it and makes it virtually invisible to its prey, ants. It enters this ant colony unchallenged. Its coat of ant corpses masks its own odour. To the ants, it smells like one of their own, and that's what matters. They'll even run straight over the top of it. The assassin simply takes an ant whenever it feels hungry, and the body of each victim then adds to its disguise. The giants here too. This is the Moala Moala, the sunfish. It's huge, three meters across, and addicted to lying on its side at the surface. It eats vast quantities of jellyfish. And there are not only fish from me in these waters, there are mammals. sea lions, whose ancestors originally came from the coasts of California. The Galapagos plankton is so abundant it attracts some of the biggest of all ocean mammals, humpback whales, and rivalling them in size the biggest of all fish. 20 ton whale shark. Few parts of the world's oceans can equally as Galapagos waters for sheer variety and abundance. That creature was a penguin. Penguins are ocean-goings for moose. But a few thousand years ago some of them got caught in the cold waters of the Humboldt current and were carried northwards up the coast of South America and out to the Galapagos. They could hardly have found anywhere more different from their polar home and in and the response they chain, the Emperor penguin that lives near the South Pole stands over a metre high, Galapagos penguin is now only half, and that helps a lot in the Galapagos. Small animals lose heat much faster than big ones, and the penguins have developed behavioral tricks as well. Bear feet are easily sunburnt, so they do their best to keep them covered, and some parts of the sea around the islands are quite cool. The humbalt current flowing up from the Antarctic and washing around the western parts of the archipelago is still quite chilly. So most of the penguins stay in the channel between the two westernmost island and when things get really hot, they can still cool off with the swim. They're quick to detect the slightest variation in temperature and move around to find places where an eddy might have brought a pleasing chill. The arrival of penguins must be the most unlikely event in the whole story of the colonization of the Galapagos. The existence of creatures like these so far from the nearest continent poses many questions. How, for example, did these enormous beasts get to the islands in the first place? But perhaps the most extraordinary thing about the Galapagos tortoises is that they're not all the same. islands have different kinds. In the heyday there were 15 species. They seem to have appeared in an evolutionary blink of the eye. But will soon become a leaf. It's no ordinary. It has a special altogether more sinister. This is Nepenthes, the pitcher plant. It grows in nutrient poor soils, So has to find nitrogen and minerals in another way. The leaf, just like a flower, attracts insects with a reward. The pitcher is coloured and scented to appeal to flies looking for a meal of rotting flesh. The visitors are rewarded with a greasy substance on the underside of the pitcher's lid. But the plant wants something in return, not pollen, but a meal. The lip of the pitcher is covered in tiny slippery ridges. Wax lubricates the surface further. It's extremely difficult to hold on, even for a fly. Once inside, there's no escape. The leaf holds a pool of digestive liquid. This contains microscopic elastic filaments, which give it the properties of quicksand. The more the insect struggles, the deeper it sinks. Enzymes begin to dissolve the victim's body while it's still alive.\""
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def transcript(audio):\n",
+    "    if type(audio) == str:\n",
+    "        link_to_audio = audio\n",
+    "        audio = torchaudio.load(link_to_audio)\n",
+    "\n",
+    "    # We assume that the audio is the audio tensor\n",
+    "\n",
+    "    # process the audio array\n",
+    "    input_features = processor(audio_array, sampling_rate, return_tensors=\"pt\").input_features\n",
+    "    predicted_ids = modelw.generate(input_features)\n",
+    "\n",
+    "    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)\n",
+    "    \n",
+    "    return audio_path, state['context'], state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def transcript(general_context, link_to_audio, voice, place, time, delete_history, state):\n",
+    "    \"\"\"this function manages speech-to-text to input Fnanswer function and text-to-speech with the Fnanswer output\"\"\"\n",
+    "    # load audio from a specific path\n",
+    "    audio_path = link_to_audio\n",
+    "    audio_array, sampling_rate = librosa.load(link_to_audio, sr=16000)  # \"sr=16000\" ensures that the sampling rate is as required\n",
+    "\n",
+    "    # process the audio array\n",
+    "    input_features = processor(audio_array, sampling_rate, return_tensors=\"pt\").input_features\n",
+    "    predicted_ids = modelw.generate(input_features)\n",
+    "\n",
+    "    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)\n",
+    "    \n",
+    "\n",
+    "\n",
+    "    return audio_path, state['context'], state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7875\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7875/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import gradio as gr\n",
+    "import torchaudio\n",
+    "import time\n",
+    "import torch\n",
+    "\n",
+    "def save_audio_as_wav(data, sample_rate, file_path):\n",
+    "    # make a tensor from the numpy array\n",
+    "    data = torch.tensor(data).reshape(1, -1)\n",
+    "    torchaudio.save(file_path, data, sample_rate=sample_rate, bits_per_sample=16, encoding=\"PCM_S\")\n",
+    "\n",
+    "def save_and_transcribe_audio(audio):\n",
+    "    # capture the audio and save it to a file as wav or mp3\n",
+    "    # file_name = save(\"audioinput.wav\")\n",
+    "    sr, y = audio\n",
+    "    # y = y.astype(np.float32)\n",
+    "    # y /= np.max(np.abs(y))\n",
+    "\n",
+    "    # add timestamp to file name\n",
+    "    filename = f\"audio{time.time()}.wav\"\n",
+    "    save_audio_as_wav(y, sr, filename)\n",
+    "    \n",
+    "    sr, y = audio\n",
+    "    y = y.astype(np.float32)\n",
+    "    y /= np.max(np.abs(y))\n",
+    "    text = transcriber({\"sampling_rate\": sr, \"raw\":y})[\"text\"]\n",
+    "    return text\n",
+    "\n",
+    "gr.Interface(\n",
+    "    fn=save_and_transcribe_audio, \n",
+    "    inputs=gr.Audio(sources=\"microphone\", type=\"numpy\", label=\"Record Audio\"), \n",
+    "    outputs=\"text\").launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "llm",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}