semvec/pypi-packages huggingface dataset:
ruff-pyspark-filter-linter 0.1.0
Custom Ruff linter to ensure specific filters in PySpark DataFrame creation
Requires Python: >=3.6

# Ruff PySpark Filter Linter

This package provides a custom Ruff linter to ensure that all PySpark DataFrame instances include specified filters.

## Installation

```bash
pip install ruff_pyspark_filter_linter
````

## Usage
1. Create a ruff_pyspark_filter_linter.json configuration file with the required filters:
```json
{
  "required_filters": ["account_id", "user_id", "session_id"]
}

```

2. Running the linter on your Python files:

```bash
ruff-pyspark-filter-linter path/to/your_code.py
```

The linter will print warnings and generate a README_Rust_YYYYMMDDHHMMSS.md file with details of any missing filters.

## Building the Package

Build the source and wheel distributions.

```bash
python setup.py sdist bdist_wheel
```

## Upload to PyPI
twine upload dist/*
toolshelf-ui 0.0.5
A versatile tool management utility for developers
Keywords: python, command-line, tool, TUI, Terminal User Interface


## Why ToolShelf?
ToolShelf simplifies the management of tool-related information, providing a single command-line interface to handle your tool inventory. It's designed to be straightforward, making it perfect for users who want a quick and efficient way to organize their tools without the need for a complex database or software solution.

In essence, ToolShelf is like a digital toolbox for your terminal tools, helping you keep everything organized and easily accessible, so you can focus on your work without worrying about tool management.

## Integration with Other Package Managers

There are many package managers like npm, pip, apt, brew, and cargo that help you manage libraries and packages for different programming languages and systems. ToolShelf complements these package managers by providing a unified way to manage all your tools, regardless of their installation method.

**Key Features:**
Tool Management: Quickly add new tools, list all your tools, update existing ones, or remove tools you no longer need.

  - Tool Management: Quickly add new tools, list all your tools, update existing ones, or   remove tools you no longer need.
 - Data Persistence: Stores all tool data in a SQLite Database.
   located in your home directory under ~/.local/share/toolshelf, ensuring
   that your tool information is always saved and easily retrievable.
 - Easy Installation and Usage: Simple to install via pip and easy to
   use through straightforward command-line commands.
 - Lightweight and Portable: Designed to be lightweight and run
   efficiently on any system with Python installed, making it ideal for
   use in various environments.

## Commands
  - Enter to start the tool you have selected.
  - Delete to delete a tool.
  - E to edit a tool.
  - P to copy the command.

![alt text](static/example.gif)

## How to install
pip install toolshelf

## How to build
Use the build.sh script to build locally.
django-urls-templateview 1.0.2
Django urls.py TemplateView urlpatterns
Keywords: django

### Installation
```bash
$ pip install django-urls-templateview
```

#### `settings.py`
```python
INSTALLED_APPS+=['django_urls_templateview']
```

#### `migrate`
```bash
$ python manage.py migrate
```

### Features
+   `urls.py` TemplateView `urlpatterns`
+   admin

### Models
model|table|columns/fields
-|-|-
`Map`|`django_urls_templateview`|`id`,`url`,`template_name`

### Examples
`urls.py`
```python
from django.db import connection
from django.views.generic.base import TemplateView

urlpatterns = []

cursor = connection.cursor()
cursor.execute("SELECT url,template_name FROM public.django_urls_templateview")
for url,template_name in cursor.fetchall():
    urlpatterns.insert(0,path(url, TemplateView.as_view(template_name=template_name)))
```
bulk-checksum 0.0.1
CLI utility for verifiying bulk file copying
Requires Python: >=3.9

# Purpose
CLI utility for verifying if a bulk file copy operation was successful.

# Usage
This tool is meant to be used after all files have been copied from a 'source' to 'destination' directory.

1. Run `bulk_checksum_generate` to create a checksum for every file in the source root directory.
The output of this will be a `checksum.json` file.
1. Run the same command in the destination directory.
1. Run `bulk_checksum_compare` on the two checksum files.
If there were any erros in copying the data, the resulting mismatches will be reported by the output of this function.
django-command-exception 1.0.2
Django python exception model, admin, logging handler, middleware and excepthook
Keywords: django

### Installation
```bash
$ pip install django-command-exception
```

#### `settings.py`
```python
INSTALLED_APPS+=['django_command_exception']
```

#### `migrate`
```bash
$ python manage.py migrate
```

### Models
model|table|columns/fields
-|-|-
`CommandException`|`django_command_exception`|id,command,exc_class,exc_message,exc_traceback,created_at

### Examples
`call_command`
```python
from django_command_exception.models import CommandException

try:
    call_command(name)
except Exception as e:
    CommandException(command=name).save()
```

`BaseCommand`
```python
from django_command_exception.models import CommandException

class BaseCommand(BaseCommand):
    def execute(self, *args, **options):
        try:
            return super().execute(*args, **options)
        except Exception as e:
            CommandException(command=type(self).__module__.split('.')[-1]).save()
```

`CommandExceptionMixin`
```python
from django_command_exception.mixins import CommandExceptionMixin

class Command(CommandExceptionMixin,BaseCommand):
    def handle(self, *args, **options):
        try:
            ...
        except Exception as e:
            self.error(e)
```
smiles-autoencoder 0.1.0
Autoencoders for SMILES strings
Requires Python: >=3.11

# smiles-autoencoder

[![GitHub version](https://badge.fury.io/gh/tjkessler%2Fsmiles-autoencoder.svg)](https://badge.fury.io/gh/tjkessler%2Fsmiles-autoencoder)
[![PyPI version](https://badge.fury.io/py/smiles-autoencoder.svg)](https://badge.fury.io/py/smiles-autoencoder)
![GitHub License](https://img.shields.io/github/license/tjkessler/smiles-autoencoder)

LSTM-based autoencoders for SMILES strings

# Installation

```
$ pip install smiles-autoencoder
```

or

```
$ git clone https://gitlab.com/tjkessler/smiles-autoencoder
$ cd smiles-autoencoder
$ pip install .
```

# Usage

### One-hot encoding

```python
from smiles_autoencoder.encoding import SmilesEncoder


smiles: List[str] = [...]

encoder = SmilesEncoder()
encoder.fit(smiles)

encoded_smiles: numpy.ndarray = encoder.encode_many(smiles)
# encoded_smiles.shape == (n_smiles_strings, sequence_length, n_unique_characters)
```

### Autoencoding

```python
import torch
import torch.nn as nn

from smiles_autoencoder.model import LSTMAutoencoder


encoded_smiles = torch.tensor(encoded_smiles, dtype=torch.float32)

autoencoder = LSTMAutoencoder(
    input_size=encoded_smiles.shape[2],
    hidden_size=64,
    latent_size=12,
    num_lstm_layers=1
)

opt = torch.optim.Adam(autoencoder.parameters(), lr=0.001)
loss_crit = nn.L1Loss(reduction="sum")

for epoch in range(8):

    for enc_smiles in encoded_smiles:

        opt.zero_grad()
        pred = autoencoder(enc_smiles)
        loss = loss_crit(pred, enc_smiles)
        loss.backward()
        opt.step()
```

### Decoding predictions

```python
pred_smiles: torch.Tensor = autoencoder(encoded_smiles[0])
pred_smiles: str = encoder.decode(torch.round(pred_smiles).detach().numpy().astype(int))
```

# Contributing, Reporting Issues and Other Support:

To contribute to smiles-autoencoder, make a pull request. Contributions should include tests for new features added, as well as extensive documentation.

To report problems with the software or feature requests, file an issue. When reporting problems, include information such as error messages, your OS/environment and Python version.

For additional support/questions, contact Travis Kessler (travis.j.kessler@gmail.com).
CaseLawSscraper 0.1
A short description of your package
Requires Python: >=3.6

# **CaseLawScraper**
------
CaseLawScraper is a module that allows you to retrieve judgments and decisions information from 2003 onwards, from Find case law in a friendly, Pythonic way without having to solve CAPTCHAs.

## Installation
-----
CaseLawScraper can be installed with pip. To install using pip, simply run:
```python
pip install CaseLawScraper
```
This package has 3 main modules:
* CaseInfoScraper
* CaseHeaderScraper
* FullTextScraper

### 1- CaseInfoScraper
---
This module contains 2 functions. These functions scrape Link, Name of the Case, judgment-listing__court, judgment-listing__neutralcitation and Datetime for a page or multipages.
Funcrions:
* scrape_judgments
* scrape_all_judgments_info

### 2- CaseHeaderScraper
---
This module has 3 functions. First module give us just page's urls that use in second and third functions. (So you have to run **scrape_judgment_urls** first) then, second function gives us direct download case's PDFs and the last one, scrape case header info :)
Functions:
* scrape_judgment_urls
* judgment_Dlink
* scrape_header_info

### 3- FullTextScraper
---
This module has 3 function. It gets output of scrape_header_info and scrape all text of each cases.
Functions:
* load_json
* scrape_full_text
* OutputScraper

### Save in JSON format
----
This scraper has one more function to save data in a stable format named **save_to_json**

### Usage Example
---
```python



```
django-command-message 0.0.1
Django command messages framework
Keywords: django

### Installation
```bash
$ pip install django-command-message
```

#### `settings.py`
```python
INSTALLED_APPS+=['django_command_message']
```

#### `migrate`
```bash
$ python manage.py migrate
```

### Features
+   database
+   admin
+   print message if `settings.DEBUG==True`

### Models
model|table|columns/fields
-|-|-
`Command`|`django_command_message`|`id`,`command`,`message`,`created_at`

### Examples
`CommandMessageMixin`
```python
from django_command_message.mixins import CommandMessageMixin

class Command(CommandMessageMixin,BaseCommand):
    def handle(self, *args, **options):
        self.message('message')
```

`Message` model
```python
from django_command_message.models import Message

Message(command='name',message="message").save()
```