semvec/pypi-packages huggingface dataset:
adapol 0.1.0
Adaptive Pole Fitting for Quantum Many-Body Physics
Requires Python: >=3.7
Keywords: Bath, Fitting, Hybridization, DMFT, Matsubara

# adapol: Adaptive Pole Fitting for Quantum Many-Body Physics
[`adapol`](https://github.com/Hertz4/Adapol) (pronounced "add a pole") is a python package for fitting Matsubara functions with the following form:
```math
G(\mathrm i \omega_k) = \sum_l \frac{V_lV_l^{\dagger}}{\mathrm i\omega_k - E_l}.
```

Current applications include
(1) hybridization fitting, (2) analytic continuation.

We also provide a [TRIQS](https://triqs.github.io/) interface if the Matsubara functions are stored in `triqs` Green's function container.

# Installation
`adapol` has `numpy` and `scipy` as its prerequisites. [`cvxpy`](https://www.cvxpy.org/) is also required for hybridization fitting of matrix-valued (instead of scalar-valued) Matsubara functions.

To install `adapol`, run
```terminal
pip install adapol
```



# Documentation

See the detailed [documentation](https://flatironinstitute.github.io/adapol/) for physical background, algorithms and user manual.

`Adapol` is a stand-alone package. For TRIQS users, we also provide a TRIQS interface. See [user manual](https://flatironinstitute.github.io/adapol/latest/python.html#triqs-interface) for details.

# Examples
In the `tutorial` page, we provide two examples [`discrete.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/discrete.html) and [`semicircle.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/semicircle.html), showcasing how to use `adapol` for both discrete spectrum and continuous spectrum.

In these notebooks, we also demonstrate how to use our code through the triqs interface.

# References
To cite this work, please include a reference to this GitHub repository, and
cite the following references:

1. Huang, Zhen, Emanuel Gull, and Lin Lin. "Robust analytic continuation of Green's functions via projection, pole estimation, and semidefinite relaxation." Physical Review B 107.7 (2023): 075151.
2. Mejuto-Zaera, Carlos, et al. "Efficient hybridization fitting for dynamical mean-field theory via semi-definite relaxation." Physical Review B 101.3 (2020): 035143.
3. Nakatsukasa, Yuji, Olivier Sète, and Lloyd N. Trefethen. "The AAA algorithm for rational approximation." SIAM Journal on Scientific Computing 40.3 (2018): A1494-A1522.
pi-folder-organizer 2.2.2
A Python package for cleaning up cluttered files and organizing them into respective folders.
Keywords: python, file organization, file cleanup, cluttered files, folder management, data organization, file management, data cleanup, Python package, developer tools, data processing, file sorting, data structuring, automated file organization, Python library, data management, data handling, file optimization, data optimization


# PiFolderOrganizer

PiFolderOrganizer is a Python package that helps organize files into different categories based on their file extensions.

## Installation

You can install PiFolderOrganizer using pip:

```bash
pip install pi-folder-organizer
```
## Usage
To use PiFolderOrganizer in your Python code, import the PiFolderOrganizer class:
```python
from pi_folder_organizer import PiFolderOrganizer
```
Make object of class
```python
pi_organizer=PiFolderOrganizer()
```
To continue with default cleaning:
```python
pi_organizer.pi_folder_organizer("/path/to/source_folder", "/path/to/destination_folder")
```
If you want to see which folders and extentions I use:
```python
pi_organizer.get_counter()
```
This will return you a dictionary of folders and the files list as folder's files.
Same for getting extensions
```python
pi_organizer.get_extensions()
```
This will return you a dictionary of folders and the files tuple of file's extensions.

### Customization Options

You can customize the counter dictionary and extensions dictionary according to your preferences. Here's how:

```python
from pi_folder_organizer import PiFolderOrganizer

# Initialize PiFolderOrganizer
pi_organizer = PiFolderOrganizer()

# Customize the counter dictionary
new_counter = {
    "Images": [],
    "Documents": []
}

# Set the new counter
pi_organizer.set_counter(new_counter)
print("Updated Counter:", pi_organizer.get_counter())

# Customize the extensions dictionary
new_extensions = {
    "Images": (".png", ".jpg"),
    "Documents": (".txt", ".docs")
}

# Set the new extensions
pi_organizer.set_extensions(new_extensions)
print("Updated Extensions:", pi_organizer.get_extensions())

# Run the PiFolderOrganizer method after your setup
pi_organizer.pi_folder_organizer("source_folder", "destination_folder")
```
**Note**
The length of ```new_counter``` and ```new_extensions``` must be same. The remaining files automatically moved to folder ```Others```.

### Contact Information

Feel free to reach out to me on social media:

[![GitHub](https://img.shields.io/badge/GitHub-mrqadeer)](https://github.com/mrqadeer)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-Qadeer)](https://www.linkedin.com/in/qadeer-ahmad-3499a4205/)
[![Twitter](https://img.shields.io/badge/Twitter-Twitter)](https://twitter.com/mr_sin_of_me)
[![Facebook](https://img.shields.io/badge/Facebook-Facebook)](https://web.facebook.com/mrqadeerofficial/)




## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
pg-comtrade 0.0.2
Python function to ingest data from UN Comtrade's bulk API to PostgreSQL
Requires Python: >=3.8

# pg-comtrade [![PyPI package](https://img.shields.io/pypi/v/pg-comtrade?label=PyPI%20package)](https://pypi.org/project/pg-comtrade/) [![Test suite](https://img.shields.io/github/actions/workflow/status/uktrade/pg-comtrade/test.yaml?label=Test%20suite)](https://github.com/uktrade/pg-comtrade/actions/workflows/test.yaml) [![Code coverage](https://img.shields.io/codecov/c/github/uktrade/pg-comtrade?label=Code%20coverage)](https://app.codecov.io/gh/uktrade/pg-comtrade)

Python utility function to ingest data from UN Comtrade's bulk API into a (partitioned) PostgreSQL table.

> [!IMPORTANT]
> This is a work-in-progress. This README serves as a rough design spec.

## Installation

pg-comtrade can be installed from PyPI using pip. psycopg2 or psycopg (Psycopg 3) must also be explicitly installed.

```bash
pip install pg-comtrade psycopg
```


## Usage

```python
from pg_comtrade import sync_goods_yearly

# For example purposes, PostgreSQL can be run locally using this...
# docker run --rm -it -e POSTGRES_HOST_AUTH_METHOD=trust -p 5432:5432 postgres

# ... which should work with this engine
engine = sa.create_engine('postgresql+psycopg://postgres@127.0.0.1:5432/')

# ... to ingest into the un.comtrade_goods table
with engine.connect() as conn:
    sync_goods_yearly(conn, 'un', 'comtrade_goods', subscription_key='123456abcdef')
```

## Development / running tests

To develop pg-comtrade, you will need to install the package in editable mode, and install development dependencies.

```bash
pip install -e '.[dev]'
```

And start a local PostgreSQL server:
```bash
./start-services.sh
```

And then to run the tests:

```bash
pytest
```
diarydek 0.0.25
A diary tool.
Requires Python: >=3.8

# diarydek

'diarydek' is a python script to handle diary entries.  It is still in
an Alpha stage of development, meaning that anything you see here
might change in the future.  Heck, some of it may be wrong even as you
read this!


# Sample Usage

## Get help.

    diarydek --help
    diarydek -h

## Add an entry that has no categories.

    diarydek I ate breakfast.

## Add an entry that has a single category.

    diarydek I ate a salad for lunch. : food

## Add an entry that has a two categories.

    diarydek I ate a salad for lunch. : food healthy

## See all entries

    diarydek --list

## See entries with `caw` in the entry.

    diarydek --list caw

## See entries with tag `sound`.

    diarydek --list : sound

## Rename a tag.

    diarydek --renameTag oldName newName

## Find tag usage

    diarydek --showTags

## Combining databases.

The following appends the contents of the database B to database A.

    diarydek --database ~/B.db --writeCSV > B.csv
    diarydek --database ~/A.db --readCSV B.csv

# Developer's Notes

The following builds locally, when run from the source directory.

    python3 -m pip install . --break-system-packages

If this works in testing, consider uploading to pypi.  Be sure to bump
the version number first to avoid conflict with a version on pypi.  Do
this in two steps:

1. Edit the `pyproject.toml` file, altering the line defining
   `version`.

2. Edit the `src/diarydek/diarydek.py` file, altering
   the definition of `self.appversion`.

With this done, it is possible to upload to pypi, which is done with
the following.  (The first step just ensures that you don't try to
upload any old sources that you might have built up previously with
twine.)

    rm dist/*                      # remove any existing files
    python3 -m build               # build, installing 2 files in dist
    python3 -m twine upload dist/* # upload to pypi

Once this is done, you can install the pypi version using the
following.  If it works, then you can have some assurance that users
can install it (using the second step).

    pip uninstall diarydek --break-system-packages # remove any existing version
    pip install diarydek --break-system-packages   # install new, from pypi

# Suggested aliases

Although you can use a single diary for all your work, it can
sometimes help to have multiple databases, e.g. for privacy.  I do
things like the following.

    alias ',dp'='diarydek --database=~/Documents/diary/personal.db'
    alias ',dw'='diarydek --database=~/Documents/diary/work.db'


References
----------

1. https://packaging.python.org/tutorials/packaging-projects/ provides
   information on packaging.