semvec/pypi-packages huggingface dataset:
slurpit_sdk 0.9.135
A robust Python SDK for slurpit
Requires Python: >=3.8

# Slurpit SDK

The Slurpit SDK is a Python package for interacting with the Slurpit API, enabling developers to easily manage devices and planning resources. It is designed for simplicity and flexibility, offering methods for listing devices, retrieving planning data, and exporting information to CSV format.

## Installation

Install the SDK:

```bash
pip install slurpit_sdk
```

To run the examples, install dependencies using Poetry (recommended):

```bash
poetry install
```

Alternatively, use pip:

```bash
pip install -r requirements.txt
```

To build from source:

```bash
cd src
python setup.py install
```

## Quick Start

To quickly test the examples, copy `.env.example` to `.env` (includes default sandbox credentials):

```bash
# From the examples/ folder run:
cp .env.example .env
```

## Working with Devices

Retrieve and print the hostnames of all devices:

```python
devices = api.device.get_devices()
for device in devices:
    print(device.hostname)
```

## Exporting Data to CSV

To export planning data to a CSV file:

```python
plannings_csvdata = api.planning.get_plannings(export_csv=True)
result = api.device.save_csv_bytes(plannings_csvdata, "csv/plannings.csv")
```
## Exporting Data as Pandas DataFrame

To export planning data as a pandas dataframe

```python
plannings_df = api.planning.get_plannings(export_df=True)
```

## Pagination

Handle large sets of devices with pagination:

```python
devices = api.device.get_devices(offset=100, limit=1000)
for device in devices:
    print(device.hostname)
```
endf 0.1.12
Python interface to ENDF-6 files
Requires Python: >=3.10

# ENDF Python Interface

[![License](https://img.shields.io/badge/license-MIT-green)](https://opensource.org/licenses/MIT)
[![PyPI](https://img.shields.io/pypi/v/endf?label=PyPI)](https://pypi.org/project/endf)

`endf` is a Python package for reading and interpreting
[ENDF-6](https://doi.org/10.2172/1425114) and
[ACE](https://github.com/NuclearData/ACEFormat) format nuclear data files.
Compared to other packages that provide functionality for working with ENDF and
ACE files, this package has numerous advantages:

- Easily installable through `pip`
- Thoughtful API design targeting Python first
- Offers both a low-level interface for working with the raw data in an ENDF
  file as well as a more intuitive high-level interface
- Fast file-loading performance thanks to optimized read routines
- Fully documented, tested, and type-hinted

## Installation

The `endf` Python package can be installed from the [Python Package
Index](https://pypi.org/project/endf/) using `pip`:

```sh
python -m pip install endf
```

## Documentation

For information on how to use the `endf` package and a full API reference,
please see the [online documentation](https://endf-python.readthedocs.io).
history4feed 1.1.6
Creates a complete full text historical archive for an RSS or ATOM feed.
Requires Python: >=3.9

# history4feed

[![codecov](https://codecov.io/gh/muchdogesec/history4feed/graph/badge.svg?token=3Z5LELB8OP)](https://codecov.io/gh/muchdogesec/history4feed)

## Before you begin...

![](docs/obstracts.png)

We use history4feed in the web version of Obstracts which includes many additional features over those in this codebase. [You can find out more about the web version here](https://www.obstracts.com/).

## Overview

![](docs/history4feed.png)

It is common for feeds (RSS or XML) to only include a limited number of posts. I generally see the latest 3 - 5 posts of a blog in a feed. For blogs that have been operating for years, this means potentially thousands of posts are missed.

There is no way to page through historic articles using an RSS or ATOM feed (they were not designed for this), which means the first poll of the feed will only contain the limited number of articles in the feed. This limit is defined by the blog owner.

history4feed can be used to create a complete history for a blog and output it as an RSS feed.

history4feed offers an API interface that;

1. takes an RSS / ATOM feed URL
2. downloads a Wayback Machine archive for the feed
3. identified all unique blog posts in the historic feeds downloaded
4. downloads a HTML version of the article content on each page
5. stores the post record in the databases
6. exposes the posts as JSON or XML RSS

## Install

### Download and configure

```shell
# clone the latest code
git clone https://github.com/muchdogesec/history4feed
```

### Configuration options

history4feed has various settings that are defined in an `.env` file.

To create a template for the file:

```shell
cp .env.example .env
```

To see more information about how to set the variables, and what they do, read the `.env.markdown` file.

### Build the Docker Image

```shell
sudo docker compose build
```

### Start the server

```shell
sudo docker compose up
```

### Access the server

The webserver (Django) should now be running on: http://127.0.0.1:8002/

You can access the Swagger UI for the API in a browser at: http://127.0.0.1:8002/api/schema/swagger-ui/

## Useful supporting tools

* [Full Text, Full Archive RSS Feeds for any Blog](https://www.dogesec.com/blog/full_text_rss_atom_blog_feeds/)
* [An up-to-date list of threat intel blogs that post cyber threat intelligence research](https://github.com/muchdogesec/awesome_threat_intel_blogs)
* [Donate to the Wayback Machine](https://archive.org/donate)

## Support

[Minimal support provided via the DOGESEC community](https://community.dogesec.com/).

## License

[Apache 2.0](/LICENSE).