"ilovetools v0.1.2: Python Utilities for ML Developers"

I just released Kiru: a text chunking lib, 1000x faster than LangChain splitters: build in Rust for Python If you're building RAG systems, you know the basic drill: load documents, split them into chunks, feed them to your vector database. Simple enough, except most chunking libraries are painfully slow when you're processing millions of documents. kiru solves this bringing Rust native performance to Python via PyO3 bindings. 𝗧𝗵𝗲 𝗻𝘂𝗺𝗯𝗲𝗿𝘀 - 4000+ MB/s for byte chunking (Pure Rust) - 1,400+ MB/s for byte chunking (Python bindings) - 300+ MB/s for character-aware chunking - Constant memory usage, even on gigabyte files - Works with files, URLs, and glob patterns out of the box 𝗪𝗵𝘆 𝗶𝘁'𝘀 𝗳𝗮𝘀𝘁 𝗮𝗻𝗱 𝗺𝗲𝗺𝗼𝗿𝘆 𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝘁 Most chunkers load entire files into memory, then split them. Kiru streams data in blocks, chunks on-the-fly, and never breaks UTF-8 boundaries. The Rust implementation hits 4,000+ MB/s (for in memory string and byte chunking), and even the Python bindings crush slower pure Python implementation. 𝗕𝘆𝘁𝗲 𝘃𝘀 𝗖𝗵𝗮𝗿𝗮𝗰𝘁𝗲𝗿 𝗰𝗵𝘂𝗻𝗸𝗶𝗻𝗴 Byte chunking splits on byte boundaries (faster, perfect for token-limited models). So for a chunk of 500 bytes we just lookup the 500th byte in the sequence, if it's not a valid character boundary we take the closest one. Character chunking splits on exact characters count. It's slower because you need to compute all the character boundaries (characters can be multi-bytes). Both respect UTF-8 boundaries, so you never get corrupted text. 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 When you're ingesting your entire knowledge base or processing documents in real-time, speed isn't just nice, it's the difference between a system that scales and one that doesn't. 𝗪𝗵𝗮𝘁'𝘀 𝗻𝗲𝘅𝘁 This is just the first release. Coming soon: 👉🏽 Delimiter-based splitting (newlines, sentences, paragraphs) 👉🏽 Recursive splitting with multiple delimiters 👉🏽 Markdown-native chunking (preserve structure) 👉🏽 Sitemap support (chunk entire websites from a single URL) 👉🏽 Code-aware splitting powered by tree-sitter Available now on PyPI and Rust Crates. Fully opensource. Links below 👇🏽 #python #rust #rag #opensource #ai #llm

Rust-level speed to Python text chunking Most chunkers choke when dealing with millions of documents. This one doesn’t. • Streams data instead of loading entire files into memory • Works directly with bytes, keeping UTF-8 intact • Handles gigabyte-scale files without breaking a sweat If you’re building RAG systems, this is the kind of efficiency that actually matters. It’s already on GitHub → github.com/bitswired/kiru

We all rely on Python, but its complexity is costing us time and money. The truth is, the current Python data stack is a patchwork of tools (NumPy, Pandas, Scikit-learn, etc.) that were never designed to work together. This fragmentation creates the three fundamental bottlenecks of modern data work.1. The Cognitive Bottleneck: From Sprawl to Semantic UnityPython requires analysts to be proficient in a dozen different library APIs, leading to inconsistent code and endless context switching.Python's Method: You must know Pandas methods for cleaning, NumPy syntax for arrays, and Matplotlib/Seaborn for plotting. If you change your data structure, all your methods break.Dataspear's Solution: Dataspear is a Semantically Unified Language. Every data operation—from filtering rows to training a model—is a built-in, first-class function of the language, interacting with one primary data object (DataSphere). The rules never change, drastically cutting down the learning curve and coding time.2. The Performance Bottleneck: Breaking the GIL ChainsPython relies on external, compiled C libraries (like NumPy's core) to achieve speed, but its own concurrency is hobbled by the Global Interpreter Lock (GIL).Python's Method: True multi-threading is impossible for CPU-bound tasks, forcing complex and inefficient workarounds like multiprocessing or relying on async frameworks for I/O.Dataspear's Solution: Dataspear is engineered for native, zero-overhead parallelism from day one. It removes threading constraints, allowing us to utilize modern multi-core processors fully and serve high-throughput data pipelines efficiently—making it faster not just for single-threaded tasks, but for entire concurrent data systems.3. The Maintenance Bottleneck: Dependency Hell is OverThe single biggest cost in Python deployment is managing the "Dependency Hell." Version conflicts between libraries are the norm, making deployment brittle and slow.Python's Method: Every project requires an isolated environment (conda or venv) and complex version files (requirements.txt). Upgrading one library often breaks three others.Dataspear's Solution: Because the analytical core is unified and maintained as a single language, all dependencies are internal and guaranteed compatible. Deployment involves packaging a compact Dataspear runtime, not an unstable, sprawling collection of third-party wheels and compiled extensions. Your code works flawlessly the first time, every time.The future of data science requires a unified, high-performance tool built specifically for the domain. That tool is Dataspear. We're moving beyond the 1990s programming paradigms. If you're tired of debugging pip install issues and wrestling with NumPy vs. Pandas syntax, what specific task do you wish Dataspear could simplify immediately? #SoftwareEngineering #DataScience #Python #Programming #TechInnovation #DataAnalytics

💠Python Tuples :- Definition , Uses & 10 Important Methods :- 🔹 What is a Tuple? ➜ A Tuple is an ordered and immutable collection of elements in Python. Once created, its values cannot be changed, added, or removed. ✧ Purpose / Uses :- • To store fixed data that should not change • Faster performance compared to lists • Ideal for read-only collections like coordinates, configuration, and database records ❖ Ways to Create a Tuple :- ➣ Way 1 my_tuple = (10, 20, 30, "Python") ➣ Way 2 my_tuple = 10, 20, 30, "Python" ✧ Example :- colors = ("red", "green", "blue") print(colors) print(type(colors)) Output :- ('red', 'green', 'blue') <class 'tuple'> ◈ Tuple Immutability ➞ Once created , you can't modify a tuple. my_tuple = (1, 2, 3) my_tuple[0] = 10 Output :- Type Error :- 'tuple' object does not support item assignment 🧮 2 Ways to Access Tuple Elements :- 1️⃣ Using Index :- numbers = (10, 20, 30) print(numbers[1]) Output :- 20 2️⃣ Using Loop :- for x in numbers: print(x) Output :- 10 20 30 🔸 10 Tuple Methods & Functions :- Tuples have fewer methods than lists because they are immutable — but they’re very efficient and powerful. 🔹 1️⃣ count() ➜ Returns the number of times a value appears. Example :- numbers = (1, 2, 2, 3, 2) print(numbers.count(2)) Output :- 3 🔹 2️⃣ index() ➜ Returns the index of the first occurrence of a value. Example :- colors = ("red", "green", "blue") print(colors.index("green")) Output :- 1 🔹 3️⃣ len() ➜ Returns total number of elements. Example :- t = (1, 2, 3, 4) print(len(t)) Output :- 4 🔹 4️⃣ max() ➜ Returns the largest element. Example :- nums = (10, 25, 15) print(max(nums)) Output :- 25 🔹 5️⃣ min() ➜ Returns the smallest element. Example :- nums = (10, 25, 15) print(min(nums)) Output :- 10 🔹 6️⃣ sum() ➜ Returns the total sum of all numeric elements. Example :- nums = (10, 20, 30) print(sum(nums)) Output :- 60 🔹 7️⃣ sorted() ➜ Returns a sorted list from the tuple (does not change original). Example :- nums = (3, 1, 2) print(sorted(nums)) Output :- [1, 2, 3] 🔹 8️⃣ tuple() ➜ Converts another data type (like list) into a tuple. Example :- A = [1, 2, 3] print(tuple(A)) Output :- (1, 2, 3) 🔹 9️⃣ any() ➜ Returns True if any element is True. Example :- values = (0, False, 5) print(any(values)) Output :- True 🔹 🔟 all() ➜ Returns True if all elements are True. Example :- values = (1, True, 3) print(all(values)) Output :- True 💡 Tip :- Use Tuples when data shouldn’t change — like database records or coordinates. They are memory-efficient and faster than lists. #Python #Tuple #DataStructures #Coding #Developers #Programming #PythonLearning #LearnPython #LinkedInLearning #CodeNewbie

Top Five python tricks 1. Multiple Assignment & Swapping Variables # Instead of: a = 1 b = 2 c = 3 # Do this: a, b, c = 1, 2, 3 # Swap variables without temp variable x, y = 10, 20 x, y = y, x # Now x=20, y=10 # Unpacking iterables first, *middle, last = [1, 2, 3, 4, 5] print(first)  # 1 print(middle) # [2, 3, 4] print(last)  # 5 2. List Comprehensions with Conditions # Instead of: squares = [] for i in range(10):   if i % 2 == 0:     squares.append(i**2) # Do this: squares = [i**2 for i in range(10) if i % 2 == 0] # More complex example: result = [x.upper() for x in ['hello', 'world', 'python'] if len(x) > 4] print(result) # ['HELLO', 'WORLD', 'PYTHON'] 3. The zip() Function for Parallel Iteration # Iterate over multiple lists simultaneously names = ['Alice', 'Bob', 'Charlie'] scores = [85, 92, 78] subjects = ['Math', 'Science', 'English'] for name, score, subject in zip(names, scores, subjects):   print(f"{name} scored {score} in {subject}") # Create dictionary from two lists score_dict = dict(zip(names, scores)) print(score_dict) # {'Alice': 85, 'Bob': 92, 'Charlie': 78} 4. enumerate() for Index-Value Pairs # Instead of: fruits = ['apple', 'banana', 'cherry'] for i in range(len(fruits)):   print(f"Index {i}: {fruits[i]}") # Do this: for i, fruit in enumerate(fruits):   print(f"Index {i}: {fruit}") # With custom start index for i, fruit in enumerate(fruits, start=1):   print(f"#{i}: {fruit}") 5. Dictionary Comprehensions & Merging # Create dictionary from list names = ['Alice', 'Bob', 'Charlie'] name_lengths = {name: len(name) for name in names} print(name_lengths) # {'Alice': 5, 'Bob': 3, 'Charlie': 7} # Merge dictionaries (Python 3.9+) dict1 = {'a': 1, 'b': 2} dict2 = {'b': 3, 'c': 4} merged = dict1 | dict2 # {'a': 1, 'b': 3, 'c': 4} # For older Python versions: merged = {**dict1, **dict2}

✅ *Python Libraries & Tools – Interview Q&A (Part 3: API Calls)* 🌐📡 *1. What is the `requests` library in Python?* *Answer:* `requests` is a popular Python library used to send HTTP/1.1 requests like GET, POST, PUT, DELETE, etc. It simplifies interaction with APIs. *2. How do you make a GET request using `requests`?* ```python import requests response = requests.get('https://lnkd.in/gk-QMyM3') print(response.status_code, response.json()) ``` This fetches data from the given URL. *3. How can you send data using POST request?* ```python payload = {'name': 'John', 'age': 30} response = requests.post('https://lnkd.in/ggtr8rHa', data=payload) ``` *4. How do you handle headers in a request?* ```python headers = {'Authorization': 'Bearer YOUR_TOKEN'} response = requests.get(url, headers=headers) ``` *5. What if the request fails or times out?* Use exception handling: ```python try: response = requests.get(url, timeout=5) response.raise_for_status() except requests.exceptions.RequestException as e: print("Error:", e) ``` *6. How do you send JSON in a POST request?* ```python import json data = {'id': 1, 'title': 'Hello'} response = requests.post(url, json=data) ``` *7. How to read response content?* - `response.text` – raw text - `response.json()` – parsed JSON - `response.status_code` – status code - `response.headers` – headers dictionary *8. How to send query parameters?* ```python params = {'page': 2, 'limit': 10} response = requests.get(url, params=params) ``` *9. Can you upload files using `requests`?* Yes: ```python files = {'file': open('example.txt', 'rb')} response = requests.post(url, files=files) ``` *10. Real-world example use-case?* Fetching live data from weather API: ```python r = requests.get("https://lnkd.in/gwzZjRnu") print(r.json()) ```

Perfect 👍 — you want a full explanation of Python functions including: ✅ Function definition ✅ Function arguments (required, keyword, default, variable-length) ✅ Return statement ✅ Lambda function ✅ Recursion Let’s go step-by-step with simple examples 👇 🐍 1️⃣ What is a Function in Python? 👉 A function is a block of code that performs a specific task. It is defined using the def keyword. def greet(): print("Hello, Welcome to Python!") greet() # function call ✅ Output: Hello, Welcome to Python! 🧠 Explanation: def greet(): defines the function. greet() calls the function. ⚙️ 2️⃣ Function Arguments (Parameters) Python functions can take different kinds of arguments: 🔸 (a) Required Arguments 👉 You must pass all values when calling the function. def add(a, b): print(a + b) add(5, 3) # ✅ works # add(5) ❌ error - missing one argument 🧠 Explanation: Both a and b are required parameters. 🔸 (b) Keyword Arguments 👉 Pass arguments using parameter names (order doesn’t matter). def student(name, age): print("Name:", name) print("Age:", age) student(age=21, name="Vaibhav") ✅ Output: Name: Vaibhav Age: 21 🔸 (c) Default Arguments 👉 Provide default values to parameters. def greet(name, msg="Good Morning"): print("Hello", name + ",", msg) greet("Vaibhav") greet("Priya", "Hi!") ✅ Output: Hello Vaibhav, Good Morning Hello Priya, Hi! 🔸 (d) Variable-length Arguments There are two types: (i) *args — multiple positional arguments def total(*numbers): print("Sum:", sum(numbers)) total(10, 20, 30) total(1, 2, 3, 4, 5) ✅ Output: Sum: 60 Sum: 15 (ii) **kwargs — multiple keyword arguments def info(**details): for key, value in details.items(): print(key, ":", value) info(name="Vaibhav", age=21, city="Mumbai") ✅ Output: name : Vaibhav age : 21 city : Mumbai 🔁 3️⃣ Return Statement 👉 The return keyword sends a value back from the function. def square(x): return x * x result = square(5) print("Square is:", result) ✅ Output: Square is: 25 🧠 Explanation: The function returns a value instead of printing it. ⚡ 4️⃣ Lambda Function 👉 A lambda is a small anonymous function (no name). Syntax: lambda arguments : expression Example: square = lambda x: x * x print(square(6)) ✅ Output: 36 🧠 Explanation: Lambda functions are used for short, simple operations. 🔄 5️⃣ Recursion Function 👉 A recursive function calls itself until a condition is met. Example: factorial using recursion def factorial(n): if n == 1: return 1 else: return n * factorial(n - 1) print("Factorial:", factorial(5)) ✅ Output: Factorial: 120 🧠 Explanation: The function calls itself with smaller values of n. Base condition if n == 1: stops recursion. 🧩 #PythonFunctions #FunctionArguments #KeywordArguments #DefaultArguments #VariableArguments #ArgsKwargs #ReturnStatement #LambdaFunction #Recursion

#!/usr/bin/env python3 """ KonomiML Markdown Runner - Execute Python code blocks from markdown files """ import os import re import sys import tempfile import subprocess from pathlib import Path def extract_code_block(markdown_file: Path) -> str:   """Extract Python code block from markdown file"""   if not markdown_file.exists():     raise FileNotFoundError(f"Markdown file not found: {markdown_file}")       with open(markdown_file, 'r', encoding='utf-8') as f:     content = f.read()       # Find Python code blocks   pattern = r'```python\s*\n(.*?)\n```'   matches = re.findall(pattern, content, re.DOTALL)       if not matches:     raise ValueError(f"No Python code blocks found in {markdown_file.name}")       # Return the first (main) code block   return matches[0] def run_markdown_program(markdown_file: Path, args: list = None):   """Run Python code from markdown file"""   try:     # Extract code block     code_block = extract_code_block(markdown_file)           # Create temporary file     with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:       temp_file.write(code_block)       temp_file_path = temp_file.name           # Prepare command     cmd = [sys.executable, temp_file_path]     if args:       cmd.extend(args)           # Set environment     env = os.environ.copy()     docs_path = Path(__file__).parent     root_path = docs_path.parent     env['PYTHONPATH'] = f"{docs_path}:{root_path}:{env.get('PYTHONPATH', '')}"           # Execute     result = subprocess.run(       cmd,       cwd=str(docs_path),       env=env     )           # Clean up     os.unlink(temp_file_path)           return result.returncode         except Exception as e:     print(f"Error running markdown program: {e}")     return 1 def main():   """Main function"""   if len(sys.argv) < 2:     print("Usage: python run_markdown.py <markdown_file> [args...]")     return 1       markdown_file = Path(sys.argv[1])   args = sys.argv[2:] if len(sys.argv) > 2 else []       # If file doesn't have .md extension, add it   if not markdown_file.suffix:     markdown_file = markdown_file.with_suffix('.md')       # Make path relative to docs directory if needed   if not markdown_file.is_absolute():     docs_path = Path(__file__).parent     markdown_file = docs_path / markdown_file       return run_markdown_program(markdown_file, args) if __name__ == "__main__":   sys.exit(main())

Dictionaries in Python: The Pantry Labels of Your Code 🏷️ Your pantry has so many items — but how do you find things easily? You don’t just dump everything in boxes — you label them! “Sugar → 1kg” “Milk → 2 packets” “Coffee → 500g” That’s what Dictionaries in Python do - they store data as key–value pairs, just like labeled jars in your kitchen! 💡 What is a Dictionary? A dictionary helps you store and access data using names (keys) instead of positions. Think of it like this: Instead of saying “Give me the 3rd item”, you can say “Give me the sugar!” 📘 Example: pantry = { "Sugar": "1kg", "Milk": "2 packets", "Coffee": "500g" } Now, if you want to check what’s in your pantry: print(pantry) Output: {'Sugar': '1kg', 'Milk': '2 packets', 'Coffee': '500g'} 💬 Accessing Items You can get values by using their key names: print(pantry["Sugar"]) Output: 1kg Easy, right? No need to remember the position - just ask for the label! 🧠 Updating or Adding Items Refill something or add new stock: pantry["Sugar"] = "2kg" # update existing pantry["Tea"] = "1 box" # add new print(pantry) Output: {'Sugar': '2kg', 'Milk': '2 packets', 'Coffee': '500g', 'Tea': '1 box'} 💥 Removing Items You can remove an item once it’s finished: del pantry["Coffee"] print(pantry) Output: {'Sugar': '2kg', 'Milk': '2 packets', 'Tea': '1 box'} 💡 Why Dictionaries Are Powerful ✅ Easy to find data using names ✅ Data stays organized and readable ✅ Perfect for real-world applications - like storing user info, product details, etc. 🧠 Today’s takeaway: “Dictionaries are like labeled jars — they help you find exactly what you need without confusion!” 💬 Try this today: Create a dictionary with your favorite fruits and their colors 🍎 Then print each fruit with its color using: for fruit, color in fruits.items(): print(fruit, "is", color) #PythonWithKeshav #LearnPython #PythonBasics #CodingJourney #PythonDictionaries #ProgrammingForBeginners #PythonLearning #CodeSmart #STEMEducation #PythonForAll

🚀 Learn Python Libraries – Part 12: yt-dlp (Download Videos, Audio & Metadata from YouTube, Facebook & More!) 🎯 In the previous part (PyPDF), we learned how to manipulate PDFs — read, merge, split, and protect them. But now… let’s move from documents to downloads! 💡 Today, we’ll explore one of the most powerful tools for automating video, audio, and metadata downloads from hundreds of websites using Python and the yt-dlp library. 🔧 What is yt-dlp? yt-dlp is an advanced fork of youtube-dl — a command-line program that can download videos, audio, playlists, and even metadata from YouTube, Facebook, Instagram, Twitter, TikTok, and many other supported platforms. With Python, you can automate downloading, renaming, organizing, or even analyzing media content. ⚙️ Installation Steps 1️⃣ Install the library using pip: --> pip install yt-dlp 2️⃣ Install FFmpeg to merge video and audio automatically: Download from: https://lnkd.in/dZSr-wQD Extract it to: C:\ffmpeg Add C:\ffmpeg\bin to your system PATH Restart your terminal and test with: --> ffmpeg -version ✅ Once FFmpeg works, yt-dlp can download and merge high-quality video and audio into a single MP4 file. 💡 Why this matters This powerful library allows you to: Download from hundreds of supported sites 🌐 Detect whether the link is a single video or a playlist 🎥 Download audio only (e.g., MP3 or M4A) 🎧 Extract metadata (title, views, duration, uploader, etc.) without downloading the media 🧠 Use it from Python or directly in CMD/Terminal 💻 Save media automatically in organized folders 📁 Handle errors safely and efficiently ⚠️ 💻 Use yt-dlp from CMD (Command Prompt): 🔹 Download a single video: --> yt-dlp https://lnkd.in/dY9CsamG 🔹 Download a playlist: --> yt-dlp https://lnkd.in/dgsMfeK4 🔹 Download audio only: --> yt-dlp -x --audio-format mp3 https://lnkd.in/dY9CsamG 🔹 Extract metadata only (no download): --> yt-dlp --dump-json https://lnkd.in/dY9CsamG 🔹 Specify custom download folder and filename: --> yt-dlp -o "C:\Videos\%(title)s.%(ext)s" https://lnkd.in/dY9CsamG 📘 This was Part 12 of Learn Python Libraries 👀 Stay tuned for Part 13, where we’ll take automation to the next level! #Python #Automation #yt_dlp #LearnPython #CodingJourney #YouTubeDownloader #FacebookDownloader #VideoDownloader #AudioDownloader #CMD #Metadata