semvec/pypi-packages huggingface dataset:
fast-auth-routes 0.1.0
A simple FastAPI application with authentication and user management
Requires Python: >=3.11

# Fast_Auth

Fast_Auth is a simple FastAPI application with authentication and user management using MongoDB.

## Features

- User Signup
- User Login
- User Recover Password
- Token-based Authentication

## Installation

To install the package, use pip:

```bash
pip install fast_auth
```

## Required Enviroment Variables

```bash
# MONGO DB
export MONGO_URI="mongodb://localhost:27017t"
export MONGO_DB_NAME="db_name"

# JWT
export SECRET_KEY="your_secret_key"
export ALGORITHM="HS256" 
export ACCESS_TOKEN_EXPIRE_MINUTES=30
```

## Usage

To run the application, use the following command:

```bash
uvicorn fast_auth.main:app --reload
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
compressfiles 0.0.5
Library used to compress files using gzip but more simple
Requires Python: >=3.6

# GZip Compression Utility

This is a Python package that provides a simple utility for compressing and decompressing files using the GZip format. The package uses the `gzip` module from the Python standard library.

## Installation

You can install the package using pip:

pip install `compressfiles`



## Usage

The package provides two main functions: `compress()` and `decompress()`. 

### Compressing a txt file

To compress a file, use the `compress()` function. For example:

from compressfiles import compress

compress('my_file.txt')



This will compress `my_file.txt` and save the compressed file as `my_file.gz`.

You can also specify the output file path using the `output_file_path` parameter:

compress('my_file.txt','my_file.gz')
You can customize the compression level (0-9), default is '6'
compress('my_file.txt','my_file.gz', '8')

### Decompressing a file

To decompress a file, use the `decompress()` function. For example:

from compressfiles import decompress

decompress('my_file.gz')



This will decompress `my_file.gz` and save the decompressed file as `my_file.txt`.

You can also specify the output file path using the `output_file_path` parameter:

decompress('my_file.gz', 'my_file.txt')



## License

This project is licensed under the terms of the MIT license. See the `LICENSE` file for details.
dtogen 0.0.17
DTO generator for Java, TypeScript, Python
Keywords: python, DTO, generator

# DTOgen - Data Transfer Object Generator

DTOgen is a powerful library that allows users to **effortlessly generate Data Transfer Object (DTO) classes** in multiple programming languages from YAML definitions. DTOgen aims to **simplify the process of mapping** JSON or XML data to objects, making it an excellent tool for microservices development.

With DTOgen, syncing Data Transfer Objects (DTOs) across services becomes a seamless process. Since DTOgen allows you to define DTOs in a centralized YAML file and **generates the corresponding classes in multiple programming languages**, you can ensure consistency across your microservices easily. 

DTOgen is designed to handle not only simple data types but also **complex data structures** like lists and maps. With the ability to represent lists and maps in the YAML definitions, DTOgen can generate DTO classes that accurately reflect these data structures in multiple programming languages.

## Features

- Define DTOs in YAML: Users can create their Data Transfer Object definitions in a YAML file, which makes it easy to manage and understand the data structures.

- Multi-language Support: DTOgen supports generating DTO classes for three popular programming languages: Java, Python, and TypeScript. This enables seamless integration into various microservices projects.

- Simple CLI Integration: The library provides a command-line interface (CLI) tool 'dtogen', making it straightforward for users to generate DTO classes for their chosen language.

## Installation

DTOgen can be installed using pip for Python, TypeScript and Java projects.

```bash
pip install dtogen
```

## Usage

1. Create a YAML file with your DTO definitions. For example, `dto_definitions.yaml`:

```yaml
info:
  name: library-dtos
  version: 0.0.1

dtos:
  person :
    attributes :
      - name : name
        type : string
      - name : age
        type : integer
```

2. Run the 'dtogen' CLI command with the desired target language:


```bash
dtogen -i dto_definitions.yaml -o dto_directory -l java --java-package com.example.dtos
```

3. The library will generate the corresponding DTO classes in the specified output directory for the chosen language.

## Example

Given the `dto_definitions.yaml` example above, DTOgen will generate the following DTO classes for each language:

### Java

```java
public class Person {
  public String name;
  public int age;
}
```

### Python

```python
class Person:
  name: str
  age: int
```

### TypeScript

```typescript
export class Person {
    name: string | undefined;
    age: number | undefined;
}
```

DTOgen simplifies the process of creating Data Transfer Objects, enabling developers to focus more on building efficient microservices without worrying about complex data mapping.
medium-article-py 0.1.10
A simple python library for Medium Articles APIs
Requires Python: >=3.6
Keywords: medium, medium-api, medium-article, api

medium-article-py
====================================================

A Python library designed to retrieve articles and user information from Medium. This library offers an easy-to-use method for developers to incorporate Medium content into their applications.


Installation
------------

You can install this library using pip.

.. code-block:: python

    pip install medium-article-py


Usage
------------

Here is a simple example to get you started:

.. code-block:: python

    from medium_article_py.medium import MediumArticles
    
    username = '<your-medium-username>'
    md = MediumArticles()

    print(md.get_profile_url(username))    
    # Output: https://medium.com/feed/@engrmuhammadusman108

.. list-table::
   :widths: 20 80 20
   :header-rows: 1

   * - Function
     - Arguments
     - Output
   * - getData
     - username : string
     - string
   * - getProfileUrl
     - username : string
     - string
   * - getProfileTitle
     - username : string
     - string
   * - getProfileAuthor
     - username : string
     - string
   * - getProfileDescription
     - username : string
     - string
   * - getProfileImageUrl
     - username : string
     - string
   * - getLatestArticleTitle
     - username : string
     - array[string]
   * - getLatestArticlePublicationDate
     - username : string
     - string
   * - getLatestArticleUrl
     - username : string
     - string
   * - getLatestArticleDescription
     - username : string
     - html
   * - getLatestArticle
     - username : string
     - object
   * - getLatestArticlesTitle
     - username : string
     - string


Contributing
------------

- [Misbah Afzal](https://github.com/misbahafzal)
- [Muhammad Usman](https://github.com/muhammad-usman-108)

Support
------------
.. image:: https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png
   :target: https://buymeacoffee.com/engrmuhammk
   :alt: engrmuhammk
   :align: left
   :height: 50px
   :width: 210px

LICENSE
------------

This project is licensed under the MIT License - see the [LICENSE](https://github.com/muhammad-usman-108/medium-article-py/blob/main/LICENSE) file for details.
termhand 0.2.1
A command-line tool that generates terminal commands from natural language prompts.
Requires Python: >=3.6

# TermHand

TermHand is a command-line tool that generates terminal commands from natural language prompts.

## Installation

Install from [PyPI](https://pypi.org/project/TermHand):

```sh
pip install termhand
```

## Usage

To use TermHand, first ensure you have set up your API key. Create a configuration file at `~/.config/termhand/termhand_config.ini` with the following content:

```ini
[termhand]
api_key = your_api_key_here
```

You can get an API Key from the [Google AI Studio](https://aistudio.google.com/app/apikey)

Then, use TermHand from the command line:

```sh
th "How do I create a new folder with the name test?"
```

## Development

Clone the repository and install the dependencies:

```sh
git clone https://github.com/yourusername/termhand.git
cd termhand
pip install -e .
```
eulith-web3 0.27.0
A Web3.py compatible wrapper library for Eulith clients
Requires Python: >=3.8

# Welcome To Eulith Client
Please find our docs at https://docs.eulith.com

---

## Setup for Linux 22.04

~~~
sudo apt update -qq
sudo apt install -qq -y python3 python3-pip
pip3 install pyproject.toml
pip3 install web3
pip3 install pytest
export PATH=$PATH:$HOME/.local/bin   ; echo consider adding this to .bashrc
~~~

## Running tests

~~~
pytest
~~~

or if you use a different URL for where to find the eulith call server
~~~
EULITH_URL=http://192.168.244.44:7777/v0 pytest
~~~
dbt-docs-controller 0.1.0
dbt-docs-controller streamlines dbt documentation by generating only the relevant models, sources, and components for concise, targeted user information.
Requires Python: >=3.7

# dbt-docs-controller📑💾🕹️

`dbt-docs-controller` is a Python CLI tool designed to generate a documentation site for a subset of models in your dbt (data build tool) project.

## 📝Description:

In standard dbt-docs, documentation is generated for the entirety of your dbt project, including:
- All models
- All sources
- All macros

This approach might be overwhelming for end-users who are only interested in a specific part of your project. `dbt-docs-controller` addresses this by allowing you to generate documentation for only the relevant models and components that your end-users will actually interact with. This CLI empowers users to selectively include only the models, sources, packages, or combinations thereof that are relevant to their needs. Whether users require documentation for a single model, a group of sources, specific packages, or custom combinations, dbt-docs-controller makes the process effortless and efficient.

### 🔑✨Key Features:
- **Selective Documentation**: Generate documentation for specific models, sources, packages, or custom combinations thereof.
- **Simplified Output**: Create a cleaner, more focused dbt-docs site by excluding unnecessary nodes.
- **Easy to Use**: Simple CLI interface for quick integration into your existing dbt workflow.

### ⚙️💡How It Works:
`dbt-docs-controller` works by editing the `manifest.json` file used by the dbt-docs site. By selectively modifying the file based on user input, the tool ensures that only the specified components are included in the final documentation site, resulting in a documentation site that is precisely tailored to meet your specific needs and preferences.
NREL-pydss 3.1.7
A high-level python interface for OpenDSS
Requires Python: >=3.9

﻿# Welcome to the pydss Repository!

**PyDSS** is a high level python interface for **OpenDSS** and provides the following functionalities

Documentation on installation, setup and examples can be found here https://nrel.github.io/PyDSS/index.html
HammingEncoder 0.1.8
A Hamming Encoder package


# HammingEncoder

HammingEncoder is the source code for paper.

## Installation

You can install HammingEncoder from PyPI:

```bash
pip install HammingEncoder
```
## Usage

Here's how to use the HammingEncoder package:

### Importing the package

```python
from HammingEncoder import HammingEncoder

# Example data
sequences = [
    ['0', '1', '2', '3', '4', '5', '1', '6', '5', '1', '7', '4', '5', '8', '5'], 
    ['0', '1', '4', '2', '3', '4', '5', '8', '5', '1', '7', '4', '5', '1', '5', '1', '5', '6', '5'],
    ['0', '1', '2', '3', '4', '5', '8', '5', '1', '5', '7', '5', '1', '8', '5', '1', '5', '1', '5', '1', '6', '4', '5'], 
    ['0', '4', '2', '3', '5', '7', '5', '1', '5', '4', '6', '5', '1', '5', '4', '5'],
    ]
labels = [0, 1, 0, 1]

# Initialize the encoder
encoder = HammingEncoder(sequences, labels, gap_constrain=5, label_number=2, Preset_set_pattern_num=1024, device='cpu')

# Fit the model
encoder.fit(n_epochs=100, patience=2, batch_size=64)

# Transform the data
encoded_data = encoder.transform(sequences)

print("Encoded data:", encoded_data)

# test
acc = encoder.test(sequences, labels)
print("Accuracy:", acc)
ml-demo 0.3
ml_demo package
Requires Python: >=3.6

# ml_demo
ml_demo是操作异步打印hello并能打印环境变量path的值库

## 用法
```python

import asyncio

from core.ml_core import async_msg, get_utils_log

get_utils_log()
asyncio.run(async_msg())

```

## 场景
1.用于异步打印hello
2.打印path
Prompter9000 2.5.0
C.L.I <-> G.U.I Dictionary Editor
Requires Python: >=3.6

## Prompter9000
Quick &amp; easy way to edit dictionaries and create counters. Console & programmatic 
usages are supported.

**NEW:** *Verson 2.0.2*
1. Data types can now be preserved. 
2. Boolean detection, as well.
3. Result Key [__conv_ok]
    - == *True* iff types preserved. 
    - *False* == at least one defaulted to string.
4.) Result Key [__btn_ok]
    - == *True* when [Okay] was pressed
    - else *False*.

### Programatic
Edit a dictionary:
```
from Prompter9000.PyEdit import *
params = {"NAME":'My', "ACCOUNT":123456, "Subscriber":False}
EditDict.edit(params)
```

Create a click-counter:
```
from Prompter9000.PyCount import *
params = {'Hits': '0', 'Miss': '0', 'Other': '10'}
Counter.edit(params)
```
*GUI*: Dictionary results will be returned ONLY IF the data was changed. Otherwise an empty dictionary will be returned.

May also be used from the C.L.I:

### Console

Dynamically edit a dictionary:
```
python PyEdit.py "{'NAME': 'My', 'PHONE': '123-456', 'EMAIL': 'a.Geekbo@zbobo.com'}"
{'NAME': 'My', 'PHONE': '123-456', 'EMAIL': 'a.Geekbo@zbobo.com', '__btn_ok': True}
```

Dynamic click-to-update counters:
```
python PyCount.py "{'Hits': '0', 'Miss': '0', 'Other': '10'}"
{'Hits': '12', 'Miss': '10', 'Other': '44', '__btn_ok': True}
```

*CLI*: The **__btn_ok** will be either **True** when user-selected, else **False**.

### PyPi

Now available on [PyPi](https://pypi.org/project/Prompter9000/)