semvec/pypi-packages huggingface dataset:
ki-thermofluids 0.1.0
Thermofluid calculations. Home of ThermoState, FlowState, Orifice, and MinorLoss.
Requires Python: >=3.11


# Karman Industries - Thermofluids

### Variable naming conventions
#### Variables
| Common Variables | Default Units | Discription                |
|------------------|---------------|----------------------------|
| P                | W             | Power                      |
| p                | Pa            | Pressure                   |
| T                | K             | Temperature                |
| h                | J/kg          | Specific Enthalpy          |
| s                | J/kgK         | Specific Entropy           |
| e                | J/kg          | Sp. Internal Energy        |
| H                | J             | Enthalpy                   |
| S                | J/K           | Entropy                    |
| E                | J             | (Internal) Energy          |
| eta              | -             | Efficiency                 |
| phi              | -             | Flow coefficient           |
| psi              | -             | Head coefficient           |
| omega            | rad/s         | Rotational speed           |
| mdot             | kg/s          | Mass flowrate              |
| vdot             | m3/s          | Volumetric flowrate        | 
| rho              | kg/m3         | Density                    | 
| pr               | -             | Pressure ratio             |  
| Q                | W             | Heat transferred           | 
| W                | W             | Work transferred           | 
| COP              | -             | Coefficient of Performance | 
| num              | int           | Number of                  | 
| dhp              | J/kg          | Polytropic head            |


#### Indicating units
It is encouraged to add units to variable names. This is done via the folling format `varname_subscript__unitNumerator_unitDenominator`:
- Use a double underscore to seperate the variable name and subscript from the unit.
- Use a single underscore to seperate the numerator from the denominator

Examples include:
```
h_isen__J_kg            # the isentropic specific enthalpy with units kJ/kg 
A_xsection__m2          # Cross-sectional area in m2
mdot_inlet__kg_s        # Flow rate in kg/s
```
crawl-youtube-channel 0.0.1a2
A package to crawl a youtube channel
Requires Python: >=3.10
Keywords: youtube crawl crawler channel

# Crawl YouTube Channel

This Python package provides tools to crawl and extract data from YouTube channels.

## Features

*   Crawl an entire YouTube channel for video information.
*   Extract metadata, comments, transcripts, audio, and video for each video.
*   Provides a base class to easily implement your own video processing and storage logic.
*   Includes a `Sqlite3YouTubeVideoProcessor` for storing data in a local SQLite database.
*   Provides data classes for easy access to crawled data.

## Prerequisites

*   Python 3.10+
*   Google Cloud YouTube API Key

## Installation

1.  **Install the package:**

    ```bash
    pip install crawl-youtube-channel
    ```

2.  **Set up your environment:**

    Create a `.env` file in your project root and add your Google Cloud YouTube API key:

    ```
    GOOGLE_CLOUD_YOUTUBE_API_KEY=your_api_key
    ```

## Usage

To use the crawler, you need to implement the `YouTubeVideoProcessorBase` abstract class. This class defines how to check for existing videos and how to process new ones.

Here is a basic skeleton for a custom processor:

```python
import asyncio
from crawl_youtube_channel import YouTubeVideoProcessorBase, YouTubeVideo

class MyVideoProcessor(YouTubeVideoProcessorBase):
    async def check_video(self, video_id: str) -> bool:
        # Implement logic to check if the video has already been processed.
        # Return True if it exists, False otherwise.
        ...

    async def process_video(self, v: YouTubeVideo) -> None:
        # Implement logic to save or process the video data.
        # For example, save it to a database, a file, or another service.
        ...

async def main():
    # Initialize your custom processor
    processor = MyVideoProcessor()

    # Start crawling the channel
    await processor.process_channel(channel_url='https://www.youtube.com/@YourFavoriteChannel/videos')

if __name__ == '__main__':
    asyncio.run(main())
```

For a concrete implementation example, see the `Sqlite3YouTubeVideoProcessor` class in the source code, which stores video data in a SQLite database.

## Data Models

The following data classes are used to structure the crawled data:

*   `YouTubeVideo`: The main container for all video-related data.
*   `YouTubeThumbnail`: Basic information about a video thumbnail.
*   `YouTubeData`: Contains detailed information about a video, including:
    *   `Meta`: Video metadata (title, description, tags, etc.).
    *   `Comment`: A YouTube comment, including replies.
    *   `Transcript`: The video's transcript.
    *   `audio`: The audio file in M4A format (as bytes).
    *   `video`: The video file in MP4 format (as bytes).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
ki-util 0.2.0
Common utility functions (e.g. constants and unit conversions).
Requires Python: >=3.11


# Karman Industries - Utilities

## Installation and Setup
### General:
* [Python VSCode Setup](https://karmanindustries.sharepoint.com/sites/Engineering/_layouts/OneNote.aspx?id=%2Fsites%2FEngineering%2FSiteAssets%2FEngineering%20Notebook&wd=target%28Software%20Setup.one%7C00C51E4F-6D68-41E7-8A3C-AFA4B6B40681%2FPython%20VSCode%20Setup%7CE146EBA0-D387-4465-AE01-3EBF2BBA9C66%2F%29)
* [How to Clone a Git Repo](https://karmanindustries.sharepoint.com/sites/Engineering/_layouts/OneNote.aspx?id=%2Fsites%2FEngineering%2FSiteAssets%2FEngineering%20Notebook&wd=target%28Software%20Setup.one%7C00C51E4F-6D68-41E7-8A3C-AFA4B6B40681%2FClone%20a%20Git%20Repo%7C194A69B3-D3AF-4F01-AA40-5E20263887AD%2F%29)
* [How to Setup Git](https://karmanindustries.sharepoint.com/sites/Engineering/_layouts/OneNote.aspx?id=%2Fsites%2FEngineering%2FSiteAssets%2FEngineering%20Notebook&wd=target%28Software%20Setup.one%7C00C51E4F-6D68-41E7-8A3C-AFA4B6B40681%2FGit%20Setup%7C77DE0CC1-4366-45DF-8EC5-1043019BFBB5%2F%29)


### Install:
Please clone to the following directory, by all users using the same directory we avoid several common issues:
```commandline
C:\Code\
```

## How to contribute
### Formatting Code
Formatting is automatically done using Ruff. Ruff is a code formatter for Python which has several advantages:
-	Ruff enforces a uniform style across the codebase, making it easier for team members to read and understand each other’s code.
-	The resulting standardized format reduces code review overhead.
-	It reduces merge conflicts resulting from different styles.
-	Removes the need for a developer to do any formatting.
-	Lastly it can be integrated into CI/CD pipelines to ensure code is formatted prior to merge.

### Documentation
Documentation is done using [Sphinx](https://www.sphinx-doc.org/en/master/index.html).

The [Google style docstring format](https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html) is used.

To generate the documentation, run the following:
```commandline
C:\Code\ki-utils>sphinx-apidoc -o docs .
C:\Code\ki-utils>cd docs
C:\Code\ki-utils\docs>make html
# or if overwriting old:
C:\Code\ki-utils\docs>make clean html
```
orchestator 0.0.1
Lightweight orchestrator for intelligent agents communication and coordination
Requires Python: >=3.8

# 🎼 orchestator

**orchestator** is a lightweight orchestration layer for intelligent agents, inspired by the role of a conductor in an orchestra.  
It provides fast and modular coordination mechanisms for message routing, task execution, and agent collaboration.

---

## 🚀 Features

- 🧠 Orchestrates communication between AI agents
- 🔄 Async-ready and event-driven
- 🪶 Lightweight and extensible
- 🧩 Plug-and-play with MCP-based systems
- 📡 Ideal for microservices, LLM agents, task routers, and distributed tools

---

## 📦 Installation

```bash
pip install orchestator

⚡ Quick Example
python
Copy
Edit
from orchestator import Orchestrator

orch = Orchestrator()

@orch.on("greeting")
async def handle_greeting(payload):
    return f"Hello, {payload.get('name', 'world')}!"

# Simulate a message
response = await orch.dispatch("greeting", {"name": "Federico"})
print(response)  # → Hello, Federico!

🔧 Use Cases
Agent-to-agent orchestration

Task routing and message dispatching

LLM toolchain coordination

Event-based pipelines

📚 Documentation
📘 Wiki: orchestator Wiki

🧪 Examples: Examples Folder

🐛 Issues: Issue Tracker

📦 Part of the Intelligent Agents Platform
pgsql
Copy
Edit
🌐 py-agent-client     → Client SDK for agent communication
🧠 py-agent-core       → Shared utilities and protocols
🔧 py-agent-tool       → Tool wrapping and execution
📡 py-agent-server     → MCP server backend
🎼 orchestator         → Agent orchestrator layer ← you are here

🪪 License
This project is licensed under the MIT License.

🧑‍💻 Author
Built with ❤️ by Federico Monfasani
Part of the Intelligent Agents Platform (IAP) ecosystem

yaml
Copy
Edit

---

¿Querés que te genere también un ejemplo de código real en `orchestator/core.py` o `orchestrator.py` para acompañarlo?
seddy 0.3.0a1
Multi-workflow SWF Decider and Workflow Management Service
Requires Python: ~=3.6
Keywords: swf, decider

# seddy
[![Build status](
https://github.com/EpicWink/seddy/workflows/test/badge.svg?branch=master)](
https://github.com/EpicWink/seddy/actions?query=branch%3Amaster+workflow%3Atest)
[![codecov](https://codecov.io/gh/EpicWink/seddy/branch/master/graph/badge.svg)](
https://codecov.io/gh/EpicWink/seddy)
[![Documentation Status](https://readthedocs.org/projects/seddy/badge/?version=latest)](
https://seddy.readthedocs.io/en/latest/?badge=latest)
[![PyPI - Version](https://img.shields.io/pypi/v/seddy?logo=pypi)](
https://pypi.org/project/seddy/)

Multi-workflow SWF decider and workflow management service.

Features:
* Start a decider on many workflows
* Specify a directed graph (aka DAG) of activity (via dependencies) tasks in the
  workflow
* Supports coloured logging
* Extensible decision-building: just subclass `seddy.DecisionsBuilder`
* Register workflows
* Customise task input

What `seddy` doesn't do:
* Activity workers
* Anything [AWS CLI](https://aws.amazon.com/cli/) can
  * Workflows listing and detailing
  * Workflow execution management and history detailing
  * Tag management
  * Domain management
  * Activities management
* Validate workflow execution input
* Manage workflows definition file (`seddy` just uses it)

## Installation
```bash
pip3 install seddy
```

Install extra packages for further functionality
* Coloured logging: [`coloredlogs`](https://pypi.org/project/coloredlogs/)
* YAML workflows specs file: [`pyyaml`](https://pypi.org/project/PyYAML/) or
  [`ruamel.yaml`](https://pypi.org/project/ruamel.yaml/)
* JSON-format logging:
  [`python-json-logger`](https://pypi.org/project/python-json-logger/)

## Usage
Get the CLI usage
```bash
seddy -h
```

API documentation
```bash
pydoc3 seddy
```

## Docker
Instead of installing `seddy` locally, you can use our pre-built Docker image
```bash
docker run -v /path/to/workflow/file/parent:/seddy-data epicwink/seddy -h
```
answer-engine-optimization 0.1.1
Answer Engine Optimization (AEO) toolkit for Python-based websites
Requires Python: >=3.6


        # Answer Engine Optimization (AEO) Toolkit
        
        **Author**: [SuperSharpAI.com](https://supersharpai.com)  
        **Email**: python@supersharpai.com
        
        ## 🚀 Introduction
        
        `answer_engine_optimization` is a Python library that helps developers optimize their websites for Answer Engines (like Google Search, Bing Chat, or ChatGPT) by:
        
        - Adding and managing FAQ content
        - Generating structured FAQ schema (JSON-LD)
        - Embedding Quick Answer blocks
        - Checking if a webpage is AEO-friendly
        
        ---
        
        ## 📦 Installation
        
        ```bash
        pip install answer_engine_optimization
        ```
        
        ---
        
        ## 🧠 Features
        
        - ✅ Add FAQs with questions and answers
        - ✅ Get a list of all added FAQs
        - ✅ Generate structured data (JSON-LD) for FAQs
        - ✅ Create Quick Answer block in HTML
        - ✅ Analyze if a webpage is AEO friendly
        
        ---
        
        ## 🧪 Example Usage
        
        ```python
        from answer_engine_optimization import AEOEngine
        
        aeo = AEOEngine()
        
        # Add FAQs
        aeo.add_faq("What is AEO?", "Answer Engine Optimization helps AI systems like ChatGPT understand your content.")
        aeo.add_faq("Why is FAQ schema important?", "It improves visibility in AI-based search and voice assistants.")
        
        # View FAQs
        print(aeo.get_faqs())
        
        # Generate FAQ schema (JSON-LD)
        print(aeo.generate_faq_schema())
        
        # Generate Quick Answer block
        print(aeo.generate_quick_answer("AEO is optimizing content for AI-driven platforms like ChatGPT and Google Search."))
        
        # Check if a webpage is AEO friendly
        html = "<html><head><title>Test Page</title></head><body><div class='quick-answer'></div></body></html>"
        print(aeo.check_aeo_friendly(html))
        ```
        
        ---
        
        ## 📄 License
        
        MIT License
        
        ---
        
        ## 🌐 Learn More
        
        Visit [https://supersharpai.com](https://supersharpai.com) for more AI and SEO tools.