semvec/pypi-packages huggingface dataset:
openapi-jira-client 0.0.1
A client library for accessing The Jira Cloud platform REST API
Requires Python: >=3.6,<4.0

# openapi-jira-client
A client library for accessing The Jira Cloud platform REST API

## Usage
First, create a client:

```python
from openapi_jira_client import Client

client = Client(base_url="https://api.example.com")
```

If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:

```python
from openapi_jira_client import AuthenticatedClient

client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
```

Now call your endpoint and use your models:

```python
from openapi_jira_client.models import MyDataModel
from openapi_jira_client.api.my_tag import get_my_data_model
from openapi_jira_client.types import Response

my_data: MyDataModel = get_my_data_model.sync(client=client)
# or if you need more info (e.g. status_code)
response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
```

Or do the same thing with an async version:

```python
from openapi_jira_client.models import MyDataModel
from openapi_jira_client.api.my_tag import get_my_data_model
from openapi_jira_client.types import Response

my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
```

Things to know:
1. Every path/method combo becomes a Python module with four functions:
    1. `sync`: Blocking request that returns parsed data (if successful) or `None`
    1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
    1. `asyncio`: Like `sync` but the async instead of blocking
    1. `asyncio_detailed`: Like `sync_detailed` by async instead of blocking
     
1. All path/query params, and bodies become method arguments.
1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
1. Any endpoint which did not have a tag will be in `openapi_jira_client.api.default`    

## Building / publishing this Client
This project uses [Poetry](https://python-poetry.org/) to manage dependencies  and packaging.  Here are the basics:
1. Update the metadata in pyproject.toml (e.g. authors, version)
1. If you're using a private repository, configure it with Poetry
    1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
    1. `poetry config http-basic.<your-repository-name> <username> <password>`
1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`

If you want to install this client into another project without publishing it (e.g. for development) then:
1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
1. If that project is not using Poetry:
    1. Build a wheel with `poetry build -f wheel`
    1. Install that wheel from the other project `pip install <path-to-wheel>`
pd-helper 1.0.0
A helpful script to optimize a Pandas DataFrame.
Requires Python: >=3.8

# pd-helper
 
 A helpful package to streamline Pandas DataFrame optimization.
 
 Save 50-75% on DataFrame memory usage by running the optimizer. 
 
 Autoconfigure dtypes for appropriate data types in each column with **helper**.

 Generate a random DataFrame of controlled random variables for testing with **maker**.

## Install
 ```bash
 pip install pd-helper
 ```

## Basic Usage to Iterate over DataFrame
```python
from pd_helper.maker import MakeData 
from pd_helper.helper import optimize
faker = MakeData()

if __name__ == "__main__":
   # MakeData() generates a fake dataframe, convenient for testing
   df = faker.make_df()
   df = optimize(df)
```
## Better Usage With Multiprocessing
```python
from pd_helper.maker import MakeData 
from pd_helper.helper import optimize
faker = MakeData()

if __name__ == "__main__":
   # MakeData() generates a fake dataframe, convenient for testing
   df = faker.make_df()
   df = optimize(df, enable_mp=True)
```

## Specify Special Mappings
```python
from pd_helper.maker import MakeData 
from pd_helper.helper import optimize
faker = MakeData()

if __name__ == "__main__":
   # MakeData() generates a fake dataframe, convenient for testing
   df = faker.make_df()
   special_mappings = {'string': ['object_id'],
                       'category': ['item_name']}
   
   # special mappings will be applied instead of by optimize ruleset, they will be returned.
   df = optimize(df
                 , enable_mp=True,
                 special_mappings=special_mappings
                 )
```


## Sample Results with Helper

```bash
Starting with 175.63 MB memory.

After optmization. 

Ending with 65.33 MB memory.
```

## Generating a Randomly Imperfect DataFrame with Maker

 Maker provides a class, MakeData(), to generate a table of made-up records. 
 
 Each row is an event where an item was retrieved. 
 
 Options to make the table imperfectly random in various ways. 
 
 Sample table below:

|  | Retrieved Date  | Item Name | Retrieved | Condition | Sector |
| ------------- | ------------- | ------------- | ------------- | ------------- | ------------- |
| Example | 2019-01-01, 2019-03-4  | Toaster, Lighter  | True, False  | Junk, Excellent  | 1, 2 |
| Data Type | String  | String  | String  | String | Integer |


## References

* Pandas Categorical: <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Categorical.html>

* Pandas Pickle: <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_pickle.html>

* Pandas CSV: <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html>

* Pandas Datetime: <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html>

### TODO

* Improve efficiency of iterating on DataFrame.

* Allow user to toggle logging.

* Provide tools for imputing missing data.