Saravanan666/pypi-org huggingface dataset:
Package: iron-cardio
# Created 2023-09-30 Sat 12:24#+options: toc:t#+title: iron-cardio#+author: Russell Helmstedter#+description: README file for iron-cardio cli tool#+keywords: kettlebells, iron cardio, cli#+language: en#+export_file_name: ../README.orgiron-cardio is a CLI designed to create and save iron cardio sessions.* InstallationUse [[https://github.com/pypa/pipx][pipx]]#+begin_src bashpipx install iron-cardio#+end_src* Usage** InitializeRun the ~init~ command. This creates the database.#+begin_src bashiron-cardio init#+end_srcNext, run the ~setloads~ command. This sets the units to either pounds or kilograms, the user's bodyweight, and the loads for the light, medium, and heavy kettlebell. This command can be run as needed when the user is ready to move up in load.#+begin_src bashiron-cardio setloads#+end_src** Commands*** sessionThe ~session~ command generates a random iron cardio session.#+begin_src bashiron-cardio session#+end_srcGenerated sessions are built from the following parameters|--------------------------+----------------------------|| Parameter                | Options                    ||--------------------------+----------------------------|| *Single Bell Variations* | Classic                    ||                          | Classic + Pullup           ||                          | Classic + Snatch           ||                          | Traveling 2s               ||                          | Traveling 2s + Snatch      ||                          | Traveling 2s + Pullup      ||                          | Armor Building Complex 2.0 ||--------------------------+----------------------------|| *Double Bell Variations* | Double Classic             ||                          | Double Traveling 2s        ||                          | Double Classic + Pullup    ||                          | Armor Building Complex     ||--------------------------+----------------------------|| *TIMES*                  | 30 mins                    ||                          | 20 mins                    ||                          | 10 mins                    ||--------------------------+----------------------------|| *LOADS*                  | heavy                      ||                          | medium                     ||                          | light                      ||--------------------------+----------------------------|| *SWINGS*                 | 0 - 100                    |*** doneThe ~done~ command saves the most recently generated session to the database.#+begin_srciron-cardio done#+end_srcTo save a custom session, use the ~--custom~ flag. This allows the user to create a custom session.#+begin_srciron-cardio done -c#+end_src*** lastThe ~last~ command displays the last saved session and calculates the amount of weight moved, the number of reps, and the pace (sec/rep).#+begin_src bashiron-cardio last#+end_src*** statsThe ~stats~ command displays the aggregated weight moved, number of reps, and pace for all sessions in the database.#+begin_src bashiron-cardio stats#+end_src*** bestThe ~best~ command displays the top ten sessions based on the weight moved.#+begin_src bashiron-cardio best#+end_src
Package: ironcore-alloy
ironcore_alloyPython bindings to the IronCore Labs Alloy SDK. Python API documentation is availablehere. General documentation of the various products and broader information about how to use the SDK is availablehere.InstallationLicenseInstallationpip install ironcore-alloyLicenseironcore-alloyis licensed under theGNU Affero General Public License. We also offer commercial licenses -emailfor more information or check pricing on ourwebsite.
Package: iron-datastructures
iron_datastructuresThis is a set of (potentially) useful data structures, including:circular queuegraph/binary treelinked liststackAnd, each data structure has some pretty epic methods built in. For example, the graph has both a depth first and a breadth first search built right in! Take a look at it!What's different about this package, eh? Just another bunch of random data structures.…to which I say, not so fast! This package is designed with type safety in mind. It is 100% type hinted, to give you that extra peace of mind when writing great code.Not only this, but there are of course tests built in! Run them easily withpython3 -m doctest iron_datastructures/*.py(add a-vfor extra verbosity!).And there's more! This package has useful examples of what you can do with each data structure. Simply take a look at the source files - for example,circular_queue.py:Initializeaqueueandaddanacceptablenumberofitemstoit:>>>myQueue=CircularQueue[str](6)>>>myQueue.enQueue("Hello")>>>myQueue.enQueue("there,")>>>myQueue.enQueue("I")>>>myQueue.enQueue("am")>>>myQueue.enQueue("an")>>>myQueue.enQueue("octopus.")Checkqueueisfull:>>>myQueue.isFull()TrueTrytoaddtoomanyitems:>>>myQueue.enQueue("overflow!")Traceback(mostrecentcalllast):...Exception:QueueisfullThis cool example, and many more like it, are bundled right up in the very same source files you'll be using in whatever fantabulous, exquisite creation you're working on.Enjoy!
Package: ironegg
patch_for_django_orm# ===========
# Background:

Django's ORM establishes a database connection per thread.
For the threads managed by Django (which are supposed to be used for directly
handing web requests), Django ORM cleans the established connections up under
the hood once the processing on the thread completes (= request_finished signal).

On the other hand, in the case where Django ORM models are used in an unmanaged thread,
Django does not handle the cleanup of the connections bound to the thread although the
Django framework automatically associates a new connection to the thread. 
This half-maintained resource possibly can cause some DB connection related issues.

To learn more details of this Django behavior, checking the following ticket 
is helpful for understanding this:
https://code.djangoproject.com/ticket/9878

# =========
# Solution:

First replace django orm's mysql database engine by SQLAlchemy connection pool,
Then we need to add put-connection-back-into-pool action when user thread is finished.
To implement above two features in django in a beautiful way, I make this patch. 
If any suggestions, please contact xing.yang@intel.com.
Let's make django more beautiful.

# ===============
# What To Patch ?

patch threading.Thread.
  start
  run
patch django.db.backends.mysql.base.
  Database
  DatabaseWrapper.get_new_connection

# =====
# Usage

# add this in django settings.py to start patch
import ironegg
ironegg.patch_all(pool_size=5, debug=True)
  
# ===============
# Tested versions

python = 3.7/2.7
django = 3.2/1.9
sqlalchemy = 1.4
pymysql = 1.0.2 (python3)
MySQL-python = 1.2.5 (python2)
mysql = 5.7
uwsgi = 2.0

# ====
# Todo

Now this patch is only for mysql database in django,
PostgreSQL and other databases will be supported later.
And only patch threading module in python2/3,
If you use old thread/_thread module to create thread, no patch.
Package: ironfence
IronFence Python Library DocumentationIntroductionIronFence is a Python library that provides two types of synchronization primitives: Mutex and RWLock. These objects allow you to protect shared data from concurrent access in an asynchronous environment. By using Mutex and RWLock, you can ensure that your application remains coroutine-safe and avoids race conditions[^1].[^1]: IronFence doesn't protect against inter-process or intra-thread races. Use additional sync mechanisms likemultiprocessing.Lockorthreading.Lockfor added protection.InstallationWhen pip is available, the distribution can be downloaded from PyPI and installed in one step:pipinstallironfenceMutexAMutex(ashort for "mutual exclusion") is a synchronization primitive that allows only one coroutine to access a shared resource at a time. Other coroutines that attempt to acquire the lock will block until the current owner releases it.importasyncioimportironfenceshared_state={}mu=ironfence.Mutex(shared_state)asyncdefmodify_state():print("modifying state..")asyncwithmu.lock()asvalue:awaitasyncio.sleep(1)value["key"]="example"print("State modified!")asyncdefread_state():print("reading state..")asyncwithmu.lock()asvalue:print("State is:",value)# run concurrentlyasyncio.get_event_loop().run_until_complete(asyncio.gather(read_state(),modify_state(),read_state()))In this example, we create a Mutex instance namedmuthat guards a shared dictionary calledshared_state. We define two coroutines,modify_state()andread_state(), that need to accessshared_state. To ensure exclusive access, we use thelock()method of the Mutex object to acquire the lock before modifying or reading the shared data. Thelock()method returns a context manager that automatically releases the lock when exiting the scope.RWLockAnRWLock(short for "reader-writer lock") is a synchronization primitive that allows multiple reader coroutines to access a shared resource simultaneously, while allowing only one writer coroutine to modify the resource at a time. This makes it more efficient than aMutexin situations where there are many reader coroutines and only occasional writes.importasyncioimportironfenceasyncdefread_state(rw_lock):asyncwithrw_lock.read()asvalue:print(value)asyncdefmodify_state(rw_lock):asyncwithrw_lock.write()asvalue:value.append("example")asyncdefmain():shared_state=[]rw_lock=ironfence.RWLock(shared_state)awaitasyncio.gather(read_state(rw_lock),modify_state(rw_lock),read_state(rw_lock))asyncio.get_event_loop().run_until_complete(main())In this example, we create anRWLockinstance namedrw_lockthat guards a shared list calledshared_state. We define two coroutines,read_state()andmodify_state(), that need to accessshared_state. To ensure exclusive access, we use theread()andwrite()methods of theRWLockobject to acquire the appropriate locks. Theread()method acquires a read lock, which allows multiple reader coroutines to enter, while thewrite()method acquires a write lock, which blocks all reader coroutines until the write operation completes.
Package: ironfonts
Iron Fontsmith ReadMeAbout the Package:This package contains modules written by the author to aid him in using FontForge to develop fonts.The modules are generally meant to be accessed thru the Python Shell.Though he is doubtful anyone will notice, the author is open to feedback on the contents of the module.(The license for this package is GNU GPLv3.)About the Author:Name: Isaac Erb, who oft goes by the username 'Ironheart'.Email:isaac.n.erb@gmail.com.
Package: ironhawks-keygen
ironhawks-keygenIronHawks KeyGen v0.2.1Effortlessly generate random passwords of custom lengths.Uses Alphabets(Upper and Lower cases), Digits(0-9) and Special
Characters/Punctuations(!"#$%&'()*+,-./:;<=>?@[]^_`{|}~) of the
'string' standard library and the 'random' standard library for the
random character picking.The available Strategies are:Generate using Alphabets only.Generate using Digits only.Generate using Alphabets and Digits only.Generate using Alphabets and Special Characters only.Generate using Digits and Special Characters only.Generate using Alphabets, Digits and Special Characters.The Constants used are:ALPHABETS - String having all Lower and Upper cases alphabets.DIGITS - String having digits from 0 to 9.SPECIAL_CHARACTERS - String having a selection of punctuation
characters that are present on standard US
keyboard and frequently used in passwords.STRING_POOL - A dictionary having the possible startegies, where the
keys represent the Strategy Number and their values
represent the respective Strategy String used for
password generation.The generate() function has three optional parameters which are,strategy_number - The corresponding number key to the strategy
specified in the STRING_POOL dictionary. Default
value is 6 for its robustness.password_length - The preferred length of the password string to be
generated. Minimum is 8 and Maximum is 128.
Recommended is 12 to 15 characters.strict - Takes boolean(True/False). Enables Strict mode for
Strategies 3 to 6, as Strategies 1 and 2 are always strict. Strict mode
refers to the condition by which the randomness in generation always
happens as preferred. For example, Strategy 3 may produce only digits or
alphabets as it is randomly generated and thus, strict mode ensures
there is atleast one digit or one alphabet in the generated password.The generate() returns the generated password string or None if either
strategy_number or password_length do not fall in the ranges [1,6] and
[8,128] respectively.The get_doc() function returns this whole docstring, if wanted.Check out the included Example file(example.py).Created by Praveen K. Contact:hartbrkrlegacy@gmail.com
Package: ironic
Team and repository tagsOverviewIronic consists of an API and plug-ins for managing and provisioning
physical machines in a security-aware and fault-tolerant manner. It can be
used with nova as a hypervisor driver, or standalone service using bifrost.
By default, it will use PXE and IPMI to interact with bare metal machines.
Ironic also supports vendor-specific plug-ins which may implement additional
functionality.Ironic is distributed under the terms of the Apache License, Version 2.0. The
full terms and conditions of this license are detailed in the LICENSE file.Project resourcesDocumentation:https://docs.openstack.org/ironic/latestSource:https://opendev.org/openstack/ironicBugs:https://bugs.launchpad.net/ironic/+bugsWiki:https://wiki.openstack.org/wiki/IronicAPIs:https://docs.openstack.org/api-ref/baremetal/index.htmlRelease Notes:https://docs.openstack.org/releasenotes/ironic/Design Specifications:https://specs.openstack.org/openstack/ironic-specs/Project status, bugs, and requests for feature enhancements (RFEs) are tracked
in StoryBoard:https://storyboard.openstack.org/#!/project/943For information on how to contribute to ironic, seehttps://docs.openstack.org/ironic/latest/contributor
Package: ironic-inspector
IntroductionThis is an auxiliary service for discovering hardware properties for a
node managed byIronic. Hardware introspection or hardware
properties discovery is a process of getting hardware parameters required for
scheduling from a bare metal node, given its power management credentials
(e.g. IPMI address, user name and password).Free software: Apache licenseSource:https://opendev.org/openstack/ironic-inspector/Bugs:https://storyboard.openstack.org/#!/project/944Downloads:https://tarballs.openstack.org/ironic-inspector/Documentation:https://docs.openstack.org/ironic-inspector/latest/Python client library and CLI tool:python-ironic-inspector-client(documentation).Noteironic-inspectorwas calledironic-discoverdbefore version 2.0.0.Release NotesFor information on any current or prior version, seethe release notes.
Package: ironic-prometheus-exporter
Ironic Prometheus Exporter is a Tool to expose hardware sensor data in thePrometheusformat through an HTTP endpoint.The hardware sensor data come from bare metal machines deployed
usingOpenStack Bare Metal Service (ironic).License: Apache License, Version 2.0Documentation:https://docs.openstack.org/ironic-prometheus-exporter/Source:https://opendev.org/openstack/ironic-prometheus-exporterBugs:https://storyboard.openstack.org/#!/project/openstack/ironic-prometheus-exporterRelease Notes:https://docs.openstack.org/releasenotes/ironic-prometheus-exporter
Package: ironic-python-agent
Team and repository tagsOverviewAn agent for controlling and deploying Ironic controlled baremetal nodes.The ironic-python-agent works with the agent driver in Ironic to provision
the node.  Starting with ironic-python-agent running on a ramdisk on the
unprovisioned node, Ironic makes API calls to ironic-python-agent to provision
the machine.  This allows for greater control and flexibility of the entire
deployment process.The ironic-python-agent may also be used with the original Ironic pxe drivers
as of the Kilo OpenStack release.Building the IPA deployment ramdiskFor more information see theImage Buildersection of the Ironic Python Agent
developer guide.Using IPA with devstackThis is covered in theDeploying Ironic with DevStacksection of the Ironic dev-quickstart guide.Project ResourcesProject bugs are tracked on Launchpad:https://bugs.launchpad.net/ironic-python-agent/+bugsDeveloper documentation can be found here:https://docs.openstack.org/ironic-python-agent/latest/Release notes for the project are available at:https://docs.openstack.org/releasenotes/ironic-python-agent/Source code repository for the project is located at:https://opendev.org/openstack/ironic-python-agent/IRC channel:#openstack-ironic on irc.oftc.netTo contribute, start here:Openstack: How to
contribute.
Package: ironic-python-agent-builder
Tools and scripts to build a deployment, cleaning or inspection ramdisk
based onIronic Python Agent.Free software: Apache licenseDocumentation:https://docs.openstack.org/ironic-python-agent-builderSource:https://opendev.org/openstack/ironic-python-agent-builderBugs:https://storyboard.openstack.org/#!/project/948Release Notes:https://docs.openstack.org/releasenotes/ironic-python-agent-builder/
Package: ironic-staging-drivers
The Ironic Staging Drivers is used to hold out-of-tree Ironic drivers
which doesn’t have means to provide a 3rd Party CI at this point in
time which is required by Ironic.The intention of this project is to provide a common place for useful
drivers resolving the “hundreds of different download sites” problem.What the Ironic Staging Drivers is notThe Ironic Staging Drivers isnota project under Ironic’s
governance, meaning that the Ironic core group isnot responsiblefor the code in this project (even though, some individuals that work in
this project also hold core status in the Ironic project).This project isnota place to dump code and run away hoping that
someone else will take care of it for you. Drivers included
in this project should be maintained and have their bugs fixed
quickly. Therefore, driver owners are going to be asked to “babysit”
their driver.How to contributeWe want to make sure that the Ironic Staging Drivers project is a
welcoming and friendly place to contribute code. Therefore, we want to
avoid bureaucratic processes as much as possible. If you want to propose
a driver to be included in the repository: Just submit the code!How do I submit the code?Before we can accept your patches, you’ll
have toagree to a contributor license agreement.Learn abouthow to use our Gerrit review system.Get the code:git clone https://opendev.org/x/ironic-staging-driversMake your changes and write a nice commit message explaining the
change in details.Submit the code!Useful linksFree software: Apache licenseDocumentation:http://ironic-staging-drivers.readthedocs.io/en/latest/Source:https://opendev.org/x/ironic-staging-driversBugs:https://storyboard.openstack.org/#!/project/950
Package: ironic-tempest-plugin
This repository contains aTempestplugin for OpenStackBare MetalandBare Metal Introspectionprojects.Free software: Apache licenseDocumentation:https://docs.openstack.org/ironic-tempest-pluginSource:https://opendev.org/openstack/ironic-tempest-pluginBugs:https://storyboard.openstack.org/#!/project/951
Package: ironic-ui
Team and repository tagsIronic UIThe Ironic UI is a Horizon plugin that will allow users to view and manage bare
metal nodes, ports and drivers.Free software: Apache licenseDocumentation:https://docs.openstack.org/ironic-ui/latestRelease notes:https://docs.openstack.org/releasenotes/ironic-ui/Source:https://opendev.org/openstack/ironic-uiBugs:https://storyboard.openstack.org/#!/project/952FeaturesView bare metal nodesView node detailsApply maintenance and power on/off actions to the nodes
Package: ironik
WarningTHIS PROJECT HAS BEEN MOVED TOhttps://gitlab-ce.gwdg.de/jdecker/ironikWarningThis tool is still in early development and only the core features are available.FeaturesUtilize OpenStack and Rancher APIs to automatically deploy Kubernetes clusterCustomize the configuration using templatesInstall new Kubernetes versions including deploying the external cloud controller manager for OpenStackInstallationYou can installironikviapipfromPyPI:$pipinstallironikAlternatively,ironikcan also be used as a container to avoid installing it:$dockerrun--rm-ti-v$(pwd):/app/tmpdocker.gitlab-ce.gwdg.de/jdecker/ironik/cli:latestironik--helpThis can be abbreviated using an alias:$aliasdironik='docker run --rm -ti -v $(pwd):/app/tmp docker.gitlab-ce.gwdg.de/jdecker/ironik/cli:latest ironik'$dironik--helpUsagePlease see theUsage Instructionsfor details.Kubernetes can also be deployed manually on OpenStack and Rancher.
See theManual Deployment Instructionsfor a full guide.TODOsUpdate Code documentation to use Google code doc styleImprove print messages during executionImplement a template validatorImplement cluster validationSet up test suiteImplement automatic config fetchingAdd functionality for undoing deployments and other helpful commandsContributingContributions are very welcome. To learn more, see theContributor Guide.Setup Development EnvironmentWe tested the developing environment with Ubuntu 22.04.Fork projectClone forked project on your working machineInstall dependencies (needed to build wheel of netifaces in Step 4.)sudo apt-get install build-essential libssl-dev libffi-dev python3-devInstall python packagespoetry installCreditsThis package was created withcookietempleusingCookiecutterbased onHypermodern_Python_Cookiecutter.
Package: ironleapdjango
Django MiddlewareSend Iron Leap API call data.How to installpipinstallironleapdjangoHow to useIn yoursettings.pyfile in your Django project directory, please addironleap.middleware.ironleap_middlewareto the MIDDLEWARE array. For example:MIDDLEWARE = [
    ...
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'ironleapdjango.middleware.ironleap_middleware'
    ...
]Configuration optionsAPP_KEY(required),string, provided by Iron Leap.IRONLEAP_URL(required),string, target url collecting eventsOptions specific to incoming API callsSKIP(optional)(request, response) => boolean, a function that takes a request and a response, and returns true if you want to skip this particular event.IDENTIFY_COMPANY(optional)(request, response) => string, a function that takes a request and a response, and returns a string that is the company id for this event.GET_METADATA(optional)(request, response) => dictionary, getMetadata is a function that returns an object that allows you
to add custom metadata that will be associated with the event. The metadata must be a dictionary that can be converted to JSON. For example, you may want to save a VM instance_id, a trace_id, or a tenant_id with the request.LOG_BODY(optional)boolean, default True, Set to False to remove the HTTP body before sending. If you want more control over which fields are included or not included look at the individual mask method below.MASK_EVENT_MODEL(optional)(APIEvent) => APIEvent, a function that takes an APIEvent and returns another APIEvent. Use this if you prefer to write your own mask function than use the string based filter options: REQUEST_BODY_MASKS, REQUEST_HEADER_MASKS, RESPONSE_BODY_MASKS, & RESPONSE_HEADER_MASKS.BATCH_SIZE(optional)int, default 25, Batch size with which events get sent to Iron Leap.EVENT_QUEUE_SIZE(optional)int, default 2500, Maximum number of events to hold in queue before sending.BATCH_SEND_INTERVAL(optional)int, default 2, Number of seconds between sends of batch.Exampledefidentify_company(req,res):# Your custom code that returns a company id stringreturn"67890"defshould_skip(req,res):# Your custom code that returns true to skip loggingreturn"health/probe"inreq.pathdefmask_event(eventmodel):# Your custom code to change or remove any sensitive fieldsif'password'ineventmodel.response.body:eventmodel.response.body['password']=Nonereturneventmodeldefget_metadata(req,res):return{'datacenter':'westus','deployment_version':'v1.2.3',}IRONLEAP_MIDDLEWARE={'APP_KEY':'app key','IRONLEAP_URL':'https://analytics.ironleap.io/api/collect''DEBUG':False,'LOG_BODY':True,'IDENTIFY_COMPANY':identify_company,'SKIP':should_skip,'MASK_EVENT_MODEL':mask_event,'GET_METADATA':get_metadata,}