semvec/pypi-packages huggingface dataset:
pytest-nogarbage 1.0.1
Ensure a test produces no garbage
License: MIT
Requires Python: >=3.7

================
pytest-nogarbage
================

.. image:: https://img.shields.io/pypi/v/pytest-nogarbage.svg
    :target: https://pypi.org/project/pytest-nogarbage
    :alt: PyPI version

.. image:: https://img.shields.io/pypi/pyversions/pytest-nogarbage.svg
    :target: https://pypi.org/project/pytest-nogarbage
    :alt: Python 3.7+

.. image:: https://img.shields.io/pypi/implementation/pytest-nogarbage.svg
    :target: https://pypi.org/project/pytest-nogarbage
    :alt: CPython

.. image:: https://img.shields.io/pypi/l/pytest-nogarbage.svg
    :target: https://pypi.org/project/pytest-nogarbage
    :alt: MIT License

The purpose of this plugin is ensuring that portions of your Python code do not produce garbage or manually invoke garbage collection.

When the `nogarbage` pytest fixture is added to a test, it will cause an error under the following conditions:

* Garbage was collected after the test was run (circular references were remaining after the test was broken down).
* Garbage was explicitly collected  (`gc.collect()`) during the test.  Automatic garbage collection sweeps are disabled during the test.

You should use this plugin when:

* You intend to run a program with garbage collection disabled in production.
* You wish to verify elimination of garbage collection overhead produced by frequently called functions.

This tool is not for finding memory leaks; even if your code produces no garbage, native call-ins can still leak memory.  Garbage in CPython is specifically circular references between Python objects.

If you are interested in optimizing CPython garbage collection or unsure of the difference between garbage and memory leaks, the `gc docs`_ and `CPython Garbage Collection devguide`_ are excellent resources.

Requirements
------------

* Python 3.7+
* This plugin is only tested against CPython.


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

You can install "pytest-nogarbage" via `pip`_ from `PyPI`_::

    $ pip install pytest-nogarbage


Usage
-----

Add the `nogarbage` fixture to your test to ensure it does not produce garbage::

    def test_circular(nogarbage):
        l1 = []
        l2 = [l1]
        l1.append(l2)
        # ERROR: Garbage collected after test.

    def test_collect(nogarbage):
        import gc
        gc.collect()
        # ERROR: Garbage collected during test.


Running the Tests
-----------------

This project uses `nox`_ to test against multiple Python versions::

    $ python3 -m venv .venv
    $ source .venv/bin/activate
    (.venv) $ pip install nox uv
    (.venv) $ nox


License
-------

Distributed under the terms of the `MIT`_ license, "pytest-nogarbage" is free and open source software.

.. _`MIT`: http://opensource.org/licenses/MIT
.. _`file an issue`: https://github.com/mvollrath/pytest-nogarbage/issues
.. _`nox`: https://nox.thea.codes/en/stable/
.. _`pip`: https://pypi.org/project/pip/
.. _`PyPI`: https://pypi.org/project
.. _`gc docs`: https://docs.python.org/3/library/gc.html
.. _`CPython Garbage Collection devguide`: https://devguide.python.org/garbage_collector/
web360 0.1.3
Tools for AI Agents
License: MIT
Requires Python: <3.13,>=3.10

# web360


`/docs' contains auto-generated files from [360noscope.gitbook.io](https://360noscope.gitbook.io/web360)
Files must be generated in Gitbook, and are synced to these here.

[360noscope.gitbook](https://app.gitbook.com/o/92bqHwQOS4AmsvwJSGH3/s/pfkqTTnftgbXDg4FUKCF/) is synced to doctorslimms github.
dev@360noscope.co has web360.gitbook.io



`/apps` contains frontend applications

```
apps/                     
│── console/                     # console.web360.dev
│   │── js/tsx
|   ...
│── landing-page/                # web360.dev
│   │── index.html               # Html file to edit
```

Run frontend from subdirectories
```bash
cd apps/console
npm run dev 
```



Tools, interfaces, and Api Types can be found in [/web360/tools](/web360/tools)

The Api which is exposed via [api.web360.dev](api.web360.dev) is run by [/web360/main.py](/web360/main.py)

```
web360/
│── main.py                  # start Api and settings
│── web360.py                # web360 class definition
│── logger.py                
│── deps/                    # Api middleware / auth / logging
│   │── __init__.py        
│── tools/                   # llm tool definitions and models
│   │── __init__.py        
│   ├── search.py            # contains SearchTool that is a Pydantic object with description, summary, examples, and endpoint
│   ├── ...
```

Database schemas
```
/models                          # contains sql and json models for cross app compatgibility
apilogs.sql                      # supabase SQL table definition
apilogs.json                     # converted to ts interface for console, and pydantic for Api
...
```


`/web360` Python package 
```bash
pip install web360
```

Api server
```bash
import web360

app = web360.create_app('...')
uvivcorn...
```
erlachemy-schemadisplay-anywidget-magic 0.0.2
Python package installation for erlachemy_schemadisplay_anywidget_magicy
License: MIT

# erlachemy_schemadisplay_anywidget_magic

IPython magic to generate a database schema using `eralchemy` and display it using `jupyter_anywidget_graphviz` Graphviz WASM anywidget.

Install from PyPi as:

`pip install erlachemy_schemadisplay_anywidget_magic`

Enable magics: `%load_ext eralchemy_schemadisplay_magic`

Create magic with "hidden" graphviz anywidget: `%schema_magic_init`

Alternatively, create an anywidget and pass it it:

```python

from jupyter_anywidget_graphviz import (
    graphviz_headless,
)

g = graphviz_headless()
%schema_magic_init g
```

Create example database:

```python

import sqlite3


def create_database():
    # Connect to (or create) the SQLite database
    conn = sqlite3.connect("example.db")
    cursor = conn.cursor()

    # Create the parent table
    cursor.execute(
        """
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL
        )
    """
    )

    # Create the child table with a foreign key reference to users
    cursor.execute(
        """
        CREATE TABLE IF NOT EXISTS orders (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER NOT NULL,
            product TEXT NOT NULL,
            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
        )
    """
    )

    # Commit and close
    conn.commit()
    conn.close()

create_database()
```

Generate schema as dot script and render using graphviz widget:

__Note that this requires the `-m / --mode` to be set to `dot`, which it is by default, although we can also pass it explicitly.

```python
dot_data = %schema_magic -c "sqlite:///example.db" -m dot

from IPython.display import SVG
SVG( g.render(dot_data)["svg"] )
```

If we pass a widget in to the magic, and we have a "full" `anywidget` running environment (not JupyterLite/pyodide), we can use the `-e / --embed` switch to return the dot diagram rendered as SVG (this will attempt to create/use an internally created graphviz widget). Alternatively, we can pass a grpahviz widget using the `-w / --widget-name` parameter.

`%schema_magic -c "sqlite:///example.db" -m dot -e`

`%schema_magic -c "sqlite:///example.db" -m dot -w g`


![Example of generating schema diagrma using magic](images/example.png)


TO DO - fix things so it works in Marimo:

- remove IPython refs
- move function to create and render dot file out of magic and into a cleaner py api
cxreports-api-client 0.0.4
Connect to CxReports API from your application.
License: MIT
Requires Python: >=3.0

# CxReportClientV1 Usage Example

 `cxreports-api-client` is a Python library that provides a simple and intuitive interface for interacting with the CxReports application’s API. This library allows you to perform various operations on CxReports, such as retrieving reports, sending data, and generating PDFs.

## Usage
```python
from cx_report_client import CxReportClientV1

# Initialize the client
client = CxReportClientV1(URL, DEFAULT_WORKSPACE, TOKEN)

types = client.get_report_types()
print(types)

types_from_another_ws = client.get_report_types(26)
print(types_from_another_ws)

workspaces = client.get_workspaces()
print(workspaces)

reports = client.get_reports("other")
print(reports)

reports_from_another_ws = client.get_reports("showcase", 26)
print(reports_from_another_ws)

token = client.create_auth_token()
print(token)

temp_data = client.push_temporary_data({"title": {'value': '123 123 123 123'}})
print(temp_data)

# get tempDataId from temp_data
temp_data_id = temp_data['tempDataId']

# Generate a PDF report
pdf = client.get_pdf(160)
with open("./test1.pdf", 'wb') as pdf_file: pdf_file.write(pdf)

# Generate a PDF report with parameters (e.g., title)
pdf = client.get_pdf(160, {"tempDataId":temp_data_id,"params": {"title": "First page title"}})
with open("./test2.pdf", 'wb') as pdf_file: pdf_file.write(pdf)

# Generate a PDF report from another WS
pdf = client.get_pdf(149, None, 26)
with open("./signature.pdf", 'wb') as pdf_file: pdf_file.write(pdf)
artgen 0.2.0
A CLI tool that generates ASCII art based on a brief description.
License: MIT
Requires Python: <4.0.0,>=3.12
Keywords: ascii, cli, art, art, generate

## ArtGen

ArtGen is a CLI tool that generates ASCII art from images and text. This project was created out of an interest in building something fun using existing Python packages. It is free, open-source, and designed to convert images into ASCII art. Additional features and changes are being explored and will be updated in upcoming versions.

## Features

Two New features
- **interactive web** mode to allow more control and support for local image upload
- **interactive cli** mode to allow run within terminal.

- Fetches images using DuckDuckGo
- Converts images to ASCII art
- Shows fallback stylized text with `pyfiglet`

## Installation

You can install ArtGen from [PyPI](https://pypi.org):

```bash
  pip install artgen --upgrade
```

## Usage

To generate ASCII art, use the following command:

```bash

  artgen generate_art "Cat"

  artgen generate_word "Sunflower"

  artgen generate_img "ASCII"

```

### For interactive

For web interface:
```bash
   artgen interactive

```
That will open on [localhost or ](http://localhost:5000/)

For cli interactive interface:
```bash
   artgen interactive_cli
```

That will launch in terminal. Known issue for terminal mode for some windows user had permission issue saving file but works on linux or osx


## Contributing

Contributions are welcome! Please open an issue or PR on GitHub.
py-immutablex 0.1.0
A Python library for interacting with the Immutable X API
License: MIT
Requires Python: >=3.7
Keywords: immutablex blockchain starknet ethereum python

# py-immutablex

![Donate](https://img.shields.io/badge/Donate-IMX/ETH-green) `0xF610975E70674b7b6429da6266a1a5d8C1C99238`

A Python library for interacting with the [Immutable X](https://www.immutable.com/) API. This library provides tools to derive Stark keys from Ethereum keys, register users, perform transfers, and more—aiming to eventually cover all Immutable X API resources.

[![PyPI version](https://badge.fury.io/py/py-immutablex.svg)](https://badge.fury.io/py/py-immutablex) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) ![Tests](https://github.com/luizrrodrigues/py-immutablex/actions/workflows/tests.yml/badge.svg)

## Features
- Derive Stark keys from Ethereum private keys for Immutable X.
- Register users on Immutable X with Ethereum and Stark signatures.
- Perform transfers (e.g., ETH) using the Immutable X API.
- (In progress) Full coverage of Immutable X API endpoints: assets, orders, trades, balances, and more.

## Installation

Install via pip:

```bash
pip install py-immutablex
```

## Quickstart

Here’s how to initialize the client and perform a transfer:

```python
from py_immutablex import IMXClient

# Initialize with your Ethereum private key
client = IMXClient('0xYourEthereumPrivateKeyHere')

# Transfer 1 ETH (in wei) to another address
transfer_id = client.transfer(
    transfer_to='0xRecipientAddress',
    token='ETH',
    amount='1000000000000000000'  # 1 ETH in wei
)
print(f'Transfer ID: {transfer_id}')
```

## Prerequisites

- Python 3.7+
- An Ethereum private key (keep it secure!)
- Dependencies (installed automatically via pip):
  - requests
  - bip32
  - eth-account
  - starkware-crypto-signature

## Development Status

This library is under active development. Current focus:
- Robust key derivation and user registration.
- Transfer functionality.

Planned features:
- Full Immutable X API support (assets, orders, trades, etc.).
- Comprehensive error handling and logging.
- Unit tests and CI/CD.

Check the [Issues](https://github.com/luizrrodrigues/py-immutablex/issues) tab for progress or to request features!

## Contributing

Contributions are welcome! Fork the repo, create a branch, and submit a pull request. See CONTRIBUTING.md for details.
1. Fork the repo.
2. Install dependencies: pip install -r requirements.txt
3. Run tests (WIP): pytest
4. Submit a PR!

## License

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

## Acknowledgments
- Built with inspiration from the Immutable X developer community.

-----

Questions? Bugs? Open an issue or reach out: [@luizrrodrigues](https://github.com/luizrrodrigues).