├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── TODO.org
├── composer.json
├── composer.lock
├── examples
    └── doctrine.py
├── phpbridge
    ├── __init__.py
    ├── classes.py
    ├── docblocks.py
    ├── functions.py
    ├── modules.py
    ├── objects.py
    ├── php-server
    │   ├── CommandServer.php
    │   ├── Commands.php
    │   ├── Exceptions
    │   │   ├── AttributeError.php
    │   │   └── ConnectionLostException.php
    │   ├── NonFunctionProxy.php
    │   ├── ObjectStore.php
    │   ├── Representer
    │   │   ├── PythonRepresenter.php
    │   │   ├── Representer.php
    │   │   └── RepresenterInterface.php
    │   └── StdioCommandServer.php
    ├── server.php
    └── utils.py
├── psalm.xml
└── setup.py


/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | *.pyc
3 | /.mypy_cache
4 | /vendor
5 | /.idea
6 | /phpbridge.egg-info
7 | /build
8 | /dist
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright 2018 Jan Verbeek <jan.verbeek@posteo.nl>
 2 | 
 3 | Permission to use, copy, modify, and distribute this software for any
 4 | purpose with or without fee is hereby granted, provided that the above
 5 | copyright notice and this permission notice appear in all copies.
 6 | 
 7 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 8 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 9 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | all: php python
 2 | 
 3 | php: phpcs psalm
 4 | 
 5 | python: flake8 mypy
 6 | 
 7 | phpcs:
 8 | 	vendor/bin/phpcs --standard=PSR2 phpbridge/php-server
 9 | 
10 | psalm:
11 | 	vendor/bin/psalm
12 | 
13 | flake8:
14 | 	python3 -m flake8 phpbridge
15 | 
16 | mypy:
17 | 	python3 -m mypy --strict -m phpbridge
18 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | This is a Python module for running PHP programs. It lets you import PHP functions, classes, objects, constants and variables to work just like regular Python versions.
  2 | 
  3 | # Examples
  4 | 
  5 | You can call functions:
  6 | ```pycon
  7 | >>> from phpbridge import php
  8 | >>> php.array_reverse(['foo', 'bar', 'baz'])
  9 | Array.list(['baz', 'bar', 'foo'])
 10 | >>> php.echo("foo\n")
 11 | foo
 12 | >>> php.getimagesize("http://php.net/images/logos/new-php-logo.png")
 13 | Array([('0', 200), ('1', 106), ('2', 3), ('3', 'width="200" height="106"'), ('bits', 8), ('mime', 'image/png')])
 14 | ```
 15 | 
 16 | You can create and use objects:
 17 | ```pycon
 18 | >>> php.DateTime
 19 | <PHP class 'DateTime'>
 20 | >>> date = php.DateTime()
 21 | >>> print(date)
 22 | <DateTime PHP object (date='2018-05-03 22:59:15.114277', timezone_type=3, timezone='Europe/Berlin')>
 23 | >>> date.getOffset()
 24 | 7200
 25 | >>> php.ArrayAccess
 26 | <PHP interface 'ArrayAccess'>
 27 | >>> issubclass(php.ArrayObject, php.ArrayAccess)
 28 | True
 29 | ```
 30 | 
 31 | You can use keyword arguments, even though PHP doesn't support them:
 32 | ```pycon
 33 | >>> date.setDate(year=1900, day=20, month=10)
 34 | <DateTime PHP object (date='1900-10-20 22:59:15.114277', timezone_type=3, timezone='Europe/Berlin')>
 35 | ```
 36 | 
 37 | You can loop over iterators and traversables:
 38 | ```pycon
 39 | >>> for path, file in php.RecursiveIteratorIterator(php.RecursiveDirectoryIterator('.git/logs')):
 40 | ...     print("{}: {}".format(path, file.getSize()))
 41 | ...
 42 | .git/logs/.: 16
 43 | .git/logs/..: 144
 44 | .git/logs/HEAD: 2461
 45 | [...]
 46 | ```
 47 | 
 48 | You can get help:
 49 | ```pycon
 50 | >>> help(php.echo)
 51 | Help on function echo:
 52 | 
 53 | echo(arg1, *rest)
 54 |     Output one or more strings.
 55 | 
 56 |     @param mixed $arg1
 57 |     @param mixed ...$rest
 58 | 
 59 |     @return void
 60 | ```
 61 | 
 62 | You can import namespaces as modules:
 63 | ```pycon
 64 | >>> from phpbridge.php.blyxxyz.PythonServer import NonFunctionProxy
 65 | >>> help(NonFunctionProxy)
 66 | Help on class blyxxyz\PythonServer\NonFunctionProxy in module phpbridge.php.blyxxyz.PythonServer:
 67 | 
 68 | class blyxxyz\PythonServer\NonFunctionProxy(phpbridge.objects.PHPObject)
 69 |  |  Provide function-like language constructs as static methods.
 70 |  |
 71 |  |  `isset` and `empty` are not provided because it's impossible for a real
 72 |  |  function to check whether its argument is defined.
 73 |  |
 74 |  |  Method resolution order:
 75 |  |      blyxxyz\PythonServer\NonFunctionProxy
 76 |  |      phpbridge.objects.PHPObject
 77 |  |      builtins.object
 78 |  |
 79 |  |  Class methods defined here:
 80 |  |
 81 |  |  array(val) -> dict from phpbridge.objects.PHPClass
 82 |  |      Cast a value to an array.
 83 |  |
 84 |  |      @param mixed $val
 85 |  |
 86 |  |      @return array
 87 | [...]
 88 | ```
 89 | 
 90 | You can index, and get lengths:
 91 | ```pycon
 92 | >>> arr = php.ArrayObject(['foo', 'bar', 'baz'])
 93 | >>> arr[10] = 'foobar'
 94 | >>> len(arr)
 95 | 4
 96 | ```
 97 | 
 98 | You can work with PHP's exceptions:
 99 | ```pycon
100 | >>> try:
101 | ...     php.get_resource_type(3)
102 | ... except php.TypeError as e:
103 | ...     print(e.getMessage())
104 | ...
105 | get_resource_type() expects parameter 1 to be resource, integer given
106 | ```
107 | 
108 | # Features
109 |   * Using PHP functions
110 |     * Keyword arguments are supported and translated based on the signature
111 |     * Docblocks are also converted, so `help` is informative
112 |   * Using PHP classes like Python classes
113 |     * Methods and constants are defined right away based on the PHP class
114 |     * Docblocks are treated like docstrings, so `help` works and is informative
115 |     * The original inheritance structure is copied
116 |     * Default properties become Python properties with documentation
117 |     * Other properties are accessed on the fly as a fallback for attribute access
118 |   * Creating and using objects
119 |   * Importing namespaces as modules
120 |   * Getting and setting constants
121 |   * Getting and setting global variables
122 |   * Translating exceptions so they can be treated as both Python exceptions and PHP objects
123 |   * Tab completion in the interpreter
124 |   * Python-like reprs for PHP objects, with information like var_dump in a more compact form
125 | 
126 | # Caveats
127 |   * On Windows, stdin and stderr are used to communicate, so PHP can't read input and if it writes to stderr the connection is lost
128 |   * You can only pass basic Python objects into PHP
129 |   * Namespaces can shadow names in an unintuitive way
130 |   * Because PHP only has one kind of array, its arrays are translated to a special kind of ordered dictionary
131 | 
132 | # Name conflicts
133 | Some PHP packages use the same name both for a class and a namespace. As an example, take `nikic/PHP-Parser`.
134 | 
135 | `PhpParser\Node` is a class, but `PhpParser\Node\Param` is also a class. This means `phpbridge.php.PhpParser.Node` becomes ambiguous - it could either refer to the `Node` class, or the namespace of the `Param` class.
136 | 
137 | In case of such a conflict, the class is preferred over the namespace. To get `Param`, a `from` import has to be used:
138 | ```pycon
139 | >>> php.require('vendor/autoload.php')
140 | <Composer.Autoload.ClassLoader PHP object (prefixLengthsPsr4=[...: (4)], ...>
141 | >>> import phpbridge.php.PhpParser.Node as Node           # Not the namespace!
142 | >>> Node
143 | <PHP interface 'PhpParser\Node'>
144 | >>> from phpbridge.php.PhpParser.Node import Param        # The class we want
145 | >>> Param
146 | <PHP class 'PhpParser\Node\Param'>
147 | >>> import phpbridge.php.PhpParser.Node.Param as Param    # Doesn't work
148 | Traceback (most recent call last):
149 |   File "<stdin>", line 1, in <module>
150 | AttributeError: type object 'PhpParser\Node' has no attribute 'Param'
151 | ```
152 | 
153 | If there are no conflicts, things work as expected:
154 | ```pycon
155 | >>> from phpbridge.php.blyxxyz.PythonServer import Commands
156 | >>> Commands
157 | <PHP class 'blyxxyz\PythonServer\Commands'>
158 | >>> import phpbridge.php.blyxxyz.PythonServer as PythonServer
159 | >>> PythonServer
160 | <PHP namespace 'blyxxyz\PythonServer'>
161 | >>> PythonServer.Commands
162 | <PHP class 'blyxxyz\PythonServer\Commands'>
163 | ```
164 | 
165 | # Installing
166 | 
167 | ```
168 | pip3 install phpbridge
169 | ```
170 | 
171 | The only dependencies are PHP 7.0+, Python 3.5+, ext-json, ext-reflection and ext-mbstring. Composer can be used to install development tools and set up autoloading, but it's not required.
172 | 


--------------------------------------------------------------------------------
/TODO.org:
--------------------------------------------------------------------------------
 1 | - Convert use of send_command to bridge methods
 2 | - Change phpbridge.classes to use inherited fake traits
 3 | - Add a helpers submodule for things like autoloading and Symfony
 4 |   - If composer dump-autoload -o is used, namespaces could be imported in advance and importing new ones could be disabled after that
 5 |     - This would help with some nasty edge cases in the current system
 6 |   - A clean way to get Symfony services
 7 | - Document more
 8 | - Don't let bridge namespace modules conflict with other modules
 9 | - Publish to PyPi
10 | - Write tests
11 | - Don't use stdin and stderr on Windows, if possible
12 | - Make bridge more symmetric
13 |   - Allow sending Python proxy objects into PHP
14 |   - Allow Python to receive commands from PHP
15 | - Try to make it possible to recover from a missed message
16 | - Try to deal with KeyboardInterrupts simultaneously killing PHP
17 | - Try to auto-generate mypy stubs
18 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "blyxxyz/python-server",
 3 |     "description": "A way to call PHP code from Python",
 4 |     "type": "library",
 5 |     "keywords": ["python"],
 6 |     "homepage": "https://github.com/blyxxyz/Python-PHP-Bridge",
 7 |     "license": "ISC",
 8 |     "require-dev": {
 9 |         "vimeo/psalm": "^1.1",
10 |         "squizlabs/php_codesniffer": "^3.2"
11 |     },
12 |     "authors": [
13 |         {
14 |             "name": "Jan Verbeek",
15 |             "email": "jan.verbeek@posteo.nl"
16 |         }
17 |     ],
18 |     "require": {
19 |         "php": "^7.0",
20 |         "ext-json": "*",
21 |         "ext-Reflection": "*"
22 |     },
23 |     "autoload": {
24 |         "psr-4": {
25 |             "blyxxyz\\PythonServer\\": "phpbridge/php-server"
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
  1 | {
  2 |     "_readme": [
  3 |         "This file locks the dependencies of your project to a known state",
  4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
  5 |         "This file is @generated automatically"
  6 |     ],
  7 |     "content-hash": "7e24cafb0cff3c1d3b45d96a56b57b15",
  8 |     "packages": [],
  9 |     "packages-dev": [
 10 |         {
 11 |             "name": "composer/xdebug-handler",
 12 |             "version": "1.3.1",
 13 |             "source": {
 14 |                 "type": "git",
 15 |                 "url": "https://github.com/composer/xdebug-handler.git",
 16 |                 "reference": "dc523135366eb68f22268d069ea7749486458562"
 17 |             },
 18 |             "dist": {
 19 |                 "type": "zip",
 20 |                 "url": "https://api.github.com/repos/composer/xdebug-handler/zipball/dc523135366eb68f22268d069ea7749486458562",
 21 |                 "reference": "dc523135366eb68f22268d069ea7749486458562",
 22 |                 "shasum": ""
 23 |             },
 24 |             "require": {
 25 |                 "php": "^5.3.2 || ^7.0",
 26 |                 "psr/log": "^1.0"
 27 |             },
 28 |             "require-dev": {
 29 |                 "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.5"
 30 |             },
 31 |             "type": "library",
 32 |             "autoload": {
 33 |                 "psr-4": {
 34 |                     "Composer\\XdebugHandler\\": "src"
 35 |                 }
 36 |             },
 37 |             "notification-url": "https://packagist.org/downloads/",
 38 |             "license": [
 39 |                 "MIT"
 40 |             ],
 41 |             "authors": [
 42 |                 {
 43 |                     "name": "John Stevenson",
 44 |                     "email": "john-stevenson@blueyonder.co.uk"
 45 |                 }
 46 |             ],
 47 |             "description": "Restarts a process without xdebug.",
 48 |             "keywords": [
 49 |                 "Xdebug",
 50 |                 "performance"
 51 |             ],
 52 |             "time": "2018-11-29T10:59:02+00:00"
 53 |         },
 54 |         {
 55 |             "name": "muglug/package-versions-56",
 56 |             "version": "1.2.4",
 57 |             "source": {
 58 |                 "type": "git",
 59 |                 "url": "https://github.com/muglug/PackageVersions.git",
 60 |                 "reference": "a67bed26deaaf9269a348e53063bc8d4dcc60ffd"
 61 |             },
 62 |             "dist": {
 63 |                 "type": "zip",
 64 |                 "url": "https://api.github.com/repos/muglug/PackageVersions/zipball/a67bed26deaaf9269a348e53063bc8d4dcc60ffd",
 65 |                 "reference": "a67bed26deaaf9269a348e53063bc8d4dcc60ffd",
 66 |                 "shasum": ""
 67 |             },
 68 |             "require": {
 69 |                 "composer-plugin-api": "^1.0",
 70 |                 "php": "^5.6 || ^7.0"
 71 |             },
 72 |             "require-dev": {
 73 |                 "composer/composer": "^1.3",
 74 |                 "ext-zip": "*",
 75 |                 "phpunit/phpunit": "^5.7.5"
 76 |             },
 77 |             "type": "composer-plugin",
 78 |             "extra": {
 79 |                 "class": "Muglug\\PackageVersions\\Installer",
 80 |                 "branch-alias": {
 81 |                     "dev-master": "2.0.x-dev"
 82 |                 }
 83 |             },
 84 |             "autoload": {
 85 |                 "psr-4": {
 86 |                     "Muglug\\PackageVersions\\": "src/PackageVersions"
 87 |                 }
 88 |             },
 89 |             "notification-url": "https://packagist.org/downloads/",
 90 |             "license": [
 91 |                 "MIT"
 92 |             ],
 93 |             "authors": [
 94 |                 {
 95 |                     "name": "Marco Pivetta",
 96 |                     "email": "ocramius@gmail.com"
 97 |                 },
 98 |                 {
 99 |                     "name": "Abdul Malik Ikhsan",
100 |                     "email": "samsonasik@gmail.com"
101 |                 },
102 |                 {
103 |                     "name": "Matt Brown",
104 |                     "email": "github@muglug.com"
105 |                 }
106 |             ],
107 |             "description": "A backport of ocramius/package-versions that supports php ^5.6. Composer plugin that provides efficient querying for installed package versions (no runtime IO)",
108 |             "time": "2018-03-26T03:22:13+00:00"
109 |         },
110 |         {
111 |             "name": "nikic/php-parser",
112 |             "version": "v3.1.5",
113 |             "source": {
114 |                 "type": "git",
115 |                 "url": "https://github.com/nikic/PHP-Parser.git",
116 |                 "reference": "bb87e28e7d7b8d9a7fda231d37457c9210faf6ce"
117 |             },
118 |             "dist": {
119 |                 "type": "zip",
120 |                 "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/bb87e28e7d7b8d9a7fda231d37457c9210faf6ce",
121 |                 "reference": "bb87e28e7d7b8d9a7fda231d37457c9210faf6ce",
122 |                 "shasum": ""
123 |             },
124 |             "require": {
125 |                 "ext-tokenizer": "*",
126 |                 "php": ">=5.5"
127 |             },
128 |             "require-dev": {
129 |                 "phpunit/phpunit": "~4.0|~5.0"
130 |             },
131 |             "bin": [
132 |                 "bin/php-parse"
133 |             ],
134 |             "type": "library",
135 |             "extra": {
136 |                 "branch-alias": {
137 |                     "dev-master": "3.0-dev"
138 |                 }
139 |             },
140 |             "autoload": {
141 |                 "psr-4": {
142 |                     "PhpParser\\": "lib/PhpParser"
143 |                 }
144 |             },
145 |             "notification-url": "https://packagist.org/downloads/",
146 |             "license": [
147 |                 "BSD-3-Clause"
148 |             ],
149 |             "authors": [
150 |                 {
151 |                     "name": "Nikita Popov"
152 |                 }
153 |             ],
154 |             "description": "A PHP parser written in PHP",
155 |             "keywords": [
156 |                 "parser",
157 |                 "php"
158 |             ],
159 |             "time": "2018-02-28T20:30:58+00:00"
160 |         },
161 |         {
162 |             "name": "openlss/lib-array2xml",
163 |             "version": "0.5.1",
164 |             "source": {
165 |                 "type": "git",
166 |                 "url": "https://github.com/nullivex/lib-array2xml.git",
167 |                 "reference": "c8b5998a342d7861f2e921403f44e0a2f3ef2be0"
168 |             },
169 |             "dist": {
170 |                 "type": "zip",
171 |                 "url": "https://api.github.com/repos/nullivex/lib-array2xml/zipball/c8b5998a342d7861f2e921403f44e0a2f3ef2be0",
172 |                 "reference": "c8b5998a342d7861f2e921403f44e0a2f3ef2be0",
173 |                 "shasum": ""
174 |             },
175 |             "require": {
176 |                 "php": ">=5.3.2"
177 |             },
178 |             "type": "library",
179 |             "autoload": {
180 |                 "psr-0": {
181 |                     "LSS": ""
182 |                 }
183 |             },
184 |             "notification-url": "https://packagist.org/downloads/",
185 |             "license": [
186 |                 "Apache-2.0"
187 |             ],
188 |             "authors": [
189 |                 {
190 |                     "name": "Bryan Tong",
191 |                     "email": "contact@nullivex.com",
192 |                     "homepage": "http://bryantong.com"
193 |                 },
194 |                 {
195 |                     "name": "Tony Butler",
196 |                     "email": "spudz76@gmail.com",
197 |                     "homepage": "http://openlss.org"
198 |                 }
199 |             ],
200 |             "description": "Array2XML conversion library credit to lalit.org",
201 |             "homepage": "http://openlss.org",
202 |             "keywords": [
203 |                 "array",
204 |                 "array conversion",
205 |                 "xml",
206 |                 "xml conversion"
207 |             ],
208 |             "time": "2016-11-10T19:10:18+00:00"
209 |         },
210 |         {
211 |             "name": "php-cs-fixer/diff",
212 |             "version": "v1.3.0",
213 |             "source": {
214 |                 "type": "git",
215 |                 "url": "https://github.com/PHP-CS-Fixer/diff.git",
216 |                 "reference": "78bb099e9c16361126c86ce82ec4405ebab8e756"
217 |             },
218 |             "dist": {
219 |                 "type": "zip",
220 |                 "url": "https://api.github.com/repos/PHP-CS-Fixer/diff/zipball/78bb099e9c16361126c86ce82ec4405ebab8e756",
221 |                 "reference": "78bb099e9c16361126c86ce82ec4405ebab8e756",
222 |                 "shasum": ""
223 |             },
224 |             "require": {
225 |                 "php": "^5.6 || ^7.0"
226 |             },
227 |             "require-dev": {
228 |                 "phpunit/phpunit": "^5.7.23 || ^6.4.3",
229 |                 "symfony/process": "^3.3"
230 |             },
231 |             "type": "library",
232 |             "autoload": {
233 |                 "classmap": [
234 |                     "src/"
235 |                 ]
236 |             },
237 |             "notification-url": "https://packagist.org/downloads/",
238 |             "license": [
239 |                 "BSD-3-Clause"
240 |             ],
241 |             "authors": [
242 |                 {
243 |                     "name": "Kore Nordmann",
244 |                     "email": "mail@kore-nordmann.de"
245 |                 },
246 |                 {
247 |                     "name": "Sebastian Bergmann",
248 |                     "email": "sebastian@phpunit.de"
249 |                 },
250 |                 {
251 |                     "name": "SpacePossum"
252 |                 }
253 |             ],
254 |             "description": "sebastian/diff v2 backport support for PHP5.6",
255 |             "homepage": "https://github.com/PHP-CS-Fixer",
256 |             "keywords": [
257 |                 "diff"
258 |             ],
259 |             "time": "2018-02-15T16:58:55+00:00"
260 |         },
261 |         {
262 |             "name": "psr/log",
263 |             "version": "1.1.0",
264 |             "source": {
265 |                 "type": "git",
266 |                 "url": "https://github.com/php-fig/log.git",
267 |                 "reference": "6c001f1daafa3a3ac1d8ff69ee4db8e799a654dd"
268 |             },
269 |             "dist": {
270 |                 "type": "zip",
271 |                 "url": "https://api.github.com/repos/php-fig/log/zipball/6c001f1daafa3a3ac1d8ff69ee4db8e799a654dd",
272 |                 "reference": "6c001f1daafa3a3ac1d8ff69ee4db8e799a654dd",
273 |                 "shasum": ""
274 |             },
275 |             "require": {
276 |                 "php": ">=5.3.0"
277 |             },
278 |             "type": "library",
279 |             "extra": {
280 |                 "branch-alias": {
281 |                     "dev-master": "1.0.x-dev"
282 |                 }
283 |             },
284 |             "autoload": {
285 |                 "psr-4": {
286 |                     "Psr\\Log\\": "Psr/Log/"
287 |                 }
288 |             },
289 |             "notification-url": "https://packagist.org/downloads/",
290 |             "license": [
291 |                 "MIT"
292 |             ],
293 |             "authors": [
294 |                 {
295 |                     "name": "PHP-FIG",
296 |                     "homepage": "http://www.php-fig.org/"
297 |                 }
298 |             ],
299 |             "description": "Common interface for logging libraries",
300 |             "homepage": "https://github.com/php-fig/log",
301 |             "keywords": [
302 |                 "log",
303 |                 "psr",
304 |                 "psr-3"
305 |             ],
306 |             "time": "2018-11-20T15:27:04+00:00"
307 |         },
308 |         {
309 |             "name": "squizlabs/php_codesniffer",
310 |             "version": "3.3.2",
311 |             "source": {
312 |                 "type": "git",
313 |                 "url": "https://github.com/squizlabs/PHP_CodeSniffer.git",
314 |                 "reference": "6ad28354c04b364c3c71a34e4a18b629cc3b231e"
315 |             },
316 |             "dist": {
317 |                 "type": "zip",
318 |                 "url": "https://api.github.com/repos/squizlabs/PHP_CodeSniffer/zipball/6ad28354c04b364c3c71a34e4a18b629cc3b231e",
319 |                 "reference": "6ad28354c04b364c3c71a34e4a18b629cc3b231e",
320 |                 "shasum": ""
321 |             },
322 |             "require": {
323 |                 "ext-simplexml": "*",
324 |                 "ext-tokenizer": "*",
325 |                 "ext-xmlwriter": "*",
326 |                 "php": ">=5.4.0"
327 |             },
328 |             "require-dev": {
329 |                 "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0"
330 |             },
331 |             "bin": [
332 |                 "bin/phpcs",
333 |                 "bin/phpcbf"
334 |             ],
335 |             "type": "library",
336 |             "extra": {
337 |                 "branch-alias": {
338 |                     "dev-master": "3.x-dev"
339 |                 }
340 |             },
341 |             "notification-url": "https://packagist.org/downloads/",
342 |             "license": [
343 |                 "BSD-3-Clause"
344 |             ],
345 |             "authors": [
346 |                 {
347 |                     "name": "Greg Sherwood",
348 |                     "role": "lead"
349 |                 }
350 |             ],
351 |             "description": "PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files and detects violations of a defined set of coding standards.",
352 |             "homepage": "http://www.squizlabs.com/php-codesniffer",
353 |             "keywords": [
354 |                 "phpcs",
355 |                 "standards"
356 |             ],
357 |             "time": "2018-09-23T23:08:17+00:00"
358 |         },
359 |         {
360 |             "name": "vimeo/psalm",
361 |             "version": "1.1.9",
362 |             "source": {
363 |                 "type": "git",
364 |                 "url": "https://github.com/vimeo/psalm.git",
365 |                 "reference": "d15cf3b7f50249caf933144c8926c8e69aff3d34"
366 |             },
367 |             "dist": {
368 |                 "type": "zip",
369 |                 "url": "https://api.github.com/repos/vimeo/psalm/zipball/d15cf3b7f50249caf933144c8926c8e69aff3d34",
370 |                 "reference": "d15cf3b7f50249caf933144c8926c8e69aff3d34",
371 |                 "shasum": ""
372 |             },
373 |             "require": {
374 |                 "composer/xdebug-handler": "^1.1",
375 |                 "muglug/package-versions-56": "1.2.4",
376 |                 "nikic/php-parser": "^3.1",
377 |                 "openlss/lib-array2xml": "^0.0.10||^0.5.1",
378 |                 "php": "^5.6||^7.0",
379 |                 "php-cs-fixer/diff": "^1.2"
380 |             },
381 |             "provide": {
382 |                 "psalm/psalm": "self.version"
383 |             },
384 |             "require-dev": {
385 |                 "bamarni/composer-bin-plugin": "^1.2",
386 |                 "php-coveralls/php-coveralls": "^2.0",
387 |                 "phpunit/phpunit": "^5.7.4",
388 |                 "squizlabs/php_codesniffer": "^3.0"
389 |             },
390 |             "suggest": {
391 |                 "ext-igbinary": "^2.0.5"
392 |             },
393 |             "bin": [
394 |                 "psalm",
395 |                 "psalter"
396 |             ],
397 |             "type": "library",
398 |             "extra": {
399 |                 "branch-alias": {
400 |                     "dev-master": "2.x-dev",
401 |                     "dev-1.x": "1.x-dev"
402 |                 }
403 |             },
404 |             "autoload": {
405 |                 "psr-4": {
406 |                     "Psalm\\": "src/Psalm"
407 |                 }
408 |             },
409 |             "notification-url": "https://packagist.org/downloads/",
410 |             "license": [
411 |                 "MIT"
412 |             ],
413 |             "authors": [
414 |                 {
415 |                     "name": "Matthew Brown"
416 |                 }
417 |             ],
418 |             "description": "A static analysis tool for finding errors in PHP applications",
419 |             "keywords": [
420 |                 "code",
421 |                 "inspection",
422 |                 "php"
423 |             ],
424 |             "time": "2018-08-14T16:06:16+00:00"
425 |         }
426 |     ],
427 |     "aliases": [],
428 |     "minimum-stability": "stable",
429 |     "stability-flags": [],
430 |     "prefer-stable": false,
431 |     "prefer-lowest": false,
432 |     "platform": {
433 |         "php": "^7.0",
434 |         "ext-json": "*",
435 |         "ext-reflection": "*"
436 |     },
437 |     "platform-dev": []
438 | }
439 | 


--------------------------------------------------------------------------------
/examples/doctrine.py:
--------------------------------------------------------------------------------
 1 | """Use Symfony and Doctrine to print a list of test users."""
 2 | 
 3 | # Initialize PHP
 4 | from phpbridge import php
 5 | php.require('vendor/autoload.php')
 6 | 
 7 | # Make this namespace accessible for later
 8 | import phpbridge.php.MyNamespace.Entities
 9 | 
10 | # Start Symfony and get a container object
11 | kernel = php.AppKernel('dev', False)
12 | kernel.boot()
13 | container = kernel.getContainer()
14 | 
15 | # Start and get an entity manager
16 | em = container.get('doctrine.orm.entity_manager')
17 | 
18 | # You can use the class object instead of a string
19 | users = em.getRepository(php.MyNamespace.Entities.User)
20 | 
21 | for user in users.findBy({'email': 'test@example.org'}):
22 |     print(user.getUsername())
23 | 


--------------------------------------------------------------------------------
/phpbridge/__init__.py:
--------------------------------------------------------------------------------
  1 | import base64
  2 | import json
  3 | import math
  4 | import os
  5 | import subprocess as sp
  6 | import sys
  7 | import types
  8 | 
  9 | from collections import ChainMap, OrderedDict
 10 | from typing import (Any, Callable, IO, Iterator, List, Dict,  # noqa: F401
 11 |                     Iterable, Optional, Set, Union)
 12 | from weakref import finalize
 13 | 
 14 | from phpbridge import functions, modules, objects
 15 | 
 16 | php_server_path = os.path.join(
 17 |     os.path.dirname(__file__), 'server.php')
 18 | 
 19 | 
 20 | class PHPBridge:
 21 |     def __init__(self, input_: IO[str], output: IO[str], name: str) -> None:
 22 |         self.input = input_
 23 |         self.output = output
 24 |         self.classes = {}        # type: Dict[str, objects.PHPClass]
 25 |         self.functions = {}      # type: Dict[str, Callable]
 26 |         self.constants = {}      # type: Dict[str, Any]
 27 |         self.cache = ChainMap(self.classes, self.functions, self.constants)
 28 |         self._remotes = {}       # type: Dict[Union[int, str], finalize]
 29 |         self._collected = set()  # type: Set[Union[int, str]]
 30 |         self._debug = False
 31 |         self.__name__ = name
 32 | 
 33 |     def send(self, command: str, data: Any) -> None:
 34 |         if self._debug:
 35 |             print(command, data)
 36 |         garbage = list(self._collected.copy())
 37 |         if self._debug and garbage:
 38 |             print("Asking to collect {}".format(garbage))
 39 |         json.dump({'cmd': command,
 40 |                    'data': data,
 41 |                    'garbage': garbage},
 42 |                   self.input)
 43 |         self.input.write('\n')
 44 |         self.input.flush()
 45 | 
 46 |     def receive(self) -> Any:
 47 |         line = self.output.readline()
 48 |         if self._debug:
 49 |             print(line, end='')
 50 |         if not line:
 51 |             # Empty response, not even a newline
 52 |             raise RuntimeError("Connection closed")
 53 |         response = json.loads(line)
 54 |         for key in response['collected']:
 55 |             if self._debug:
 56 |                 print("Confirmed {} collected".format(key))
 57 |             if key in self._collected:
 58 |                 self._collected.remove(key)
 59 |             else:
 60 |                 if self._debug:
 61 |                     print("But {} is not pending collection".format(key))
 62 |         if response['type'] == 'exception':
 63 |             try:
 64 |                 exception = self.decode(response['data']['value'])
 65 |             except Exception:
 66 |                 raise Exception(
 67 |                     "Failed decoding exception with message '{}'".format(
 68 |                         response['data']['message']))
 69 |             raise exception
 70 |         elif response['type'] == 'result':
 71 |             return response['data']
 72 |         else:
 73 |             raise Exception("Received response with unknown type {}".format(
 74 |                 response['type']))
 75 | 
 76 |     def encode(self, data: Any) -> dict:
 77 |         if isinstance(data, str):
 78 |             try:
 79 |                 data.encode()
 80 |                 return {'type': 'string', 'value': data}
 81 |             except UnicodeEncodeError:
 82 |                 # string contains surrogates
 83 |                 data = data.encode(errors='surrogateescape')
 84 | 
 85 |         if isinstance(data, bytes):
 86 |             return {'type': 'bytes',
 87 |                     'value': base64.b64encode(data).decode()}
 88 | 
 89 |         if isinstance(data, bool):
 90 |             return {'type': 'boolean', 'value': data}
 91 | 
 92 |         if isinstance(data, int):
 93 |             return {'type': 'integer', 'value': data}
 94 | 
 95 |         if isinstance(data, float):
 96 |             if math.isnan(data):
 97 |                 data = 'NAN'
 98 |             elif math.isinf(data):
 99 |                 data = 'INF' if data > 0 else '-INF'
100 |             return {'type': 'double', 'value': data}
101 | 
102 |         if data is None:
103 |             return {'type': 'NULL', 'value': data}
104 | 
105 |         if isinstance(data, dict) and all(
106 |                 isinstance(key, str) or isinstance(key, int)
107 |                 for key in data):
108 |             return {'type': 'array', 'value': {k: self.encode(v)
109 |                                                for k, v in data.items()}}
110 |         if isinstance(data, list):
111 |             return {'type': 'array', 'value': [self.encode(item)
112 |                                                for item in data]}
113 | 
114 |         if isinstance(data, objects.PHPObject) and data._bridge is self:
115 |             return {'type': 'object',
116 |                     'value': {'class': data.__class__._name,  # type: ignore
117 |                               'hash': data._hash}}
118 | 
119 |         if isinstance(data, objects.PHPResource) and data._bridge is self:
120 |             return {'type': 'resource',
121 |                     'value': {'type': data._type,
122 |                               'hash': data._id}}
123 | 
124 |         if isinstance(data, objects.PHPClass) and data._bridge is self:
125 |             # PHP uses strings to represent functions and classes
126 |             # This unfortunately means they will be strings if they come back
127 |             return {'type': 'string', 'value': data._name}
128 | 
129 |         if (isinstance(data, types.FunctionType) and
130 |                 getattr(data, '_bridge', None) is self):
131 |             return {'type': 'string', 'value': data.__name__}
132 | 
133 |         if (isinstance(data, types.MethodType) and
134 |                 getattr(data.__self__, '_bridge', None) is self):
135 |             return self.encode([data.__self__, data.__name__])
136 | 
137 |         raise RuntimeError("Can't encode {!r}".format(data))
138 | 
139 |     def decode(self, data: dict) -> Any:
140 |         type_ = data['type']
141 |         value = data['value']
142 |         if type_ in {'string', 'integer', 'NULL', 'boolean'}:
143 |             return value
144 |         elif type_ == 'double':
145 |             if value == 'INF':
146 |                 return math.inf
147 |             elif value == '-INF':
148 |                 return -math.inf
149 |             elif value == 'NAN':
150 |                 return math.nan
151 |             return value
152 |         elif type_ == 'array':
153 |             if isinstance(value, list):
154 |                 return Array.list(map(self.decode, value))
155 |             elif isinstance(value, dict):
156 |                 return Array((key, self.decode(item))
157 |                              for key, item in value.items())
158 |         elif type_ == 'object':
159 |             cls = self.get_class(value['class'])
160 |             return self.get_object(cls, value['hash'])
161 |         elif type_ == 'resource':
162 |             return self.get_resource(value['type'], value['hash'])
163 |         elif type_ == 'bytes':
164 |             # PHP's strings are just byte arrays
165 |             # Decoding this to a bytes object would be problematic
166 |             # It might be meant as a legitimate string, and some binary data
167 |             # could be valid unicode by accident
168 |             value = base64.b64decode(value)
169 |             return value.decode(errors='surrogateescape')
170 |         raise RuntimeError("Unknown type {!r}".format(type_))
171 | 
172 |     def send_command(self, cmd: str, data: Any = None,
173 |                      decode: bool = False) -> Any:
174 |         self.send(cmd, data)
175 |         result = self.receive()
176 |         if decode:
177 |             result = self.decode(result)
178 |         return result
179 | 
180 |     def resolve(self, path: str, name: str) -> Any:
181 |         if path:
182 |             name = path + '\\' + name
183 | 
184 |         if name in self.cache:
185 |             return self.cache[name]
186 |         else:
187 |             kind = self.send_command('resolveName', name)
188 | 
189 |         if kind == 'class':
190 |             return self.get_class(name)
191 |         elif kind == 'func':
192 |             return self.get_function(name)
193 |         elif kind == 'const':
194 |             return self.get_const(name)
195 |         elif kind == 'global':
196 |             return self.get_global(name)
197 |         elif kind == 'none':
198 |             raise AttributeError("Nothing named '{}' found".format(name))
199 |         else:
200 |             raise RuntimeError("Resolved unknown data type {}".format(kind))
201 | 
202 |     def get_class(self, name: str) -> objects.PHPClass:
203 |         if name not in self.classes:
204 |             objects.create_class(self, name)
205 |         return self.classes[name]
206 | 
207 |     def get_function(self, name: str) -> Callable:
208 |         if name not in self.functions:
209 |             functions.create_function(self, name)
210 |         return self.functions[name]
211 | 
212 |     def get_const(self, name: str) -> Any:
213 |         if name not in self.constants:
214 |             self.constants[name] = self.send_command(
215 |                 'getConst', name, decode=True)
216 |         return self.constants[name]
217 | 
218 |     def get_global(self, name: str) -> Any:
219 |         return self.send_command('getGlobal', name, decode=True)
220 | 
221 |     def get_object(self, cls: objects.PHPClass,
222 |                    hash_: str) -> objects.PHPObject:
223 |         obj = self._lookup(hash_)
224 |         if obj is not None:
225 |             return obj          # type: ignore
226 |         new_obj = super(objects.PHPObject, cls).__new__(cls)  # type: ignore
227 |         object.__setattr__(new_obj, '_hash', hash_)
228 |         self._register(hash_, new_obj)
229 |         return new_obj          # type: ignore
230 | 
231 |     def get_resource(self, type_: str, id_: int) -> objects.PHPResource:
232 |         resource = self._lookup(id_)
233 |         if resource is not None:
234 |             return resource     # type: ignore
235 |         new_resource = objects.PHPResource(self, type_, id_)
236 |         self._register(id_, new_resource)
237 |         return new_resource
238 | 
239 |     def _register(self, ident: Union[int, str],
240 |                   entity: Union[objects.PHPResource,
241 |                                 objects.PHPObject]) -> None:
242 |         """Register an object or resource with a weakref."""
243 |         if self._debug:
244 |             print("Registering {}".format(ident))
245 |         self._remotes[ident] = finalize(entity, self._collect, ident)
246 | 
247 |     def _lookup(self, ident: Union[int, str]) -> Optional[
248 |             Union[objects.PHPResource, objects.PHPObject]]:
249 |         """Look up an existing object for a remote entity."""
250 |         try:
251 |             ref = self._remotes[ident]
252 |         except KeyError:
253 |             return None
254 |         contents = ref.peek()
255 |         if contents is None:
256 |             return None
257 |         return contents[0]
258 | 
259 |     def _collect(self, ident: Union[int, str]) -> None:
260 |         """Mark an object or resource identifier as garbage collected."""
261 |         if self._debug:
262 |             print("Lost {}".format(ident))
263 |         self._collected.add(ident)
264 |         del self._remotes[ident]
265 | 
266 | 
267 | class Array(OrderedDict):
268 |     """An ordered dictionary with some of PHP's idiosyncrasies.
269 | 
270 |     These can be treated like lists, to some extent. Simple looping yields
271 |     values, not keys. To get keys, explicitly use .keys(). Positive integer
272 |     keys are automatically converted to strings.
273 | 
274 |     Creating these arrays yourself or modifying them is a bad idea. This class
275 |     only exists to deal with PHP's ambiguities. If not consumed immediately,
276 |     it's best to convert it to a list or a dict, depending on the kind of array
277 |     you expect.
278 |     """
279 |     def __iter__(self) -> Iterator:
280 |         yield from self.values()
281 | 
282 |     def __getitem__(self, index: Union[int, str, slice]) -> Any:
283 |         if isinstance(index, slice) or isinstance(index, int) and index < 0:
284 |             return list(self.values())[index]
285 |         if isinstance(index, int):
286 |             index = str(index)
287 |         return super().__getitem__(index)
288 | 
289 |     def __contains__(self, value: Any) -> bool:
290 |         return value in self.values()
291 | 
292 |     def __setitem__(self, index: Union[int, str], value: Any) -> None:
293 |         if isinstance(index, int):
294 |             index = str(index)
295 |         super().__setitem__(index, value)
296 | 
297 |     def __delitem__(self, index: Union[int, str]) -> None:
298 |         if isinstance(index, int):
299 |             index = str(index)
300 |         super().__delitem__(index)
301 | 
302 |     def listable(self) -> bool:
303 |         """Return whether the array could be created from a list."""
304 |         return all(str(ind) == key for ind, key in enumerate(self.keys()))
305 | 
306 |     @classmethod
307 |     def list(cls, iterable: Iterable) -> 'Array':
308 |         """Create by taking values from a list and using indexes as keys."""
309 |         return cls((str(ind), item)  # type: ignore
310 |                    for ind, item in enumerate(iterable))
311 | 
312 |     def __repr__(self) -> str:
313 |         if self and self.listable():
314 |             return "{}.list({})".format(self.__class__.__name__,
315 |                                         list(self.values()))
316 |         return super().__repr__()
317 | 
318 | 
319 | def start_process_unix(fname: str, name: str) -> PHPBridge:
320 |     """Start a server.php bridge using two pipes.
321 | 
322 |     pass_fds is not supported on Windows. It may be that some other way to
323 |     inherit file descriptors exists on Windows. In that case, the Windows
324 |     function should be adjusted, or merged with this one.
325 |     """
326 |     php_in, py_in = os.pipe()
327 |     py_out, php_out = os.pipe()
328 |     sp.Popen(['php', fname, 'php://fd/{}'.format(php_in),
329 |               'php://fd/{}'.format(php_out)],
330 |              pass_fds=[0, 1, 2, php_in, php_out])
331 |     os.close(php_in)
332 |     os.close(php_out)
333 |     return PHPBridge(os.fdopen(py_in, 'w'), os.fdopen(py_out, 'r'), name)
334 | 
335 | 
336 | def start_process_windows(fname: str, name: str) -> PHPBridge:
337 |     """Start a server.php bridge over stdin and stderr."""
338 |     proc = sp.Popen(['php', fname, 'php://stdin', 'php://stderr'],
339 |                     stdin=sp.PIPE, stderr=sp.PIPE,
340 |                     universal_newlines=True)
341 |     return PHPBridge(proc.stdin, proc.stderr, name)
342 | 
343 | 
344 | def start_process(fname: str = php_server_path,
345 |                   name: str = 'php') -> PHPBridge:
346 |     """Start server.php and open a bridge to it."""
347 |     if sys.platform.startswith('win32'):
348 |         return start_process_windows(fname, name)
349 |     return start_process_unix(fname, name)
350 | 
351 | 
352 | modules.NamespaceFinder(start_process, 'php').register()
353 | 


--------------------------------------------------------------------------------
/phpbridge/classes.py:
--------------------------------------------------------------------------------
  1 | """PHP classes with special Python behavior.
  2 | 
  3 | These classes either provide special methods or inherit from Python classes.
  4 | They are not subclassed or instantiated directly. Instead, their methods and
  5 | bases are copied to the corresponding PHPClasses. This helps keep the class
  6 | hierarchy clean, because each class must be bound to a bridge.
  7 | """
  8 | 
  9 | import typing
 10 | 
 11 | from typing import Any, Callable, Dict, Optional, Type, Union  # noqa: F401
 12 | 
 13 | from phpbridge.objects import PHPObject
 14 | 
 15 | predef_classes = {}             # type: Dict[str, Type]
 16 | 
 17 | magic_aliases = {
 18 |     '__toString': '__str__',
 19 |     '__invoke': '__call__'
 20 | }                               # type: Dict[str, str]
 21 | 
 22 | 
 23 | def predef(_cls: Optional[Type] = None, *,
 24 |            name: Optional[str] = None) -> Union[Callable[[Type], Type], Type]:
 25 |     """A decorator to add a class to the dictionary of pre-defined classes."""
 26 | 
 27 |     def decorator(cls: Type) -> Type:
 28 |         nonlocal name
 29 |         if name is None:
 30 |             name = cls.__name__
 31 |         predef_classes[name] = cls
 32 |         return cls
 33 | 
 34 |     if _cls is None:
 35 |         return decorator
 36 | 
 37 |     return decorator(_cls)
 38 | 
 39 | 
 40 | @predef
 41 | class Countable(PHPObject):
 42 |     """Classes that can be used with count() (PHP) or len() (Python).
 43 | 
 44 |     See also: collections.abc.Sized.
 45 |     """
 46 |     def __len__(self) -> int:
 47 |         return self._bridge.send_command(  # type: ignore
 48 |             'count', self._bridge.encode(self))
 49 | 
 50 | 
 51 | @predef
 52 | class Iterator(PHPObject):
 53 |     """Interface for objects that can be iterated.
 54 | 
 55 |     See also: collections.abc.Iterator.
 56 |     """
 57 |     def __next__(self) -> Any:
 58 |         status, key, value = self._bridge.send_command(
 59 |             'nextIteration', self._bridge.encode(self), decode=True)
 60 |         if not status:
 61 |             raise StopIteration
 62 |         return key, value
 63 | 
 64 | 
 65 | @predef
 66 | class Traversable(PHPObject):
 67 |     """Interface to detect if a class is traversable using a for(each) loop.
 68 | 
 69 |     See also: collections.abc.Iterable.
 70 |     """
 71 |     def __iter__(self) -> typing.Iterator:
 72 |         return self._bridge.send_command(  # type: ignore
 73 |             'startIteration', self._bridge.encode(self), decode=True)
 74 | 
 75 | 
 76 | @predef
 77 | class ArrayAccess(PHPObject):
 78 |     """Interface to provide accessing objects as arrays.
 79 | 
 80 |     Note that the "in" operator only ever checks for valid keys when it comes
 81 |     to this class. It's less general than the usual possibilities.
 82 |     """
 83 |     def __contains__(self, item: Any) -> bool:
 84 |         return self._bridge.send_command(  # type: ignore
 85 |             'hasItem',
 86 |             {'obj': self._bridge.encode(self),
 87 |              'offset': self._bridge.encode(item)})
 88 | 
 89 |     def __getitem__(self, item: Any) -> Any:
 90 |         return self._bridge.send_command(
 91 |             'getItem',
 92 |             {'obj': self._bridge.encode(self),
 93 |              'offset': self._bridge.encode(item)},
 94 |             decode=True)
 95 | 
 96 |     def __setitem__(self, item: Any, value: Any) -> None:
 97 |         self._bridge.send_command(
 98 |             'setItem',
 99 |             {'obj': self._bridge.encode(self),
100 |              'offset': self._bridge.encode(item),
101 |              'value': self._bridge.encode(value)})
102 | 
103 |     def __delitem__(self, item: Any) -> None:
104 |         self._bridge.send_command(
105 |             'delItem',
106 |             {'obj': self._bridge.encode(self),
107 |              'offset': self._bridge.encode(item)})
108 | 
109 | 
110 | @predef
111 | class Throwable(PHPObject, Exception):
112 |     """An exception created in PHP.
113 | 
114 |     Both a valid Exception and a valid PHPObject, so can be raised and
115 |     caught.
116 |     """
117 |     def __init__(self, *args: Any, **kwargs: Any) -> None:
118 |         super(Exception, self).__init__(self.getMessage())
119 | 
120 | 
121 | # Closure is somehow hardwired to be callable, without __invoke
122 | # TODO: It would be nice to generate a signature for this
123 | @predef
124 | class Closure(PHPObject):
125 |     def __call__(self, *args: Any) -> Any:
126 |         return self._bridge.send_command(
127 |             'callObj',
128 |             {'obj': self._bridge.encode(self),
129 |              'args': [self._bridge.encode(arg) for arg in args]},
130 |             decode=True)
131 | 
132 | 
133 | @predef(name='ArithmeticError')
134 | class PHPArithmeticError(PHPObject, ArithmeticError):
135 |     pass
136 | 
137 | 
138 | @predef(name='AssertionError')
139 | class PHPAssertionError(PHPObject, AssertionError):
140 |     pass
141 | 
142 | 
143 | @predef
144 | class OutOfBoundsException(PHPObject, IndexError):
145 |     pass
146 | 
147 | 
148 | @predef
149 | class OverflowException(PHPObject, OverflowError):
150 |     pass
151 | 
152 | 
153 | @predef
154 | class ParseError(PHPObject, SyntaxError):
155 |     pass
156 | 
157 | 
158 | @predef
159 | class RuntimeException(PHPObject, RuntimeError):
160 |     pass
161 | 
162 | 
163 | @predef(name='TypeError')
164 | class PHPTypeError(PHPObject, TypeError):
165 |     pass
166 | 
167 | 
168 | @predef
169 | class UnexpectedValueException(PHPObject, ValueError):
170 |     pass
171 | 
172 | 
173 | @predef(name=r'blyxxyz\PythonServer\Exceptions\AttributeError')
174 | class PHPAttributeError(PHPObject, AttributeError):
175 |     pass
176 | 


--------------------------------------------------------------------------------
/phpbridge/docblocks.py:
--------------------------------------------------------------------------------
  1 | """A module for parsing docblock types into mypy-style types.
  2 | 
  3 | This was originally going to be used to enhance the function signatures, but
  4 | it's useful to know the types that PHP will actually check for and the docblock
  5 | types are visible in the __doc__ anyway so it's not used at all now.
  6 | 
  7 | It could still be useful for auto-generating mypy stubs, or something.
  8 | """
  9 | 
 10 | from typing import Any, Callable, Dict, Optional, Sequence, Type, Union
 11 | 
 12 | import phpbridge
 13 | import re
 14 | 
 15 | 
 16 | def parse_type(bridge: 'phpbridge.PHPBridge',
 17 |                spec: str,
 18 |                cls: Optional[Type] = None,
 19 |                bases: Optional[Sequence[Type]] = None) -> Any:
 20 |     """Try to parse a PHPDoc type specification.
 21 | 
 22 |     Mostly follows https://docs.phpdoc.org/guides/types.html.
 23 |     """
 24 | 
 25 |     if not all(char.isalnum() or char in '|[]?\\'
 26 |                for char in spec):
 27 |         # The spec is probably too advanced for us to deal with properly
 28 |         # In that case, return a string
 29 |         # This excludes some valid class names, but if you're using
 30 |         # non-alphanumeric unicode in your class names, please stop
 31 |         return spec
 32 | 
 33 |     simple_types = {
 34 |         'string': str,
 35 |         'int': int,
 36 |         'integer': int,
 37 |         'float': float,
 38 |         'double': float,        # This is not official but probably better
 39 |         'bool': bool,
 40 |         'boolean': bool,
 41 |         'array': dict,
 42 |         'resource': phpbridge.objects.PHPResource,
 43 |         'object': phpbridge.objects.PHPObject,
 44 |         'null': None,
 45 |         'void': None,
 46 |         'callable': Callable,
 47 |         'mixed': Any,
 48 |         'false': False,
 49 |         'true': True,
 50 |         'self': cls if cls is not None else 'self',
 51 |         'static': 'static',     # These are tricky, maybe work them out later
 52 |         '$this': '$this'
 53 |     }
 54 | 
 55 |     parsed = []
 56 | 
 57 |     for option in spec.split('|'):  # type: Any
 58 | 
 59 |         is_array = False
 60 |         if option.endswith('[]'):
 61 |             option = option[:-2]
 62 |             is_array = True
 63 | 
 64 |         is_optional = False
 65 |         if option.startswith('?'):
 66 |             option = option[1:]
 67 |             is_optional = True
 68 | 
 69 |         if any(char in option for char in '[]?'):
 70 |             # This is too advanced, abort
 71 |             return spec
 72 | 
 73 |         if option in simple_types:
 74 |             option = simple_types[option]
 75 |         else:
 76 |             try:
 77 |                 option = bridge.get_class(option)
 78 |             except Exception:
 79 |                 # Give up and keep it as a string
 80 |                 pass
 81 | 
 82 |         if is_array:
 83 |             option = Dict[Union[int, str], option]
 84 | 
 85 |         if is_optional:
 86 |             option = Optional[option]
 87 | 
 88 |         parsed.append(option)
 89 | 
 90 |     if parsed != [None]:
 91 |         # A Union with one member just becomes that member so this is ok
 92 |         return Union[tuple(parsed)]
 93 |     else:
 94 |         # But Union[None] becomes NoneType and that's ugly
 95 |         return None
 96 | 
 97 | 
 98 | def get_signature(bridge: 'phpbridge.PHPBridge',
 99 |                   docblock: str,
100 |                   cls: Optional[Type] = None,
101 |                   bases: Optional[Sequence[Type]] = None):
102 |     params = {name: parse_type(bridge, spec, cls, bases)
103 |               for spec, name in
104 |               re.findall(r'\@param\s+([^\s]*)\s+\$([^\s\*]+)', docblock)}
105 |     match = re.search(r'\@return\s+([^\s]*)', docblock)
106 |     if match is not None:
107 |         ret = parse_type(bridge, match.group(1), cls, bases)
108 |     else:
109 |         # "None" would be a valid return type, so we use this
110 |         ret = ''
111 |     return params, ret
112 | 


--------------------------------------------------------------------------------
/phpbridge/functions.py:
--------------------------------------------------------------------------------
  1 | import itertools
  2 | 
  3 | from inspect import Parameter, Signature
  4 | from typing import Any, Callable, Dict, Iterator, Optional, Set  # noqa: F401
  5 | 
  6 | from phpbridge import modules, utils
  7 | 
  8 | MYPY = False
  9 | if MYPY:
 10 |     from phpbridge import PHPBridge  # noqa: F401
 11 | 
 12 | 
 13 | def parse_type_info(bridge: 'PHPBridge', info: Dict[str, Any]) -> Any:
 14 |     """Turn a type info dict into an annotation."""
 15 |     from phpbridge import objects
 16 | 
 17 |     if info['isClass']:
 18 |         try:
 19 |             annotation = bridge.get_class(info['name'])  # type: Any
 20 |         except Exception:
 21 |             # This probably means the type annotation is invalid.
 22 |             # PHP just lets that happen, because the annotation might start
 23 |             # existing in the future. So we'll allow it too. But we can't get
 24 |             # the class, so use the name of the class instead.
 25 |             annotation = (modules.get_module(bridge, info['name']) + '.' +
 26 |                           modules.basename(info['name']))
 27 |     else:
 28 |         annotation = objects.php_types.get(info['name'], info['name'])
 29 |     if info['nullable']:
 30 |         annotation = Optional[annotation]
 31 | 
 32 |     return annotation
 33 | 
 34 | 
 35 | def different_name(name: str) -> Iterator[str]:
 36 |     """Look for new names that don't conflict with existing names."""
 37 |     yield name
 38 |     for n in itertools.count(2):
 39 |         yield name + str(n)
 40 | 
 41 | 
 42 | def make_signature(bridge: 'PHPBridge', info: Dict[str, Any],
 43 |                    add_first: Optional[str] = None) -> Signature:
 44 |     """Create a function signature from an info dict."""
 45 |     parameters = []
 46 |     used_names = set()          # type: Set[str]
 47 | 
 48 |     if add_first:
 49 |         parameters.append(Parameter(
 50 |             name=add_first,
 51 |             kind=Parameter.POSITIONAL_OR_KEYWORD,
 52 |             default=Parameter.empty,
 53 |             annotation=Parameter.empty))
 54 |         used_names.add(add_first)
 55 | 
 56 |     # Mysteriously enough, PHP lets you make a function with default arguments
 57 |     # before arguments without a default. Python doesn't. So if that happens,
 58 |     # we mark it as an unknown default.
 59 |     # default_required is set to True as soon as we find the first parameter
 60 |     # with a default value.
 61 |     default_required = False
 62 | 
 63 |     for param in info['params']:
 64 | 
 65 |         for param_name in different_name(param['name']):
 66 |             if param_name not in used_names:
 67 |                 used_names.add(param_name)
 68 |                 break
 69 | 
 70 |         default = (bridge.decode(param['default']) if param['hasDefault'] else
 71 |                    Parameter.empty)
 72 | 
 73 |         if (param['isOptional'] and not param['variadic'] and
 74 |                 default is Parameter.empty):
 75 |             # Some methods have optional parameters without (visible) default
 76 |             # values. We'll use this to represent those.
 77 |             default = utils.unknown_param_default
 78 | 
 79 |         if (default_required and default is Parameter.empty and
 80 |                 not param['variadic']):
 81 |             default = utils.unknown_param_default
 82 | 
 83 |         if default is not Parameter.empty:
 84 |             # From now on, we need a default value even if we can't find one.
 85 |             default_required = True
 86 | 
 87 |         if param['type'] is None:
 88 |             annotation = Parameter.empty
 89 |         else:
 90 |             annotation = parse_type_info(bridge, param['type'])
 91 | 
 92 |         kind = (Parameter.VAR_POSITIONAL if param['variadic'] else
 93 |                 Parameter.POSITIONAL_OR_KEYWORD)
 94 | 
 95 |         parameters.append(Parameter(
 96 |             name=param_name,
 97 |             kind=kind,
 98 |             default=default,
 99 |             annotation=annotation))
100 | 
101 |     return_annotation = (Signature.empty if info['returnType'] is None else
102 |                          parse_type_info(bridge, info['returnType']))
103 | 
104 |     return Signature(parameters=parameters,
105 |                      return_annotation=return_annotation)
106 | 
107 | 
108 | default_constructor_signature = Signature(
109 |     parameters=[Parameter(name='cls',
110 |                           kind=Parameter.POSITIONAL_OR_KEYWORD,
111 |                           default=Parameter.empty,
112 |                           annotation=Parameter.empty)],
113 |     return_annotation=Signature.empty)
114 | 
115 | 
116 | def create_function(bridge: 'PHPBridge', name: str) -> None:
117 |     """Create and register a PHP function."""
118 |     info = bridge.send_command('funcInfo', name)
119 | 
120 |     if info['name'] in bridge.functions:
121 |         bridge.functions[name] = bridge.functions[info['name']]
122 |         return
123 | 
124 |     def func(*args: Any, **kwargs: Any) -> Any:
125 |         args = utils.parse_args(
126 |             func.__signature__, args, kwargs)  # type: ignore
127 |         return bridge.send_command(
128 |             'callFun',
129 |             {'name': name,
130 |              'args': [bridge.encode(arg) for arg in args]},
131 |             decode=True)
132 | 
133 |     func.__doc__ = utils.convert_docblock(info['doc'])
134 |     func.__module__ = modules.get_module(bridge, name)
135 |     func.__name__ = info['name']
136 |     func.__qualname__ = modules.basename(info['name'])
137 |     func.__signature__ = make_signature(bridge, info)  # type: ignore
138 |     func._bridge = bridge                              # type: ignore
139 | 
140 |     bridge.functions[name] = func
141 |     bridge.functions[info['name']] = func
142 | 


--------------------------------------------------------------------------------
/phpbridge/modules.py:
--------------------------------------------------------------------------------
  1 | import importlib
  2 | import importlib.abc
  3 | import sys
  4 | 
  5 | from importlib.machinery import ModuleSpec
  6 | from types import ModuleType
  7 | from typing import (Any, Callable, Dict, Generator,  # noqa: F401
  8 |                     List, Optional, Union)
  9 | 
 10 | import phpbridge
 11 | 
 12 | MYPY = False
 13 | if MYPY:
 14 |     from phpbridge import PHPBridge  # noqa: F401
 15 | 
 16 | bridges = {}                # type: Dict[PHPBridge, str]
 17 | 
 18 | 
 19 | class Namespace(ModuleType):
 20 |     def __init__(self, name: str, doc: Optional[str] = None, *,
 21 |                  bridge: 'PHPBridge', path: str) -> None:
 22 |         super().__init__(name, doc)
 23 |         self._bridge = bridge
 24 |         self._path = path
 25 |         self.__path__ = []      # type: List[str]
 26 | 
 27 |     def __getattribute__(self, attr: str) -> Any:
 28 |         val = None
 29 |         try:
 30 |             val = super().__getattribute__(attr)
 31 |             if not isinstance(val, Namespace):
 32 |                 return val
 33 |         except AttributeError:
 34 |             pass
 35 |         try:
 36 |             path = super().__getattribute__('_path')
 37 |             return self._bridge.resolve(path, attr)
 38 |         except AttributeError:
 39 |             if val is not None:
 40 |                 # We did manage to get val, but it's a Namespace
 41 |                 # It's ok as a fallback
 42 |                 return val
 43 |             raise
 44 | 
 45 |     def __dir__(self) -> Generator:
 46 |         yield from super().__dir__()
 47 |         for entry in self._bridge.send_command('listEverything', self._path):
 48 |             if '\\' not in entry:
 49 |                 yield entry
 50 |                 continue
 51 | 
 52 |     @property
 53 |     def __all__(self) -> List[str]:
 54 |         """This is unreliable because of autoloading."""
 55 |         return list(dir(self))
 56 | 
 57 |     def __repr__(self) -> str:
 58 |         if self._path:
 59 |             return "<PHP namespace '{}'>".format(self._path)
 60 |         return "<PHP global namespace>"
 61 | 
 62 |     def __getitem__(self, index: str) -> Any:
 63 |         try:
 64 |             path = super().__getattribute__('_path')
 65 |             return self._bridge.resolve(path, index)
 66 |         except AttributeError as e:
 67 |             raise KeyError(*e.args)
 68 | 
 69 | 
 70 | class NamespaceLoader(importlib.abc.Loader):
 71 |     def __init__(self, bridge: 'PHPBridge', path: str) -> None:
 72 |         self.bridge = bridge
 73 |         self.path = path
 74 | 
 75 |     def create_module(self, spec: ModuleSpec) -> Namespace:
 76 |         return Namespace(spec.name, bridge=self.bridge, path=self.path)
 77 | 
 78 |     def exec_module(self, module: ModuleType) -> None:
 79 |         pass
 80 | 
 81 | 
 82 | class NamespaceFinder(importlib.abc.MetaPathFinder):
 83 |     """Import PHP namespaces over a bridge."""
 84 |     def __init__(self, bridge: Union['PHPBridge', Callable[[], 'PHPBridge']],
 85 |                  name: str) -> None:
 86 |         self.bridge = bridge
 87 |         self.prefix = __package__ + '.' + name
 88 |         if isinstance(self.bridge, phpbridge.PHPBridge):
 89 |             bridges[self.bridge] = self.prefix
 90 | 
 91 |     def resolve(self, name: str) -> Optional[str]:
 92 |         """Parse a module name into a namespace identity.
 93 | 
 94 |         Args:
 95 |             - name: The prospective module path.
 96 | 
 97 |         Return:
 98 |             - None if the name doesn't specify a namespace.
 99 |             - A string representing the namespace otherwise.
100 |         """
101 |         if name == self.prefix:
102 |             return ''
103 | 
104 |         if not name.startswith(self.prefix + '.'):
105 |             return None
106 | 
107 |         name = name[len(self.prefix) + 1:]
108 |         return name.replace('.', '\\')
109 | 
110 |     def find_spec(self, fullname: str, path: Any,
111 |                   target: Optional[ModuleType] = None) -> Optional[ModuleSpec]:
112 |         namespace = self.resolve(fullname)
113 |         if namespace is None:
114 |             return None
115 |         if not isinstance(self.bridge, phpbridge.PHPBridge):
116 |             # Lazy bridge
117 |             self.bridge = self.bridge()
118 |             bridges[self.bridge] = self.prefix
119 |         loader = NamespaceLoader(self.bridge, namespace)
120 |         return ModuleSpec(fullname, loader, is_package=True)
121 | 
122 |     def register(self) -> None:
123 |         """Add self to sys.meta_path."""
124 |         if self not in sys.meta_path:
125 |             sys.meta_path.append(self)
126 | 
127 | 
128 | def get_module(bridge: 'PHPBridge', name: str) -> str:
129 |     """Get the full name of the module that contains a name's namespace."""
130 |     prefix = bridges[bridge]
131 |     namespace, _, name = name.rpartition('\\')
132 |     if namespace == '':
133 |         module = prefix
134 |     else:
135 |         module = prefix + '.' + namespace.replace('\\', '.')
136 |     if module not in sys.modules:
137 |         importlib.import_module(module)
138 |     return module
139 | 
140 | 
141 | def basename(fullyqualname: str) -> str:
142 |     """Remove a name's namespace, so it can be used in a __qualname__.
143 | 
144 |     It may seem wrong that the fully qualified PHP name is used as __name__,
145 |     and the unqualified PHP name is used as __qualname__, but Python's
146 |     qualified names shouldn't include the module name.
147 |     """
148 |     return fullyqualname.rpartition('\\')[2]
149 | 


--------------------------------------------------------------------------------
/phpbridge/objects.py:
--------------------------------------------------------------------------------
  1 | """Translation of PHP classes and objects to Python."""
  2 | 
  3 | from itertools import product
  4 | from typing import (Any, Callable, Dict, List, Optional, Type,  # noqa: F401
  5 |                     Union)
  6 | from warnings import warn
  7 | 
  8 | from phpbridge.functions import make_signature, default_constructor_signature
  9 | from phpbridge import modules, utils
 10 | 
 11 | MYPY = False
 12 | if MYPY:
 13 |     from phpbridge import PHPBridge  # noqa: F401
 14 | 
 15 | 
 16 | class PHPClass(type):
 17 |     """The metaclass of all PHP classes and interfaces."""
 18 |     _bridge = None              # type: PHPBridge
 19 |     _name = None                # type: str
 20 |     _is_abstract = False
 21 |     _is_interface = False
 22 |     _is_trait = False
 23 | 
 24 |     def __call__(self, *a: Any, **kw: Any) -> Any:
 25 |         if self._is_trait:
 26 |             raise TypeError("Cannot instantiate trait {}".format(
 27 |                 self.__name__))
 28 |         elif self._is_interface:
 29 |             raise TypeError("Cannot instantiate interface {}".format(
 30 |                 self.__name__))
 31 |         elif self._is_abstract:
 32 |             raise TypeError("Cannot instantiate abstract class {}".format(
 33 |                 self.__name__))
 34 |         return super().__call__(*a, **kw)
 35 | 
 36 |     def __repr__(self) -> str:
 37 |         if self._is_trait:
 38 |             return "<PHP trait '{}'>".format(self.__name__)
 39 |         elif self._is_interface:
 40 |             return "<PHP interface '{}'>".format(self.__name__)
 41 |         elif self._is_abstract:
 42 |             return "<PHP abstract class '{}'>".format(self.__name__)
 43 |         return "<PHP class '{}'>".format(self.__name__)
 44 | 
 45 | 
 46 | class PHPObject(metaclass=PHPClass):
 47 |     """The base class of all instantiatable PHP classes."""
 48 |     def __new__(cls, *args: Any) -> Any:
 49 |         """Create and return a new object."""
 50 |         return cls._bridge.send_command(
 51 |             'createObject',
 52 |             {'name': cls._name,
 53 |              'args': [cls._bridge.encode(arg) for arg in args]},
 54 |             decode=True)
 55 | 
 56 |     # In theory, this __new__ only shows up if no constructor has been defined,
 57 |     # so it doesn't take arguments. In practice we don't want to enforce that,
 58 |     # but we'll override the ugly signature.
 59 |     __new__.__signature__ = default_constructor_signature  # type: ignore
 60 | 
 61 |     def __repr__(self) -> str:
 62 |         return self._bridge.send_command(  # type: ignore
 63 |             'repr', self._bridge.encode(self), decode=True)
 64 | 
 65 |     def __getattr__(self, attr: str) -> Any:
 66 |         return self._bridge.send_command(
 67 |             'getProperty',
 68 |             {'obj': self._bridge.encode(self),
 69 |              'name': attr},
 70 |             decode=True)
 71 | 
 72 |     def __setattr__(self, attr: str, value: Any) -> None:
 73 |         self._bridge.send_command(
 74 |             'setProperty',
 75 |             {'obj': self._bridge.encode(self),
 76 |              'name': attr,
 77 |              'value': self._bridge.encode(value)})
 78 | 
 79 |     def __delattr__(self, attr: str) -> None:
 80 |         self._bridge.send_command(
 81 |             'unsetProperty',
 82 |             {'obj': self._bridge.encode(self),
 83 |              'name': attr})
 84 | 
 85 |     def __dir__(self) -> List[str]:
 86 |         return super().__dir__() + self._bridge.send_command(  # type: ignore
 87 |             'listNonDefaultProperties', self._bridge.encode(self))
 88 | 
 89 | 
 90 | def make_method(bridge: 'PHPBridge', classname: str, name: str,
 91 |                 info: dict) -> Callable:
 92 | 
 93 |     def method(*args: Any, **kwargs: Any) -> Any:
 94 |         self, *args = utils.parse_args(
 95 |             method.__signature__, args, kwargs)  # type: ignore
 96 |         return bridge.send_command(
 97 |             'callMethod',
 98 |             {'obj': bridge.encode(self),
 99 |              'name': name,
100 |              'args': [bridge.encode(arg) for arg in args]},
101 |             decode=True)
102 | 
103 |     method.__module__ = modules.get_module(bridge, classname)
104 |     method.__name__ = name
105 |     method.__qualname__ = modules.basename(classname) + '.' + name
106 | 
107 |     if info['doc'] is not False:
108 |         method.__doc__ = utils.convert_docblock(info['doc'])
109 | 
110 |     if info['static']:
111 |         # mypy doesn't know classmethods are callable
112 |         return classmethod(method)  # type: ignore
113 | 
114 |     return method
115 | 
116 | 
117 | def create_property(name: str, doc: Optional[str]) -> property:
118 |     def getter(self: PHPObject) -> Any:
119 |         return self._bridge.send_command(
120 |             'getProperty',
121 |             {'obj': self._bridge.encode(self), 'name': name},
122 |             decode=True)
123 | 
124 |     def setter(self: PHPObject, value: Any) -> None:
125 |         self._bridge.send_command(
126 |             'setProperty',
127 |             {'obj': self._bridge.encode(self),
128 |              'name': name,
129 |              'value': self._bridge.encode(value)})
130 | 
131 |     def deleter(self: PHPObject) -> None:
132 |         self._bridge.send_command(
133 |             'unsetProperty', {'obj': self._bridge.encode(self), 'name': name})
134 | 
135 |     getter.__doc__ = doc
136 | 
137 |     return property(getter, setter, deleter)
138 | 
139 | 
140 | def create_class(bridge: 'PHPBridge', unresolved_classname: str) -> None:
141 |     """Create and register a PHPClass.
142 | 
143 |     Args:
144 |         bridge: The bridge the class belongs to.
145 |         unresolved_classname: The name of the class.
146 |     """
147 |     info = bridge.send_command('classInfo', unresolved_classname)
148 | 
149 |     classname = info['name']            # type: str
150 |     methods = info['methods']           # type: Dict[str, Dict[str, Any]]
151 |     interfaces = info['interfaces']     # type: List[str]
152 |     traits = info['traits']             # type: List[str]
153 |     consts = info['consts']             # type: Dict[str, Any]
154 |     properties = info['properties']     # type: Dict[str, Dict[str, Any]]
155 |     doc = info['doc']                   # type: Optional[str]
156 |     parent = info['parent']             # type: str
157 |     is_abstract = info['isAbstract']    # type: bool
158 |     is_interface = info['isInterface']  # type: bool
159 |     is_trait = info['isTrait']          # type: bool
160 | 
161 |     # PHP turns empty associative arrays into empty lists, so
162 |     if not properties:
163 |         properties = {}
164 |     if not consts:
165 |         consts = {}
166 |     if not methods:
167 |         methods = {}
168 | 
169 |     # "\Foo" resolves to the same class as "Foo", so we want them to be the
170 |     # same Python objects as well
171 |     if classname in bridge.classes:
172 |         bridge.classes[unresolved_classname] = bridge.classes[classname]
173 |         return
174 | 
175 |     bases = [PHPObject]         # type: List[Type]
176 | 
177 |     if parent is not False:
178 |         bases.append(bridge.get_class(parent))
179 | 
180 |     for trait in traits:
181 |         bases.append(bridge.get_class(trait))
182 | 
183 |     for interface in interfaces:
184 |         bases.append(bridge.get_class(interface))
185 | 
186 |     bindings = {}               # type: Dict[str, Any]
187 | 
188 |     for name, value in consts.items():
189 |         bindings[name] = value
190 | 
191 |     for name, property_info in properties.items():
192 |         if name in bindings:
193 |             warn("'{}' on class '{}' has multiple meanings".format(
194 |                 name, classname))
195 |         property_doc = utils.convert_docblock(property_info['doc'])
196 |         bindings[name] = create_property(name, property_doc)
197 | 
198 |     created_methods = {}        # type: Dict[str, Callable]
199 | 
200 |     from phpbridge.classes import magic_aliases
201 |     for name, method_info in methods.items():
202 |         if name in bindings:
203 |             warn("'{}' on class '{}' has multiple meanings".format(
204 |                 name, classname))
205 |         if method_info['owner'] != classname:
206 |             # Make inheritance visible
207 |             continue
208 | 
209 |         method = make_method(bridge, classname, name, method_info)
210 | 
211 |         if (isinstance(method.__doc__, str) and
212 |                 '@inheritdoc' in method.__doc__.lower()):
213 |             # If @inheritdoc is used, we manually look for inheritance.
214 |             # If method.__doc__ is empty we leave it empty, and pydoc and
215 |             # inspect know where to look.
216 |             for base in bases:
217 |                 try:
218 |                     base_doc = getattr(base, name).__doc__
219 |                     if isinstance(base_doc, str):
220 |                         method.__doc__ = base_doc
221 |                         break
222 |                 except AttributeError:
223 |                     pass
224 | 
225 |         bindings[name] = method
226 |         created_methods[name] = method
227 |         if name in magic_aliases:
228 |             bindings[magic_aliases[name]] = method
229 | 
230 |         if method_info['isConstructor']:
231 | 
232 |             def __new__(*args: Any, **kwargs: Any) -> Any:
233 |                 cls, *args = utils.parse_args(
234 |                     __new__.__signature__, args, kwargs)  # type: ignore
235 |                 return PHPObject.__new__(cls, *args)
236 | 
237 |             __new__.__module__ = method.__module__
238 |             __new__.__qualname__ = modules.basename(classname) + '.__new__'
239 |             __new__.__doc__ = method.__doc__
240 |             bindings['__new__'] = __new__
241 | 
242 |     # Bind the magic methods needed to make these interfaces work
243 |     # TODO: figure out something less ugly
244 |     from phpbridge.classes import predef_classes
245 |     if classname in predef_classes:
246 |         predef = predef_classes[classname]
247 |         for name, value in predef.__dict__.items():
248 |             if callable(value):
249 |                 bindings[name] = value
250 |         if doc is False:
251 |             doc = predef.__doc__
252 |         bases += predef.__bases__
253 | 
254 |     # Remove redundant bases
255 |     while True:
256 |         for (ind_a, a), (ind_b, b) in product(enumerate(bases),
257 |                                               enumerate(bases)):
258 |             if ind_a != ind_b and issubclass(a, b):
259 |                 # Don't use list.remove because maybe a == b
260 |                 # It's cleaner to keep the first occurrence
261 |                 del bases[ind_b]
262 |                 # Restart the loop because we modified bases
263 |                 break
264 |         else:
265 |             break
266 | 
267 |     # do this last to make sure it isn't replaced
268 |     bindings['_bridge'] = bridge
269 |     bindings['__doc__'] = utils.convert_docblock(doc)
270 |     bindings['__module__'] = modules.get_module(bridge, classname)
271 |     bindings['_is_abstract'] = is_abstract
272 |     bindings['_is_interface'] = is_interface
273 |     bindings['_is_trait'] = is_trait
274 | 
275 |     # PHP does something really nasty when you make an anonymous class.
276 |     # Each class needs to have a unique name, so it makes a name that goes
277 |     # class@anonymous<null byte><place of definition><hex memory address>
278 |     # The null byte is probably to trick naively written C code into
279 |     # printing only the class@anonymous part.
280 |     # Unfortunately, Python doesn't like those class names, so we'll
281 |     # insert another character that you'll (hopefully) not find in any
282 |     # named class's name because the syntax doesn't allow it.
283 |     typename = classname.replace('\0', '$')
284 |     bindings['_name'] = classname
285 | 
286 |     cls = PHPClass(typename, tuple(bases), bindings)
287 | 
288 |     cls.__qualname__ = modules.basename(cls.__name__)
289 | 
290 |     bridge.classes[unresolved_classname] = cls
291 |     bridge.classes[classname] = cls
292 | 
293 |     # Only now do we attach signatures, because the signatures may contain the
294 |     # class we just registered
295 |     for name, func in created_methods.items():
296 |         method_info = methods[name]
297 |         if method_info['static']:
298 |             # classmethod
299 |             func = func.__func__  # type: ignore
300 |         signature = make_signature(bridge, method_info, add_first='self')
301 |         func.__signature__ = signature  # type: ignore
302 | 
303 |         if method_info['isConstructor']:
304 |             cls.__new__.__signature__ = make_signature(  # type: ignore
305 |                 bridge, method_info, add_first='cls')
306 | 
307 | 
308 | class PHPResource:
309 |     """A representation of a remote resource value.
310 | 
311 |     Not technically an object, but similar in a lot of ways. Resources have a
312 |     type (represented by a string) and an identifier used for reference
313 |     counting.
314 |     """
315 |     def __init__(self, bridge: 'PHPBridge', type_: str, id_: int) -> None:
316 |         # Leading underscores are not necessary here but nice for consistency
317 |         self._bridge = bridge
318 |         self._type = type_
319 |         self._id = id_
320 | 
321 |     def __repr__(self) -> str:
322 |         """Mimics print_r output for resources, but more informative."""
323 |         return "<PHP {} resource id #{}>".format(self._type, self._id)
324 | 
325 | 
326 | php_types = {
327 |     'int': int,
328 |     'integer': int,
329 |     'bool': bool,
330 |     'boolean': bool,
331 |     'array': dict,
332 |     'float': float,
333 |     'double': float,
334 |     'string': str,
335 |     'void': None,
336 |     'NULL': None,
337 |     'null': None,
338 |     'callable': Callable,
339 |     'true': True,
340 |     'false': False,
341 |     'mixed': Any,
342 |     'object': PHPObject,
343 |     'resource': PHPResource
344 | }
345 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/CommandServer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace blyxxyz\PythonServer;
  5 | 
  6 | /**
  7 |  * Process commands from another process
  8 |  *
  9 |  * This class allows another process to communicate with PHP and run PHP code.
 10 |  * It receives commands, executes them, and returns the result. The exact
 11 |  * method of communication should be defined in inheriting classes, but it's
 12 |  * assumed to use JSON or some other format that maps to arrays, strings and
 13 |  * numbers.
 14 |  */
 15 | abstract class CommandServer
 16 | {
 17 |     /** @var ObjectStore */
 18 |     private $objectStore;
 19 | 
 20 |     public function __construct()
 21 |     {
 22 |         $this->objectStore = new ObjectStore();
 23 |     }
 24 | 
 25 |     /**
 26 |      * Receive a command from the other side of the bridge.
 27 |      *
 28 |      * Waits for a command. If one is received, returns it. If the other side
 29 |      * is closed, return false.
 30 |      *
 31 |      * @psalm-suppress MismatchingDocblockReturnType
 32 |      * @return array{cmd: string, data: mixed, garbage: array}|false
 33 |      */
 34 |     abstract public function receive(): array;
 35 | 
 36 |     /**
 37 |      * Send a response to the other side of the bridge.
 38 |      *
 39 |      * @param array $data
 40 |      *
 41 |      * @return void
 42 |      */
 43 |     abstract public function send(array $data);
 44 | 
 45 |     /**
 46 |      * Encode a value into something JSON-serializable.
 47 |      *
 48 |      * @param mixed $data
 49 |      *
 50 |      * @return array{type: string, value: mixed}
 51 |      */
 52 |     protected function encode($data): array
 53 |     {
 54 |         if (is_int($data) || is_null($data) || is_bool($data)) {
 55 |             return [
 56 |                 'type' => gettype($data),
 57 |                 'value' => $data
 58 |             ];
 59 |         } elseif (is_string($data)) {
 60 |             if (mb_check_encoding($data)) {
 61 |                 return [
 62 |                     'type' => 'string',
 63 |                     'value' => $data
 64 |                 ];
 65 |             }
 66 |             return [
 67 |                 'type' => 'bytes',
 68 |                 'value' => base64_encode($data)
 69 |             ];
 70 |         } elseif (is_float($data)) {
 71 |             if (is_nan($data) || is_infinite($data)) {
 72 |                 $data = (string)$data;
 73 |             }
 74 |             return [
 75 |                 'type' => 'double',
 76 |                 'value' => $data
 77 |             ];
 78 |         } elseif (is_array($data)) {
 79 |             return [
 80 |                 'type' => 'array',
 81 |                 'value' => array_map([$this, 'encode'], $data)
 82 |             ];
 83 |         } elseif (is_object($data)) {
 84 |             return [
 85 |                 'type' => 'object',
 86 |                 'value' => [
 87 |                     'class' => get_class($data),
 88 |                     'hash' => $this->objectStore->encode($data)
 89 |                 ]
 90 |             ];
 91 |         } elseif (is_resource($data)) {
 92 |             return [
 93 |                 'type' => 'resource',
 94 |                 'value' => [
 95 |                     'type' => get_resource_type($data),
 96 |                     'hash' => $this->objectStore->encode($data)
 97 |                 ]
 98 |             ];
 99 |         } else {
100 |             $type = gettype($data);
101 |             throw new \Exception("Can't encode value of type '$type'");
102 |         }
103 |     }
104 | 
105 |     /**
106 |      * Convert deserialized data into the value it represents, inverts encode.
107 |      *
108 |      * @param array{type: string, value: mixed} $data
109 |      *
110 |      * @return mixed
111 |      */
112 |     protected function decode(array $data)
113 |     {
114 |         $type = $data['type'];
115 |         $value = $data['value'];
116 |         switch ($type) {
117 |             case 'integer':
118 |             case 'string':
119 |             case 'NULL':
120 |             case 'boolean':
121 |                 return $value;
122 |             case 'double':
123 |                 if ($value === 'NAN') {
124 |                     return NAN;
125 |                 } elseif ($value === 'INF') {
126 |                     return INF;
127 |                 } elseif ($value === '-INF') {
128 |                     return -INF;
129 |                 }
130 |                 return $value;
131 |             case 'array':
132 |                 return $this->decodeArray($value);
133 |             case 'object':
134 |             case 'resource':
135 |                 return $this->objectStore->decode($value['hash']);
136 |             case 'bytes':
137 |                 return base64_decode($value);
138 |             default:
139 |                 throw new \Exception("Unknown type '$type'");
140 |         }
141 |     }
142 | 
143 |     /**
144 |      * Decode an array of values.
145 |      *
146 |      * @param array<array> $dataItems
147 |      *
148 |      * @return array
149 |      */
150 |     protected function decodeArray(array $dataItems)
151 |     {
152 |         return array_map([$this, 'decode'], $dataItems);
153 |     }
154 | 
155 |     /**
156 |      * Continually listen for commands.
157 |      *
158 |      * @return void
159 |      */
160 |     public function communicate()
161 |     {
162 |         while (($command = $this->receive()) !== false) {
163 |             $cmd = $command['cmd'];
164 |             $data = $command['data'];
165 |             $garbage = $command['garbage'];
166 |             $collected = [];
167 |             try {
168 |                 foreach ($garbage as $key) {
169 |                     // It might have been removed before, but ObjectStore
170 |                     // doesn't mind
171 |                     $this->objectStore->remove($key);
172 |                     $collected[] = $key;
173 |                 }
174 |                 $response = $this->execute($cmd, $data);
175 |             } catch (\Throwable $exception) {
176 |                 $this->send($this->encodeThrownException(
177 |                     $exception,
178 |                     $collected
179 |                 ));
180 |                 continue;
181 |             }
182 |             $this->send([
183 |                 'type' => 'result',
184 |                 'data' => $response,
185 |                 'collected' => $collected
186 |             ]);
187 |         }
188 |     }
189 | 
190 |     /**
191 |      * Encode an exception into a thrownException response.
192 |      *
193 |      * @param \Throwable $exception
194 |      * @param array<string|int> $collected
195 |      * @return array
196 |      */
197 |     protected function encodeThrownException(
198 |         \Throwable $exception,
199 |         array $collected = []
200 |     ): array {
201 |         return [
202 |             'type' => 'exception',
203 |             'data' => [
204 |                 'value' => $this->encode($exception),
205 |                 'message' => $exception->getMessage()
206 |             ],
207 |             'collected' => $collected
208 |         ];
209 |     }
210 | 
211 |     /**
212 |      * Execute a command and return the (unencoded) result.
213 |      *
214 |      * @param string $command The name of the command
215 |      * @param mixed $data The parameters of the commands
216 |      *
217 |      * @return mixed
218 |      */
219 |     private function execute(string $command, $data)
220 |     {
221 |         switch ($command) {
222 |             case 'getConst':
223 |                 return $this->encode(Commands::getConst($data));
224 |             case 'setConst':
225 |                 return Commands::setConst(
226 |                     $data['name'],
227 |                     $this->decode($data['value'])
228 |                 );
229 |             case 'getGlobal':
230 |                 return $this->encode(Commands::getGlobal($data));
231 |             case 'setGlobal':
232 |                 return Commands::setGlobal(
233 |                     $data['name'],
234 |                     $this->decode($data['value'])
235 |                 );
236 |             case 'callFun':
237 |                 return $this->encode(Commands::callFun(
238 |                     $data['name'],
239 |                     $this->decodeArray($data['args'])
240 |                 ));
241 |             case 'callObj':
242 |                 return $this->encode(Commands::callObj(
243 |                     $this->decode($data['obj']),
244 |                     $this->decodeArray($data['args'])
245 |                 ));
246 |             case 'callMethod':
247 |                 return $this->encode(Commands::callMethod(
248 |                     $this->decode($data['obj']),
249 |                     $data['name'],
250 |                     $this->decodeArray($data['args'])
251 |                 ));
252 |             case 'hasItem':
253 |                 return Commands::hasItem(
254 |                     $this->decode($data['obj']),
255 |                     $this->decode($data['offset'])
256 |                 );
257 |             case 'getItem':
258 |                 return $this->encode(Commands::getItem(
259 |                     $this->decode($data['obj']),
260 |                     $this->decode($data['offset'])
261 |                 ));
262 |             case 'setItem':
263 |                 return Commands::setItem(
264 |                     $this->decode($data['obj']),
265 |                     $this->decode($data['offset']),
266 |                     $this->decode($data['value'])
267 |                 );
268 |             case 'delItem':
269 |                 return Commands::delItem(
270 |                     $this->decode($data['obj']),
271 |                     $this->decode($data['offset'])
272 |                 );
273 |             case 'createObject':
274 |                 return $this->encode(Commands::createObject(
275 |                     $data['name'],
276 |                     $this->decodeArray($data['args'])
277 |                 ));
278 |             case 'getProperty':
279 |                 return $this->encode(Commands::getProperty(
280 |                     $this->decode($data['obj']),
281 |                     $data['name']
282 |                 ));
283 |             case 'setProperty':
284 |                 return Commands::setProperty(
285 |                     $this->decode($data['obj']),
286 |                     $data['name'],
287 |                     $this->decode($data['value'])
288 |                 );
289 |             case 'unsetProperty':
290 |                 return Commands::unsetProperty(
291 |                     $this->decode($data['obj']),
292 |                     $data['name']
293 |                 );
294 |             case 'listNonDefaultProperties':
295 |                 return Commands::listNonDefaultProperties($this->decode($data));
296 |             case 'classInfo':
297 |                 $classInfo =  Commands::classInfo($data);
298 |                 foreach ($classInfo['methods'] as &$method) {
299 |                     foreach ($method['params'] as &$param) {
300 |                         $param['default'] = $this->encode($param['default']);
301 |                     }
302 |                 }
303 |                 return $classInfo;
304 |             case 'funcInfo':
305 |                 $funcInfo = Commands::funcInfo($data);
306 |                 foreach ($funcInfo['params'] as &$param) {
307 |                     $param['default'] = $this->encode($param['default']);
308 |                 }
309 |                 return $funcInfo;
310 |             case 'listConsts':
311 |                 return Commands::listConsts();
312 |             case 'listGlobals':
313 |                 return Commands::listGlobals();
314 |             case 'listFuns':
315 |                 return Commands::listFuns();
316 |             case 'listClasses':
317 |                 return Commands::listClasses();
318 |             case 'listEverything':
319 |                 return iterator_to_array(Commands::listEverything($data));
320 |             case 'listNamespaces':
321 |                 return Commands::listNamespaces($data);
322 |             case 'resolveName':
323 |                 return Commands::resolveName($data);
324 |             case 'repr':
325 |                 return $this->encode(Commands::repr($this->decode($data)));
326 |             case 'str':
327 |                 return $this->encode(Commands::str($this->decode($data)));
328 |             case 'count':
329 |                 return Commands::count($this->decode($data));
330 |             case 'startIteration':
331 |                 return $this->encode(Commands::startIteration(
332 |                     $this->decode($data)
333 |                 ));
334 |             case 'nextIteration':
335 |                 return $this->encode(Commands::nextIteration(
336 |                     $this->decode($data)
337 |                 ));
338 |             case 'throwException':
339 |                 Commands::throwException(
340 |                     $data['class'],
341 |                     $data['message']
342 |                 );
343 |                 return null;
344 |             default:
345 |                 throw new \Exception("Unknown command '$command'");
346 |         }
347 |     }
348 | }
349 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Commands.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /** @noinspection PhpVariableVariableInspection */
  3 | declare(strict_types=1);
  4 | 
  5 | namespace blyxxyz\PythonServer;
  6 | 
  7 | use blyxxyz\PythonServer\Exceptions\AttributeError;
  8 | use blyxxyz\PythonServer\Representer\PythonRepresenter;
  9 | 
 10 | /**
 11 |  * Implements the commands called through the bridge
 12 |  */
 13 | class Commands
 14 | {
 15 |     /**
 16 |      * Get a constant by its name.
 17 |      *
 18 |      * @param string $name
 19 |      *
 20 |      * @return mixed
 21 |      */
 22 |     public static function getConst(string $name)
 23 |     {
 24 |         if (!defined($name)) {
 25 |             throw new \Exception("Constant '$name' is not defined");
 26 |         }
 27 |         return constant($name);
 28 |     }
 29 | 
 30 |     /**
 31 |      * Define a constant.
 32 |      *
 33 |      * @param string $name
 34 |      * @param mixed $value
 35 |      *
 36 |      * @return null
 37 |      */
 38 |     public static function setConst(string $name, $value)
 39 |     {
 40 |         define($name, $value);
 41 |         return null;
 42 |     }
 43 | 
 44 |     /**
 45 |      * Get a global variable.
 46 |      *
 47 |      * @param string $name
 48 |      *
 49 |      * @return mixed
 50 |      */
 51 |     public static function getGlobal(string $name)
 52 |     {
 53 |         if (!array_key_exists($name, $GLOBALS)) {
 54 |             throw new \Exception("Global variable '$name' does not exist");
 55 |         }
 56 |         if ($name === 'GLOBALS') {
 57 |             // This doesn't work:
 58 |             // $value = $GLOBALS['GLOBALS'];
 59 |             // $value['GLOBALS'] = null;
 60 |             // It turns $GLOBALS into null. So we do it like this.
 61 |             $result = [];
 62 |             foreach ($GLOBALS as $key => $value) {
 63 |                 if ($key !== 'GLOBALS') {
 64 |                     $result[$key] = $value;
 65 |                 }
 66 |             }
 67 |             return $result;
 68 |         }
 69 |         return $GLOBALS[$name];
 70 |     }
 71 | 
 72 |     /**
 73 |      * Set a global variable.
 74 |      *
 75 |      * @param string $name
 76 |      * @param mixed $value
 77 |      *
 78 |      * @return null
 79 |      */
 80 |     public static function setGlobal(string $name, $value)
 81 |     {
 82 |         $GLOBALS[$name] = $value;
 83 |         return null;
 84 |     }
 85 | 
 86 |     /**
 87 |      * Call a function.
 88 |      *
 89 |      * @param string $name
 90 |      * @param array $args
 91 |      *
 92 |      * @return mixed
 93 |      */
 94 |     public static function callFun(string $name, array $args)
 95 |     {
 96 |         if (is_callable($name)) {
 97 |             return $name(...$args);
 98 |         } elseif (method_exists(NonFunctionProxy::class, $name)) {
 99 |             return NonFunctionProxy::$name(...$args);
100 |         }
101 |         throw new \Exception("Could not resolve function '$name'");
102 |     }
103 | 
104 |     /**
105 |      * Call an object.
106 |      *
107 |      * @param callable $obj
108 |      * @param array $args
109 |      *
110 |      * @return mixed
111 |      */
112 |     public static function callObj($obj, array $args)
113 |     {
114 |         return $obj(...$args);
115 |     }
116 | 
117 |     /**
118 |      * Call an object or class method.
119 |      *
120 |      * @param object|string $obj
121 |      * @param string $name
122 |      * @param array $args
123 |      *
124 |      * @return mixed
125 |      */
126 |     public static function callMethod($obj, string $name, array $args)
127 |     {
128 |         $method = [$obj, $name];
129 |         return $method(...$args);
130 |     }
131 | 
132 |     /**
133 |      * Instantiate an object.
134 |      *
135 |      * @param string $name
136 |      * @param array $args
137 |      *
138 |      * @return object
139 |      */
140 |     public static function createObject(string $name, array $args)
141 |     {
142 |         return new $name(...$args);
143 |     }
144 | 
145 |     /**
146 |      * Check whether an offset exists.
147 |      *
148 |      * @param \ArrayAccess $obj
149 |      * @param mixed $offset
150 |      *
151 |      * @return bool
152 |      */
153 |     public static function hasItem($obj, $offset): bool
154 |     {
155 |         return isset($obj[$offset]);
156 |     }
157 | 
158 |     /**
159 |      * Get the value at an offset.
160 |      *
161 |      * @param \ArrayAccess $obj
162 |      * @param mixed $offset
163 |      *
164 |      * @return mixed
165 |      */
166 |     public static function getItem($obj, $offset)
167 |     {
168 |         return $obj[$offset];
169 |     }
170 | 
171 |     /**
172 |      * Set the value at an offset.
173 |      *
174 |      * @param \ArrayAccess $obj
175 |      * @param mixed $offset
176 |      * @param mixed $value
177 |      *
178 |      * @return null
179 |      */
180 |     public static function setItem($obj, $offset, $value)
181 |     {
182 |         $obj[$offset] = $value;
183 |         return null;
184 |     }
185 | 
186 |     /**
187 |      * Remove the value at an offset.
188 |      *
189 |      * @param \ArrayAccess $obj
190 |      * @param mixed $offset
191 |      *
192 |      * @return null
193 |      */
194 |     public static function delItem($obj, $offset)
195 |     {
196 |         unset($obj[$offset]);
197 |         return null;
198 |     }
199 | 
200 |     /**
201 |      * Get an object property.
202 |      *
203 |      * @param object $obj
204 |      * @param string $name
205 |      *
206 |      * @return mixed
207 |      */
208 |     public static function getProperty($obj, string $name)
209 |     {
210 |         if (property_exists($obj, $name)) {
211 |             return $obj->$name;
212 |         } else {
213 |             $class = get_class($obj);
214 |             throw new AttributeError(
215 |                 "'$class' object has no property '$name'"
216 |             );
217 |         }
218 |     }
219 | 
220 |     /**
221 |      * Set an object property to a value.
222 |      *
223 |      * @param object $obj
224 |      * @param string $name
225 |      * @param mixed $value
226 |      *
227 |      * @return null
228 |      */
229 |     public static function setProperty($obj, $name, $value)
230 |     {
231 |         $obj->$name = $value;
232 |         return null;
233 |     }
234 | 
235 |     /**
236 |      * Unset an object property.
237 |      *
238 |      * @param object $obj
239 |      * @param string $name
240 |      *
241 |      * @return null
242 |      */
243 |     public static function unsetProperty($obj, string $name)
244 |     {
245 |         if (!property_exists($obj, $name)) {
246 |             $class = get_class($obj);
247 |             throw new AttributeError(
248 |                 "'$class' object has no property '$name'"
249 |             );
250 |         }
251 |         unset($obj->$name);
252 |         return null;
253 |     }
254 | 
255 |     /**
256 |      * Get an array of all property names.
257 |      *
258 |      * Doesn't work for all objects. For example, properties set on an
259 |      * ArrayObject don't show up. They don't show up either when the object
260 |      * is cast to an array, so that's probably related.
261 |      *
262 |      * @param object $obj
263 |      *
264 |      * @return array
265 |      */
266 |     public static function listNonDefaultProperties($obj)
267 |     {
268 |         $properties = [];
269 |         foreach ((new \ReflectionObject($obj))->getProperties() as $property) {
270 |             if ($property->isPublic() && !$property->isDefault()) {
271 |                 $properties[] = $property->getName();
272 |             }
273 |         }
274 |         return $properties;
275 |     }
276 | 
277 |     /**
278 |      * Get a summary of a class
279 |      *
280 |      * @param string $class
281 |      *
282 |      * @return array
283 |      */
284 |     public static function classInfo(string $class): array
285 |     {
286 |         $reflectionClass = new \ReflectionClass($class);
287 |         $parent = $reflectionClass->getParentClass();
288 |         if ($parent !== false) {
289 |             $parent = $parent->getName();
290 |         }
291 |         $info = [
292 |             'name' => $reflectionClass->getName(),
293 |             'doc' => $reflectionClass->getDocComment(),
294 |             'consts' => [],
295 |             'methods' => [],
296 |             'properties' => [],
297 |             'interfaces' => $reflectionClass->getInterfaceNames(),
298 |             'traits' => $reflectionClass->getTraitNames(),
299 |             'isAbstract' => $reflectionClass->isAbstract(),
300 |             'isInterface' => $reflectionClass->isInterface(),
301 |             'isTrait' => $reflectionClass->isTrait(),
302 |             'parent' => $parent
303 |         ];
304 | 
305 |         foreach ($reflectionClass->getReflectionConstants() as $constant) {
306 |             if ($constant->isPublic()) {
307 |                 $info['consts'][$constant->getName()] = $constant->getValue();
308 |             }
309 |         }
310 | 
311 |         foreach ($reflectionClass->getMethods() as $method) {
312 |             if ($method->isPublic()) {
313 |                 $info['methods'][$method->getName()] = [
314 |                     'static' => $method->isStatic(),
315 |                     'doc' => $method->getDocComment(),
316 |                     'params' => array_map(
317 |                         [static::class, 'paramInfo'],
318 |                         $method->getParameters()
319 |                     ),
320 |                     'returnType' => static::typeInfo($method->getReturnType()),
321 |                     'owner' => $method->getDeclaringClass()->getName(),
322 |                     'isConstructor' => $method->isConstructor()
323 |                 ];
324 |             }
325 |         }
326 | 
327 |         $defaults = $reflectionClass->getDefaultProperties();
328 |         foreach ($reflectionClass->getProperties() as $property) {
329 |             if ($property->isPublic()) {
330 |                 $name = $property->getName();
331 |                 $info['properties'][$name] = [
332 |                     'default' => array_key_exists($name, $defaults)
333 |                         ? $defaults[$name] : null,
334 |                     'doc' => $property->getDocComment()
335 |                 ];
336 |             }
337 |         }
338 | 
339 |         return $info;
340 |     }
341 | 
342 |     /**
343 |      * Get detailed information about a function.
344 |      *
345 |      * @param string $name
346 |      *
347 |      * @return array
348 |      */
349 |     public static function funcInfo(string $name): array
350 |     {
351 |         if (is_callable($name) && is_string($name)) {
352 |             $function = new \ReflectionFunction($name);
353 |         } elseif (method_exists(NonFunctionProxy::class, $name)) {
354 |             $function = (new \ReflectionClass(NonFunctionProxy::class))
355 |                 ->getMethod($name);
356 |         } else {
357 |             throw new \Exception("Could not resolve function '$name'");
358 |         }
359 |         return [
360 |             'name' => $function->getName(),
361 |             'doc' => $function->getDocComment(),
362 |             'params' => array_map(
363 |                 [static::class, 'paramInfo'],
364 |                 $function->getParameters()
365 |             ),
366 |             'returnType' => static::typeInfo($function->getReturnType())
367 |         ];
368 |     }
369 | 
370 |     /**
371 |      * Serialize information about a function parameter.
372 |      *
373 |      * @param \ReflectionParameter $parameter
374 |      *
375 |      * @return array
376 |      */
377 |     private static function paramInfo(\ReflectionParameter $parameter): array
378 |     {
379 |         $hasDefault = $parameter->isDefaultValueAvailable();
380 |         return [
381 |             'name' => $parameter->getName(),
382 |             'type' => static::typeInfo($parameter->getType()),
383 |             'hasDefault' => $hasDefault,
384 |             'default' => $hasDefault ? $parameter->getDefaultValue() : null,
385 |             'variadic' => $parameter->isVariadic(),
386 |             'isOptional' => $parameter->isOptional()
387 |         ];
388 |     }
389 | 
390 |     /**
391 |      * Serialize information about a parameter or return type.
392 |      *
393 |      * @param \ReflectionType|null $type
394 |      *
395 |      * @return array|null
396 |      */
397 |     private static function typeInfo(\ReflectionType $type = null)
398 |     {
399 |         if ($type === null) {
400 |             return null;
401 |         }
402 |         return [
403 |             'name' => $type->getName(),
404 |             'isClass' => !$type->isBuiltin(),
405 |             'nullable' => $type->allowsNull(),
406 |         ];
407 |     }
408 | 
409 |     /**
410 |      * Get an array of all defined constant names.
411 |      *
412 |      * @return array
413 |      */
414 |     public static function listConsts(): array
415 |     {
416 |         return array_keys(get_defined_constants());
417 |     }
418 | 
419 |     /**
420 |      * Get an array of all global variable names.
421 |      *
422 |      * @return array
423 |      */
424 |     public static function listGlobals(): array
425 |     {
426 |         return array_keys($GLOBALS);
427 |     }
428 | 
429 |     /**
430 |      * Get an array of names of all defined functions.
431 |      *
432 |      * @return array
433 |      */
434 |     public static function listFuns(): array
435 |     {
436 |         $result = get_class_methods(NonFunctionProxy::class);
437 |         foreach (get_defined_functions() as $functions) {
438 |             $result = array_merge($result, $functions);
439 |         }
440 |         return $result;
441 |     }
442 | 
443 |     /**
444 |      * Get an array of names of all declared classes.
445 |      *
446 |      * @return array
447 |      */
448 |     public static function listClasses(): array
449 |     {
450 |         return array_merge(get_declared_classes(), get_declared_interfaces());
451 |     }
452 | 
453 |     /**
454 |      * List all resolvable names.
455 |      *
456 |      * @param string $namespace
457 |      *
458 |      * @return \Generator
459 |      */
460 |     public static function listEverything(string $namespace = ''): \Generator
461 |     {
462 |         $prefix = $namespace === '' ? '' : "$namespace\\";
463 |         $names = array_merge(
464 |             static::listConsts(),
465 |             static::listFuns(),
466 |             static::listClasses(),
467 |             static::listGlobals()
468 |         );
469 |         if ($prefix === '') {
470 |             yield from $names;
471 |             return;
472 |         }
473 |         foreach ($names as $name) {
474 |             if (substr($name, 0, strlen($prefix)) === $prefix) {
475 |                 yield substr($name, strlen($prefix));
476 |             }
477 |         }
478 |     }
479 | 
480 |     /**
481 |      * List all known (sub)namespaces.
482 |      *
483 |      * @param string $namespace
484 |      *
485 |      * @return array
486 |      */
487 |     public static function listNamespaces(string $namespace = ''): array
488 |     {
489 |         // We'll use this as a set by only using the keys
490 |         $namespaces = [];
491 |         foreach (static::listEverything($namespace) as $name) {
492 |             if (strpos($name, '\\') !== false) {
493 |                 $namespaces[explode('\\', $name)[0]] = null;
494 |             }
495 |         }
496 |         return array_keys($namespaces);
497 |     }
498 | 
499 |     /**
500 |      * Try to guess what a name represents.
501 |      *
502 |      * @param string $name
503 |      *
504 |      * @return string
505 |      */
506 |     public static function resolveName(string $name): string
507 |     {
508 |         if (defined($name)) {
509 |             return 'const';
510 |         } elseif (function_exists($name) ||
511 |             method_exists(NonFunctionProxy::class, $name)) {
512 |             return 'func';
513 |         } elseif (class_exists($name) || interface_exists($name) ||
514 |             trait_exists($name)) {
515 |             return 'class';
516 |         } elseif (array_key_exists($name, $GLOBALS)) {
517 |             return 'global';
518 |         } else {
519 |             return 'none';
520 |         }
521 |     }
522 | 
523 |     /**
524 |      * Build a string representation for Python reprs using Representer.
525 |      *
526 |      * @param mixed $value
527 |      *
528 |      * @return string
529 |      */
530 |     public static function repr($value): string
531 |     {
532 |         return (new PythonRepresenter)->repr($value);
533 |     }
534 | 
535 |     /**
536 |      * Cast a value to a string.
537 |      *
538 |      * @param mixed $value
539 |      *
540 |      * @return string
541 |      */
542 |     public static function str($value): string
543 |     {
544 |         return (string)$value;
545 |     }
546 | 
547 |     /**
548 |      * Get the count/length of an object.
549 |      *
550 |      * @param \Countable $value
551 |      *
552 |      * @return int
553 |      */
554 |     public static function count(\Countable $value): int
555 |     {
556 |         return count($value);
557 |     }
558 | 
559 |     /**
560 |      * Start iterating over something.
561 |      *
562 |      * We deliberately return the Generator object so we can get values out
563 |      * of it in further commands.
564 |      *
565 |      * @param iterable $iterable
566 |      *
567 |      * @return \Generator
568 |      */
569 |     public static function startIteration($iterable): \Generator
570 |     {
571 |         /** @psalm-suppress RedundantConditionGivenDocblockType */
572 |         if (!(is_array($iterable) || $iterable instanceof \Traversable)) {
573 |             if (is_object($iterable)) {
574 |                 $class = get_class($iterable);
575 |                 throw new \TypeError("'$class' object is not iterable");
576 |             }
577 |             $type = gettype($iterable);
578 |             throw new \TypeError("'$type' value is not iterable");
579 |         }
580 |         foreach ($iterable as $key => $value) {
581 |             yield $key => $value;
582 |         }
583 |     }
584 | 
585 |     /**
586 |      * Get the next key and value from a generator.
587 |      *
588 |      * Returns an array containing a bool indicating whether the generator is
589 |      * still going, the new key, and the new value.
590 |      *
591 |      * @param \Generator $generator
592 |      *
593 |      * @return array
594 |      */
595 |     public static function nextIteration(\Generator $generator): array
596 |     {
597 |         $ret = [$generator->valid(), $generator->key(), $generator->current()];
598 |         $generator->next();
599 |         return $ret;
600 |     }
601 | 
602 |     /**
603 |      * Throw an exception. Used for throwing an error while receiving a command.
604 |      *
605 |      * @param string $class
606 |      * @param string $message
607 |      * @return void
608 |      */
609 |     public static function throwException(string $class, string $message)
610 |     {
611 |         $obj = new $class($message);
612 |         if (!$obj instanceof \Throwable) {
613 |             throw new \RuntimeException(
614 |                 "Can't throw '$class' with message '$message' - " .
615 |                 "not throwable"
616 |             );
617 |         }
618 |         throw $obj;
619 |     }
620 | }
621 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Exceptions/AttributeError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer\Exceptions;
 5 | 
 6 | /**
 7 |  * The equivalent of a Python AttributeError.
 8 |  */
 9 | class AttributeError extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Exceptions/ConnectionLostException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer\Exceptions;
 5 | 
 6 | /**
 7 |  * Thrown when the connection to Python is lost.
 8 |  */
 9 | class ConnectionLostException extends \RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/NonFunctionProxy.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /** @noinspection PhpIncludeInspection */
  3 | declare(strict_types=1);
  4 | 
  5 | namespace blyxxyz\PythonServer;
  6 | 
  7 | /**
  8 |  * Provide function-like language constructs as static methods.
  9 |  *
 10 |  * `isset` and `empty` are not provided because it's impossible for a real
 11 |  * function to check whether its argument is defined.
 12 |  */
 13 | class NonFunctionProxy
 14 | {
 15 |     /**
 16 |      * Output one or more strings.
 17 |      *
 18 |      * @param mixed $arg1
 19 |      * @param mixed ...$rest
 20 |      *
 21 |      * @return void
 22 |      */
 23 |     public static function echo($arg1, ...$rest)
 24 |     {
 25 |         echo $arg1;
 26 |         foreach ($rest as $arg) {
 27 |             echo $arg;
 28 |         }
 29 |     }
 30 | 
 31 |     /**
 32 |      * Output a string.
 33 |      *
 34 |      * @param mixed $arg
 35 |      *
 36 |      * @return int
 37 |      */
 38 |     public static function print($arg): int
 39 |     {
 40 |         return print $arg;
 41 |     }
 42 | 
 43 |     /**
 44 |      * Evaluate a string as PHP code.
 45 |      *
 46 |      * @param string $code
 47 |      *
 48 |      * @return mixed
 49 |      */
 50 |     public static function eval(string $code)
 51 |     {
 52 |         return eval($code);
 53 |     }
 54 | 
 55 |     /**
 56 |      * Output a message and terminate the current script.
 57 |      *
 58 |      * @param mixed $status
 59 |      *
 60 |      * @return void
 61 |      */
 62 |     public static function exit($status = 0)
 63 |     {
 64 |         exit($status);
 65 |     }
 66 | 
 67 |     /**
 68 |      * Output a message and terminate the current script.
 69 |      *
 70 |      * @param mixed $status
 71 |      *
 72 |      * @return void
 73 |      */
 74 |     public static function die($status = 0)
 75 |     {
 76 |         die($status);
 77 |     }
 78 | 
 79 |     /**
 80 |      * Include and evaluate the specified file.
 81 |      *
 82 |      * @param string $file
 83 |      *
 84 |      * @return mixed
 85 |      *
 86 |      * @psalm-suppress UnresolvableInclude
 87 |      */
 88 |     public static function include(string $file)
 89 |     {
 90 |         return include $file;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Include and evaluate the specified file.
 95 |      *
 96 |      * @param string $file
 97 |      *
 98 |      * @return mixed
 99 |      *
100 |      * @psalm-suppress UnresolvableInclude
101 |      */
102 |     public static function require(string $file)
103 |     {
104 |         return require $file;
105 |     }
106 | 
107 |     /**
108 |      * Include and evaluate the specified file, unless included before.
109 |      *
110 |      * @param string $file
111 |      *
112 |      * @return mixed
113 |      *
114 |      * @psalm-suppress UnresolvableInclude
115 |      */
116 |     public static function include_once(string $file)  // phpcs:ignore
117 |     {
118 |         return include_once $file;
119 |     }
120 | 
121 |     /**
122 |      * Include and evaluate the specified file, unless included before.
123 |      *
124 |      * @param string $file
125 |      *
126 |      * @return mixed
127 |      *
128 |      * @psalm-suppress UnresolvableInclude
129 |      */
130 |     public static function require_once(string $file)  // phpcs:ignore
131 |     {
132 |         return require_once $file;
133 |     }
134 | 
135 |     /*
136 |      * Casting uses function calls in Python, so it may make sense to provide
137 |      * hem as functions. These are valid function names, so they could be
138 |      * silently overridden by proper functions. Use with care.
139 |      */
140 | 
141 |     /**
142 |      * Cast a value to an integer.
143 |      *
144 |      * @param mixed $val
145 |      *
146 |      * @return int
147 |      */
148 |     public static function int($val): int
149 |     {
150 |         return (int)$val;
151 |     }
152 | 
153 |     /**
154 |      * Cast a value to a boolean.
155 |      *
156 |      * @param mixed $val
157 |      *
158 |      * @return bool
159 |      */
160 |     public static function bool($val): bool
161 |     {
162 |         return (bool)$val;
163 |     }
164 | 
165 |     /**
166 |      * Cast a value to a float.
167 |      *
168 |      * @param mixed $val
169 |      *
170 |      * @return float
171 |      */
172 |     public static function float($val): float
173 |     {
174 |         return (float)$val;
175 |     }
176 | 
177 |     /**
178 |      * Cast a value to a string.
179 |      *
180 |      * @param mixed $val
181 |      *
182 |      * @return string
183 |      */
184 |     public static function string($val): string
185 |     {
186 |         return (string)$val;
187 |     }
188 | 
189 |     /**
190 |      * Cast a value to an array.
191 |      *
192 |      * @param mixed $val
193 |      *
194 |      * @return array
195 |      */
196 |     public static function array($val): array
197 |     {
198 |         return (array)$val;
199 |     }
200 | 
201 |     /**
202 |      * Cast a value to an object.
203 |      *
204 |      * @param mixed $val
205 |      *
206 |      * @return object
207 |      */
208 |     public static function object($val)
209 |     {
210 |         return (object)$val;
211 |     }
212 | }
213 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/ObjectStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer;
 5 | 
 6 | /**
 7 |  * Stores objects and resources so they can be serialized
 8 |  */
 9 | class ObjectStore
10 | {
11 |     /** @var array<string, object> */
12 |     private $objects;
13 | 
14 |     /** @var array<int, resource> */
15 |     private $resources;
16 | 
17 |     public function __construct()
18 |     {
19 |         $this->objects = [];
20 |         $this->resources = [];
21 |     }
22 | 
23 |     /**
24 |      * @param object|resource $object
25 |      *
26 |      * @return string|int
27 |      */
28 |     public function encode($object)
29 |     {
30 |         if (is_resource($object)) {
31 |             // This uses an implementation detail, but it's the best we have
32 |             $key = intval($object);
33 |             $this->resources[$key] = $object;
34 |         } else {
35 |             $key = spl_object_hash($object);
36 |             $this->objects[$key] = $object;
37 |         }
38 |         return $key;
39 |     }
40 | 
41 |     /**
42 |      * @param string|int $key
43 |      *
44 |      * @return object|resource
45 |      */
46 |     public function decode($key)
47 |     {
48 |         if (is_int($key)) {
49 |             return $this->resources[$key];
50 |         } else {
51 |             return $this->objects[$key];
52 |         }
53 |     }
54 | 
55 |     /**
56 |      * @param string|int $key
57 |      *
58 |      * @return void
59 |      */
60 |     public function remove($key)
61 |     {
62 |         if (is_int($key)) {
63 |             unset($this->resources[$key]);
64 |         } else {
65 |             unset($this->objects[$key]);
66 |         }
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Representer/PythonRepresenter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer\Representer;
 5 | 
 6 | /**
 7 |  * Build a representation that follows Python syntax.
 8 |  */
 9 | class PythonRepresenter extends Representer
10 | {
11 |     /** @var string */
12 |     private $module;
13 | 
14 |     public function __construct(string $module = '')
15 |     {
16 |         $this->module = $module;
17 |     }
18 | 
19 |     const TRUE = 'True';
20 |     const FALSE = 'False';
21 |     const NULL = 'None';
22 | 
23 |     const OBJECT_IDEN = 'PHP object';
24 |     const RESOURCE_IDEN = 'PHP resource';
25 | 
26 |     const SEQ_ARRAY_DELIMS = ['[', ']'];
27 |     const ASSOC_ARRAY_DELIMS = ['{', '}'];
28 |     const KEY_SEP = ': ';
29 |     const ITEM_SEP = ', ';
30 | 
31 |     const NAN = 'nan';
32 |     const INF = 'inf';
33 |     const NEG_INF = '-inf';
34 | 
35 |     // Overriding reprString would be good for correctness but a lot of work
36 | 
37 |     protected function convertClassName(string $name): string
38 |     {
39 |         $repr = str_replace('\\', '.', $name);
40 |         if ($this->module !== '') {
41 |             $repr = $this->module . '.' . $repr;
42 |         }
43 |         return $repr;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Representer/Representer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types=1);
  3 | 
  4 | namespace blyxxyz\PythonServer\Representer;
  5 | 
  6 | /**
  7 |  * Build Pythonish representations of objects.
  8 |  *
  9 |  * This class provides functionality similar to var_dump and friends, but
 10 |  * with a different, more terse style. These aren't to dump on a web page on
 11 |  * special occasions, but to routinely show in an interactive terminal
 12 |  * session to give feedback.
 13 |  *
 14 |  * Loosely following Python's conventions, a representation is either a
 15 |  * string of valid PHP code that evaluates to the same value, or a useful
 16 |  * description surrounded by < and >.
 17 |  */
 18 | class Representer implements RepresenterInterface
 19 | {
 20 |     /**
 21 |      * Shorthand to get a representation without making an object manually.
 22 |      *
 23 |      * @param mixed $thing
 24 |      * @param int $depth
 25 |      * @return string
 26 |      */
 27 |     public static function r($thing, int $depth = 2): string
 28 |     {
 29 |         return (new static)->repr($thing, $depth);
 30 |     }
 31 | 
 32 |     const TRUE = 'true';
 33 |     const FALSE = 'false';
 34 |     const NULL = 'null';
 35 | 
 36 |     /**
 37 |      * Represent any value.
 38 |      *
 39 |      * $depth can be used to specify how many levels deep the representation
 40 |      * may go.
 41 |      *
 42 |      * @param mixed $thing
 43 |      * @param int $depth
 44 |      * @return string
 45 |      */
 46 |     public function repr($thing, int $depth = 2): string
 47 |     {
 48 |         $depth -= 1;
 49 | 
 50 |         switch (gettype($thing)) {
 51 |             case 'resource':
 52 |                 return $this->reprResource($thing, $depth);
 53 |             case 'array':
 54 |                 return $this->reprArray($thing, $depth);
 55 |             case 'boolean':
 56 |                 return $thing ? static::TRUE : static::FALSE;
 57 |             case 'NULL':
 58 |                 return static::NULL;
 59 |             case 'double':
 60 |                 return $this->reprFloat($thing, $depth);
 61 |             case 'string':
 62 |                 return $this->reprString($thing, $depth);
 63 |             case 'object':
 64 |                 return $this->reprObject($thing, $depth);
 65 |             default:
 66 |                 return $this->reprFallback($thing, $depth);
 67 |         }
 68 |     }
 69 | 
 70 |     const RESOURCE_IDEN = 'resource';
 71 | 
 72 |     /**
 73 |      * Represent a resource, including its type.
 74 |      *
 75 |      * @param resource $resource
 76 |      * @param int $depth
 77 |      * @return string
 78 |      */
 79 |     protected function reprResource($resource, int $depth): string
 80 |     {
 81 |         $kind = get_resource_type($resource);
 82 |         $id = intval($resource);
 83 |         return "<$kind " . static::RESOURCE_IDEN . " id #$id>";
 84 |     }
 85 | 
 86 |     const SEQ_ARRAY_DELIMS = ['[', ']'];
 87 |     const ASSOC_ARRAY_DELIMS = ['[', ']'];
 88 |     const KEY_SEP = ' => ';
 89 |     const ITEM_SEP = ', ';
 90 | 
 91 |     /**
 92 |      * Represent an array using modern syntax, up to a certain depth.
 93 |      *
 94 |      * @param array $array
 95 |      * @param int $depth
 96 |      * @return string
 97 |      */
 98 |     protected function reprArray(array $array, int $depth): string
 99 |     {
100 |         if ($array === []) {
101 |             return implode(static::ASSOC_ARRAY_DELIMS);
102 |         }
103 |         $sequential = self::arrayIsSequential($array);
104 |         if ($depth <= 0) {
105 |             $count = count($array);
106 |             if ($sequential) {
107 |                 return implode(
108 |                     "... ($count)",
109 |                     static::ASSOC_ARRAY_DELIMS
110 |                 );
111 |             } else {
112 |                 return implode(
113 |                     "..." . static::KEY_SEP . "($count)",
114 |                     static::SEQ_ARRAY_DELIMS
115 |                 );
116 |             }
117 |         }
118 |         $content = [];
119 |         if (self::arrayIsSequential($array)) {
120 |             foreach ($array as $item) {
121 |                 $content[] = $this->repr($item, $depth);
122 |             }
123 |             return implode(
124 |                 implode(static::ITEM_SEP, $content),
125 |                 static::SEQ_ARRAY_DELIMS
126 |             );
127 |         } else {
128 |             foreach ($array as $key => $item) {
129 |                 $content[] = $this->repr($key, $depth) . static::KEY_SEP
130 |                     . $this->repr($item, $depth);
131 |             }
132 |             return implode(
133 |                 implode(static::ITEM_SEP, $content),
134 |                 static::ASSOC_ARRAY_DELIMS
135 |             );
136 |         }
137 |     }
138 | 
139 |     /**
140 |      * Determine whether an array could have been created without using
141 |      * associative syntax.
142 |      *
143 |      * @param array $array
144 |      * @return bool
145 |      */
146 |     protected static function arrayIsSequential(array $array): bool
147 |     {
148 |         if (count($array) === 0) {
149 |             return true;
150 |         }
151 |         return array_keys($array) === range(0, count($array) - 1);
152 |     }
153 | 
154 |     const NAN = 'NAN';
155 |     const INF = 'INF';
156 |     const NEG_INF = '-INF';
157 | 
158 |     protected function reprFloat(float $thing, int $depth): string
159 |     {
160 |         if (is_nan($thing)) {
161 |             return static::NAN;
162 |         } elseif (is_infinite($thing) && $thing > 0) {
163 |             return static::INF;
164 |         } elseif (is_infinite($thing) && $thing < 0) {
165 |             return static::NEG_INF;
166 |         }
167 |         return $this->reprFallback($thing, $depth);
168 |     }
169 | 
170 |     protected function reprString(string $thing, int $depth): string
171 |     {
172 |         return $this->reprFallback($thing, $depth);
173 |     }
174 | 
175 |     const OBJECT_IDEN = 'object';
176 | 
177 |     /**
178 |      * Represent an object using its properties.
179 |      *
180 |      * @param object $object
181 |      * @param int $depth
182 |      * @return string
183 |      */
184 |     protected function reprObject($object, int $depth): string
185 |     {
186 |         if ($depth <= 0) {
187 |             return $this->opaqueReprObject($object);
188 |         }
189 | 
190 |         $cls = $this->convertClassName(get_class($object));
191 |         $properties = (array)$object;
192 | 
193 |         if (count($properties) === 0) {
194 |             return $this->opaqueReprObject($object);
195 |         }
196 | 
197 |         $propertyReprs = [];
198 |         foreach ($properties as $key => $value) {
199 |             // private properties do something obscene with null bytes
200 |             $keypieces = explode("\0", (string)$key);
201 |             $key = $keypieces[count($keypieces) - 1];
202 |             $propertyReprs[] = "$key=" . $this->repr($value, $depth);
203 |         }
204 |         return "<$cls " . static::OBJECT_IDEN .
205 |             " (" . implode(', ', $propertyReprs) . ")>";
206 |     }
207 | 
208 |     /**
209 |      * Represent an object using only its class and hash.
210 |      *
211 |      * @param object $object
212 |      * @return string
213 |      */
214 |     protected function opaqueReprObject($object): string
215 |     {
216 |         $cls = $this->convertClassName(get_class($object));
217 |         $hash = spl_object_hash($object);
218 |         if (strlen($hash) === 32) {
219 |             // Get the only interesting part
220 |             $hash = substr($hash, 8, 8);
221 |         }
222 |         return "<$cls " . static::OBJECT_IDEN . " 0x$hash>";
223 |     }
224 | 
225 |     /**
226 |      * Convert a class name to the preferred notation.
227 |      *
228 |      * @param string $name
229 |      * @return string
230 |      */
231 |     protected function convertClassName(string $name): string
232 |     {
233 |         return $name;
234 |     }
235 | 
236 |     /**
237 |      * Represent a value if no other handler is available.
238 |      *
239 |      * @param mixed $thing
240 |      * @param int $depth
241 |      *
242 |      * @return string
243 |      */
244 |     protected function reprFallback($thing, int $depth): string
245 |     {
246 |         if (is_null($thing) || is_bool($thing)) {
247 |             return strtolower(var_export($thing, true));
248 |         }
249 | 
250 |         if (is_int($thing) || is_float($thing) || is_string($thing)) {
251 |             return var_export($thing, true);
252 |         }
253 | 
254 |         // We don't know what this is so we won't risk var_export
255 |         $type = gettype($thing);
256 |         return "<$type>";
257 |     }
258 | }
259 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/Representer/RepresenterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer\Representer;
 5 | 
 6 | /**
 7 |  * Create string representations of values.
 8 |  *
 9 |  * See Representer for more information.
10 |  */
11 | interface RepresenterInterface
12 | {
13 |     public static function r($thing, int $depth = 2): string;
14 |     public function repr($thing, int $depth = 2): string;
15 | }
16 | 


--------------------------------------------------------------------------------
/phpbridge/php-server/StdioCommandServer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types=1);
 3 | 
 4 | namespace blyxxyz\PythonServer;
 5 | 
 6 | use blyxxyz\PythonServer\Exceptions\ConnectionLostException;
 7 | 
 8 | /**
 9 |  * A command bridge that uses standard file input and output to communicate.
10 |  *
11 |  * $in and $out will be treated as file paths. PHP's special mock file paths,
12 |  * like php://stdin and php://fd/{file descriptor}, may be used too.
13 |  */
14 | class StdioCommandServer extends CommandServer
15 | {
16 |     /** @var resource */
17 |     private $in;
18 | 
19 |     /** @var resource */
20 |     private $out;
21 | 
22 |     public function __construct(string $in, string $out)
23 |     {
24 |         parent::__construct();
25 |         $this->in = fopen($in, 'r');
26 |         $this->out = fopen($out, 'w');
27 |     }
28 | 
29 |     public function receive(): array
30 |     {
31 |         $line = fgets($this->in);
32 |         if ($line === false) {
33 |             throw new ConnectionLostException("Can't read from input");
34 |         }
35 |         $result = json_decode($line, true);
36 |         if (!is_array($result)) {
37 |             return [
38 |                 'cmd' => 'throwException',
39 |                 'data' => [
40 |                     'class' => \RuntimeException::class,
41 |                     'message' => "Error decoding JSON: " . json_last_error_msg()
42 |                 ]
43 |             ];
44 |         }
45 |         return $result;
46 |     }
47 | 
48 |     public function send(array $data)
49 |     {
50 |         $encoded = json_encode($data, JSON_PRESERVE_ZERO_FRACTION);
51 |         if ($encoded === false) {
52 |             $encoded = json_encode($this->encodeThrownException(
53 |                 new \RuntimeException(json_last_error_msg()),
54 |                 $data['collected']
55 |             ));
56 |         }
57 |         fwrite($this->out, $encoded);
58 |         fwrite($this->out, "\n");
59 |     }
60 | 
61 |     /**
62 |      * Promote warnings to exceptions. This is vital if stderr is used for
63 |      * communication, because anything else written there will then disrupt
64 |      * the connection.
65 |      *
66 |      * @return mixed
67 |      */
68 |     public static function promoteWarnings()
69 |     {
70 |         return set_error_handler(function (int $errno, string $errstr): bool {
71 |             if (error_reporting() !== 0) {
72 |                 throw new \ErrorException($errstr);
73 |             }
74 |             return false;
75 |         });
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/phpbridge/server.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * A stand-alone file to start a bridge without messing with composer.
 5 |  *
 6 |  * $argv[1] and $argv[2] should contain the files to be opened by
 7 |  * StdioCommandserver. A typical invocation might be
 8 |  * php path/to/server.php php://stdin php://stderr.
 9 |  */
10 | 
11 | declare(strict_types=1);
12 | 
13 | if (file_exists(__DIR__ . '/../../../../vendor/autoload.php')) {
14 |     require_once __DIR__ . '/../../../../vendor/autoload.php';
15 | } else {
16 |     // Adapted from the PHP-FIG example autoloader
17 |     spl_autoload_register(function ($class) {
18 |         $prefix = 'blyxxyz\\PythonServer\\';
19 |         $base_dir = __DIR__ . '/php-server/';
20 | 
21 |         $len = strlen($prefix);
22 |         if (strncmp($prefix, $class, $len) !== 0) {
23 |             return;
24 |         }
25 | 
26 |         $relative_class = substr($class, $len);
27 | 
28 |         $file = $base_dir . str_replace('\\', '/', $relative_class) . '.php';
29 | 
30 |         if (file_exists($file)) {
31 |             /** @noinspection PhpIncludeInspection */
32 |             require $file;
33 |         }
34 |     });
35 | }
36 | 
37 | 
38 | $server = new \blyxxyz\PythonServer\StdioCommandServer($argv[1], $argv[2]);
39 | if ($argv[2] === 'php://stderr') {
40 |     // Promoting warnings is a good idea, but unless we're using stderr, it's
41 |     // outside the scope of this package to do it automatically
42 |     $server::promoteWarnings();
43 | }
44 | try {
45 |     $server->communicate();
46 | } catch (\blyxxyz\PythonServer\Exceptions\ConnectionLostException $exception) {
47 | }
48 | 


--------------------------------------------------------------------------------
/phpbridge/utils.py:
--------------------------------------------------------------------------------
 1 | """Stand-alone utility functions."""
 2 | 
 3 | from inspect import Parameter, Signature
 4 | from typing import Any, Dict, Optional, Tuple
 5 | 
 6 | 
 7 | def convert_docblock(doc: Optional[str]) -> Optional[str]:
 8 |     """Strip the comment syntax out of a docblock."""
 9 |     if not isinstance(doc, str):
10 |         return doc
11 |     doc = doc.strip('/*')
12 |     lines = doc.split('\n')
13 |     lines = [line.strip() for line in lines]
14 |     lines = [line[1:] if line.startswith('*') else line
15 |              for line in lines]
16 |     return '\n'.join(lines)
17 | 
18 | 
19 | def parse_args(signature: Signature, orig_args: Tuple,
20 |                orig_kwargs: Dict[str, Any]) -> Tuple:
21 |     """Use a function signature to interpret keyword arguments.
22 | 
23 |     If no keyword arguments are provided, args is always returned unchanged.
24 |     This ensures that it's possible to call a function even if the signature
25 |     is inaccurate. inspect.Signature.bind is similar, but less forgiving.
26 |     """
27 |     if not orig_kwargs:
28 |         return orig_args
29 |     args = list(orig_args)
30 |     kwargs = dict(orig_kwargs)
31 |     parameters = list(signature.parameters.values())
32 |     while kwargs:
33 |         index = len(args)
34 |         if index >= len(parameters):
35 |             key, value = kwargs.popitem()
36 |             raise TypeError("Can't handle keyword argument '{}'".format(key))
37 |         cur_param = parameters[index]
38 |         name = cur_param.name
39 |         default = cur_param.default
40 |         if default is unknown_param_default:
41 |             raise TypeError("Missing value for argument '{}' with "
42 |                             "unknown default".format(name))
43 |         if name in kwargs:
44 |             args.append(kwargs.pop(name))
45 |         else:
46 |             if default == Parameter.empty:
47 |                 raise TypeError("Missing required argument '{}'".format(name))
48 |             args.append(default)
49 |     return tuple(args)
50 | 
51 | 
52 | class _UnknownParameterDefaultValue:
53 |     """Represent optional parameters without known defaults."""
54 |     def __repr__(self) -> str:
55 |         return '?'
56 | 
57 | 
58 | unknown_param_default = _UnknownParameterDefaultValue()
59 | 


--------------------------------------------------------------------------------
/psalm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <psalm
 3 |     totallyTyped="false"
 4 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |     xsi:schemaLocation="/home/ring/software/python-php-bridge/vendor/vimeo/psalm/src/config.xsd"
 6 | >
 7 |     <projectFiles>
 8 |         <directory name="phpbridge/php-server" />
 9 |     </projectFiles>
10 | 
11 |     <issueHandlers>
12 |         <LessSpecificReturnType errorLevel="info" />
13 | 
14 |         <!-- level 3 issues - slightly lazy code writing, but provably low false-negatives -->
15 |         <DeprecatedMethod errorLevel="info" />
16 |         <DeprecatedProperty errorLevel="info" />
17 |         <DeprecatedClass errorLevel="info" />
18 | 
19 |         <MissingClosureReturnType errorLevel="info" />
20 |         <MissingReturnType errorLevel="info" />
21 |         <MissingPropertyType errorLevel="info" />
22 |         <InvalidDocblock errorLevel="info" />
23 |         <MisplacedRequiredParam errorLevel="info" />
24 | 
25 |         <PropertyNotSetInConstructor errorLevel="info" />
26 |         <MissingConstructor errorLevel="info" />
27 |         <MissingClosureParamType errorLevel="info" />
28 |         <MissingParamType errorLevel="info" />
29 | 
30 |         <DocblockTypeContradiction errorLevel="info" />
31 |         <RedundantConditionGivenDocblockType errorLevel="info" />
32 | 
33 |         <UnresolvableInclude errorLevel="info" />
34 | 
35 |         <RawObjectIteration errorLevel="info" />
36 |     </issueHandlers>
37 | </psalm>
38 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | import setuptools
 2 | 
 3 | with open("README.md", 'r') as f:
 4 |     long_description = f.read()
 5 | 
 6 | setuptools.setup(
 7 |     name="phpbridge",
 8 |     version="0.0.3",
 9 |     author="Jan Verbeek",
10 |     author_email="jan.verbeek@posteo.nl",
11 |     description="Import PHP code into Python",
12 |     long_description=long_description,
13 |     long_description_content_type="text/markdown",
14 |     url="https://github.com/blyxxyz/Python-PHP-Bridge",
15 |     packages=setuptools.find_packages(),
16 |     package_data={
17 |         'phpbridge': ['*.php', '*/*.php', '*/*/*.php', '*/*/*/*.php'],
18 |     },
19 |     license="ISC",
20 |     classifiers=[
21 |         "Programming Language :: PHP",
22 |         "Programming Language :: Python :: 3",
23 |         "Programming Language :: Python :: 3",
24 |         "Programming Language :: Python :: 3 :: Only",
25 |         "Programming Language :: Python :: 3.5",
26 |         "License :: OSI Approved :: ISC License (ISCL)",
27 |     ]
28 | )
29 | 


--------------------------------------------------------------------------------