semvec/pypi-packages huggingface dataset:
codeworks 0.0.2rc38.post1
CodeWorks python package
Requires Python: >=3.8.1

# CodeWorks

... 

## Getting Started

To get started with this template, simply 'Use This Template' to create a new repository and start building your project within the `src` directory. Try to open the project in GitHub Codespace, and to run the unit tests using the VS Code Test extension.

## Contributing

This project welcomes contributions and suggestions. For details, visit the repository's [Contributor License Agreement (CLA)](https://cla.opensource.microsoft.com) and [Code of Conduct](https://opensource.microsoft.com/codeofconduct/) pages.
FINKER 1.0.1
A universal approach to optimal frequency identification using nonparametric kernel regression
Requires Python: >=3.6



![FINKER Logo](https://see.fontimg.com/api/renderfont4/KpAp/eyJyIjoiZnMiLCJoIjo3NywidyI6MTAwMCwiZnMiOjc3LCJmZ2MiOiIjQjgxODIwIiwiYmdjIjoiI0ZGRkZGRiIsInQiOjF9/RklOS0VS/kg-second-chances-sketch.png)


## Overview

FINKER (Frequency Identification through Nonparametric Kernel Regression) is an advanced statistical tool for optimal frequency identification using nonparametric kernel regression. It is designed to offer more accurate estimation in various contexts, including handling measurement uncertainties and facilitating multiband processing, even with as few as 10 observations. The project leverages the power of kernel regression methods to provide robust, flexible analysis, particularly valuable in astronomical and statistical applications.

## Features

- **Local Linear and Constant Regression**: Utilizes local regression techniques for precise modeling.
- **Kernel Functions and Bandwidth Calculation**: Includes Gaussian kernel and implements a custom fixed bandwidth for computational efficiency. Multiple other options are available: Silverman's rule, Scott's rule, and an Adaptive bandwidth.
- **Multiband Processing**: Capable of handling multi-band data efficiently.
- **Error Handling**: Robust to measurement uncertainties, enhancing reliability in real-world datasets.

## Installation

To use FINKER, clone the repository or install with:

```bash
pip install FINKER
```

## Usage

Here's a simple example to demonstrate the use of FINKER's kernel regression functions:

```python
from FINKER.utils_FINKER import *

# Creating a FINKER instance
finker = FINKER()

# Running a parallel FINKER search
best_freq, freq_err, result_dict = finker.parallel_nonparametric_kernel_regression(
    t_observed=t_observed,
    y_observed=y_observed,
    uncertainties=uncertainties,
    freq_list=freq,
    show_plot=False,
    kernel_type='gaussian',
    regression_type='local_constant',
    bandwidth_method='custom',
    n_jobs=-2
)
```

Replace `t_observed`, `y_observed`, and `uncertainties` with numpy arrays of your observations.
Replace `freq` with a numpy array of the ferquencies to search.

## Contributing

Contributions to FINKER are welcome! Please read our [contributing guidelines](CONTRIBUTING.md) for more information on how to get involved.

## License

This project is licensed under the [Apache License](LICENSE) - see the LICENSE file for details.

## Contact

For any queries or further information, please reach out to f.stoppa@astro.ru.nl.
allure-unittest 0.0.2
unittest Allure integration
Requires Python: >=3.6

# allure-unittest

unittest Allure integration

```python
import unittest
from allure_unittest import Run


class Activity(unittest.TestCase):
    def test_1(self):
        self._testMethodDoc = "test 1 == 1"
        self.assertEqual(1, 1)

    def test_2(self):
        self._testMethodDoc = "test 1 == 2"
        self.assertEqual(1, 2)

    def test_3(self):
        self._testMethodDoc = "test 2 == 3"
        self.assertEqual(2, 3, "2 not Equal 3")


if __name__ == '__main__':
    c = unittest.defaultTestLoader.loadTestsFromTestCase(Activity)
    Run('test', c, clean=True)
```
glimlach 0.4.7
Glimlach is a project that allows you to easily run Docker images based on a configuration file.

   Glimlach is a cybersecurity automation tool designed to streamline the execution of multiple open-source security tools in a single scan. The project is initiated to support Rauli's research, enabling automated complex security scans with commonly used tools like Nmap, Testssl.sh, and Ssh-audit. This tool is a Python script that allows you to run Docker tools in parallel based on a JSON configuration file. It is designed to make it easy to automate the execution of Docker images with customizable parameters.

The primary objective is to facilitate the execution of various cybersecurity tools as a single scan without the need for individual installations and configurations. Glimlach focuses on the containerized execution (OCI) of tools, allowing for isolation and reproducibility.
llm-loop 0.2
A utility package for querying language models with pattern matching and retry logic

# llm-loop

## Overview

`llm-loop` is a Python package designed to simplify the process of querying language models (like GPT or similar models) until a response matching a specified pattern is obtained or a maximum number of attempts is reached. This is particularly useful when working with AI models in scenarios where a specific format of response is required.

## Installation

```bash
pip install llm-loop
```

   This will install the necessary Python packages, including `ctransformers` and any other dependencies.

## Usage

Here's a basic example of how to use `llm-loop`:

1. **Import the necessary modules:**
   ```python
   import os
   from ctransformers import AutoModelForCausalLM, AutoTokenizer
   from llm_loop.main import LLMLoop
   ```

2. **Initialize the model with custom parameters:**
   ```python
   model_name = "YourModelName"
   model_file = "YourModelFileName"
   start_dir = '/path/to/your/model'
   model_path = f"{start_dir}/{model_file}"

   llm = AutoModelForCausalLM.from_pretrained(model_name, model_file=model_path, model_type='YourModelType', gpu_layers=YourGPULayers)
   ```

3. **Create an instance of LLMLoop and query the model:**
   ```python
   loop = LLMLoop(llm, 10)  # 10 is the maximum number of attempts

   prompt = "Your prompt here"
   pattern = r'Your regex pattern here'

   response = loop.query_llm(prompt=prompt, pattern=pattern)

   print("Response:", response)
   ```

## Contributing

Contributions to `llm-loop` are welcome! Please feel free to submit pull requests or open issues to suggest improvements or add new features.

## License

MIT.
colorama-terminal 0.0.1
在终端有颜色地打印python变量
Requires Python: >=3.6

# colorama-terminal

在终端有颜色地打印python变量。


## 使用

带颜色的字符串 `Colormsg` 类

```python
import colorama_terminal as ct

# 打印紫色的你好
hello = ct.Colormsg("helloworld").set_color('MAGENTA')
print(hello)

# 打印复杂的数据
raw_colormsg = ct.Colormsg.from_built_in_type([{1: True}, {"2": False}])
print(raw_colormsg)

# 打印复杂的数据
ct.print([{1: True}, {"2": False}])
```

其他功能  `proportion_bar shell` 函数

```python
from colorama_terminal import * #内置的print被覆盖了
# 进度条
import time
for i in range(0, 101):
    time.sleep(0.02)
    proportion_bar(i / 100, 'MAGENTA')
print('\nOK')

# 进入交互式
shell()
```