semvec/pypi-packages huggingface dataset:
dforge 2.1.5
A package for efortless data manager.
Requires Python: >=3.6

# Data Forge

Data Forge is a Python package designed to provide a comprehensive suite of tools specialized in managing and analyzing data. It offers a user-friendly toolkit suitable for individuals of all levels of expertise. This initial release encompasses the following features:

- Effortless reading of datafiles with support for Pandas-compatible extensions.
- Simplified dataframe creation by specifying column names and corresponding values.
- Automatic generation of hexadecimal and numeric identifiers.
- Provision of common statistical analyses for specified columns.
- Histogram plotting functionality.
- Easy visualization of class distribution within the database.
- Data standardization capabilities.
- Feature discretization support.
- Creation of fold columns for conducting stratified k-fold analyses.

# Components
## 'PDBuilder' Class
This class enables the creation and manipulation of Pandas DataFrames. It supports the following functionalities:
- Reading data from various file formats: CSV, Excel, JSON, Parquet, Feather, and Pickle.
- Generating unique identifiers for rows.
- Adding new data to the DataFrame.
- Displaying the DataFrame.
- Retrieving column names.
- Printing specific columns.

## 'PDNumPro' Class
This class extends the PDBuilder class and provides additional functionalities for numerical analysis and preprocessing. It includes the following features:

- Computing statistics for numerical columns.
- Plotting histograms.
- Analyzing data balance.
- Standardizing numerical data.
- Reconstructing data.
- Converting non-numeric columns to numeric values.
- Creating folds for cross-validation.

## Dependencies
This toolkit requires the following dependencies:

- pandas
- numpy
- matplotlib
- scikit-learn

## Installation
To install the dependencies, run:
```python
pip install dforge
```

## Usage
You can use this toolkit in your Python projects by importing the necessary classes and functions. Here's an example of how to use the PDBuilder class:

```python
import dforge as df

# Create a DataFrame from data
data = [[1, 'A', 10], [2, 'B', 20], [3, 'C', 30]]
columns = ['ID', 'Category', 'Value']
data_pd = df.PDBuilder(data=data, columns=columns)

# Display DataFrame
data_pd.show_dataset()

# Add new data
new_data = [[4, 'D', 40], [5, 'E', 50]]
data_pd.add_data(new_data)

# Display DataFrame with added data
data_pd.show_dataset()
```

# Work in progress...

Stay tuned for upcoming releases, which will incorporate the following enhancements:
- Missing data completion functionality.
- Conversion of dataframes into datasets suitable for machine learning inputs.
- Introduction of PDTextAnalysis for handling features related to text manipulation.
django-twitter-auth-manager 1.0
Manage Twitter OAuth 2.0 Authorization Code Flow with PKCE (User Context) authentication by an Django app and store necessary token and refresh token for future uses.

![PyPI - Version](https://img.shields.io/pypi/v/django-twitter-auth-manager?color=blue)
![GitHub License](https://img.shields.io/github/license/codesyntax/django-twitter-auth-manager%20)

# django-twitter-auth-manager

Manage Twitter OAuth 2.0 Authorization Code Flow with PKCE (User Context) authentication by an Django app and store necessary token and refresh token for future uses.

## Dependencies

This package depends on the Tweepy library, and Django framework as well as the Django's cache application.

## Limitations

The auth manage system is designed to use Twitters Free API plan. That's why uses OAuth 2.0 Authorization Code Flow with PKCE (User Context), for write procedures. So the limitation are set by Twitters Free plan:

- access token is valid only for 2 hours
- 1 environment
- up to 1500 posts per month
- 50 requests / 24 hours PER APP for tweets
- 25 requests / 24 hoursPER USER info

More details in: [https://developer.twitter.com/en/portal/products/free](https://developer.twitter.com/en/portal/products/free)

## Installation

To install `django-twitter-auth-manager` simply run:

```bash

   pip install django-twitter-auth-manager
```

## Configuration

We need to hook `django-twitter-auth-manager` into our project.

1. Put `django_uptime` into your `INSTALLED_APPS` at settings module:

```python

   INSTALLED_APPS = (
       # other apps
       "django_twitter_auth_manager",
   )
```

2. Include the desired url path into your projects main `urls.py` file:

```python

   from django.urls import include, path

   urlpatterns = [
      ...
      path('twitter/', include('django_twitter_auth_manager.urls')),
      ...
   ]
```

## Usage

1. Execute the "Authenticate your app" Django admin action from Access Token list panel
2. Follow the Oauth2 flow procedure
3. Once the first access token is saved, we can now use the Tweepy client:

```python
   from django_twitter_auth_manager.models import Access_token

   access_token = Access_token.objects.last()
   client = tweepy.Client(access_token.access_token)
   client.create_tweet(text="Hello World!", user_auth=False)
```

### Refresh token

In order to refresh the access token, you can do manually by triggering admin's "Refresh token" action or checking the validity an triggering automatically:

```python
   from django_twitter_auth_manager.models import Access_token
   from django_twitter_auth_manager.views import refresh_token

   access_token = Access_token.objects.last()

   if not access_token.is_valid():
      access_token = refresh_token()

   # Further actions
```

1.0 (2024-04-25)
----------------
testmyct 1.0.0
Used for integration with Application monitoring systems

The purpose of this project is to show how to upload a python package to the PYPI server.

Main commands:

- Build the package distribution
`python setup.py sdist bdist_wheel`

- Install twine on local env
`pip install twine`

- Upload to TestPyPi
`twine upload --repository-url https://test.pypi.org/legacy/ dist/*`

- Upload to Pypi
`twine upload dist/*`

- Create a venv
`python -m venv venv`

- Activate a venv
`venv\\Scripts\\activate`

- Install package
`pip install --index-url https://test.pypi.org/simple/ your_package_name`

- Show installed packages
`pip list`
auto-audio-rec 0.1.0
This will allow user to start the microphone after certain period of time and can stop the microphone with a button.
Requires Python: >=3.7

# auto-audio-rec

This will allow user to start the microphone after certain period of time and can stop the microphone with a button.

## Installation instructions 

```sh
pip install auto-audio-rec
```

## Usage instructions

```python
import streamlit as st

from auto_audio_rec import auto_audio_rec

value = auto_audio_rec()

st.write(value)
vsvn-application-monitoring 1.0.0
Used for integration with Application monitoring systems

The purpose of this project is to show how to upload a python package to the PYPI server.

Main commands:

- Build the package distribution
`python setup.py sdist bdist_wheel`

- Install twine on local env
`pip install twine`

- Upload to TestPyPi
`twine upload --repository-url https://test.pypi.org/legacy/ dist/*`

- Upload to Pypi
`twine upload dist/*`

- Create a venv
`python -m venv venv`

- Activate a venv
`venv\\Scripts\\activate`

- Install package
`pip install --index-url https://test.pypi.org/simple/ your_package_name`

- Show installed packages
`pip list`
arithmeticTestPackage-owais-md 0.0.2
Simple arithmetic package
Requires Python: >=3.6


## Simple python package
This python package implements simple arithmetic functions, i.e., addition, subtraction and multiplication.


# Arithmetic Package Owais
Arithmetic Package Owais is a simple Python package that provides basic arithmetic functions such as addition, subtraction, and multiplication.

## Installation
The package name is "arithmeticPackageOwais" and its URL is https://pypi.org/project/arithmeticPackageOwais/.
To install the Arithmetic Package Owais, use pip:

```bash
pip install arithmeticTestPackage-Owais-md
```

## Usage

To use the functions, use the following command:
```bash 
from arithmeticPackageOwais import add, subtract, multiply
```
sqlx-orm-generator 0.0.2
sqlx-orm-generator is a model code generator from tables for sqlx-orm_generator.
Requires Python: >=3.5
Keywords: MySQL, mysqlx, python

Install
'''''''

.. code:: shell

   pip install mysqlx-generator

Usage Sample
''''''''''''

.. code:: python

       from orm_generator import Generator

       if __name__ == '__main__':
           coder = Generator(host='127.0.0.1', port='3306', user='xxx', password='xxx', database='test')
           # you can generate a model class for one table
           coder.generate_with_tables(tables='user', path='models.py')
           # you can generate model classes for tables
           coder.generate_with_tables(tables=['user', 'person'], path='models.py')
           # you can generate model classes for all tables from a given schema. default current schema if not given
           coder.generate_with_schema(schema='test', path='models.py')

If you run last code, then generate a file 'models.py' in current
directory like follow:

.. code:: python

       from decimal import Decimal
       from datetime import date, datetime
       from orm import Model, KeyStrategy

       class BaseModel(Model):
           __key__ = 'id'
           __del_flag__ = 'del_flag'
           __update_by__ = 'update_by'
           __update_time__ = 'update_time'
           __key_strategy__ = KeyStrategy.DB_AUTO_INCREMENT

           def __init__(self, id: int = None, create_by: int = None, create_time: datetime = None, update_by: int = None, update_time: datetime = None,
                   del_flag: int = None):
               self.id = id
               self.create_by = create_by
               self.create_time = create_time
               self.update_by = update_by
               self.update_time = update_time
               self.del_flag = del_flag


       class User(BaseModel):
           __table__ = 'user'

           def __init__(self, id: int = None, name: str = None, age: int = None, birth_date: date = None, sex: int = None, grade: float = None,
                   point: float = None, money: Decimal = None, create_by: int = None, create_time: datetime = None, update_by: int = None,
                   update_time: datetime = None, del_flag: int = None):
               super().__init__(id=id, create_by=create_by, create_time=create_time, update_by=update_by, update_time=update_time, del_flag=del_flag)
               self.name = name
               self.age = age
               self.birth_date = birth_date
               self.sex = sex
               self.grade = grade
               self.point = point
               self.money = money


MySqlx: https://pypi.org/project/mysqlx
django-nested-modals 0.0.24
Django app to implement Bootstrap nested modals
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/django-nested-modals.svg)](https://badge.fury.io/py/django-nested-modals)

Add to installed apps in settings   
`'bootstrap_modals',`
    

Add to template
  
    <script src="{% static 'django_modals/js/modals.js' %}"></script>
    <link rel="stylesheet" type="text/css" href="{% static 'django_modals/css/modals.css' %}"/>

####See django_examples for example usage