semvec/pypi-packages huggingface dataset:
moduleprofiler 0.0.4
Module profiler
Requires Python: >=3.9
Keywords: pytorch, machine-learning, neural-network, profiling, complexity-analysis

# ModuleProfiler
Free open-source package to profile `torch.nn.Module` modules and obtain useful information to design a model that fits your needs and constraints at development time.

With `moduleprofiler` you can:
- Calculate the number of parameters of your model.
- Trace the input and output sizes of each component of your model.
- Estimate the number of operations your model performs in a forward pass.
- Calculate per module and total inference time.

All results can be obtained in one of the following formats:
- `dict` (default output format)
- `pandas.DataFrame` (to perform further calculations or filtering in your code)
- `html` (to export as webpage)
- `LaTeX` (to include in your publications)

[<a href="https://eagomez2.github.io/moduleprofiler/" target="_blank">Online documentation</a> | <a href="https://eagomez2.github.io/moduleprofiler/tutorial/" target="_blank">Tutorial</a> ]

# Installation
`moduleprofiler` can be installed as any regular `python` module within your environment.

Install from PyPI:
```bash
python -m pip install moduleprofiler
```

Install from this repository:
```bash
python -m pip install git+https://github.com/eagomez2/moduleprofiler.git
```

# Documentation
You can access the <a href="https://eagomez2.github.io/moduleprofiler/" target="blank">online documentation</a>. There you will find a more in depth introduction to `moduleprofiler`, including tutorials, methods documentation and an extensive reference about the calculations utilized to estimate the operations of different supported `torch.nn.Module` modules.

You can also run the documentation locally by going to the root folder of the package and running:

```bash
mkdocs serve
```

Before running this, make sure that your python environment is enabled.

# Cite
If this package contributed to your work, please consider citing it:

```
@misc{moduleprofiler,
  author = {Esteban Gómez},
  title  = {moduleprofiler},
  year   = 2024,
  url    = {https://github.com/eagomez2/moduleprofiler}
}
```

This package was developed by <a href="https://estebangomez.me/" target="_blank">Esteban Gómez</a>, member of the <a href="https://www.aalto.fi/en/department-of-information-and-communications-engineering/speech-interaction-technology" target="_blank">Speech Interaction Technology group from Aalto University</a>.

# License
For further details about the license of this package, please see [LICENSE](LICENSE).
nexusfm 0.4.0
An advanced personalized file manager with GUI and terminal interface
Requires Python: >=3.6

# NexusFM

NexusFM is an advanced personalized file manager with both GUI and terminal interfaces. It offers features like file operations, hashing, permissions management, and content searching.

## Installation

To install NexusFM, run:

```
pip install nexusfm
```

## Usage

To start the GUI:

```
nexusfm-gui
```

For CLI usage, import and use the `AdvancedPyFileManager` class in your Python scripts.

## Features

- File and directory operations (create, delete, move, copy)
- File hashing
- Change file permissions
- Content search
- Command history
- Interactive GUI

## License

This project is licensed under the MIT License.
task_5_syrkin 0.0.7
Application counts the unique symbols in a string or file.
Requires Python: >=3.12

# Unique Character Counter

## Overview
This Python package provides a tool for counting unique characters in a string or file. The tool can be useful for text analysis, file parsing, and general string processing tasks.

## Features
- Count unique characters in a string.
- Count unique characters in a file.
- Customizable options for ignoring case sensitivity or specific characters.

## Installation
```bash
pip install task_5_syrkin
```
All modules will be installed automatically.

## Usage
In the command line, execute the `collection_app.py` file with the following parameters:

```bash
# To test the application
python3 collection_app.py --test

# For counting unique characters in a string
python3 collection_app.py --string "your string here"

# For counting unique characters in a file
python3 collection_app.py --file "your file here"
```

## Contributing
You can use this package as a function to count unique characters. For further contributions, please clone the repository and follow the guidelines below.

## Changelog
- **0.0.1 release**
- **0.0.2**: Added doctests and README.md file
- **0.0.4**: Added setup.py

```bash
git clone https://git.foxminded.ua/andrii-syrkin-py_ment/task_5.git


```
markets-analytics 1.0.1
A utility package to handle data analytics
Requires Python: >=3.8

# Markets Analytics Package

A utility [package](https://pypi.org/project/markets-analytics/0.1.5/#description) to that helps with data analytics by reducing boiler plate code and replacing them with helper function for database interactivity, ETL pipelines, Google Sheets, and dates.

## Installation

```sh
pip install markets_analytics
```

To install specific version of the package then run the following command:

```sh
pip install markets_analytics==X.Y.Z 
```

# Imports

The following examples showcase how to import packages for the areas you're interested in.

Although you can import original classes like `RedshiftConnector`, aliases have already been provided to reduce this step further.

Database connectivity:

```python
from markets_analytics import redshift, datalake, exasol
from markets_analytics import Redshift, Datalake, Exasol # Actual class names
```

ETL pipelines:

```python
from markets_analytics import etl
from markets_analytics import ETL # Actual class names
```

Google Sheets:

```python
from markets_analytics import GSheetHelper
gsheet = GSheetHelper('<Name of the GSheet>')
```

Date utilities:

```python
from markets_analytics import dateutil
from markets_analytics import DateUtil  # Actual class names
```

Google Chat:

```python
from markets_analytics import GoogleChat
gchat = GoogleChat('<Webhook URL of the Google Chat Space>')
```

Email

```python
from markets_analytics import Email
email = Email('<Your Email ID>', '<Your Email App Password>') # App Password is setup via Google 2FA Security tab
```

## Releasing New Version

To release new versions after making changes, we need to update the `pyproject.toml` file and increment the version's minor or major counter by 1. You would then be able to run the following in your terminal (make sure dist only contains the new version files after build command has successfully completed):

```sh
python3 -m pip install --upgrade build twine
python3 -m build
python3 -m twine upload --repository testpypi dist/* # Repository tag is optional
```

Make sure to set your twine details before uploading the package distributions:

```sh
set TWINE_USERNAME=__token__
set TWINE_PASSWORD=<pypi-token>
```
diegobmota-image-process 0.0.1
Pacote para Processamento de imagens
Requires Python: >=3.8

# package_name

Description. 
The package package_name is used to:
	Processing:
		- Histograma matching
		- Structural similarity
		- Resize image
	Util:
		- Read image
		- Save image
		- Plot image
		- Plot result
		- Plot histogram

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install image_processing
```

## Author
Diego Brito

## License
[MIT](https://choosealicense.com/licenses/mit/)
django-fernet-fields2 0.6
Fernet-encrypted model fields for Django

====================
django-fernet-fields
====================

.. image:: https://secure.travis-ci.org/orcasgit/django-fernet-fields.png?branch=master
   :target: http://travis-ci.org/orcasgit/django-fernet-fields
   :alt: Test status
.. image:: https://coveralls.io/repos/orcasgit/django-fernet-fields/badge.png?branch=master
   :target: https://coveralls.io/r/orcasgit/django-fernet-fields
   :alt: Test coverage
.. image:: https://readthedocs.org/projects/django-fernet-fields/badge/?version=latest
   :target: https://readthedocs.org/projects/django-fernet-fields/?badge=latest
   :alt: Documentation Status
.. image:: https://badge.fury.io/py/django-fernet-fields.svg
   :target: https://pypi.python.org/pypi/django-fernet-fields
   :alt: Latest version

`Fernet`_ symmetric encryption for Django model fields, using the
`cryptography`_ library.

``django-fernet-fields`` supports `Django`_ 1.11 and later on Python 2.7, 3.5, 3.6, 3.7, pypy, and pypy3.

Only PostgreSQL, SQLite, and MySQL are tested, but any Django database backend
with support for ``BinaryField`` should work.

.. _Django: http://www.djangoproject.com/
.. _Fernet: https://cryptography.io/en/latest/fernet/
.. _cryptography: https://cryptography.io/en/latest/


Getting Help
============

Documentation for django-fernet-fields is available at
https://django-fernet-fields.readthedocs.org/

This app is available on `PyPI`_ and can be installed with ``pip install
django-fernet-fields``.

.. _PyPI: https://pypi.python.org/pypi/django-fernet-fields/


Contributing
============

See the `contributing docs`_.

.. _contributing docs: https://github.com/orcasgit/django-fernet-fields/blob/master/CONTRIBUTING.rst

CHANGES
=======

master (unreleased)
-------------------

0.6 (2019.05.10)
----------------

* Support Postgres 10
* Drop support for Django < 1.11, Python 3.3/3.4
* Add support for Django 1.11 through 2.2, Python 3.7

0.5 (2017.02.22)
----------------

* Support Django 1.10.

0.4 (2015.09.18)
----------------

* Add `isnull` lookup.


0.3 (2015.05.29)
----------------

* Remove DualField and HashField. The only cases where they are useful, they
  aren't secure.


0.2.1 (2015.05.28)
------------------

* Fix issue getting IntegerField validators.


0.2 (2015.05.28)
----------------

* Extract HashField for advanced lookup needs.


0.1 (2015.05.27)
----------------

* Initial working version.
qtworker 1.0.2
Generic worker for QThreadpools
Requires Python: >=3.9

# qt Worker

A generic worker class for QThreadpool use.


The following snippet shows the basic usecase
```
from qtworker import Worker

self.pool = QThreadpool()

worker = Worker(function, *args, **kwargs)
worker.signals.started.connect(self.handle_start)
worker.signals.result.connect(self.handle_result)
worker.signals.error.connect(self.handle_error)
worker.signals.finished.connect(self.handle_cleanup)
self.pool.start(worker)
```

> Todo: with full context



## setup

install the package via pip:
```
pip install qtworker
```

The full documentation can be found under 
[qtworker documentation](https://qtworker.readthedocs.io/en/latest/)
The source code can be found under
[qtworker repository](https://github.com/kolja-wagner/qtworker)
news-google-api 0.1.5
A Python library to fetch and parse Google News feeds
Requires Python: >=3.6

# news-google-api

A Python library to fetch and parse Google News feeds.

## Installation

```
pip install news-google-api
```

## Usage

### As a library

```python
from googlenews import GoogleNews

news = GoogleNews()

# Get top news
top_news = news.top_news()

# Get topic headlines
tech_news = news.topic_headlines('TECHNOLOGY')

# Search news
search_results = news.search('Python programming')

# Print results
for entry in top_news['entries']:
    print(f"Title: {entry['title']}")
    print(f"Link: {entry['link']}")
    print(f"Published: {entry['published']}")
    print("---")
```


## Features

- Fetch top news from Google News
- Get headlines for specific topics
- Search for news articles
- Command-line interface for quick access to news

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Amos Maru

## Acknowledgments

- Google News for providing the RSS feeds
- All contributors who help improve this library
public-transit-viewer 1.0.0
Viewer to interact with the public transit service.
Requires Python: <4.0,>=3.12

# Public Transit Viewer

Viewer to interact with the [Public Transit Service](https://github.com/naviqore/public-transit-service).

The streamlit based Python app allows users to query connections between two stops or generate isolines from a specific
stop. The application supports the query parameters of the service to search specific connections or isoline.

## Installation

Get the current release from pypi and start the viewer:

```sh
pip install public-transit-viewer

export NAVIQORE_SERVICE_URL=<SERVER:PORT>
ptv-deploy
```

Or run the viewer inside a Docker container:

```sh
docker run -p 8501:8501 -e NAVIQORE_SERVICE_URL=<SERVER:PORT> ghcr.io/naviqore/public-transit-client:latest
```

Access the viewer on `http://localhost:8501`.

## Development

### Configuration

Create a `.env` file in the root directory. And add a line telling the application to which service host it should
connect. In Local Development this is typically a Java Spring service running on `http://localhost:8080`.

The required line in the `.env` file will then be: `NAVIQORE_SERVICE_URL=http://localhost:8080`

**Note**: you can also specify the `NAVIQORE_SERVICE_URL` in your operating system environment.

### Starting the App

To start the app in development mode run following command from the root directory:

```sh
poetry run streamlit run public_transit_viewer/connections.py
```

## License

This project is licensed under the MIT License - see
the [LICENSE](https://github.com/naviqore/public-transit-viewer/blob/main/LICENSE) file for details.
pynews-google 0.1.2
A Python library to fetch and parse Google News feeds
Requires Python: >=3.6

# PyNews-Google

A Python library to fetch and parse Google News feeds.

## Installation

```
pip install pynews-google
```

## Usage

### As a library

```python
from pynews_google import GoogleNews

news = GoogleNews()

# Get top news
top_news = news.top_news()

# Get topic headlines
tech_news = news.topic_headlines('TECHNOLOGY')

# Search news
search_results = news.search('Python programming')

# Print results
for entry in top_news['entries']:
    print(f"Title: {entry['title']}")
    print(f"Link: {entry['link']}")
    print(f"Published: {entry['published']}")
    print("---")
```

### As a CLI

```
pynews-google top
pynews-google topic --topic TECHNOLOGY
pynews-google search --query "Python programming"
```

## Features

- Fetch top news from Google News
- Get headlines for specific topics
- Search for news articles
- Command-line interface for quick access to news

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Amos Maru

## Acknowledgments

- Google News for providing the RSS feeds
- All contributors who help improve this library
duckdq 0.0.7
A DQ package
Requires Python: >=3.8

# Install
```
pip install duckdq 
```

# Import 
```
from duckdq import client
```

# Libraries
```
from supabase import create_client, Client # type: ignore
from dotenv import load_dotenv # type: ignore
import duckdb # type: ignore
import os

# env
load_dotenv()
URL = os.environ.get("API_URL")
KEY = os.environ.get("API_KEY")
BUCKET_KEY_ID = os.environ.get("BUCKET_KEY_ID")
BUCKET_SECRET = os.environ.get("BUCKET_SECRET")

# Session
session: Client = create_client(URL, KEY)

# Engine
engine = duckdb.connect(':memory:')

# Session
dq = client.APIClient(session, engine)
```

# Job
```
# Name
dataset = "test" 
run_id = "2024-09-24"

# Data
engine.sql(f""" create or replace table {dataset} as select * from read_csv_auto('.csv/fake_customers.csv') limit 10000 """)
```

# Register (initial one-time only)
```
dq.register(dataset)
```

# Run
```
dq.run(dataset, run_id)
```

# Env
.env File
```
API_KEY=xyz
API_URL=xyz
```
Or
Export variables 
```
export API_KEY=xyz
export API_URL=xyz
```

# Database User
```
GRANT USAGE on schema "validation" to anon;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA "validation" TO anon;
GRANT ALL ON SEQUENCE validation.rule_output_rule_output_id_seq TO anon;
GRANT ALL ON SEQUENCE validation. connections_connection_id_seq TO anon;
GRANT ALL ON SEQUENCE validation.owlcheck_q_job_id_seq TO anon;
GRANT ALL ON SEQUENCE validation.job_log_log_id_seq TO anon;
GRANT ALL ON SEQUENCE validation.assignment_q_id_seq TO anon;
```
configwidgets 1.4.3
Subclassing PyQt5.QtWidgets to syncronize state in QSettings object.
Requires Python: >=3.7

# configwidgets

Subclassing `QWidgets` to save the widget state in a `QSettings` Instance.
A `setup` method links the widget to key within the `QSettings` instance. 
The value is loaded during setup and gets stored when the widget state changes.
Without calling this method, the widget has no special behaviour.

See the following snippet for a minimal example:
```
from PyQt5.QtCore import QSettings
from configwidgets import ConfigCheckBox

config = QSettings()
checkBox = ConfigCheckBox()
checkBox.setup(config, "checkBox")
```

## setup

install the package via pip:
```
pip install configwidgets
```

The full documentation can be found under 
[configwidgets documentation](https://configwidgets.readthedocs.io/en/latest/index.html)
The source code can be found under
[configwidgets repository](https://github.com/kolja-wagner/configwidgets)
dbt-metric-utils 0.1.1
Utilities for dbt metrics.
Requires Python: >=3.10

# dbt-metric-utils

This tool allows you to query metrics from your dbt semantic model directly from a dbt model through the `dbt_metric_utils_materialize` macro. One way to look at it is that it revives the `metric.calculate()` macro from dbt `<=v1.5`. By having access to this macro, the dbt semantic layer becomes more useful for dbt-core users. You still don't have all the goodness of dbt-cloud semantic layer but it does allow you to get started with connecting your users and BI tools to aggregation tables/views that are directly querying your metrics.

> [!TIP]
> Check out some examples queries [here](./jaffle-shop/models/marts/materialized_metrics/)

> [!TIP]
> Browse the dbt docs pages for the example project [here](https://djlemkes.github.io/dbt-metric-utils)

## Installation instructions

This project is a Python package that wraps around `dbt` in the most transparant way I could find. Try it out through the following steps:

1. Install `dbt-metric-utils` from Pypi in your project (e.g. `pip install dbt-metric-utils`)
1. Run `dbt-metric-utils init` or `dbtmu init`. This will install the macro into your project and will make sure that any `dbt` CLI calls are intercepted and processed in the correct way (check below for explanation)
1. Introduce a dbt model that calls the `dbt_metric_utils_materialize` macro.
1. Continue using `dbt` as you're used to.

## How it works

Any dbt command that doesn't require dbt to compile your project is simply passed directly to dbt (Mode A in the diagram). A dbt invocation that does require compilation (e.g. `compile`, `run`, `test` , etc) is intercepted by the package.

![](assets/how_it_works.png)

After intercepting we run through the following sequence of steps

1. Call `dbt parse` . This will build a partially filled `manifest.json` from which we can extract all the models, their dependencies, and the raw SQL queries.
2. Extract all models that contain a `dbt_metric_utils_materialize` invocation.
3. Run `mf query --explain` commands for all the `dbt_metric_utils_materialize` invocations.
4. Inject the generated queries by Metricflow as dbt variables in the actual dbt command. If the user ran `dbt run` , we actually trigger `dbt run --vars {<macro_invocation_signature>: <query>}` 

The passed variables will be a mapping from `dbt_metric_utils_materialize` invocation signature (e.g. `metric=['m1'],dimensions='[dim1']...` ) to the generated metric query. The  `dbt_metric_utils_materialize` macro will find that variable at compile time and return it as the macro result. 

Along this sequence of steps, we also ensure that the dependency graph in `manifest.json` is updated correctly. Dbt itself only detects dependencies based on `ref` and `source` , not on macros that are external to it.
mysudoku 1.3
A Sudoku generator and solver

# My Sudoku
Sudoku generator and solver


## Installation
```
pip install mysudoku
```

Example:
```
from mysudoku import Sudoku

sudoku = Sudoku(dimension=3, difficulty=0.5)

print(sudoku)

'''
9 8 . 5 1 . . . .
. 6 . . . . 7 1 .
7 . 5 . 6 4 9 . .
. 2 . 7 5 . . . .
. . 4 9 . 6 . 5 .
8 5 . 4 3 1 6 2 .
. . 6 . 7 2 . 4 1
. 4 1 6 9 3 2 . .
. . 8 . 4 5 . 9 .
'''
```