semvec/pypi-packages huggingface dataset:
pyfingerd 0.5.1
finger (RFC 1288) server-side daemon
Requires Python: >=3.11,<4.0
Keywords: finger,fingerd,rfc742,rfc1288,79,tcp/79

finger (RFC 1288) server-side daemon
====================================

finger is both a protocol and a utility to get the information and status
from a user on a distant machine. It was standardized in `RFC 742`_
in 1977, then in `RFC 1288`_ in 1991, and has been abandoned since.

While describing the protocol in `a blog post of mine`_, I wanted
to implement this protocol for fun, but didn't want to present the
real information about the users on my server, so I made this to present
some fictional information in order to be able to tell a story through
finger.

For more information, consult the following links:

* `pyfingerd documentation`_;
* `PyPI package detail`_;
* `Issue tracker`_;
* `Pending contributions`_.

.. _RFC 742: https://tools.ietf.org/html/rfc742
.. _RFC 1288: https://tools.ietf.org/html/rfc1288
.. _a blog post of mine: https://thomas.touhey.fr/2018/09/12/finger.en.html
.. _pyfingerd documentation: https://pyfingerd.org/
.. _PyPI package detail: https://pypi.org/project/pyfingerd/
.. _Issue tracker: https://gitlab.com/pyfingerd/pyfingerd/-/issues
.. _Pending contributions:
    https://gitlab.com/pyfingerd/pyfingerd/-/merge_requests
fastdev-py 0.5.0
FastAPI development server that JIT preprocess TS, TSX, SCSS, etc... files.
Requires Python: >=3.11
Keywords: devserver,dev-server,devtools,sever,liveserver,live-server

### fastdev_py

FastAPI development server that JIT preprocess TS, TSX, SCSS, etc... files without littering your filesystem at all. <br>
also, has in-memory caching of preprocessed files. <br>
under the hood, it uses Deno along with a webassembly version of esbuild to transform your requested files
sampleReddit 0.1.5
Take snowball samples of Reddit data
Requires Python: >=3.10
Keywords: data,praw,reddit,sample,snowball,social media

# sampleReddit 🫴

A streamlined interface for generating snowball samples of Reddit data. 

Snowball sampling is a data collection method that starts with a small set of seeds and iteratively collects data from their connections. This method is particularly useful for collecting data from social media platforms, where the connections between users and communities are often of primary interest. sampleReddit also outputs full documentation of each sampling process.

## Installation

sampleReddit can be installed from PyPI using pip:

```bash
pip install sampleReddit
```

## Quick Start

An annotated example of how to go from a list of seed subreddits to a snowball sample of Reddit comments can be found in this [script](https://github.com/ReedMerrill/sampleReddit-example-files/blob/main/scripts/example-comment-sampling.py).

## Usage

The core functionality of sampleReddit resides in the `sample_reddit` function:

```python
import sampleReddit as sr

sampling_frame, users_df = sr.sample_reddit(
    api_instance=instance,
    seed_subreddits=["politics", "news"],
    post_filter="top",
    time_period="year",
    n_posts="3",
    log_file_path="path/to/log/file.log",
)
```

The above function will conduct a snowball sample of Reddit users by collecting the top 3 posts from the "politics" and "news" subreddits from the past year and then the usernames of all the users who commented on those posts. The function returns two things:

1. A Python dictionary object that documents the sampling frame. It maps subreddits to posts and posts to comments.
2. A `pandas` `DataFrame` with a single column called "users" that lists the users who were sampled.

The library also provides lower-level functions that only sample posts from a subreddit, or comments from a list of posts IDs. For a full list of functions, see the [documentation](https://github.com/ReedMerrill/sampleReddit/wiki).

**Note:** Any access to the Reddit API requires an application that is registered with Reddit via their developer portal. Once your app is registered the `setup_access` function can be used to create an authenticated Reddit API instance. For instructions on how to set up a registered Reddit API application, refer to [this guide](https://github.com/reddit-archive/reddit/wiki/OAuth2-App-Types#script-app).[^1]

[^1]: You will need a regular Reddit user account to complete the app authentication setup.

Testing is performed on Python 3.10, but everything should work on 3.6 or later.

## Documentation

Full package documentation can be found in this repo's [wiki](https://github.com/ReedMerrill/sampleReddit/wiki).

## Acknowledgments

sampleReddit is built on top of the [PRAW](https://github.com/praw-dev/praw) (Python Reddit API Wrapper) library, which provides a comprehensive and flexible interface for the Reddit API.
VintedAPIClient 0.1.1
Python client for scraping Vinted website
Requires Python: >=3.6


# VintedAPIClient

## Installation

You can install the package using pip:

```bash
pip install VintedAPIClient
```

## Usage


```python
from VintedAPIClient.VintedAPI import VintedAPI

# Initialize the API client
api = VintedAPI()

# Retrieve a list of items based on a search query
# query: String containing the search keywords
# page: Integer indicating the page number to retrieve (approximately 100 items per page)
items = api.get_list_items("query", page)

# Download images for a specific item
# url: Vinted URL corresponding to an item
# destination_folder: Folder path where the images should be saved
# Images will be saved sequentially as "imgNUMBER.jpg"
api.download_images_by_url(url, destination_folder)

```
d2x-cli 0.0.3
A command line interface to MuseLab's D2X Cloud for running automation against Salesforce orgs
Requires Python: >=3.8

# D2X CLI

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

---

**Table of Contents**

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

## Installation

```console
pip install d2x-cli
```

## License

`d2x-cli` is distributed under the terms of the [BSD3](https://spdx.org/licenses/BSD3.html) license.
shshsh 1.0.6
bridge of python and shell
Requires Python: >=3.8,<4.0

# shshsh 🐍❤️🐚
[![PyPI](https://img.shields.io/badge/python-3.8%7C3.9%7C3.10%7C3.11-blue.svg)](https://pypi.org/project/shshsh/)

Shshsh is a bridge connects python and shell.
- A simple way to write shell commands in Python.
- Flexibility.
- Support for directly chaining a Python function in a pipeline.

## Installation
To install shshsh with pip, run: `pip install shshsh`

To install shshsh with conda, run: `conda install shshsh -c conda-forge`

To install shshsh from source, clone the repository and run: `pip install poetry;poetry install`

⚠️ **If you are using python3.8**: Be very careful with python function Pipe, there are known bugs!

## Basic Usage
You can use `I >> "[command]"` or `Sh("[command]")`in any Python project.

Here's an example of getting all file which name contains "test":
```python
from shshsh import I, IZ

for filename in I >> "ls" | "grep test":
    print(filename)

# zero mode, split line by "\x00"
for filename in IZ >> "ls" | "grep test":
    print(filename)
```

Also, you can safely pass parameter without worrying about command injection; shshsh will help you escape all bash control characters:
```python
from shshsh import I
from sys import stdout

res = (I >> "echo #{}") % "dangerous; cat /etc/passwd" | stdout
res.wait()
# dangerous; cat /etc/passwd

```

To operate on the current working directory (cwd):
```python
from shshsh.utils import cwd

# change dir
after_change_path = cwd("../../")

# to get current cwd, just don't give any parameter
cwd()

```

Python functions or iterables can be part of the chain. You no longer have to search Google (or chatgpt) repeatedly to write `sed` or `awk` 😇:
```python
from shshsh import I
from sys import stdout

# as map function
def add_suffix(line: str) -> str:
    return line + ".py"

res = I >> "ls -alh" | add_suffix | "grep test" | stdout
res.wait()

# as data source
def data_source():
    for i in range(10):
        yield f"test{i}"

res = I >> data_source() | "grep test1" | stdout
res.wait()

```

By default, stderr will directly redirect to current Python process's stderr. 

But you can also keep its result using the redirect expr `>=` for stderr and `>` for stdout:

```python
from shshsh import I, keep

res = I >> "ls not_exist" >= keep
res.wait()

print(res.stderr.read())

```

The redirect expression can redirect the stream to any kind of IO object:
```python
from shshsh import I

with open("res", "w") as f:
    # redirect stdout to file.
    res = I >> "echo 123" > f
    # redirect stderr to file.
    res1 = I >> "ls not_exist" >= f
    res1.wait()
    res.wait()

```
nlbq 0.1.7
Natural language to BigQuery
Requires Python: >=3.11

# nlbq
Natural language interface to BigQuery

## Google credentials

The Python BigQuery library expects the environment variable `GOOGLE_APPLICATION_CREDENTIALS`, which should point to a JSON file containing the credentials of a Google service account. You can create a service account and download its credentials from the [Google Cloud Console](https://console.cloud.google.com/iam-admin/serviceaccounts). Then set the environment variable:

```bash
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/your/google-service-account.json
```

## Creating a demo environment

```bash
mkdir demo # Git will ignore this directory
cd demo
python3 -m venv venv
source venv/bin/activate
pip install -e ../ # Install the local package in editable mode
nlbq init  # generates prompt.txt, Dockerfile and index.html
# make changes then
pip uninstall nlbq --yes; pip install -e ../
```

You can initialise with prepopulated BigQuery dataset table schema information with

```bash
nlbq init --table dataset.table_id
```

## Usage

```bash
nlbq --help
```