Saravanan666/pypi-org huggingface dataset:
Package: tcpkissserver
TCP KISS ServerTCPKISSserver for connecting software applications toReticulumusing its built-in TCP client interface (with kiss framing enabled).Reticulum ConfigurationReticulum will need to be configured appropriately to interact with the TCP KISS server. Using the default server IP address and port number would look like this:[[TCP KISS Interface]]
    type = TCPClientInterface
    interface_enabled = True
    kiss_framing = True
    target_host = 127.0.0.1
    target_port = 8001See theTCP Client Interface section in the Reticulum manualfor more information.Note that the server IP address and port number are configurable:server = tcpkissserver.Server(bind_ip='192.168.0.5', bind_port=8005, tx_callback=my_function)Be sure to configure Reticulum to match.Exampleimport fskmodem
import tcpkissserver

modem = fskmodem.Modem()
server = tcpkissserver.Server(tx_callback=modem.send)
modem.set_rx_callback(server.receive)Data received by the modem will be passed to the server which will then pass the data to Reticulum.
Data sent by Reticulum will be received by the server which will then pass the data to the modem for transmitting.
Package: tc-player
A robot that does the boring bits of playing Time Clickers for you using
Selenium and the WebGL version of the game, recommended for people who
have already time warped a bunch of times.What it doesn’t doManipulate the game internally at allSpend Time Cubes or Weapon Cubes for youWhat it doesClick in the centre of the screen a hundred timesClick the upgrade buttons for each of your team members in sequenceClick ‘Activate All’Click Dimension ShiftClick CooldownRepeatHow to use itRequirementsA Time Gamers account with a Time Clickers save synced to itPython 3 & pipchromedriver (probably in your system’s package manager)Installationpip installtc-playerUsageRunTC_USERNAME=[yourtime gamers username]TC_PASSWORD=[yourtime gamers password] tc.Use theleaderboardsor your profile page to check your progress.The game uploads a cloud save every minute or so, so you can interrupt
with^cwhenever you like.But I want to see what’s going on as it happens!AddTC_VISIBLE=1to the environment.Wait.After a minute or so, the settings page will appear for a moment to
disable screen shake and post effects, and then the automation will
begin.Leave it running until you want to time warp or spend Weapon Cubes,
at which point you should interrupt the process in your terminal and
do so in another instance of the game.Once it’s up and running, it’ll just keep going. Be careful when mousing
over the window, since the mouse will be clicking constantly while
you’re there.
Package: tcpnonblock
TCP Non-BlockA Simple Implementation of Non-Blocking TCP Socket Server.Key FeaturesSimple to UseThreading Built InExpandable  - Does'nt use a thread per connectionStress Tested - Can handle 100+ connections  (tested on aOVH VPS SSD 1)InstallationYou can install via python'spipmodule:Install with Offical Python Package Index:python3-mpipinstalltcpnonblockor with this Git Respiratorypython3-mpipinstallgit+https://github.com/SamHDev/tcpnonblock.gitNote for Noobies: Ifpython3work then usepythonUsageYou can import the libary with the following statement:importtcpnonblockServer ExampleHere is a quick Example of a TCPSocket Server. This is anEcho Serverthat replies the message from a client.server=tcpnonblock.TCPSocketServer()# Create a Server Object# Create a Client Instance for the Server@server.client_instanceclassClientInstance(tcpnonblock.TCPSocketServerInstance):# On Client Connectdefconnect(self):print("Client Connected")# On Client Disconnectdefdisconnect(self):print("Client Disconnected")# On Client Messagedefmessage(self,msg):print("Client Message: ",msg)self.send("You Said: ",msg)# Echo the Message (Send)# On Server Start Event@server.on_startdefstart(host,port):print("Server Start")# On Server Stop Event@server.on_stopdefstop():print("Server Stop")# Start the Serverserver.listen("0.0.0.0",8080)# Host,Portserver.start()Client ExampleHere is a quick Example of a TCPSocket Client to go with our Echo Server. This is anEcho Clientthat interacts with our Example.client=remote.TCPSocketClient()# Create a Client Object# On Client Connected to Server@client.on_opendefon_open():print("Connected to Server")client.send("Hello World!")# On Client Disconnected from Server@client.on_closedefon_close():print("Disconnected to Server")# On Server Message Received@client.on_messagedefon_message(msg):print("Reply: ",msg)#`Msg` is a `string`client.connect("localhost",8080)ThreadingWhat about that threading I mentioned earlier, well its this simple.
Just declare thethreadingargument in the creation of the object.
It works for bothTCPSocketServerandTCPSocketClientserver=tcpnonblock.TCPSocketServer(threaded=True)client=rtcpnonblock.TCPSocketClient(threaded=True)The Thread will be created and started on.start()License and AttributesCreated by Sam Huddart under aliasSamHDevfor theBlume Open Source Project.SamHDev/tcpnonblockis licensed under the GNU General Public License v3.0 and is Open-Source as seen inLICENSE. Commercial use, Modification and Distribution are permmited. Although credit is not necessary, it is much obliged. If you do wish to credit the author, please link therespiratoryand the author atgithuborwebsite. Thank you for using our work.
Package: tcposcrouter
OSC routing over TCPAn OpenSoundControl message router over TCP written in Python designed with SuperCollider in mind.Connect multiple SuperCollider instances over the internet and exchange messages between them.While tcposcrouter was developed with SuperCollider in mind, it is possible to use it with any other software that supports OSC over TCP.OSC specificationtcposcrouter supports both spec-1.0 and spec-1.1 in regards to framing the messages for sending over TCP stream.Seehttps://forum.renoise.com/t/osc-via-tcp-has-no-framing/42459for an technical explanation.SuperCollider implements OSC spec-1.0 while PureData implements spec-1.1 (with mrpeach external).
See the examples folder for examples in both SuperCollider and PureData.tcposcrouter will open two ports by default, one for each spec version, but the internal routing/user/group state is shared between them.InstallingYou will need Python >= 3.7 together with python-osc python library.Easiest way to install is to get it from PyPI:$ pip install tcposcrouterRunning$  tcposcrouter -h
usage: tcposcrouter [-h] [--osc-port OSC_PORT] [--osc11-port OSC11_PORT] [--disable-osc10] [--disable-osc11] [--log-dir LOG_DIR]

Run the tcposcrouter server.

optional arguments:
  -h, --help            show this help message and exit
  --osc-port OSC_PORT   OSC port to listen
  --osc11-port OSC11_PORT
                        OSC port to listen using SLIP encoding
  --disable-osc10       Disables data length prefix (OSC spec-1.0)
  --disable-osc11       Disables SLIP encoding (OSC spec-1.1)
  --log-dir LOG_DIR     Path where to save logsBy default it listens for OSC spec-1.0 on the 55555TCPand spec-1.1 on 55556 port.ClientFor a client example please check the SuperCollider class at:https://github.com/aiberlin/HyperDisCo/blob/master/Classes/OSCRouterClient.scA client should send an OSC message to the server following the format:/oscrouter/register,ssssi,userName,userPassword,groupName,groupPasswordThessssiis the OSC format to tell that the arguments are 4 strings and 1 integer.On a successful authentication the server will reply with the following message:/oscrouter/register/userNameTheuserNameis created with the givenuserPasswordinside the givengroupName.For both theuserNameandgroupNameif one already exists the server will try to authenticate with the correspondent password, or fail if the password doesn't match.Once the user is authenticated in a group (the/oscrouter/registermessage is sent back), you can start sending messages to the server. Any messages sent to the server from that point will be forwarded to all the users in the same group.It is also possible to send private messages by sending a message like:/oscrouter/private,ss,userName,addressFollowed by as many arguments as you want. So/oscrouter/private,ssifs,userName,address,10,123.30,hellois a valid private message.Your client will receive private messages in the/oscrouter/privateaddress as well. For every user leaving or joining the group the client also receives the current list of users as/oscrouter/userlist.
Package: tcp-reader
TCP Stream ReaderDescriptionReads raw ethernet data, splits them by TCP stream and use a TCPReader per stream.ExampleExample usage of TCPManager with win_pcap:fromtcp_readerimportTCPManagerfromwinpcapyimportWinPcapUtilsdefprint_callback(host,port,data):print('Received data from',host,'on Port',port+':',str(data))tcp_manager=TCPManager(callback=print_callback,host=['93.184.216.34/32'],client=['192.168.0.0/16'])WinPcapUtils.capture_on('*Ethernet*',tcp_manager.receive_raw_win_pcap)
Package: tcprint
=======tcprint=======This package provides the various tcprint_XXX routines whichcan be used to print the text using color formatting.Internally, ANSI color codes are used to format the text.Typical usage often looks like this::#!/usr/bin/env pythonfrom tcprint import *tcprint_red('Text in red')tcprint_B_red('Text in bold red')tcprint_red_on_green('Red text against a green background')tcprint_B_red_on_green('Bold Red text against a green background')tcprint_red_on_B_yellow('Red text against a bold yellow background')tcprint_B_red_on_B_magenta('Bold red text against a bold magenta background')Available Colors================* black* red* green* yellow* blue* magenta* cyan* whiteFor Bold colors use B_ prefix as shown in the exampleThanks also to==============This package was inspired by termcolor package by Konstantin Lepahttp://pypi.python.org/pypi/termcolor/1.1.0It's really a very useful package. I personally didn't want to specify thecolors towards the end of the line via arguments. Having just the text withinthe double quotes [tcprint_red("text to be printed")] seems more readable for me.Upcoming========Will add the other text attributes, like underline/blink, in the next release
Package: tcp-sdk
tcp-sdk is a Python module that provides a convenient object-oriented interface to TCP API. It acts as a wrapper aroundslumber.QuickStartInstall tcp-sdk$virtualenvmy_virtualenv$sourcemy_virtualenv/bin/activate$pipinstalltcp-sdkConnect to your TCP accountimporttcpclient=tcp.client(usermail="user@domain.org",passwd="passwd")print(client.token)Save this token to the environment variable $TCP_API_TOKEN.
Latter calls totcp.client()will automatically connect to TCP API using this environment variable.Start using tcp-sdkimporttcpclient=tcp.client()print(client.query().auth.get())Requirementstcp-sdk requires the following modules.requestsslumberrequests-oauthlib
Package: tcpstat
# TcpstatA TCP port traffic monitor written in Python.
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/caizixian/tcpstat/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/caizixian/tcpstat/?branch=master)
[![Build Status](https://scrutinizer-ci.com/g/caizixian/tcpstat/badges/build.png?b=master)](https://scrutinizer-ci.com/g/caizixian/tcpstat/build-status/master)## Dependencies:MongoDB: an open-source document database.PyMongo: a native Python driver for MongoDB.python-iptables: Python bindings for iptables.## Install dependencies:` sudoapt-getupdate sudoapt-getinstall-ymongodbpython-pippython-devbuild-essentialsudo pip install-r/vagrant/requirements.txt `[How to secure my MongoDB?][3]## Developing:Download Vagrant box athttps://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-i386-vagrant-disk1.boxvagrant box add ubuntu/trusty32 trusty-server-cloudimg-i386-vagrant-disk1.boxvagrant upvagrant provision## InstallThis project is under heavy development. It is subject to major, breaking changes.Don’t use it on production server or even testing server.## Wiki[GitHub wiki page][1]## LicenseMIT## Bugs and IssuesFeel free to create issue at [issue tracker][2]And please feel free to make pull requests.[1]:https://github.com/caizixian/tcpstat/wiki[2]:https://github.com/caizixian/tcpstat/issues[3]:https://docs.mongodb.org/manual/administration/security/
Package: tcptest
tcptest is following Perl’s “Test::TCP”.It has the methods like original one, but also has another TestServer implementation.This package also includes memcached and redis test server support.SYNOPSISimporttcptest.memcachedimporttcptest.redisimporttcptest.fluentd# with contextwithtcptest.memcached.Server()asserver:memd=memcache.Client(['127.0.0.1:%d'%server.port])...withtcptest.redis.Server()asserver:db=redis.Redis(host='127.0.0.1',port=server.port,db=0)...withtcptest.fluentd.Server()asserver:importfluentd.senderimportfluentd.eventfluent.sender.setup('app',port=server.port)fluent.event.Event('follow',{'foo':'bar'})fluent.event.Event('label',{'hoge':'fuga'})printserver.logs# [('app.follow:', {u'foo': u'bar'}), ('app.label:', {u'hoge': u'fuga'})]# manually handlingserver=tcptest.memcached.Server()server.start()...server.stop()TIPScustom serverimporttcptestclassYourTestServer(tcptest.TestServer):defbuild_command(self):return('your server command','arg1','arg2',...)withYourTestServer()asserver:# your server works on server.port...capture server outputsimporttcptest.redisres={}withtcptest.redis.Server(res=res)asserver:...stdout=res['stdout']stderr=res['stderr']redis optionsimporttcptest.rediswithtcptest.redis.Server(settings=dict(databases=4))asserver:...redis replicationimporttcptest.redismaster=tcptest.redis.Server()master.start()slave_settings={'slaveof':'localhost%d'%master.port}slave=tcptest.redis.Server(settings=slave_settings)slave.start()SEE ALSOhttp://search.cpan.org/~tokuhirom/Test-TCP/http://search.cpan.org/~dmaki/Test-Memcached/CHANGES0.6.0 - 2015/10/29Support Python3 (thanks ikegami-yukino)Improve redis-server port reserve, to support redis cluster0.5.0 - 2015/06/12Improve error handling (thanks okamuuu)0.4.0 - 2014/04/05Support fluentd test server0.3.0 - 2014/01/28Update tcptest.redispass command args instead of conf file (require redis-server 2.6 or later)cannot overwrite the server port0.2.4 - 2013/07/16Fix pip installationAdd MANIFEST.in0.2.1-3 - 2013/05/27Maintain setup.py and docs0.2.0 - 2013/05/21Support Redis test server0.1.0 - 2013/05/21First releaseTravis
Package: tcpwatch
TCPWatch is a utility written in Python that lets you monitor forwarded TCP
connections or HTTP proxy connections. It displays the sessions in a window
with a history of past connections. It is useful for developing and debugging
protocol implementations and web services.Version 1.3 is compatible with Tkinter installations that use threads. See the
change log for a list of other changes.TCPWatch is licensed under ZPL 2.0 and requires Python 2.1 or later.Version 1.3.1Convert to use setuptools and console scripts for installationRelease to PyPI.Version 1.3Made compatible with versions of tcl that have threads enabled.Log file numbers are now sequential.“user@host” is now accepted as a destination hostname (the user
name is ignored).Version 1.2.1A typo made it impossible to use two of the command line options.
Fixed.Version 1.2Added the ability to record TCP sessions to a directory.
Use -r <path>.  Implemented by Tres Seaver.Replaced the launch script with a distutils setup.py, thanks again
to Tres Seaver.Version 1.1Almost completely rewritten.  The code is now more reusable and
reliable, but the user interface has not changed much.8-bit clean.  (You can now use TCPWatch to verify that SSH really
does encrypt data. ;-) )It can now run as a simple HTTP proxy server using the “-p”
option.  There are a lot of interesting ways to use this.It’s now easier to watch persistent HTTP connections.  The “-h”
option shows each transaction in a separate entry.You can turn off the Tkinter GUI using the -s option, which
outputs to stdout.Colorized Tkinter output.Version 1.0Never released to the public.
Package: tc-pypeflow
PypeFlowPython package for designing and analyzing piping networks.Designing a piping network involves finding a solution for two kinds of problems:The design flow rates in the pipe sections composing the network are known. Also known are the available
friction losses due to fluid flow in the pipe sections. The problem remains to find appropriate diameters
for the pipe sections, so that the known flow rates do not generate friction losses that exceed the
available values.The design flow rates in the pipe sections composing the network are known. Also known are the diameters
of the pipe sections and the fittings/valves present in each pipe section of the network.
The problem consists of finding the pressure drops across the pipe sections when design flow rates are flowing.Once a piping network is designed, PypeFlow can search for all possible flow paths between the start
and the end node of the network. This allows for flow balancing the different branches in the network. One
can add balancing valves in certain pipe sections to accomplish this. PypeFlow will then calculate the Kvr setting
of each balancing valve in the network, so that all flow paths retrieve the same pressure drop when the
design flow rates are flowing in the pipe sections. Without flow balancing it is uncertain whether the desired flow rate
will flow in each of the pipe sections.Analyzing a piping network involves finding the steady flow rate and pressure distribution in a known piping network.
For this, PypeFlow uses the Hardy Cross method. One can also add pumps to the network and make use of so called pseudo
sections for networks that are open (eg. drinking water installations).Input data for letting PypeFlow design or analyze a piping network comes from a network configuration file.
This is just a csv-file that can be made with any spreadsheet program. The network configuration is entered by the user
in a table in which each row represents a pipe section of the network.PypeFlow is (at this moment) only an API, which means that one should interact with PypeFlow through Python scripts.
Jupyter Notebook is also an excellent tool for doing the design and analysis of a piping network using PypeFlow.
Examples can be found in the accompanyingGithub repository.
Package: tc-pysh
PyshAboutPysh aims at providing the tools required to write in Python the script I would have written in bash before.Python provide a more robust, and more powerful environment for scripting and makes the script easier to maintain and extend.
Pysh makes it possible to write file manipulation script just as quickly as in bash.It should be good both for quick one-of scripts, as well as more complex reusable small programs.InstallationBe careful: thepyshname was already taken on PyPI, it is a different package, that I have nothing to do with.
My package is namedtc-pyshpipinstalltc-pyshUsageAt the center of pysh is the path facilities:pysh.AbsolutePathandpysh.RelativePathare objects representing locations in the file system taht are easy to manipulate and use with pysh utils, as well as with most of python standard library thanks toos.PathLike.pysh.utilsprovides equivalents of the commonly used commands in bash scripts such asmv,cp,rm,cat, etc.pysh.lsandpysh.findprovides familiar interface to thepysh.queryfacilities, making it easy to browse a directory or arborescence, with tools likes sorting and filtering in the form of iterators, building on top of the standard library and therestandard module.pysh.fileprovides a set of functions that are related to filecontent, likegrep,headandtail.Here is an example of usinglsto print the sizes of all text files of a directory.frompyshimportlsfrompysh.fileimportsize,humanforfinls().name(r".*\.txt").sort():s=size(f)s,u=human(s)print(str(f),s,u)
Package: tc-python-lib-template
# python-library[![Maintainability](https://api.codeclimate.com/v1/badges/e1239b895f0ee2569b61/maintainability)](https://codeclimate.com/github/TogetherCrew/python-library/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/e1239b895f0ee2569b61/test_coverage)](https://codeclimate.com/github/TogetherCrew/python-library/test_coverage)This repository acts as a template for python libraries that could be implemented.
Package: tcranno
TCRannoQualitative and Quantitative Annotations of T-Cell Receptor (TCR) Repertoire SpecificityRequirementsPython>=3.7.6tensorflow>=2.4.1, levenshtein, pandas, matplotlib, comut, palettableInstallationpip3 install tensorflow levenshtein pandas comut palettable
pip3 install tcrannoUsagePlease refer to the github page:https://github.com/deepomicslab/TCRanno
Package: tcrdist3
tcrdist3Flexible distance measures for comparing T cell receptorstcrdist3 is a python API-enabled toolkit for analyzing T-cell receptor repertoires. Some of the functionality and code is adapted from the original tcr-dist package which was released with the publication of Dash et al. Nature (2017) doi:10.1038/nature22383. This package contains a new API for computing tcrdistance measures as well as new features for biomarker development (bioRxiv (2020)). The package has been expanded to include gamma-delta TCRs; it has also been recoded to increase CPU efficiency using numba, a high-performance just-in-time compiler.Installationpip install tcrdist3orpip install git+https://github.com/kmayerb/tcrdist3.git@0.2.2Dockerdocker pull quay.io/kmayerb/tcrdist3:0.2.2DocumentationMore documentation can be found attcrdist3.readthedocs.Basic Usageimportpandasaspdfromtcrdist.repertoireimportTCRrepdf=pd.read_csv("dash.csv")tr=TCRrep(cell_df=df,organism='mouse',chains=['alpha','beta'],db_file='alphabeta_gammadelta_db.tsv')tr.pw_alphatr.pw_betatr.pw_cdr3_a_aatr.pw_cdr3_b_aafromtcrdist.publicimport_neighbors_fixed_radius_neighbors_fixed_radius(tr.pw_beta,50)Sparse Matrix Representationimportpandasaspdfromtcrdist.repertoireimportTCRrepfromtcrdist.breadthimportget_safe_chunkdf=pd.read_csv("dash.csv")tr=TCRrep(cell_df=df[['subject','epitope','count','v_b_gene','j_b_gene','cdr3_b_aa','cdr3_b_nucseq']],organism='mouse',chains=['beta'],compute_distances=False)# Set to desired number of CPUstr.cpus=2# Identify a safe chunk size based on input data shape and target number of# pairwise distance to be temporarily held in memory per node.safe_chunk_size=get_safe_chunk(tr.clone_df.shape[0],tr.clone_df.shape[0],target=10**7)tr.compute_sparse_rect_distances(df=tr.clone_df,radius=50,chunk_size=safe_chunk_size)print(tr.rw_beta)CitingTCR meta-clonotypes for biomarker discovery with tcrdist3: quantification of public, HLA-restricted TCR biomarkers of SARS-CoV-2 infectionMayer-Blackwell K, Schattgen S, Cohen-Lavi L, Crawford JC, Souquette A, Gaevert JA, Hertz T, Thomas PG, Bradley PH, Fiore-Gartland A.bioRxiv (2020).Quantifiable predictive features define epitope-specific T cell receptor repertoiresPradyot Dash, Andrew J. Fiore-Gartland, Tomer Hertz, George C. Wang, Shalini Sharma, Aisha Souquette, Jeremy Chase Crawford, E. Bridie Clemens, Thi H. O. Nguyen, Katherine Kedzierska, Nicole L. La Gruta, Philip Bradley & Paul G. ThomasNature (2017).
Package: tc-release
Introhttps://confluence.slac.stanford.edu/display/PCDS/Releasing+Pytmc+TwinCAT+Project+IOCsand more specifically:https://confluence.slac.stanford.edu/display/PCDS/Automated+Tagging+for+TwinCAT+ProjectsInstalling$gitclonehttps://github.com/pcdshub/tc_release
$cdtc_release
$pipinstall.Running$tc-release
usage:tc-release[-h][--plcprojPLCPROJ][--dry-run]VERSIONNUMBERrepo_urlBuilding the exeInstall pyinstaller and pywin32conda install -c conda-forge pyinstaller
conda install -c anaconda pywin32Build exepyinstaller tc_release