Saravanan666/pypi-org huggingface dataset:
Package: kinesis-logger-streamhandler
Kinesis Logger Stream HandlerThis package containsAwsSessionManagement - handles AWS Session with AWS Temp credentials by Assuming a given Role
it renews the temp credentials when neededAWS Kinesis Logger StreamHandler - a logging streamhandler which can send logs to AWS KinesisUsage:def get_kinesis_client(aws_access_key_id, aws_secret_access_key, aws_session_token):
    logger.info("creating/updating kinesis client ...")
    kinesis = boto3.client('kinesis', region_name=get_region(),
                           aws_access_key_id = aws_access_key_id,
                           aws_secret_access_key = aws_secret_access_key,
                           aws_session_token = aws_session_token)
    logger.info("returning new kinesis client")
    return kinesis


logger = logging.getLogger("my-package")
logger.setLevel(logging.INFO)

kinesisAwsSessionManagement = AwsSessionManagement(role_arn='roleArnValue',
                                                   external_id='externalIdValue',
                                                    func=get_kinesis_client,
                                                    role_session_name="KinesisSession")

kinesis_stream_handler = KinesisDataStreamHandler(kinesis_stream_name, 'subsystem_value', 'component_value', 'action_value', 'project_name', 'env', 'version', kinesisAwsSessionManagement)

kinesis_stream_handler.setLevel(logLevel)
logger.addHandler(kinesis_stream_handler)Now, every logging call will send the logs both to console and kinesis data stream with a given 'kinesis_stream_name'
Package: kinesisloghandler
Kinesis Log HandlerPython logging handler for sending logs to AWS KinesisRequirementsPython 3.5+boto3InstallationInstall and update using pippipinstall-UkinesisloghandlerA Simple Exampleimportloggingfromkinesis_log_handler.firehoseimportFirehoseHandlerlogger=logging.getLogger('neil')fh=FirehoseHandler(delivery_stream_name='your_kinesis_stream_name',region_name='ap-northeast-1')logger.addHandler(fh)logger.warning('Warning!')TODOEmit asynchronously
Package: kinesis-producer
Python producer for AWS Kinesis Stream with record aggregation.It uses Boto 3 and is tested on Python 2.7 and 3.4/3.5.PyPI:https://pypi.python.org/pypi/kinesis_producerCode:https://github.com/ludia/kinesis_producerInstallpip install ‘kinesis_producer < 1’Note: Kinesis Producer use semver: you should always freeze on the major
version since it could mean breaking the API.UsageSend records aggregated up to 100KB, 200ms and joined with ‘\n’:fromkinesis_producerimportKinesisProducerconfig=dict(aws_region='us-east-1',buffer_size_limit=100000,buffer_time_limit=0.2,kinesis_concurrency=1,kinesis_max_retries=10,record_delimiter='\n',stream_name='KINESIS_STREAM_NAME',)k=KinesisProducer(config=config)forrecordinrecords:k.send(record)k.close()k.join()Configaws_region:AWS region for Kinesis calls (like us-east-1)buffer_size_limit:Approximative size limit for record aggregation (in bytes)buffer_time_limit:Approximative time limit for record aggregation (in seconds)kinesis_concurrency:Set the concurrency level for Kinesis calls. Set to 1 for no
concurrency. Set to 2 and more to use a thread pool.kinesis_max_retries:Number of Kinesis put_records call attempt before giving up.
This number should be between 4 and 10 if you want to handle
temporary ProvisionedThroughputExceeded errors.record_delimiter:Delimiter for record aggregationstream_name:Name of the Kinesis StreamKinesis retriesKinesis calls are retried for ProvisionedThroughputExceeded error
only. Retry use an exponential backoff logic (0.1s, 0.2s, 0.4s, 0.8s,
1.60s, 3.20s, 6.40s, 12.80s, 25.60s, 51.20s, 102.40s…)Copyright and licenseReleased under the MIT license.
Package: kinesis-stream-consumer
kinesis-stream-consumerKinesis stream consumer channelize through redis along with aws autorefreshable sessionUsageRequirementspython >= 3.0boto3 >= 1.13.5kinesis-python >= 0.2.1redis >= 3.5.0InstallationInstall with:pipinstallkinesis-stream-consumerOr, if you're using a development version cloned from this repository:gitclonehttps://github.com/harshittrivedi78/kinesis-stream-consumer.git
pythonkinesis-stream-consumer/setup.pyinstallThis will install boto3 >= 1.13.5 and kinesis-python >= 0.2.1 and redis >= 3.5.0How to use it?There is two consumer which has to be run parallelly one is kinesis consumer and second is records queue consumer
(redis). I have added a example.py file in this code base which can be used to check and test the code.importthreadingfromkinesis_stream.consumerimportKinesisConsumerfromkinesis_stream.record_queueimportRecordQueueConsumerfromkinesis_stream.redis_wrapperimportget_redis_connredis_conn=get_redis_conn(host="localhost",port=6379,db="0")stream_name="test-kinesis-stream"region="eu-west-1"kinesis_consumer=KinesisConsumer(stream_name,region,redis_conn)record_queue_consumer=RecordQueueConsumer(stream_name,redis_conn)kinesis_consumer_thread=threading.Thread(name='kinesis_consumer',target=kinesis_consumer.start)kinesis_consumer_thread.start()record_queue_consumer_thread=threading.Thread(name='record_queue_consumer',target=record_queue_consumer.start)record_queue_consumer_thread.start()Override handle_message func to do some stuff with the kinesis messages.fromkinesis_stream.record_queueimportRecordQueueConsumerasBaseRecordQueueConsumerclassRecordQueueConsumer(BaseRecordQueueConsumer):defhandle_message(self,message):# your codeprint(message)
Package: kinesisutils
Miscellaneous utilities forAWS
Kinesis.Installationpip install kinesisutilsTo install the development version:pip install git+https://github.com/findhotel/kinesisutilsUsageAt the moment there is only one utility implemented: a Python generator
that reads records from a Kinesis stream. You can use it like this:import json

from kinesisutils.kinesisutils import KinesisGenerator

# Hit Kinesis with at most 10 requests per second, usin json.loads to
# deserialize the Kinesis records (the default). You could deactivate record
# deserialization by setting des=None.
kg = KinesisGenerator("stream_name", rqs=10, des=json.loads)

for rec in kg:
    print(rec)By default the generator will keep pulling records from Kinesis for 60
seconds. You can customize this timeout if you want:from kinesisutils.kinesisutils import KinesisGenerator

kg = KinesisGenerator("stream_name", timeout=30)

for rec in kg:
    print(rec)If you are using the Kinesis generator to read Cloudwatch log events
that are being forwarded to a Kinesis stream using a [logs
subscription][logsubs] you will need to decompress the Cloudwatch
records before deserializing them:import decompress
import json

kg = KinesisGenerator("stream_name", rqs=10, des=json.loads,
                      preprocess=gzip.decompress)

for rec in kg:
    print(rec)ContactIf you have questions, bug reports, suggestions, etc. please create an
issue on theGitHub project
page. PRs are also
welcome.LicenseThis software is licensed under theMIT
license.SeeLicense
file.© 2017 German Gomez-Herrero,Find
Hoteland others.
Package: kines-proto
KinesFriendly Command Line Interface forAmazon Kinesis Data StreamsInstall`pip install kines-protoSetupaws configureCommandsList all Kinesis Streamkines lsThis command lists streams with their open shard count, enhanced consumers count, retention period and encryption type. Internally this command callslist-streamsanddescribe_stream_summarymethods ofBoto3Kinesis client.List Kinesis Stream Shardskines lss <stream-name>This command will show you open as well as closed shards of a Kinesis stream.For detailed output Runkines lss <stream-name> -dFind shard for partition keykines find prod-clickstream -p 123455 -p 8900FromKinesis DocsA partition key is used to group data by shard within a stream. Kinesis Data Streams segregates the data records belonging to a stream into multiple shards. It uses the partition key that is associated with each data record to determine which shard a given data record belongs to. Partition keys are Unicode strings with a maximum length limit of 256 bytes. An MD5 hash function is used to map partition keys to 128-bit integer values and to map associated data records to shards. When an application puts data into a stream, it must specify a partition key.This command comes handy when you want to determine shard for a partition key. This Command can accept multiple partition keys.Walk through kinesis recordskines walk <stream-name> <shard-id> -s <sequence-number> -n <number-of-records-per-call>You can use this command to debug kinesis records. This command internally creates aShard Iterator. If you don't specifysequence-numberthen a ShardIterator is created with typeTRIM_HORIZON, which allows you to fetch from oldest Kinesis records in shard. When you specifysequence-numbera ShardIterator is created withAT_SEQUENCE_NUMBERtype, which fetches data from the specified sequence number.
The Kinesis record's data is decoded usingbase64decoder. You can press ⏎ to fetch more records or typento abort.Walk through kinesis records with protobuf decoderkines walk <stream-name> <shard-id> -s <sequence-number> -n <number-of-records-per-call> -d protobuf --protobuf-decode-msg-type opentelemetry.proto.metrics.v1.ResourceMetrics --protobuf-protodir=/Users/apolyakov/dev/opentelemetry-proto --protobuf-file=opentelemetry/proto/metrics/v1/metrics.protoYou can optionally specify protobuf as a decoder in which case you would need to point it to file and directory containing proto definitions as well as specify concrete message type for decoding. Note - this requiresprotocinstalled.twine upload --skip-existing dist/*Get report for Kinesis StreamThe report command gives you statistics about your Kinesis Stream. Internally, this command callsget_metric_dataof Boto3 Cloudwatch client.Please take a look at legends command for shortforms used in this report.View all short forms and legendskines legendsHow to build in Dev?pip install --editable .How to publish to pypi?python3 setup.py sdist bdist_wheeltwine upload --skip-existing dist/*
Package: kinesyslog
Syslog and GELF relay to AWS Kinesis Firehose. Supports UDP, TCP, and TLS; RFC3164, RFC5424, RFC5425, RFC6587, GELF v1.1.PrerequisitesThis module requires Python 3.5 or better, due to its use of theasyncioframework.This module uses Boto3 to make API calls against the Kinesis Firehose service. You
should have a working AWS API environment (~/.aws/credentials,
environment variables, or EC2 IAM Role) that allows calling Kinesis Firehose’sput-record-batchmethod against the stream specified on the command line.ConsultREADME.md on GitHubfor usage instructions.
Package: kinet2pcb
kinet2pcbConvert KiCad netlist into a PCBNEW.kicad_pcbfile.Free software: MIT licenseDocumentation:https://devbisme.github.io/kinet2pcb.FeaturesConverts a KiCad netlist file into a.kicad_pcbfile that can be edited with PCBNEW.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History1.1.2 (2024-02-26)Added FPID setting to part, otherwise only the fp_name and not the fp_lib appears in the final board.Added iterator to connect all pads of the same number to a given net. This mimics the behavior of the GUI editor.Added Python 3.12 to test environments.1.1.1 (2023-09-10)net.get_pins()is now used when a SKiDL Circuit object is used as the input for generating a PCB.1.1.0 (2022-08-13)Added–librariescommand-line option to specify footprint library directories.1.0.1 (2022-06-30)Fixed incompatibilities with KiCad V6 Python API (pcbnew).1.0.0 (2021-09-16)Decided this tool was mature to the point it could be called 1.0.0.0.1.3 (2021-05-19)The parts in the PCB are now given a non-overlapping arrangement
grouped according to their hierarchical nesting.0.1.2 (2021-05-18)Thekinet2pcb()function will now generate a KiCad PCB file when given
a netlist file name, a PyParsing object, or a SKiDL Circuit object.kinet2pcbcan now be installed in the default Python interpreter on
a system and it will look in/usr/lib/python3/dist-packagesto find
thepcbnewmodule installed by KiCad.  If thepcbnewmodule
is not found there, add the correct location to thePYTHONPATHenvironment variable.0.1.1 (2019-03-09)Now runs under Python 2 & 3.0.1.0 (2019-10-28)First release on PyPI.
Package: kineticlib
KineticLib==========Provides a library with various functions used in computational kinetic theory.Aimed at the multi-temperature (and one-temperature as a special case) and state-to-state approximations.Documentation is available here: http://kineticlib.readthedocs.org/en/latest/For changes see CHANGELOG.rst (https://github.com/Kunstmord/kineticlib/blob/master/CHANGELOG.rst)Roadmap (major additions)=========================`List of planned additions to Kineticlib <https://github.com/Kunstmord/kineticlib/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement>`_Current issues==============`List of Kineticlib issues <https://github.com/Kunstmord/kineticlib/issues?q=is%3Aopen+is%3Aissue+label%3Abug>`_
Package: kinetic-sdk
Kinetic Python SDKKinetic Python SDK is the officialpythonSDK forKineticbased on theKinetic SDK Standard.This SDK allows developers to rapidly integrate Kin and other SPL tokens in their app.UsageIn order to use this SDK, please head over to theKinetic Pyrhon SDKdocumentation.VersionThis SDK is built to work with@kinetic/api@v1.0.0-rc.16. Using it with other versions may lead to issues.ContributingIf you want to contribute to this SDK, please follow the steps below to get it running locally:1. Install the Poetry CLI on your local machine by visiting the link below:Install Poetry2. Install the OpenAPI Generator via NPM (for alternative installs visit:https://openapi-generator.tech)$ npm install @openapitools/openapi-generator-cli -g3. Fetch the Kinetic Python repo$ git clone https://github.com/kin-labs/kinetic-python-sdk4. Change into kinetic-python-sdk working directory$ cd kinetic-python-sdk5. Run the tests$ make test6. Generate OpenAPI Python client$ make generateDirectory labelsgeneratedContains all the generated Python client code based on the openapi spec.helpersContains helper functions that simply calling the createAccount and makeTranfer sdk functionsmodelsHere you can find all reference to classes to-be created and what they override.ContributingTo start contributing, take a look at the standard as this lays down the base for all clients.
This standard is subject to change so always review this before committing any meaningful work.
You can visit the standardhereTroubleshootingIf you have issues withcoincurvedependency in Apple Silicon M1 run this:xcode-select --install
brew install autoconf automake libffi libtool pkg-config python
Package: kineticspy
kineticspySimulation tool for roboticsRobotics is a very vast branch of engineering involoving computer, mechanical and electrical engineering.While there are many libraries available online for robotics. They are not that easy to use for beginners.
To create interest in robotics we need to provide easier visualisation platforms so that the interest can
nurture.The aim of this project is to do exactly that. By using plotly we are providing a 3D toggle to visualize
the trajectory and orientation of the robot.As currently plotly's 3D animation toolbox is still under development we are limited to matplotlib for
animation of the robot.
All the contributions are welcome!!
I have not yet documented anything will do that in about a months time.If any doubts mail me or raise an issue.Currently I am working on animation through trajectories
And the library is not very well oriented there are redundancies which can be removed
Will work on that.Current func:Create Robot objectForward DynamicsTrajectory ploting for continuously varying jointsInverse KinmaticsMinimum Trajectory Potting i.e straight lineVia Points AdditionCurrent Goals:add animationMake the library suitable to be used using DH paramaetersAdd various options for plotting RobotPS: I am new to open source XDNote: Functions using inverse kinematics functions are only available for 3DOF arm.
Package: kineticstoolkit
Kinetics ToolkitAn open-source Python package to facilitate research in biomechanics.Website:https://kineticstoolkit.uqam.caRepository for the Python package:https://github.com/felixchenier/kineticstoolkitRepository for the website:https://github.com/felixchenier/kineticstoolkit_docKinetics Toolkit is an open-source Python package to facilitate research in biomechanics. It provides tools for:TimeSeries analysis, including data, time and event management, time-domain and frequency-domain noise filtering, and cycle management;File management, including reading/writing C3D, CSV and any file supported by Pandas;Rigid body geometry, including manipulation of series of points, vectors, frames and homogeneous transforms, coordinate system changes, and 3D angle extraction;Interactive visualization of 3D markers and rigid bodies;Kinematic operations such as reconstruction of occluded, removed or probed markers;And more using extensions.It is a programming library, and programming can be hard for new users. Therefore, we also provide the free, electronic book Biomechanical Analysis using Python and Kinetics Toolkit, which guides new programmers from the basics to advanced, generic 3D biomechanical analysis. This book covers:The Python programming language, including arithmetics, variables, numbers, strings, functions, conditions, lists, loops and dictionaries;Matplotlib, to generate print-quality graphics and to analyze curves interactively;NumPy basics, including n-dimensional arrays, arithmetics, trigonometry, infinity/nan, statistical functions, comparisons, logical operators, indexing, slicing and filtering arrays.It also covers all the features of Kinetics Toolkit, with reproducible examples based on real, downloadable data.
Package: kinetix
Kinetix - A simple enzyme kinetics simulation frameworkThis is a simple framework for single / multiple reaction enzyme kinetics simulation and plotting.
It allows one to plot reaction kinetics that follows the reversibleMichaelis - Mentenmodel.UsageOne can use the library to produce figures via a command line interface or programmatically (see below for examples)CLISingle reactionAs an example, the reaction kinetics of Glucose Kinase (EC:2.7.1.2is displayed as an example)First, create a definition file in YAML format, that defines the reaction parameters:name:"Glucosekinasesimulation"reactants:#Concentration of the reactants at the beginning of the reaction (mM)glucose:0.2glucose_6_p:0.0enzymes:#Concentration of the enzyme(s) at the begining of the reaction (mM)gluk:0.05reaction:#Kinetic parameters of each of the enzymes for the forward and backward steps of the (reversible) reaction. Note that non-reversible reactions can simple be modeled with high Km for on of the directions.gluk:fwd:"glucose"back:"glucose_6_p"km_fwd:0.24km_back:21kcat_fwd:61kcat_back:15.9Then, run the simulation with a simple command line and a few arguments:python ./code/runner.py examples/glucose_kinase.yaml --plot_out gluc.png --csv_out gluc.csvA figure showing the progression of the reaction as a function of time is generated:A csv file containing the data used to generate the figure can also optionally be generated and saved (using the--csv_outflag)A pathwayKinetix can also simulate a pathway composed of several enzymes. This example shows a pathway composed of 3 different enzymes used in the production ofallulose(D-psicose) a C3 epimer of fructose:Fructose kinase(for the production of fructose-6-phosphate)D-psicose-3-epimerase(converting fructose-6-phosphate to allulose-6-phosphate)Alkaline phosphatase(converting allulose-6-phosphate to allulose)The flow is similar to the one-enzyme case. First, define a yaml file with all the parameters:---name:"Allulosesynthesisfromfructose"reactants:fructose:1.8fructose_6_p:0.0allulose:0.0allulose_6_p:0.0enzymes:fruk:0.05alsE:0.05phosphatase:0.05reaction:fruk:fwd:"fructose_6_p"back:"fructose"km_fwd:0.24km_back:21kcat_fwd:61kcat_back:15.9alsE:fwd:"allulose_6_p"back:"fructose_6_p"km_fwd:1.6km_back:1.6kcat_fwd:46kcat_back:46phosphatase:fwd:"allulose"back:"allulose_6_p"km_fwd:1km_back:100kcat_fwd:100kcat_back:1Then, invoke the application just as before:./code/runner.py examples/allulose.yaml --plot_out examples/figures/alu.svg --csv_out examples/csvs/alu.csvTo produce the reaction figure, which displays the concentration of each of the reactants as a function of time:Programmatic AccessKinetix also makes it really easy to simulate and plot a reaction more flexibly via a simple API.
Example:https://github.com/LiorZ/Kinetix/blob/4d1107d3e85c45d8d3f222428936ef82c658f223/examples/programmatic.py#L8-L44
Package: kingalban-tap-userflow
tap-userflowtap-userflowis a Singer tap for UserFlow.Built with theMeltano Tap SDKfor Singer Taps.InstallationInstall from PyPi:pipinstallkingalban-tap-userflowInstall from GitHub:pipxinstallgit+https://github.com/kingalban/tap-userflow.git@mainConfigurationAccepted Config OptionsA full list of supported settings and capabilities for this
tap is available by running:tap-userflow--aboutExample Config File{"auth_token":"<userflow-api-key>"}Configure using environment variablesThis Singer tap will automatically import any environment variables within the working directory's.envif the--config=ENVis provided, such that config values will be considered if a matching
environment variable is set either in the terminal context or in the.envfile.Source Authentication and AuthorizationUserflow uses Bearer authentication. Follow their documentationhereto generate API keys.UsageYou can easily runtap-userflowby itself or in a pipeline usingMeltano.Executing the Tap Directlytap-userflow--version
tap-userflow--help
tap-userflow--configCONFIG--discover>./catalog.jsonDeveloper ResourcesFollow these instructions to contribute to this project.Initialize your Development Environmentpipxinstallpoetry
poetryinstallCreate and Run TestsCreate tests within thetestssubfolder and
then run:TAP_USERFLOW_AUTH_TOKEN='<your-token-here>'poetryrunpytestYou can also test thetap-userflowCLI interface directly usingpoetry run:poetryruntap-userflow--helpTesting withMeltanoNote:This tap will work in any Singer environment and does not require Meltano.
Examples here are for convenience and to streamline end-to-end orchestration scenarios.Next, install Meltano (if you haven't already) and any needed plugins:# Install meltanopipxinstallmeltano# Initialize meltano within this directorycdtap-userflow
meltanoinstallNow you can test and orchestrate using Meltano:# Test invocation:meltanoinvoketap-userflow--version# OR run a test `elt` pipeline:meltanoelttap-userflowtarget-jsonlSDK Dev GuideSee thedev guidefor more instructions on how to use the SDK to
develop your own taps and targets.
Package: kingbird
KingbirdCentralized service for multi-region OpenStack deployments.Kingbird is an centralized OpenStack service that provides resource operation
and management across multiple OpenStack instances in a multi-region OpenStack
deployments. This service is part of the OPNFV Multisite project that intends
to address the use cases related to distributed cloud environments.Kingbird provides features like centralized quota management, centralized view
for distributed virtual resources, global view for tenant level IP/MAC address
space management, synchronisation of ssh keys, images, flavors, security
groups, etc. across regions.Useful LinksFree software: Apache licensePyPi- package installationLaunchpad project- release managementBlueprints- feature specificationsBugs- issue trackingSourceHow to Contribute