semvec/pypi-packages huggingface dataset:
xpdfpghljk 0.4.2
This is just a cython + packaging + cibuildwheel test
Requires Python: >=3.8

# XPDFPGHLJK

This is a Cython + packaging + cibuildwheel test. The name was chosen to avoid a
conflict on PyPI.

## Usage

```bash
$ python3 -m venv venv
$ source venv/bin/activate
$ pip install .
$ cython_test
```
PyFADO 0.0.1
PyFADO is in beta version.

# pyFADO

in processing.... Beta version

<p align="center">
  <img align="center" src="https://github.com/neutrinomuon/AST4001-Extragalactic-Astronomy/blob/master/figures/FADO%20logo%20F-01.jpg?raw=true" width="260">
</p>

Description: This repository contains modules for reading and plotting the output files of FADO in python 3. It also contains a Jupyter Notebook with a <b>quickstart</b> guide on how to run the FADO spectral synthesis code.

You can start by clicking at: <a href='FADO_QuickStartGuide-GITHUB.ipynb'>Quick Start Guide</a>

pyFADO is a Python package for performing spectral synthesis analysis with FADO.

Overview
FADO is a popular code for performing stellar population synthesis modeling of galaxies. pyFADO extends FADO by providing a Python interface for constructing, fitting, and analyzing synthetic spectra.

Some key features of pyFADO include:

Efficient implementation of FADO's spectral synthesis algorithm in Python
Ability to easily load and manipulate observational data
Automatic parameter optimization using Markov Chain Monte Carlo (MCMC) methods
Flexible and customizable model construction and fitting options
Extensive plotting capabilities for visualizing model fits and results
Installation
To install pyFADO, simply clone the repository and install the required dependencies:

bash
Copy code
git clone https://github.com/username/pyfado.git
cd pyfado
pip install -r requirements.txt
Usage
To use pyFADO, you will need to provide a set of observational data and a model grid of synthetic spectra. Once you have loaded your data and model, you can run the fitting algorithm using the pyfado.fit() function.

Here's an example of how to use pyFADO to fit a model to some mock data:

python
Copy code
import pyfado

# Load observational data
data = pyfado.load_data('data.fits')

# Load model grid
model = pyfado.load_model('model.fits')

# Fit model to data
result = pyfado.fit(data, model)

# Plot the results
result.plot()
Documentation
For more information on how to use pyFADO, please refer to the documentation. You can generate the documentation locally by running:

go
Copy code
cd docs
make html
The documentation will then be available in docs/_build/html/index.html.

Contributing
If you would like to contribute to pyFADO, please submit a pull request with your changes. We welcome contributions of all kinds, including bug fixes, new features, and documentation improvements.

License
pyFADO is released under the MIT License. See the LICENSE file for details.

author: Jean Michel Gomes<br>
published: 04/06/2019
terick 0.2.6
Package full of simple functions
Keywords: python,regular,helper


## Terick - Help Library
Publishing this library in hope it will help someone as it helped me. Have fun!
<br><br>
Terick is script pack full of fuctions that might help in every script so you use less
power of brain on scripts that you would retype in every script anyway.
<br><br>

### Update: <br>
- Upgraded: `div_time()` 
- Upgraded: `short_num()`
- Added: `short_bytes()`
- Changed: `file_walk()` name to `scan_dir()`
hfinger 0.2.2
Hfinger - fingerprinting malware HTTP requests stored in pcap files
Requires Python: >=3.3


# Hfinger - fingerprinting malware HTTP requests

Tool for fingerprinting malware HTTP requests. Based on Tshark and written in Python3. Working prototype stage :-)

It's main objective is to provide a representation of malware requests in a shorter form than printing whole request, 
but still human interpretable. This representation should be unique between malware families, 
what means that any fingerprint should be seen only for one particular family.

Project's website: [https://github.com/CERT-Polska/hfinger](https://github.com/CERT-Polska/hfinger).
bindvar 2023.5.0
Bind variables to Python functions.
Requires Python: >=3.8

bindvar
=======

**Bind variables to Python functions**

This is a micropackage with a decorator `@bind` that can be used to bind
objects to Python functions.  The objects can then be loaded into variables in
a function, exactly as they were given, without using globals or closures.

How this works is probably easier shown than explained:

```py
>>> from bindvar import bind
>>>
>>> x = 1
>>>
>>> @bind(x)
... def f():
...     x = "__bound__"
...     print(f"{x=}")
...
>>> del x
>>>
>>> f()
x=1

```

Multiple objects can be bound in a tuple, and assigned to multiple variables:

```py
>>> x, y, z = 1, 2, 3
>>>
>>> @bind(x, y, z)
... def f():
...     x, y, z = "__bound__"
...     print(f"{x=}, {y=}, {z=}")
...
>>> del x, y, z
>>>
>>> f()
x=1, y=2, z=3

```

Variable names in the function do not have to match the names of the bound
objects:

```py
>>> x, y, z = 1, 2, 3
>>>
>>> @bind(x, y, z)
... def f():
...     a, b, c = "__bound__"
...     print(f"{a=}, {b=}, {c=}")
...
>>> del x, y, z
>>>
>>> f()
a=1, b=2, c=3

```

Technically, the binding is achieved by storing the objects in the `co_const`
array of a Python function's code object.  Loading the variables works by
replacing the string literal `"__bound__"` with the bound objects.  The string
`"__bound__"` can therefore not be used for anything else in the decorated
function (strings containing  `"__bound__"` as a substring are not affected).
loggerV 1.0.2
A logger class, and a decorator that works with that class for python
Requires Python: >=3.7

# loggerV
A logger class, and a decorator that works with that class for python
## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install loggerV.

```bash
pip install loggerV
```

## Basic Usage

```python
from loggerV.logger import Logger


# Creates an instance of class Logger
logger = Logger("Logger")

logger.append(
    step="First Log",
    message="Testing",
    success=True,
)
```

## Advanced Usage

```python
from loggerV.logger import Logger
from loggerV.logger import funcLogger


# Create a custom dataclass to use in the logger
class Example:
    def __init__(self, one, two) -> None:
        self.one = one
        self.two = two


# Create a new instance of the Logger class
logger = Logger(name="Logger")


# A method decorated with the funcLogger method. It accepts the logger as an argument.
# fail is what precedence the logger should use if the decorated functions fails. (Optional)
# success is what precedence the logger should use if the decorated function succeeds. (Optional)
# run is what level of logging to use. 0: no loging, even if it fails. 1: log if the function fails. 2: log whether it failsor succeeds
@funcLogger(logger)
def convert(string, run=0, fail=None, success=None):
    return int(string)


# Load the custom class so that it can be used in the logger
logger.loadCustom(
    names=["fieldOne", "fieldTwo"],
    printValues=["One", "Two"],
    defaults=None,
    dontPrintIf=None,
)

# The way partitions work is that each partition has a precedence. There are two partitions by default. main with a precedence of 3 and footer with a precedence of ten.
# Partitions and precedence can be created through the below method, and can be used in the append function. by default append uses partition main (3). 
# Logs in the same partition are ordered by first come first serve
logger.addPartition(name="first", precedence=1)


# Create a new Log
logger.append(
    step="First Log",
    message="Testing",
    custom=Example(
        one="Hello", two="World"
        ),
    success=True,
    partition="main",
)
logger.append("Second Log", "Testing", success=False, partition=1)
logger.append("Third Log")

print(logger)
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)