Saravanan666/pypi-org huggingface dataset:
Package: e621-dl
e621-dle621-dlis a simple and fast e621 post/pool downloader. It is based upon thee621api wrapper both in implementation and interface.Installationpip install e621-dlQuickstartDownloading PostsTo download posts with the ids 12345 and 67891:e6 posts get 12345 67891To download all posts that match the canine but not the 3d tag:e6 posts search "canine -3d"To download 500 posts that match the 3d tag:e6 posts search 3d -m 500To download posts that match the 3d tag to directory e621_downloads:e6 posts search 3d -d e621_downloadsTo download all posts that match the 3d tag and replace all post duplicates from the parent directory with symlinks:e6 posts search 3d -sDownloading PoolsTo download the pools with the ids 12345 and 67891:e6 pools get 12345 67891To download at most 10 pools whose names start with "Hello" and end with "Kitty" with anything else in the middle.e6 pools search --name-matches Hello*Kitty -m 10To download the top 3 active series ordered by post count to a directory named "my_top_3":e6 pools search --is-active --order post_count -m 3 -d my_top_3There are a lot more options so I recommend checking out the output ofe6 pools search --helpUsing Api KeyTo save e621 login information to be used for every future query:e6 loginTo remove e621 login information:e6 logoutOptimizing SpaceTo replace all post duplicates from the current directory (all of its subdirectories) with symlinks:e6 cleanFAQ and Known IssuesIf your tags include the minus (-) sign, a colon (:), or any other character bash/typer might consider special -- you must wrap your query in quotation marks. For example,e6 posts search "3d -canine order:score"For advanced reference, use--helpoption. For example,e6 --help,e6 posts search --help, etc.
Package: e621-stable
e621e621 is a feature-rich high-level e621 and e926 API wrapper.It provides access to almost all of the endpoints available. The only exceptions are unstable and admin-only endpoints.e621 API documentation is currently highly undocumented, unstable, and sometimes even untruthful. We tried to wrap it in a sanest possible way, properly documenting all the possible ways to interact with it. However, if you still have any questions, bugs to report, or features to request -- please, create an issue on ourgithub pageand we will reply as soon as we can.Installationpipinstalle621-stableQuickstartWe translate everything the API returns to python data types created with pydantic. Everything is 100% typehinted so you get autocomplete everywhere and your IDE will warn you if you are sending invalid arguments or using nonexistent attributes.Creating the api clientTo create the most basic client, all you need to do isfrome621importE621api=E621()If you wish to get information about your account, use your blacklist or create/update/delete any of the e621's entities, you will have to create an api key and put it into the API client as such:api=E621(("your_e621_login","your_e621_api_key"))SearchingThe majority of the endpoints allow you to query for a list of their entities, be it posts, pools or tags.To search for posts that match the "canine" but not the "3d" tag:posts=api.posts.search("canine -3d")# Orposts=api.posts.search(["canine","-3d"])To search for pools whose names start with "hello" and end with "kitty":posts=api.pools.search(name_matches="hello*kitty")e621 searching api is paginated, which means that if you want to get a lot of posts, you will have to make multiple requests with a different "page" parameter. To simplify interactions with paginated queries, all of our searching endpoints support the "limit", "page", and "ignore_pagination" parameters. If you wish to get a specific number of entities, simply pass the "limit" and "ignore_pagination" arguments:tags=api.tags.search(name_matches="large_*",limit=900,ignore_pagination=True)Accessing AttributesWhen you have retrieved the entities, you can access any of their attributes without dealing with json.forpostinposts:print(post.score.total,post.all_tags,post.relationships.parent_id)withopen(f"{post.id}.{post.file.ext}","wb")asf:f.write(requests.get(post.file.url).content)GettingMany entities that have unique identifiers (such as post_id or username) support indexing using these ids:post=api.posts.get(3291457)posts=api.posts.get([3291457,3069995])pool=api.pools.get(28232)user=api.users.get("fox")Updatingapi.posts.update(3291457,tag_string_diff="canine -male",description="Rick roll?")CreatingfrompathlibimportPathapi.posts.create(tag_string="canine 3d rick_roll",file=Path("path/to/rickroll.webm"),rating="s",sources=[],description="Rick roll?")
Package: e621-temp
e621e621 is a feature-rich high-level e621 and e926 API wrapper.It provides access to almost all of the endpoints available. The only exceptions are unstable and admin-only endpoints.e621 API documentation is currently highly undocumented, unstable, and sometimes even untruthful. We tried to wrap it in a sanest possible way, properly documenting all the possible ways to interact with it. However, if you still have any questions, bugs to report, or features to request -- please, create an issue on ourgithub pageand we will reply as soon as we can.Installation$pipinstalle621QuickstartWe translate everything the API returns to python data types created with pydantic. Everything is 100% typehinted so you get autocomplete everywhere and your IDE will warn you if you are sending invalid arguments or using nonexistent attributes.Creating the api clientTo create the most basic client, all you need to do isfrome621importE621api=E621()If you wish to get information about your account, use your blacklist or create/update/delete any of the e621's entities, you will have to create an api key and put it into the API client as such:api=E621(("your_e621_login","your_e621_api_key"))SearchingThe majority of the endpoints allow you to query for a list of their entities, be it posts, pools or tags.To search for posts that match the "canine" but not the "3d" tag:posts=api.posts.search("canine -3d")# Orposts=api.posts.search(["canine","-3d"])To search for pools whose names start with "hello" and end with "kitty":posts=api.pools.search(name_matches="hello*kitty")e621 searching api is paginated, which means that if you want to get a lot of posts, you will have to make multiple requests with a different "page" parameter. To simplify interactions with paginated queries, all of our searching endpoints support the "limit", "page", and "ignore_pagination" parameters. If you wish to get a specific number of entities, simply pass the "limit" and "ignore_pagination" arguments:tags=api.tags.search(name_matches="large_*",limit=900,ignore_pagination=True)Accessing AttributesWhen you have retrieved the entities, you can access any of their attributes without dealing with json.forpostinposts:print(post.score.total,post.all_tags,post.relationships.parent_id)withopen(f"{post.id}.{post.file.ext}","wb")asf:f.write(requests.get(post.file.url).content)GettingMany entities that have unique identifiers (such as post_id or username) support indexing using these ids:post=api.posts.get(3291457)posts=api.posts.get([3291457,3069995])pool=api.pools.get(28232)user=api.users.get("fox")Updatingapi.posts.update(3291457,tag_string_diff="canine -male",description="Rick roll?")CreatingfrompathlibimportPathapi.posts.create(tag_string="canine 3d rick_roll",file=Path("path/to/rickroll.webm"),rating="s",sources=[],description="Rick roll?")FAQFor more information on these and other api endpoints, please, visit ourendpoint reference
Package: e6b
E6BSimple python project to perform E6B flight calculationsInstallation$pipinstalle6bUsageCalculate required flight bearing and final ground speedfrome6bimporte6bwindSpeed=10windBearing=90trueAirSpeed=15desiredBearing=180correctedBearing,correction=e6b.getCorrectedBearing(windSpeed,windBearing,trueAirSpeed,desiredBearing)groundSpeed=e6b.getGroundSpeed(windSpeed,windBearing,trueAirSpeed,desiredBearing,correction)print(correctedBearing)>>138.18968510422138print(groundSpeed)>>11.180339887498947Using radians instead of degreesfrome6bimporte6bwindSpeed=10windBearing=1.5708trueAirSpeed=15desiredBearing=3.14159correctedBearing,correction=e6b.getCorrectedBearing(windSpeed,windBearing,trueAirSpeed,desiredBearing,True)groundSpeed=e6b.getGroundSpeed(windSpeed,windBearing,trueAirSpeed,desiredBearing,correction,True)print(correctedBearing)>>2.4118623437909346print(groundSpeed)>>11.180276619728994
Package: e6py
e6pye6pyis an API wrapper for e621/e926RequirementsPython 3.10requests >= 2.26.0attrs >= 21.2.0Usagefrome6pyimportE621Clientclient=E621Client(login="username",api_key="API Key")posts=client.get_posts()forpostinposts:print(f"Got post{post.id}")print(f"  Rating:{post.rating}")print(f"   Score:{post.score}")print(f"     URL:{post.file.url}")
Package: e6py-aio
e6py-aioe6py-aiois an asyncio API wrapper for e621/e926RequirementsPython >= 3.10aiohttp >= 3.8.5attrs >= 22.2.0Usagefrome6py_aioimportE621Clientclient=E621Client(login="username",api_key="API Key")posts=awaitclient.get_posts()forpostinposts:print(f"Got post{post.id}")print(f"  Rating:{post.rating}")print(f"   Score:{post.score}")print(f"     URL:{post.file.url}")
Package: e7epd
E707 Electronics Parts Database (E7EPD)Database Rev 0.5, Backend and CLI Rev 0.5.1Still a Work-In-ProgressThis project attempts to create yet another open-source electronics parts management system. While there are some out
there, I wasn't satisfied with them.Philosophy and GoalsSimplicity: The core application should remain simple to allow for ease of adding features. This is partially
why only a CLI will be created for this instead of a webpage or a GUI application, and why the language this program
will use is Python.Modularity: The core application will be made in such a way as to allow ease of adding new parameters for example.
Mostly will be accomplished with configuration listsParameterization, Kind of: The only components that really need parameterization are things like resistors, capacitors, etc.
Things where the specific part number doesn't matter for a project.
In contrast to a microcontroller, a project can't really say: I don't care which micro as long as it's 8-bits.Interoperability: This database specification will use a common database (SQL like), and be documented so that
migration from and away from this specific program shall be possible.InstallationFrom Rev0.4 and onwards,e7epdcan be installed withpip install e7epdTo install from the GitHub repository, run the following command inside the cloned repository:pip install .Security:As of Rev 0.3, this project uses sqlAlchemy, without directly creating SQL commands like before. This should make it more
secure than previous revisions in terms of arbitrary SQL code issues.NOTICE: The password for a mySQL user is stored in a json file in plain format. Make sure the mySQL account only has permission to the parts' database.CLI ApplicationTo start using this application/database, simply launche7epdfrom the command line. Prompts should show up, allowing you to interact with the
parts database. Some of the things you can do with it are:Add a partDelete a partSee the entire part's database tableAdd and/or remove stock to a partDocsThe documentation for this project can be found inthe project's readthedocs.The documentation is for the latest released version. For the non-released master docs, seehere.Database specification and InterfaceFor more details as to how parts are stored in the database, seedatabase specificationThe python filee7epd.pyincludes aE7EPDclass, which is a wrapper for the database.
To add the database wrappere7epd.pyto your project, you will need Python>3.7 with their pre-installed packages as well as the following extra packages:SQLAlchemyalembicThe following packages are required to run it:richengineering_notationquestionarySQLAlchemyalembicChangelog and In-ProgressFor the changelog and in-progress additions, seethe project's master changelogfor more details on that.LicenseThe license for this project is the GNU General Public License v3. The full text can be found atLICENSE.md
Package: eaaccess-crypto
EAAccess-Crypto BetaThis is a platform package for cryptocurrency trading.EAAccess-crypto provide a programming platform to do the Live trading, Paper trading and Backtesting
based on CCXT libraries. CCXT is A JavaScript / Python / PHP cryptocurrency trading API with support
for more than 120 bitcoin/altcoin exchanges (https://github.com/ccxt/ccxt), CCXT is a perferct unified
API for hundred of exchanges, but not support WebSockect yet until 2019/12/31. EAAccess-crypto use
binance's raw websocket API to support Ticker and Candlesticks real-time data refresh. So, EAAccess-cyrpto
version 0.5.x beta only support binance. When CCXT support unified websocket API, EAAccess-crypto
will support the same exchanges with CCXT.
Package: eaasi-uvi-client
eaasi-uvi-clientAboutPython client for getting emulation environment recommendations from
theEaaSIsoftware platform's Universal Virtual Interactor, or
UVI.UsageCommand-line interfaceAfter installing package withpip, useget-eaasi-recommendations:Usage: get-eaasi-recommendations [OPTIONS]

  Get emulation environment suggestions from EaaSI API.

Options:
  --eaasi-url TEXT  EaaSI host URL.  [required]
  --data-url TEXT   Data URL for content to characterize.  [required]
  --data-type TEXT  Data type. Allowed values: "zip", "tar", "bagit+zip",
                    "bagit+tar"  [default: zip]
  --help            Show this message and exit.Python libraryTheeaasi_uvi_clientPython library consists mainly of theEaaSIUVIClientclass, which has the following public methods:EaaSIUVIClient.get_recommendations(): returns dictionary
representation of the JSON returned by EaaSI's EnvironmentProposer
API endpoints; raisesrequests.ConnectionErrororeaasi_uvi_client.ResultNotFoundon error.EaaSIUVIClient.parse_suggested_environments(): returns list of
dictionaries with suggested emulation environments from JSON
returned by EaaSI's EnvironmentProposer API endpoints; raiseseaasi_uvi_client.ResultNotFoundifget_recommendations()has not
yet been called.Seecli/cli.pyfor an implementation example.InstallationInstall eaasi_uvi_client packageeaasi-uvi-clientrequires Python 3.6+.Via PyPIpipinstalleaasi-uvi-clientManuallyDownload this repo:gitclonehttps://github.com/artefactual-labs/eaasi-uvi-client.gitChange into the cloned directory and install:cdeaasi-uvi-client/
pipinstall.DevelopmentInstallationFor development, it may be useful to installeaasi-uvi-clientwithpip install -e ., which will apply changes made to the source code
immediately.Publishing to PyPIThis repository contains aMakefilewith commands to aid in
building packages and publishing to [PyPI][pypi].To check that the package is valid:makepackage-checkTo upload the package to PyPI (this requires PyPI credentials and being
listed as a collaborator on theauditmaticaproject):makepackage-uploadTo clean up package distribution files:makeclean
Package: eabr-functions
EABR FunctionsAutor👤Walter AvelinoStackOverFlow@walteravelinoGithub:@walteravelinoLinkedin:@walteravelinoDEV:@walteravelino📝 LicençaCopyright © 2020Walter Avelino.Os projetos estão sob a licençaMIT.Pacote para validação de documentosInstalação do EABR FunctionsPara instalar o pacote:pipinstalleabr-functions
Package: eachpng
eachpngExecutes command line for each PNG from standard input and forwards their output to stdout.
This can be useful if you are want to generate an animated GIF (e.g. which gifsicle) but
coming from a stream of of PNGs (which cannot be converted via ImageMagick as such).Installing$pipinstall.Running tests$noseteststestsUsageHere’s an example how to convert a stream of PNGs to an animated GIF. This example uses:seqto create a sequence of numbers (stream: many lines with a number each line), usesxargsto call a fictitious program./toolthat produces a PNG for each call (stream: sequence of PNGs)eachpngcalling ImageMagickconvertfor each PNG to convert it to GIF (stream: sequence if GIFs)gifsicleoperating taking the sequence of GIFs to produce an animated GIF$seq03312000|\xargs-L1-ITC./tool-tTC-o-|\eachpngconvert-GIF:-|\gifsicle--multifile--delay3-O3>out.gif
Package: eac-logchecker
EAC LogcheckerThis is a transparent implementation of the Exact Audio Copy log checksum algorithm in Python 3.5+.This is a fork ofhttps://github.com/puddly/eac_logsigner, with modifications to have it
better match the output of the actual EAC Logchecker to be used in downstream applications. All
credit goes to puddly for reverse-engineering the closed source EAC to develop the base.RequirementsPython 3.5+pprp==0.2.6InstallationFrom PyPI:$ pip install eac-logcheckerFrom source:$ git clone https://github.com/OPSnet/eac_logchecker.py
$ cd eac_logchecker.py
$ python setup.py installUsageusage: eac_logchecker.py [-h] [--json] file

Verifies and resigns EAC logs

positional arguments:
file        input log file

optional arguments:
-h, --help  show this help message and exit
--json      Output as JSONExample$ eac_logchecker logs/01.log
Log Integrity Checker   (C) 2010 by Andre Wiethoff

1. Log entry is fine!
$ eac_logchecker logs/01.log
$ eac_logchecker logs/05.log
Log Integrity Checker   (C) 2010 by Andre Wiethoff

1. Log entry is fine!
2. Log entry is fine!
$ eac_logchecker --json logs/05.log
[{"message": "Log entry is fine!", "status": "OK"}, {"message": "Log entry is fine!", "status": "OK"}]AlgorithmStrip the log file of newlines and BOMs.Cut off the existing signature block and (re-)encode the log text back into little-endian UTF-16Encrypt the log file with Rijndael-256:in CBC modewith a 256-bit block size (most AES implementations hard-code a 128-bit block size)all-zeroes IVzero-paddingthe hex key9378716cf13e4265ae55338e940b376184da389e50647726b35f6f341ee3efd9XOR together all of the resulting 256-bit ciphertext blocks. You can do it byte-by-byte, it doesn't matter in the end.Output the little-endian representation of the above number, in uppercase hex.
Package: eac-toolbelt
## Toolbelt### data and database utilities![toolbelt](http://www.gusgusdesigns.co.uk/ekmps/shops/gusgusdesigns/images/pretend-toy-carpenters-tool-belt-from-bigjigs-391-p.jpg)---This repository provides the source code to the `toolbelt` tool, which is a command line clientwritten in Python that is used to administer systems administration tasks through a varietyof utilities that have been combined together into a single tool.*Note: the initial components of this tool previously made up the `replicator`, `geocoder`, `shapeloader` and `load-gnaf` services*### OverviewRun with `toolbelt` after install (it should be in your path)Available commands:* `shapeloader` - load directories of shapefiles into Postgresql with specific support for PSMA distributions (selecting subsets of data, based on bbox or states)* `initdb` - initializes a database from SQL scripts (for use with `db-schema`)* `initsearch` - intializes and builds indexes for Elastic Search based on a defined schema### InstallThis project is distributed on PyPi - the Python package management environment. It can be installed across allplatforms easily and usually with a single command (provided you don't require editing the source code)*Note: this tool will soon be provided as a standalone binary and installer for all platforms using the PyInstaller library*1. Setup on Mac OS XStart with Homebrew:```sh$ brew install python$ easy_install toolbelt```*Note: This will install toolbelt globally, the better option would be to install it into its own environment using `virtualenv`2. Setup with WindowsInstall [python for Windows](http://www.python.org/download/)Open a command prompt and run:```sh> pip install eac-toolbelt```3. Run with DockerRun the `estateagents/sysadmin` Docker image as a container:```sh$ docker run --rm -it estateagents/sysadmin```and then in the shell setup a virtual environment and install `eac-toolbelt`:```sh$ virtualenv .venv$ source .venv/bin/activate$ pip install eac-toolbelt```### RunningSee the respective repositories in `db-schema` and `search-schema` on how to setup and run this tool in those scenarios.### Commands1. shapeloader - Loads Shapefile's into a Postgres or SQL Server database.1. initdb - Initializes a database schema for Postgres or SQL Server from a set of definition files1. initsearch - Initializes a search index on Elastic Search from a set of definition files1. geocode - Geocode addresses using database queries or web service API's and update tables1. replicate - Replicate one database to another (supports Postgres and SQL Server bidirectionally)1. maplayer - Modify layer properties in Mapnik XML files (switch layers off and on, change credentials)### environment filesConfiguration is either loaded from the command line, from the environment or from a '.env' file in the current directory or in a parent directory.Variables all begin with `TOOLBELT_` ex.1. `TOOLBELT_SRC_DSN` - DSN string for the source database1. `TOOLBELT_DEST_DSN` - DSN string for the destination database
Package: eaddaa-game
eaddaa Game is an exciting project with a focus on creating a number guessing game. The primary objective is to provide an engaging and enjoyable user experience through a simple yet entertaining game.Installation
To install eaddaa_game on your local machine, follow these steps:Clone the repository:git clone https://github.com/eaddaa/eaddaa_game.gitNavigate to the project directory:cd eaddaa_gameInstall the required dependencies:pip install -r requirements.txtUsage
Run the game with the following command:python3 main.pycan be found herehttps://pypi.org/project/eaddaa-game/0.1.0/Feel free to explore and enjoy the game!
Package: eadf
MotivationGeometry-based MIMO channel modelling and a high-resolution parameter estimation are applications in which a precise description of the radiation pattern of the antenna arrays is required. In this package we implement an efficient representation of the polarimetric antenna response, which we refer to as the Effective Aperture Distribution Function (EADF). High-resolution parameter estimation are applications in which this reduced description permits us to efficiently interpolate the beam pattern to gather the antenna response for an arbitrary direction in azimuth and elevation. Moreover, the EADF provides a continuous description of the array manifold and its derivatives with respect to azimuth and elevation. The latter is valuable for the performance evaluation of an antenna array as well as for gradient-based parameter estimation techniques.InstructionsInstallationCurrently we simply have a source only distribution setup. To install the latest tagged release just usepip install eadf. Otherwise you can simply runpip install -e . --userin your local git clone to get a development setup running.DocumentationWe also have recent documentation onreadthedocs. Locally you can build it your git clone viapython setup.py build_sphinx -E.ContributingWe are always happy about unhapppy users, who run into problems, report bugs, file pull requests or cheer for our nice package. If you want something merged, please create a pull request againstmasterand we are happy to review them.ReferencesFull 3D Antenna Pattern Interpolation Using Fourier Transform
Based Wavefield Modelling; S. Haefner, R. Mueller, R. S. Thomae;
WSA 2016; 20th International ITG Workshop on Smart Antennas;
Munich, Germany; pp. 1-8Impact of Incomplete and Inaccurate Data Models on High Resolution Parameter
Estimation in Multidimensional Channel Sounding, M. Landmann, M. Käske
and R.S. Thomä; IEEE Trans. on Antennas and Propagation, vol. 60, no 2,
February 2012, pp. 557-573Efficient antenna description for MIMO channel modelling and estimation, M. Landmann, G. Del Galdo; 7th European Conference on Wireless Technology; Amsterdam; 2004;IEEE LinkGeometry-based Channel Modeling for Multi-User MIMO Systems and Applications, G. Del Galdo; Dissertation, Research Reports from the Communications Research Laboratory at TU Ilmenau; Ilmenau; 2007;DownloadLimitations of Experimental Channel Characterisation, M. Landmann; Dissertation; Ilmenau; 2008;Download