semvec/pypi-packages huggingface dataset:
pymccool 0.5.6
Reusable Python Utilities by McCool
Requires Python: >=3.8

[![codecov](https://codecov.io/gh/bmccool/pyMcCool/graph/badge.svg?token=T7L4GHQT67)](https://codecov.io/gh/bmccool/pyMcCool)
[![docs](https://readthedocs.org/projects/pymccool/badge/?version=latest)](https://pymccool.readthedocs.io/en/latest/)
[![PyPI - Version](https://img.shields.io/pypi/v/pymccool?cacheSeconds=600)](https://pypi.org/project/pymccool/)
[![GitHub version](https://img.shields.io/github/v/release/bmccool/pymccool?cacheSeconds=600)](https://github.com/bmccool/pymccool)

# Installation
  - `pip install pymccool`

# Usage
- For basic, no-nonsense console and file logging:
  ```python
  from pymccool.logging import Logger
  logger = Logger(app_name="<your app name>")
  ```

- For more options, use LoggerKwargs
    ```python
    from pymccool.logging import Logger, LoggerKwargs
    logger = Logger(
            LoggerKwargs(
                app_name="test_logger_loki",
                default_level=Logger.VERBOSE,
                stream_level=Logger.VERBOSE,
                grafana_loki_endpoint="https://loki.end.point.com/loki/api/v1/push")
    )
    ```

- To use the Tracer:
  ```python
  from uuid import uuid1
  from pymccool.tracing import get_tracer, get_decorator
  from pymccool.logging import Logger, LoggerKwargs
  logger = Logger(
          LoggerKwargs(
              app_name="test_logger_loki",
              default_level=Logger.VERBOSE,
              stream_level=Logger.VERBOSE,
              grafana_loki_endpoint="https://loki.end.point.com/loki/api/v1/push")
  )
  tracer = get_tracer(service_name="test_tracer",
                      endpoint="https://otel-rec.end.point.com/v1/traces",
                      uuid=UUID)
  instrument_decorator = get_decorator(e2e_tracer)
  ```
stdpipeIO 0.1.4
A simple decorator for receiving and sending data via the standard pipe
Requires Python: >=3.6

# stdpipeIO

stdpipeIO is a simple Python decorator for receiving and sending data via the standard pipe. It allows you to easily read input from standard input (stdin) and write output to standard output (stdout).

## Installation

To install stdpipeIO, you can use the following command:

```sh
pip install stdpipeIO
```

## Usage
To use the pipe_io decorator, simply import it and apply it to your function. The decorated function will read input from stdin, process it, and write the result to stdout.

```sh
from stdpipeIO.std_pipe_io import std_pipe_io

@std_pipe_io
def process_input(input_data):
    return input_data.upper()

if __name__ == '__main__':
    process_input()
```

You can then run your script and provide input via stdin:

```sh
echo "Hello, World!" | python your_script.py
```

The output will be:

```sh
HELLO, WORLD!
```

## Testing
To run the tests for stdpipeIO, you can use the following command:

```sh
python -m unittest discover tests
```

## License
This project is licensed under the MIT License. See the LICENSE file for details.

## Author
Greendog - x6reend0g@foxmail.com
emogen 0.0.1
A Python library for generating emotions.
Requires Python: >=3.9

# emogen

[![PyPI - Version](https://img.shields.io/pypi/v/emogen.svg)](https://pypi.org/project/emogen)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/emogen.svg)](https://pypi.org/project/emogen)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install emogen
```

## License

`emogen` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
soltxs 1.0.8
Solana transaction normalizer, parser, and resolver.
Requires Python: >=3.10

# 📟 Solana Transactions _(soltxs)_

Solana transaction normalizer, parser, and resolver.

## Installing

```bash
pip install soltxs
```

## Overview

This library breaks down Solana transaction introspection and analysis into three steps: 

1. **Normalize**: Converts a raw JSON RPC payload into a `Transaction` object.
2. **Parse**: Routes each instruction in the `Transaction` to the correct program-level parser. Produces objects describing each recognized instruction.
3. **Resolve**: Takes the parsed instructions and converts them into a more human-readable format.

#### Support 

* Normalizers
    * Standard RPC Response
    * Modified YellowStone Geyser Response
* Parsers
    * Compute Budget
    * System Program
    * Token Program
    * PumpFun Program
    * Raydium AMM Program
* Resolvers
    * PumpFun Swap
    * Raydium Swap

## Usage

```python
import soltxs

tx = {"jsonrpc": ..., "result": ..., "id": ...}

# All three steps below can be combined into a single call.
# Equivalent to: resolve(parse(normalize(tx)))
result = soltxs.process(tx)

norm_tx = soltxs.normalize(tx)
# Transaction(
#     slot=...,
#     blockTime=...,
#     signatures=[...],
#     message=...,
#     meta=...,
#     loadedAddresses=...,
# )

parsed_data = soltxs.parse(norm_tx)
# ParsedTransaction(
#     signatures=[...],
#     instructions=[
#         <ComputeBudget.SetComputeUnitLimit(...)>,
#         <ComputeBudget.SetComputeUnitPrice(...)>,
#         <SystemProgram.CreateAccount(...)>,
#         <TokenProgram.InitAccount(...)>,
#         <RaydiumAMM.Swap(...)>,
#         <TokenProgram.Unknown(...)>,
#         <SystemProgram.Transfer(...)>,
#         <UnknownProgram.Unknown(...)>,
#     ],
#     Addons(
#         compute_units=<ComputeUnits(...)>,
#         instruction_count=<InstructionCount(...)>,
#         loaded_addresses=<LoadedAddresses(...)>
#         platform_identifier=<PlatformIdentifier(...)>,
#         token_transfer_summary=<TokenTransfer(...)>
#     )
# )

resolved_tx = soltxs.resolve(parsed_data)
# For example, a Raydium resolved output might be:
# Raydium(
#     type=...,
#     who=...,
#     from_token=...,
#     from_amount=...,
#     to_token=...,
#     to_amount=...,
#     minimum_amount_out=...
# )
```
dyntrack 1.1.4
Python package for the study of particle dynamics from 2D tracks
Requires Python: >=3.9

[![PyPI](https://img.shields.io/pypi/v/dyntrack.svg)](https://pypi.python.org/pypi/dyntrack/)
[![Platform](https://img.shields.io/badge/platform-linux--64%20|%20osx--64%20|%20win--64-blueviolet)](https://pypi.org/project/dyntrack/#files)
[![Documentation Status](https://readthedocs.org/projects/dyntrack/badge/?version=latest)](https://dyntrack.readthedocs.io/en/latest/?badge=latest)
[![Build & Test](https://github.com/LouisFaure/dyntrack/actions/workflows/test.yml/badge.svg)](https://github.com/LouisFaure/dyntrack/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/LouisFaure/dyntrack/branch/main/graph/badge.svg)](https://codecov.io/gh/LouisFaure/dyntrack)
[![DOI](https://img.shields.io/badge/DOI-10.1016/j.cub.2022.04.054-blue)](https://doi.org/10.1016/j.cub.2022.04.054)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://github.com/LouisFaure/dyntrack/blob/master/LICENSE)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

# DynTrack

Python package for the study of particle dynamics from 2D tracks

Installation
------------

```bash
pip install -U dyntrack
```

Usage
-----

```python
import dyntrack as dt

DT = dt.ut.load_data("tracks.csv","Position X","Position Y","Parent","Time","background.tiff")

dt.tl.vector_field(DT)
dt.pl.vector_field(DT)

dt.tl.FTLE(DT, 20000,5)
dt.pl.FTLE(DT)

dt.tl.fit_ppt(DT,seed=1)
dt.pl.fit_ppt(DT)
```

Workflow
--------

![](https://github.com/LouisFaure/dyntrack/raw/main/docs/workflow.png)


Source build and run issues with windows
----------------------------------------

If missing DLL errors occurs while running, or gcc is not available while building from source please install MinGW-w64:

```powershell
choco install mingw
```

Citations and used works
------------------------

### Vector field building


The function `dyntrack.tl.vector_field` uses
[vfkm](https://github.com/nivan/vfkm/) to generate vector fields (see
[license](https://github.com/LouisFaure/dyntrack/blob/main/vfkm/LICENSE)),
please cite the related study if you use it:


    Ferreira, N., Klosowski, J. T., Scheidegger, C. & Silva, C.
    Vector Field k-Means: Clustering Trajectories by Fitting Multiple Vector Fields.
    Comput. Graph. Forum 32, 201–210 (2012).


### FTLE scalar field generation

Code from `dyntrack.tl.FTLE` have been adapted and optimized from [Richard
Galvez's
notebook](https://github.com/richardagalvez/Vortices-Python/blob/master/Vortex-FTLE.ipynb).


### Principal tree fitting with SimplePPT

Code from `dyntrack.tl.fit_ppt` uses SimplePPT algorithm to fit principal trees on each frames.
SimplePPT has been described in the following paper:

    Mao et al. (2015), SimplePPT: A simple principal tree algorithm
    SIAM International Conference on Data Mining.
jaraco.net 10.2.3
Networking tools by jaraco
Requires Python: >=3.9

.. image:: https://img.shields.io/pypi/v/jaraco.net.svg
   :target: https://pypi.org/project/jaraco.net

.. image:: https://img.shields.io/pypi/pyversions/jaraco.net.svg

.. image:: https://github.com/jaraco/jaraco.net/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.net/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. image:: https://readthedocs.org/projects/jaraconet/badge/?version=latest
   :target: https://jaraconet.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2025-informational
   :target: https://blog.jaraco.com/skeleton

``jaraco.net`` provides miscellaneous utility functions used across
projects developed by the author.

DNS Forwarding Service
----------------------

``jaraco.net`` includes a DNS forwarding service for Windows. This is
because Microsoft appears to be unable to bind to 6 to 4 and Teredo
addresses with their production DNS Server. After installing
``jaraco.net``, the service executable is available as
`%PYTHON%\Scripts\dns-forward-service.exe`. In addition to the
documented install/uninstall/start/stop commands, it's also possible
to configure a bind address with the -b option. For example::

    dns-forward-service -b 2002:41de:a625::41de:a625 install

The service will be installed and the bind address will be stored in
`HKLM\Software\jaraco.net\DNS Forwarding Service\Listen Address`. Note
that the service must be restarted to recognize an updated bind address.
codejump 0.1.3
A Python library for controlled code jumps using checkpoints and teleportation.
Requires Python: >=3.6

# CodeJump

CodeJump is a fun Python library that allows for controlled execution of code with checkpoints and teleportation. It enables users to jump to specific points in the code, run particular segments as needed, and execute code step-by-step.

## Features
It is just a fun library, not very efficient. 
- **checkpoint**: Register points in the code to "jump" to.
- **teleport_to**: Jump to specific checkpoints during execution.
- **jumprun**: Execute code step by step while managing jumps.


## Installation

You can install **CodeJump** via pip:
```bash
pip install codejump
```
## Usage

Here’s how to use CodeJump in your Python scripts:
checkpoints and teleports can be used only in a function and ```jumprun(func_name)``` should be used to execute the function. 

```python
from codejump import checkpoint, teleport_to, jumprun

def main():
    checkpoint("start")
    print("Inside Start")
    teleport_to("end")
    
    #the code below gets skipped
    checkpoint("middle")
    print("Inside Middle")
    teleport_to("end")
    #the code above gets skipped
    
    checkpoint("end")
    print("Inside End")
    
jumprun(main)
```
Output:
```
 Inside Start
 Inside End
```
## License
This project is licensed under the MIT License - see the LICENSE file for details.

## Contact
For any inquiries or questions, feel free to reach out to us via GitHub Issues.
GitHub Repository: [CodeJump on GitHub](https://github.com/Ami-sh/codejump)