semvec/pypi-packages huggingface dataset:
lasfile 0.2.5
A Python library for reading LAS files.
Requires Python: >=3.7
Keywords: las, CWLS, las logs, petrophysical logs

# lasfile
 Library for reading CWLS Log ASCII Standard v. 1.2, 2.0, and 3.0 .las files.

## Installation
```bash
pip install lasfile
```

## Usage
### Read LAS file
```python
import lasfile

las = lasfile.LASFile(file_path='path/to/file.las')
```
#### In order for an lasfile to properly read, and pass a critical error check, it must have the following sections:
- Version
- Well
- Curves
- Data

### View sections in LAS file
```python
las.sections
```
### View section data in LAS file
#### Using dot notation
##### As raw ascii text
```python
las.well.raw_data
```
##### As pandas dataframe
```python
las.well.df
```
#### Using dictionary notation
##### As raw ascii text
```python
las['well']['raw_data']
```
##### As pandas dataframe
```python
las['well']['df']
```

### Write LAS file
The `write` function allows you to write LAS files based on the sections available in the `LASFile` object.

#### Usage:
```python
from lasfile import write

write(las, overwrite=False, file_path='path/to/output/file.las')
```

#### Functionality:
- If a 'file_path' is not passed to the function, the 'write' function will attempt to overwrite the existing file stored in the 'file_path' variable of the LASFile object. Overwrite functionality is disabled by default but can be enabled by setting the 'overwrite' attribute to 'True'.

#### Limitations:
- Currently, the write functionality **cannot** write LAS v. 3.0 files. This feature is under development.
- LAS v. 3.0 files can be written to LAS v. 2.0 format by setting the 'version' keyword argument of the 'write' function to '2.0'. However, this will result in the loss of any data stored in sections not found in the LAS v. 2.0 format.

### Read and Write Capabilities
| Version | Read       | Write         |
|---------|------------|---------------|
| 1.2     | ✔ Working  | ✔ Working     |
| 2.0     | ✔ Working  | ✔ Working     |
| 3.0     | ✔ Working  | 🚧 In Development |

### Errors
#### View all errors
```python
las.errors
```

#### View specific errors
```python
las.open_error
las.read_error
las.split_error
las.version_error
las.parse_errors
las.validate_errors
```

#### Check for errors
##### Check for only critical errors
```python
lasfile.error_check(las)
```
##### Check for all errors
```python
lasfile.error_check(las, critical_only=False)
```
##### LASSection objects can also be passed to error_check
```python
lasfile.error_check(las.well)
```


## License
[MIT](https://choosealicense.com/licenses/mit/)
```
openinference-instrumentation-google-genai 0.1.10
OpenInference Google GenAI Instrumentation
Requires Python: <3.15,>=3.10

# OpenInference Google GenAI Instrumentation

Python auto-instrumentation library for GenAI SDK. Traces are fully OpenTelemetry compatible and can be sent to any OpenTelemetry collector for viewing, such as [Arize Phoenix](https://github.com/Arize-ai/phoenix).

## Installation

```shell
pip install -Uqqq openinference-instrumentation-google-genai
```

## Quickstart

Install `openinference-instrumentation-google-genai` and `arize-phoenix`.

```shell
pip install -U \
    openinference-instrumentation-google-genai \
    arize-phoenix \
    opentelemetry-sdk \
    opentelemetry-exporter-otlp \
    "opentelemetry-proto>=1.12.0"
```

Start the `phoenix` server so that it is ready to receive traces.
The `phoenix` server runs entirely on your machine and does not send data over the internet.

```shell
phoenix serve
```

Instrumenting `genai` is simple.

```python
from openinference.instrumentation.google_genai import GoogleGenAIInstrumentor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

endpoint = "http://127.0.0.1:4317"
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))

GoogleGenAIInstrumentor().instrument(tracer_provider=tracer_provider)
```

Now, all calls by `generate_content` are instrumented and can be viewed in the `phoenix` UI.

## Progress

This instrumentation is a work in progress

-   [x] parse messages and invocation
-   [ ] capture tool definitions

## More Info

-   [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
-   [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
-   [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)
openinference-instrumentation-instructor 0.1.13
OpenInference Instructor Instrumentation
Requires Python: <3.14,>=3.9

# OpenInference Instructor Instrumentation

[![pypi](https://badge.fury.io/py/openinference-instrumentation-instructor.svg)](https://pypi.org/project/openinference-instrumentation-instructor/)

Python auto-instrumentation library for the (Instructor)[https://github.com/jxnl/instructor] library

## Installation

```shell
pip install openinference-instrumentation-instructor
```

## Quickstart

This quickstart shows you how to instrument Instructor

Install required packages.

```shell
pip install instructor arize-phoenix opentelemetry-sdk opentelemetry-exporter-otlp
```

Start Phoenix in the background as a collector. By default, it listens on `http://localhost:6006`. You can visit the app via a browser at the same address. (Phoenix does not send data over the internet. It only operates locally on your machine.)

```shell
python -m phoenix.server.main serve
```

Set up `InstructorInstrumentor` to trace your application and send the traces to Phoenix at the endpoint defined below. 
```python
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

endpoint = "http://127.0.0.1:6006/v1/traces"
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
from openinference.instrumentation.instructor import InstructorInstrumentor
from openinference.instrumentation.openai import OpenAIInstrumentor

InstructorInstrumentor().instrument(tracer_provider=tracer_provider)

# Optionally instrument the OpenAI SDK to get additional observability
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
```

Simple Instructor example
```python
import instructor
from pydantic import BaseModel
from openai import OpenAI


# Define your desired output structure
class UserInfo(BaseModel):
    name: str
    age: int


# Patch the OpenAI client
client = instructor.from_openai(OpenAI())

# Extract structured data from natural language
user_info = client.chat.completions.create(
    model="gpt-3.5-turbo",
    response_model=UserInfo,
    messages=[{"role": "user", "content": "John Doe is 30 years old."}],
)
```

## More Info

* [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
* [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
* [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)
ytvideo2pdf 0.0.19
Convert YouTube educational video to crisp PDF notes
Requires Python: >=3.9

# 🎬 Glimpsify: Extract PPT Slides from any Educational Video

**A Video-to-PDF Frame Extraction Tool**

❌ Watch an entire 34 minutes long lecture video on YouTube? Naah 👎 \
✅ Get PDF notes of screenshots of important parts of the video instead? Hell yessss! 👌

That's what Glimpsify does! 💻

You pass it YouTube link 🔗 of the lecture video 🎥 and it gives you the PDF notes 📑 of the key parts of the video.
Yes with all the visuals - diagrams, charts, formulas - which no summarizer in the market gives!

See sample PDF: \
https://drive.google.com/drive/folders/1XOIjQs7dnYCBK1dg3ZzK8PPhx09H58-f?usp=drive_link

## Quick start

0. Tesseract OCR must be installed on your system for text detection to work.
   - For Windows, download the installer from [here](https://sourceforge.net/projects/tesseract-ocr.mirror/) and follow the installation instructions.
   - For macOS, you can install it using Homebrew:
     ```bash
     brew install tesseract
     ```
   - For Linux (Debian/Ubuntu), use the following command:
     ```bash
      sudo apt-get install tesseract-ocr
     ```
1. Install the package
   - `pip install ytvideo2pdf`
2. Run the CLI to get PDF notes
   - `ytvideo2pdf --input=youtube --url="https://youtu.be/Z_MLrbI1s2E?si=ZrVBfIa0apzkuUKD"`

### 📚 Perfect For:

- **Students**: Creating last-minute revision PDFs from lecture videos
- **Educators**: Extracting slide content from recorded presentations
- **Researchers**: Analyzing visual content in educational materials
- **Professionals**: Converting training videos to reference documents
- **Content Creators**: Generating thumbnails and key moments

## LinkedIn Posts

I actively post on LinkedIn about my project. You can find link to the posts here:

- https://www.linkedin.com/posts/vedantpanchal_neso-academy-never-provides-their-ppts-activity-7254912964451811328-0a7H
- https://www.linkedin.com/posts/vedantpanchal_edtech-youtubesummarization-glimpsify-activity-7301972904718528512-LGoy

## Extracting Most Information Frame

Pass a YouTube Video link and get the screenshots of the frame which has the most information content (like if someone is explaining with the help of a PPT, capture screenshot when all the text of one slide of PPT has animated in)

Frame with most information it can possibly have
![image](https://github.com/DeveloperDowny/most_info_frame_extractor/assets/60831483/854332d4-5d59-4f11-aeff-e0fa0c8e1fcd)

This frame can have more information and thus not the most information frame
![image](https://github.com/DeveloperDowny/most_info_frame_extractor/assets/60831483/35eed63d-e490-441a-ab65-06ad336cb8aa)
xenfra 0.4.6
Xenfra CLI: Hands for AI to deploy on DigitalOcean.
Requires Python: >=3.11

# Xenfra CLI (The Interface) 🖥️

[![PyPI](https://img.shields.io/pypi/v/xenfra)](https://pypi.org/project/xenfra/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The official command-line interface for **Xenfra** (The Sovereign Cloud OS). It empowers developers to deploy, monitor, and manage applications on their own infrastructure (DigitalOcean) with the ease of Heroku.

## 🚀 Features

- **Zero-Config Deployment**: `xenfra deploy` detects your stack (Python, Node.js) and ships it.
- **Sovereign Auth**: `xenfra auth login` connects securely to your cloud provider.
- **Live Logs**: `xenfra logs` streams colorized, PII-scrubbed logs from your servers.
- **Doctor**: `xenfra doctor` runs a battery of health checks on your deployment environment.
- **Zen Mode**: Automatically applies fix patches when deployments fail.

## 📦 Installation

```bash
# Recommended: Install via uv
uv tool install xenfra

# Or via pip
pip install xenfra
```

## 🛠️ Quick Start

### 1. Login

Authenticate with your cloud provider (DigitalOcean via Xenfra Platform).

```bash
xenfra auth login
```

### 2. Deploy Your App

Navigate to your project directory and blast off.

```bash
cd ~/my-projects/awesome-api
xenfra deploy
```

_That's it._ Xenfra handles Dockerfile generation, server provisioning, SSL (Caddy), and database connections.

### 3. Check Status

```bash
xenfra status
```

## 🎛️ Command Reference

| Command             | Description                             |
| :------------------ | :-------------------------------------- |
| `xenfra auth login` | Start the OAuth flow                    |
| `xenfra deploy`     | Deploy current directory                |
| `xenfra logs`       | Tail logs (Ctrl+C to stop)              |
| `xenfra status`     | Show health metrics (CPU/RAM)           |
| `xenfra list`       | List all your projects                  |
| `xenfra init`       | Generate config files without deploying |

## 🔗 The Xenfra Ecosystem

This CLI is the "Interface" of the Xenfra Open Core architecture:

- **[xenfra-sdk](https://github.com/xenfracloud/xenfra-sdk)**: The Core Engine (Used by this CLI).
- **[xenfra-mcp](https://github.com/xenfracloud/xenfra-mcp)**: The AI Agent Interface.
- **xenfra-platform**: The Private SaaS Backend.

## 🤝 Contributing

We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.

## 📄 License

MIT © [Xenfra Cloud](https://xenfra.tech)
python-switchos 0.0.8
Python library to interact with MikroTik SwitchOS and SwitchOS Lite
Requires Python: >=3.10
Keywords: api, mikrotik, switchos, switchos lite

# python-switchos
Python library to interact with MikroTik SwitchOS and SwitchOS Lite

## Features

- Get identity, model, serial number, OS version, MAC and IP address

- Read cpu temperature, current, voltage, and power consumption of the switch

- List ports with name, status, speed, duplex mode etc.

- Check PoE status, power usage, voltage, and current per port

## Installation

Install via pip:

```bash
pip install python-switchos
```

> Requires Python 3.10 or higher

## Dependencies

- demjson3 3.0.6 or higher - for tolerant JSON parsing

## Usage Example


Example with httpx

```python
async def main(host, user, password):
    auth = DigestAuth(user, password)
    async with AsyncClient(auth=auth) as session:
        client = Client(createHttpClient(session), host)
        print(await client.fetch(SystemEndpoint))
```

Example with aiohttp

```python
async def main(host, user, password):
    digest_auth = DigestAuthMiddleware(login=user, password=password)
    async with ClientSession(middlewares=(digest_auth, )) as session:
        client = Client(createHttpClient(session), host)
        return await client.fetch(SystemEndpoint)
```

## Supported Devices

This library targets MikroTik switches running **SwitchOS** or **SwitchOS Lite** and has been tested with:
- Mikrotik CRS326-24G-2S+ running Switch OS 2.18
- MikroTik CSS610-8P-2S+ running Switch OS Lite 2.19 and 2.20

Other models with SwitchOS or SwitchOS Lite may also work.

## License

MIT License

## Contributing

Contributions are welcome!\
Feel free to open issues, submit pull requests, or suggest features.
asdf-standard 1.5.0
The ASDF Standard schemas
Requires Python: >=3.10

ASDF specification and core schemas
===================================
![CI](https://github.com/asdf-format/asdf-standard/actions/workflows/ci.yml/badge.svg)
![Downstream](https://github.com/asdf-format/asdf-standard/actions/workflows/downstream.yml/badge.svg)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
[![DOI](https://zenodo.org/badge/18113139.svg)](https://zenodo.org/badge/latestdoi/18113139)

This document describes the Advanced Scientific Data Format (ASDF),
pronounced *AZ*-diff.  You can read the full specification at [the online documentation](http://asdf-standard.readthedocs.io/).

> This is the **A**dvanced **S**cientific **D**ata **F**ormat - if you are looking for the **A**daptable **S**eismic **D**ata **F**ormat, go here: http://seismic-data.org/


## Contributing
Please open a new [issue](https://github.com/spacetelescope/asdf-standard/issue) or new [pull request](https://github.com/spacetelescope/asdf-standard/pulls) for bugs, feedback, or new features you would like to see. If there is an issue you would like to work on, please leave a comment and we will be happy to assist. New contributions and contributors are very welcome!

There are two mailing lists for ASDF:

* [asdf-users](https://groups.google.com/forum/#!forum/asdf-users)
* [asdf-developers](https://groups.google.com/forum/#!forum/asdf-developers)

## Getting More Information

* [FAQ page](https://github.com/spacetelescope/asdf-standard/wiki/FAQ) on the wiki.
* [ASDF: A new data format for astronomy](https://doi.org/10.1016/j.ascom.2015.06.004), published in *Astronomy and Computing*:

> Greenfield, P., Droettboom, M., & Bray, E. (2015). ASDF: A new data format for astronomy. *Astronomy and Computing*, 12: 240-251.
> doi:[10.1016/j.ascom.2015.06.004](https://doi.org/10.1016/j.ascom.2015.06.004)