semvec/pypi-packages huggingface dataset:
machine-stats-bojack 0.2
A simple and effective way to gather machine statistics (RAM, Storage, CPU, etc.) from server environment

# Machine Stats Alpha

[![PyPI](https://img.shields.io/pypi/v/machine-stats-alpha)](https://pypi.org/project/machine-stats-alpha/)

| Warning: This is not a stable release!  |
|-----------------------------------------|

For a simple and effective way to gather machine statistics (RAM, Storage, CPU)
from a server environment, please check out the stable version at [machine-stats](https://pypi.org/project/machine-stats/).
drf-translated 0.0.1
DRF modeltranslation serializer
Requires Python: >=3.8
Keywords: python,python3,modeltranslation,drf,serializer


# drf-translated 

django-modeltranslation DRF serializers

## Features

- Query/context translation support
- Highly customizable

## Installation 
```bash
pip install drf-translated
```

## Usage

Create a drf_translated.serializers.TranslatedModelSerializer serializer for your registered translation model:

```python
from drf_translated.serializers import TranslatedModelSerializer

class MovieSerializer(TranslatedModelSerializer):
  class Meta:
    model = Movie

    fields = '__all__'

```

| Setting | Default | Description |
| ------ | ------ | ------ |
| DRF_TRANSLATED_QUERY_PARAM | language | Query language param to convert translated values from dict to str |
| DRF_TRANSLATED_LOCALE_CONTEXT | locale | Serializer context key for getting translation language |
LyceanEM 0.0.3
LyceanEM is a Python library for modelling electromagnetic propagation for sensors and communications. You can find the documentation at https://lyceanem-python.readthedocs.io/en/latest/
Requires Python: >=3.7

.. _introduction:

About This Project
###################

LyceanEM was conceived to enable rapid assesments of the suitability of difference antenna apertures for a wide range of platforms.
This is based upon the use of ray tracing to determine the field of view of points of interest on the platform, whether building, train, plane, or mobile phone handset. Allowing the application of Wheelers formulation of the gain of an aperture.

This has been developed further since that point to include a frequency domain propagation model, allowing for antenna arrays and aperture antennas to be simulated with environment scattering.

Further development is planned for time domain modelling, computational efficiency, and eventually a Finite-Difference Time-Domain algorithm may be implemented to allow for modelling of a wider range of situations, or possibly hybrid modelling. This would use the FDTD algorithm for near field calculations, while using the ray tracing for more sparse situations.

Further documentation can be found `here`_.

.. _here:  https://lyceanem-python.readthedocs.io/en/latest/index.html

If you use LyceanEM in an academic project, please cite our paper:

::

    @article{Pelham2021,
        author      = {Timothy G Pelham and Geoff Hilton and Evangelos Mellios and Rob Lewis},
        title       = {Conformal Antenna Array Design Using Aperture Synthesis and On-Platform Modeling},
        journal     = {IEEE Access},
        year        = {2021},
        doi         = {10.1109/ACCESS.2021.3074317}
    }

Core Features
===============
* 3D Visualization of Platform and Antenna Arrays
* Aperture Projection
* Raycasting
* Frequency Domain Electromagnetics Modelling for scattering, antennas, and antenna array patterns
* Time Domain Electromagnetics Modelling for scattering, antennas, and antenna array patterns
* GPU acceleration of core operations

Supported Platforms
=====================

The package has been tested on:

* Ubuntu and Mint 18.04 and 20.04
* Windows 10 64-bit

With Python versions:

* 3.7

Dependancies
==============

LyceanEM uses CUDA for GPU acceleration. The advised installation method is to use Conda to setup a virtual
environment, and installing both cudatoolkit and cupy.

.. code-block:: console

   $ conda install -c conda-forge cudatoolkit
   $ conda install -c conda-forge cupy
   $ conda install -c lyceanem lyceanem

Resources
==========
* Code: `github.com/LyceanEM/LyceanEM-Python <https://github.com/LyceanEM/LyceanEM-Python>`_
* Documentation: `lyceanem-python.readthedocs.io/en/latest/ <https://lyceanem-python.readthedocs.io/en/latest/>`_
* License: `github.com/LyceanEM/LyceanEM-Python/blob/master/LICENSE.txt <https://github.com/LyceanEM/LyceanEM-Python/blob/master/LICENSE.txt>`_
urban-dictionary-python 0.0.9
Urban Dictionary Python (Unofficial)
Keywords: python,urban_dictionary,requests,api

# Urban Dictionary Python (Unofficial)

A Python Library To Web Scrape Urban Dictionary.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

```bash
pip install urban-dictionary-python
```

## Usage

```python
import urban_dictionary
word="" # Enter A Word
# Make An Instance
ubd=urban_dictionary.UrbanDictionary(word)
# Get Most Liked Meaning
print(ubd.meaning())
# Get Most Liked Meaning's Example
print(ubd.example())
# Get Most Liked Meaning's Author Name
print(ubd.author())
# Get Most Liked Meaning's Publishing Date
print(ubd.publishing_date())
# Get Most Liked Meaning's Mug Link
print(ubd.mug_link())
# Get Most Liked Meaning's Front Mug Image
print(ubd.front_mug_image())
# Get Most Liked Meaning's Back Mug Image
print(ubd.back_mug_image())
# Get More Meanings List:
print(ubd.more_meanings())
# Get More Meanings Of Query :
for i in ubd.more_meanings():
    print(i)
# Get All Meanings Of Query :
for i in ubd.more_meanings():
    print(i["meaning"])
# Get All Examples Of Query :
for i in ubd.more_meanings():
    print(i["example"])
# Get Every Author's Name :
for i in ubd.more_meanings():
    print(i["author"])
# Get Every Meaning's Publishing Date :
for i in ubd.more_meanings():
    print(i["date"])
# Get Every Meaning's Mug Back Image :
for i in ubd.more_meanings():
    print(i["mug_back_image"])
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://github.com/0xN1nja/urban-dictionary-python/blob/master/LICENCE.txt)
watchdoc 0.0.1
Markdown and Jupyter Notebook file watcher. It generates automatically a docx, a pptx, and a pdf for each md or ipynb file.
Requires Python: >=3.7

# WatchDoc

Markdown and Jupyter Notebook file watcher. It generates automatically a docx, a pptx, and a pdf for each md or ipynb file.


References for markdown: [Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
erc721 0.0.4
A Python library for interacting with the public google BigQuery datasets to extract ERC721 token data.
Requires Python: >=3.6

# Project Description

A simple interface to interact with the ethereum ETL data stored in public Google BigQuery datasets. Requires a GCP Project to interact with the data.

# Setup and Installation

Firstly you must have set up a GCP project to interact with the public google BigQuery datasets using Python. To do this follow the instructions located under quick setup [here](https://pypi.org/project/google-cloud-bigquery/).


Next, install this module from PyPi.

```
pip install erc721
```

That's it, once this is setup you should be able to interact with the provided functions.

# Interactions

There are a few simple interactions provided:

```python
get_all_collection_transfers_sql(nft_token_address)
```

This fetches all of the transfers and sales for a single ERC721 token. For example to get all transfers for BAYC, pass the token address "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d" as a string to the function.

This will extract all of the sales and transfer data for that desired collection and return it as a pandas dataframe.

Additionally a highwatermark (of the blocknumber) can be passed to this function to allow for faster batch processing from past that point only. The function will return a second value which is a new highwatermark of the highest block number returned.

```python
get_all_sales(all_data=None, collection_address=None)
```

This fetches all of the sales data and returns it as a pandas dataframe. This can either be called alone by being passed a collection address (for BAYC: collection_address="0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d") or if you have already extracted data using get_all_collection_transfers, the result of this can be passed.

```python
get_all_transfers(all_data=None, collection_address=None)
```

Working in the same way as the above function, this function returns all of the transfers (without any payment).

```python
get_all_sales_and_transfers(all_data=None, collection_address=None)
```

Working in the same way as the two above functions, this function returns two arguments all sales and all transfers respectively as two separate pandas dataframes.
mypythonanywhere 0.1.5rc0
A python wrapper for the pythonanywhere.com API
Requires Python: >=3.10

# MyPythonAnywhere

A python async package to communicate with [PythonAnywhere](https://help.pythonanywhere.com/pages/API) api.

## Installation

The beta package is available at [PyPi](https://pypi.org/project/mypythonanywhere).

## Get Started

### Requirements

1. Api Token: get your api token from [pythonanywhere account page](https://www.pythonanywhere.com/user/MerrilleChoate/account/).

2. Determine if your account is US_Based or EU_Based ( It's commonly US. )

3. Your username.

### Create Client

``` py
from mypythonanywhere import AccountType, FriendlyPythonAnywhereClient

client = FriendlyPythonAnywhereClient(
    username='MerrilleChoate',
    token='API_TOKEN',
    account_type=AccountType.UsBased
)
```

### Send Requests

Get cpu usage.

``` py
>>> result = await client.cpu.get_cpu_usage()
>>> print(result)
# CpuUsage(daily_cpu_limit_seconds=100, next_reset_time='2022-04-17T11:23:40', daily_cpu_total_usage_seconds=0.0) 
```

Get all of your consoles.

``` py
>>> result = await client.consoles.get_consoles()
>>> print(result)
# [Console(id=24036640, user='MerrilleChoate', executable='python2.7', arguments='', working_directory=None, name='Python2.7 console 24036640', console_url='/user/MerrilleChoate/consoles/24036640/', console_frame_url='/user/MerrilleChoate/consoles/24036640/frame/')]
```

### A full example

Send requests one by one

``` py
import asyncio

async def main():

    client = FriendlyPythonAnywhereClient(
        username='MerrilleChoate',
        token='API_TOKEN',
        account_type=AccountType.UsBased
    )

    consoles = await client.console.get_consoles()
    print(consoles)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```

Send a batch of requests using one session

``` py
import asyncio

async def main():

    client = FriendlyPythonAnywhereClient(
        username='MerrilleChoate',
        token='API_TOKEN',
        account_type=AccountType.UsBased
    )

    async with client:
        consoles = await client.console.get_consoles()
        for x in consoles:
            await client.console.kill_console(x.id)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```

### Direct Call

``` py
from mypythonanywhere.pythonanywhere import PythonAnywhereClient
from mypythonanywhere.types.requests.console_requests import GetConsoleInfo

client = PythonAnywhereClient(
    # --- sniff ---
)

console = await client(GetConsoleInfo(123456789)) # Console
```

🍟 _Not all methods are implemented yet!_
...

## Contribute

There're api methods that are not implemented. following the order of <https://help.pythonanywhere.com/pages/API>, methods related to files and below are yet to implement.

### Implement Methods?

Take a look at [requests dir](src/mypythonanywhere/types/requests) for examples of implementing api methods.

All you need is to inherit from `BaseRequest[T]` ( where `T` is the method return type ). then filling the abstract methods, unless you face something new.

### Automated tests

Tests are missing for most of methods.