cutted 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

cutted/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "0.3.2"
+__version__ = "0.4.0"
 __author__ = "simon0302010"

cutted/app.py

@@ -25,6 +25,8 @@ class CuttedApp:
         self.canvas = None
         self.cursor_line = None
         self.last_slider_update = 0
+        self.slider_value = 0
+        self.playback_start_time = 0
         self.is_playing = False
         self.last_states = []
         self.setup_ui()
@@ -107,45 +109,54 @@ class CuttedApp:
     def update_plot(self):
         if self.canvas:
             self.canvas.get_tk_widget().destroy()
-        
+        if hasattr(self, "slider") and self.slider is not None:
+            self.slider.destroy()
+
         fig = self.AudioProcessor.plot_audio()
         self.ax = fig.axes[0]
         self.canvas = FigureCanvasTkAgg(fig, master=self.plot_frame)
         self.canvas.draw()
-        
-        self.audio_lenght = int(round(self.AudioProcessor.get_lenght()))
-        
+
+        self.audio_length = float(self.AudioProcessor.get_length())
+
         slider_width = self.root.winfo_width() - 40
+        if self.slider_value > self.audio_length:
+            self.slider_value = self.audio_length
+        if self.slider_value < 0:
+            self.slider_value = 0
+
         self.slider = customtkinter.CTkSlider(
-            self.root, from_=0, to=self.audio_lenght, command=self.set_cursor, width=slider_width
+            self.root, from_=0, to=self.audio_length, command=self.set_cursor, width=slider_width
         )
-        self.slider.set(0)
-        
+        self.slider.set(self.slider_value)
         self.slider.place(relx=0.5, rely=1.0, anchor="s", y=-130)
-        
+        self.set_cursor(self.slider_value)
+
         self.canvas.get_tk_widget().pack(
             fill=customtkinter.BOTH, 
             expand=True, 
             padx=10,
             pady=10,
         )
-        
-        self.cursor_line = self.ax.axvline(x=0, color="red", linewidth=2)
+
+        self.cursor_line = self.ax.axvline(x=self.slider_value, color="red", linewidth=2)
         self.canvas.draw_idle()
         
     def set_cursor(self, value):
         now = time.time()
-        if now - self.last_slider_update < 0.1:  # 100ms
+        if now - self.last_slider_update < 0.05:  # 100ms
             return
         self.last_slider_update = now
         
-        self.slider_value = round(value)
+        self.slider_value = round(value, 2)
         
         if self.cursor_line:
             self.cursor_line.set_xdata([self.slider_value, self.slider_value])
             self.canvas.draw_idle()
+            self.slider.set(self.slider_value)
+            self.set_cursor(self.slider_value)
         
-        print(f"Slider Value: {self.slider_value}")
+        print_info(f"Slider Value: {self.slider_value}")
 
     def play_audio(self):
         if not hasattr(self.AudioProcessor, "audio") or self.AudioProcessor.audio is None:
@@ -153,11 +164,16 @@ class CuttedApp:
             return
 
         start_time = self.slider.get() if hasattr(self, 'slider') else 0
+        self.playback_start_time = start_time
         self.AudioProcessor.play_audio(start_time)
 
     def stop_audio(self):
-        self.AudioProcessor.stop_audio()
+        rel_pos = self.AudioProcessor.stop_audio()
         self.is_playing = False
+        abs_pos = self.playback_start_time + rel_pos
+        self.slider.set(abs_pos)
+        self.set_cursor(abs_pos)
+        print_info(f"Absolute position in audio: {abs_pos:.2f}s")
         
     def export_audio(self):
         if not hasattr(self.AudioProcessor, "audio") or self.AudioProcessor.audio is None:
@@ -184,6 +200,7 @@ class CuttedApp:
             print_success(f"Audio exported to {save_path}")
             
     def send_prompt(self):
+        print(self.AudioProcessor.get_waveform_summary())
         self.save_state()
 
         if not hasattr(self.AudioProcessor, "audio") or self.AudioProcessor.audio is None:
@@ -192,14 +209,18 @@ class CuttedApp:
         
         text = self.entry.get()
         if text.strip():
-            full_prompt = f"You are a audio editing AI. You are controllable via natural language and editing a audio file. The audio file is {round(self.AudioProcessor.get_lenght())}s long."
+            full_prompt = f"You are a audio editing AI. You are controllable via natural language and editing a audio file. The audio file is {round(self.AudioProcessor.get_length(), 2)}s long. The cursor of the user is currently at {self.slider_value}s."
+            full_prompt += "\nHere is a the waveform samples of the audio. You can use them to determine silent parts, loud parts, silences, beats and much more.\nYou are forced to used these if the user requires you to cut out silent of quiet parts for example."
+            full_prompt += "\nAll of your tools should be enough to fullfill almost every task.\nNEVER ASK FOR CONFIRMATION FROM THE USER. DO EVERYTHING!"
+            full_prompt += f"\n{self.AudioProcessor.get_waveform_summary()}\n"
             if whisper_support:
                 if self.use_transcript_checkbox.get():
                     if not self.whisper:
-                        messagebox.showinfo("Info", "Loading Whisper model. This may take a few minutes depending on your internet connection. See the progress in your command line. If this window appears to be frozen, the transcription is running.")
+                        messagebox.showinfo("Info", "Loading Whisper model. This may take a few minutes depending on your internet connection. See the progress in your command line. If this window appears to be frozen, the transcription is running. Press OK to continue.")
                         self.whisper = transcribe.Whisper()
                     transcript = self.whisper.transcribe(self.AudioProcessor.audio_path)
                     full_prompt += f"\nThis is a transcript with per word timestamps of the audio:\n{transcript}"
+                    full_prompt += "\nThe transcript likely has issues. If you need infos about some words they might just be misspelled in the audio."
             full_prompt += f"\n\nUser Prompt: {text}"
             self.entry.delete(0, "end")
             
@@ -216,10 +237,17 @@ class CuttedApp:
                     result = self.AudioProcessor.cut(args["start"], args["end"])
                     if not result:
                         messagebox.showerror("Error", "Please try again.")
+                if function_call.name == "change_volume":
+                    print_info("Change Volume function called")
+                    args = function_call.args
+                    result = self.AudioProcessor.change_volume(args["start"], args["end"], args["volume"])
+                    if not result:
+                        messagebox.showerror("Error", "Please try again.")
                 self.update_plot()
             elif text_result:
                 messagebox.showerror("Error", text_result.strip())
             else:
+                messagebox.showerror("Error", "Gemini returned no data")
                 print_fail("Gemini returned no data")
 
     def save_state(self):

cutted/core/audio_processor.py

@@ -62,7 +62,21 @@ class AudioProcessor:
         
         return fig
     
-    def get_lenght(self):
+    def get_waveform_summary(self):
+        num_samples = round(self.get_length())
+        if self.audio is None:
+            return "No audio loaded."
+        samples = np.array(self.audio.get_array_of_samples())
+        if self.audio.channels == 2:
+            samples = samples.reshape((-1, 2))
+            samples = samples.mean(axis=1)
+        samples = samples / np.max(np.abs(samples))
+        indices = np.linspace(0, len(samples)-1, num_samples).astype(int)
+        summary = samples[indices]
+        return f"Waveform samples (normalized, {num_samples} points):\n" + \
+            " ".join(f"{x:.2f}" for x in summary)
+    
+    def get_length(self):
         self.duration = self.audio.duration_seconds
         self.duration = round(self.duration, 2)
         return self.duration
@@ -70,17 +84,25 @@ class AudioProcessor:
     def cut(self, start, end):
         if len(start) == len(end):
             if len(start) == 1:
-                print_info(f"Cutting from {start[0]} to {end[0]}")
-                start_ms = round(start[0] * 1000)
-                end_ms = round(end[0] * 1000)
+                single_start = max(0, start[0])
+                single_end = max(0, end[0])
+                if single_end <= single_start:
+                    print_fail("End time must be greater than start time.")
+                    return False
+                print_info(f"Cutting from {single_start} to {single_end}")
+                start_ms = round(single_start * 1000)
+                end_ms = round(single_end * 1000)
                 self.audio = self.audio[:start_ms] + self.audio[end_ms:]
                 return True
             else:
                 time_sets = list(zip(start, end))
                 subtract_time = 0
                 for single_start, single_end in time_sets:
-                    single_start = single_start - subtract_time
-                    single_end = single_end - subtract_time
+                    single_start = max(0, single_start - subtract_time)
+                    single_end = max(0, single_end - subtract_time)
+                    if single_end <= single_start:
+                        print_fail("End time must be greater than start time.")
+                        continue
                     print_info(f"Cutting from {single_start} to {single_end}")
                     start_ms = round(single_start * 1000)
                     end_ms = round(single_end * 1000)
@@ -90,6 +112,28 @@ class AudioProcessor:
         else:
             return False
         
+    def change_volume(self, start, end, volume):
+        if len(start) == len(end) == len(volume):
+            time_sets = list(zip(start, end, volume))
+            for single_start, single_end, single_volume in time_sets:
+                if single_end <= single_start:
+                    print_fail("End time must be greater than start time.")
+                    continue
+                print_info(f"Changing volume of {single_start} - {single_end} to {str(single_volume)}")
+                
+                start_ms = round(single_start * 1000)
+                end_ms = round(single_end * 1000)
+                part1 = self.audio[:start_ms]
+                part2 = self.audio[start_ms:end_ms]
+                part3 = self.audio[end_ms:]
+                
+                part2 = part2.apply_gain(ratio_to_db(single_volume))
+                
+                self.audio = part1 + part2 + part3
+            return True
+        else:
+            return False
+            
     def play_audio(self, start_time=0):
         if self.audio is None:
             print_fail("No audio loaded.")
@@ -123,11 +167,15 @@ class AudioProcessor:
     def stop_audio(self):
         try:
             if pygame.mixer.get_init():
+                pos_ms = pygame.mixer.music.get_pos()
+                pos_sec = pos_ms / 1000 if pos_ms >= 0 else 0
                 pygame.mixer.music.stop()
                 self.is_playing_var = False
-                print_info("Audio playback stopped")
+                print_info(f"Audio playback stopped at {pos_sec:.2f}s")
+                return pos_sec
         except Exception as e:
             print_warn(f"Error stopping audio: {e}")
+            return 0
             
     def is_playing(self):
         try:
@@ -142,7 +190,7 @@ class AudioProcessor:
             return None
         
         return {
-            "duration": self.get_lenght(),
+            "duration": self.get_length(),
             "channels": self.audio.channels,
             "frame_rate": self.audio.frame_rate,
             "sample_width": self.audio.sample_width

cutted/core/gemini.py

@@ -15,6 +15,7 @@ class GeminiClient:
         self.client = genai.Client(
             api_key=GEMINI_API_KEY,
         )
+        self.contents = []
     
     def generate(self, prompt: str, model: str = "gemini-2.0-flash", audio_base64 = None):
         parts=[
@@ -27,38 +28,76 @@ class GeminiClient:
                 data=base64.b64decode(audio_base64)
             ))
         
-        contents = [
+        self.contents.append(
             types.Content(
                 role="user",
                 parts=parts
-            ),
-        ]
+            )
+        )
         tools = [
             types.Tool(
                 function_declarations=[
                     types.FunctionDeclaration(
                         name="cut_audio",
-                        description="Cuts specified parts out of audio. Multiple parts can be cut if a list of both start and end values is used as property.",
+                        description=(
+                            "Remove one or more segments from the audio by specifying start and end times in seconds. "
+                            "You can cut multiple segments at once by providing lists of start and end values. "
+                            "Each segment defined by a start and end pair will be removed from the audio."
+                        ),
+                        parameters=genai.types.Schema(
+                            type=genai.types.Type.OBJECT,
+                            required=["start", "end"],
+                            properties={
+                                "start": genai.types.Schema(
+                                    type=genai.types.Type.ARRAY,
+                                    items=genai.types.Schema(
+                                        type=genai.types.Type.NUMBER,
+                                    ),
+                                ),
+                                "end": genai.types.Schema(
+                                    type=genai.types.Type.ARRAY,
+                                    items=genai.types.Schema(
+                                        type=genai.types.Type.NUMBER,
+                                    ),
+                                ),
+                            },
+                        ),
+                    ),
+                    types.FunctionDeclaration(
+                        name="change_volume",
+                        description=(
+                            "Adjust the volume of specific segments in the audio by specifying lists of start times, end times, "
+                            "and volume factors. Each segment between a start and end time will have its volume changed by the "
+                            "corresponding factor (e.g., 0.5 for half volume, 2.0 for double volume). Multiple segments can be "
+                            "adjusted at once by providing lists of values."
+                        ),
                         parameters=genai.types.Schema(
-                            type = genai.types.Type.OBJECT,
-                            required = ["start", "end"],
-                            properties = {
+                            type=genai.types.Type.OBJECT,
+                            required=["start", "end", "volume"],
+                            properties={
                                 "start": genai.types.Schema(
-                                    type = genai.types.Type.ARRAY,
-                                    items = genai.types.Schema(
-                                        type = genai.types.Type.NUMBER,
+                                    type=genai.types.Type.ARRAY,
+                                    items=genai.types.Schema(
+                                        type=genai.types.Type.NUMBER,
                                     ),
                                 ),
                                 "end": genai.types.Schema(
-                                    type = genai.types.Type.ARRAY,
-                                    items = genai.types.Schema(
-                                        type = genai.types.Type.NUMBER,
+                                    type=genai.types.Type.ARRAY,
+                                    items=genai.types.Schema(
+                                        type=genai.types.Type.NUMBER,
                                     ),
+                                ),
+                                "volume": genai.types.Schema(
+                                    type=genai.types.Type.ARRAY,
+                                    items=genai.types.Schema(
+                                        type=genai.types.Type.NUMBER,
                                     ),
+                                ),
                             },
                         ),
                     ),
-                ])
+                ]
+            )
         ]
         generate_content_config = types.GenerateContentConfig(
             tools=tools,
@@ -67,7 +106,7 @@ class GeminiClient:
 
         response = self.client.models.generate_content(
             model=model,
-            contents=contents,
+            contents=self.contents,
             config=generate_content_config,
         )
 
@@ -81,7 +120,27 @@ class GeminiClient:
                     if part.text:
                         text_response = part.text
         except TypeError:
-            return None, None
+            pass
+        
+        model_parts = []
+        if text_response:
+            model_parts.append(
+                types.Part.from_text(text=text_response)
+            )
+        if function_call:
+            model_parts.append(
+                types.Part.from_function_call(
+                    name=function_call.name,
+                    args=function_call.args
+                )
+            )
+            
+        self.contents.append(
+            types.Content(
+                role="model",
+                parts=model_parts
+            )
+        )
 
         return function_call, text_response
         

{cutted-0.3.2.dist-info → cutted-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cutted
-Version: 0.3.2
+Version: 0.4.0
 Summary: AI-powered audio editor controllable via natural language.
 Author-email: simon0302010 <simon0302010@gmail.com>
 License-Expression: GPL-3.0

cutted-0.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cutted/__init__.py,sha256=7eWSPFhMOE6u-f5s_QomBlTjCze86s3xKt-v0bLJAAs,49
+cutted/__main__.py,sha256=lYGLgtIZ_vGZIJmWG6ZQoqOdyOJnaWEA4NBn5Rc7Q8E,61
+cutted/app.py,sha256=LyVv3RHiAemtcEgLiZCcyenAD_QliaFIZ08JfCNwxq4,11543
+cutted/core/audio_processor.py,sha256=OBxNAKs67zqIfnJIsSgaMDa0UbB0R0mccyWcgNs5Bk0,7663
+cutted/core/gemini.py,sha256=0ATm5gHZWmu4k_9SZOsOx5XYY7nEer5LOzt1SMfQlIk,5836
+cutted/core/logger.py,sha256=AjqrgW2LV9HdPkPQ8oOmyd9lWzVSIg46r74ILR7mVHo,585
+cutted/core/transcribe.py,sha256=0e7aCva4y6D-gKe1xw5HT9VoFgbvHGgV6utn12r8wXA,986
+cutted-0.4.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cutted-0.4.0.dist-info/METADATA,sha256=wEeg-ive3z6zwUmLvZ_3Lh8W0xhsj12mMgSMASxWdUg,1503
+cutted-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cutted-0.4.0.dist-info/top_level.txt,sha256=PL6glZvzRyKWCDn5aoYI9uH8HlEA5Qd_XFJowJKARYI,7
+cutted-0.4.0.dist-info/RECORD,,

cutted-0.3.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-cutted/__init__.py,sha256=ttFLenYuOpXQTaR9nB0dF-3zFB_PeksXf9R4r_TB8S8,49
-cutted/__main__.py,sha256=lYGLgtIZ_vGZIJmWG6ZQoqOdyOJnaWEA4NBn5Rc7Q8E,61
-cutted/app.py,sha256=Ay_yVrPt1TQAE3lqmrII88lFoGZb5Mh5cDwediM9ZG8,9592
-cutted/core/audio_processor.py,sha256=JdPeWO_jAIn_uZFeZYQJX3RC0Vy8GClKrX7xGk4pXR4,5426
-cutted/core/gemini.py,sha256=yHsQXk4tDHcW5qJBuL2LpPvdChimxlmEbu76BvsoeY4,3108
-cutted/core/logger.py,sha256=AjqrgW2LV9HdPkPQ8oOmyd9lWzVSIg46r74ILR7mVHo,585
-cutted/core/transcribe.py,sha256=0e7aCva4y6D-gKe1xw5HT9VoFgbvHGgV6utn12r8wXA,986
-cutted-0.3.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-cutted-0.3.2.dist-info/METADATA,sha256=MPuSW4_LjNch0PXeFrGtRW1C4CuJ7unNv1ZZhvFHmSM,1503
-cutted-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cutted-0.3.2.dist-info/top_level.txt,sha256=PL6glZvzRyKWCDn5aoYI9uH8HlEA5Qd_XFJowJKARYI,7
-cutted-0.3.2.dist-info/RECORD,,